/*

* Cppcheck - A tool for static C/C++ code analysis

* Copyright (C) 2007-2026 Cppcheck team.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU General Public License as published by

* the Free Software Foundation, either version 3 of the License, or

* (at your option) any later version.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

*/

#include "checkers.h"

#include "cmdlinelogger.h"

#include "cmdlineparser.h"

#include "config.h"

#include "errorlogger.h"

#include "errortypes.h"

#include "filesettings.h"

#include "fixture.h"

#include "helpers.h"

#include "path.h"

#include "platform.h"

#include "redirect.h"

#include "settings.h"

#include "standards.h"

#include "suppressions.h"

#include "timer.h"

#include "utils.h"

#include <cstdio>

#include <list>

#include <memory>

#include <set>

#include <stdexcept>

#include <string>

#include <unordered_set>

#include <vector>

class TestCmdlineParser : public TestFixture {

public:

TestCmdlineParser() : TestFixture("TestCmdlineParser")

{}

private:

class CmdLineLoggerTest final : 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'); // TODO: should not append newline

}

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;

};

class CmdLineParserTest final : public CmdLineParser

{

friend class TestCmdlineParser;

public:

CmdLineParserTest(CmdLineLogger &logger, Settings &settings, Suppressions &suppressions)

: CmdLineParser(logger, settings, suppressions)

{}

};

std::unique_ptr<CmdLineLoggerTest> logger;

std::unique_ptr<Settings> settings;

std::unique_ptr<Suppressions> supprs;

std::unique_ptr<CmdLineParserTest> parser;

