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: " + buf);

}

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

}

void teardownTestInternal() override {

logger->destroy();

}

void asPremium() {

// set this so we think it is the premium

settings->cppcheckCfgProductName = "Cppcheck Premium 0.0.0";

}

void run() override {

TEST_CASE(nooptions);

TEST_CASE(helpshort);

TEST_CASE(helpshortExclusive);

TEST_CASE(helplong);

TEST_CASE(helplongExclusive);

TEST_CASE(version);

TEST_CASE(versionWithCfg);

TEST_CASE(versionExclusive);

TEST_CASE(versionWithInvalidCfg);

TEST_CASE(checkVersionCorrect);

TEST_CASE(checkVersionIncorrect);

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

TEST_CASE(disabledMissingIncludeWithInformation);

TEST_CASE(enabledMissingIncludeWithInformation);

TEST_CASE(enabledMissingIncludeWithInformationReverseOrder);

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

TEST_CASE(fileList);

TEST_CASE(fileListNoFile);

TEST_CASE(fileListStdin);

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

TEST_CASE(outputFormatXml);

TEST_CASE(outputFormatOther);

TEST_CASE(outputFormatImplicitPlist);

TEST_CASE(outputFormatImplicitXml);

TEST_CASE(premiumOptions1);

TEST_CASE(premiumOptions2);

TEST_CASE(premiumOptions3);

TEST_CASE(premiumOptions4);

TEST_CASE(premiumOptions5);

TEST_CASE(premiumOptionsCertCIntPrecision);

TEST_CASE(premiumOptionsLicenseFile);

TEST_CASE(premiumOptionsInvalid1);

TEST_CASE(premiumOptionsInvalid2);

TEST_CASE(premiumSafety);

TEST_CASE(reportProgress1);

TEST_CASE(reportProgress2);

TEST_CASE(reportProgress3);

TEST_CASE(reportProgress4);

TEST_CASE(reportProgress5);

TEST_CASE(stdc99);

TEST_CASE(stdgnu17);

TEST_CASE(stdiso9899_1999);

TEST_CASE(stdcpp11);

TEST_CASE(stdgnupp23);

TEST_CASE(stdunknown1);

TEST_CASE(stdunknown2);

TEST_CASE(stdunknown3);

TEST_CASE(stdoverwrite1);

TEST_CASE(stdoverwrite2);

TEST_CASE(stdoverwrite3);

TEST_CASE(stdoverwrite4);

TEST_CASE(stdmulti1);

TEST_CASE(stdmulti2);

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

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

TEST_CASE(showtimeSummary);

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

TEST_CASE(errorlistWithCfg);

TEST_CASE(errorlistExclusive);

TEST_CASE(errorlistWithInvalidCfg);

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 HAS_THREADING_MODEL_FORK

TEST_CASE(loadAverage);

TEST_CASE(loadAverage2);

TEST_CASE(loadAverageInvalid);

#else

TEST_CASE(loadAverageNotSupported);

#endif

TEST_CASE(maxCtuDepth);

TEST_CASE(maxCtuDepth2);

TEST_CASE(maxCtuDepthLimit);

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

TEST_CASE(addonMissing);

#ifdef HAVE_RULES

TEST_CASE(rule);

TEST_CASE(ruleMissingPattern);

#else

TEST_CASE(ruleNotSupported);

#endif

#ifdef HAVE_RULES

TEST_CASE(ruleFileMulti);

TEST_CASE(ruleFileSingle);

TEST_CASE(ruleFileEmpty);

TEST_CASE(ruleFileMissing);

TEST_CASE(ruleFileInvalid);

TEST_CASE(ruleFileNoRoot);

TEST_CASE(ruleFileEmptyElements1);

TEST_CASE(ruleFileEmptyElements2);

TEST_CASE(ruleFileUnknownElement1);

TEST_CASE(ruleFileUnknownElement2);

TEST_CASE(ruleFileMissingTokenList);

TEST_CASE(ruleFileUnknownTokenList);

TEST_CASE(ruleFileMissingId);

TEST_CASE(ruleFileInvalidSeverity1);

TEST_CASE(ruleFileInvalidSeverity2);

#else

TEST_CASE(ruleFileNotSupported);

#endif

TEST_CASE(signedChar);

TEST_CASE(signedChar2);

TEST_CASE(unsignedChar);

TEST_CASE(unsignedChar2);

TEST_CASE(signedCharUnsignedChar);

TEST_CASE(library);

TEST_CASE(libraryMissing);

TEST_CASE(libraryMultiple);

TEST_CASE(libraryMultipleEmpty);

TEST_CASE(libraryMultipleEmpty2);

TEST_CASE(suppressXml);

TEST_CASE(suppressXmlEmpty);

TEST_CASE(suppressXmlMissing);

TEST_CASE(suppressXmlInvalid);

TEST_CASE(suppressXmlNoRoot);

TEST_CASE(executorDefault);

TEST_CASE(executorAuto);

TEST_CASE(executorAutoNoJobs);

#if defined(HAS_THREADING_MODEL_THREAD)

TEST_CASE(executorThread);

TEST_CASE(executorThreadNoJobs);

#else

TEST_CASE(executorThreadNotSupported);

#endif

#if defined(HAS_THREADING_MODEL_FORK)

TEST_CASE(executorProcess);

TEST_CASE(executorProcessNoJobs);

#else

TEST_CASE(executorProcessNotSupported);

#endif

TEST_CASE(checkLevelDefault);

TEST_CASE(checkLevelNormal);

TEST_CASE(checkLevelExhaustive);

TEST_CASE(checkLevelUnknown);

TEST_CASE(cppHeaderProbe);

TEST_CASE(cppHeaderProbe2);

TEST_CASE(noCppHeaderProbe);

TEST_CASE(noCppHeaderProbe2);

TEST_CASE(debugLookup);

TEST_CASE(debugLookupAll);

TEST_CASE(debugLookupAddon);

TEST_CASE(debugLookupConfig);

TEST_CASE(debugLookupLibrary);

TEST_CASE(debugLookupPlatform);

TEST_CASE(ignorepaths1);

TEST_CASE(ignorepaths2);

TEST_CASE(ignorepaths3);

TEST_CASE(ignorepaths4);

TEST_CASE(ignorefilepaths1);

TEST_CASE(ignorefilepaths2);

TEST_CASE(ignorefilepaths3);

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

TEST_CASE(cppcheckBuildDirMultiple);

TEST_CASE(noCppcheckBuildDir);

TEST_CASE(noCppcheckBuildDir2);

TEST_CASE(invalidCppcheckCfg);

}

