| import copy |
| import hashlib |
| import json |
| import tempfile |
| import unittest |
| from pathlib import Path |
|
|
| from klein_code_bench.build import build |
| from klein_code_bench.catalog import FAMILIES |
| from klein_code_bench.fuzz import generated_inputs |
| from klein_code_bench.reference.domains import solve |
| from klein_code_bench.reference.export import export_reference |
| from klein_code_bench.reference.service import Service |
| from klein_code_bench.runner import ( |
| DATA, |
| copy_project, |
| equal, |
| evaluate, |
| load_tasks, |
| run_session, |
| ) |
| from klein_code_bench.scoring import summarize |
|
|
|
|
| class DomainTests(unittest.TestCase): |
| def test_all_65_independent_goldens(self): |
| self.assertEqual(len(FAMILIES), 65) |
| for family in FAMILIES.values(): |
| with self.subTest(family=family.slug): |
| self.assertTrue( |
| equal(solve(family.slug, family.inputs[0]), family.golden) |
| ) |
|
|
| def test_generators_cover_every_family_without_mutating_input(self): |
| for family in FAMILIES: |
| for data in generated_inputs(family): |
| original = copy.deepcopy(data) |
| json.dumps(solve(family, data), allow_nan=False) |
| self.assertEqual(data, original, family) |
|
|
| def test_money_conservation(self): |
| for x in generated_inputs("money_split", count=100): |
| shares = solve("money_split", x) |
| self.assertEqual(sum(shares), x["amount"]) |
| self.assertTrue(all(v >= 0 for v in shares)) |
|
|
| def test_knapsack_against_exhaustive_subsets(self): |
| for x in generated_inputs("knapsack", count=50): |
| best = max( |
| sum(item["value"] for i, item in enumerate(x["items"]) if mask >> i & 1) |
| for mask in range(1 << len(x["items"])) |
| if sum( |
| item["weight"] for i, item in enumerate(x["items"]) if mask >> i & 1 |
| ) |
| <= x["capacity"] |
| ) |
| self.assertEqual(solve("knapsack", x), best) |
|
|
| def test_shortest_path_against_bellman_ford(self): |
| for x in generated_inputs("shortest_path", count=50): |
| d = {n: float("inf") for n in x["nodes"]} |
| d[x["start"]] = 0 |
| for _ in x["nodes"]: |
| for a, b, w in x["edges"]: |
| d[b] = min(d[b], d[a] + w) |
| expected = {k: v if v != float("inf") else None for k, v in d.items()} |
| self.assertEqual(solve("shortest_path", x), expected) |
|
|
| def test_factorization_reconstructs_input(self): |
| for x in generated_inputs("prime_factors", count=100): |
| product = 1 |
| for p, exponent in solve("prime_factors", x): |
| self.assertTrue(all(p % d for d in range(2, int(p**0.5) + 1))) |
| product *= p**exponent |
| self.assertEqual(product, x["number"]) |
|
|
| def test_base_conversion_roundtrip(self): |
| for x in generated_inputs("base_convert", count=100): |
| self.assertEqual( |
| int(solve("base_convert", x), x["to_base"]), int(x["digits"]) |
| ) |
|
|
| def test_sequence_script_reconstructs_both_inputs(self): |
| for x in generated_inputs("sequence_diff", count=100): |
| result = solve("sequence_diff", x) |
| self.assertEqual([v for op, v in result if op != "insert"], x["a"]) |
| self.assertEqual([v for op, v in result if op != "delete"], x["b"]) |
|
|
|
|
| class ServiceTests(unittest.TestCase): |
| def setUp(self): |
| self.s = Service("word_frequency", "max") |
|
|
| def call(self, op, **kwargs): |
| return self.s.request(dict(op=op, **kwargs)) |
|
|
| def test_revisions_and_failed_cas(self): |
| self.assertEqual( |
| self.call("put", key="a", value=None), |
| {"ok": True, "result": {"key": "a", "revision": 1}}, |
| ) |
| self.assertEqual( |
| self.call("delete", key="missing", if_revision=0), |
| {"ok": False, "error": "conflict"}, |
| ) |
| self.assertEqual( |
| self.call("get", key="a")["result"], |
| {"key": "a", "value": None, "revision": 1}, |
| ) |
| self.assertEqual(self.call("status")["result"], {"revision": 1, "size": 1}) |
|
|
| def test_batch_rollback_and_revision_reuse(self): |
| self.assertEqual( |
| self.call( |
| "batch", |
| commands=[ |
| {"op": "put", "key": "a", "value": 1}, |
| {"op": "get", "key": "bad"}, |
| ], |
| ), |
| {"ok": False, "error": "not_found"}, |
| ) |
| self.assertEqual(self.call("status")["result"], {"revision": 0, "size": 0}) |
| self.assertEqual(self.call("history")["result"], []) |
| self.assertEqual(self.call("put", key="b", value=2)["result"]["revision"], 1) |
|
|
| def test_nested_commit_outer_rollback(self): |
| self.call("begin") |
| self.call("put", key="a", value=1) |
| self.call("begin") |
| self.call("put", key="b", value=2) |
| self.assertEqual(self.call("commit")["result"], {"depth": 1}) |
| self.assertEqual(self.call("rollback")["result"], {"depth": 0}) |
| self.assertEqual(self.call("list")["result"], []) |
| self.assertEqual(self.call("history")["result"], []) |
|
|
| def test_idempotent_request_checks_cache_before_cas(self): |
| first = self.call("put", key="a", value=1, token="t", if_revision=0) |
| self.assertEqual( |
| self.call("put", key="a", value=1, token="t", if_revision=0), first |
| ) |
| self.assertEqual(self.call("status")["result"]["revision"], 1) |
| self.assertEqual( |
| self.call("put", key="a", value=2, token="t"), |
| {"ok": False, "error": "idempotency_conflict"}, |
| ) |
|
|
| def test_failed_and_rolled_back_tokens_forgotten(self): |
| self.call("delete", key="a", token="t") |
| self.assertTrue(self.call("put", key="a", value=1, token="t")["ok"]) |
| self.call("begin") |
| self.call("put", key="b", value=2, token="u") |
| self.call("rollback") |
| self.assertTrue(self.call("put", key="b", value=3, token="u")["ok"]) |
|
|
| def test_evaluate_is_read_only(self): |
| self.call("put", key="a", value={"text": "x x"}) |
| self.assertEqual( |
| self.call("evaluate", key="a")["result"], [{"word": "x", "count": 2}] |
| ) |
| self.assertEqual(self.call("get", key="a")["result"]["value"], {"text": "x x"}) |
| self.assertEqual(self.call("status")["result"]["revision"], 1) |
|
|
| def test_scan_pages(self): |
| for key in ["c", "a", "b"]: |
| self.call("put", key=key, value=key) |
| self.assertEqual( |
| self.call("scan", limit=1)["result"], |
| {"items": [{"key": "a", "value": "a", "revision": 2}], "next": "a"}, |
| ) |
| self.assertEqual(self.call("scan", after="b", limit=1)["result"]["next"], None) |
| self.assertEqual( |
| self.call("scan", limit=0)["result"], {"items": [], "next": None} |
| ) |
|
|
| def test_outer_commit_is_durable_and_open_transaction_is_not(self): |
| with tempfile.TemporaryDirectory() as d: |
| self.s = Service("word_frequency", "max", d) |
| self.call("begin") |
| self.call("put", key="a", value={"text": "saved"}, token="t") |
| self.call("commit") |
| self.call("begin") |
| self.call("delete", key="a") |
| reloaded = Service("word_frequency", "max", d) |
| self.assertEqual( |
| reloaded.request({"op": "get", "key": "a"})["result"]["revision"], 1 |
| ) |
| self.assertEqual(reloaded.state["tokens"].keys(), {"t"}) |
| self.assertEqual(len(reloaded.state["history"]), 1) |
|
|
|
|
| class DatasetTests(unittest.TestCase): |
| def test_exact_counts_unique_ids_and_manifest(self): |
| rows = list(load_tasks()) |
| self.assertEqual(len(rows), 260) |
| self.assertEqual(len({r["task_id"] for r in rows}), 260) |
| for tier in ["easy", "intermediate", "hard", "max"]: |
| self.assertEqual(sum(r["subset"] == tier for r in rows), 65) |
| manifest = json.loads((DATA / "manifest.json").read_text()) |
| for name, digest in manifest["sha256"].items(): |
| self.assertEqual( |
| hashlib.sha256((DATA / name).read_bytes()).hexdigest(), digest |
| ) |
|
|
| def test_build_reproducible(self): |
| with tempfile.TemporaryDirectory() as d: |
| build(d) |
| for file in DATA.iterdir(): |
| if file.suffix in {".json", ".jsonl"}: |
| self.assertEqual( |
| file.read_bytes(), (Path(d) / file.name).read_bytes(), file.name |
| ) |
|
|
| def test_public_examples_in_prompt_and_nonempty_acceptance(self): |
| for row in load_tasks(): |
| self.assertTrue(json.loads(row["public_tests"])) |
| traces = json.loads(row["acceptance_tests"]) |
| self.assertTrue(traces) |
| self.assertEqual( |
| row["num_assertions"], |
| sum(len(s["expected"]) for t in traces for s in t["sessions"]), |
| ) |
| for trace in traces: |
| for session in trace["sessions"]: |
| self.assertTrue(session["requests"]) |
| self.assertEqual(len(session["requests"]), len(session["expected"])) |
|
|
| def test_scoring_uses_full_denominator_and_rejects_smoke(self): |
| row = next(load_tasks("easy")) |
| report = {"task_id": row["task_id"], "subset": "easy", "resolved": True} |
| self.assertEqual( |
| summarize([report])["subsets"]["easy"]["resolution_rate"], 1 / 65 |
| ) |
| with self.assertRaises(ValueError): |
| summarize([report, report]) |
| with self.assertRaises(ValueError): |
| summarize([dict(report, evaluation_scope="public")]) |
|
|
|
|
| class RunnerTests(unittest.TestCase): |
| def setUp(self): |
| self.temporary = tempfile.TemporaryDirectory() |
| self.root = Path(self.temporary.name) |
| self.project, self.state = self.root / "project", self.root / "state" |
| self.project.mkdir() |
| self.state.mkdir() |
| self.session = { |
| "requests": [{"op": "status"}], |
| "expected": [{"ok": True, "result": 7}], |
| } |
|
|
| def tearDown(self): |
| self.temporary.cleanup() |
|
|
| def run_code(self, code, timeout=1): |
| (self.project / "main.py").write_text(code) |
| return run_session(self.project, self.state, self.session, timeout=timeout) |
|
|
| def test_response_and_clean_exit(self): |
| self.assertTrue( |
| self.run_code( |
| 'import sys\nfor line in sys.stdin:\n print(\'{"ok":true,"result":7}\', flush=True)\n' |
| )["passed"] |
| ) |
|
|
| def test_rejects_wrong_boolean_numeric_type(self): |
| self.assertFalse(equal(True, 1)) |
| self.assertFalse(equal(1, True)) |
| self.assertFalse(equal(float("nan"), 1)) |
| self.assertTrue(equal(1.0, 1)) |
| self.assertFalse(equal(10**30, 10**30 + 1)) |
|
|
| def test_timeout_without_output(self): |
| self.assertFalse( |
| self.run_code("import time\ntime.sleep(20)", timeout=0.2)["passed"] |
| ) |
|
|
| def test_failure_on_nonzero_exit(self): |
| self.assertFalse( |
| self.run_code( |
| 'import sys\nsys.stdin.readline()\nprint(\'{"ok":true,"result":7}\',flush=True)\nsys.exit(1)' |
| )["passed"] |
| ) |
|
|
| def test_rejects_extra_stdout(self): |
| self.assertFalse( |
| self.run_code( |
| 'import sys\nsys.stdin.readline()\nprint(\'{"ok":true,"result":7}\')\nprint("extra",flush=True)' |
| )["passed"] |
| ) |
|
|
| def test_output_flood_is_bounded(self): |
| self.assertFalse( |
| self.run_code('import os\nwhile True: os.write(1,b"x"*65536)')["passed"] |
| ) |
|
|
| def test_stderr_flood_does_not_deadlock(self): |
| self.assertTrue( |
| self.run_code( |
| 'import os,sys\nfor line in sys.stdin:\n os.write(2,b"x"*200000)\n print(\'{"ok":true,"result":7}\',flush=True)' |
| )["passed"] |
| ) |
|
|
| def test_symlinks_rejected(self): |
| (self.project / "main.py").symlink_to("/etc/passwd") |
| target = self.root / "copied" |
| target.mkdir() |
| with self.assertRaises(ValueError): |
| copy_project(self.project, target) |
|
|
| def test_invalid_submission_is_failed_rather_than_infrastructure_error(self): |
| (self.project / "main.py").symlink_to("/etc/passwd") |
| result = evaluate(next(load_tasks("easy")), self.project) |
| self.assertFalse(result["resolved"]) |
| self.assertIn("symlink", result["reason"]) |
|
|
| def test_reference_max_restart_and_empty_submission(self): |
| row = next(load_tasks("max")) |
| export_reference(row["family"], "max", self.project) |
| result = evaluate(row, self.project) |
| self.assertTrue(result["passed"], result) |
| empty = self.root / "empty" |
| empty.mkdir() |
| self.assertFalse(evaluate(row, empty)["passed"]) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main() |
|
|
