diff --git a/gui/projectfiledialog.cpp b/gui/projectfiledialog.cpp
index 2392ed92838..98e294bfb8a 100644
--- a/gui/projectfiledialog.cpp
+++ b/gui/projectfiledialog.cpp
@@ -30,6 +30,7 @@
 
 #include "ui_projectfile.h"
 
+#include <array>
 #include <list>
 #include <string>
 #include <utility>
@@ -79,7 +80,7 @@ static QStringList getPaths(const QListWidget *list)
 }
 
 /** Platforms shown in the platform combobox */
-static constexpr Platform::Type builtinPlatforms[] = {
+static const std::array<Platform::Type, 6> builtinPlatforms = {
     Platform::Type::Native,
     Platform::Type::Win32A,
     Platform::Type::Win32W,
@@ -88,8 +89,6 @@ static constexpr Platform::Type builtinPlatforms[] = {
     Platform::Type::Unix64
 };
 
-static constexpr int numberOfBuiltinPlatforms = sizeof(builtinPlatforms) / sizeof(builtinPlatforms[0]);
-
 QStringList ProjectFileDialog::getProjectConfigs(const QString &fileName)
 {
     if (!fileName.endsWith(".sln") && !fileName.endsWith(".vcxproj"))
@@ -336,7 +335,7 @@ void ProjectFileDialog::loadFromProjectFile(const ProjectFile *projectFile)
     const QString& platform = projectFile->getPlatform();
     if (platform.endsWith(".xml")) {
         int i;
-        for (i = numberOfBuiltinPlatforms; i < mUI->mComboBoxPlatform->count(); ++i) {
+        for (i = builtinPlatforms.size(); i < mUI->mComboBoxPlatform->count(); ++i) {
             if (mUI->mComboBoxPlatform->itemText(i) == platform)
                 break;
         }
@@ -348,12 +347,12 @@ void ProjectFileDialog::loadFromProjectFile(const ProjectFile *projectFile)
         }
     } else {
         int i;
-        for (i = 0; i < numberOfBuiltinPlatforms; ++i) {
+        for (i = 0; i < builtinPlatforms.size(); ++i) {
             const Platform::Type p = builtinPlatforms[i];
             if (platform == Platform::toString(p))
                 break;
         }
-        if (i < numberOfBuiltinPlatforms)
+        if (i < builtinPlatforms.size())
             mUI->mComboBoxPlatform->setCurrentIndex(i);
         else
             mUI->mComboBoxPlatform->setCurrentIndex(-1);
@@ -482,7 +481,7 @@ void ProjectFileDialog::saveToProjectFile(ProjectFile *projectFile) const
         projectFile->setPlatform(mUI->mComboBoxPlatform->currentText());
     else {
         const int i = mUI->mComboBoxPlatform->currentIndex();
-        if (i>=0 && i < numberOfBuiltinPlatforms)
+        if (i>=0 && i < builtinPlatforms.size())
             projectFile->setPlatform(Platform::toString(builtinPlatforms[i]));
         else
             projectFile->setPlatform(QString());
diff --git a/lib/tokenize.cpp b/lib/tokenize.cpp
index 320a17b0df3..75aa3fe4d57 100644
--- a/lib/tokenize.cpp
+++ b/lib/tokenize.cpp
@@ -39,6 +39,7 @@
 #include "vfvalue.h"
 
 #include <algorithm>
+#include <array>
 #include <cassert>
 #include <cctype>
 #include <cstdlib>
@@ -7443,13 +7444,13 @@ void Tokenizer::simplifyStaticConst()
 {
     // This function will simplify the token list so that the qualifiers "extern", "static"
     // and "const" appear in the same order as in the array below.
-    const std::string qualifiers[] = {"extern", "static", "const"};
+    static const std::array<std::string, 3> qualifiers = {"extern", "static", "const"};
 
     // Move 'const' before all other qualifiers and types and then
     // move 'static' before all other qualifiers and types, ...
     for (Token *tok = list.front(); tok; tok = tok->next()) {
         bool continue2 = false;
-        for (std::size_t i = 0; i < sizeof(qualifiers)/sizeof(qualifiers[0]); i++) {
+        for (std::size_t i = 0; i < qualifiers.size(); i++) {
 
             // Keep searching for a qualifier
             if (!tok->next() || tok->strAt(1) != qualifiers[i])
diff --git a/test/fixture.h b/test/fixture.h
index 0a440dc1185..625616325d7 100644
--- a/test/fixture.h
+++ b/test/fixture.h
@@ -215,7 +215,10 @@ class TestFixture : public ErrorLogger {
 
         SettingsBuilder& library(const char lib[]);
 
-        SettingsBuilder& libraryxml(const char xmldata[], std::size_t len);
+        template<size_t size>
+        SettingsBuilder& libraryxml(const char (&xmldata)[size]) {
+            return libraryxml(xmldata, size-1);
+        }
 
         SettingsBuilder& platform(Platform::Type type);
 
@@ -237,6 +240,8 @@ class TestFixture : public ErrorLogger {
             return std::move(settings);
         }
     private:
+        SettingsBuilder& libraryxml(const char xmldata[], std::size_t len);
+
         const TestFixture &fixture;
         Settings settings;
 
diff --git a/test/testbufferoverrun.cpp b/test/testbufferoverrun.cpp
index ea5758b8742..1993455b9c6 100644
--- a/test/testbufferoverrun.cpp
+++ b/test/testbufferoverrun.cpp
@@ -3697,7 +3697,7 @@ class TestBufferOverrun : public TestFixture {
                                    "    <arg nr=\"2\"/>\n"
                                    "  </function>\n"
                                    "</def>";
-        const Settings settings = settingsBuilder().libraryxml(xmldata, sizeof(xmldata)).build();
+        const Settings settings = settingsBuilder().libraryxml(xmldata).build();
 
         // Attempt to get size from Cfg files, no false positives if size is not specified
         check("void f() {\n"
@@ -4255,7 +4255,7 @@ class TestBufferOverrun : public TestFixture {
                                    "    <arg nr=\"3\"/>\n"
                                    "  </function>\n"
                                    "</def>";
-        /*const*/ Settings settings = settingsBuilder().libraryxml(xmldata, sizeof(xmldata)).severity(Severity::warning).build();
+        /*const*/ Settings settings = settingsBuilder().libraryxml(xmldata).severity(Severity::warning).build();
         settings.platform.sizeof_wchar_t = 4;
 
         check("void f() {\n"
@@ -4393,7 +4393,7 @@ class TestBufferOverrun : public TestFixture {
                                    "    <arg nr=\"3\"/>\n"
                                    "  </function>\n"
                                    "</def>";
-        const Settings settings = settingsBuilder().libraryxml(xmldata, sizeof(xmldata)).build();
+        const Settings settings = settingsBuilder().libraryxml(xmldata).build();
 
         check("void f() {\n"
               "    char c[7];\n"
@@ -4454,7 +4454,7 @@ class TestBufferOverrun : public TestFixture {
                                    "    </arg>\n"
                                    "  </function>\n"
                                    "</def>";
-        const Settings settings = settingsBuilder().libraryxml(xmldata, sizeof(xmldata)).build();
+        const Settings settings = settingsBuilder().libraryxml(xmldata).build();
 
         // formatstr..
         check("void f() {\n"
@@ -4565,7 +4565,7 @@ class TestBufferOverrun : public TestFixture {
                                    "    <arg nr=\"4\"/>\n"
                                    "  </function>\n"
                                    "</def>";
-        const Settings settings = settingsBuilder().libraryxml(xmldata, sizeof(xmldata)).build();
+        const Settings settings = settingsBuilder().libraryxml(xmldata).build();
 
         check("void f() {\n"
               "    char c[5];\n"
diff --git a/test/testclass.cpp b/test/testclass.cpp
index c3c63abec85..73b682cfe4a 100644
--- a/test/testclass.cpp
+++ b/test/testclass.cpp
@@ -3447,7 +3447,7 @@ class TestClass : public TestFixture {
                                    "  <podtype name=\"std::uint8_t\" sign=\"u\" size=\"1\"/>\n"
                                    "  <podtype name=\"std::atomic_bool\"/>\n"
                                    "</def>";
-        const Settings settings = settingsBuilder().libraryxml(xmldata, sizeof(xmldata)).build();
+        const Settings settings = settingsBuilder().libraryxml(xmldata).build();
 
         checkNoMemset("class A {\n"
                       "    std::array<int, 10> ints;\n"
diff --git a/test/testcmdlineparser.cpp b/test/testcmdlineparser.cpp
index 8dea8cbaaef..ec2b5cbcd9b 100644
--- a/test/testcmdlineparser.cpp
+++ b/test/testcmdlineparser.cpp
@@ -111,6 +111,16 @@ class TestCmdlineParser : public TestFixture {
         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(helpshort);
@@ -473,42 +483,42 @@ class TestCmdlineParser : public TestFixture {
     void nooptions() {
         REDIRECT;
         const char * const argv[] = {"cppcheck"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parser->parseFromArgs(1, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(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_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, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(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_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, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(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_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
         ASSERT(logger->str().compare(0, 11, "Cppcheck 2.") == 0);
     }
 
@@ -519,7 +529,7 @@ class TestCmdlineParser : public TestFixture {
                         "\"productName\": \"The Product\""
                         "}\n");
         const char * const argv[] = {"cppcheck", "--version"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
         // TODO: somehow the config is not loaded on some systems
         (void)logger->str(); //ASSERT_EQUALS("The Product\n", logger->str()); // TODO: include version?
     }
@@ -529,7 +539,7 @@ class TestCmdlineParser : public TestFixture {
     void versionExclusive() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--library=missing", "--version"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
         ASSERT(logger->str().compare(0, 11, "Cppcheck 2.") == 0);
     }
 
@@ -538,7 +548,7 @@ class TestCmdlineParser : public TestFixture {
         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_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());
     }
 
@@ -547,20 +557,20 @@ class TestCmdlineParser : public TestFixture {
         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));
+        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, parser->parseFromArgs(3, argv));
+        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, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(1, (int)parser->getPathNames().size());
         ASSERT_EQUALS("file.cpp", parser->getPathNames().at(0));
     }
@@ -568,7 +578,7 @@ class TestCmdlineParser : public TestFixture {
     void onepath() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "src"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(1, (int)parser->getPathNames().size());
         ASSERT_EQUALS("src", parser->getPathNames().at(0));
     }
@@ -576,7 +586,7 @@ class TestCmdlineParser : public TestFixture {
     void optionwithoutfile() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-v"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS(0, (int)parser->getPathNames().size());
         ASSERT_EQUALS("cppcheck: error: no C or C++ source files found.\n", logger->str());
     }
@@ -584,63 +594,63 @@ class TestCmdlineParser : public TestFixture {
     void verboseshort() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-v", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        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, parser->parseFromArgs(3, argv));
+        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, parser->parseFromArgs(3, argv));
+        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, parser->parseFromArgs(3, argv));
+        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, parser->parseFromArgs(3, argv));
+        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, parser->parseFromArgs(3, argv));
+        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, parser->parseFromArgs(3, argv));
+        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, parser->parseFromArgs(3, argv));
+        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, parser->parseFromArgs(3, argv));
+        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]);
@@ -650,7 +660,7 @@ class TestCmdlineParser : public TestFixture {
     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_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(true, settings->relativePaths);
         ASSERT_EQUALS(2, settings->basePaths.size());
         ASSERT_EQUALS("C:/foo", settings->basePaths[0]);
@@ -660,14 +670,14 @@ class TestCmdlineParser : public TestFixture {
     void quietshort() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-q", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        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, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(true, settings->quiet);
     }
 
@@ -675,7 +685,7 @@ class TestCmdlineParser : public TestFixture {
         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_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '-D' is missing.\n", logger->str());
     }
 
@@ -683,7 +693,7 @@ class TestCmdlineParser : public TestFixture {
         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_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '-D' is missing.\n", logger->str());
     }
 
@@ -691,84 +701,84 @@ class TestCmdlineParser : public TestFixture {
         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_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, parser->parseFromArgs(3, argv));
+        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, parser->parseFromArgs(4, argv));
+        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, parser->parseFromArgs(4, argv));
+        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, parser->parseFromArgs(3, argv));
+        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, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(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_ENUM(CmdLineParser::Result::Success, parseFromArgs(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_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, parser->parseFromArgs(4, argv));
+        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, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(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_ENUM(CmdLineParser::Result::Success, parseFromArgs(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_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unknown language 'unknownLanguage' enforced.\n", logger->str());
     }
 
@@ -776,42 +786,42 @@ class TestCmdlineParser : public TestFixture {
         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_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, parser->parseFromArgs(4, argv));
+        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, parser->parseFromArgs(4, argv));
+        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, parser->parseFromArgs(4, argv));
+        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, parser->parseFromArgs(3, argv));
+        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, parser->parseFromArgs(6, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS("include/", settings->includePaths.front());
         settings->includePaths.pop_front();
         ASSERT_EQUALS("framework/", settings->includePaths.front());
@@ -823,7 +833,7 @@ class TestCmdlineParser : public TestFixture {
                         "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_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(2, settings->includePaths.size());
         auto it = settings->includePaths.cbegin();
         ASSERT_EQUALS("path/sub/", *it++);
@@ -833,7 +843,7 @@ class TestCmdlineParser : public TestFixture {
     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_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unable to open includes file at 'fileThatDoesNotExist.txt'\n", logger->str());
     }
 
@@ -843,7 +853,7 @@ class TestCmdlineParser : public TestFixture {
                         "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_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(2, settings->configExcludePaths.size());
         auto it = settings->configExcludePaths.cbegin();
         ASSERT_EQUALS("path/sub/", *it++);
@@ -853,14 +863,14 @@ class TestCmdlineParser : public TestFixture {
     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_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, parser->parseFromArgs(3, argv));
+        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));
@@ -872,7 +882,7 @@ class TestCmdlineParser : public TestFixture {
     void enabledStyle() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--enable=style", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        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));
@@ -885,7 +895,7 @@ class TestCmdlineParser : public TestFixture {
     void enabledPerformance() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--enable=performance", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        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));
@@ -898,7 +908,7 @@ class TestCmdlineParser : public TestFixture {
     void enabledPortability() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--enable=portability", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        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));
@@ -911,7 +921,7 @@ class TestCmdlineParser : public TestFixture {
     void enabledInformation() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--enable=information", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->severity.isEnabled(Severity::error));
         ASSERT(settings->severity.isEnabled(Severity::information));
         ASSERT(!settings->checks.isEnabled(Checks::missingInclude));
@@ -920,7 +930,7 @@ class TestCmdlineParser : public TestFixture {
     void enabledUnusedFunction() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--enable=unusedFunction", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->severity.isEnabled(Severity::error));
         ASSERT(settings->checks.isEnabled(Checks::unusedFunction));
     }
@@ -928,7 +938,7 @@ class TestCmdlineParser : public TestFixture {
     void enabledMissingInclude() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--enable=missingInclude", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->severity.isEnabled(Severity::error));
         ASSERT(settings->checks.isEnabled(Checks::missingInclude));
     }
@@ -936,7 +946,7 @@ class TestCmdlineParser : public TestFixture {
     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_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->severity.isEnabled(Severity::error));
         ASSERT(settings->severity.isEnabled(Severity::information));
         ASSERT(!settings->checks.isEnabled(Checks::missingInclude));
@@ -946,7 +956,7 @@ class TestCmdlineParser : public TestFixture {
     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_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->severity.isEnabled(Severity::error));
         ASSERT(settings->severity.isEnabled(Severity::information));
         ASSERT(settings->checks.isEnabled(Checks::missingInclude));
@@ -956,7 +966,7 @@ class TestCmdlineParser : public TestFixture {
     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_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->severity.isEnabled(Severity::error));
         ASSERT(settings->severity.isEnabled(Severity::information));
         ASSERT(settings->checks.isEnabled(Checks::missingInclude));
@@ -967,7 +977,7 @@ class TestCmdlineParser : public TestFixture {
     void enabledInternal() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--enable=internal", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->severity.isEnabled(Severity::error));
         ASSERT(settings->checks.isEnabled(Checks::internalCheck));
     }
@@ -976,7 +986,7 @@ class TestCmdlineParser : public TestFixture {
     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_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));
@@ -989,21 +999,21 @@ class TestCmdlineParser : public TestFixture {
     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_ENUM(CmdLineParser::Result::Fail, parseFromArgs(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_ENUM(CmdLineParser::Result::Fail, parseFromArgs(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_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: --enable parameter is empty\n", logger->str());
     }
 
@@ -1011,7 +1021,7 @@ class TestCmdlineParser : public TestFixture {
     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_ENUM(CmdLineParser::Result::Success, parseFromArgs(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));
@@ -1026,7 +1036,7 @@ class TestCmdlineParser : public TestFixture {
     void disableMultiple() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--enable=all", "--disable=style", "--disable=unusedFunction", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(5, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::error));
         ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::warning));
         ASSERT_EQUALS(false, settings->severity.isEnabled(Severity::style));
@@ -1042,7 +1052,7 @@ class TestCmdlineParser : public TestFixture {
     void disableStylePartial() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--enable=style", "--disable=performance", "--enable=unusedFunction", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(5, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::error));
         ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::warning));
         ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::style));
@@ -1057,7 +1067,7 @@ class TestCmdlineParser : public TestFixture {
     void disableInformationPartial() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--enable=information", "--disable=missingInclude", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->severity.isEnabled(Severity::information));
         ASSERT(!settings->checks.isEnabled(Checks::missingInclude));
         ASSERT_EQUALS("", logger->str());
@@ -1066,7 +1076,7 @@ class TestCmdlineParser : public TestFixture {
     void disableInformationPartial2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--enable=missingInclude", "--disable=information", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(!settings->severity.isEnabled(Severity::information));
         ASSERT(settings->checks.isEnabled(Checks::missingInclude));
     }
@@ -1074,35 +1084,35 @@ class TestCmdlineParser : public TestFixture {
     void disableInvalid() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--disable=leaks", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: --disable parameter with the unknown name 'leaks'\n", logger->str());
     }
 
     void disableError() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--disable=error", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: --disable parameter with the unknown name 'error'\n", logger->str());
     }
 
     void disableEmpty() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--disable=", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: --disable parameter is empty\n", logger->str());
     }
 
     void inconclusive() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--inconclusive", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(true, settings->certainty.isEnabled(Certainty::inconclusive));
     }
 
     void errorExitcode() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--error-exitcode=5", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(5, settings->exitCode);
     }
 
@@ -1110,7 +1120,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--error-exitcode=", "file.cpp"};
         // Fails since exit code not given
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--error-exitcode=' is not valid - not an integer.\n", logger->str());
     }
 
@@ -1118,14 +1128,14 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--error-exitcode=foo", "file.cpp"};
         // Fails since invalid exit code
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--error-exitcode=' is not valid - not an integer.\n", logger->str());
     }
 
     void exitcodeSuppressionsOld() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--exitcode-suppressions", "suppr.txt", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--exitcode-suppressions\".\n", logger->str());
     }
 
@@ -1135,7 +1145,7 @@ class TestCmdlineParser : public TestFixture {
                         "uninitvar\n"
                         "unusedFunction\n");
         const char * const argv[] = {"cppcheck", "--exitcode-suppressions=suppr.txt", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         const auto supprsNofail = supprs->nofail.getSuppressions();
         ASSERT_EQUALS(2, supprsNofail.size());
         auto it = supprsNofail.cbegin();
@@ -1146,7 +1156,7 @@ class TestCmdlineParser : public TestFixture {
     void exitcodeSuppressionsNoFile() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--exitcode-suppressions", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--exitcode-suppressions\".\n", logger->str());
     }
 
@@ -1154,7 +1164,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         RedirectInput input("file1.c\nfile2.cpp\n");
         const char * const argv[] = {"cppcheck", "--file-filter=-"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: no C or C++ source files found.\n", logger->str());
         ASSERT_EQUALS(2U, settings->fileFilters.size());
         ASSERT_EQUALS("file1.c", settings->fileFilters[0]);
@@ -1167,7 +1177,7 @@ class TestCmdlineParser : public TestFixture {
                         "file1.c\n"
                         "file2.cpp\n");
         const char * const argv[] = {"cppcheck", "--file-list=files.txt", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(3, parser->getPathNames().size());
         auto it = parser->getPathNames().cbegin();
         ASSERT_EQUALS("file1.c", *it++);
@@ -1178,7 +1188,7 @@ class TestCmdlineParser : public TestFixture {
     void fileListNoFile() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--file-list=files.txt", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: couldn't open the file: \"files.txt\".\n", logger->str());
     }
 
@@ -1186,7 +1196,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         RedirectInput input("file1.c\nfile2.cpp\n");
         const char * const argv[] = {"cppcheck", "--file-list=-", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(3, parser->getPathNames().size());
         auto it = parser->getPathNames().cbegin();
         ASSERT_EQUALS("file1.c", *it++);
@@ -1197,28 +1207,28 @@ class TestCmdlineParser : public TestFixture {
     void fileListInvalid() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--file-list", "files.txt", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--file-list\".\n", logger->str());
     }
 
     void inlineSuppr() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--inline-suppr", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->inlineSuppressions);
     }
 
     void jobs() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-j", "3", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(3, settings->jobs);
     }
 
     void jobs2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-j3", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(3, settings->jobs);
     }
 
@@ -1226,7 +1236,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-j", "file.cpp"};
         // Fails since -j is missing thread count
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '-j' is not valid - not an integer.\n", logger->str());
     }
 
@@ -1234,28 +1244,28 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-j", "e", "file.cpp"};
         // Fails since invalid count given for -j
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '-j' is not valid - not an integer.\n", logger->str());
     }
 
     void jobsNoJobs() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-j0", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument for '-j' must be greater than 0.\n", logger->str());
     }
 
     void jobsTooBig() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-j1025", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument for '-j' is allowed to be 1024 at max.\n", logger->str());
     }
 
     void maxConfigs() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-f", "--max-configs=12", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(12, settings->maxConfigs);
         ASSERT_EQUALS(false, settings->force);
     }
@@ -1264,7 +1274,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--max-configs=", "file.cpp"};
         // Fails since --max-configs= is missing limit
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--max-configs=' is not valid - not an integer.\n", logger->str());
     }
 
@@ -1272,7 +1282,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--max-configs=e", "file.cpp"};
         // Fails since invalid count given for --max-configs=
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--max-configs=' is not valid - not an integer.\n", logger->str());
     }
 
@@ -1280,42 +1290,42 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--max-configs=0", "file.cpp"};
         // Fails since limit must be greater than 0
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--max-configs=' must be greater than 0.\n", logger->str());
     }
 
     void outputFormatText() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--output-format=text", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Settings::OutputFormat::text, settings->outputFormat);
     }
 
     void outputFormatSarif() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--output-format=sarif", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Settings::OutputFormat::sarif, settings->outputFormat);
     }
 
     void outputFormatXml() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--output-format=xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Settings::OutputFormat::xml, settings->outputFormat);
     }
 
     void outputFormatOther() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--output-format=plist", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--output-format=' must be 'text', 'sarif' or 'xml'.\n", logger->str());
     }
 
     void outputFormatImplicitPlist() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--plist-output=.", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Settings::OutputFormat::plist, settings->outputFormat);
         ASSERT_EQUALS("./", settings->plistOutput);
     }
