TestCmdlineParser() : TestFixture("TestCmdlineParser")

{

#if defined(_WIN64) || defined(_WIN32)

CmdLineParser::SHOW_DEF_PLATFORM_MSG = false;

#endif

}

~TestCmdlineParser() override {

#if defined(_WIN64) || defined(_WIN32)

CmdLineParser::SHOW_DEF_PLATFORM_MSG = true;

#endif

}

Settings settings; // TODO: reset after each test

CmdLineParser defParser{settings, settings.nomsg, settings.nofail}; // TODO: reset after each test

void run() override {

TEST_CASE(nooptions);

TEST_CASE(helpshort);

TEST_CASE(helplong);

TEST_CASE(showversion);

TEST_CASE(onefile);

TEST_CASE(onepath);

TEST_CASE(optionwithoutfile);

TEST_CASE(verboseshort);

TEST_CASE(verboselong);

TEST_CASE(debugSimplified);

TEST_CASE(debugwarnings);

TEST_CASE(forceshort);

TEST_CASE(forcelong);

TEST_CASE(relativePaths);

TEST_CASE(quietshort);

TEST_CASE(quietlong);

TEST_CASE(defines_noarg);

TEST_CASE(defines_noarg2);

TEST_CASE(defines_noarg3);

TEST_CASE(defines);

TEST_CASE(defines2);

TEST_CASE(defines3);

TEST_CASE(defines4);

TEST_CASE(enforceLanguage);

TEST_CASE(includesnopath);

TEST_CASE(includes);

TEST_CASE(includesslash);

TEST_CASE(includesbackslash);

TEST_CASE(includesnospace);

TEST_CASE(includes2);

TEST_CASE(includesFile);

TEST_CASE(includesFileNoFile);

TEST_CASE(configExcludesFile);

TEST_CASE(configExcludesFileNoFile);

TEST_CASE(enabledAll);

TEST_CASE(enabledStyle);

TEST_CASE(enabledPerformance);

TEST_CASE(enabledPortability);

TEST_CASE(enabledInformation);

TEST_CASE(enabledUnusedFunction);

TEST_CASE(enabledMissingInclude);

#ifdef CHECK_INTERNAL

TEST_CASE(enabledInternal);

#endif

TEST_CASE(enabledMultiple);

TEST_CASE(enabledInvalid);

TEST_CASE(enabledError);

TEST_CASE(enabledEmpty);

TEST_CASE(disableAll);

TEST_CASE(disableMultiple);

TEST_CASE(disableStylePartial);

TEST_CASE(disableInformationPartial);

TEST_CASE(disableInformationPartial2);

TEST_CASE(disableInvalid);

TEST_CASE(disableError);

TEST_CASE(disableEmpty);

TEST_CASE(inconclusive);

TEST_CASE(errorExitcode);

TEST_CASE(errorExitcodeMissing);

TEST_CASE(errorExitcodeStr);

TEST_CASE(exitcodeSuppressionsOld);

TEST_CASE(exitcodeSuppressions);

TEST_CASE(exitcodeSuppressionsNoFile);

TEST_CASE(fileList);

TEST_CASE(fileListNoFile);

// TEST_CASE(fileListStdin); // Disabled since hangs the test run

TEST_CASE(fileListInvalid);

TEST_CASE(inlineSuppr);

TEST_CASE(jobs);

TEST_CASE(jobs2);

TEST_CASE(jobsMissingCount);

TEST_CASE(jobsInvalid);

TEST_CASE(jobsTooBig);

TEST_CASE(maxConfigs);

TEST_CASE(maxConfigsMissingCount);

TEST_CASE(maxConfigsInvalid);

TEST_CASE(maxConfigsTooSmall);

TEST_CASE(reportProgressTest); // "Test" suffix to avoid hiding the parent's reportProgress

TEST_CASE(stdc99);

TEST_CASE(stdcpp11);

TEST_CASE(stdunknown);

TEST_CASE(platformWin64);

TEST_CASE(platformWin32A);

TEST_CASE(platformWin32W);

TEST_CASE(platformUnix32);

TEST_CASE(platformUnix32Unsigned);

TEST_CASE(platformUnix64);

TEST_CASE(platformUnix64Unsigned);

TEST_CASE(platformNative);

TEST_CASE(platformUnspecified);

TEST_CASE(platformPlatformFile);

TEST_CASE(platformUnknown);

#if defined(_WIN64) || defined(_WIN32)

TEST_CASE(platformDefault);

TEST_CASE(platformDefault2);

#endif

TEST_CASE(plistEmpty);

TEST_CASE(plistDoesNotExist);

TEST_CASE(suppressionsOld);

TEST_CASE(suppressions);

TEST_CASE(suppressionsNoFile);

TEST_CASE(suppressionSingle);

TEST_CASE(suppressionSingleFile);

TEST_CASE(suppressionTwo);

TEST_CASE(suppressionTwoSeparate);

TEST_CASE(templates);

TEST_CASE(templatesGcc);

TEST_CASE(templatesVs);

TEST_CASE(templatesEdit);

TEST_CASE(templatesCppcheck1);

TEST_CASE(templatesDaca2);

TEST_CASE(templatesSelfcheck);

TEST_CASE(templatesNoPlaceholder);

TEST_CASE(templateFormatInvalid);

TEST_CASE(templateFormatInvalid2);

TEST_CASE(templateFormatEmpty);

TEST_CASE(templateLocationInvalid);

TEST_CASE(templateLocationInvalid2);

TEST_CASE(templateLocationEmpty);

TEST_CASE(xml);

TEST_CASE(xmlver2);

TEST_CASE(xmlver2both);

TEST_CASE(xmlver2both2);

TEST_CASE(xmlverunknown);

TEST_CASE(xmlverinvalid);

TEST_CASE(doc);

TEST_CASE(showtime);

TEST_CASE(errorlist1);

TEST_CASE(errorlistverbose1);

TEST_CASE(errorlistverbose2);

TEST_CASE(ignorepathsnopath);

TEST_CASE(exceptionhandling);

TEST_CASE(exceptionhandling2);

TEST_CASE(exceptionhandling3);

TEST_CASE(exceptionhandlingInvalid);

TEST_CASE(exceptionhandlingInvalid2);

TEST_CASE(clang);

TEST_CASE(clang2);

TEST_CASE(clangInvalid);

TEST_CASE(valueFlowMaxIterations);

TEST_CASE(valueFlowMaxIterations2);

TEST_CASE(valueFlowMaxIterationsInvalid);

TEST_CASE(valueFlowMaxIterationsInvalid2);

TEST_CASE(valueFlowMaxIterationsInvalid3);

TEST_CASE(checksMaxTime);

TEST_CASE(checksMaxTime2);

TEST_CASE(checksMaxTimeInvalid);

#ifdef THREADING_MODEL_FORK

TEST_CASE(loadAverage);

TEST_CASE(loadAverage2);

TEST_CASE(loadAverageInvalid);

#endif

TEST_CASE(maxCtuDepth);

TEST_CASE(maxCtuDepthInvalid);

TEST_CASE(performanceValueflowMaxTime);

TEST_CASE(performanceValueflowMaxTimeInvalid);

TEST_CASE(performanceValueFlowMaxIfCount);

TEST_CASE(performanceValueFlowMaxIfCountInvalid);

TEST_CASE(templateMaxTime);

TEST_CASE(templateMaxTimeInvalid);

TEST_CASE(templateMaxTimeInvalid2);

TEST_CASE(typedefMaxTime);

TEST_CASE(typedefMaxTimeInvalid);

TEST_CASE(typedefMaxTimeInvalid2);

TEST_CASE(templateMaxTime);

TEST_CASE(templateMaxTime);

TEST_CASE(ignorepaths1);

TEST_CASE(ignorepaths2);

TEST_CASE(ignorepaths3);

TEST_CASE(ignorepaths4);

TEST_CASE(ignorefilepaths1);

TEST_CASE(ignorefilepaths2);

TEST_CASE(checkconfig);

TEST_CASE(unknownParam);

TEST_CASE(undefs_noarg);

TEST_CASE(undefs_noarg2);

TEST_CASE(undefs_noarg3);

TEST_CASE(undefs);

TEST_CASE(undefs2);

}

