| """Torch-free tests for the 13x13 difficulty ladder and the graded |
| generator behind it. |
| |
| Run from the repository root with the package installed. |
| """ |
| from maze_lab.difficulty import (GRID_SIZE, LEVEL_SPECS, LEVELS, ROOMS, analyse, |
| build, qualifies, search_seeds, suite) |
| from maze_lab.maze_generator import (_carve, _pick_start_goal, _room_path, |
| generate_graded_maze) |
| from maze_lab.benchmark import score |
|
|
|
|
| def test_every_maze_is_exactly_13x13(): |
| for level, seed, m, _st in suite(): |
| assert len(m.grid) == GRID_SIZE == 13, f"L{level} seed={seed}: {len(m.grid)} rows" |
| assert all(len(row) == 13 for row in m.grid), f"L{level} seed={seed}: ragged grid" |
|
|
|
|
| def test_every_maze_is_solvable(): |
| for level, seed, m, st in suite(): |
| assert m.bfs_distance_to_goal(m.start) is not None, f"L{level} seed={seed} unreachable" |
| assert m.simulate(m.start, st["solution"])["reached_goal"] |
|
|
|
|
| def test_recorded_seeds_still_qualify(): |
| """The hardcoded LEVELS must match what LEVEL_SPECS asks for -- this is |
| what stops a tweak to the generator from silently re-grading the suite.""" |
| for level, seeds in LEVELS.items(): |
| assert len(seeds) == 3, f"L{level} has {len(seeds)} seeds, expected 3" |
| for seed in seeds: |
| assert qualifies(level, build(level, seed)), ( |
| f"L{level} seed={seed} no longer meets {LEVEL_SPECS[level]}") |
|
|
|
|
| def test_seeds_are_distinct_across_levels(): |
| flat = [s for seeds in LEVELS.values() for s in seeds] |
| assert len(flat) == len(set(flat)), "a seed is reused across levels" |
|
|
|
|
| def test_difficulty_increases_monotonically(): |
| """Mean route length and mean decision points must both rise with level |
| -- otherwise the 'ladder' isn't one.""" |
| means = {} |
| for level in sorted(LEVELS): |
| rows = [analyse(build(level, s)) for s in LEVELS[level]] |
| means[level] = (sum(r["moves"] for r in rows) / len(rows), |
| sum(r["decision_pts"] for r in rows) / len(rows)) |
| levels = sorted(means) |
| for lo, hi in zip(levels, levels[1:]): |
| assert means[hi][0] > means[lo][0], f"L{hi} no longer than L{lo}: {means}" |
| assert means[hi][1] >= means[lo][1], f"L{hi} has fewer decisions than L{lo}: {means}" |
|
|
|
|
| def test_traps_never_create_a_shortcut(): |
| """The core safety property of graded traps: the route through the |
| finished maze is exactly the room path, two char-moves per room hop. |
| Any trap that opened a shortcut or a loop would make this shorter.""" |
| import random |
| for seed in range(30): |
| m = generate_graded_maze(seed, rooms=ROOMS, target_moves=40, n_traps=8, max_trap_depth=4) |
| passages = _carve(random.Random(seed), ROOMS) |
| a, b, _da = _pick_start_goal(passages, ROOMS, 40) |
| expected = 2 * (len(_room_path(passages, ROOMS, a, b)) - 1) |
| assert m.bfs_distance_to_goal(m.start) == expected, f"seed={seed} shortcut opened" |
|
|
|
|
| def test_graded_generator_is_deterministic(): |
| a = generate_graded_maze(5, rooms=ROOMS, target_moves=40, n_traps=6, max_trap_depth=3) |
| b = generate_graded_maze(5, rooms=ROOMS, target_moves=40, n_traps=6, max_trap_depth=3) |
| assert a.grid == b.grid and a.start == b.start and a.goal == b.goal |
|
|
|
|
| def test_graded_generator_beats_sparse_on_decision_points(): |
| """The reason generate_graded_maze exists at all -- if this stops being |
| true, use generate_sparse_maze and delete the new one.""" |
| from maze_lab.maze_generator import generate_sparse_maze |
| def mean_dp(fn): |
| return sum(analyse(fn(s))["decision_pts"] for s in range(30)) / 30 |
| graded = mean_dp(lambda s: generate_graded_maze(s, rooms=ROOMS, target_moves=40, |
| n_traps=6, max_trap_depth=3)) |
| sparse = mean_dp(lambda s: generate_sparse_maze(s, rooms=ROOMS, target_moves=40, |
| n_traps=6, max_trap_depth=3)) |
| assert graded > sparse + 1.0, f"graded={graded:.2f} vs sparse={sparse:.2f}" |
|
|
|
|
| def test_search_is_reproducible(): |
| assert search_seeds(2, want=3, exclude=set(LEVELS[1])) == LEVELS[2] |
|
|
|
|
| def test_scoring_grades_each_failure_kind(): |
| _lvl, _seed, m, st = suite()[0] |
| ident = lambda r: r |
|
|
| good = score(m, st["solution"], ident) |
| assert good["solved"] and good["failure"] is None |
|
|
| assert score(m, None, ident)["failure"] == "no_final_answer" |
|
|
| truncated = score(m, st["solution"][:3], ident) |
| assert not truncated["solved"] and truncated["failure"] == "stopped_short" |
| assert truncated["dist_remaining"] == len(st["solution"]) - 3 |
|
|
| gave_up = score(m, "no path exists.", ident) |
| assert not gave_up["solved"] and gave_up["failure"] == "no_moves_in_answer" |
|
|
| |
| flip = {"U": "D", "D": "U", "L": "R", "R": "L"} |
| wall = score(m, flip[st["solution"][0]], ident) |
| assert not wall["solved"] and wall["failure"] == "hit_wall" |
| assert wall["valid_prefix_len"] == 0 |
|
|
|
|
| def _main(): |
| fns = [v for k, v in sorted(globals().items()) if k.startswith("test_")] |
| for fn in fns: |
| fn() |
| print(f" ok {fn.__name__}") |
| print(f"\n{len(fns)} tests passed") |
|
|
|
|
| if __name__ == "__main__": |
| _main() |
|
|