@@ -1323,14 +1333,14 @@ class TestCmdlineParser : public TestFixture {
     void outputFormatImplicitXml() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Settings::OutputFormat::xml, settings->outputFormat);
     }
 
     void outputFormatOverridePlist() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--plist-output=.", "--output-format=text", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Settings::OutputFormat::text, settings->outputFormat);
         ASSERT_EQUALS("", settings->plistOutput);
     }
@@ -1339,7 +1349,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         asPremium();
         const char * const argv[] = {"cppcheck", "--premium=autosar", "file.c"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->severity.isEnabled(Severity::error));
         ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::warning));
     }
@@ -1348,7 +1358,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         asPremium();
         const char * const argv[] = {"cppcheck", "--premium=misra-c-2012", "file.c"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->severity.isEnabled(Severity::error));
         ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::warning));
     }
@@ -1357,7 +1367,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         asPremium();
         const char * const argv[] = {"cppcheck", "--premium=misra-c++-2023", "file.c"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->severity.isEnabled(Severity::error));
         ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::warning));
     }
@@ -1366,7 +1376,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         asPremium();
         const char * const argv[] = {"cppcheck", "--premium=cert-c++-2016", "file.c"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->severity.isEnabled(Severity::error));
         ASSERT_EQUALS(true, settings->severity.isEnabled(Severity::warning));
     }