void nooptions() {

REDIRECT;

const char * const argv[] = {"cppcheck"};

CmdLineParser parser(settings, settings.nomsg, settings.nofail);

ASSERT(parser.parseFromArgs(1, argv));

ASSERT_EQUALS(true, parser.getShowHelp());

ASSERT(GET_REDIRECT_OUTPUT.find("Cppcheck - A tool for static C/C++ code analysis") == 0);

}

void helpshort() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-h"};

CmdLineParser parser(settings, settings.nomsg, settings.nofail);

ASSERT(parser.parseFromArgs(2, argv));

ASSERT_EQUALS(true, parser.getShowHelp());

ASSERT(GET_REDIRECT_OUTPUT.find("Cppcheck - A tool for static C/C++ code analysis") == 0);

}

void helplong() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--help"};

CmdLineParser parser(settings, settings.nomsg, settings.nofail);

ASSERT(parser.parseFromArgs(2, argv));

ASSERT_EQUALS(true, parser.getShowHelp());

ASSERT(GET_REDIRECT_OUTPUT.find("Cppcheck - A tool for static C/C++ code analysis") == 0);

}

void showversion() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--version"};

CmdLineParser parser(settings, settings.nomsg, settings.nofail);

ASSERT(parser.parseFromArgs(2, argv));

