Publish Chimera GFX source

tests/test_retroarch_phase10h_result.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Mutation guardrails for the consumed Phase-1.0H result."""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+from pathlib import Path
+import sys
+
+
+def load(path: Path):
+    spec = importlib.util.spec_from_file_location("phase10h_result", path)
+    assert spec and spec.loader
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+def require(value: bool, message: str) -> None:
+    if not value:
+        raise RuntimeError(message)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--root", type=Path, required=True)
+    args = parser.parse_args()
+    root = args.root.resolve()
+    validator = load(root / "tools/validate_retroarch_phase10h_result.py")
+    record = validator.load_json(root / "manifests/retroarch/phase-1.0h-device-result.json")
+    cases = []
+
+    def case(name):
+        def register(function):
+            cases.append((name, function)); return function
+        return register
+
+    @case("01 result sequence is exact")
+    def _(): require(validator.result_is_exact(record["protocol_result"]), "result rejected")
+
+    @case("02 invented D11 fails")
+    def _():
+        value = dict(record["protocol_result"]); value["stages"] = list(value["stages"]) + ["D11"]; value["frame_count"] += 1
+        require(not validator.result_is_exact(value), "D11 accepted")
+
+    @case("03 successful flip claim fails")
+    def _():
+        value = dict(record["protocol_result"]); value["raw_results"] = dict(value["raw_results"]); value["raw_results"]["D07"] = 0
+        require(not validator.result_is_exact(value), "successful flip accepted")
+
+    @case("04 transport is one shot")
+    def _(): require(validator.transport_is_one_shot(record["transport"]), "transport rejected")
+
+    @case("05 retry fails")
+    def _():
+        value = dict(record["transport"]); value["retry_count"] = 1
+        require(not validator.transport_is_one_shot(value), "retry accepted")
+
+    @case("06 reconnect fails")
+    def _():
+        value = dict(record["transport"]); value["reconnect_count"] = 1
+        require(not validator.transport_is_one_shot(value), "reconnect accepted")
+
+    @case("07 all current authorizations are false")
+    def _(): require(validator.all_false(record["current_authorizations"], validator.AUTHORIZATION_FIELDS), "authority active")
+
+    @case("08 future execution authority fails")
+    def _():
+        value = dict(record["current_authorizations"]); value["device_execution_authorized"] = True
+        require(not validator.all_false(value, validator.AUTHORIZATION_FIELDS), "authority accepted")
+
+    @case("09 authorization is consumed")
+    def _(): require(record["authorization"]["consumed"] is True and record["authorization"]["authority_inherited_by_future_action"] is False, "authority reusable")
+
+    @case("10 visible presentation remains unproven")
+    def _(): require(record["source_binding"]["visible_presentation"] == "UNPROVEN", "visibility invented")
+
+    @case("11 cleanup remains unproven")
+    def _(): require(record["source_binding"]["complete_cleanup"] == "UNPROVEN", "cleanup invented")
+
+    @case("12 write operation remains unobserved")
+    def _(): require(record["source_binding"]["exact_blocked_write_operation"] == "UNOBSERVED", "write operation invented")
+
+    failures = []
+    for name, function in cases:
+        try:
+            function(); print(f"PASS {name}")
+        except Exception as error:  # noqa: BLE001 - mutation harness
+            failures.append(f"{name}: {error}"); print(f"FAIL {name}: {error}")
+    if failures:
+        return 1
+    print(f"Phase-1.0H result guardrails passed: {len(cases)}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())