@@ -1375,7 +1385,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         asPremium();
         const char * const argv[] = {"cppcheck", "--premium=safety", "file.c"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->severity.isEnabled(Severity::error));
         ASSERT_EQUALS(false, settings->severity.isEnabled(Severity::warning));
     }
@@ -1384,7 +1394,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         asPremium();
         const char * const argv[] = {"cppcheck", "--premium-cert-c-int-precision=12", "file.c"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS("--cert-c-int-precision=12", settings->premiumArgs);
     }
 
@@ -1392,7 +1402,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         asPremium();
         const char * const argv[] = {"cppcheck", "--premium-license-file=file.lic", "file.c"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS("--license-file=file.lic", settings->premiumArgs);
     }
 
@@ -1400,7 +1410,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         asPremium();
         const char * const argv[] = {"cppcheck", "--premium=misra", "file.c"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: invalid --premium option 'misra'.\n", logger->str());
     }
 
@@ -1408,7 +1418,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         asPremium();
         const char * const argv[] = {"cppcheck", "--premium=cert", "file.c"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: invalid --premium option 'cert'.\n", logger->str());
     }
 
@@ -1416,63 +1426,63 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         asPremium();
         const char * const argv[] = {"cppcheck", "--premium=safety", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(true, settings->safety);
     }
 
     void reportProgress1() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--report-progress", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(10, settings->reportProgress);
     }
 
     void reportProgress2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--report-progress=", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--report-progress=' is not valid - not an integer.\n", logger->str());
     }
 
     void reportProgress3() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--report-progress=-1", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--report-progress=' needs to be a positive integer.\n", logger->str());
     }
 
     void reportProgress4() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--report-progress=0", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(0, settings->reportProgress);
     }
 
     void reportProgress5() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--report-progress=1", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(1, settings->reportProgress);
     }
 
     void stdc99() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--std=c99", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->standards.c == Standards::C99);
     }
 
     void stdgnu17() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--std=gnu17", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->standards.c == Standards::C17);
     }
 
     void stdiso9899_1999() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--std=iso9899:1999", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->standards.c == Standards::C99);
     }
 
@@ -1480,7 +1490,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--std=c++11", "file.cpp"};
         settings->standards.cpp = Standards::CPP03;
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->standards.cpp == Standards::CPP11);
     }
 
@@ -1488,35 +1498,35 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--std=gnu++23", "file.cpp"};
         settings->standards.cpp = Standards::CPP03;
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->standards.cpp == Standards::CPP23);
     }
 
     void stdunknown1() {
         REDIRECT;
         const char *const argv[] = {"cppcheck", "--std=d++11", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unknown --std value 'd++11'\n", logger->str());
     }
 
     void stdunknown2() {
         REDIRECT;
         const char *const argv[] = {"cppcheck", "--std=cplusplus11", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unknown --std value 'cplusplus11'\n", logger->str());
     }
 
     void stdunknown3() {
         REDIRECT;
         const char *const argv[] = {"cppcheck", "--std=C++11", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unknown --std value 'C++11'\n", logger->str());
     }
 
     void stdoverwrite1() {
         REDIRECT;
         const char *const argv[] = {"cppcheck", "--std=c++11", "--std=c++23", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Standards::CPP23, settings->standards.cpp);
         ASSERT_EQUALS_ENUM(Standards::CLatest, settings->standards.c);
     }
@@ -1524,7 +1534,7 @@ class TestCmdlineParser : public TestFixture {
     void stdoverwrite2() {
         REDIRECT;
         const char *const argv[] = {"cppcheck", "--std=c99", "--std=c11", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Standards::C11, settings->standards.c);
         ASSERT_EQUALS_ENUM(Standards::CPPLatest, settings->standards.cpp);
     }
@@ -1532,7 +1542,7 @@ class TestCmdlineParser : public TestFixture {
     void stdoverwrite3() {
         REDIRECT;
         const char *const argv[] = {"cppcheck", "--std=c99", "--std=c++11", "--std=c11", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(5, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Standards::C11, settings->standards.c);
         ASSERT_EQUALS_ENUM(Standards::CPP11, settings->standards.cpp);
     }
@@ -1540,7 +1550,7 @@ class TestCmdlineParser : public TestFixture {
     void stdoverwrite4() {
         REDIRECT;
         const char *const argv[] = {"cppcheck", "--std=c++11", "--std=c99", "--std=c++23", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(5, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Standards::CPP23, settings->standards.cpp);
         ASSERT_EQUALS_ENUM(Standards::C99, settings->standards.c);
     }
@@ -1548,7 +1558,7 @@ class TestCmdlineParser : public TestFixture {
     void stdmulti1() {
         REDIRECT;
         const char *const argv[] = {"cppcheck", "--std=c99", "--std=c++11", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Standards::C99, settings->standards.c);
         ASSERT_EQUALS_ENUM(Standards::CPP11, settings->standards.cpp);
     }
@@ -1556,7 +1566,7 @@ class TestCmdlineParser : public TestFixture {
     void stdmulti2() {
         REDIRECT;
         const char *const argv[] = {"cppcheck", "--std=c++20", "--std=c11", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Standards::C11, settings->standards.c);
         ASSERT_EQUALS_ENUM(Standards::CPP20, settings->standards.cpp);
     }
@@ -1565,7 +1575,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--platform=win64", "file.cpp"};
         ASSERT(settings->platform.set(Platform::Type::Unspecified));
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(Platform::Type::Win64, settings->platform.type);
     }
 
@@ -1573,7 +1583,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--platform=win32A", "file.cpp"};
         ASSERT(settings->platform.set(Platform::Type::Unspecified));
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(Platform::Type::Win32A, settings->platform.type);
     }
 
@@ -1581,7 +1591,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--platform=win32W", "file.cpp"};
         ASSERT(settings->platform.set(Platform::Type::Unspecified));
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(Platform::Type::Win32W, settings->platform.type);
     }
 
@@ -1589,7 +1599,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--platform=unix32", "file.cpp"};
         ASSERT(settings->platform.set(Platform::Type::Unspecified));
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(Platform::Type::Unix32, settings->platform.type);
     }
 
@@ -1597,7 +1607,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--platform=unix32-unsigned", "file.cpp"};
         ASSERT(settings->platform.set(Platform::Type::Unspecified));
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(Platform::Type::Unix32, settings->platform.type);
     }
 
@@ -1605,7 +1615,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--platform=unix64", "file.cpp"};
         ASSERT(settings->platform.set(Platform::Type::Unspecified));
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(Platform::Type::Unix64, settings->platform.type);
     }
 
@@ -1613,7 +1623,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--platform=unix64-unsigned", "file.cpp"};
         ASSERT(settings->platform.set(Platform::Type::Unspecified));
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(Platform::Type::Unix64, settings->platform.type);
     }
 
@@ -1621,7 +1631,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--platform=native", "file.cpp"};
         ASSERT(settings->platform.set(Platform::Type::Unspecified));
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(Platform::Type::Native, settings->platform.type);
     }
 
@@ -1629,7 +1639,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--platform=unspecified", "file.cpp"};
         ASSERT(settings->platform.set(Platform::Type::Native));
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(Platform::Type::Unspecified, settings->platform.type);
     }
 
@@ -1637,21 +1647,21 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--platform=avr8", "file.cpp"};
         ASSERT(settings->platform.set(Platform::Type::Unspecified));
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(Platform::Type::File, settings->platform.type);
     }
 
     void platformUnknown() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--platform=win128", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unrecognized platform: 'win128'.\n", logger->str());
     }
 
     void plistEmpty() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--plist-output=", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->plistOutput == "./");
     }
 
@@ -1659,14 +1669,14 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--plist-output=./cppcheck_reports", "file.cpp"};
         // Fails since folder pointed by --plist-output= does not exist
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: plist folder does not exist: 'cppcheck_reports'.\n", logger->str());
     }
 
     void suppressionsOld() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--suppressions", "suppr.txt", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--suppressions\".\n", logger->str());
     }
 
@@ -1676,7 +1686,7 @@ class TestCmdlineParser : public TestFixture {
                         "uninitvar\n"
                         "unusedFunction\n");
         const char * const argv[] = {"cppcheck", "--suppressions-list=suppr.txt", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         const auto supprsNomsg = supprs->nomsg.getSuppressions();
         ASSERT_EQUALS(2, supprsNomsg.size());
         auto it = supprsNomsg.cbegin();
@@ -1687,21 +1697,21 @@ class TestCmdlineParser : public TestFixture {
     void suppressionsNoFile1() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--suppressions-list=", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS(false, logger->str().find("If you want to pass two files") != std::string::npos);
     }
 
     void suppressionsNoFile2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--suppressions-list=a.suppr,b.suppr", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS(true, logger->str().find("If you want to pass two files") != std::string::npos);
     }
 
     void suppressionsNoFile3() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--suppressions-list=a.suppr b.suppr", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS(true, logger->str().find("If you want to pass two files") != std::string::npos);
     }
 
@@ -1716,21 +1726,21 @@ class TestCmdlineParser : public TestFixture {
     void suppressionSingle() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--suppress=uninitvar", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(true, supprs->nomsg.isSuppressed(errorMessage("uninitvar", "file.cpp", 1)));
     }
 
     void suppressionSingleFile() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--suppress=uninitvar:file.cpp", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(true, supprs->nomsg.isSuppressed(errorMessage("uninitvar", "file.cpp", 1U)));
     }
 
     void suppressionTwo() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--suppress=uninitvar,noConstructor", "file.cpp"};
-        TODO_ASSERT_EQUALS(static_cast<int>(CmdLineParser::Result::Success), static_cast<int>(CmdLineParser::Result::Fail), static_cast<int>(parser->parseFromArgs(3, argv)));
+        TODO_ASSERT_EQUALS(static_cast<int>(CmdLineParser::Result::Success), static_cast<int>(CmdLineParser::Result::Fail), static_cast<int>(parseFromArgs(argv)));
         TODO_ASSERT_EQUALS(true, false, supprs->nomsg.isSuppressed(errorMessage("uninitvar", "file.cpp", 1U)));
         TODO_ASSERT_EQUALS(true, false, supprs->nomsg.isSuppressed(errorMessage("noConstructor", "file.cpp", 1U)));
         TODO_ASSERT_EQUALS("", "cppcheck: error: Failed to add suppression. Invalid id \"uninitvar,noConstructor\"\n", logger->str());
@@ -1739,7 +1749,7 @@ class TestCmdlineParser : public TestFixture {
     void suppressionTwoSeparate() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--suppress=uninitvar", "--suppress=noConstructor", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(true, supprs->nomsg.isSuppressed(errorMessage("uninitvar", "file.cpp", 1U)));
         ASSERT_EQUALS(true, supprs->nomsg.isSuppressed(errorMessage("noConstructor", "file.cpp", 1U)));
     }
