cppcheck/test/testcmdlineparser.cpp

1051 lines
36 KiB
C++
Raw Normal View History

/*
* Cppcheck - A tool for static C/C++ code analysis
2016-01-01 14:34:45 +01:00
* Copyright (C) 2007-2016 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 "cmdlineparser.h"
2017-05-27 04:33:47 +02:00
#include "platform.h"
#include "redirect.h"
2017-05-27 04:33:47 +02:00
#include "settings.h"
#include "standards.h"
#include "suppressions.h"
#include "testsuite.h"
#include "timer.h"
2017-05-27 04:33:47 +02:00
#include <list>
#include <set>
#include <sstream>
#include <string>
#include <vector>
2011-10-13 20:53:06 +02:00
class TestCmdlineParser : public TestFixture {
public:
TestCmdlineParser()
: TestFixture("TestCmdlineParser")
2014-11-20 14:20:09 +01:00
, defParser(&settings) {
}
private:
Settings settings;
CmdLineParser defParser;
2014-11-20 14:20:09 +01:00
void run() {
TEST_CASE(nooptions);
TEST_CASE(helpshort);
TEST_CASE(helplong);
TEST_CASE(showversion);
2010-09-06 22:16:52 +02:00
TEST_CASE(onefile);
TEST_CASE(onepath);
TEST_CASE(optionwithoutfile);
TEST_CASE(verboseshort);
TEST_CASE(verboselong);
TEST_CASE(debug);
TEST_CASE(debugwarnings);
TEST_CASE(forceshort);
TEST_CASE(forcelong);
TEST_CASE(relativePaths);
2010-09-06 22:16:52 +02:00
TEST_CASE(quietshort);
TEST_CASE(quietlong);
TEST_CASE(defines_noarg);
TEST_CASE(defines_noarg2);
TEST_CASE(defines_noarg3);
TEST_CASE(defines);
TEST_CASE(defines2);
TEST_CASE(defines3);
TEST_CASE(defines4);
TEST_CASE(enforceLanguage);
TEST_CASE(includesnopath);
TEST_CASE(includes);
TEST_CASE(includesslash);
TEST_CASE(includesbackslash);
TEST_CASE(includesnospace);
TEST_CASE(includes2);
TEST_CASE(includesFile);
2010-12-04 13:13:44 +01:00
TEST_CASE(enabledAll);
TEST_CASE(enabledStyle);
TEST_CASE(enabledPerformance);
TEST_CASE(enabledPortability);
2010-12-04 13:13:44 +01:00
TEST_CASE(enabledUnusedFunction);
TEST_CASE(enabledMissingInclude);
#ifdef CHECK_INTERNAL
TEST_CASE(enabledInternal);
#endif
TEST_CASE(enabledMultiple);
TEST_CASE(inconclusive);
2010-12-04 13:13:44 +01:00
TEST_CASE(errorExitcode);
TEST_CASE(errorExitcodeMissing);
TEST_CASE(errorExitcodeStr);
TEST_CASE(exitcodeSuppressionsOld); // TODO: Create and test real suppression file
TEST_CASE(exitcodeSuppressions);
TEST_CASE(exitcodeSuppressionsNoFile);
2010-12-04 13:13:44 +01:00
TEST_CASE(fileList); // TODO: Create and test real file listing file
// TEST_CASE(fileListStdin); // Disabled since hangs the test run
2010-12-04 13:13:44 +01:00
TEST_CASE(inlineSuppr);
TEST_CASE(jobs);
TEST_CASE(jobsMissingCount);
TEST_CASE(jobsInvalid);
TEST_CASE(maxConfigs);
TEST_CASE(maxConfigsMissingCount);
TEST_CASE(maxConfigsInvalid);
TEST_CASE(maxConfigsTooSmall);
TEST_CASE(reportProgressTest); // "Test" suffix to avoid hiding the parent's reportProgress
TEST_CASE(stdposix);
TEST_CASE(stdc99);
TEST_CASE(stdcpp11);
TEST_CASE(platform);
TEST_CASE(suppressionsOld); // TODO: Create and test real suppression file
TEST_CASE(suppressions);
TEST_CASE(suppressionsNoFile);
TEST_CASE(suppressionSingle);
TEST_CASE(suppressionSingleFile);
TEST_CASE(suppressionTwo);
TEST_CASE(suppressionTwoSeparate);
2010-12-04 13:13:44 +01:00
TEST_CASE(templates);
TEST_CASE(templatesGcc);
TEST_CASE(templatesVs);
TEST_CASE(templatesEdit);
2010-12-04 13:13:44 +01:00
TEST_CASE(xml);
TEST_CASE(xmlver1);
TEST_CASE(xmlver2);
TEST_CASE(xmlver2both);
TEST_CASE(xmlver2both2);
TEST_CASE(xmlverunknown);
TEST_CASE(xmlverinvalid);
TEST_CASE(doc);
TEST_CASE(showtime);
TEST_CASE(errorlist1);
TEST_CASE(errorlistverbose1);
TEST_CASE(errorlistverbose2);
TEST_CASE(ignorepathsnopath);
// Disabling these tests since they use relative paths to the
// testrunner executable.
//TEST_CASE(ignorepaths1);
//TEST_CASE(ignorepaths2);
//TEST_CASE(ignorepaths3);
//TEST_CASE(ignorepaths4);
//TEST_CASE(ignorefilepaths1);
//TEST_CASE(ignorefilepaths2);
TEST_CASE(checkconfig);
2010-12-04 13:13:44 +01:00
TEST_CASE(unknownParam);
TEST_CASE(undefs_noarg);
TEST_CASE(undefs_noarg2);
TEST_CASE(undefs_noarg3);
TEST_CASE(undefs);
TEST_CASE(undefs2);
}
2010-12-04 13:13:44 +01:00
2014-11-20 14:20:09 +01:00
void nooptions() {
REDIRECT;
const char *argv[] = {"cppcheck"};
CmdLineParser parser(&settings);
ASSERT(parser.ParseFromArgs(1, argv));
ASSERT_EQUALS(true, parser.GetShowHelp());
}
2014-11-20 14:20:09 +01:00
void helpshort() {
REDIRECT;
const char *argv[] = {"cppcheck", "-h"};
CmdLineParser parser(&settings);
ASSERT(parser.ParseFromArgs(2, argv));
ASSERT_EQUALS(true, parser.GetShowHelp());
}
2014-11-20 14:20:09 +01:00
void helplong() {
REDIRECT;
const char *argv[] = {"cppcheck", "--help"};
CmdLineParser parser(&settings);
ASSERT(parser.ParseFromArgs(2, argv));
ASSERT_EQUALS(true, parser.GetShowHelp());
}
2014-11-20 14:20:09 +01:00
void showversion() {
REDIRECT;
const char *argv[] = {"cppcheck", "--version"};
CmdLineParser parser(&settings);
ASSERT(parser.ParseFromArgs(2, argv));
ASSERT_EQUALS(true, parser.GetShowVersion());
}
2010-09-06 22:16:52 +02:00
2014-11-20 14:20:09 +01:00
void onefile() {
2010-09-06 22:16:52 +02:00
REDIRECT;
const char *argv[] = {"cppcheck", "file.cpp"};
CmdLineParser parser(&settings);
ASSERT(parser.ParseFromArgs(2, argv));
ASSERT_EQUALS(1, (int)parser.GetPathNames().size());
2010-09-06 22:16:52 +02:00
ASSERT_EQUALS("file.cpp", parser.GetPathNames().at(0));
}
2014-11-20 14:20:09 +01:00
void onepath() {
2010-09-06 22:16:52 +02:00
REDIRECT;
const char *argv[] = {"cppcheck", "src"};
CmdLineParser parser(&settings);
ASSERT(parser.ParseFromArgs(2, argv));
ASSERT_EQUALS(1, (int)parser.GetPathNames().size());
2010-09-06 22:16:52 +02:00
ASSERT_EQUALS("src", parser.GetPathNames().at(0));
}
2014-11-20 14:20:09 +01:00
void optionwithoutfile() {
2010-09-06 22:16:52 +02:00
REDIRECT;
const char *argv[] = {"cppcheck", "-v"};
CmdLineParser parser(&settings);
ASSERT_EQUALS(false, parser.ParseFromArgs(2, argv));
ASSERT_EQUALS(0, (int)parser.GetPathNames().size());
2010-09-06 22:16:52 +02:00
}
2014-11-20 14:20:09 +01:00
void verboseshort() {
2010-09-06 22:16:52 +02:00
REDIRECT;
2010-09-06 23:12:24 +02:00
const char *argv[] = {"cppcheck", "-v", "file.cpp"};
settings.verbose = false;
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT_EQUALS(true, settings.verbose);
2010-09-06 22:16:52 +02:00
}
2014-11-20 14:20:09 +01:00
void verboselong() {
2010-09-06 22:16:52 +02:00
REDIRECT;
2010-09-06 23:12:24 +02:00
const char *argv[] = {"cppcheck", "--verbose", "file.cpp"};
settings.verbose = false;
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT_EQUALS(true, settings.verbose);
2010-09-06 22:16:52 +02:00
}
2014-11-20 14:20:09 +01:00
void debug() {
2010-09-06 22:16:52 +02:00
REDIRECT;
2010-09-06 23:12:24 +02:00
const char *argv[] = {"cppcheck", "--debug", "file.cpp"};
settings.debug = false;
ASSERT(defParser.ParseFromArgs(3, argv));
2010-09-06 22:16:52 +02:00
ASSERT_EQUALS(true, settings.debug);
}
2014-11-20 14:20:09 +01:00
void debugwarnings() {
2010-09-06 22:16:52 +02:00
REDIRECT;
2010-09-06 23:12:24 +02:00
const char *argv[] = {"cppcheck", "--debug-warnings", "file.cpp"};
settings.debugwarnings = false;
ASSERT(defParser.ParseFromArgs(3, argv));
2010-09-06 22:16:52 +02:00
ASSERT_EQUALS(true, settings.debugwarnings);
}
2014-11-20 14:20:09 +01:00
void forceshort() {
2010-09-06 22:16:52 +02:00
REDIRECT;
2010-09-06 23:12:24 +02:00
const char *argv[] = {"cppcheck", "-f", "file.cpp"};
settings.force = false;
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT_EQUALS(true, settings.force);
2010-09-06 22:16:52 +02:00
}
2014-11-20 14:20:09 +01:00
void forcelong() {
2010-09-06 22:16:52 +02:00
REDIRECT;
2010-09-06 23:12:24 +02:00
const char *argv[] = {"cppcheck", "--force", "file.cpp"};
settings.force = false;
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT_EQUALS(true, settings.force);
2010-09-06 22:16:52 +02:00
}
2014-11-20 14:20:09 +01:00
void relativePaths() {
REDIRECT;
settings.relativePaths = false;
const char *argvs[] = {"cppcheck", "-rp", "file.cpp"};
ASSERT(defParser.ParseFromArgs(3, argvs));
ASSERT_EQUALS(true, settings.relativePaths);
settings.relativePaths = false;
const char *argvl[] = {"cppcheck", "--relative-paths", "file.cpp"};
ASSERT(defParser.ParseFromArgs(3, argvl));
ASSERT_EQUALS(true, settings.relativePaths);
settings.relativePaths = false;
settings.basePaths.clear();
const char *argvsp[] = {"cppcheck", "-rp=C:/foo;C:\\bar", "file.cpp"};
ASSERT(defParser.ParseFromArgs(3, argvsp));
ASSERT_EQUALS(true, settings.relativePaths);
ASSERT_EQUALS(2, settings.basePaths.size());
ASSERT_EQUALS("C:/foo", settings.basePaths[0]);
ASSERT_EQUALS("C:/bar", settings.basePaths[1]);
settings.relativePaths = false;
settings.basePaths.clear();
const char *argvlp[] = {"cppcheck", "--relative-paths=C:/foo;C:\\bar", "file.cpp"};
ASSERT(defParser.ParseFromArgs(3, argvlp));
ASSERT_EQUALS(true, settings.relativePaths);
ASSERT_EQUALS(2, settings.basePaths.size());
ASSERT_EQUALS("C:/foo", settings.basePaths[0]);
ASSERT_EQUALS("C:/bar", settings.basePaths[1]);
}
2014-11-20 14:20:09 +01:00
void quietshort() {
2010-09-06 22:16:52 +02:00
REDIRECT;
2010-09-06 23:12:24 +02:00
const char *argv[] = {"cppcheck", "-q", "file.cpp"};
settings.quiet = false;
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT_EQUALS(true, settings.quiet);
2010-09-06 22:16:52 +02:00
}
2014-11-20 14:20:09 +01:00
void quietlong() {
2010-09-06 22:16:52 +02:00
REDIRECT;
2010-09-06 23:12:24 +02:00
const char *argv[] = {"cppcheck", "--quiet", "file.cpp"};
settings.quiet = false;
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT_EQUALS(true, settings.quiet);
2010-09-06 22:16:52 +02:00
}
2014-11-20 14:20:09 +01:00
void defines_noarg() {
REDIRECT;
const char *argv[] = {"cppcheck", "-D"};
// Fails since -D has no param
ASSERT_EQUALS(false, defParser.ParseFromArgs(2, argv));
}
2014-11-20 14:20:09 +01:00
void defines_noarg2() {
REDIRECT;
const char *argv[] = {"cppcheck", "-D", "-v", "file.cpp"};
// Fails since -D has no param
ASSERT_EQUALS(false, defParser.ParseFromArgs(4, argv));
}
2014-11-20 14:20:09 +01:00
void defines_noarg3() {
REDIRECT;
const char *argv[] = {"cppcheck", "-D", "--quiet", "file.cpp"};
// Fails since -D has no param
ASSERT_EQUALS(false, defParser.ParseFromArgs(4, argv));
}
2014-11-20 14:20:09 +01:00
void defines() {
REDIRECT;
const char *argv[] = {"cppcheck", "-D_WIN32", "file.cpp"};
settings.userDefines.clear();
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT_EQUALS("_WIN32=1", settings.userDefines);
}
2014-11-20 14:20:09 +01:00
void defines2() {
REDIRECT;
const char *argv[] = {"cppcheck", "-D_WIN32", "-DNODEBUG", "file.cpp"};
settings.userDefines.clear();;
ASSERT(defParser.ParseFromArgs(4, argv));
ASSERT_EQUALS("_WIN32=1;NODEBUG=1", settings.userDefines);
}
2014-11-20 14:20:09 +01:00
void defines3() {
REDIRECT;
const char *argv[] = {"cppcheck", "-D", "DEBUG", "file.cpp"};
settings.userDefines.clear();
ASSERT(defParser.ParseFromArgs(4, argv));
ASSERT_EQUALS("DEBUG=1", settings.userDefines);
}
2014-11-20 14:20:09 +01:00
void defines4() {
REDIRECT;
const char *argv[] = {"cppcheck", "-DDEBUG=", "file.cpp"}; // #5137 - defining empty macro
settings.userDefines.clear();
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT_EQUALS("DEBUG=", settings.userDefines);
}
2014-11-20 14:20:09 +01:00
void enforceLanguage() {
REDIRECT;
{
const char *argv[] = {"cppcheck", "file.cpp"};
settings.enforcedLang = Settings::None;
ASSERT(defParser.ParseFromArgs(2, argv));
ASSERT_EQUALS(Settings::None, settings.enforcedLang);
}
{
const char *argv[] = {"cppcheck", "-x", "c++", "file.cpp"};
settings.enforcedLang = Settings::None;
ASSERT(defParser.ParseFromArgs(4, argv));
ASSERT_EQUALS(Settings::CPP, settings.enforcedLang);
}
{
const char *argv[] = {"cppcheck", "-x"};
ASSERT(!defParser.ParseFromArgs(2, argv));
}
{
const char *argv[] = {"cppcheck", "-x", "--inconclusive", "file.cpp"};
ASSERT(!defParser.ParseFromArgs(4, argv));
}
{
const char *argv[] = {"cppcheck", "--language=c++", "file.cpp"};
settings.enforcedLang = Settings::None;
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT_EQUALS(Settings::CPP, settings.enforcedLang);
}
{
const char *argv[] = {"cppcheck", "--language=c", "file.cpp"};
settings.enforcedLang = Settings::None;
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT_EQUALS(Settings::C, settings.enforcedLang);
}
{
const char *argv[] = {"cppcheck", "--language=unknownLanguage", "file.cpp"};
ASSERT(!defParser.ParseFromArgs(3, argv));
}
}
2014-11-20 14:20:09 +01:00
void includesnopath() {
REDIRECT;
2013-08-08 15:50:45 +02:00
const char *argv[] = {"cppcheck", "-I"};
// Fails since -I has no param
ASSERT_EQUALS(false, defParser.ParseFromArgs(2, argv));
}
2014-11-20 14:20:09 +01:00
void includes() {
REDIRECT;
const char *argv[] = {"cppcheck", "-I", "include", "file.cpp"};
settings.includePaths.clear();
ASSERT(defParser.ParseFromArgs(4, argv));
ASSERT_EQUALS("include/", settings.includePaths.front());
}
2014-11-20 14:20:09 +01:00
void includesslash() {
REDIRECT;
const char *argv[] = {"cppcheck", "-I", "include/", "file.cpp"};
settings.includePaths.clear();
ASSERT(defParser.ParseFromArgs(4, argv));
ASSERT_EQUALS("include/", settings.includePaths.front());
}
2014-11-20 14:20:09 +01:00
void includesbackslash() {
REDIRECT;
const char *argv[] = {"cppcheck", "-I", "include\\", "file.cpp"};
settings.includePaths.clear();
ASSERT(defParser.ParseFromArgs(4, argv));
ASSERT_EQUALS("include/", settings.includePaths.front());
}
2014-11-20 14:20:09 +01:00
void includesnospace() {
REDIRECT;
const char *argv[] = {"cppcheck", "-Iinclude", "file.cpp"};
settings.includePaths.clear();
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT_EQUALS("include/", settings.includePaths.front());
}
2014-11-20 14:20:09 +01:00
void includes2() {
REDIRECT;
const char *argv[] = {"cppcheck", "-I", "include/", "-I", "framework/", "file.cpp"};
settings.includePaths.clear();
ASSERT(defParser.ParseFromArgs(6, argv));
ASSERT_EQUALS("include/", settings.includePaths.front());
settings.includePaths.pop_front();
ASSERT_EQUALS("framework/", settings.includePaths.front());
}
2010-12-04 13:13:44 +01:00
2014-11-20 14:20:09 +01:00
void includesFile() {
// TODO: Fails since cannot open the file
REDIRECT;
const char *argv[] = {"cppcheck", "--includes-file=inclpaths.txt", "file.cpp"};
settings.includePaths.clear();
ASSERT_EQUALS(true, defParser.ParseFromArgs(3, argv));
}
2014-11-20 14:20:09 +01:00
void enabledAll() {
2010-12-04 13:13:44 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "--enable=all", "file.cpp"};
settings = Settings();
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT(settings.isEnabled(Settings::STYLE));
ASSERT(settings.isEnabled(Settings::WARNING));
ASSERT(settings.isEnabled(Settings::UNUSED_FUNCTION));
ASSERT(settings.isEnabled(Settings::MISSING_INCLUDE));
ASSERT(!settings.isEnabled(Settings::INTERNAL));
2010-12-04 13:13:44 +01:00
}
2014-11-20 14:20:09 +01:00
void enabledStyle() {
2010-12-04 13:13:44 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "--enable=style", "file.cpp"};
settings = Settings();
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT(settings.isEnabled(Settings::STYLE));
ASSERT(settings.isEnabled(Settings::WARNING));
ASSERT(settings.isEnabled(Settings::PERFORMANCE));
ASSERT(settings.isEnabled(Settings::PORTABILITY));
ASSERT(!settings.isEnabled(Settings::UNUSED_FUNCTION));
ASSERT(!settings.isEnabled(Settings::MISSING_INCLUDE));
}
2014-11-20 14:20:09 +01:00
void enabledPerformance() {
REDIRECT;
const char *argv[] = {"cppcheck", "--enable=performance", "file.cpp"};
settings = Settings();
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT(!settings.isEnabled(Settings::STYLE));
ASSERT(!settings.isEnabled(Settings::WARNING));
ASSERT(settings.isEnabled(Settings::PERFORMANCE));
ASSERT(!settings.isEnabled(Settings::PORTABILITY));
ASSERT(!settings.isEnabled(Settings::UNUSED_FUNCTION));
ASSERT(!settings.isEnabled(Settings::MISSING_INCLUDE));
}
2014-11-20 14:20:09 +01:00
void enabledPortability() {
REDIRECT;
const char *argv[] = {"cppcheck", "--enable=portability", "file.cpp"};
settings = Settings();
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT(!settings.isEnabled(Settings::STYLE));
ASSERT(!settings.isEnabled(Settings::WARNING));
ASSERT(!settings.isEnabled(Settings::PERFORMANCE));
ASSERT(settings.isEnabled(Settings::PORTABILITY));
ASSERT(!settings.isEnabled(Settings::UNUSED_FUNCTION));
ASSERT(!settings.isEnabled(Settings::MISSING_INCLUDE));
2010-12-04 13:13:44 +01:00
}
2014-11-20 14:20:09 +01:00
void enabledUnusedFunction() {
2010-12-04 13:13:44 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "--enable=unusedFunction", "file.cpp"};
settings = Settings();
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT(settings.isEnabled(Settings::UNUSED_FUNCTION));
2010-12-04 13:13:44 +01:00
}
2014-11-20 14:20:09 +01:00
void enabledMissingInclude() {
2010-12-04 13:13:44 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "--enable=missingInclude", "file.cpp"};
settings = Settings();
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT(settings.isEnabled(Settings::MISSING_INCLUDE));
2010-12-04 13:13:44 +01:00
}
#ifdef CHECK_INTERNAL
2014-11-20 14:20:09 +01:00
void enabledInternal() {
REDIRECT;
const char *argv[] = {"cppcheck", "--enable=internal", "file.cpp"};
settings = Settings();
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT(settings.isEnabled(Settings::INTERNAL));
}
#endif
2014-11-20 14:20:09 +01:00
void enabledMultiple() {
REDIRECT;
const char *argv[] = {"cppcheck", "--enable=missingInclude,portability,warning", "file.cpp"};
settings = Settings();
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT(!settings.isEnabled(Settings::STYLE));
ASSERT(settings.isEnabled(Settings::WARNING));
ASSERT(!settings.isEnabled(Settings::PERFORMANCE));
ASSERT(settings.isEnabled(Settings::PORTABILITY));
ASSERT(!settings.isEnabled(Settings::UNUSED_FUNCTION));
ASSERT(settings.isEnabled(Settings::MISSING_INCLUDE));
}
2014-11-20 14:20:09 +01:00
void inconclusive() {
REDIRECT;
const char *argv[] = {"cppcheck", "--inconclusive"};
settings.inconclusive = false;
ASSERT(defParser.ParseFromArgs(2, argv));
ASSERT_EQUALS(true, settings.inconclusive);
}
2014-11-20 14:20:09 +01:00
void errorExitcode() {
2010-12-04 13:13:44 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "--error-exitcode=5", "file.cpp"};
settings.exitCode = 0;
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT_EQUALS(5, settings.exitCode);
2010-12-04 13:13:44 +01:00
}
2014-11-20 14:20:09 +01:00
void errorExitcodeMissing() {
2010-12-04 13:13:44 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "--error-exitcode=", "file.cpp"};
settings.exitCode = 0;
// Fails since exit code not given
ASSERT_EQUALS(false, defParser.ParseFromArgs(3, argv));
2010-12-04 13:13:44 +01:00
}
2014-11-20 14:20:09 +01:00
void errorExitcodeStr() {
2010-12-04 13:13:44 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "--error-exitcode=foo", "file.cpp"};
settings.exitCode = 0;
// Fails since invalid exit code
ASSERT_EQUALS(false, defParser.ParseFromArgs(3, argv));
2010-12-04 13:13:44 +01:00
}
2014-11-20 14:20:09 +01:00
void exitcodeSuppressionsOld() {
// TODO: Fails since cannot open the file
REDIRECT;
const char *argv[] = {"cppcheck", "--exitcode-suppressions", "suppr.txt", "file.cpp"};
settings.exitCode = 0;
TODO_ASSERT_EQUALS(true, false, defParser.ParseFromArgs(4, argv));
}
2014-11-20 14:20:09 +01:00
void exitcodeSuppressions() {
// TODO: Fails since cannot open the file
2010-12-04 13:13:44 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "--exitcode-suppressions=suppr.txt", "file.cpp"};
settings.exitCode = 0;
TODO_ASSERT_EQUALS(true, false, defParser.ParseFromArgs(3, argv));
}
2014-11-20 14:20:09 +01:00
void exitcodeSuppressionsNoFile() {
// TODO: Fails since cannot open the file
REDIRECT;
const char *argv[] = {"cppcheck", "--exitcode-suppressions", "file.cpp"};
settings.exitCode = 0;
TODO_ASSERT_EQUALS(true, false, defParser.ParseFromArgs(3, argv));
2010-12-04 13:13:44 +01:00
}
2014-11-20 14:20:09 +01:00
void fileList() {
// TODO: Fails since cannot open the file
2010-12-04 13:13:44 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "--file-list", "files.txt", "file.cpp"};
TODO_ASSERT_EQUALS(true, false, defParser.ParseFromArgs(4, argv));
2010-12-04 13:13:44 +01:00
}
2011-09-30 01:23:30 +02:00
2014-01-11 07:54:06 +01:00
/* void fileListStdin() {
// TODO: Give it some stdin to read from, fails because the list of
// files in stdin (_pathnames) is empty
REDIRECT;
const char *argv[] = {"cppcheck", "--file-list=-", "file.cpp"};
TODO_ASSERT_EQUALS(true, false, defParser.ParseFromArgs(3, argv));
} */
2010-12-04 13:13:44 +01:00
2014-11-20 14:20:09 +01:00
void inlineSuppr() {
2010-12-04 13:13:44 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "--inline-suppr", "file.cpp"};
ASSERT(defParser.ParseFromArgs(3, argv));
2010-12-04 13:13:44 +01:00
}
2014-11-20 14:20:09 +01:00
void jobs() {
2010-12-04 13:13:44 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "-j", "3", "file.cpp"};
settings.jobs = 0;
ASSERT(defParser.ParseFromArgs(4, argv));
ASSERT_EQUALS(3, settings.jobs);
2010-12-04 13:13:44 +01:00
}
2014-11-20 14:20:09 +01:00
void jobsMissingCount() {
2010-12-04 13:13:44 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "-j", "file.cpp"};
settings.jobs = 0;
// Fails since -j is missing thread count
ASSERT_EQUALS(false, defParser.ParseFromArgs(3, argv));
2010-12-04 13:13:44 +01:00
}
2014-11-20 14:20:09 +01:00
void jobsInvalid() {
2010-12-04 13:13:44 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "-j", "e", "file.cpp"};
settings.jobs = 0;
// Fails since invalid count given for -j
ASSERT_EQUALS(false, defParser.ParseFromArgs(4, argv));
2010-12-04 13:13:44 +01:00
}
2014-11-20 14:20:09 +01:00
void maxConfigs() {
REDIRECT;
const char *argv[] = {"cppcheck", "-f", "--max-configs=12", "file.cpp"};
settings.force = false;
settings.maxConfigs = 12;
ASSERT(defParser.ParseFromArgs(4, argv));
ASSERT_EQUALS(12, settings.maxConfigs);
ASSERT_EQUALS(false, settings.force);
}
2014-11-20 14:20:09 +01:00
void maxConfigsMissingCount() {
REDIRECT;
const char *argv[] = {"cppcheck", "--max-configs=", "file.cpp"};
// Fails since --max-configs= is missing limit
ASSERT_EQUALS(false, defParser.ParseFromArgs(3, argv));
}
2014-11-20 14:20:09 +01:00
void maxConfigsInvalid() {
REDIRECT;
const char *argv[] = {"cppcheck", "--max-configs=e", "file.cpp"};
// Fails since invalid count given for --max-configs=
ASSERT_EQUALS(false, defParser.ParseFromArgs(3, argv));
}
2014-11-20 14:20:09 +01:00
void maxConfigsTooSmall() {
REDIRECT;
const char *argv[] = {"cppcheck", "--max-configs=0", "file.cpp"};
// Fails since limit must be greater than 0
ASSERT_EQUALS(false, defParser.ParseFromArgs(3, argv));
2011-10-22 11:11:54 +02:00
}
2014-11-20 14:20:09 +01:00
void reportProgressTest() {
2010-12-04 13:13:44 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "--report-progress", "file.cpp"};
settings.reportProgress = false;
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT(settings.reportProgress);
2010-12-04 13:13:44 +01:00
}
2014-11-20 14:20:09 +01:00
void stdposix() {
REDIRECT;
const char *argv[] = {"cppcheck", "--std=posix", "file.cpp"};
settings.standards.posix = false;
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT(settings.standards.posix);
}
2014-11-20 14:20:09 +01:00
void stdc99() {
REDIRECT;
const char *argv[] = {"cppcheck", "--std=c99", "file.cpp"};
settings.standards.c = Standards::C89;
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT(settings.standards.c == Standards::C99);
}
2014-11-20 14:20:09 +01:00
void stdcpp11() {
REDIRECT;
const char *argv[] = {"cppcheck", "--std=c++11", "file.cpp"};
settings.standards.cpp = Standards::CPP03;
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT(settings.standards.cpp == Standards::CPP11);
}
2014-11-20 14:20:09 +01:00
void platform() {
REDIRECT;
const char *argv[] = {"cppcheck", "--platform=win64", "file.cpp"};
settings.platform(Settings::Unspecified);
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT(settings.platformType == Settings::Win64);
}
2014-11-20 14:20:09 +01:00
void suppressionsOld() {
// TODO: Fails because there is no suppr.txt file!
2010-12-04 13:13:44 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "--suppressions", "suppr.txt", "file.cpp"};
ASSERT(!defParser.ParseFromArgs(4, argv));
2010-12-04 13:13:44 +01:00
}
2014-11-20 14:20:09 +01:00
void suppressions() {
// TODO: Fails because there is no suppr.txt file!
REDIRECT;
const char *argv[] = {"cppcheck", "--suppressions-list=suppr.txt", "file.cpp"};
TODO_ASSERT_EQUALS(true, false, defParser.ParseFromArgs(3, argv));
}
2014-11-20 14:20:09 +01:00
void suppressionsNoFile() {
REDIRECT;
{
CLEAR_REDIRECT_OUTPUT;
const char *argv[] = {"cppcheck", "--suppressions-list=", "file.cpp"};
ASSERT_EQUALS(false, defParser.ParseFromArgs(3, argv));
ASSERT_EQUALS(false, GET_REDIRECT_OUTPUT.find("If you want to pass two files") != std::string::npos);
}
{
CLEAR_REDIRECT_OUTPUT;
const char *argv[] = {"cppcheck", "--suppressions-list=a.suppr,b.suppr", "file.cpp"};
ASSERT_EQUALS(false, defParser.ParseFromArgs(3, argv));
ASSERT_EQUALS(true, GET_REDIRECT_OUTPUT.find("If you want to pass two files") != std::string::npos);
}
{
CLEAR_REDIRECT_OUTPUT;
const char *argv[] = {"cppcheck", "--suppressions-list=a.suppr b.suppr", "file.cpp"};
ASSERT_EQUALS(false, defParser.ParseFromArgs(3, argv));
ASSERT_EQUALS(true, GET_REDIRECT_OUTPUT.find("If you want to pass two files") != std::string::npos);
}
}
2014-11-20 14:20:09 +01:00
void suppressionSingle() {
2011-02-16 10:26:40 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "--suppress=uninitvar", "file.cpp"};
settings = Settings();
ASSERT(defParser.ParseFromArgs(3, argv));
2011-02-16 10:26:40 +01:00
ASSERT_EQUALS(true, settings.nomsg.isSuppressed("uninitvar", "file.cpp", 1U));
}
2014-11-20 14:20:09 +01:00
void suppressionSingleFile() {
2011-02-16 10:26:40 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "--suppress=uninitvar:file.cpp", "file.cpp"};
settings = Settings();
ASSERT(defParser.ParseFromArgs(3, argv));
2011-02-16 10:26:40 +01:00
ASSERT_EQUALS(true, settings.nomsg.isSuppressed("uninitvar", "file.cpp", 1U));
}
2014-11-20 14:20:09 +01:00
void suppressionTwo() {
REDIRECT;
const char *argv[] = {"cppcheck", "--suppress=uninitvar,noConstructor", "file.cpp"};
settings = Settings();
TODO_ASSERT_EQUALS(true, false, defParser.ParseFromArgs(3, argv));
TODO_ASSERT_EQUALS(true, false, settings.nomsg.isSuppressed("uninitvar", "file.cpp", 1U));
TODO_ASSERT_EQUALS(true, false, settings.nomsg.isSuppressed("noConstructor", "file.cpp", 1U));
}
2014-11-20 14:20:09 +01:00
void suppressionTwoSeparate() {
REDIRECT;
const char *argv[] = {"cppcheck", "--suppress=uninitvar", "--suppress=noConstructor", "file.cpp"};
settings = Settings();
ASSERT(defParser.ParseFromArgs(4, argv));
ASSERT_EQUALS(true, settings.nomsg.isSuppressed("uninitvar", "file.cpp", 1U));
ASSERT_EQUALS(true, settings.nomsg.isSuppressed("noConstructor", "file.cpp", 1U));
}
2014-11-20 14:20:09 +01:00
void templates() {
2010-12-04 13:13:44 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "--template", "{file}:{line},{severity},{id},{message}", "file.cpp"};
settings.outputFormat.clear();
ASSERT(defParser.ParseFromArgs(4, argv));
ASSERT_EQUALS("{file}:{line},{severity},{id},{message}", settings.outputFormat);
2010-12-04 13:13:44 +01:00
}
2014-11-20 14:20:09 +01:00
void templatesGcc() {
2010-12-04 13:13:44 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "--template", "gcc", "file.cpp"};
settings.outputFormat.clear();
ASSERT(defParser.ParseFromArgs(4, argv));
ASSERT_EQUALS("{file}:{line}: {severity}: {message}", settings.outputFormat);
2010-12-04 13:13:44 +01:00
}
2014-11-20 14:20:09 +01:00
void templatesVs() {
2010-12-04 13:13:44 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "--template", "vs", "file.cpp"};
settings.outputFormat.clear();
ASSERT(defParser.ParseFromArgs(4, argv));
ASSERT_EQUALS("{file}({line}): {severity}: {message}", settings.outputFormat);
2010-12-04 13:13:44 +01:00
}
2014-11-20 14:20:09 +01:00
void templatesEdit() {
REDIRECT;
const char *argv[] = {"cppcheck", "--template", "edit", "file.cpp"};
settings.outputFormat.clear();
ASSERT(defParser.ParseFromArgs(4, argv));
ASSERT_EQUALS("{file} +{line}: {severity}: {message}", settings.outputFormat);
}
2014-11-20 14:20:09 +01:00
void xml() {
2010-12-04 13:13:44 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "--xml", "file.cpp"};
settings.xml_version = 1;
settings.xml = false;
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT(settings.xml);
ASSERT_EQUALS(1, settings.xml_version);
}
2014-11-20 14:20:09 +01:00
void xmlver1() {
REDIRECT;
const char *argv[] = {"cppcheck", "--xml-version=1", "file.cpp"};
settings.xml_version = 1;
settings.xml = false;
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT(settings.xml);
ASSERT_EQUALS(1, settings.xml_version);
}
2014-11-20 14:20:09 +01:00
void xmlver2() {
REDIRECT;
const char *argv[] = {"cppcheck", "--xml-version=2", "file.cpp"};
settings.xml_version = 1;
settings.xml = false;
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT(settings.xml);
ASSERT_EQUALS(2, settings.xml_version);
}
2014-11-20 14:20:09 +01:00
void xmlver2both() {
REDIRECT;
const char *argv[] = {"cppcheck", "--xml", "--xml-version=2", "file.cpp"};
settings.xml_version = 1;
settings.xml = false;
ASSERT(defParser.ParseFromArgs(4, argv));
ASSERT(settings.xml);
ASSERT_EQUALS(2, settings.xml_version);
}
2014-11-20 14:20:09 +01:00
void xmlver2both2() {
REDIRECT;
const char *argv[] = {"cppcheck", "--xml-version=2", "--xml", "file.cpp"};
settings.xml_version = 1;
settings.xml = false;
ASSERT(defParser.ParseFromArgs(4, argv));
ASSERT(settings.xml);
ASSERT_EQUALS(2, settings.xml_version);
2010-12-04 13:13:44 +01:00
}
2014-11-20 14:20:09 +01:00
void xmlverunknown() {
REDIRECT;
const char *argv[] = {"cppcheck", "--xml", "--xml-version=3", "file.cpp"};
// FAils since unknown XML format version
ASSERT_EQUALS(false, defParser.ParseFromArgs(4, argv));
}
2014-11-20 14:20:09 +01:00
void xmlverinvalid() {
REDIRECT;
const char *argv[] = {"cppcheck", "--xml", "--xml-version=a", "file.cpp"};
// FAils since unknown XML format version
ASSERT_EQUALS(false, defParser.ParseFromArgs(4, argv));
}
2014-11-20 14:20:09 +01:00
void doc() {
REDIRECT;
const char *argv[] = {"cppcheck", "--doc"};
ASSERT(defParser.ParseFromArgs(2, argv));
ASSERT(defParser.ExitAfterPrinting());
}
2014-11-20 14:20:09 +01:00
void showtime() {
REDIRECT;
const char *argv[] = {"cppcheck", "--showtime=summary"};
settings.showtime = SHOWTIME_NONE;
ASSERT(defParser.ParseFromArgs(2, argv));
ASSERT(settings.showtime == SHOWTIME_SUMMARY);
}
2014-11-20 14:20:09 +01:00
void errorlist1() {
REDIRECT;
const char *argv[] = {"cppcheck", "--errorlist"};
ASSERT(defParser.ParseFromArgs(2, argv));
ASSERT(defParser.GetShowErrorMessages());
}
2014-11-20 14:20:09 +01:00
void errorlistverbose1() {
REDIRECT;
const char *argv[] = {"cppcheck", "--verbose", "--errorlist"};
settings.verbose = false;
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT(settings.verbose);
}
2014-11-20 14:20:09 +01:00
void errorlistverbose2() {
REDIRECT;
const char *argv[] = {"cppcheck", "--errorlist", "--verbose"};
settings.verbose = false;
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT(settings.verbose);
}
2014-11-20 14:20:09 +01:00
void ignorepathsnopath() {
REDIRECT;
const char *argv[] = {"cppcheck", "-i"};
CmdLineParser parser(&settings);
// Fails since no ignored path given
ASSERT_EQUALS(false, parser.ParseFromArgs(2, argv));
ASSERT_EQUALS(0, parser.GetIgnoredPaths().size());
}
2017-05-03 14:39:21 +02:00
/*
void ignorepaths1() {
REDIRECT;
const char *argv[] = {"cppcheck", "-isrc", "file.cpp"};
CmdLineParser parser(&settings);
ASSERT(parser.ParseFromArgs(3, argv));
ASSERT_EQUALS(1, parser.GetIgnoredPaths().size());
ASSERT_EQUALS("src/", parser.GetIgnoredPaths()[0]);
}
2017-05-03 14:39:21 +02:00
void ignorepaths2() {
REDIRECT;
const char *argv[] = {"cppcheck", "-i", "src", "file.cpp"};
CmdLineParser parser(&settings);
ASSERT(parser.ParseFromArgs(4, argv));
ASSERT_EQUALS(1, parser.GetIgnoredPaths().size());
ASSERT_EQUALS("src/", parser.GetIgnoredPaths()[0]);
}
2017-05-03 14:39:21 +02:00
void ignorepaths3() {
REDIRECT;
const char *argv[] = {"cppcheck", "-isrc", "-imodule", "file.cpp"};
CmdLineParser parser(&settings);
ASSERT(parser.ParseFromArgs(4, argv));
ASSERT_EQUALS(2, parser.GetIgnoredPaths().size());
ASSERT_EQUALS("src/", parser.GetIgnoredPaths()[0]);
ASSERT_EQUALS("module/", parser.GetIgnoredPaths()[1]);
}
*/
2014-11-20 14:20:09 +01:00
void ignorepaths4() {
REDIRECT;
const char *argv[] = {"cppcheck", "-i", "src", "-i", "module", "file.cpp"};
CmdLineParser parser(&settings);
ASSERT(parser.ParseFromArgs(6, argv));
ASSERT_EQUALS(2, parser.GetIgnoredPaths().size());
ASSERT_EQUALS("src/", parser.GetIgnoredPaths()[0]);
ASSERT_EQUALS("module/", parser.GetIgnoredPaths()[1]);
}
2017-05-03 14:39:21 +02:00
/*
void ignorefilepaths1() {
REDIRECT;
const char *argv[] = {"cppcheck", "-ifoo.cpp", "file.cpp"};
CmdLineParser parser(&settings);
ASSERT(parser.ParseFromArgs(3, argv));
ASSERT_EQUALS(1, parser.GetIgnoredPaths().size());
ASSERT_EQUALS("foo.cpp", parser.GetIgnoredPaths()[0]);
}
*/
2014-11-20 14:20:09 +01:00
void ignorefilepaths2() {
REDIRECT;
const char *argv[] = {"cppcheck", "-isrc/foo.cpp", "file.cpp"};
CmdLineParser parser(&settings);
ASSERT(parser.ParseFromArgs(3, argv));
ASSERT_EQUALS(1, parser.GetIgnoredPaths().size());
ASSERT_EQUALS("src/foo.cpp", parser.GetIgnoredPaths()[0]);
}
2014-11-20 14:20:09 +01:00
void checkconfig() {
2011-05-04 20:07:02 +02:00
REDIRECT;
const char *argv[] = {"cppcheck", "--check-config", "file.cpp"};
settings.checkConfiguration = false;
ASSERT(defParser.ParseFromArgs(3, argv));
2011-05-04 20:07:02 +02:00
ASSERT_EQUALS(true, settings.checkConfiguration);
}
2014-11-20 14:20:09 +01:00
void unknownParam() {
2010-12-04 13:13:44 +01:00
REDIRECT;
const char *argv[] = {"cppcheck", "--foo", "file.cpp"};
ASSERT(!defParser.ParseFromArgs(3, argv));
2010-12-04 13:13:44 +01:00
}
2014-11-20 14:20:09 +01:00
void undefs() {
REDIRECT;
const char *argv[] = {"cppcheck", "-U_WIN32", "file.cpp"};
settings = Settings();
ASSERT(defParser.ParseFromArgs(3, argv));
ASSERT_EQUALS(1, settings.userUndefs.size());
ASSERT(settings.userUndefs.find("_WIN32") != settings.userUndefs.end());
}
2014-11-20 14:20:09 +01:00
void undefs2() {
REDIRECT;
const char *argv[] = {"cppcheck", "-U_WIN32", "-UNODEBUG", "file.cpp"};
settings = Settings();
ASSERT(defParser.ParseFromArgs(4, argv));
ASSERT_EQUALS(2, settings.userUndefs.size());
ASSERT(settings.userUndefs.find("_WIN32") != settings.userUndefs.end());
ASSERT(settings.userUndefs.find("NODEBUG") != settings.userUndefs.end());
}
2014-11-20 14:20:09 +01:00
void undefs_noarg() {
REDIRECT;
const char *argv[] = {"cppcheck", "-U"};
// Fails since -U has no param
ASSERT_EQUALS(false, defParser.ParseFromArgs(2, argv));
}
2014-11-20 14:20:09 +01:00
void undefs_noarg2() {
REDIRECT;
const char *argv[] = {"cppcheck", "-U", "-v", "file.cpp"};
// Fails since -U has no param
ASSERT_EQUALS(false, defParser.ParseFromArgs(4, argv));
}
2014-11-20 14:20:09 +01:00
void undefs_noarg3() {
REDIRECT;
const char *argv[] = {"cppcheck", "-U", "--quiet", "file.cpp"};
// Fails since -U has no param
ASSERT_EQUALS(false, defParser.ParseFromArgs(4, argv));
}
};
REGISTER_TEST(TestCmdlineParser)