ASSERT_EQUALS(true, parser.getShowVersion());

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT); // version is not actually shown

}

void onefile() {

REDIRECT;

const char * const argv[] = {"cppcheck", "file.cpp"};

CmdLineParser parser(settings, settings.nomsg, settings.nofail);

ASSERT(parser.parseFromArgs(2, argv));

ASSERT_EQUALS(1, (int)parser.getPathNames().size());

ASSERT_EQUALS("file.cpp", parser.getPathNames().at(0));

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void onepath() {

REDIRECT;

const char * const argv[] = {"cppcheck", "src"};

CmdLineParser parser(settings, settings.nomsg, settings.nofail);

ASSERT(parser.parseFromArgs(2, argv));

ASSERT_EQUALS(1, (int)parser.getPathNames().size());

ASSERT_EQUALS("src", parser.getPathNames().at(0));

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void optionwithoutfile() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-v"};

CmdLineParser parser(settings, settings.nomsg, settings.nofail);

ASSERT_EQUALS(false, parser.parseFromArgs(2, argv));

ASSERT_EQUALS(0, (int)parser.getPathNames().size());

ASSERT_EQUALS("cppcheck: error: no C or C++ source files found.\n", GET_REDIRECT_OUTPUT);

}

void verboseshort() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-v", "file.cpp"};

settings.verbose = false;

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings.verbose);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void verboselong() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--verbose", "file.cpp"};

settings.verbose = false;

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings.verbose);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void debugSimplified() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--debug-simplified", "file.cpp"};

settings.debugSimplified = false;

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings.debugSimplified);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void debugwarnings() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--debug-warnings", "file.cpp"};

settings.debugwarnings = false;

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings.debugwarnings);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void forceshort() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-f", "file.cpp"};

settings.force = false;

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings.force);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void forcelong() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--force", "file.cpp"};

settings.force = false;

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings.force);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void relativePaths() {

REDIRECT;

settings.relativePaths = false;

const char * const argvs[] = {"cppcheck", "-rp", "file.cpp"};

ASSERT(defParser.parseFromArgs(3, argvs));

ASSERT_EQUALS(true, settings.relativePaths);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

CLEAR_REDIRECT_OUTPUT;

settings.relativePaths = false;

const char * const argvl[] = {"cppcheck", "--relative-paths", "file.cpp"};

ASSERT(defParser.parseFromArgs(3, argvl));

ASSERT_EQUALS(true, settings.relativePaths);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

CLEAR_REDIRECT_OUTPUT;

settings.relativePaths = false;

settings.basePaths.clear();

const char * const argvsp[] = {"cppcheck", "-rp=C:/foo;C:\\bar", "file.cpp"};

ASSERT(defParser.parseFromArgs(3, argvsp));

ASSERT_EQUALS(true, settings.relativePaths);

ASSERT_EQUALS(2, settings.basePaths.size());

ASSERT_EQUALS("C:/foo", settings.basePaths[0]);

ASSERT_EQUALS("C:/bar", settings.basePaths[1]);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

CLEAR_REDIRECT_OUTPUT;

settings.relativePaths = false;

settings.basePaths.clear();

const char * const argvlp[] = {"cppcheck", "--relative-paths=C:/foo;C:\\bar", "file.cpp"};

ASSERT(defParser.parseFromArgs(3, argvlp));

ASSERT_EQUALS(true, settings.relativePaths);

ASSERT_EQUALS(2, settings.basePaths.size());

ASSERT_EQUALS("C:/foo", settings.basePaths[0]);

ASSERT_EQUALS("C:/bar", settings.basePaths[1]);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void quietshort() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-q", "file.cpp"};

settings.quiet = false;

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings.quiet);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void quietlong() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--quiet", "file.cpp"};