@@ -1747,7 +1757,7 @@ class TestCmdlineParser : public TestFixture {
     void templates() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--template={file}:{line},{severity},{id},{message}", "--template-location={file}:{line}:{column} {info}", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS("{file}:{line},{severity},{id},{message}", settings->templateFormat);
         ASSERT_EQUALS("{file}:{line}:{column} {info}", settings->templateLocation);
     }
@@ -1755,7 +1765,7 @@ class TestCmdlineParser : public TestFixture {
     void templatesGcc() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--template=gcc", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS("{file}:{line}:{column}: warning: {message} [{id}]\n{code}", settings->templateFormat);
         ASSERT_EQUALS("{file}:{line}:{column}: note: {info}\n{code}", settings->templateLocation);
     }
@@ -1763,7 +1773,7 @@ class TestCmdlineParser : public TestFixture {
     void templatesVs() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--template=vs", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS("{file}({line}): {severity}: {message}", settings->templateFormat);
         ASSERT_EQUALS("", settings->templateLocation);
     }
@@ -1771,7 +1781,7 @@ class TestCmdlineParser : public TestFixture {
     void templatesEdit() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--template=edit", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS("{file} +{line}: {severity}: {message}", settings->templateFormat);
         ASSERT_EQUALS("", settings->templateLocation);
     }
@@ -1779,7 +1789,7 @@ class TestCmdlineParser : public TestFixture {
     void templatesCppcheck1() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--template=cppcheck1", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS("{callstack}: ({severity}{inconclusive:, inconclusive}) {message}", settings->templateFormat);
         ASSERT_EQUALS("", settings->templateLocation);
     }
@@ -1787,7 +1797,7 @@ class TestCmdlineParser : public TestFixture {
     void templatesDaca2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--template=daca2", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS("{file}:{line}:{column}: {severity}:{inconclusive:inconclusive:} {message} [{id}]", settings->templateFormat);
         ASSERT_EQUALS("{file}:{line}:{column}: note: {info}", settings->templateLocation);
         ASSERT_EQUALS(true, settings->daca);
@@ -1796,7 +1806,7 @@ class TestCmdlineParser : public TestFixture {
     void templatesSelfcheck() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--template=selfcheck", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS("{file}:{line}:{column}: {severity}:{inconclusive:inconclusive:} {message} [{id}]\n{code}", settings->templateFormat);
         ASSERT_EQUALS("{file}:{line}:{column}: note: {info}\n{code}", settings->templateLocation);
     }
@@ -1804,7 +1814,7 @@ class TestCmdlineParser : public TestFixture {
     void templatesSimple() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--template=simple", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS("{file}:{line}:{column}: {severity}:{inconclusive:inconclusive:} {message} [{id}]", settings->templateFormat);
         ASSERT_EQUALS("", settings->templateLocation);
     }
@@ -1813,7 +1823,7 @@ class TestCmdlineParser : public TestFixture {
     void templatesNoPlaceholder() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--template=selfchek", "file.cpp"};
-        TODO_ASSERT_EQUALS(static_cast<int>(CmdLineParser::Result::Fail), static_cast<int>(CmdLineParser::Result::Success), static_cast<int>(parser->parseFromArgs(3, argv)));
+        TODO_ASSERT_EQUALS(static_cast<int>(CmdLineParser::Result::Fail), static_cast<int>(CmdLineParser::Result::Success), static_cast<int>(parseFromArgs(argv)));
         ASSERT_EQUALS("selfchek", settings->templateFormat);
         ASSERT_EQUALS("", settings->templateLocation);
     }
@@ -1821,7 +1831,7 @@ class TestCmdlineParser : public TestFixture {
     void templateFormatInvalid() {
         REDIRECT;
         const char* const argv[] = { "cppcheck", "--template", "file.cpp" };
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--template\".\n", logger->str());
     }
 
@@ -1830,7 +1840,7 @@ class TestCmdlineParser : public TestFixture {
     void templateFormatEmpty() {
         REDIRECT;
         const char* const argv[] = { "cppcheck", "--template=", "file.cpp" };
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS("{file}:{line}:{column}: {inconclusive:}{severity}:{inconclusive: inconclusive:} {message} [{id}]\n{code}", settings->templateFormat);
         ASSERT_EQUALS("{file}:{line}:{column}: note: {info}\n{code}", settings->templateLocation);
     }
@@ -1838,7 +1848,7 @@ class TestCmdlineParser : public TestFixture {
     void templateLocationInvalid() {
         REDIRECT;
         const char* const argv[] = { "cppcheck", "--template-location", "--template={file}", "file.cpp" };
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--template-location\".\n", logger->str());
     }
 
@@ -1847,7 +1857,7 @@ class TestCmdlineParser : public TestFixture {
     void templateLocationEmpty() {
         REDIRECT;
         const char* const argv[] = { "cppcheck", "--template-location=", "file.cpp" };
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS("{file}:{line}:{column}: {inconclusive:}{severity}:{inconclusive: inconclusive:} {message} [{id}]\n{code}", settings->templateFormat);
         ASSERT_EQUALS("{file}:{line}:{column}: note: {info}\n{code}", settings->templateLocation);
     }
@@ -1855,7 +1865,7 @@ class TestCmdlineParser : public TestFixture {
     void xml() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Settings::OutputFormat::xml, settings->outputFormat);
         ASSERT_EQUALS(2, settings->xml_version);
     }
@@ -1863,7 +1873,7 @@ class TestCmdlineParser : public TestFixture {
     void xmlver2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--xml-version=2", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Settings::OutputFormat::xml, settings->outputFormat);
         ASSERT_EQUALS(2, settings->xml_version);
     }
@@ -1871,7 +1881,7 @@ class TestCmdlineParser : public TestFixture {
     void xmlver2both() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--xml", "--xml-version=2", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Settings::OutputFormat::xml, settings->outputFormat);
         ASSERT_EQUALS(2, settings->xml_version);
     }
@@ -1879,7 +1889,7 @@ class TestCmdlineParser : public TestFixture {
     void xmlver2both2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--xml-version=2", "--xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Settings::OutputFormat::xml, settings->outputFormat);
         ASSERT_EQUALS(2, settings->xml_version);
     }
@@ -1888,7 +1898,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--xml", "--xml-version=4", "file.cpp"};
         // FAils since unknown XML format version
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: '--xml-version' can only be 2 or 3.\n", logger->str());
     }
 
@@ -1896,49 +1906,49 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--xml", "--xml-version=a", "file.cpp"};
         // FAils since unknown XML format version
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--xml-version=' is not valid - not an integer.\n", logger->str());
     }
 
     void doc() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--doc"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
         ASSERT(startsWith(logger->str(), "## "));
     }
 
     void docExclusive() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--library=missing", "--doc"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
         ASSERT(startsWith(logger->str(), "## "));
     }
 
     void showtimeSummary() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--showtime=summary", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->showtime == SHOWTIME_MODES::SHOWTIME_SUMMARY);
     }
 
     void showtimeFile() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--showtime=file", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->showtime == SHOWTIME_MODES::SHOWTIME_FILE);
     }
 
     void showtimeFileTotal() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--showtime=file-total", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->showtime == SHOWTIME_MODES::SHOWTIME_FILE_TOTAL);
     }
 
     void showtimeTop5() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--showtime=top5", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->showtime == SHOWTIME_MODES::SHOWTIME_TOP5_FILE);
         ASSERT_EQUALS("cppcheck: --showtime=top5 is deprecated and will be removed in Cppcheck 2.14. Please use --showtime=top5_file or --showtime=top5_summary instead.\n", logger->str());
     }
@@ -1946,42 +1956,42 @@ class TestCmdlineParser : public TestFixture {
     void showtimeTop5File() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--showtime=top5_file", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->showtime == SHOWTIME_MODES::SHOWTIME_TOP5_FILE);
     }
 
     void showtimeTop5Summary() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--showtime=top5_summary", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->showtime == SHOWTIME_MODES::SHOWTIME_TOP5_SUMMARY);
     }
 
     void showtimeNone() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--showtime=none", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->showtime == SHOWTIME_MODES::SHOWTIME_NONE);
     }
 
     void showtimeEmpty() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--showtime=", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: no mode provided for --showtime\n", logger->str());
     }
 
     void showtimeInvalid() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--showtime=top10", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unrecognized --showtime mode: 'top10'. Supported modes: file, file-total, summary, top5, top5_file, top5_summary.\n", logger->str());
     }
 
     void errorlist() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--errorlist"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
         ASSERT_EQUALS("", logger->str()); // empty since it is logged via ErrorLogger
         const std::string errout_s = GET_REDIRECT_OUTPUT;
         ASSERT(startsWith(errout_s, ErrorMessage::getXMLHeader("")));
@@ -1993,7 +2003,7 @@ class TestCmdlineParser : public TestFixture {
         ScopedFile file(Path::join(Path::getPathFromFilename(Path::getCurrentExecutablePath("")), "cppcheck.cfg"),
                         R"({"productName": "The Product"}\n)");
         const char * const argv[] = {"cppcheck", "--errorlist"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
         ASSERT_EQUALS("", logger->str()); // empty since it is logged via ErrorLogger
         ASSERT(startsWith(GET_REDIRECT_OUTPUT, ErrorMessage::getXMLHeader("The Product")));
     }
@@ -2001,7 +2011,7 @@ class TestCmdlineParser : public TestFixture {
     void errorlistExclusive() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--library=missing", "--errorlist"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Exit, parseFromArgs(argv));
         ASSERT_EQUALS("", logger->str()); // empty since it is logged via ErrorLogger
         const std::string errout_s = GET_REDIRECT_OUTPUT;
         ASSERT(startsWith(errout_s, ErrorMessage::getXMLHeader("")));
@@ -2013,7 +2023,7 @@ class TestCmdlineParser : public TestFixture {
         ScopedFile file(Path::join(Path::getPathFromFilename(Path::getCurrentExecutablePath("")), "cppcheck.cfg"),
                         "{\n");
         const char * const argv[] = {"cppcheck", "--errorlist"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(2, argv));
+        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());
     }
 
@@ -2021,7 +2031,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-i"};
         // Fails since no ignored path given
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '-i' is missing.\n", logger->str());
     }
 
@@ -2029,7 +2039,7 @@ class TestCmdlineParser : public TestFixture {
     void exceptionhandling() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--exception-handling", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->exceptionHandling);
         ASSERT_EQUALS(stdout, settings->exceptionOutput);
     }
@@ -2037,7 +2047,7 @@ class TestCmdlineParser : public TestFixture {
     void exceptionhandling2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--exception-handling=stderr", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->exceptionHandling);
         ASSERT_EQUALS(stderr, settings->exceptionOutput);
     }
@@ -2045,7 +2055,7 @@ class TestCmdlineParser : public TestFixture {
     void exceptionhandling3() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--exception-handling=stdout", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->exceptionHandling);
         ASSERT_EQUALS(stdout, settings->exceptionOutput);
     }
@@ -2053,28 +2063,28 @@ class TestCmdlineParser : public TestFixture {
     void exceptionhandlingInvalid() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--exception-handling=exfile"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: invalid '--exception-handling' argument\n", logger->str());
     }
 
     void exceptionhandlingInvalid2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--exception-handling-foo"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--exception-handling-foo\".\n", logger->str());
     }
 #else
     void exceptionhandlingNotSupported() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--exception-handling", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: Option --exception-handling is not supported since Cppcheck has not been built with any exception handling enabled.\n", logger->str());
     }
 
     void exceptionhandlingNotSupported2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--exception-handling=stderr", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: Option --exception-handling is not supported since Cppcheck has not been built with any exception handling enabled.\n", logger->str());
     }
 #endif
@@ -2082,7 +2092,7 @@ class TestCmdlineParser : public TestFixture {
     void clang() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--clang", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->clang);
         ASSERT_EQUALS("clang", settings->clangExecutable);
     }
