Datasets:
Download experiments/t2/tests/test_batch.py from PV-SJTU/PV-Bench: direct link, hf CLI and curl.
- Browser
- Download file 10.6 kB
-
https://huggingface.co/datasets/PV-SJTU/PV-Bench/resolve/main/experiments/t2/tests/test_batch.py
- Command line
-
hf download hf://datasets/PV-SJTU/PV-Bench/experiments/t2/tests/test_batch.py
-
curl -L -o test_batch.py https://huggingface.co/datasets/PV-SJTU/PV-Bench/resolve/main/experiments/t2/tests/test_batch.py
10.6 kB
| """Only synthetic case lists; never launch a real model or benchmark batch.""" | |
| import contextlib | |
| import io | |
| import json | |
| from pathlib import Path | |
| import platform | |
| import shutil | |
| import threading | |
| import sys | |
| import time | |
| from unittest.mock import patch | |
| from helpers import EGRESS, Fixture, fake_credentials | |
| from pvbench_common.container import Outcome | |
| from t2 import runners | |
| from t2.batch import read_cases | |
| from t2.cli import main | |
| from t2.config import Case | |
| class BatchTests(Fixture): | |
| def setUp(self): | |
| super().setUp() | |
| shutil.copytree(self.bench / "Toy", self.bench / "Category/Second") | |
| self.list_file = self.root / "synthetic cases.txt" | |
| self.list_file.write_bytes(b"\xef\xbb\xbf# Test fixtures only\r\nToy\r\n\r\nCategory/Second # second case\r\nToy\r\n") | |
| def args(self, runner="codex", mask="batch-test", dry=False): | |
| return ["run-all", str(self.list_file), "--runner", runner, | |
| "--model", "fake-model", "--mask", mask, *(["--dry-run"] if dry else [])] | |
| def reports(self): | |
| return [json.loads(p.read_text()) for p in sorted((self.cfg.ws_root / ".batches").glob("*/summary.json"))] | |
| def test_comments_bom_crlf_order_and_duplicates(self): | |
| data, cases, duplicates = read_cases(self.list_file) | |
| self.assertEqual(data, self.list_file.read_bytes()) | |
| self.assertEqual(cases, ["Toy", "Category/Second"]) | |
| self.assertEqual(duplicates, ["Toy"]) | |
| def test_dry_batch_prepares_both_runners_without_subprocesses(self): | |
| platform.system() # Windows discovers its version via subprocess on first call. | |
| for name in ("codex", "claude"): | |
| mask = "preview-" + name | |
| with self.subTest(runner=name), patch("t2.cli.Config.load", return_value=self.cfg), \ | |
| patch("t2.cli.runners.run") as runner, patch("t2.cli.runners.preflight") as preflight, \ | |
| patch("subprocess.Popen", side_effect=AssertionError("dry batch must not launch subprocesses")), \ | |
| contextlib.redirect_stdout(io.StringIO()): | |
| code = main(self.args(name, mask, dry=True)) | |
| self.assertEqual(code, 0) | |
| runner.assert_not_called() | |
| preflight.assert_not_called() | |
| report = next(r for r in self.reports() if r["mask"] == mask) | |
| self.assertEqual(report["counts"], {"prepared": 2}) | |
| self.assertEqual(report["duplicates_ignored"], ["Toy"]) | |
| self.assertEqual(report["proof_status"], "not_checked") | |
| for problem in ("Toy", "Category/Second"): | |
| case = Case.create(self.cfg, problem, "fake-model", name, mask) | |
| self.assertTrue((case.workspace / "answer/solution_annotated.c").is_file()) | |
| self.assertFalse((case.evidence / "events.jsonl").exists()) | |
| command = json.loads((case.evidence / "command.json").read_text()) | |
| self.assertEqual(command[0], name) | |
| self.assertNotIn("--effort", command) | |
| self.assertFalse(any("model_reasoning_effort" in arg for arg in command)) | |
| def test_existing_attempts_are_skipped_and_untouched(self): | |
| with patch("t2.cli.Config.load", return_value=self.cfg), contextlib.redirect_stdout(io.StringIO()): | |
| self.assertEqual(main(self.args(dry=True)), 0) | |
| first = Case.create(self.cfg, "Toy", "fake-model", "codex", "batch-test") | |
| answer = first.workspace / "answer/solution_annotated.c" | |
| answer.write_text("preserved saved answer") | |
| with patch("t2.cli.Config.load", return_value=self.cfg), patch("t2.cli.run_case") as run_case, \ | |
| contextlib.redirect_stdout(io.StringIO()): | |
| self.assertEqual(main(self.args()), 0) | |
| run_case.assert_not_called() | |
| self.assertEqual(answer.read_text(), "preserved saved answer") | |
| self.assertTrue(any(r["counts"] == {"skipped": 2} for r in self.reports())) | |
| def test_invalid_or_empty_list_fails_before_any_workspace_or_session(self): | |
| for contents in ("Toy\nMissing\n", "# only a comment\n", "Toy\n../escape\n"): | |
| self.list_file.write_text(contents) | |
| with self.subTest(contents=contents), patch("t2.cli.Config.load", return_value=self.cfg), \ | |
| patch("t2.cli.run_case") as run_case, contextlib.redirect_stderr(io.StringIO()): | |
| self.assertEqual(main(self.args()), 2) | |
| run_case.assert_not_called() | |
| self.assertFalse(self.cfg.ws_root.exists()) | |
| def test_failed_case_does_not_stop_later_cases(self): | |
| order = [] | |
| def fake_run(cfg, case, effort, dry): | |
| order.append(case.problem) | |
| self.assertEqual(case.mask, "batch-test") | |
| self.assertEqual(cfg.timeout, cfg.task.limits.agent_timeout_s) | |
| self.assertIsNone(effort) | |
| return 1 if case.problem == "Toy" else 0 | |
| with patch("t2.cli.Config.load", return_value=self.cfg), patch("t2.cli.run_case", side_effect=fake_run), \ | |
| contextlib.redirect_stdout(io.StringIO()): | |
| self.assertEqual(main(self.args()), 1) | |
| self.assertEqual(order, ["Toy", "Category/Second"]) | |
| self.assertEqual(self.reports()[0]["counts"], {"failed": 1, "completed": 1}) | |
| def test_jobs_two_runs_cases_concurrently_and_records_results(self): | |
| lock = threading.Lock() | |
| active = 0 | |
| peak = 0 | |
| def fake_run(cfg, case, effort, dry, **kwargs): | |
| nonlocal active, peak | |
| with lock: | |
| active += 1 | |
| peak = max(peak, active) | |
| time.sleep(0.15) | |
| with lock: | |
| active -= 1 | |
| return 1 if case.problem == "Toy" else 0 | |
| with patch("t2.cli.Config.load", return_value=self.cfg), \ | |
| patch("t2.cli.run_case", side_effect=fake_run), \ | |
| patch("pvbench_common.container.daemon_resources", return_value=(6, 24 * 1024 ** 3)), \ | |
| contextlib.redirect_stdout(io.StringIO()): | |
| self.assertEqual(main(self.args() + ["--jobs", "2"]), 1) | |
| self.assertEqual(peak, 2) | |
| report = self.reports()[0] | |
| self.assertEqual(report["jobs"], 2) | |
| self.assertEqual(report["counts"], {"failed": 1, "completed": 1}) | |
| def test_invalid_jobs_rejected_before_writing(self): | |
| with patch("t2.cli.Config.load", return_value=self.cfg), \ | |
| contextlib.redirect_stderr(io.StringIO()): | |
| self.assertEqual(main(self.args() + ["--jobs", "0"]), 2) | |
| self.assertFalse(self.cfg.ws_root.exists()) | |
| def test_parallel_interrupt_stops_unstarted_case(self): | |
| shutil.copytree(self.bench / "Toy", self.bench / "Category/Third") | |
| self.list_file.write_text("Toy\nCategory/Second\nCategory/Third\n") | |
| started = [] | |
| def fake_run(cfg, case, effort, dry, *, cancel_event, **kwargs): | |
| started.append(case.problem) | |
| if case.problem == "Toy": | |
| time.sleep(0.05) | |
| return 130 | |
| self.assertTrue(cancel_event.wait(2)) | |
| return 130 | |
| with patch("t2.cli.Config.load", return_value=self.cfg), \ | |
| patch("t2.cli.run_case", side_effect=fake_run), \ | |
| patch("pvbench_common.container.daemon_resources", return_value=(6, 24 * 1024 ** 3)), \ | |
| contextlib.redirect_stdout(io.StringIO()): | |
| self.assertEqual(main(self.args() + ["--jobs", "2"]), 130) | |
| self.assertCountEqual(started, ["Toy", "Category/Second"]) | |
| self.assertEqual(self.reports()[0]["counts"], {"interrupted": 2, "not_started": 1}) | |
| def test_jobs_capped_by_daemon_resources(self): | |
| seen = [] | |
| def fake_run(cfg, case, effort, dry, **kwargs): | |
| seen.append(kwargs.get("concurrent")) | |
| return 0 | |
| out = io.StringIO() | |
| with patch("t2.cli.Config.load", return_value=self.cfg), patch("t2.cli.run_case", side_effect=fake_run), \ | |
| patch("pvbench_common.container.daemon_resources", return_value=(4, 16 * 1024 ** 3)), \ | |
| contextlib.redirect_stdout(out): | |
| self.assertEqual(main(self.args() + ["--jobs", "8"]), 0) | |
| self.assertIn("--jobs 8 capped at 2", out.getvalue()) | |
| self.assertEqual(self.reports()[0]["jobs"], 2) | |
| self.assertEqual(seen, [2, 2]) | |
| def test_interrupt_stops_batch_before_next_case(self): | |
| with patch("t2.cli.Config.load", return_value=self.cfg), \ | |
| patch("t2.cli.run_case", side_effect=KeyboardInterrupt) as run_case, \ | |
| contextlib.redirect_stdout(io.StringIO()): | |
| self.assertEqual(main(self.args()), 130) | |
| self.assertEqual(run_case.call_count, 1) | |
| report = self.reports()[0] | |
| self.assertEqual(report["status"], "interrupted") | |
| self.assertEqual(report["counts"], {"interrupted": 1, "not_started": 1}) | |
| def test_fake_sessions_use_single_case_lifecycle_for_each_case(self): | |
| def fake_container(inv, *, timeout_s, stdout, stderr): | |
| host = next(h for h, at, _ in inv.mounts if at == "/work/answer") | |
| (Path(host) / "solution_annotated.c").write_text("synthetic batch answer") | |
| Path(stdout).write_text('{"type":"turn.completed","usage":{}}\n'); Path(stderr).write_text("") | |
| now = time.time() | |
| return Outcome(0, False, False, now - 1, now, Path(stdout), Path(stderr)) | |
| with patch("t2.cli.Config.load", return_value=self.cfg), patch("t2.runners.preflight"), \ | |
| patch.object(runners.egress, "ensure", return_value=EGRESS), \ | |
| patch.object(runners.egress, "log_since", return_value=[]), \ | |
| patch.object(runners.credentials, "prepare", side_effect=fake_credentials), \ | |
| patch.object(runners.container, "daemon_resources", return_value=(6, 12 * 1024 ** 3)), \ | |
| patch.object(runners.container, "run", side_effect=fake_container), \ | |
| contextlib.redirect_stdout(io.StringIO()): | |
| self.assertEqual(main(self.args()), 0) | |
| report = self.reports()[0] | |
| self.assertEqual(report["counts"], {"completed": 2}) | |
| for problem in ("Toy", "Category/Second"): | |
| case = Case.create(self.cfg, problem, "fake-model", "codex", "batch-test") | |
| self.assertEqual((case.root / "out/solution_annotated.c").read_text(), "synthetic batch answer") | |
| self.assertEqual(json.loads((case.root / "summary.json").read_text())["proof_status"], "not_checked") | |
| self.assertFalse((case.workspace / "answer/feedback/latest.json").exists()) | |