File size: 4,149 Bytes
87cc7f2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
import sys
import json
import unittest
from unittest.mock import patch
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))

from pilot_scoring import (  # noqa: E402
    extract_final_answer,
    score_answer,
    score_completion,
    score_extracted_answer,
)


class TestFinalAnswerExtraction(unittest.TestCase):
    def test_last_boxed_answer_with_nested_braces(self):
        result = extract_final_answer(
            r"We simplify the expression. Final result: \boxed{\frac{1}{\sqrt{2}}}."
        )
        self.assertEqual(result.status, "parsed")
        self.assertEqual(result.answer, r"\frac{1}{\sqrt{2}}")

    def test_last_boxed_answer_supersedes_intermediate_work(self):
        result = extract_final_answer(r"First I got \boxed{3}. Correcting the arithmetic gives \boxed{4}.")
        self.assertEqual(result.answer, "4")

    def test_terminal_answer_label(self):
        result = extract_final_answer("Some reasoning. Final answer: $240$.")
        self.assertEqual(result.status, "parsed")
        self.assertEqual(result.answer, "$240$")

    def test_terminal_hash_answer_line(self):
        result = extract_final_answer("worked steps\n#### 17")
        self.assertEqual(result.answer, "17")

    def test_ambiguous_alternatives_abstain(self):
        result = extract_final_answer(r"The solution is \boxed{1} or \boxed{2}.")
        self.assertEqual(result.status, "abstained")

    def test_incomplete_final_box_abstains(self):
        result = extract_final_answer(r"The answer is \boxed{1+")
        self.assertEqual(result.status, "abstained")

    def test_bare_reasoning_number_is_not_guessed(self):
        result = extract_final_answer("I computed 6 times 7, so the result is 42")
        self.assertEqual(result.status, "unparsed")


class TestPilotScoring(unittest.TestCase):
    @patch('pilot_scoring._math_verify_available', return_value=False)
    def test_numeric_equivalence_and_difference_are_distinguished(self, _mock):
        equal = score_extracted_answer(r"\frac{1}{2}", "0.5")
        different = score_extracted_answer("240", "241")
        self.assertEqual(equal.status, "correct")
        self.assertEqual(equal.method, "exact_numeric")
        self.assertEqual(different.status, "incorrect")

    @patch('pilot_scoring._math_verify_available', return_value=False)
    def test_identical_symbolic_literal_is_safe_but_other_form_is_unparsed(self, _mock):
        equal = score_extracted_answer(r"\sqrt{2}", r"\sqrt{2}")
        uncertain = score_extracted_answer(r"\sqrt{2}", "1.41421356")
        self.assertEqual(equal.status, "correct")
        self.assertEqual(equal.method, "exact_literal")
        self.assertEqual(uncertain.status, "unparsed")

    def test_completion_preserves_extraction_outcomes(self):
        self.assertEqual(score_completion("No final answer marker.", "12").status, "unparsed")
        self.assertEqual(score_completion(r"Answer: \boxed{1} or \boxed{2}", "1").status, "abstained")
        self.assertEqual(score_completion(r"Thus \boxed{240}.", "240").status, "correct")

    @patch('pilot_scoring._math_verify_available', return_value=False)
    def test_non_numeric_mismatch_is_not_overclaimed_incorrect(self, _mock):
        result = score_extracted_answer(r"x=1", r"x=-1")
        self.assertEqual(result.status, "unparsed")

    def test_timeout_must_be_positive(self):
        with self.assertRaises(ValueError):
            score_extracted_answer("1", "1", timeout_seconds=0)

    def test_public_record_is_json_serializable_and_uses_nullable_correct(self):
        correct = score_answer(r"Final answer: \boxed{240}", "240")
        uncertain = score_answer("I think the answer might be 240 or 241", "240")
        self.assertIs(correct["correct"], True)
        self.assertEqual(correct["status"], "correct")
        self.assertIsNone(uncertain["correct"])
        self.assertEqual(uncertain["status"], "abstained")
        json.dumps(correct)
        json.dumps(uncertain)


if __name__ == "__main__":
    unittest.main()