@@ -2090,7 +2100,7 @@ class TestCmdlineParser : public TestFixture {
     void clang2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--clang=clang-14", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->clang);
         ASSERT_EQUALS("clang-14", settings->clangExecutable);
     }
@@ -2098,63 +2108,63 @@ class TestCmdlineParser : public TestFixture {
     void clangInvalid() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--clang-foo"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--clang-foo\".\n", logger->str());
     }
 
     void valueFlowMaxIterations() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--valueflow-max-iterations=0", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(0, settings->vfOptions.maxIterations);
     }
 
     void valueFlowMaxIterations2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--valueflow-max-iterations=11", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(11, settings->vfOptions.maxIterations);
     }
 
     void valueFlowMaxIterationsInvalid() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--valueflow-max-iterations"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--valueflow-max-iterations\".\n", logger->str());
     }
 
     void valueFlowMaxIterationsInvalid2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--valueflow-max-iterations=seven"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--valueflow-max-iterations=' is not valid - not an integer.\n", logger->str());
     }
 
     void valueFlowMaxIterationsInvalid3() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--valueflow-max-iterations=-1"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--valueflow-max-iterations=' is not valid - needs to be positive.\n", logger->str());
     }
 
     void checksMaxTime() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--checks-max-time=12", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(12, settings->checksMaxTime);
     }
 
     void checksMaxTime2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--checks-max-time=-1", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--checks-max-time=' needs to be a positive integer.\n", logger->str());
     }
 
     void checksMaxTimeInvalid() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--checks-max-time=one", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--checks-max-time=' is not valid - not an integer.\n", logger->str());
     }
 
@@ -2162,28 +2172,28 @@ class TestCmdlineParser : public TestFixture {
     void loadAverage() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-l", "12", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(12, settings->loadAverage);
     }
 
     void loadAverage2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-l12", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(12, settings->loadAverage);
     }
 
     void loadAverageInvalid() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-l", "one", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '-l' is not valid - not an integer.\n", logger->str());
     }
 #else
     void loadAverageNotSupported() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-l", "12", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: Option -l cannot be used as Cppcheck has not been built with fork threading model.\n", logger->str());
     }
 #endif
@@ -2191,21 +2201,21 @@ class TestCmdlineParser : public TestFixture {
     void maxCtuDepth() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--max-ctu-depth=5", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(5, settings->maxCtuDepth);
     }
 
     void maxCtuDepth2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--max-ctu-depth=10", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(10, settings->maxCtuDepth);
     }
 
     void maxCtuDepthLimit() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--max-ctu-depth=12", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(10, settings->maxCtuDepth);
         ASSERT_EQUALS("cppcheck: --max-ctu-depth is being capped at 10. This limitation will be removed in a future Cppcheck version.\n", logger->str());
     }
@@ -2213,77 +2223,77 @@ class TestCmdlineParser : public TestFixture {
     void maxCtuDepthInvalid() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--max-ctu-depth=one", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--max-ctu-depth=' is not valid - not an integer.\n", logger->str());
     }
 
     void performanceValueflowMaxTime() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--performance-valueflow-max-time=12", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(12, settings->vfOptions.maxTime);
     }
 
     void performanceValueflowMaxTimeInvalid() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--performance-valueflow-max-time=one", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--performance-valueflow-max-time=' is not valid - not an integer.\n", logger->str());
     }
 
     void performanceValueFlowMaxIfCount() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--performance-valueflow-max-if-count=12", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(12, settings->vfOptions.maxIfCount);
     }
 
     void performanceValueFlowMaxIfCountInvalid() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--performance-valueflow-max-if-count=one", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--performance-valueflow-max-if-count=' is not valid - not an integer.\n", logger->str());
     }
 
     void templateMaxTime() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--template-max-time=12", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(12, settings->templateMaxTime);
     }
 
     void templateMaxTimeInvalid() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--template-max-time=one", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--template-max-time=' is not valid - not an integer.\n", logger->str());
     }
 
     void templateMaxTimeInvalid2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--template-max-time=-1", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--template-max-time=' is not valid - needs to be positive.\n", logger->str());
     }
 
     void typedefMaxTime() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--typedef-max-time=12", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(12, settings->typedefMaxTime);
     }
 
     void typedefMaxTimeInvalid() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--typedef-max-time=one", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--typedef-max-time=' is not valid - not an integer.\n", logger->str());
     }
 
     void typedefMaxTimeInvalid2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--typedef-max-time=-1", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--typedef-max-time=' is not valid - needs to be positive.\n", logger->str());
     }
 
@@ -2296,7 +2306,7 @@ class TestCmdlineParser : public TestFixture {
                         "</paths>\n"
                         "</project>");
         const char * const argv[] = {"cppcheck", "--project=project.cppcheck"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(1, parser->getPathNames().size());
         auto it = parser->getPathNames().cbegin();
         ASSERT_EQUALS("dir", *it);
@@ -2306,7 +2316,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         ScopedFile file("project.cppcheck", "<project></project>");
         const char * const argv[] = {"cppcheck", "--project=project.cppcheck", "--project=project.cppcheck", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: multiple --project options are not supported.\n", logger->str());
     }
 
@@ -2314,35 +2324,35 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         ScopedFile file("project.cppcheck", "<project></project>");
         const char * const argv[] = {"cppcheck", "--project=project.cppcheck", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: --project cannot be used in conjunction with source files.\n", logger->str());
     }
 
     void projectEmpty() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--project=", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: failed to open project ''. The file does not exist.\n", logger->str());
     }
 
     void projectMissing() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--project=project.cppcheck", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: failed to open project 'project.cppcheck'. The file does not exist.\n", logger->str());
     }
 
     void projectNoPaths() {
         ScopedFile file("project.cppcheck", "<project></project>");
         const char * const argv[] = {"cppcheck", "--project=project.cppcheck"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: no C or C++ source files found.\n", logger->str());
     }
 
     void addon() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--addon=misra", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(1, settings->addons.size());
         ASSERT_EQUALS("misra", *settings->addons.cbegin());
     }
@@ -2350,7 +2360,7 @@ class TestCmdlineParser : public TestFixture {
     void addonMissing() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--addon=misra2", "file.cpp"};
-        ASSERT(!parser->fillSettingsFromArgs(3, argv));
+        ASSERT(!fillSettingsFromArgs(argv));
         ASSERT_EQUALS(1, settings->addons.size());
         ASSERT_EQUALS("misra2", *settings->addons.cbegin());
         ASSERT_EQUALS("Did not find addon misra2.py\n", logger->str());
@@ -2359,35 +2369,35 @@ class TestCmdlineParser : public TestFixture {
     void signedChar() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--fsigned-char", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS('s', settings->platform.defaultSign);
     }
 
     void signedChar2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--platform=avr8", "--fsigned-char", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS('s', settings->platform.defaultSign);
     }
 
     void unsignedChar() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--funsigned-char", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS('u', settings->platform.defaultSign);
     }
 
     void unsignedChar2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--platform=mips32", "--funsigned-char", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS('u', settings->platform.defaultSign);
     }
 
     void signedCharUnsignedChar() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--fsigned-char", "--funsigned-char", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS('u', settings->platform.defaultSign);
     }
 
@@ -2395,7 +2405,7 @@ class TestCmdlineParser : public TestFixture {
     void rule() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--rule=.+", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(1, settings->rules.size());
         auto it = settings->rules.cbegin();
         ASSERT_EQUALS(".+", it->pattern);
@@ -2404,14 +2414,14 @@ class TestCmdlineParser : public TestFixture {
     void ruleMissingPattern() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--rule=", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: no rule pattern provided.\n", logger->str());
     }
 #else
     void ruleNotSupported() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--rule=.+", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: Option --rule cannot be used as Cppcheck has not been built with rules support.\n", logger->str());
     }
 #endif
@@ -2441,7 +2451,7 @@ class TestCmdlineParser : public TestFixture {
                         "</rule>\n"
                         "</rules>");
         const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(2, settings->rules.size());
         auto it = settings->rules.cbegin();
         ASSERT_EQUALS("raw", it->tokenlist);
@@ -2470,7 +2480,7 @@ class TestCmdlineParser : public TestFixture {
                         "</message>\n"
                         "</rule>\n");
         const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(1, settings->rules.size());
         auto it = settings->rules.cbegin();
         ASSERT_EQUALS("define", it->tokenlist);
@@ -2483,14 +2493,14 @@ class TestCmdlineParser : public TestFixture {
     void ruleFileEmpty() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--rule-file=", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unable to load rule-file '' (XML_ERROR_FILE_NOT_FOUND).\n", logger->str());
     }
 
     void ruleFileMissing() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' (XML_ERROR_FILE_NOT_FOUND).\n", logger->str());
     }
 
@@ -2498,7 +2508,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         ScopedFile file("rule.xml", "");
         const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' (XML_ERROR_EMPTY_DOCUMENT).\n", logger->str());
     }
 
@@ -2506,7 +2516,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         ScopedFile file("rule.xml", "<?xml version=\"1.0\"?>");
         const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(0, settings->rules.size());
     }
 
@@ -2520,7 +2530,7 @@ class TestCmdlineParser : public TestFixture {
                         "</rule>"
                         );
         const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv)); // do not crash
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv)); // do not crash
         ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' - a rule is lacking a pattern.\n", logger->str());
     }
 
@@ -2536,7 +2546,7 @@ class TestCmdlineParser : public TestFixture {
                         "</rule>"
                         );
         const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv)); // do not crash
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv)); // do not crash
         ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' - a rule is lacking a pattern.\n", logger->str());
     }
 
@@ -2548,7 +2558,7 @@ class TestCmdlineParser : public TestFixture {
                         "</rule>"
                         );
         const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' - unknown element 'messages' encountered in 'rule'.\n", logger->str());
     }
 
@@ -2562,7 +2572,7 @@ class TestCmdlineParser : public TestFixture {
                         "</rule>"
                         );
         const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' - unknown element 'pattern' encountered in 'message'.\n", logger->str());
     }
 
@@ -2574,7 +2584,7 @@ class TestCmdlineParser : public TestFixture {
                         "<pattern>.+</pattern>\n"
                         "</rule>\n");
         const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' - a rule is lacking a tokenlist.\n", logger->str());
     }
 
@@ -2586,7 +2596,7 @@ class TestCmdlineParser : public TestFixture {
                         "<pattern>.+</pattern>\n"
                         "</rule>\n");
         const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' - a rule is using the unsupported tokenlist 'simple'.\n", logger->str());
     }
 
@@ -2600,7 +2610,7 @@ class TestCmdlineParser : public TestFixture {
                         "</message>\n"
                         "</rule>\n");
         const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' - a rule is lacking an id.\n", logger->str());
     }
 
@@ -2614,7 +2624,7 @@ class TestCmdlineParser : public TestFixture {
                         "</message>\n"
                         "</rule>\n");
         const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' - a rule has an invalid severity.\n", logger->str());
     }
 
@@ -2628,14 +2638,14 @@ class TestCmdlineParser : public TestFixture {
                         "</message>\n"
                         "</rule>\n");
         const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unable to load rule-file 'rule.xml' - a rule has an invalid severity.\n", logger->str());
     }
 #else
     void ruleFileNotSupported() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--rule-file=rule.xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: Option --rule-file cannot be used as Cppcheck has not been built with rules support.\n", logger->str());
     }
 #endif
@@ -2643,7 +2653,7 @@ class TestCmdlineParser : public TestFixture {
     void library() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--library=posix", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(1, settings->libraries.size());
         ASSERT_EQUALS("posix", *settings->libraries.cbegin());
     }
