149 lines
5.0 KiB
Python
149 lines
5.0 KiB
Python
"""Tests for maze generation algorithms."""
|
|
|
|
import pytest
|
|
from src.generators import (
|
|
RecursiveBacktrackingGenerator,
|
|
KruskalGenerator,
|
|
PrimGenerator,
|
|
SidewinderGenerator,
|
|
HuntAndKillGenerator,
|
|
EllerGenerator,
|
|
WilsonGenerator,
|
|
AldousBroderGenerator
|
|
)
|
|
|
|
|
|
# All generators to test
|
|
GENERATORS = [
|
|
RecursiveBacktrackingGenerator(),
|
|
KruskalGenerator(),
|
|
PrimGenerator(),
|
|
SidewinderGenerator(),
|
|
HuntAndKillGenerator(),
|
|
EllerGenerator(),
|
|
WilsonGenerator(),
|
|
AldousBroderGenerator()
|
|
]
|
|
|
|
|
|
class TestGenerators:
|
|
"""Test all maze generation algorithms."""
|
|
|
|
@pytest.mark.parametrize("generator", GENERATORS)
|
|
def test_generator_creates_valid_maze(self, generator):
|
|
"""Test that generator creates a valid maze."""
|
|
maze = generator.generate(10, 10, seed=42)
|
|
|
|
assert maze is not None
|
|
assert maze.rows == 10
|
|
assert maze.cols == 10
|
|
assert maze.algorithm_used == generator.name
|
|
assert maze.generation_time_ms >= 0
|
|
|
|
@pytest.mark.parametrize("generator", GENERATORS)
|
|
def test_generator_with_different_sizes(self, generator):
|
|
"""Test generator with different maze sizes."""
|
|
# Small maze
|
|
maze_small = generator.generate(5, 5, seed=42)
|
|
assert maze_small.rows == 5
|
|
assert maze_small.cols == 5
|
|
|
|
# Large maze
|
|
maze_large = generator.generate(25, 25, seed=42)
|
|
assert maze_large.rows == 25
|
|
assert maze_large.cols == 25
|
|
|
|
@pytest.mark.parametrize("generator", GENERATORS)
|
|
def test_generator_reproducibility(self, generator):
|
|
"""Test that same seed produces same maze."""
|
|
maze1 = generator.generate(10, 10, seed=42)
|
|
maze2 = generator.generate(10, 10, seed=42)
|
|
|
|
# Compare wall structures
|
|
for row in range(10):
|
|
for col in range(10):
|
|
cell1 = maze1.get_cell(row, col)
|
|
cell2 = maze2.get_cell(row, col)
|
|
assert cell1.walls == cell2.walls
|
|
|
|
@pytest.mark.parametrize("generator", GENERATORS)
|
|
def test_maze_is_fully_connected(self, generator):
|
|
"""Test that all cells in maze are reachable."""
|
|
maze = generator.generate(10, 10, seed=42)
|
|
|
|
# Use BFS to check connectivity
|
|
start = maze.get_cell(0, 0)
|
|
visited = set()
|
|
queue = [start]
|
|
start.visited = True
|
|
|
|
while queue:
|
|
current = queue.pop(0)
|
|
visited.add((current.row, current.col))
|
|
|
|
neighbors = maze.get_neighbors(current)
|
|
for neighbor, direction in neighbors:
|
|
if not neighbor.visited and not current.has_wall(direction):
|
|
neighbor.visited = True
|
|
queue.append(neighbor)
|
|
|
|
# All cells should be reachable
|
|
assert len(visited) == maze.rows * maze.cols
|
|
|
|
@pytest.mark.parametrize("generator", GENERATORS)
|
|
def test_maze_has_passages(self, generator):
|
|
"""Test that maze has passages (some walls removed)."""
|
|
maze = generator.generate(10, 10, seed=42)
|
|
|
|
total_walls = 0
|
|
for row in maze.grid:
|
|
for cell in row:
|
|
total_walls += sum(1 for wall in cell.walls.values() if wall)
|
|
|
|
# Should have fewer walls than a completely walled maze
|
|
max_walls = 10 * 10 * 4
|
|
assert total_walls < max_walls
|
|
|
|
@pytest.mark.parametrize("generator", GENERATORS)
|
|
def test_generator_performance(self, generator):
|
|
"""Test generator meets performance targets."""
|
|
# 10x10 should be very fast
|
|
maze = generator.generate(10, 10, seed=42)
|
|
assert maze.generation_time_ms < 1000 # Less than 1 second
|
|
|
|
# Even 25x25 should be reasonable (except Aldous-Broder can be slow)
|
|
if generator.name != "Aldous-Broder Algorithm":
|
|
maze = generator.generate(25, 25, seed=42)
|
|
assert maze.generation_time_ms < 5000 # Less than 5 seconds
|
|
|
|
|
|
class TestSpecificGenerators:
|
|
"""Test specific generator properties."""
|
|
|
|
def test_recursive_backtracking_name(self):
|
|
"""Test recursive backtracking has correct name."""
|
|
gen = RecursiveBacktrackingGenerator()
|
|
assert gen.name == "Recursive Backtracking"
|
|
|
|
def test_kruskal_name(self):
|
|
"""Test Kruskal's has correct name."""
|
|
gen = KruskalGenerator()
|
|
assert gen.name == "Kruskal's Algorithm"
|
|
|
|
def test_prim_name(self):
|
|
"""Test Prim's has correct name."""
|
|
gen = PrimGenerator()
|
|
assert gen.name == "Prim's Algorithm"
|
|
|
|
def test_sidewinder_creates_valid_maze(self):
|
|
"""Test Sidewinder algorithm."""
|
|
gen = SidewinderGenerator()
|
|
maze = gen.generate(10, 10, seed=42)
|
|
|
|
# Top row should have all east walls removed (characteristic of Sidewinder)
|
|
# Check that top row is mostly connected horizontally
|
|
top_row = maze.grid[0]
|
|
east_walls = sum(1 for cell in top_row if cell.has_wall('east'))
|
|
# Should have mostly removed east walls in top row
|
|
assert east_walls < len(top_row)
|