TestCmdlineParser() : TestFixture("TestCmdlineParser")

{}

class CmdLineLoggerTest : public CmdLineLogger

{

public:

CmdLineLoggerTest() = default;

void printMessage(const std::string &message) override

{

printInternal("cppcheck: " + message + '\n');

}

void printError(const std::string &message) override

{

printMessage("error: " + message);

}

void printRaw(const std::string &message) override

{

printInternal(message + '\n');

}

std::string str()

{

std::string s;

std::swap(buf, s);

return s;

}

void destroy()

{

if (!buf.empty())

throw std::runtime_error("unconsumed messages");

}

private:

void printInternal(const std::string &message)

{

buf += message;

}

std::string buf;

};

std::unique_ptr<CmdLineLoggerTest> logger;

std::unique_ptr<Settings> settings;

std::unique_ptr<CmdLineParser> parser;

void prepareTestInternal() override {

logger.reset(new CmdLineLoggerTest());

settings.reset(new Settings());

parser.reset(new CmdLineParser(*logger, *settings, settings->nomsg, settings->nofail));

}

void teardownTestInternal() override {

logger->destroy();

// TODO: verify that the redirect output is empty

}

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

TEST_CASE(relativePaths2);

TEST_CASE(relativePaths3);

TEST_CASE(relativePaths4);

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

TEST_CASE(enforceLanguage2);

TEST_CASE(enforceLanguage3);

TEST_CASE(enforceLanguage4);

TEST_CASE(enforceLanguage5);

TEST_CASE(enforceLanguage6);

TEST_CASE(enforceLanguage7);

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

TEST_CASE(jobsTooBig);

TEST_CASE(maxConfigs);

TEST_CASE(maxConfigsMissingCount);

TEST_CASE(maxConfigsInvalid);

TEST_CASE(maxConfigsTooSmall);

TEST_CASE(reportProgress1);

TEST_CASE(reportProgress2);

TEST_CASE(reportProgress3);

TEST_CASE(reportProgress4);

TEST_CASE(reportProgress5);

TEST_CASE(stdc99);

TEST_CASE(stdcpp11);

TEST_CASE(stdunknown1);

TEST_CASE(stdunknown2);

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

TEST_CASE(plistEmpty);

TEST_CASE(plistDoesNotExist);

TEST_CASE(suppressionsOld);

TEST_CASE(suppressions);

TEST_CASE(suppressionsNoFile1);

TEST_CASE(suppressionsNoFile2);

TEST_CASE(suppressionsNoFile3);

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

TEST_CASE(templateLocationInvalid);

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

TEST_CASE(showtimeFileTotal);

TEST_CASE(showtimeTop5);

TEST_CASE(showtimeTop5File);

TEST_CASE(showtimeTop5Summary);

TEST_CASE(showtimeNone);

TEST_CASE(showtimeEmpty);

TEST_CASE(showtimeInvalid);

TEST_CASE(errorlist1);

TEST_CASE(errorlistverbose1);

TEST_CASE(errorlistverbose2);

TEST_CASE(ignorepathsnopath);

#if defined(USE_WINDOWS_SEH) || defined(USE_UNIX_SIGNAL_HANDLING)

TEST_CASE(exceptionhandling);

TEST_CASE(exceptionhandling2);

TEST_CASE(exceptionhandling3);

TEST_CASE(exceptionhandlingInvalid);

TEST_CASE(exceptionhandlingInvalid2);

#else

TEST_CASE(exceptionhandlingNotSupported);

TEST_CASE(exceptionhandlingNotSupported2);

#endif

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

#else

TEST_CASE(loadAverageNotSupported);

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

TEST_CASE(projectMultiple);

TEST_CASE(projectAndSource);

TEST_CASE(projectEmpty);

TEST_CASE(projectMissing);

TEST_CASE(projectNoPaths);

TEST_CASE(addon);

#ifdef HAVE_RULES

TEST_CASE(rule);

#else

TEST_CASE(ruleNotSupported);

#endif

#ifdef HAVE_RULES

TEST_CASE(ruleFile);

TEST_CASE(ruleFileEmpty);

TEST_CASE(ruleFileMissing);

TEST_CASE(ruleFileInvalid);

#else

TEST_CASE(ruleFileNotSupported);

#endif

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

TEST_CASE(cppcheckBuildDirExistent);

TEST_CASE(cppcheckBuildDirNonExistent);

TEST_CASE(cppcheckBuildDirEmpty);

}