settings.quiet = false;

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings.quiet);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void defines_noarg() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-D"};

// Fails since -D has no param

ASSERT_EQUALS(false, defParser.parseFromArgs(2, argv));

ASSERT_EQUALS("cppcheck: error: argument to '-D' is missing.\n", GET_REDIRECT_OUTPUT);

}

void defines_noarg2() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-D", "-v", "file.cpp"};

// Fails since -D has no param

ASSERT_EQUALS(false, defParser.parseFromArgs(4, argv));

ASSERT_EQUALS("cppcheck: error: argument to '-D' is missing.\n", GET_REDIRECT_OUTPUT);

}

void defines_noarg3() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-D", "--quiet", "file.cpp"};

// Fails since -D has no param

ASSERT_EQUALS(false, defParser.parseFromArgs(4, argv));

ASSERT_EQUALS("cppcheck: error: argument to '-D' is missing.\n", GET_REDIRECT_OUTPUT);

}

void defines() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-D_WIN32", "file.cpp"};

settings.userDefines.clear();

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT_EQUALS("_WIN32=1", settings.userDefines);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void defines2() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-D_WIN32", "-DNODEBUG", "file.cpp"};

settings.userDefines.clear();

ASSERT(defParser.parseFromArgs(4, argv));

ASSERT_EQUALS("_WIN32=1;NODEBUG=1", settings.userDefines);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void defines3() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-D", "DEBUG", "file.cpp"};

settings.userDefines.clear();

ASSERT(defParser.parseFromArgs(4, argv));

ASSERT_EQUALS("DEBUG=1", settings.userDefines);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void defines4() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-DDEBUG=", "file.cpp"}; // #5137 - defining empty macro

