added (undocumented) --no-cppcheck-build-dir command-line option to indicate that tests should not inject a build dir

Author: firewave

cli/cmdlineparser.cpp

@@ -913,6 +913,11 @@ CmdLineParser::Result CmdLineParser::parseFromArgs(int argc, const char* const a
                 mSettings.maxCtuDepth = temp;
             }
 
+            // undocumented option for usage in Python tests to indicate that no build dir should be injected
+            else if (std::strcmp(argv[i], "--no-cppcheck-build-dir") == 0) {
+                mSettings.buildDir.clear();
+            }
+
             else if (std::strcmp(argv[i], "--no-cpp-header-probe") == 0) {
                 mSettings.cppHeaderProbe = false;
             }

test/cli/testutils.py

@@ -194,7 +194,7 @@ def cppcheck_ex(args, env=None, remove_checkers_report=True, cwd=None, cppcheck_
     if 'TEST_CPPCHECK_INJECT_BUILDDIR' in os.environ:
         found_builddir = False
         for arg in args:
-            if arg.startswith('--cppcheck-build-dir='):
+            if arg.startswith('--cppcheck-build-dir=') or arg == '--no-cppcheck-build-dir':
                 found_builddir = True
                 break
         if not found_builddir:

test/cli/unused_function_test.py

@@ -3,6 +3,7 @@
 
 import os
 import json
+import pytest
 from testutils import cppcheck
 
 __script_dir = os.path.dirname(os.path.abspath(__file__))
@@ -30,185 +31,140 @@ def __create_compdb(tmpdir, projpath):
     return compile_commands
 
 
-def test_unused_functions():
-    ret, stdout, stderr = cppcheck(['-q', '--template=simple', '--enable=unusedFunction', '--inline-suppr', '-j1', __project_dir])
+def __test_unused_functions(extra_args):
+    args = ['-q', '--template=simple', '--enable=unusedFunction', '--inline-suppr', __project_dir]
+    args += extra_args
+    ret, stdout, stderr = cppcheck(args)
     assert stdout.splitlines() == []
     assert stderr.splitlines() == [
         "{}3.c:3:0: style: The function 'f3_3' is never used. [unusedFunction]".format(__project_dir_sep)
     ]
     assert ret == 0, stdout
 
 
+def test_unused_functions():
+    __test_unused_functions(['-j1', '--no-cppcheck-build-dir'])
+
+
 def test_unused_functions_j():
-    ret, stdout, stderr = cppcheck(['-q', '--template=simple', '--enable=unusedFunction', '--inline-suppr', '-j2', __project_dir])
+    ret, stdout, stderr = cppcheck(['-q', '--template=simple', '--enable=unusedFunction', '--inline-suppr', '-j2', '--no-cppcheck-build-dir', __project_dir])
     assert stdout.splitlines() == [
         "cppcheck: unusedFunction check requires --cppcheck-build-dir to be active with -j."
     ]
     assert stderr.splitlines() == []
     assert ret == 0, stdout
 
 
-def test_unused_functions_project():
-    ret, stdout, stderr = cppcheck(['-q',
-                                    '--template=simple',
-                                    '--enable=unusedFunction',
-                                    '--inline-suppr',
-                                    '--project={}'.format(os.path.join(__project_dir, 'unusedFunction.cppcheck')),
-                                    '-j1'])
+def test_unused_functions_builddir(tmpdir):
+    build_dir = os.path.join(tmpdir, 'b1')
+    os.mkdir(build_dir)
+    __test_unused_functions(['-j1', '--cppcheck-build-dir={}'.format(build_dir)])
+
+
+@pytest.mark.xfail(strict=True)
+def test_unused_functions_builddir_j(tmpdir):
+    build_dir = os.path.join(tmpdir, 'b1')
+    os.mkdir(build_dir)
+    __test_unused_functions(['-j2', '--cppcheck-build-dir={}'.format(build_dir)])
+
+def __test_unused_functions_project(extra_args):
+    project_file = os.path.join(__project_dir, 'unusedFunction.cppcheck')
+    args = ['-q',
+            '--template=simple',
+            '--enable=unusedFunction',
+            '--inline-suppr',
+            '--project={}'.format(project_file),
+            ]
+    args += extra_args
+    ret, stdout, stderr = cppcheck(args)
     assert stdout.splitlines() == []
     assert [
         "{}3.c:3:0: style: The function 'f3_3' is never used. [unusedFunction]".format(__project_dir_sep)
     ] == stderr.splitlines()
     assert ret == 0, stdout
 
 
-def test_unused_functions_project_j():
-    ret, stdout, stderr = cppcheck(['-q',
-                                    '--template=simple',
-                                    '--enable=unusedFunction',
-                                    '--inline-suppr',
-                                    '--project={}'.format(os.path.join(__project_dir, 'unusedFunction.cppcheck')),
-                                    '-j2'])
-    assert stdout.splitlines() == [
-        "cppcheck: unusedFunction check requires --cppcheck-build-dir to be active with -j."
-    ]
-    assert [] == stderr.splitlines()
-    assert ret == 0, stdout
-
-
-def test_unused_functions_compdb(tmpdir):
-    compdb_file = __create_compdb(tmpdir, __project_dir)
-    ret, stdout, stderr = cppcheck(['-q',
-                                    '--template=simple',
-                                    '--enable=unusedFunction',
-                                    '--inline-suppr',
-                                    '--project={}'.format(compdb_file),
-                                    '-j1'
-                                    ])
-    assert stdout.splitlines() == []
-    assert stderr.splitlines() == [
-        "{}3.c:3:0: style: The function 'f3_3' is never used. [unusedFunction]".format(__project_dir_sep)
-    ]
-    assert ret == 0, stdout
+def test_unused_functions_project():
+    __test_unused_functions_project(['-j1', '--no-cppcheck-build-dir'])
 
 
-def test_unused_functions_compdb_j(tmpdir):
-    compdb_file = __create_compdb(tmpdir, __project_dir)
+def test_unused_functions_project_j():
+    project_file = os.path.join(__project_dir, 'unusedFunction.cppcheck')
     ret, stdout, stderr = cppcheck(['-q',
                                     '--template=simple',
                                     '--enable=unusedFunction',
                                     '--inline-suppr',
-                                    '--project={}'.format(compdb_file),
-                                    '-j2'
+                                    '--project={}'.format(project_file),
+                                    '-j2',
+                                    '--no-cppcheck-build-dir'
                                     ])
     assert stdout.splitlines() == [
         "cppcheck: unusedFunction check requires --cppcheck-build-dir to be active with -j."
     ]
-    assert stderr.splitlines() == []
+    assert [] == stderr.splitlines()
     assert ret == 0, stdout
 
 
-def test_unused_functions_builddir(tmpdir):
+def test_unused_functions_project_builddir(tmpdir):
     build_dir = os.path.join(tmpdir, 'b1')
     os.mkdir(build_dir)
-    ret, stdout, stderr = cppcheck(['-q', '--template=simple', '--enable=unusedFunction', '--inline-suppr', '-j1', '--cppcheck-build-dir={}'.format(build_dir), __project_dir])
-    assert stdout.splitlines() == []
-    assert stderr.splitlines() == [
-        "{}3.c:3:0: style: The function 'f3_3' is never used. [unusedFunction]".format(__project_dir_sep)
-    ]
-    assert ret == 0, stdout
+    __test_unused_functions_project(['-j1', '--cppcheck-build-dir={}'.format(build_dir)])
 
 
-# TODO: only f3_3 is unused
-def test_unused_functions_builddir_j(tmpdir):
+@pytest.mark.xfail(strict=True)
+def test_unused_functions_project_builddir_j(tmpdir):
     build_dir = os.path.join(tmpdir, 'b1')
     os.mkdir(build_dir)
-    ret, stdout, stderr = cppcheck(['-q', '--template=simple', '--enable=unusedFunction', '--inline-suppr', '-j2', '--cppcheck-build-dir={}'.format(build_dir), __project_dir])
-    assert stdout.splitlines() == []
-    assert stderr.splitlines() == [
-        "{}1.c:4:0: style: The function 'f1' is never used. [unusedFunction]".format(__project_dir_sep),
-        "{}2.c:4:0: style: The function 'f2' is never used. [unusedFunction]".format(__project_dir_sep),
-        "{}3.c:3:0: style: The function 'f3_3' is never used. [unusedFunction]".format(__project_dir_sep),
-        "{}4.c:4:0: style: The function 'f4_1' is never used. [unusedFunction]".format(__project_dir_sep)
-    ]
-    assert ret == 0, stdout
+    __test_unused_functions_project(['-j2', '--cppcheck-build-dir={}'.format(build_dir)])
 
 
-def test_unused_functions_builddir_project(tmpdir):
-    build_dir = os.path.join(tmpdir, 'b1')
-    os.mkdir(build_dir)
-    ret, stdout, stderr = cppcheck(['-q',
-                                    '--template=simple',
-                                    '--enable=unusedFunction',
-                                    '--inline-suppr',
-                                    '--project={}'.format(os.path.join(__project_dir, 'unusedFunction.cppcheck')),
-                                    '--cppcheck-build-dir={}'.format(build_dir),
-                                    '-j1'])
+def __test_unused_functions_compdb(tmpdir, extra_args):
+    compdb_file = __create_compdb(tmpdir, __project_dir)
+    args = ['-q',
+            '--template=simple',
+            '--enable=unusedFunction',
+            '--inline-suppr',
+            '--project={}'.format(compdb_file),
+            '-j1'
+            ]
+    args += extra_args
+    ret, stdout, stderr = cppcheck(args)
     assert stdout.splitlines() == []
     assert stderr.splitlines() == [
         "{}3.c:3:0: style: The function 'f3_3' is never used. [unusedFunction]".format(__project_dir_sep)
     ]
     assert ret == 0, stdout
 
 
-# TODO: only f3_3 is unused
-def test_unused_functions_builddir_project_j(tmpdir):
-    build_dir = os.path.join(tmpdir, 'b1')
-    os.mkdir(build_dir)
-    ret, stdout, stderr = cppcheck(['-q',
-                                    '--template=simple',
-                                    '--enable=unusedFunction',
-                                    '--inline-suppr',
-                                    '--project={}'.format(os.path.join(__project_dir, 'unusedFunction.cppcheck')),
-                                    '--cppcheck-build-dir={}'.format(build_dir),
-                                    '-j2'])
-    assert stdout.splitlines() == []
-    assert stderr.splitlines() == [
-        "{}1.c:4:0: style: The function 'f1' is never used. [unusedFunction]".format(__project_dir_sep),
-        "{}2.c:4:0: style: The function 'f2' is never used. [unusedFunction]".format(__project_dir_sep),
-        "{}3.c:3:0: style: The function 'f3_3' is never used. [unusedFunction]".format(__project_dir_sep),
-        "{}4.c:4:0: style: The function 'f4_1' is never used. [unusedFunction]".format(__project_dir_sep)
-    ]
-    assert ret == 0, stdout
+def test_unused_functions_compdb(tmpdir):
+    __test_unused_functions_compdb(tmpdir, ['-j1', '--no-cppcheck-build-dir'])
 
 
-def test_unused_functions_builddir_compdb(tmpdir):
+def test_unused_functions_compdb_j(tmpdir):
     compdb_file = __create_compdb(tmpdir, __project_dir)
-    build_dir = os.path.join(tmpdir, 'b1')
-    os.mkdir(build_dir)
     ret, stdout, stderr = cppcheck(['-q',
                                     '--template=simple',
                                     '--enable=unusedFunction',
                                     '--inline-suppr',
                                     '--project={}'.format(compdb_file),
-                                    '--cppcheck-build-dir={}'.format(build_dir),
-                                    '-j1'
+                                    '-j2',
+                                    '--no-cppcheck-build-dir'
                                     ])
-    assert stdout.splitlines() == []
-    assert stderr.splitlines() == [
-        "{}3.c:3:0: style: The function 'f3_3' is never used. [unusedFunction]".format(__project_dir_sep)
+    assert stdout.splitlines() == [
+        "cppcheck: unusedFunction check requires --cppcheck-build-dir to be active with -j."
     ]
+    assert stderr.splitlines() == []
     assert ret == 0, stdout
 
 
-# TODO: only f3_3 is unused
-def test_unused_functions_builddir_compdb_j(tmpdir):
-    compdb_file = __create_compdb(tmpdir, __project_dir)
+def test_unused_functions_compdb_builddir(tmpdir):
     build_dir = os.path.join(tmpdir, 'b1')
     os.mkdir(build_dir)
-    ret, stdout, stderr = cppcheck(['-q',
-                                    '--template=simple',
-                                    '--enable=unusedFunction',
-                                    '--inline-suppr',
-                                    '--project={}'.format(compdb_file),
-                                    '--cppcheck-build-dir={}'.format(build_dir),
-                                    '-j2'
-                                    ])
-    assert stdout.splitlines() == []
-    assert stderr.splitlines() == [
-        "{}1.c:4:0: style: The function 'f1' is never used. [unusedFunction]".format(__project_dir_sep),
-        "{}2.c:4:0: style: The function 'f2' is never used. [unusedFunction]".format(__project_dir_sep),
-        "{}3.c:3:0: style: The function 'f3_3' is never used. [unusedFunction]".format(__project_dir_sep),
-        "{}4.c:4:0: style: The function 'f4_1' is never used. [unusedFunction]".format(__project_dir_sep)
-    ]
-    assert ret == 0, stdout
+    __test_unused_functions_compdb(tmpdir, ['-j1', '--cppcheck-build-dir={}'.format(build_dir)])
+
+
+@pytest.mark.xfail(strict=True)
+def test_unused_functions_compdb_buildir_j(tmpdir):
+    build_dir = os.path.join(tmpdir, 'b1')
+    os.mkdir(build_dir)
+    __test_unused_functions_compdb(tmpdir, ['-j2', '--cppcheck-build-dir={}'.format(build_dir)])

test/testcmdlineparser.cpp

@@ -436,6 +436,7 @@ class TestCmdlineParser : public TestFixture {
         TEST_CASE(cppcheckBuildDirExistent);
         TEST_CASE(cppcheckBuildDirNonExistent);
         TEST_CASE(cppcheckBuildDirEmpty);
+        // TODO: test --no-cppcheck-build-dir
 
         TEST_CASE(invalidCppcheckCfg);
     }