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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
"""Tests for the validation-predicate probe (harness/valprobe.py, docs/47).
The bundled FECS-promote matrix runs offline on the shipped 570.144 image
(skipped when the image is absent). No hardware, no module, no guest, no
network.
Run::
python3 -m unittest tests.test_valprobe -v
"""
from __future__ import annotations
import contextlib
import io
import json
import os
import struct
import sys
import tempfile
import unittest
HERE = os.path.dirname(os.path.abspath(__file__))
TOOL_ROOT = os.path.abspath(os.path.join(HERE, ".."))
if TOOL_ROOT not in sys.path:
sys.path.insert(0, TOOL_ROOT)
from sim.decode import K_JALR, K_LUI, K_OPI, decode32 # noqa: E402
from harness.rehost import DEFAULT_IMAGE, _parse_u64 # noqa: E402
from harness.valprobe import ( # noqa: E402
MATRIX_FORMAT,
PROBE_FORMAT,
PROMOTE_VALIDATION,
SPEC_FORMAT,
ValprobeError,
decode_memory_spec,
encode_return_stub,
fecs_spec,
main,
reg_index,
run_spec,
)
PROFILE = os.path.join(TOOL_ROOT, "sim", "profiles", "tu104-570.144.json")
def _run_main(argv: list[str]) -> tuple[int, str, str]:
out, err = io.StringIO(), io.StringIO()
with contextlib.redirect_stdout(out), contextlib.redirect_stderr(err):
rc = main(argv)
return rc, out.getvalue(), err.getvalue()
class EncodingTests(unittest.TestCase):
def test_stub_decodes_as_lui_addi_ret(self):
code = encode_return_stub(0x2FFFF9800)
self.assertEqual(len(code), 12)
words = struct.unpack("<III", code)
lui = decode32(0, words[0])
addi = decode32(4, words[1])
ret = decode32(8, words[2])
self.assertEqual(lui[0], K_LUI)
self.assertEqual(lui[2], 10)
self.assertEqual(addi[0], K_OPI)
self.assertEqual(addi[2], 10)
self.assertEqual(ret[0], K_JALR)
self.assertEqual(ret[1], 0) # jalr zero, 0(ra)
def test_stub_value_roundtrip(self):
# The lui+addi pair must reconstruct every value the probe uses
# (scratch addresses below 2^31, offset by the 12-bit signed addi).
for value in (0, 0x800, 0xFFF, 0x1234, 0x10000000, 0x1FFFFFFF, 0x7FFF_F000):
code = encode_return_stub(value)
hi = struct.unpack("<I", code[0:4])[0] >> 12
lo = struct.unpack("<I", code[4:8])[0] >> 20
if lo >= 0x800:
lo -= 0x1000
self.assertEqual((hi << 12) + lo, value)
def test_memory_spec_widths(self):
self.assertEqual(decode_memory_spec({"addr": "0x10", "hex": "aabb"}),
(0x10, b"\xaa\xbb"))
self.assertEqual(decode_memory_spec({"addr": "0x10", "u64": 1}),
(0x10, b"\x01" + b"\x00" * 7))
self.assertEqual(decode_memory_spec({"addr": "0x10", "u32": 2}),
(0x10, b"\x02\x00\x00\x00"))
self.assertEqual(decode_memory_spec({"addr": "0x10", "u16": 3}),
(0x10, b"\x03\x00"))
self.assertEqual(decode_memory_spec({"addr": "0x10", "u8": 4}),
(0x10, b"\x04"))
with self.assertRaises(ValprobeError):
decode_memory_spec({"addr": "0x10"})
def test_register_aliases(self):
for name, index in (("s2", 18), ("x18", 18), ("a3", 13), ("t1", 6), ("fp", 8)):
self.assertEqual(reg_index(name), index)
with self.assertRaises(ValprobeError):
reg_index("r99")
class SpecTests(unittest.TestCase):
def test_fecs_spec_shape(self):
spec = fecs_spec()
self.assertEqual(spec["format"], SPEC_FORMAT)
self.assertEqual(_parse_u64(spec["target"]), PROMOTE_VALIDATION)
self.assertGreaterEqual(len(spec["variants"]), 15)
for variant in spec["variants"]:
self.assertTrue(variant["label"])
self.assertIn(variant["expect"], set(spec["outcomes"].values()))
self.assertTrue(variant["stubs"])
def test_fecs_spec_layout_stays_inside_ram(self):
spec = fecs_spec()
profile_ram_mb = 12288
ram_hi = profile_ram_mb * 1024 * 1024
for variant in spec["variants"]:
for item in variant["memory"]:
self.assertLess(_parse_u64(item["addr"]) + 8, ram_hi)
def test_missing_spec_is_clean_error(self):
rc, _, err = _run_main(["run", "--spec", "/nonexistent/spec.json"])
self.assertEqual(rc, 2)
self.assertIn("error:", err)
@unittest.skipUnless(os.path.isfile(DEFAULT_IMAGE), "570.144 firmware absent")
class RealImageMatrixTests(unittest.TestCase):
def _reduced_spec(self) -> dict:
spec = fecs_spec()
keep = {
"FECS init vidmem, slot non-NULL",
"FECS init vidmem, slot NULL",
"FECS init sysmem attr 0x6, slot non-NULL",
"FECS no-init mapped, slot non-NULL",
"PM init",
}
spec["variants"] = [v for v in spec["variants"] if v["label"] in keep]
return spec
def test_matrix_reproduces_live_verdicts_deterministically(self):
spec = self._reduced_spec()
first = run_spec(spec=spec, profile_path=PROFILE, record=False, name="valprobe-test")
second = run_spec(spec=spec, profile_path=PROFILE, record=False, name="valprobe-test")
self.assertEqual(first["format"], MATRIX_FORMAT)
self.assertEqual(first["evaluated"], len(spec["variants"]))
self.assertEqual(first["failed"], 0)
verdicts_a = [(r["label"], r["outcome"]) for r in first["variants"]]
verdicts_b = [(r["label"], r["outcome"]) for r in second["variants"]]
self.assertEqual(verdicts_a, verdicts_b)
by_label = dict(verdicts_a)
self.assertEqual(by_label["FECS init vidmem, slot non-NULL"],
"refuse-fecs-slot-exists-0x1f")
self.assertEqual(by_label["FECS init vidmem, slot NULL"], "accept-commit-path")
self.assertEqual(by_label["FECS no-init mapped, slot non-NULL"], "accept-skip-path")
def test_probe_reports_firmware_slot_index_and_stub(self):
spec = self._reduced_spec()
spec["variants"] = [v for v in spec["variants"]
if v["label"] == "FECS init vidmem, slot non-NULL"]
matrix = run_spec(spec=spec, profile_path=PROFILE, record=False, name="valprobe-test")
row = matrix["variants"][0]
self.assertEqual(row["format"], PROBE_FORMAT)
self.assertEqual(row["status"], "outcome")
self.assertEqual(row["instructions"], row["instructions"])
self.assertTrue(row["stubs"])
slot_index = [r for r in row["reads"] if r.get("label") == "firmware-mapped-slot-index"]
self.assertEqual(slot_index[0]["u32"], 6) # firmware maps FECS -> slot 6
def test_boot_to_b3_then_probe(self):
spec = self._reduced_spec()
spec["variants"] = [v for v in spec["variants"]
if v["label"] == "FECS init vidmem, slot non-NULL"]
spec["boot_to"] = "B3"
matrix = run_spec(spec=spec, profile_path=PROFILE, record=False, name="valprobe-test")
row = matrix["variants"][0]
self.assertIsNotNone(row["boot"])
self.assertEqual(row["boot"]["rung"], "B3")
self.assertTrue(row["boot"]["reached"])
self.assertEqual(row["outcome"], "refuse-fecs-slot-exists-0x1f")
def test_matrix_writes_report_json(self):
spec = self._reduced_spec()
spec["variants"] = spec["variants"][:2]
with tempfile.TemporaryDirectory() as tmp:
matrix = run_spec(spec=spec, profile_path=PROFILE, out=tmp,
record=False, name="valprobe-test")
self.assertTrue(os.path.isfile(os.path.join(tmp, "valprobe-matrix.json")))
with open(matrix["report_json"], "r", encoding="utf-8") as fh:
doc = json.load(fh)
self.assertEqual(doc["format"], MATRIX_FORMAT)
self.assertEqual(len(doc["variants"]), 2)
def test_cli_sweep_returns_zero(self):
rc, out, _ = _run_main(["sweep", "--no-record"])
self.assertEqual(rc, 0)
self.assertIn("PASS", out)
if __name__ == "__main__":
unittest.main()
|