settings.userDefines.clear();

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT_EQUALS("DEBUG=", settings.userDefines);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void enforceLanguage() {

REDIRECT;

{

const char * const argv[] = {"cppcheck", "file.cpp"};

settings.enforcedLang = Settings::Language::None;

ASSERT(defParser.parseFromArgs(2, argv));

ASSERT_EQUALS(Settings::Language::None, settings.enforcedLang);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

CLEAR_REDIRECT_OUTPUT;

{

const char * const argv[] = {"cppcheck", "-x", "c++", "file.cpp"};

settings.enforcedLang = Settings::Language::None;

ASSERT(defParser.parseFromArgs(4, argv));

ASSERT_EQUALS(Settings::Language::CPP, settings.enforcedLang);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

CLEAR_REDIRECT_OUTPUT;

{

const char * const argv[] = {"cppcheck", "-x"};

ASSERT(!defParser.parseFromArgs(2, argv));

ASSERT_EQUALS("cppcheck: error: no language given to '-x' option.\n", GET_REDIRECT_OUTPUT);

}

CLEAR_REDIRECT_OUTPUT;

{

const char * const argv[] = {"cppcheck", "-x", "--inconclusive", "file.cpp"};

ASSERT(!defParser.parseFromArgs(4, argv));

ASSERT_EQUALS("cppcheck: error: no language given to '-x' option.\n", GET_REDIRECT_OUTPUT);

}

CLEAR_REDIRECT_OUTPUT;

{

const char * const argv[] = {"cppcheck", "--language=c++", "file.cpp"};

settings.enforcedLang = Settings::Language::None;

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT_EQUALS(Settings::Language::CPP, settings.enforcedLang);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

CLEAR_REDIRECT_OUTPUT;

{

const char * const argv[] = {"cppcheck", "--language=c", "file.cpp"};

settings.enforcedLang = Settings::Language::None;

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT_EQUALS(Settings::Language::C, settings.enforcedLang);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

CLEAR_REDIRECT_OUTPUT;

{

const char * const argv[] = {"cppcheck", "--language=unknownLanguage", "file.cpp"};

ASSERT(!defParser.parseFromArgs(3, argv));

ASSERT_EQUALS("cppcheck: error: unknown language 'unknownLanguage' enforced.\n", GET_REDIRECT_OUTPUT);

}

}

void includesnopath() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-I"};

// Fails since -I has no param

ASSERT_EQUALS(false, defParser.parseFromArgs(2, argv));

ASSERT_EQUALS("cppcheck: error: argument to '-I' is missing.\n", GET_REDIRECT_OUTPUT);

}

void includes() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-I", "include", "file.cpp"};

settings.includePaths.clear();

ASSERT(defParser.parseFromArgs(4, argv));

ASSERT_EQUALS("include/", settings.includePaths.front());

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void includesslash() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-I", "include/", "file.cpp"};

settings.includePaths.clear();

ASSERT(defParser.parseFromArgs(4, argv));

ASSERT_EQUALS("include/", settings.includePaths.front());

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void includesbackslash() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-I", "include\\", "file.cpp"};

settings.includePaths.clear();

ASSERT(defParser.parseFromArgs(4, argv));

ASSERT_EQUALS("include/", settings.includePaths.front());

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void includesnospace() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-Iinclude", "file.cpp"};

settings.includePaths.clear();

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT_EQUALS("include/", settings.includePaths.front());

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void includes2() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-I", "include/", "-I", "framework/", "file.cpp"};

settings.includePaths.clear();

ASSERT(defParser.parseFromArgs(6, argv));

ASSERT_EQUALS("include/", settings.includePaths.front());

settings.includePaths.pop_front();

ASSERT_EQUALS("framework/", settings.includePaths.front());

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

// TODO: fails since the file is not found

void includesFile() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--includes-file=fileThatDoesNotExist.txt", "file.cpp"};

TODO_ASSERT_EQUALS(true, false, defParser.parseFromArgs(3, argv));

TODO_ASSERT_EQUALS("", "cppcheck: error: unable to open includes file at 'fileThatDoesNotExist.txt'\n", GET_REDIRECT_OUTPUT);

}

void includesFileNoFile() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--includes-file=fileThatDoesNotExist.txt", "file.cpp"};

ASSERT_EQUALS(false, defParser.parseFromArgs(3, argv));

ASSERT_EQUALS("cppcheck: error: unable to open includes file at 'fileThatDoesNotExist.txt'\n", GET_REDIRECT_OUTPUT);

}

// TODO: fails since the file is not found

void configExcludesFile() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--config-excludes-file=fileThatDoesNotExist.txt", "file.cpp"};

settings.includePaths.clear();

TODO_ASSERT_EQUALS(true, false, defParser.parseFromArgs(3, argv));

// TODO: add checks

TODO_ASSERT_EQUALS("", "cppcheck: error: unable to open config excludes file at 'fileThatDoesNotExist.txt'\n", GET_REDIRECT_OUTPUT);

}

void configExcludesFileNoFile() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--config-excludes-file=fileThatDoesNotExist.txt", "file.cpp"};

ASSERT_EQUALS( false, defParser.parseFromArgs(3, argv));

ASSERT_EQUALS("cppcheck: error: unable to open config excludes file at 'fileThatDoesNotExist.txt'\n", GET_REDIRECT_OUTPUT);

}

void enabledAll() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--enable=all", "file.cpp"};

settings = Settings();

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT(settings.severity.isEnabled(Severity::style));

ASSERT(settings.severity.isEnabled(Severity::warning));

ASSERT(settings.checks.isEnabled(Checks::unusedFunction));

ASSERT(settings.checks.isEnabled(Checks::missingInclude));

ASSERT(!settings.checks.isEnabled(Checks::internalCheck));

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void enabledStyle() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--enable=style", "file.cpp"};

settings = Settings();

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT(settings.severity.isEnabled(Severity::style));

ASSERT(settings.severity.isEnabled(Severity::warning));

ASSERT(settings.severity.isEnabled(Severity::performance));

ASSERT(settings.severity.isEnabled(Severity::portability));

ASSERT(!settings.checks.isEnabled(Checks::unusedFunction));

ASSERT(!settings.checks.isEnabled(Checks::internalCheck));

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void enabledPerformance() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--enable=performance", "file.cpp"};

settings = Settings();

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT(!settings.severity.isEnabled(Severity::style));