@@ -2651,7 +2661,7 @@ class TestCmdlineParser : public TestFixture {
     void libraryMissing() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--library=posix2", "file.cpp"};
-        ASSERT_EQUALS(false, parser->fillSettingsFromArgs(3, argv));
+        ASSERT_EQUALS(false, fillSettingsFromArgs(argv));
         ASSERT_EQUALS(1, settings->libraries.size());
         ASSERT_EQUALS("posix2", *settings->libraries.cbegin());
         ASSERT_EQUALS("cppcheck: Failed to load library configuration file 'posix2'. File not found\n", logger->str());
@@ -2660,7 +2670,7 @@ class TestCmdlineParser : public TestFixture {
     void libraryMultiple() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--library=posix,gnu", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(2, settings->libraries.size());
         auto it = settings->libraries.cbegin();
         ASSERT_EQUALS("posix", *it++);
@@ -2670,14 +2680,14 @@ class TestCmdlineParser : public TestFixture {
     void libraryMultipleEmpty() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--library=posix,,gnu", "file.cpp"};
-        ASSERT_EQUALS(false, parser->fillSettingsFromArgs(3, argv));
+        ASSERT_EQUALS(false, fillSettingsFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: empty library specified.\n", logger->str());
     }
 
     void libraryMultipleEmpty2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--library=posix,gnu,", "file.cpp"};
-        ASSERT_EQUALS(false, parser->fillSettingsFromArgs(3, argv));
+        ASSERT_EQUALS(false, fillSettingsFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: empty library specified.\n", logger->str());
     }
 
@@ -2690,7 +2700,7 @@ class TestCmdlineParser : public TestFixture {
                         "</suppress>\n"
                         "</suppressions>");
         const char * const argv[] = {"cppcheck", "--suppress-xml=suppress.xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         const auto supprsNomsg = supprs->nomsg.getSuppressions();
         ASSERT_EQUALS(1, supprsNomsg.size());
         const auto it = supprsNomsg.cbegin();
@@ -2700,14 +2710,14 @@ class TestCmdlineParser : public TestFixture {
     void suppressXmlEmpty() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--suppress-xml=", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: failed to load suppressions XML '' (XML_ERROR_FILE_NOT_FOUND).\n", logger->str());
     }
 
     void suppressXmlMissing() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--suppress-xml=suppress.xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: failed to load suppressions XML 'suppress.xml' (XML_ERROR_FILE_NOT_FOUND).\n", logger->str());
     }
 
@@ -2715,7 +2725,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         ScopedFile file("suppress.xml", "");
         const char * const argv[] = {"cppcheck", "--suppress-xml=suppress.xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: failed to load suppressions XML 'suppress.xml' (XML_ERROR_EMPTY_DOCUMENT).\n", logger->str());
     }
 
@@ -2723,14 +2733,14 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         ScopedFile file("suppress.xml", "<?xml version=\"1.0\"?>");
         const char * const argv[] = {"cppcheck", "--suppress-xml=suppress.xml", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: failed to load suppressions XML 'suppress.xml' (no root node found).\n", logger->str());
     }
 
     void executorDefault() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
 #if defined(HAS_THREADING_MODEL_FORK)
         ASSERT_EQUALS_ENUM(Settings::ExecutorType::Process, settings->executor);
 #elif defined(HAS_THREADING_MODEL_THREAD)
@@ -2741,7 +2751,7 @@ class TestCmdlineParser : public TestFixture {
     void executorAuto() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-j2", "--executor=auto", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
 #if defined(HAS_THREADING_MODEL_FORK)
         ASSERT_EQUALS_ENUM(Settings::ExecutorType::Process, settings->executor);
 #elif defined(HAS_THREADING_MODEL_THREAD)
@@ -2752,7 +2762,7 @@ class TestCmdlineParser : public TestFixture {
     void executorAutoNoJobs() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--executor=auto", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
 #if defined(HAS_THREADING_MODEL_FORK)
         ASSERT_EQUALS_ENUM(Settings::ExecutorType::Process, settings->executor);
 #elif defined(HAS_THREADING_MODEL_THREAD)
@@ -2764,14 +2774,14 @@ class TestCmdlineParser : public TestFixture {
     void executorThread() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-j2", "--executor=thread", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Settings::ExecutorType::Thread, settings->executor);
     }
 
     void executorThreadNoJobs() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--executor=thread", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Settings::ExecutorType::Thread, settings->executor);
         ASSERT_EQUALS("cppcheck: '--executor' has no effect as only a single job will be used.\n", logger->str());
     }
@@ -2779,7 +2789,7 @@ class TestCmdlineParser : public TestFixture {
     void executorThreadNotSupported() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-j2", "--executor=thread", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: executor type 'thread' cannot be used as Cppcheck has not been built with a respective threading model.\n", logger->str());
     }
 #endif
@@ -2788,14 +2798,14 @@ class TestCmdlineParser : public TestFixture {
     void executorProcess() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-j2", "--executor=process", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Settings::ExecutorType::Process, settings->executor);
     }
 
     void executorProcessNoJobs() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--executor=process", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Settings::ExecutorType::Process, settings->executor);
         ASSERT_EQUALS("cppcheck: '--executor' has no effect as only a single job will be used.\n", logger->str());
     }
@@ -2803,7 +2813,7 @@ class TestCmdlineParser : public TestFixture {
     void executorProcessNotSupported() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-j2", "--executor=process", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: executor type 'process' cannot be used as Cppcheck has not been built with a respective threading model.\n", logger->str());
     }
 #endif
@@ -2812,7 +2822,7 @@ class TestCmdlineParser : public TestFixture {
     void checkLevelDefault() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Settings::CheckLevel::normal, settings->checkLevel);
         ASSERT_EQUALS(100, settings->vfOptions.maxIfCount);
         ASSERT_EQUALS(8, settings->vfOptions.maxSubFunctionArgs);
@@ -2823,7 +2833,7 @@ class TestCmdlineParser : public TestFixture {
     void checkLevelNormal() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--check-level=normal", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Settings::CheckLevel::normal, settings->checkLevel);
         ASSERT_EQUALS(100, settings->vfOptions.maxIfCount);
         ASSERT_EQUALS(8, settings->vfOptions.maxSubFunctionArgs);
@@ -2834,7 +2844,7 @@ class TestCmdlineParser : public TestFixture {
     void checkLevelExhaustive() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--check-level=exhaustive", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(Settings::CheckLevel::exhaustive, settings->checkLevel);
         ASSERT_EQUALS(-1, settings->vfOptions.maxIfCount);
         ASSERT_EQUALS(256, settings->vfOptions.maxSubFunctionArgs);
@@ -2845,42 +2855,42 @@ class TestCmdlineParser : public TestFixture {
     void checkLevelUnknown() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--check-level=default", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unknown '--check-level' value 'default'.\n", logger->str());
     }
 
     void cppHeaderProbe() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--cpp-header-probe", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(true, settings->cppHeaderProbe);
     }
 
     void cppHeaderProbe2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--no-cpp-header-probe", "--cpp-header-probe", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(true, settings->cppHeaderProbe);
     }
 
     void noCppHeaderProbe() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--no-cpp-header-probe", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(false, settings->cppHeaderProbe);
     }
 
     void noCppHeaderProbe2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--cpp-header-probe", "--no-cpp-header-probe", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(false, settings->cppHeaderProbe);
     }
 
     void debugLookup() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--debug-lookup", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(true, settings->debuglookup);
         GET_REDIRECT_OUTPUT; // ignore config lookup output
     }
@@ -2888,7 +2898,7 @@ class TestCmdlineParser : public TestFixture {
     void debugLookupAll() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--debug-lookup=all", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(true, settings->debuglookup);
         GET_REDIRECT_OUTPUT; // ignore config lookup output
     }
@@ -2896,14 +2906,14 @@ class TestCmdlineParser : public TestFixture {
     void debugLookupAddon() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--debug-lookup=addon", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(true, settings->debuglookupAddon);
     }
 
     void debugLookupConfig() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--debug-lookup=config", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(true, settings->debuglookupConfig);
         GET_REDIRECT_OUTPUT; // ignore config lookup output
     }
@@ -2911,63 +2921,63 @@ class TestCmdlineParser : public TestFixture {
     void debugLookupLibrary() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--debug-lookup=library", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(true, settings->debuglookupLibrary);
     }
 
     void debugLookupPlatform() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--debug-lookup=platform", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(true, settings->debuglookupPlatform);
     }
 
     void maxTemplateRecursion() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--max-template-recursion=12", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(12, settings->maxTemplateRecursion);
     }
 
     void maxTemplateRecursionMissingCount() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--max-template-recursion=", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '--max-template-recursion=' is not valid - not an integer.\n", logger->str());
     }
 
     void emitDuplicates() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--emit-duplicates", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(true, settings->emitDuplicates);
     }
 
     void debugClangOutput() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--debug-clang-output", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(true, settings->debugClangOutput);
     }
 
     void debugXmlMultiple() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--debug", "--xml", "1.cpp", "2.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(5, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: printing debug output in XML format does not support multiple input files.\n", logger->str());
     }
 
     void debugNormalXmlMultiple() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--debug-normal", "--xml", "1.cpp", "2.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(5, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: printing debug output in XML format does not support multiple input files.\n", logger->str());
     }
 
     void ignorepaths1() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-isrc", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(1, parser->getIgnoredPaths().size());
         ASSERT_EQUALS("src", parser->getIgnoredPaths()[0]);
     }
@@ -2975,7 +2985,7 @@ class TestCmdlineParser : public TestFixture {
     void ignorepaths2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-i", "src", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(1, parser->getIgnoredPaths().size());
         ASSERT_EQUALS("src", parser->getIgnoredPaths()[0]);
     }
@@ -2983,7 +2993,7 @@ class TestCmdlineParser : public TestFixture {
     void ignorepaths3() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-isrc", "-imodule", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(2, parser->getIgnoredPaths().size());
         ASSERT_EQUALS("src", parser->getIgnoredPaths()[0]);
         ASSERT_EQUALS("module", parser->getIgnoredPaths()[1]);
@@ -2992,7 +3002,7 @@ class TestCmdlineParser : public TestFixture {
     void ignorepaths4() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-i", "src", "-i", "module", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(6, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(2, parser->getIgnoredPaths().size());
         ASSERT_EQUALS("src", parser->getIgnoredPaths()[0]);
         ASSERT_EQUALS("module", parser->getIgnoredPaths()[1]);
@@ -3001,7 +3011,7 @@ class TestCmdlineParser : public TestFixture {
     void ignorefilepaths1() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-ifoo.cpp", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(1, parser->getIgnoredPaths().size());
         ASSERT_EQUALS("foo.cpp", parser->getIgnoredPaths()[0]);
     }
@@ -3009,7 +3019,7 @@ class TestCmdlineParser : public TestFixture {
     void ignorefilepaths2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-isrc/foo.cpp", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(1, parser->getIgnoredPaths().size());
         ASSERT_EQUALS("src/foo.cpp", parser->getIgnoredPaths()[0]);
     }
@@ -3017,7 +3027,7 @@ class TestCmdlineParser : public TestFixture {
     void ignorefilepaths3() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-i", "foo.cpp", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(1, parser->getIgnoredPaths().size());
         ASSERT_EQUALS("foo.cpp", parser->getIgnoredPaths()[0]);
     }
@@ -3025,28 +3035,28 @@ class TestCmdlineParser : public TestFixture {
     void nonexistentpath() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "file.cpp"};
-        ASSERT(!parser->fillSettingsFromArgs(2, argv));
+        ASSERT(!fillSettingsFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: could not find or open any of the paths given.\n", logger->str());
     }
 
     void checkconfig() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--check-config", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(true, settings->checkConfiguration);
     }
 
     void unknownParam() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--foo", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: unrecognized command line option: \"--foo\".\n", logger->str());
     }
 
     void undefs() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-U_WIN32", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(1, settings->userUndefs.size());
         ASSERT(settings->userUndefs.find("_WIN32") != settings->userUndefs.end());
     }
