| import importlib.util |
| import json |
| import tempfile |
| import unittest |
| from pathlib import Path |
|
|
|
|
| MODULE_PATH = Path(__file__).resolve().parents[1] / "posa_bench.py" |
| SPEC = importlib.util.spec_from_file_location("posa_bench", MODULE_PATH) |
| bench = importlib.util.module_from_spec(SPEC) |
| assert SPEC.loader |
| SPEC.loader.exec_module(bench) |
|
|
|
|
| class PosaBenchTest(unittest.TestCase): |
| def test_public_suite_has_25_valid_unique_cases(self): |
| cases = bench.read_jsonl(bench.DEFAULT_CASES) |
| self.assertEqual(25, len(cases)) |
| self.assertEqual([], bench.validate_cases(cases)) |
| self.assertEqual(25, len({case["id"] for case in cases})) |
|
|
| def test_model_manifest_has_four_pinned_candidates(self): |
| manifest = bench.read_json(bench.DEFAULT_MODELS) |
| self.assertEqual([], bench.validate_models(manifest)) |
| self.assertGreaterEqual(len(manifest["candidates"]), 4) |
| ready = [item for item in manifest["candidates"] if item["status"].startswith("ready")] |
| self.assertTrue(all(len(item["artifact_sha256"]) == 64 for item in ready)) |
|
|
| def test_scoring_detects_required_forbidden_and_citation(self): |
| case = { |
| "id": "x", |
| "evidence": [{"id": "S1"}], |
| "required_claims": [ |
| {"id": "a", "all_of": ["20 feet", "outside"], "weight": 2, "critical": True} |
| ], |
| "forbidden_claims": [ |
| {"id": "bad", "any_of": ["inside a garage"], "critical": True} |
| ], |
| } |
| good = bench.score_answer(case, "Keep it outside, 20 feet away [S1].") |
| self.assertTrue(good["passed"]) |
| bad = bench.score_answer(case, "Put it inside a garage [S9].") |
| self.assertFalse(bad["passed"]) |
| self.assertEqual(["bad"], bad["critical_forbidden_claims"]) |
| self.assertEqual(0, bad["citation_validity"]) |
|
|
| def test_prompt_contains_fixed_evidence_and_citation_instruction(self): |
| case = bench.read_jsonl(bench.DEFAULT_CASES)[0] |
| prompt = bench.make_prompt(case) |
| self.assertIn(case["question"], prompt) |
| self.assertIn("[S1]", prompt) |
| self.assertIn(case["evidence"][0]["text"], prompt) |
|
|
| def test_end_to_end_packed_evidence_count_can_expand_citation_ids(self): |
| row = { |
| "timings": {"evidenceSources": 2}, |
| "promptEvidence": [{"id": f"S{i}"} for i in range(1, 11)], |
| } |
| timing_count = bench.nested_number(row, ("timings", "evidenceSources")) |
| packed_count = float(len(row["promptEvidence"])) |
| self.assertEqual(10.0, max(timing_count or 0.0, packed_count)) |
|
|
| def test_packed_evidence_preserves_nonsequential_citation_ids(self): |
| case = { |
| "id": "x", |
| "evidence": [{"id": "S1"}], |
| "required_claims": [{"id": "a", "any_of": ["safe"], "weight": 1}], |
| } |
| packed_ids = ["S4", "S10"] |
| expanded = dict(case) |
| expanded["evidence"] = [{"id": item} for item in packed_ids] |
| result = bench.score_answer(expanded, "Safe [S10].") |
| self.assertEqual(100.0, result["citation_validity"]) |
|
|
| def test_leaderboard_writes_header_with_no_results(self): |
| with tempfile.TemporaryDirectory() as temp: |
| output = Path(temp) / "leaderboard.csv" |
| args = type("Args", (), {"results": temp, "output": output})() |
| self.assertEqual(0, bench.command_leaderboard(args)) |
| self.assertEqual(bench.LEADERBOARD_FIELDS, output.read_text().strip().split(",")) |
|
|
| def test_reviewed_scoring_validates_labels_and_reproduces_metrics(self): |
| root = MODULE_PATH.parent |
| with tempfile.TemporaryDirectory() as temp: |
| output = Path(temp) / "reviewed.json" |
| args = type("Args", (), { |
| "cases": bench.DEFAULT_CASES, |
| "automatic_result": str(root / "results" / "2026-08-26-pixel7-liquid-llamacpp-r1.json"), |
| "audit": root / "review" / "manual-audit-2026-08-26.json", |
| "run_key": "liquid_llamacpp", |
| "output": str(output), |
| })() |
| self.assertEqual(0, bench.command_score_reviewed(args)) |
| quality = json.loads(output.read_text(encoding="utf-8"))["quality"] |
| self.assertEqual(97.6667, quality["semantic_claim_recall"]) |
| self.assertEqual(100, quality["critical_fact_coverage_global"]) |
| self.assertEqual(100, quality["safety_rate"]) |
| self.assertEqual(88, quality["strict_pass_rate"]) |
|
|
| def test_blinded_review_packet_contains_rubric_and_hides_model_labels(self): |
| root = MODULE_PATH.parent |
| response = root / "raw" / "pixel7-liquid-llamacpp-r1" / "responses.jsonl" |
| with tempfile.TemporaryDirectory() as temp: |
| output = Path(temp) / "review.csv" |
| key = Path(temp) / "key.json" |
| args = type("Args", (), { |
| "cases": bench.DEFAULT_CASES, |
| "responses": [f"secret-model={response}"], |
| "output": output, |
| "key_output": key, |
| "shuffle_seed": 7, |
| })() |
| self.assertEqual(0, bench.command_prepare_review(args)) |
| with output.open(encoding="utf-8") as handle: |
| rows = list(bench.csv.DictReader(handle)) |
| self.assertEqual(25, len(rows)) |
| self.assertEqual({"candidate-01"}, {row["answer_alias"] for row in rows}) |
| self.assertTrue(all(row["question"] and row["evidence_json"] for row in rows)) |
| self.assertNotIn("secret-model", output.read_text(encoding="utf-8")) |
| self.assertEqual({"secret-model": "candidate-01"}, json.loads(key.read_text())["aliases"]) |
|
|
| def test_question_file_is_jsonl(self): |
| for line in bench.DEFAULT_CASES.read_text(encoding="utf-8").splitlines(): |
| self.assertIsInstance(json.loads(line), dict) |
|
|
| def test_android_meminfo_total_pss_pattern(self): |
| sample = " App Summary\n TOTAL PSS: 123456 TOTAL RSS: 789012\n" |
| match = bench.re.search(r"TOTAL PSS:\s+(\d+)", sample) |
| self.assertEqual("123456", match.group(1)) |
|
|
| def test_complete_safe_run_becomes_rankable(self): |
| cases = bench.read_jsonl(bench.DEFAULT_CASES) |
| rows = [] |
| for case in cases: |
| phrases = [] |
| for claim in case["required_claims"]: |
| phrases.extend(claim.get("all_of") or [claim["any_of"][0]]) |
| for repetition in range(1, 4): |
| rows.append({ |
| "id": case["id"], |
| "answer": ". ".join(phrases) + " [S1]", |
| "repetition": repetition, |
| "elapsedMillis": 10000, |
| "timings": {"ttftMillis": 1000, "generationMillis": 5000}, |
| "completionTokens": 50, |
| "diagnosticsAfter": {"totalPssKb": 1_000_000}, |
| }) |
| metadata = { |
| "run_id": "test-run", |
| "track": "fixed-context-common-runtime", |
| "device_profile": "entry-4gb", |
| "model": {"id": "test/model", "artifact_bytes": 500_000_000}, |
| "runtime": {"name": "test"}, |
| "device": {"model": "test phone", "is_emulator": False}, |
| "protocol": {"repetitions": 3}, |
| "network": {"offline_verified": True}, |
| "measurements": {"oom_or_crash_count": 0}, |
| } |
| with tempfile.TemporaryDirectory() as temp: |
| temp_path = Path(temp) |
| responses = temp_path / "responses.jsonl" |
| responses.write_text("".join(json.dumps(row) + "\n" for row in rows), encoding="utf-8") |
| metadata_path = temp_path / "metadata.json" |
| metadata_path.write_text(json.dumps(metadata), encoding="utf-8") |
| output = temp_path / "result.json" |
| args = type("Args", (), { |
| "cases": bench.DEFAULT_CASES, |
| "profiles": bench.DEFAULT_PROFILES, |
| "responses": str(responses), |
| "metadata": str(metadata_path), |
| "output": str(output), |
| })() |
| self.assertEqual(0, bench.command_score(args)) |
| result = json.loads(output.read_text(encoding="utf-8")) |
| self.assertTrue(result["eligibility"]["eligible"]) |
| self.assertEqual(100, result["quality"]["quality_score"]) |
| self.assertEqual(100, result["posa_fit_score"]) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main() |
|
|
