pytest-cppcheck 0.1.0__tar.gz

pytest_cppcheck-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: pytest-cppcheck
+Version: 0.1.0
+Summary: A pytest plugin that runs cppcheck static analysis on C/C++ source files
+Classifier: Framework :: Pytest
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Requires-Dist: pytest>=7.0
+Requires-Dist: cppcheck>=1.4.0

pytest_cppcheck-0.1.0/README.md

@@ -0,0 +1,97 @@
+# pytest-cppcheck
+
+A pytest plugin that runs [cppcheck](https://cppcheck.sourceforge.io/) static
+analysis on C/C++ source files. Each file is collected as a test item and
+reported as a pass or failure in the normal pytest output.
+
+Useful for Python projects with C extension modules where you already run pytest
+and want cppcheck findings surfaced in the same test run.
+
+## Installation
+
+```
+pip install pytest-cppcheck
+```
+
+This pulls in cppcheck automatically via the
+[cppcheck](https://pypi.org/project/cppcheck/) PyPI package. If you prefer a
+specific version, install cppcheck yourself via your system package manager
+(`apt install cppcheck`, `brew install cppcheck`, etc.) — the plugin uses
+whichever `cppcheck` is on PATH.
+
+## Usage
+
+The plugin does nothing unless explicitly enabled:
+
+```
+pytest --cppcheck
+```
+
+This collects all `.c` and `.cpp` files and runs cppcheck on each one.
+Files with findings fail; clean files pass.
+
+```
+PASSED src/clean.c::CPPCHECK
+FAILED src/buggy.c::CPPCHECK
+  src/buggy.c:42:8: error: Array 'arr[10]' accessed at index 10, which is
+  out of bounds. [arrayIndexOutOfBounds]
+```
+
+You can combine `--cppcheck` with your normal test run — Python tests and
+cppcheck items appear together in the results.
+
+## Configuration
+
+All options go in `pyproject.toml`, `pytest.ini`, or `setup.cfg` under `[pytest]`.
+
+### `cppcheck_args`
+
+Extra arguments forwarded to every cppcheck invocation. This is the main
+configuration surface — use it for `--enable`, `--suppress`, and any other
+cppcheck flags. The plugin always passes `--quiet` and `--error-exitcode=1`
+automatically.
+
+With no `cppcheck_args`, cppcheck runs its default checks (mostly
+error-severity). Use `--enable` to broaden coverage. A good starting
+configuration:
+
+```ini
+[pytest]
+cppcheck_args =
+    --enable=warning,style,performance,portability
+    --suppress=missingIncludeSystem
+    --suppress=normalCheckLevelMaxBranches
+```
+
+`missingIncludeSystem` suppresses noise about system headers that aren't
+available to cppcheck. `normalCheckLevelMaxBranches` suppresses an
+informational message that cppcheck emits on complex files and that would
+otherwise be reported as a failure.
+
+### `cppcheck_extensions`
+
+File extensions to collect. Default: `.c .cpp`.
+
+```ini
+[pytest]
+cppcheck_extensions = .c .cpp .h
+```
+
+## Caching
+
+Results are cached based on file modification time and `cppcheck_args`. On
+subsequent runs, files that previously passed are skipped. The cache is
+automatically invalidated when a file is modified or `cppcheck_args` changes.
+Caching relies on pytest's built-in cache provider (the `.pytest_cache` directory).
+If the cache provider is disabled (for example with `-p no:cacheprovider`), results
+will not be cached and all files will be re-checked on each run.
+
+To force a full re-check:
+
+```
+pytest --cppcheck --cache-clear
+```
+
+## License
+
+MIT

pytest_cppcheck-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pytest-cppcheck"
+version = "0.1.0"
+description = "A pytest plugin that runs cppcheck static analysis on C/C++ source files"
+requires-python = ">=3.8"
+dependencies = [
+    "pytest>=7.0",
+    "cppcheck>=1.4.0",
+]
+classifiers = [
+    "Framework :: Pytest",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+]
+
+[project.entry-points."pytest11"]
+cppcheck = "pytest_cppcheck.plugin"
+
+[tool.setuptools.packages.find]
+where = ["src"]

pytest_cppcheck-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pytest_cppcheck-0.1.0/src/pytest_cppcheck/plugin.py

@@ -0,0 +1,98 @@
+import subprocess
+
+import pytest
+from cppcheck import get_cppcheck_dir
+
+CPPCHECK_BIN = str(get_cppcheck_dir() / "cppcheck")
+CACHE_KEY = "cppcheck/mtimes"
+
+
+def pytest_addoption(parser):
+    group = parser.getgroup("cppcheck", "cppcheck static analysis")
+    group.addoption(
+        "--cppcheck",
+        action="store_true",
+        default=False,
+        help="run cppcheck on C/C++ source files",
+    )
+    parser.addini(
+        "cppcheck_extensions",
+        type="args",
+        default=[".c", ".cpp"],
+        help="file extensions to collect for cppcheck (default: .c .cpp)",
+    )
+    parser.addini(
+        "cppcheck_args",
+        type="args",
+        default=[],
+        help="extra arguments forwarded to every cppcheck invocation",
+    )
+
+
+def pytest_configure(config):
+    if not config.getoption("cppcheck"):
+        return
+    cache = getattr(config, "cache", None)
+    config._cppcheck_mtimes = cache.get(CACHE_KEY, {}) if cache else {}
+
+
+def pytest_unconfigure(config):
+    mtimes = getattr(config, "_cppcheck_mtimes", None)
+    if mtimes is None:
+        return
+    cache = getattr(config, "cache", None)
+    if cache:
+        cache.set(CACHE_KEY, mtimes)
+
+
+def pytest_collect_file(parent, file_path):
+    if not parent.config.getoption("cppcheck"):
+        return None
+    extensions = parent.config.getini("cppcheck_extensions")
+    if file_path.suffix in extensions:
+        return CppcheckFile.from_parent(parent, path=file_path)
+    return None
+
+
+class CppcheckError(Exception):
+    pass
+
+
+class CppcheckFile(pytest.File):
+    def collect(self):
+        yield CppcheckItem.from_parent(self, name="CPPCHECK")
+
+
+class CppcheckItem(pytest.Item):
+    def setup(self):
+        mtimes = getattr(self.config, "_cppcheck_mtimes", {})
+        self._mtime = self.path.stat().st_mtime_ns
+        args = self.config.getini("cppcheck_args")
+        old = mtimes.get(str(self.path))
+        if old == [self._mtime, args]:
+            pytest.skip("previously passed cppcheck")
+
+    def runtest(self):
+        args = self.config.getini("cppcheck_args")
+        cmd = [CPPCHECK_BIN, "--quiet", "--error-exitcode=1"] + args + [str(self.path)]
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        if result.returncode != 0:
+            output = result.stderr or result.stdout
+            if not output:
+                output = f"cppcheck exited with code {result.returncode}"
+            raise CppcheckError(output)
+        # Cache only on success
+        if hasattr(self.config, "_cppcheck_mtimes"):
+            self._mtime = getattr(self, "_mtime", self.path.stat().st_mtime_ns)
+            self.config._cppcheck_mtimes[str(self.path)] = [
+                self._mtime,
+                args,
+            ]
+
+    def repr_failure(self, excinfo):
+        if excinfo.errisinstance(CppcheckError):
+            return str(excinfo.value)
+        return super().repr_failure(excinfo)
+
+    def reportinfo(self):
+        return self.path, None, f"{self.path}::CPPCHECK"

pytest_cppcheck-0.1.0/src/pytest_cppcheck.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: pytest-cppcheck
+Version: 0.1.0
+Summary: A pytest plugin that runs cppcheck static analysis on C/C++ source files
+Classifier: Framework :: Pytest
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Requires-Dist: pytest>=7.0
+Requires-Dist: cppcheck>=1.4.0

pytest_cppcheck-0.1.0/src/pytest_cppcheck.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+src/pytest_cppcheck/__init__.py
+src/pytest_cppcheck/plugin.py
+src/pytest_cppcheck.egg-info/PKG-INFO
+src/pytest_cppcheck.egg-info/SOURCES.txt
+src/pytest_cppcheck.egg-info/dependency_links.txt
+src/pytest_cppcheck.egg-info/entry_points.txt
+src/pytest_cppcheck.egg-info/requires.txt
+src/pytest_cppcheck.egg-info/top_level.txt
+tests/test_plugin.py

pytest_cppcheck-0.1.0/src/pytest_cppcheck.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pytest_cppcheck-0.1.0/src/pytest_cppcheck.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+cppcheck = pytest_cppcheck.plugin

pytest_cppcheck-0.1.0/src/pytest_cppcheck.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pytest>=7.0
+cppcheck>=1.4.0

pytest_cppcheck-0.1.0/src/pytest_cppcheck.egg-info/top_level.txt

@@ -0,0 +1 @@
+pytest_cppcheck

pytest_cppcheck-0.1.0/tests/test_plugin.py

@@ -0,0 +1,149 @@
+"""Tests for pytest-cppcheck using pytester."""
+
+# C source with an out-of-bounds access that cppcheck detects.
+C_ERROR = """\
+#include <stdlib.h>
+int main() {
+    int arr[10];
+    arr[10] = 0;
+    return 0;
+}
+"""
+
+# C source with no issues.
+C_CLEAN = """\
+int main() {
+    return 0;
+}
+"""
+
+
+def test_clean_file_passes(pytester):
+    pytester.makefile(".c", clean=C_CLEAN)
+    result = pytester.runpytest("--cppcheck", "-v")
+    result.stdout.fnmatch_lines(["*PASSED*"])
+    result.assert_outcomes(passed=1)
+
+
+def test_error_file_fails(pytester):
+    pytester.makeini(
+        "[pytest]\n"
+        "cppcheck_args = --enable=warning\n"
+    )
+    pytester.makefile(".c", bad=C_ERROR)
+    result = pytester.runpytest("--cppcheck")
+    result.assert_outcomes(failed=1)
+
+
+def test_stderr_in_failure_output(pytester):
+    pytester.makeini(
+        "[pytest]\n"
+        "cppcheck_args = --enable=warning\n"
+    )
+    pytester.makefile(".c", bad=C_ERROR)
+    result = pytester.runpytest("--cppcheck")
+    result.stdout.fnmatch_lines(["*arrayIndexOutOfBounds*"])
+
+
+def test_not_collected_without_flag(pytester):
+    pytester.makefile(".c", clean=C_CLEAN)
+    result = pytester.runpytest()
+    result.assert_outcomes()
+
+
+def test_custom_extensions(pytester):
+    pytester.makeini(
+        "[pytest]\n"
+        "cppcheck_extensions = .h\n"
+    )
+    pytester.makefile(".h", header=C_CLEAN)
+    pytester.makefile(".c", also_clean=C_CLEAN)
+    pytester.makefile(".cpp", also_also_clean=C_CLEAN)
+    result = pytester.runpytest("--cppcheck")
+    # only .h collected, not .c or .cpp
+    result.assert_outcomes(passed=1)
+
+
+def test_cpp_collected_by_default(pytester):
+    pytester.makefile(".cpp", clean=C_CLEAN)
+    result = pytester.runpytest("--cppcheck")
+    result.assert_outcomes(passed=1)
+
+
+def test_quiet_flag_always_passed(pytester):
+    pytester.makefile(".c", clean=C_CLEAN)
+    result = pytester.runpytest("--cppcheck", "-v")
+    result.assert_outcomes(passed=1)
+
+
+def test_cppcheck_args_forwarded(pytester):
+    """Suppress the specific error so the file passes despite the bug."""
+    pytester.makeini(
+        "[pytest]\n"
+        "cppcheck_args = --enable=warning --suppress=arrayIndexOutOfBounds\n"
+    )
+    pytester.makefile(".c", bad=C_ERROR)
+    result = pytester.runpytest("--cppcheck")
+    result.assert_outcomes(passed=1)
+
+
+def test_cache_skips_on_second_run(pytester):
+    pytester.makefile(".c", clean=C_CLEAN)
+    # First run: passes and populates cache
+    result = pytester.runpytest("--cppcheck", "-p", "cacheprovider")
+    result.assert_outcomes(passed=1)
+    # Second run: skipped via cache
+    result = pytester.runpytest("--cppcheck", "-p", "cacheprovider")
+    result.assert_outcomes(skipped=1)
+
+
+def test_cache_reruns_after_file_change(pytester):
+    import os
+    path = pytester.makefile(".c", clean=C_CLEAN)
+    # First run
+    result = pytester.runpytest("--cppcheck", "-p", "cacheprovider")
+    result.assert_outcomes(passed=1)
+    # Bump mtime explicitly to avoid filesystem resolution issues
+    st = path.stat()
+    os.utime(path, ns=(st.st_atime_ns, st.st_mtime_ns + 1_000_000_000))
+    # Second run: re-checked because mtime changed
+    result = pytester.runpytest("--cppcheck", "-p", "cacheprovider")
+    result.assert_outcomes(passed=1)
+
+
+def test_cache_reruns_after_args_change(pytester):
+    pytester.makefile(".c", clean=C_CLEAN)
+    # First run
+    result = pytester.runpytest("--cppcheck", "-p", "cacheprovider")
+    result.assert_outcomes(passed=1)
+    # Second run with different args: re-checked
+    pytester.makeini(
+        "[pytest]\n"
+        "cppcheck_args = --enable=warning\n"
+    )
+    result = pytester.runpytest("--cppcheck", "-p", "cacheprovider")
+    result.assert_outcomes(passed=1)
+
+
+def test_cache_does_not_skip_failures(pytester):
+    pytester.makeini(
+        "[pytest]\n"
+        "cppcheck_args = --enable=warning\n"
+    )
+    pytester.makefile(".c", bad=C_ERROR)
+    # First run: fails
+    result = pytester.runpytest("--cppcheck", "-p", "cacheprovider")
+    result.assert_outcomes(failed=1)
+    # Second run: still fails (not cached)
+    result = pytester.runpytest("--cppcheck", "-p", "cacheprovider")
+    result.assert_outcomes(failed=1)
+
+
+def test_cache_clear_forces_rerun(pytester):
+    pytester.makefile(".c", clean=C_CLEAN)
+    # First run: passes and populates cache
+    result = pytester.runpytest("--cppcheck", "-p", "cacheprovider")
+    result.assert_outcomes(passed=1)
+    # Second run with --cache-clear: re-checked
+    result = pytester.runpytest("--cppcheck", "--cache-clear", "-p", "cacheprovider")
+    result.assert_outcomes(passed=1)