ASSERT(!settings.severity.isEnabled(Severity::warning));

ASSERT(settings.severity.isEnabled(Severity::performance));

ASSERT(!settings.severity.isEnabled(Severity::portability));

ASSERT(!settings.checks.isEnabled(Checks::unusedFunction));

ASSERT(!settings.checks.isEnabled(Checks::missingInclude));

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void enabledPortability() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--enable=portability", "file.cpp"};

settings = Settings();

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT(!settings.severity.isEnabled(Severity::style));

ASSERT(!settings.severity.isEnabled(Severity::warning));

ASSERT(!settings.severity.isEnabled(Severity::performance));

ASSERT(settings.severity.isEnabled(Severity::portability));

ASSERT(!settings.checks.isEnabled(Checks::unusedFunction));

ASSERT(!settings.checks.isEnabled(Checks::missingInclude));

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void enabledInformation() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--enable=information", "file.cpp"};

settings = Settings();

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT(settings.severity.isEnabled(Severity::information));

ASSERT(settings.checks.isEnabled(Checks::missingInclude));

ASSERT_EQUALS("cppcheck: '--enable=information' will no longer implicitly enable 'missingInclude' starting with 2.16. Please enable it explicitly if you require it.\n", GET_REDIRECT_OUTPUT);

}

void enabledUnusedFunction() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--enable=unusedFunction", "file.cpp"};

settings = Settings();

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT(settings.checks.isEnabled(Checks::unusedFunction));

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void enabledMissingInclude() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--enable=missingInclude", "file.cpp"};

settings = Settings();

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT(settings.checks.isEnabled(Checks::missingInclude));

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

#ifdef CHECK_INTERNAL

void enabledInternal() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--enable=internal", "file.cpp"};

settings = Settings();

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT(settings.checks.isEnabled(Checks::internalCheck));

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

#endif

void enabledMultiple() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--enable=missingInclude,portability,warning", "file.cpp"};

settings = Settings();

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT(!settings.severity.isEnabled(Severity::style));

ASSERT(settings.severity.isEnabled(Severity::warning));

ASSERT(!settings.severity.isEnabled(Severity::performance));

ASSERT(settings.severity.isEnabled(Severity::portability));

ASSERT(!settings.checks.isEnabled(Checks::unusedFunction));

ASSERT(settings.checks.isEnabled(Checks::missingInclude));

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void enabledInvalid() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--enable=warning,missingIncludeSystem,style", "file.cpp"};

settings = Settings();

ASSERT(!defParser.parseFromArgs(3, argv));

ASSERT_EQUALS("cppcheck: error: --enable parameter with the unknown name 'missingIncludeSystem'\n", GET_REDIRECT_OUTPUT);

}

void enabledError() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--enable=error", "file.cpp"};

settings = Settings();

ASSERT(!defParser.parseFromArgs(3, argv));

ASSERT_EQUALS("cppcheck: error: --enable parameter with the unknown name 'error'\n", GET_REDIRECT_OUTPUT);

}

void enabledEmpty() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--enable=", "file.cpp"};

settings = Settings();

ASSERT(!defParser.parseFromArgs(3, argv));

ASSERT_EQUALS("cppcheck: error: --enable parameter is empty\n", GET_REDIRECT_OUTPUT);

}

void disableAll() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--enable=all", "--disable=all"};

settings.severity.clear();

settings.checks.clear();

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings.severity.isEnabled(Severity::error));

ASSERT_EQUALS(false, settings.severity.isEnabled(Severity::warning));

ASSERT_EQUALS(false, settings.severity.isEnabled(Severity::style));

ASSERT_EQUALS(false, settings.severity.isEnabled(Severity::performance));

ASSERT_EQUALS(false, settings.severity.isEnabled(Severity::portability));

ASSERT_EQUALS(false, settings.severity.isEnabled(Severity::debug));

ASSERT_EQUALS(false, settings.checks.isEnabled(Checks::unusedFunction));

ASSERT_EQUALS(false, settings.checks.isEnabled(Checks::missingInclude));

ASSERT_EQUALS(false, settings.checks.isEnabled(Checks::internalCheck));

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void disableMultiple() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--enable=all", "--disable=style", "--disable=unusedFunction"};

settings.severity.clear();

settings.checks.clear();

ASSERT(defParser.parseFromArgs(4, argv));