@@ -3054,7 +3064,7 @@ class TestCmdlineParser : public TestFixture {
     void undefs2() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-U_WIN32", "-UNODEBUG", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(2, settings->userUndefs.size());
         ASSERT(settings->userUndefs.find("_WIN32") != settings->userUndefs.end());
         ASSERT(settings->userUndefs.find("NODEBUG") != settings->userUndefs.end());
@@ -3064,7 +3074,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-U"};
         // Fails since -U has no param
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '-U' is missing.\n", logger->str());
     }
 
@@ -3072,7 +3082,7 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-U", "-v", "file.cpp"};
         // Fails since -U has no param
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '-U' is missing.\n", logger->str());
     }
 
@@ -3080,35 +3090,35 @@ class TestCmdlineParser : public TestFixture {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "-U", "--quiet", "file.cpp"};
         // Fails since -U has no param
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: argument to '-U' is missing.\n", logger->str());
     }
 
     void cppcheckBuildDirExistent() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--cppcheck-build-dir=.", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(".", settings->buildDir);
     }
 
     void cppcheckBuildDirNonExistent() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--cppcheck-build-dir=non-existent-path", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: Directory 'non-existent-path' specified by --cppcheck-build-dir argument has to be existent.\n", logger->str());
     }
 
     void cppcheckBuildDirEmpty() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--cppcheck-build-dir=", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: no path has been specified for --cppcheck-build-dir\n", logger->str());
     }
 
     void cppcheckBuildDirMultiple() {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--cppcheck-build-dir=non-existent-path", "--cppcheck-build-dir=.", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS(".", settings->buildDir);
     }
 