void nooptions() {

REDIRECT;

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

ASSERT(parser->parseFromArgs(1, argv));

ASSERT(startsWith(logger->str(), "Cppcheck - A tool for static C/C++ code analysis"));

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void helpshort() {

REDIRECT;

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

ASSERT(parser->parseFromArgs(2, argv));

ASSERT(startsWith(logger->str(), "Cppcheck - A tool for static C/C++ code analysis"));

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void helplong() {

REDIRECT;

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

ASSERT(parser->parseFromArgs(2, argv));

ASSERT(startsWith(logger->str(), "Cppcheck - A tool for static C/C++ code analysis"));

ASSERT_EQUALS("", GET_REDIRECT_OUTPUT);

}

void showversion() {

REDIRECT;

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

ASSERT(parser->parseFromArgs(2, argv));

ASSERT_EQUALS(true, parser->getShowVersion());

ASSERT_EQUALS("", logger->str()); // version is not actually shown

}

void onefile() {

REDIRECT;

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

ASSERT(parser->parseFromArgs(2, argv));

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

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

ASSERT_EQUALS("", logger->str());

}

void onepath() {

REDIRECT;

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

ASSERT(parser->parseFromArgs(2, argv));

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

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

ASSERT_EQUALS("", logger->str());

}

void optionwithoutfile() {

REDIRECT;

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

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", logger->str());

}

void verboseshort() {

REDIRECT;

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

settings->verbose = false;

ASSERT(parser->parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings->verbose);

ASSERT_EQUALS("", logger->str());

}

void verboselong() {

REDIRECT;

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

settings->verbose = false;

ASSERT(parser->parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings->verbose);

ASSERT_EQUALS("", logger->str());

}

void debugSimplified() {

REDIRECT;

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

settings->debugSimplified = false;

ASSERT(parser->parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings->debugSimplified);

ASSERT_EQUALS("", logger->str());

}

void debugwarnings() {

REDIRECT;

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

settings->debugwarnings = false;

ASSERT(parser->parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings->debugwarnings);

ASSERT_EQUALS("", logger->str());

}

void forceshort() {

REDIRECT;

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

settings->force = false;

ASSERT(parser->parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings->force);

ASSERT_EQUALS("", logger->str());

}

void forcelong() {

REDIRECT;

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

settings->force = false;

ASSERT(parser->parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings->force);

ASSERT_EQUALS("", logger->str());

}

void relativePaths1() {

REDIRECT;

settings->relativePaths = false;

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

ASSERT(parser->parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings->relativePaths);

ASSERT_EQUALS("", logger->str());

}

void relativePaths2() {

REDIRECT;

settings->relativePaths = false;

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

ASSERT(parser->parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings->relativePaths);

ASSERT_EQUALS("", logger->str());

}

void relativePaths3() {

REDIRECT;

settings->relativePaths = false;

settings->basePaths.clear();

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

ASSERT(parser->parseFromArgs(3, argv));

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("", logger->str());

}

void relativePaths4() {

REDIRECT;

settings->relativePaths = false;

settings->basePaths.clear();

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

ASSERT(parser->parseFromArgs(3, argv));

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("", logger->str());

}

void quietshort() {

REDIRECT;

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

settings->quiet = false;

ASSERT(parser->parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings->quiet);

ASSERT_EQUALS("", logger->str());

}

void quietlong() {

REDIRECT;

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

settings->quiet = false;

ASSERT(parser->parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings->quiet);

ASSERT_EQUALS("", logger->str());

}

void defines_noarg() {

REDIRECT;

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

// Fails since -D has no param

ASSERT_EQUALS(false, parser->parseFromArgs(2, argv));

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

}

void defines_noarg2() {

REDIRECT;

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

// Fails since -D has no param

ASSERT_EQUALS(false, parser->parseFromArgs(4, argv));

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

}

void defines_noarg3() {

REDIRECT;

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

// Fails since -D has no param

ASSERT_EQUALS(false, parser->parseFromArgs(4, argv));

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

}

void defines() {

REDIRECT;

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

settings->userDefines.clear();

ASSERT(parser->parseFromArgs(3, argv));

ASSERT_EQUALS("_WIN32=1", settings->userDefines);

ASSERT_EQUALS("", logger->str());

}

void defines2() {

REDIRECT;

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

settings->userDefines.clear();

ASSERT(parser->parseFromArgs(4, argv));

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

ASSERT_EQUALS("", logger->str());

}

void defines3() {

REDIRECT;

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

settings->userDefines.clear();

ASSERT(parser->parseFromArgs(4, argv));

ASSERT_EQUALS("DEBUG=1", settings->userDefines);

ASSERT_EQUALS("", logger->str());

}

void defines4() {

REDIRECT;

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

settings->userDefines.clear();

ASSERT(parser->parseFromArgs(3, argv));

ASSERT_EQUALS("DEBUG=", settings->userDefines);

ASSERT_EQUALS("", logger->str());

}

void enforceLanguage1() {

REDIRECT;

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

settings->enforcedLang = Settings::Language::None;

ASSERT(parser->parseFromArgs(2, argv));

ASSERT_EQUALS(Settings::Language::None, settings->enforcedLang);

ASSERT_EQUALS("", logger->str());

}

void enforceLanguage2() {

REDIRECT;

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

settings->enforcedLang = Settings::Language::None;

ASSERT(parser->parseFromArgs(4, argv));

ASSERT_EQUALS(Settings::Language::CPP, settings->enforcedLang);

ASSERT_EQUALS("", logger->str());

}

void enforceLanguage3() {

REDIRECT;

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

ASSERT(!parser->parseFromArgs(2, argv));

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

}

void enforceLanguage4() {

REDIRECT;

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

ASSERT(!parser->parseFromArgs(4, argv));

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

}

void enforceLanguage5() {

REDIRECT;

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

settings->enforcedLang = Settings::Language::None;

ASSERT(parser->parseFromArgs(3, argv));

ASSERT_EQUALS(Settings::Language::CPP, settings->enforcedLang);

ASSERT_EQUALS("", logger->str());

}

void enforceLanguage6() {

REDIRECT;

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

settings->enforcedLang = Settings::Language::None;

ASSERT(parser->parseFromArgs(3, argv));

ASSERT_EQUALS(Settings::Language::C, settings->enforcedLang);

ASSERT_EQUALS("", logger->str());

}

void enforceLanguage7() {

REDIRECT;

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

ASSERT(!parser->parseFromArgs(3, argv));

ASSERT_EQUALS("cppcheck: error: unknown language 'unknownLanguage' enforced.\n", logger->str());

}

void includesnopath() {

REDIRECT;

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

// Fails since -I has no param

ASSERT_EQUALS(false, parser->parseFromArgs(2, argv));

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

}

void includes() {

REDIRECT;

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

settings->includePaths.clear();

ASSERT(parser->parseFromArgs(4, argv));

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

ASSERT_EQUALS("", logger->str());

}

void includesslash() {

REDIRECT;

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

settings->includePaths.clear();

ASSERT(parser->parseFromArgs(4, argv));

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

ASSERT_EQUALS("", logger->str());

}

void includesbackslash() {

REDIRECT;

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

settings->includePaths.clear();

ASSERT(parser->parseFromArgs(4, argv));

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

ASSERT_EQUALS("", logger->str());

}

void includesnospace() {

REDIRECT;

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

settings->includePaths.clear();

ASSERT(parser->parseFromArgs(3, argv));

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

ASSERT_EQUALS("", logger->str());

}

void includes2() {

REDIRECT;

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

settings->includePaths.clear();

ASSERT(parser->parseFromArgs(6, argv));

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

settings->includePaths.pop_front();

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

ASSERT_EQUALS("", logger->str());

}

void includesFile() {

REDIRECT;

ScopedFile file("includes.txt",

"path/sub\n"

"path2/sub1\n");

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

ASSERT_EQUALS(true, parser->parseFromArgs(3, argv));

ASSERT_EQUALS(2, settings->includePaths.size());

auto it = settings->includePaths.cbegin();

ASSERT_EQUALS("path/sub/", *it++);

ASSERT_EQUALS("path2/sub1/", *it);

ASSERT_EQUALS("", logger->str());

}

void includesFileNoFile() {

REDIRECT;

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

ASSERT_EQUALS(false, parser->parseFromArgs(3, argv));

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

}

void configExcludesFile() {

REDIRECT;

ScopedFile file("excludes.txt",

"path/sub\n"

"path2/sub1\n");

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

settings->configExcludePaths.clear();

ASSERT_EQUALS(true, parser->parseFromArgs(3, argv));

ASSERT_EQUALS(2, settings->configExcludePaths.size());

auto it = settings->configExcludePaths.cbegin();

ASSERT_EQUALS("path/sub/", *it++);

ASSERT_EQUALS("path2/sub1/", *it);

ASSERT_EQUALS("", logger->str());

}

void configExcludesFileNoFile() {

REDIRECT;

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

ASSERT_EQUALS( false, parser->parseFromArgs(3, argv));

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

}

void enabledAll() {

REDIRECT;

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

ASSERT(parser->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("", logger->str());

}

void enabledStyle() {

REDIRECT;

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

ASSERT(parser->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("", logger->str());

}

void enabledPerformance() {

REDIRECT;

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

ASSERT(parser->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("", logger->str());

}

void enabledPortability() {

REDIRECT;

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

ASSERT(parser->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("", logger->str());

}

void enabledInformation() {

REDIRECT;

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

ASSERT(parser->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", logger->str());

}

void enabledUnusedFunction() {

REDIRECT;

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

ASSERT(parser->parseFromArgs(3, argv));

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

ASSERT_EQUALS("", logger->str());

}

void enabledMissingInclude() {

REDIRECT;

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

ASSERT(parser->parseFromArgs(3, argv));

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

ASSERT_EQUALS("", logger->str());

}

#ifdef CHECK_INTERNAL

void enabledInternal() {

REDIRECT;

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

ASSERT(parser->parseFromArgs(3, argv));

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

ASSERT_EQUALS("", logger->str());

}

#endif

void enabledMultiple() {

REDIRECT;

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

ASSERT(parser->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("", logger->str());

}

void enabledInvalid() {

REDIRECT;

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

ASSERT(!parser->parseFromArgs(3, argv));

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

}

void enabledError() {

REDIRECT;

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

ASSERT(!parser->parseFromArgs(3, argv));

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

}

void enabledEmpty() {

REDIRECT;

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

ASSERT(!parser->parseFromArgs(3, argv));

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

}

void disableAll() {

REDIRECT;

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

settings->severity.clear();

settings->checks.clear();

ASSERT(parser->parseFromArgs(4, 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("", logger->str());

}

void disableMultiple() {

REDIRECT;

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

settings->severity.clear();

settings->checks.clear();

ASSERT(parser->parseFromArgs(5, 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("", logger->str());

}

// 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", "file.cpp"};

settings->severity.clear();

settings->checks.clear();

ASSERT(parser->parseFromArgs(5, 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("", logger->str());

}

void disableInformationPartial() {

REDIRECT;

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

ASSERT(parser->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", logger->str());

}

void disableInformationPartial2() {

REDIRECT;

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

ASSERT(parser->parseFromArgs(4, argv));

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

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

ASSERT_EQUALS("", logger->str());

}

void disableInvalid() {

REDIRECT;

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

ASSERT(!parser->parseFromArgs(3, argv));

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

}

void disableError() {

REDIRECT;

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

ASSERT(!parser->parseFromArgs(3, argv));

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

}

void disableEmpty() {

REDIRECT;

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

ASSERT(!parser->parseFromArgs(3, argv));

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

}

void inconclusive() {

REDIRECT;

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

settings->certainty.clear();

ASSERT(parser->parseFromArgs(3, argv));

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

ASSERT_EQUALS("", logger->str());

}

void errorExitcode() {

REDIRECT;

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

settings->exitCode = 0;

ASSERT(parser->parseFromArgs(3, argv));

ASSERT_EQUALS(5, settings->exitCode);

ASSERT_EQUALS("", logger->str());

}

void errorExitcodeMissing() {

REDIRECT;

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

// Fails since exit code not given

ASSERT_EQUALS(false, parser->parseFromArgs(3, argv));

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

}

void errorExitcodeStr() {

REDIRECT;

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

// Fails since invalid exit code

ASSERT_EQUALS(false, parser->parseFromArgs(3, argv));

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

}

void exitcodeSuppressionsOld() {

REDIRECT;

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

ASSERT_EQUALS(false, parser->parseFromArgs(4, argv));

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

}

void exitcodeSuppressions() {

REDIRECT;

ScopedFile file("suppr.txt",

"uninitvar\n"

"unusedFunction\n");

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

ASSERT_EQUALS(true, parser->parseFromArgs(3, argv));

ASSERT_EQUALS(2, settings->nofail.getSuppressions().size());

auto it = settings->nofail.getSuppressions().cbegin();

ASSERT_EQUALS("uninitvar", (it++)->errorId);

ASSERT_EQUALS("unusedFunction", it->errorId);

ASSERT_EQUALS("", logger->str());