ASSERT_EQUALS(true, settings.severity.isEnabled(Severity::error));

ASSERT_EQUALS(true, settings.severity.isEnabled(Severity::warning));

ASSERT_EQUALS(false, settings.severity.isEnabled(Severity::style));

ASSERT_EQUALS(true, settings.severity.isEnabled(Severity::performance));

ASSERT_EQUALS(true, settings.severity.isEnabled(Severity::portability));

ASSERT_EQUALS(true, settings.severity.isEnabled(Severity::debug));

ASSERT_EQUALS(false, settings.checks.isEnabled(Checks::unusedFunction));

ASSERT_EQUALS(true, settings.checks.isEnabled(Checks::missingInclude));

ASSERT_EQUALS(false, settings.checks.isEnabled(Checks::internalCheck));

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

// make sure the implied "style" checks are not added when "--enable=style" is specified

void disableStylePartial() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--enable=style", "--disable=performance", "--enable=unusedFunction"};

settings.severity.clear();

settings.checks.clear();

ASSERT(defParser.parseFromArgs(4, argv));

ASSERT_EQUALS(true, settings.severity.isEnabled(Severity::error));

ASSERT_EQUALS(true, settings.severity.isEnabled(Severity::warning));

ASSERT_EQUALS(true, settings.severity.isEnabled(Severity::style));

ASSERT_EQUALS(false, settings.severity.isEnabled(Severity::performance));

ASSERT_EQUALS(true, settings.severity.isEnabled(Severity::portability));

ASSERT_EQUALS(false, settings.severity.isEnabled(Severity::debug));

ASSERT_EQUALS(true, settings.checks.isEnabled(Checks::unusedFunction));

ASSERT_EQUALS(false, settings.checks.isEnabled(Checks::missingInclude));

ASSERT_EQUALS(false, settings.checks.isEnabled(Checks::internalCheck));

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void disableInformationPartial() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--enable=information", "--disable=missingInclude", "file.cpp"};

settings = Settings();

ASSERT(defParser.parseFromArgs(4, argv));

ASSERT(settings.severity.isEnabled(Severity::information));

ASSERT(!settings.checks.isEnabled(Checks::missingInclude));

ASSERT_EQUALS("cppcheck: '--enable=information' will no longer implicitly enable 'missingInclude' starting with 2.16. Please enable it explicitly if you require it.\n", GET_REDIRECT_OUTPUT);

}

void disableInformationPartial2() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--enable=missingInclude", "--disable=information", "file.cpp"};

settings = Settings();

ASSERT(defParser.parseFromArgs(4, argv));

ASSERT(!settings.severity.isEnabled(Severity::information));

ASSERT(settings.checks.isEnabled(Checks::missingInclude));

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void disableInvalid() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--disable=leaks", "file.cpp"};

settings = Settings();

ASSERT(!defParser.parseFromArgs(3, argv));

ASSERT_EQUALS("cppcheck: error: --disable parameter with the unknown name 'leaks'\n", GET_REDIRECT_OUTPUT);

}

void disableError() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--disable=error", "file.cpp"};

settings = Settings();

ASSERT(!defParser.parseFromArgs(3, argv));

ASSERT_EQUALS("cppcheck: error: --disable parameter with the unknown name 'error'\n", GET_REDIRECT_OUTPUT);

}

void disableEmpty() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--disable=", "file.cpp"};

settings = Settings();

ASSERT(!defParser.parseFromArgs(3, argv));

ASSERT_EQUALS("cppcheck: error: --disable parameter is empty\n", GET_REDIRECT_OUTPUT);

}

void inconclusive() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--inconclusive"};

settings.certainty.clear();

ASSERT(defParser.parseFromArgs(2, argv));

ASSERT_EQUALS(true, settings.certainty.isEnabled(Certainty::inconclusive));

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void errorExitcode() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--error-exitcode=5", "file.cpp"};

settings.exitCode = 0;

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT_EQUALS(5, settings.exitCode);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void errorExitcodeMissing() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--error-exitcode=", "file.cpp"};

// Fails since exit code not given

ASSERT_EQUALS(false, defParser.parseFromArgs(3, argv));

ASSERT_EQUALS("cppcheck: error: argument to '--error-exitcode=' is not valid - not an integer.\n", GET_REDIRECT_OUTPUT);

}