void nooptions() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parser->parseFromArgs(1, argv));

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

}

void helpshort() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parser->parseFromArgs(2, argv));

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

}

void helpshortExclusive() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parser->parseFromArgs(3, argv));

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

}

void helplong() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parser->parseFromArgs(2, argv));

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

}

void helplongExclusive() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parser->parseFromArgs(3, argv));

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

}

void version() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parser->parseFromArgs(2, argv));

ASSERT(logger->str().compare(0, 11, "Cppcheck 2.") == 0);

}

void versionWithCfg() {

REDIRECT;

ScopedFile file(Path::join(Path::getPathFromFilename(Path::getCurrentExecutablePath("")), "cppcheck.cfg"),

"{\n"

"\"productName\": \"The Product\""

"}\n");

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parser->parseFromArgs(2, argv));

// TODO: somehow the config is not loaded on some systems

(void)logger->str(); //ASSERT_EQUALS("The Product\n", logger->str()); // TODO: include version?

}

// TODO: test --version with extraVersion

void versionExclusive() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parser->parseFromArgs(3, argv));

ASSERT(logger->str().compare(0, 11, "Cppcheck 2.") == 0);

}

void versionWithInvalidCfg() {

REDIRECT;

ScopedFile file(Path::join(Path::getPathFromFilename(Path::getCurrentExecutablePath("")), "cppcheck.cfg"),

"{\n");

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(2, argv));

ASSERT_EQUALS("cppcheck: error: could not load cppcheck.cfg - not a valid JSON - syntax error at line 2 near: \n", logger->str());

}

void checkVersionCorrect() {

REDIRECT;

const std::string currentVersion = parser->getVersion();

const std::string checkVersion = "--check-version=" + currentVersion;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

}

void checkVersionIncorrect() {

REDIRECT;

const char * const argv[] = {"cppcheck", "--check-version=Cppcheck 2.0", "file.cpp"};

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));

ASSERT_EQUALS("cppcheck: error: --check-version check failed. Aborting.\n", logger->str());

}

void onefile() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(2, argv));

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

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

}

void onepath() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(2, argv));

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

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

}

void optionwithoutfile() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, 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"};

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings->verbose);

}

void verboselong() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings->verbose);

}

void debugSimplified() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings->debugSimplified);

}

void debugwarnings() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings->debugwarnings);

}

void forceshort() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings->force);

}

void forcelong() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings->force);

}

void relativePaths1() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings->relativePaths);

}

void relativePaths2() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings->relativePaths);

}

void relativePaths3() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, 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]);

}

void relativePaths4() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, 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]);

}

void quietshort() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings->quiet);

}

void quietlong() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

ASSERT_EQUALS(true, settings->quiet);

}

void defines_noarg() {

REDIRECT;

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

// Fails since -D has no param

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, 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_ENUM(CmdLineParser::Result::Fail, 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_ENUM(CmdLineParser::Result::Fail, 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"};

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

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

}

void defines2() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));

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

}

void defines3() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));

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

}

void defines4() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

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

}

void enforceLanguage1() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(2, argv));

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

}

void enforceLanguage2() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));

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

}

void enforceLanguage3() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, 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_EQUALS_ENUM(CmdLineParser::Result::Fail, 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"};

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

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

}

void enforceLanguage6() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

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

}

void enforceLanguage7() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, 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_ENUM(CmdLineParser::Result::Fail, 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"};

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));

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

}

void includesslash() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));

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

}

void includesbackslash() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));

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

}

void includesnospace() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

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

}

void includes2() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(6, argv));

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

settings->includePaths.pop_front();

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

}

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_ENUM(CmdLineParser::Result::Success, 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);

}

void includesFileNoFile() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, 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"};

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, 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);

}

void configExcludesFileNoFile() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, 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_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

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

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

}

void enabledStyle() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

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

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

}

void enabledPerformance() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

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

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

}

void enabledPortability() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

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

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

}

void enabledInformation() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

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

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

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

}

void enabledUnusedFunction() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

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

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

}

void enabledMissingInclude() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

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

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

}

void disabledMissingIncludeWithInformation() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));

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

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

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

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

}

void enabledMissingIncludeWithInformation() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));

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

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

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

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

}

void enabledMissingIncludeWithInformationReverseOrder() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));

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

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

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_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

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

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

}

#endif

void enabledMultiple() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));

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

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

}

void enabledInvalid() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, 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_EQUALS_ENUM(CmdLineParser::Result::Fail, 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_EQUALS_ENUM(CmdLineParser::Result::Fail, 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"};

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, 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));