fix(chip): keep source-only riscv checks clean

Author: NubsCarson

packages/chip/benchmarks/parsers/tests/test_parsers_hypothesis.py

@@ -31,6 +31,7 @@
     HYPOTHESIS_AVAILABLE = True
 except ImportError:  # pragma: no cover - skip when hypothesis is absent
     HYPOTHESIS_AVAILABLE = False
+    raise unittest.SkipTest("hypothesis is not installed")
 
 from benchmarks.parsers import (  # noqa: E402
     ParseError,

packages/chip/scripts/check_linux_external_bsp.py

@@ -220,16 +220,24 @@ def main(argv: list[str]) -> int:
     parser.add_argument("linux_tree", nargs="?")
     parser.add_argument("--json", action="store_true")
     parser.add_argument("--require-pass", action="store_true")
+    parser.add_argument(
+        "--report",
+        default=str(REPORT),
+        help=f"status report path (default: {rel(REPORT)})",
+    )
     args = parser.parse_args(argv)
 
+    report_path = Path(args.report).expanduser()
+    if not report_path.is_absolute():
+        report_path = ROOT / report_path
     report = build_report(candidate_linux_tree(args.linux_tree))
-    REPORT.parent.mkdir(parents=True, exist_ok=True)
-    REPORT.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    report_path.parent.mkdir(parents=True, exist_ok=True)
+    report_path.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n", encoding="utf-8")
     if args.json:
         print(json.dumps(report, indent=2, sort_keys=True))
     else:
         print(f"STATUS: {report['status'].upper()} linux.external_bsp_status")
-        print(f"  report: {rel(REPORT)}")
+        print(f"  report: {rel(report_path)}")
         for key, value in report["producer_commands"].items():
             print(f"  command.{key}: {value}")
         for blocker in report["blockers"]:

packages/chip/scripts/check_minimum_linux_target.py

@@ -14,7 +14,7 @@
 DOC = ROOT / "docs/project/minimum-linux-npu-target.md"
 REPORT = ROOT / "build/reports/minimum-linux-kernel-target.json"
 LINUX_DTS = ROOT / "sw/linux/dts/eliza-e1.dts"
-LINUX_EXTERNAL_STATUS = ROOT / "docs/evidence/linux/linux-external-bsp-status.json"
+LINUX_EXTERNAL_STATUS = ROOT / "build/reports/linux-external-bsp-status.json"
 
 REQUIRED_LOCAL_ARTIFACTS = {
     "linux_bsp_readme": "docs/sw/linux/README.md",
@@ -151,7 +151,12 @@ def collect() -> dict[str, Any]:
             errors.append(f"Linux DTS missing {name}: {REQUIRED_DTS_TOKENS[name]}")
 
     subprocess.run(
-        [sys.executable, "scripts/check_linux_external_bsp.py"],
+        [
+            sys.executable,
+            "scripts/check_linux_external_bsp.py",
+            "--report",
+            str(LINUX_EXTERNAL_STATUS),
+        ],
         cwd=ROOT,
         text=True,
         stdout=subprocess.PIPE,

packages/chip/scripts/test_check_cocotb_coverage_hypothesis.py

@@ -40,6 +40,7 @@
     HYPOTHESIS_AVAILABLE = True
 except ImportError:  # pragma: no cover - skip when hypothesis is absent
     HYPOTHESIS_AVAILABLE = False
+    raise unittest.SkipTest("hypothesis is not installed")
 
 
 def _make_block_payload(

packages/chip/scripts/test_check_cpu_2028_target.py

@@ -46,6 +46,45 @@
 except ImportError:  # pragma: no cover - skip when hypothesis is absent
     HYPOTHESIS_AVAILABLE = False
 
+    class _MissingHealthCheck:
+        too_slow = "too_slow"
+        function_scoped_fixture = "function_scoped_fixture"
+
+    class _MissingStrategy:
+        def filter(self, *_args: object, **_kwargs: object) -> "_MissingStrategy":
+            return self
+
+    class _MissingStrategies:
+        def sampled_from(self, *_args: object, **_kwargs: object) -> _MissingStrategy:
+            return _MissingStrategy()
+
+        def lists(self, *_args: object, **_kwargs: object) -> _MissingStrategy:
+            return _MissingStrategy()
+
+        def text(self, *_args: object, **_kwargs: object) -> _MissingStrategy:
+            return _MissingStrategy()
+
+        def characters(self, *_args: object, **_kwargs: object) -> _MissingStrategy:
+            return _MissingStrategy()
+
+        def integers(self, *_args: object, **_kwargs: object) -> _MissingStrategy:
+            return _MissingStrategy()
+
+    def given(*_args: object, **_kwargs: object):
+        def decorator(fn):
+            return fn
+
+        return decorator
+
+    def settings(*_args: object, **_kwargs: object):
+        def decorator(fn):
+            return fn
+
+        return decorator
+
+    HealthCheck = _MissingHealthCheck
+    st = _MissingStrategies()
+
 
 def minimal_valid_spec() -> dict[str, Any]:
     return {

packages/chip/scripts/test_generate_e1_phone_cad.py

@@ -1,8 +1,19 @@
 #!/usr/bin/env python3
 import importlib.util
 import json
+import unittest
 from pathlib import Path
 
+_required_modules = ("matplotlib", "numpy", "trimesh", "yaml")
+_missing_modules = [
+    module for module in _required_modules if importlib.util.find_spec(module) is None
+]
+if _missing_modules:
+    raise unittest.SkipTest(
+        "optional E1 phone CAD dependencies are not installed: "
+        + ", ".join(_missing_modules)
+    )
+
 import generate_e1_phone_cad as cad
 import pytest
 

packages/chip/scripts/test_linux_external_bsp.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_REPORT = ROOT / "docs/evidence/linux/linux-external-bsp-status.json"
+
+
+class LinuxExternalBspReportTests(unittest.TestCase):
+    def test_custom_report_path_keeps_tracked_evidence_unchanged(self) -> None:
+        before = DEFAULT_REPORT.read_bytes()
+        with tempfile.TemporaryDirectory() as tmp:
+            report = Path(tmp) / "linux-external-bsp-status.json"
+            completed = subprocess.run(
+                [
+                    sys.executable,
+                    "scripts/check_linux_external_bsp.py",
+                    "--report",
+                    str(report),
+                ],
+                cwd=ROOT,
+                text=True,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                check=False,
+            )
+
+            self.assertEqual(completed.returncode, 0, completed.stdout)
+            self.assertIn("STATUS: BLOCKED linux.external_bsp_status", completed.stdout)
+            self.assertTrue(report.is_file())
+            self.assertEqual(DEFAULT_REPORT.read_bytes(), before)
+
+            payload = json.loads(report.read_text(encoding="utf-8"))
+            self.assertEqual(payload["schema"], "eliza.linux_external_bsp_status.v1")
+            self.assertEqual(payload["status"], "blocked")
+
+
+if __name__ == "__main__":
+    unittest.main()