void prepareTestInternal() override {

logger.reset(new CmdLineLoggerTest());

settings.reset(new Settings());

supprs.reset(new Suppressions());

parser.reset(new CmdLineParserTest(*logger, *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";

}

template<size_t size>

CmdLineParser::Result parseFromArgs(const char* const (&argv)[size]) {

return parser->parseFromArgs(size, argv);

}

template<size_t size>

bool fillSettingsFromArgs(const char* const (&argv)[size]) {

return parser->fillSettingsFromArgs(size, argv);

}

void run() override {

TEST_CASE(nooptions);

TEST_CASE(nooptionsWithCfg);

TEST_CASE(nooptionsWithInvalidCfg);

TEST_CASE(helpshort);

TEST_CASE(helpshortExclusive);

TEST_CASE(helpshortWithCfg);

TEST_CASE(helplong);

TEST_CASE(helplongExclusive);

TEST_CASE(helplongWithCfg);

TEST_CASE(version);

TEST_CASE(versionWithCfg);

TEST_CASE(versionExclusive);

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

TEST_CASE(fileFilterFileWithDetailsCase);

TEST_CASE(fileFilterStdin);

TEST_CASE(fileFilterPlus);

TEST_CASE(fileFilterNoMatch);

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

TEST_CASE(outputFormatSarif);

TEST_CASE(outputFormatXml);

TEST_CASE(outputFormatXmlv2);

TEST_CASE(outputFormatXmlv3);

TEST_CASE(outputFormatOther);

TEST_CASE(outputFormatImplicitPlist);

TEST_CASE(outputFormatImplicitXml);

TEST_CASE(outputFormatOverridePlist);

TEST_CASE(outputFormatMixed1);

TEST_CASE(outputFormatMixed2);

TEST_CASE(outputFormatMixed3);

TEST_CASE(premiumOptions1);

TEST_CASE(premiumOptions2);

TEST_CASE(premiumOptions3);

TEST_CASE(premiumOptions4);

TEST_CASE(premiumOptions5);

TEST_CASE(premiumOptionsAll);

TEST_CASE(premiumOptionsMetrics);

TEST_CASE(premiumOptionsCertCIntPrecision);

TEST_CASE(premiumOptionsLicenseFile);

TEST_CASE(premiumOptionsInvalid1);

TEST_CASE(premiumOptionsInvalid2);

TEST_CASE(premiumSafety);

TEST_CASE(premiumDebugProgress);

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

TEST_CASE(plistEmpty);

TEST_CASE(plistDoesNotExist);

TEST_CASE(suppressionsOld);

TEST_CASE(suppressions);

TEST_CASE(suppressionsNoFile1);

TEST_CASE(suppressionsNoFile2);

TEST_CASE(suppressionsNoFile3);

TEST_CASE(suppressSingle);

TEST_CASE(suppressSingleFile);

TEST_CASE(suppressTwo);

TEST_CASE(suppressTwoSeparate);

TEST_CASE(exitcodeSuppressSingle);

TEST_CASE(exitcodeSuppressSingleFile);

TEST_CASE(exitcodeSuppressTwo);

TEST_CASE(exitcodeSuppressTwoSeparate);

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

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

TEST_CASE(ruleInvalidPattern);

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

TEST_CASE(ruleFileInvalidPattern);

TEST_CASE(ruleFileInvalidEngine);

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

TEST_CASE(maxTemplateRecursionMissingCount);

TEST_CASE(emitDuplicates);

TEST_CASE(debugClangOutput);

TEST_CASE(debugXmlMultiple);

TEST_CASE(debugNormalXmlMultiple);

TEST_CASE(debugIgnore);

TEST_CASE(checkHeaders);

TEST_CASE(noCheckHeaders);

TEST_CASE(noCheckHeaders2);

TEST_CASE(filesdir);

TEST_CASE(checkUnusedTemplates);

TEST_CASE(noCheckUnusedTemplates);

TEST_CASE(noCheckUnusedTemplates);

TEST_CASE(clangTidy);

TEST_CASE(clangTidyCustom);

TEST_CASE(projectConfigurationNoProject);

TEST_CASE(projectConfigurationEmpty);

TEST_CASE(analyzeAllVsConfigs);

TEST_CASE(noAnalyzeAllVsConfigs);

TEST_CASE(noAnalyzeAllVsConfigs2);

TEST_CASE(debugSymdb);

TEST_CASE(debugAst);

TEST_CASE(debugValueflow);

TEST_CASE(debugNormal);

TEST_CASE(debugNormalVerbose);

TEST_CASE(debug);

TEST_CASE(debugVerbose);

TEST_CASE(safety);

TEST_CASE(safetyOverride);

TEST_CASE(noSafety);

TEST_CASE(noSafetyOverride);

TEST_CASE(debugAnalyzerinfo);

TEST_CASE(ignorepaths1);

TEST_CASE(ignorepaths2);

TEST_CASE(ignorepaths3);

TEST_CASE(ignorepaths4);

TEST_CASE(ignorefilepaths1);

TEST_CASE(ignorefilepaths2);

TEST_CASE(ignorefilepaths3);

TEST_CASE(ignorefilepaths4);

TEST_CASE(ignorefilepaths5);

TEST_CASE(ignorefilepaths6);

TEST_CASE(ignorefilepaths7);

TEST_CASE(ignorefilepaths8);

TEST_CASE(ignorefilepaths9);

TEST_CASE(nonexistentpath);

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

TEST_CASE(reportTypeAutosar);

TEST_CASE(reportTypeCertCpp);

TEST_CASE(reportTypeCertC);

TEST_CASE(reportTypeMisraC2012);

TEST_CASE(reportTypeMisraC2023);

TEST_CASE(reportTypeMisraC2025);

TEST_CASE(reportTypeMisraCpp2008);

TEST_CASE(reportTypeMisraCpp2023);

TEST_CASE(invalidReportType);

TEST_CASE(defaultReportType);

}

void nooptions() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));

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

}

void nooptionsWithCfg() {

REDIRECT;

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

"{\n"

"\"productName\": \"Cppcheck Premium\","

"\"manualUrl\": \"https://docs.notcppcheck.com/manual.pdf\""

"}\n");

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));

ASSERT_EQUALS(1, settings->settingsFiles.size());

ASSERT_EQUALS(file.path(), *settings->settingsFiles.cbegin());

const std::string log_str = logger->str();