@@ -3116,7 +3126,7 @@ class TestCmdlineParser : public TestFixture {
     {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--no-cppcheck-build-dir", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->buildDir.empty());
     }
 
@@ -3124,7 +3134,7 @@ class TestCmdlineParser : public TestFixture {
     {
         REDIRECT;
         const char * const argv[] = {"cppcheck", "--cppcheck-build-dir=b1", "--no-cppcheck-build-dir", "file.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(4, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT(settings->buildDir.empty());
     }
 
@@ -3133,70 +3143,70 @@ class TestCmdlineParser : public TestFixture {
         ScopedFile file(Path::join(Path::getPathFromFilename(Path::getCurrentExecutablePath("")), "cppcheck.cfg"),
                         "{\n");
         const char * const argv[] = {"cppcheck", "test.cpp"};
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(2, argv));
+        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 reportTypeAutosar() {
         REDIRECT;
         const char *const argv[] = { "cppcheck", "--report-type=autosar", "file.cpp" };
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(ReportType::autosar, settings->reportType);
     }
 
     void reportTypeCertCpp() {
         REDIRECT;
         const char *const argv[] = { "cppcheck", "--report-type=cert-cpp-2016", "file.cpp" };
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(ReportType::certCpp, settings->reportType);
     }
 
     void reportTypeCertC() {
         REDIRECT;
         const char *const argv[] = { "cppcheck", "--report-type=cert-c-2016", "file.cpp" };
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(ReportType::certC, settings->reportType);
     }
 
     void reportTypeMisraC2012() {
         REDIRECT;
         const char *const argv[] = { "cppcheck", "--report-type=misra-c-2012", "file.cpp" };
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(ReportType::misraC, settings->reportType);
     }
 
     void reportTypeMisraC2023() {
         REDIRECT;
         const char *const argv[] = { "cppcheck", "--report-type=misra-c-2023", "file.cpp" };
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(ReportType::misraC, settings->reportType);
     }
 
     void reportTypeMisraCpp2008() {
         REDIRECT;
         const char *const argv[] = { "cppcheck", "--report-type=misra-cpp-2008", "file.cpp" };
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(ReportType::misraCpp2008, settings->reportType);
     }
 
     void reportTypeMisraCpp2023() {
         REDIRECT;
         const char *const argv[] = { "cppcheck", "--report-type=misra-cpp-2023", "file.cpp" };
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(ReportType::misraCpp2023, settings->reportType);
     }
 
     void invalidReportType() {
         REDIRECT;
         const char *const argv[] = { "cppcheck", "--report-type=invalid", "file.cpp" };
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parser->parseFromArgs(3, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Fail, parseFromArgs(argv));
         ASSERT_EQUALS("cppcheck: error: Unknown report type 'invalid'\n", logger->str());
     }
 
     void defaultReportType() {
         REDIRECT;
         const char *const argv[] = { "cppcheck", "file.cpp" };
-        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parser->parseFromArgs(2, argv));
+        ASSERT_EQUALS_ENUM(CmdLineParser::Result::Success, parseFromArgs(argv));
         ASSERT_EQUALS_ENUM(ReportType::normal, settings->reportType);
     }
 };
diff --git a/test/testcondition.cpp b/test/testcondition.cpp
index 8655092c69d..fd1e7e8563e 100644
--- a/test/testcondition.cpp
+++ b/test/testcondition.cpp
@@ -42,7 +42,7 @@ class TestCondition : public TestFixture {
                            "<def>\n"
                            "  <function name=\"bar\"> <pure/> </function>\n"
                            "</def>";
-        settings1 = settingsBuilder(settings1).libraryxml(cfg, sizeof(cfg)).build();
+        settings1 = settingsBuilder(settings1).libraryxml(cfg).build();
 
         TEST_CASE(assignAndCompare);   // assignment and comparison don't match
         TEST_CASE(mismatchingBitAnd);  // overlapping bitmasks
diff --git a/test/testcppcheck.cpp b/test/testcppcheck.cpp
index 3860ea6b316..2493eb08d7b 100644
--- a/test/testcppcheck.cpp
+++ b/test/testcppcheck.cpp
@@ -158,7 +158,7 @@ class TestCppcheck : public TestFixture {
                         "}");
 
         const char xmldata[] = R"(<def format="2"><markup ext=".cpp" reporterrors="false"/></def>)";
-        const Settings s = settingsBuilder().libraryxml(xmldata, sizeof(xmldata)).build();
+        const Settings s = settingsBuilder().libraryxml(xmldata).build();
         Suppressions supprs;
         ErrorLogger2 errorLogger;
         CppCheck cppcheck(s, supprs, errorLogger, false, {});
diff --git a/test/testfunctions.cpp b/test/testfunctions.cpp
index c1c69b18d62..7e103b7ebf3 100644
--- a/test/testfunctions.cpp
+++ b/test/testfunctions.cpp
@@ -1324,7 +1324,7 @@ class TestFunctions : public TestFixture {
                                    "    <arg nr=\"2\"/>\n"
                                    "  </function>\n"
                                    "</def>";
-        const Settings settings2 = settingsBuilder().severity(Severity::warning).libraryxml(xmldata, sizeof(xmldata)).build();
+        const Settings settings2 = settingsBuilder().severity(Severity::warning).libraryxml(xmldata).build();
 
         check("void foo() {\n"
               "  mystrcmp(a, b);\n"
@@ -1485,7 +1485,7 @@ class TestFunctions : public TestFixture {
                                "    <arg nr=\"2\"/>\n"
                                "  </function>\n"
                                "</def>";
-        const Settings settings2 = settingsBuilder().severity(Severity::style).libraryxml(xmldata, sizeof(xmldata)).build();
+        const Settings settings2 = settingsBuilder().severity(Severity::style).libraryxml(xmldata).build();
 
         check("void foo() {\n"
               "  mystrcmp(a, b);\n"
diff --git a/test/testleakautovar.cpp b/test/testleakautovar.cpp
index 7838679d6dd..02ef1b57289 100644
--- a/test/testleakautovar.cpp
+++ b/test/testleakautovar.cpp
@@ -3126,7 +3126,7 @@ class TestLeakAutoVar : public TestFixture {
                                    "    </arg>\n"
                                    "  </function>\n"
                                    "</def>";
-        const Settings settingsFunctionCall = settingsBuilder(settings).libraryxml(xmldata, sizeof(xmldata)).build();
+        const Settings settingsFunctionCall = settingsBuilder(settings).libraryxml(xmldata).build();
 
         check("void test_func()\n"
               "{\n"
@@ -3159,7 +3159,7 @@ class TestLeakAutoVar : public TestFixture {
                                    "    <arg nr=\"1\" direction=\"in\"/>\n"
                                    "  </function>\n"
                                    "</def>\n";
-        const Settings settingsLeakIgnore = settingsBuilder().libraryxml(xmldata, sizeof(xmldata)).build();
+        const Settings settingsLeakIgnore = settingsBuilder().libraryxml(xmldata).build();
         check("void f() {\n"
               "    double* a = new double[1024];\n"
               "    SomeClass::someMethod(a);\n"
diff --git a/test/testoptions.cpp b/test/testoptions.cpp
index f6baeb870e1..beb34fd2fc1 100644
--- a/test/testoptions.cpp
+++ b/test/testoptions.cpp
@@ -16,8 +16,9 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "options.h"
 #include "fixture.h"
+#include "options.h"
+#include "utils.h"
 
 #include <functional>
 #include <set>
@@ -50,75 +51,75 @@ class TestOptions : public TestFixture {
 
     void which_test() const {
         const char* argv[] = {"./test_runner", "TestClass"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         ASSERT(std::set<std::string> {"TestClass"} == args.which_test());
     }
 
 
     void which_test_method() const {
         const char* argv[] = {"./test_runner", "TestClass::TestMethod"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         ASSERT(std::set<std::string> {"TestClass::TestMethod"} == args.which_test());
     }
 
 
     void no_test_method() const {
         const char* argv[] = {"./test_runner"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         ASSERT(std::set<std::string> {""} == args.which_test());
     }
 
 
     void not_quiet() const {
         const char* argv[] = {"./test_runner", "TestClass::TestMethod", "-v"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         ASSERT_EQUALS(false, args.quiet());
     }
 
 
     void quiet() const {
         const char* argv[] = {"./test_runner", "TestClass::TestMethod", "-q"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         ASSERT_EQUALS(true, args.quiet());
     }
 
     void not_help() const {
         const char* argv[] = {"./test_runner", "TestClass::TestMethod", "-v"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         ASSERT_EQUALS(false, args.help());
     }
 
 
     void help() const {
         const char* argv[] = {"./test_runner", "TestClass::TestMethod", "-h"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         ASSERT_EQUALS(true, args.help());
     }
 
 
     void help_long() const {
         const char* argv[] = {"./test_runner", "TestClass::TestMethod", "--help"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         ASSERT_EQUALS(true, args.help());
     }
 
     void multiple_testcases() const {
         const char* argv[] = {"./test_runner", "TestClass::TestMethod", "TestClass::AnotherTestMethod"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         std::set<std::string> expected {"TestClass::TestMethod", "TestClass::AnotherTestMethod"};
         ASSERT(expected == args.which_test());
     }
 
     void multiple_testcases_ignore_duplicates() const {
         const char* argv[] = {"./test_runner", "TestClass::TestMethod", "TestClass"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         std::set<std::string> expected {"TestClass"};
         ASSERT(expected == args.which_test());
     }
 
     void invalid_switches() const {
         const char* argv[] = {"./test_runner", "TestClass::TestMethod", "-a", "-v", "-q"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         std::set<std::string> expected {"TestClass::TestMethod"};
         ASSERT(expected == args.which_test());
         ASSERT_EQUALS(true, args.quiet());
@@ -126,13 +127,13 @@ class TestOptions : public TestFixture {
 
     void summary() const {
         const char* argv[] = {"./test_runner", "TestClass::TestMethod", "-n"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         ASSERT_EQUALS(false, args.summary());
     }
 
     void dry_run() const {
         const char* argv[] = {"./test_runner", "TestClass::TestMethod", "-d"};
-        options args(sizeof argv / sizeof argv[0], argv);
+        options args(getArrayLength(argv), argv);
         ASSERT_EQUALS(true, args.dry_run());
     }
 };
diff --git a/test/testother.cpp b/test/testother.cpp
index 816ded5d5ba..410a129ca54 100644
--- a/test/testother.cpp
+++ b/test/testother.cpp
@@ -5284,7 +5284,7 @@ class TestOther : public TestFixture {
                                    "    <arg nr=\"1\"/>\n"
                                    "  </function>\n"
                                    "</def>";
-        /*const*/ Settings settings = settingsBuilder().libraryxml(xmldata, sizeof(xmldata)).build();
+        /*const*/ Settings settings = settingsBuilder().libraryxml(xmldata).build();
 
         check("void foo() {\n"
               "    exit(0);\n"
@@ -7180,7 +7180,7 @@ class TestOther : public TestFixture {
                                    "    <arg nr=\"2\"/>\n"
                                    "  </function>\n"
                                    "</def>";
-        /*const*/ Settings settings = settingsBuilder().libraryxml(xmldata, sizeof(xmldata)).build();
+        /*const*/ Settings settings = settingsBuilder().libraryxml(xmldata).build();
 
         check("void foo() {\n"
               "    if (x() || x()) {}\n"
diff --git a/test/testprocessexecutor.cpp b/test/testprocessexecutor.cpp
index 069a74fdc58..96d74a69201 100644
--- a/test/testprocessexecutor.cpp
+++ b/test/testprocessexecutor.cpp
@@ -342,7 +342,7 @@ class TestProcessExecutorBase : public TestFixture {
         SUPPRESS;
         const Settings settingsOld = settings;
         const char xmldata[] = R"(<def format="2"><markup ext=".cpp" reporterrors="false"/></def>)";
-        settings = settingsBuilder().libraryxml(xmldata, sizeof(xmldata)).build();
+        settings = settingsBuilder().libraryxml(xmldata).build();
         check(2, 1, 0,
               "int main()\n"
               "{\n"
diff --git a/test/testsingleexecutor.cpp b/test/testsingleexecutor.cpp
index 736cd1f4d1b..a3ca9c9a6fb 100644
--- a/test/testsingleexecutor.cpp
+++ b/test/testsingleexecutor.cpp
@@ -346,7 +346,7 @@ class TestSingleExecutorBase : public TestFixture {
         SUPPRESS;
         const Settings settingsOld = settings;
         const char xmldata[] = R"(<def format="2"><markup ext=".cpp" reporterrors="false"/></def>)";
-        settings = settingsBuilder().libraryxml(xmldata, sizeof(xmldata)).build();
+        settings = settingsBuilder().libraryxml(xmldata).build();
         check(1, 0,
               "int main()\n"
               "{\n"
diff --git a/test/testsymboldatabase.cpp b/test/testsymboldatabase.cpp
index e0553ba5b37..8f5c96a916e 100644
--- a/test/testsymboldatabase.cpp
+++ b/test/testsymboldatabase.cpp
@@ -9416,7 +9416,7 @@ class TestSymbolDatabase : public TestFixture {
                                "<returnValue type=\"" #type "\"/>\n" \
                                "</function>\n" \
                                "</def>";              \
-        const Settings sF = settingsBuilder().libraryxml(xmldata, sizeof(xmldata)).build(); \
+        const Settings sF = settingsBuilder().libraryxml(xmldata).build(); \
         ASSERT_EQUALS(#type, typeOf("void f() { auto x = g(); }", "x", true, &sF)); \
 } while (false)
         // *INDENT-OFF*
@@ -9446,7 +9446,7 @@ class TestSymbolDatabase : public TestFixture {
                                        "  <podtype name=\"char16_t\" sign=\"u\" size=\"2\"/>\n"
                                        "  <podtype name=\"char32_t\" sign=\"u\" size=\"4\"/>\n"
                                        "</def>";
-            /*const*/ Settings settings = settingsBuilder().libraryxml(xmldata, sizeof(xmldata)).build();
+            /*const*/ Settings settings = settingsBuilder().libraryxml(xmldata).build();
             settings.platform.sizeof_short = 2;
             settings.platform.sizeof_int = 4;
 
@@ -9465,7 +9465,7 @@ class TestSymbolDatabase : public TestFixture {
                                        "  <podtype name=\"xyz::x\" sign=\"u\" size=\"4\"/>\n"
                                        "  <podtype name=\"podtype2\" sign=\"u\" size=\"0\" stdtype=\"int\"/>\n"
                                        "</def>";
-            const Settings settingsWin64 = settingsBuilder().platform(Platform::Type::Win64).libraryxml(xmldata, sizeof(xmldata)).build();
+            const Settings settingsWin64 = settingsBuilder().platform(Platform::Type::Win64).libraryxml(xmldata).build();
             ValueType vt;
             ASSERT_EQUALS(true, vt.fromLibraryType("u32", settingsWin64));
             ASSERT_EQUALS(true, vt.fromLibraryType("xyz::x", settingsWin64));
@@ -9487,7 +9487,7 @@ class TestSymbolDatabase : public TestFixture {
                                        "    <platform type=\"unix32\"/>\n"
                                        "  </platformtype>\n"
                                        "</def>";
-            const Settings settingsUnix32 = settingsBuilder().platform(Platform::Type::Unix32).libraryxml(xmldata, sizeof(xmldata)).build();
+            const Settings settingsUnix32 = settingsBuilder().platform(Platform::Type::Unix32).libraryxml(xmldata).build();
             ValueType vt;
             ASSERT_EQUALS(true, vt.fromLibraryType("s32", settingsUnix32));
             ASSERT_EQUALS(ValueType::Type::INT, vt.type);
@@ -9500,7 +9500,7 @@ class TestSymbolDatabase : public TestFixture {
                                        "    <platform type=\"win64\"/>\n"
                                        "  </platformtype>\n"
                                        "</def>";
-            const Settings settingsWin64 = settingsBuilder().platform(Platform::Type::Win64).libraryxml(xmldata, sizeof(xmldata)).build();
+            const Settings settingsWin64 = settingsBuilder().platform(Platform::Type::Win64).libraryxml(xmldata).build();
             ValueType vt;
             ASSERT_EQUALS(true, vt.fromLibraryType("LPCTSTR", settingsWin64));
             ASSERT_EQUALS(ValueType::Type::WCHAR_T, vt.type);
@@ -9511,7 +9511,7 @@ class TestSymbolDatabase : public TestFixture {
                                        "<def>\n"
                                        "  <container id=\"C\" startPattern=\"C\"/>\n"
                                        "</def>";
-            const Settings sC = settingsBuilder().libraryxml(xmldata, sizeof(xmldata)).build();
+            const Settings sC = settingsBuilder().libraryxml(xmldata).build();
             ASSERT_EQUALS("container(C) *", typeOf("C*c=new C;","new",true,&sC));
             ASSERT_EQUALS("container(C) *", typeOf("x=(C*)c;","(",true,&sC));
             ASSERT_EQUALS("container(C)", typeOf("C c = C();","(",true,&sC));
@@ -9533,7 +9533,7 @@ class TestSymbolDatabase : public TestFixture {
                                        "    <access indexOperator=\"array-like\"/>\n"
                                        "  </container>\n"
                                        "</def>";
-            const Settings set = settingsBuilder().libraryxml(xmldata, sizeof(xmldata)).build();
+            const Settings set = settingsBuilder().libraryxml(xmldata).build();
             ASSERT_EQUALS("signed int", typeOf("Vector<int> v; v[0]=3;", "[", true, &set));
             ASSERT_EQUALS("container(test :: string)", typeOf("{return test::string();}", "(", true, &set));
             ASSERT_EQUALS(
@@ -9599,7 +9599,7 @@ class TestSymbolDatabase : public TestFixture {
                                        "<def>\n"
                                        "  <smart-pointer class-name=\"std::shared_ptr\"/>\n"
                                        "</def>";
-            const Settings set = settingsBuilder().libraryxml(xmldata, sizeof(xmldata)).build();
+            const Settings set = settingsBuilder().libraryxml(xmldata).build();
             ASSERT_EQUALS("smart-pointer(std::shared_ptr)",
                           typeOf("class C {}; x = std::make_shared<C>();", "(", true, &set));
         }
@@ -9611,7 +9611,7 @@ class TestSymbolDatabase : public TestFixture {
                                        "<def>\n"
                                        "  <container id=\"C\" startPattern=\"C\"/>\n"
                                        "</def>";
-            const Settings sC = settingsBuilder().libraryxml(xmldata, sizeof(xmldata)).build();
+            const Settings sC = settingsBuilder().libraryxml(xmldata).build();
             ASSERT_EQUALS("container(C)", typeOf("C f(char *p) { char data[10]; return data; }", "return", true, &sC));
         }
         // Smart pointer
@@ -9620,7 +9620,7 @@ class TestSymbolDatabase : public TestFixture {
                                        "<def>\n"
                                        "  <smart-pointer class-name=\"MyPtr\"/>\n"
                                        "</def>";
-            const Settings set = settingsBuilder().libraryxml(xmldata, sizeof(xmldata)).build();
+            const Settings set = settingsBuilder().libraryxml(xmldata).build();
             ASSERT_EQUALS("smart-pointer(MyPtr)",
                           typeOf("void f() { MyPtr<int> p; return p; }", "p ;", true, &set));
             ASSERT_EQUALS("signed int", typeOf("void f() { MyPtr<int> p; return *p; }", "* p ;", true, &set));
diff --git a/test/testthreadexecutor.cpp b/test/testthreadexecutor.cpp
index 2de27ea9b97..9fa431782b5 100644
--- a/test/testthreadexecutor.cpp
+++ b/test/testthreadexecutor.cpp
@@ -340,7 +340,7 @@ class TestThreadExecutorBase : public TestFixture {
         SUPPRESS;
         const Settings settingsOld = settings;
         const char xmldata[] = R"(<def format="2"><markup ext=".cpp" reporterrors="false"/></def>)";
-        settings = settingsBuilder().libraryxml(xmldata, sizeof(xmldata)).build();
+        settings = settingsBuilder().libraryxml(xmldata).build();
         check(2, 1, 0,
               "int main()\n"
               "{\n"
diff --git a/test/testuninitvar.cpp b/test/testuninitvar.cpp
index e1046c7eb5e..0404951ce07 100644
--- a/test/testuninitvar.cpp
+++ b/test/testuninitvar.cpp
@@ -840,7 +840,7 @@ class TestUninitVar : public TestFixture {
                                        "<def format=\"1\">"
                                        "  <podtype name=\"_tm\"/>"
                                        "</def>";
-            const Settings s = settingsBuilder(settings).libraryxml(xmldata, sizeof(xmldata)).build();
+            const Settings s = settingsBuilder(settings).libraryxml(xmldata).build();
             checkUninitVar("void f() {\n"
                            "  Fred _tm;\n"
                            "  _tm.dostuff();\n"
@@ -4580,7 +4580,7 @@ class TestUninitVar : public TestFixture {
                                                         "    <arg nr=\"1\" direction=\"out\"/>\n"
                                                         "  </function>\n"
                                                         "</def>";
-            const Settings s = settingsBuilder(settings).libraryxml(argDirectionsTestXmlData, sizeof(argDirectionsTestXmlData)).build();
+            const Settings s = settingsBuilder(settings).libraryxml(argDirectionsTestXmlData).build();
 
             checkUninitVar("struct AB { int a; };\n"
                            "void f(void) {\n"
diff --git a/test/testvalueflow.cpp b/test/testvalueflow.cpp
index acc64f1f97d..be6d7d5e94d 100644
--- a/test/testvalueflow.cpp
+++ b/test/testvalueflow.cpp
@@ -53,7 +53,7 @@ class TestValueFlow : public TestFixture {
                                "  <function name=\"strcpy\"> <arg nr=\"1\"><not-null/></arg> </function>\n"
                                "  <function name=\"abort\"> <noreturn>true</noreturn> </function>\n" // abort is a noreturn function
                                "</def>";
-        settings = settingsBuilder(settings).libraryxml(cfg, sizeof(cfg)).build();
+        settings = settingsBuilder(settings).libraryxml(cfg).build();
 
         TEST_CASE(valueFlowNumber);
         TEST_CASE(valueFlowString);