void errorExitcodeStr() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--error-exitcode=foo", "file.cpp"};

// Fails since invalid exit code

ASSERT_EQUALS(false, defParser.parseFromArgs(3, argv));

ASSERT_EQUALS("cppcheck: error: argument to '--error-exitcode=' is not valid - not an integer.\n", GET_REDIRECT_OUTPUT);

}

void exitcodeSuppressionsOld() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--exitcode-suppressions", "suppr.txt", "file.cpp"};

ASSERT_EQUALS(false, defParser.parseFromArgs(4, argv));

ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--exitcode-suppressions\".\n", GET_REDIRECT_OUTPUT);

}

void exitcodeSuppressions() {

// TODO: Fails since cannot open the file

REDIRECT;

const char * const argv[] = {"cppcheck", "--exitcode-suppressions=suppr.txt", "file.cpp"};

TODO_ASSERT_EQUALS(true, false, defParser.parseFromArgs(3, argv));

TODO_ASSERT_EQUALS("", "cppcheck: error: couldn't open the file: \"suppr.txt\".\n", GET_REDIRECT_OUTPUT);

}

void exitcodeSuppressionsNoFile() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--exitcode-suppressions", "file.cpp"};

ASSERT_EQUALS(false, defParser.parseFromArgs(3, argv));

ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--exitcode-suppressions\".\n", GET_REDIRECT_OUTPUT);

}

// TODO: file does not exist

void fileList() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--file-list=files.txt", "file.cpp"};

TODO_ASSERT_EQUALS(true, false, defParser.parseFromArgs(3, argv));

// TODO: settings are not being reset after each test

//TODO_ASSERT_EQUALS(4, 1, defParser.getPathNames().size());

TODO_ASSERT_EQUALS("", "cppcheck: error: couldn't open the file: \"files.txt\".\n", GET_REDIRECT_OUTPUT);

}

void fileListNoFile() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--file-list=files.txt", "file.cpp"};

ASSERT_EQUALS(false, defParser.parseFromArgs(3, argv));

ASSERT_EQUALS("cppcheck: error: couldn't open the file: \"files.txt\".\n", GET_REDIRECT_OUTPUT);

}

/* void fileListStdin() {

void fileListInvalid() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--file-list", "files.txt", "file.cpp"};

ASSERT_EQUALS(false, defParser.parseFromArgs(4, argv));

ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--file-list\".\n", GET_REDIRECT_OUTPUT);

}

void inlineSuppr() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--inline-suppr", "file.cpp"};

settings.inlineSuppressions = false;

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT(settings.inlineSuppressions);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void jobs() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-j", "3", "file.cpp"};

settings.jobs = 0;

ASSERT(defParser.parseFromArgs(4, argv));

ASSERT_EQUALS(3, settings.jobs);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void jobs2() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-j3", "file.cpp"};

settings.jobs = 0;

ASSERT(defParser.parseFromArgs(3, argv));

ASSERT_EQUALS(3, settings.jobs);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void jobsMissingCount() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-j", "file.cpp"};

// Fails since -j is missing thread count

ASSERT_EQUALS(false, defParser.parseFromArgs(3, argv));

ASSERT_EQUALS("cppcheck: error: argument to '-j' is not valid - not an integer.\n", GET_REDIRECT_OUTPUT);

}

void jobsInvalid() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-j", "e", "file.cpp"};

// Fails since invalid count given for -j

ASSERT_EQUALS(false, defParser.parseFromArgs(4, argv));

ASSERT_EQUALS("cppcheck: error: argument to '-j' is not valid - not an integer.\n", GET_REDIRECT_OUTPUT);

}

void jobsTooBig() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-j10001", "file.cpp"};

ASSERT(!defParser.parseFromArgs(3, argv));

ASSERT_EQUALS("cppcheck: error: argument for '-j' is allowed to be 10000 at max.\n", GET_REDIRECT_OUTPUT);

}

void maxConfigs() {

REDIRECT;

const char * const argv[] = {"cppcheck", "-f", "--max-configs=12", "file.cpp"};

settings.force = false;

settings.maxConfigs = 0;

ASSERT(defParser.parseFromArgs(4, argv));

ASSERT_EQUALS(12, settings.maxConfigs);

ASSERT_EQUALS(false, settings.force);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);