ASSERT_MSG(startsWith(log_str, "Cppcheck - A tool for static C/C++ code analysis"), "header");

ASSERT_MSG(log_str.find("https://docs.notcppcheck.com/manual.pdf") != std::string::npos, "help url");

}

void nooptionsWithInvalidCfg() {

REDIRECT;

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

"{\n");

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));

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

}

void helpshort() {

REDIRECT;

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

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

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

}

void helpshortWithCfg() {

REDIRECT;

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

"{\n"

"\"productName\": \"Cppcheck Premium\","

"\"manualUrl\": \"https://docs.notcppcheck.com/manual.pdf\""

"}\n");

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));

ASSERT_EQUALS(1, settings->settingsFiles.size());

ASSERT_EQUALS(file.path(), *settings->settingsFiles.cbegin());

const std::string log_str = logger->str();

ASSERT_MSG(startsWith(log_str, "Cppcheck - A tool for static C/C++ code analysis"), "header");

ASSERT_MSG(log_str.find("https://docs.notcppcheck.com/manual.pdf") != std::string::npos, "help url");

}

void helplong() {

REDIRECT;

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

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

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

}

void helplongWithCfg() {

REDIRECT;

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

"{\n"

"\"productName\": \"Cppcheck Premium\","

"\"manualUrl\": \"https://docs.notcppcheck.com/manual.pdf\""

"}\n");

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));

ASSERT_EQUALS(1, settings->settingsFiles.size());

ASSERT_EQUALS(file.path(), *settings->settingsFiles.cbegin());

const std::string log_str = logger->str();

ASSERT_MSG(startsWith(log_str, "Cppcheck - A tool for static C/C++ code analysis"), "header");

ASSERT_MSG(log_str.find("https://docs.notcppcheck.com/manual.pdf") != std::string::npos, "help url");

}

void version() {

REDIRECT;

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

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

ASSERT_EQUALS(1, settings->settingsFiles.size());

ASSERT_EQUALS(file.path(), *settings->settingsFiles.cbegin());

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, parseFromArgs(argv));

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

}

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, parseFromArgs(argv));

}

void checkVersionIncorrect() {

REDIRECT;

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

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

ASSERT_EQUALS(1, parser->mPathNames.size());

ASSERT_EQUALS("file.cpp", parser->mPathNames[0]);

}

void onepath() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));

ASSERT_EQUALS(1, parser->mPathNames.size());

ASSERT_EQUALS("src", parser->mPathNames[0]);

}

void optionwithoutfile() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));

ASSERT_EQUALS(0, parser->mPathNames.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, parseFromArgs(argv));

ASSERT_EQUALS(true, settings->verbose);

}

void verboselong() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));

ASSERT_EQUALS(true, settings->verbose);

}

void debugSimplified() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));

ASSERT_EQUALS(true, settings->debugSimplified);

}

void debugwarnings() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));

ASSERT_EQUALS(true, settings->debugwarnings);

}

void forceshort() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));

ASSERT_EQUALS(true, settings->force);

}

void forcelong() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));

ASSERT_EQUALS(true, settings->force);

}

void relativePaths1() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));

ASSERT_EQUALS(true, settings->relativePaths);

}

void relativePaths2() {

REDIRECT;

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

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

ASSERT_EQUALS(true, settings->quiet);

}

void quietlong() {

REDIRECT;

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

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

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

}

void enforceLanguage1() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));

ASSERT_EQUALS(Standards::Language::None, parser->mEnforcedLang);

}

void enforceLanguage2() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));

ASSERT_EQUALS(Standards::Language::CPP, parser->mEnforcedLang);

}

void enforceLanguage3() {

REDIRECT;

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

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

ASSERT_EQUALS(Standards::Language::CPP, parser->mEnforcedLang);

}

void enforceLanguage6() {

REDIRECT;

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

ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));

ASSERT_EQUALS(Standards::Language::C, parser->mEnforcedLang);

}

void enforceLanguage7() {

REDIRECT;

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

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

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

}

void includesnospace() {

REDIRECT;

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

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