TestCmdlineParser()

: TestFixture("TestCmdlineParser")

, defParser(&settings) {}

Settings settings; // TODO: reset after each test

CmdLineParser defParser; // 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(enabledUnusedFunction);

TEST_CASE(enabledMissingInclude);

#ifdef CHECK_INTERNAL

TEST_CASE(enabledInternal);

#endif

TEST_CASE(enabledMultiple);

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(jobsMissingCount);

TEST_CASE(jobsInvalid);

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(platformUnix64);

TEST_CASE(platformNative);

TEST_CASE(platformUnspecified);

//TEST_CASE(platformPlatformFile);

TEST_CASE(platformUnknown);

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(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);

// TODO

// Disabling these tests since they use relative paths to the

// testrunner executable.

//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);

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);

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);

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);

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);

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);

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);

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 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 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 must be an integer. Try something like '--error-exitcode=1'.\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 must be an integer. Try something like '--error-exitcode=1'.\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 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 a number.\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 a number.\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);

}

void maxConfigsMissingCount() {

REDIRECT;

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

// Fails since --max-configs= is missing limit

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

ASSERT_EQUALS("cppcheck: error: argument to '--max-configs=' is not a number.\n", GET_REDIRECT_OUTPUT);

}

void maxConfigsInvalid() {

REDIRECT;

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

// Fails since invalid count given for --max-configs=

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

ASSERT_EQUALS("cppcheck: error: argument to '--max-configs=' is not a number.\n", GET_REDIRECT_OUTPUT);

}

void maxConfigsTooSmall() {

REDIRECT;

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

// Fails since limit must be greater than 0

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

ASSERT_EQUALS("cppcheck: error: argument to '--max-configs=' must be greater than 0.\n", GET_REDIRECT_OUTPUT);

}

void reportProgressTest() {

REDIRECT;

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

settings.reportProgress = false;

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

ASSERT(settings.reportProgress);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void stdc99() {

REDIRECT;

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

settings.standards.c = Standards::C89;

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

ASSERT(settings.standards.c == Standards::C99);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void stdcpp11() {

REDIRECT;

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

settings.standards.cpp = Standards::CPP03;

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

ASSERT(settings.standards.cpp == Standards::CPP11);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void stdunknown() {

REDIRECT;

{

const char *const argv[] = {"cppcheck", "--std=d++11", "file.cpp"};

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

ASSERT_EQUALS("cppcheck: error: unknown --std value 'd++11'\n", GET_REDIRECT_OUTPUT);

}

CLEAR_REDIRECT_OUTPUT;

{

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

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

TODO_ASSERT_EQUALS("cppcheck: error: unknown --std value 'cplusplus11'\n", "", GET_REDIRECT_OUTPUT);

}

}

void platformWin64() {

REDIRECT;

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

ASSERT(settings.platform(Settings::Unspecified));

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

ASSERT_EQUALS(Settings::Win64, settings.platformType);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void platformWin32A() {

REDIRECT;

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

ASSERT(settings.platform(Settings::Unspecified));

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

ASSERT_EQUALS(Settings::Win32A, settings.platformType);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void platformWin32W() {

REDIRECT;

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

ASSERT(settings.platform(Settings::Unspecified));

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

ASSERT_EQUALS(Settings::Win32W, settings.platformType);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void platformUnix32() {

REDIRECT;

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

ASSERT(settings.platform(Settings::Unspecified));

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

ASSERT_EQUALS(Settings::Unix32, settings.platformType);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void platformUnix64() {

REDIRECT;

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

ASSERT(settings.platform(Settings::Unspecified));

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

ASSERT_EQUALS(Settings::Unix64, settings.platformType);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void platformNative() {

REDIRECT;

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

ASSERT(settings.platform(Settings::Unspecified));

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

ASSERT_EQUALS(Settings::Native, settings.platformType);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void platformUnspecified() {

REDIRECT;

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

ASSERT(settings.platform(Settings::Native));

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

ASSERT_EQUALS(Settings::Unspecified, settings.platformType);

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

/*

void platformUnknown() {

REDIRECT;

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

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

ASSERT_EQUALS("cppcheck: error: unrecognized platform: \"win128\".\n", GET_REDIRECT_OUTPUT);

}

void plistEmpty() {

REDIRECT;

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

settings.plistOutput = "";

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

ASSERT(settings.plistOutput == "./");

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void plistDoesNotExist() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--plist-output=./cppcheck_reports", "file.cpp"};

// Fails since folder pointed by --plist-output= does not exist

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

// TODO: output contains non-native separator

//ASSERT_EQUALS("cppcheck: error: plist folder does not exist: \"cppcheck_reports/\".\n", GET_REDIRECT_OUTPUT);

}

void suppressionsOld() {

REDIRECT;

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

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

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

}

void suppressions() {

// TODO: Fails because there is no suppr.txt file!

REDIRECT;

const char * const argv[] = {"cppcheck", "--suppressions-list=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 suppressionsNoFile() {

REDIRECT;

{

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

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

ASSERT_EQUALS(false, GET_REDIRECT_OUTPUT.find("If you want to pass two files") != std::string::npos);

}

CLEAR_REDIRECT_OUTPUT;

{

const char * const argv[] = {"cppcheck", "--suppressions-list=a.suppr,b.suppr", "file.cpp"};

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

ASSERT_EQUALS(true, GET_REDIRECT_OUTPUT.find("If you want to pass two files") != std::string::npos);

}

CLEAR_REDIRECT_OUTPUT;

{

const char * const argv[] = {"cppcheck", "--suppressions-list=a.suppr b.suppr", "file.cpp"};

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

ASSERT_EQUALS(true, GET_REDIRECT_OUTPUT.find("If you want to pass two files") != std::string::npos);

}

}

static Suppressions::ErrorMessage errorMessage(const std::string &errorId, const std::string &fileName, int lineNumber) {

Suppressions::ErrorMessage e;

e.errorId = errorId;

e.setFileName(fileName);

e.lineNumber = lineNumber;

return e;

}