def testHuntAndKill(self):
m = Maze()
m.generator = HuntAndKill(4, 5)
m.generate()
self.assertTrue(self.boundary_is_solid(m.grid))
self.assertTrue(self.all_passages_open(m.grid))
self.assertTrue(self.all_corners_complete(m.grid))
def testGrowingTree(self):
m = Maze()
m.generator = GrowingTree(4, 5)
m.generate()
self.assertTrue(self.boundary_is_solid(m.grid))
self.assertTrue(self.all_passages_open(m.grid))
self.assertTrue(self.all_corners_complete(m.grid))
def testDivision(self):
m = Maze()
m.generator = Division(4, 5)
m.generate()
self.assertTrue(self.boundary_is_solid(m.grid))
self.assertTrue(self.all_passages_open(m.grid))
self.assertTrue(self.all_corners_complete(m.grid))
def testBacktrackingGenerator(self):
m = Maze()
m.generator = BacktrackingGenerator(4, 5)
m.generate()
self.assertTrue(self.boundary_is_solid(m.grid))
self.assertTrue(self.all_passages_open(m.grid))
self.assertTrue(self.all_corners_complete(m.grid))
def testAldousBroder(self):
m = Maze()
m.generator = AldousBroder(4, 5)
m.generate()
self.assertTrue(self.boundary_is_solid(m.grid))
self.assertTrue(self.all_passages_open(m.grid))
self.assertTrue(self.all_corners_complete(m.grid))
def test_sidewinder(self):
""" test the Sidewinder method generates a reasonably sane maze """
m = Maze()
m.generator = Sidewinder(4, 5)
m.generate()
assert boundary_is_solid(m.grid)
assert all_passages_open(m.grid)
assert all_corners_complete(m.grid)
def test_kruskal(self):
""" test the Kruskal method generates a reasonably sane maze """
m = Maze()
m.generator = Kruskal(4, 5)
m.generate()
assert boundary_is_solid(m.grid)
assert all_passages_open(m.grid)
assert all_corners_complete(m.grid)
def test_hunt_and_kill_serpentine_order(self):
""" test the Hunt and Kill method generates a reasonably sane maze, using the serpentine pathway """
m = Maze()
m.generator = HuntAndKill(4, 5, 'serpentine')
m.generate()
assert boundary_is_solid(m.grid)
assert all_passages_open(m.grid)
assert all_corners_complete(m.grid)
def test_aldous_broder(self):
""" test the AlgousBroder method generates a reasonably sane maze """
m = Maze()
m.generator = AldousBroder(4, 5)
m.generate()
assert boundary_is_solid(m.grid)
assert all_passages_open(m.grid)
assert all_corners_complete(m.grid)
def test_backtracking_generator(self):
""" test the Backtracking method generates a reasonably sane maze """
m = Maze()
m.generator = BacktrackingGenerator(4, 5)
m.generate()
assert boundary_is_solid(m.grid)
assert all_passages_open(m.grid)
assert all_corners_complete(m.grid)
def test_binary_tree(self):
""" test the Binary Tree method generates a reasonably sane maze """
m = Maze()
m.generator = BinaryTree(4, 5)
m.generate()
assert boundary_is_solid(m.grid)
assert all_passages_open(m.grid)
assert all_corners_complete(m.grid)
def test_division(self):
""" test the Division method generates a reasonably sane maze """
m = Maze()
m.generator = Division(4, 5)
m.generate()
assert boundary_is_solid(m.grid)
assert all_passages_open(m.grid)
assert all_corners_complete(m.grid)
def test_trivial_maze_spiral(self):
m = Maze()
m.generator = TrivialMaze(4, 5)
m.generate()
self.assertTrue(boundary_is_solid(m.grid))
self.assertTrue(all_passages_open(m.grid))
self.assertTrue(all_corners_complete(m.grid))
self.assertTrue(all_corners_complete(m.grid))
def test_wilsons_serpentine_order(self):
""" test the Wilson method generates a reasonably sane maze, using the serpentine pathway """
m = Maze()
m.generator = Wilsons(4, 5, hunt_order='serpentine')
m.generate()
assert boundary_is_solid(m.grid)
assert all_passages_open(m.grid)
assert all_corners_complete(m.grid)
def test_set_seed(self):
""" Test the Maze.set_seed staticmethod, to make sure we can control the random seeding """
m = Maze(123)
m.generator = Prims(7, 7)
m.generate()
grid0 = str(m)
m = Maze(123)
m.generator = Prims(7, 7)
m.generate()
grid1 = str(m)
assert grid0 == grid1
m.generator = Prims(7, 7)
m.generate()
grid2 = str(m)
assert grid0 != grid2
def test_trivial_maze_spiral(self):
""" test that the trivial/spiral maze is reasonably sane """
m = Maze()
m.generator = TrivialMaze(4, 5)
m.generate()
assert boundary_is_solid(m.grid)
assert all_passages_open(m.grid)
assert all_corners_complete(m.grid)
assert all_corners_complete(m.grid)
def test_trivial_maze_serpentine(self):
# run this test enough times to trip the different skewness parameters
for _ in range(10):
m = Maze()
m.generator = TrivialMaze(4, 5, 'serpentine')
m.generate()
self.assertTrue(boundary_is_solid(m.grid))
self.assertTrue(all_passages_open(m.grid))
self.assertTrue(all_corners_complete(m.grid))
def test_dungeon_rooms_serpentine_rooms(self):
m = Maze()
m.generator = DungeonRooms(4,
4,
rooms=[[(1, 1), (3, 3)]],
hunt_order='serpentine')
m.generate()
self.assertTrue(boundary_is_solid(m.grid))
self.assertTrue(all_passages_open(m.grid))
def test_prune_solution(self):
""" test the solution-pruning helper method """
# build a test Maze and solver, just as placeholders
m = Maze()
m.solver = RandomMouse()
m.solver.start = (0, 1)
m.solver.end = (0, 5)
# test the pruner does nothing if nothing needs to be done
sol = [(1, 1), (1, 2), (1, 3), (1, 4), (1, 5)]
assert sol == m.solver._prune_solution(sol)
# test the pruner correctly prunes one duplicate
sol1 = [(1, 1), (1, 2), (1, 3), (1, 4), (2, 4), (3, 4), (2, 4), (1, 4),
(1, 5)]
assert sol == m.solver._prune_solution(sol1)
# test the pruner correctly prunes two duplicates
sol2 = [(1, 1), (1, 2), (1, 3), (1, 4), (2, 4), (3, 4), (2, 4), (1, 4),
(2, 4), (3, 4), (2, 4), (1, 4), (1, 5)]
assert sol == m.solver._prune_solution(sol2)
# test the pruner correctly prunes the end point from the solution
sol3 = [(1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (0, 5)]
assert sol == m.solver._prune_solution(sol3)
# test the pruner correctly prunes the start point from the solution
sol4 = [(0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5)]
assert sol == m.solver._prune_solution(sol4)
# test the pruner correctly prunes the start points and end points from the solution
sol5 = [(0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5), (0, 5)]
assert sol == m.solver._prune_solution(sol5)
# test the pruner correctly prunes multiple start points and end points from the solution
sol6 = [(0, 1), (0, 1), (0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (1, 5),
(0, 5), (0, 5)]
assert sol == m.solver._prune_solution(sol6)
# test the pruner correctly prunes a complex mess of a solution
sol7 = [(0, 1), (0, 1), (0, 1), (1, 1), (1, 2), (1, 3), (1, 4), (2, 4),
(3, 4), (2, 4), (1, 4), (1, 5), (0, 5), (0, 5)]
assert sol == m.solver._prune_solution(sol7)
# bonus: let's tests a long, and heavily redundant, solution
assert sol == m.solver._prune_solution(sol7 * 100)
# let's also test a couple edge cases
sol = []
assert sol == m.solver._prune_solution(sol)
sol = [(1, 1)]
assert sol == m.solver._prune_solution(sol)
sol = [(1, 1), (1, 2)]
assert sol == m.solver._prune_solution(sol)
sol = [(1, 1), (1, 2)]
assert sol == m.solver._prune_solution(sol * 100)
def test_perturbation(self):
m = Maze()
m.generator = TrivialMaze(4, 5)
m.generate()
m.transmuters = [Perturbation()]
m.transmute()
self.assertTrue(boundary_is_solid(m.grid))
self.assertTrue(all_passages_open(m.grid))
self.assertTrue(all_corners_complete(m.grid))
def testOuterEntrances(self):
h = 4
w = 5
m = Maze()
m.generator = Prims(h, w)
m.generate()
m.generate_entrances()
self.assertTrue(self._on_edge(m.grid, m.start))
self.assertTrue(self._on_edge(m.grid, m.end))
def testInnerEntrances(self):
h = 4
w = 5
m = Maze()
m.generator = Prims(h, w)
m.generate()
m.generate_entrances(False, False)
self.assertFalse(self._on_edge(m.grid, m.start))
self.assertFalse(self._on_edge(m.grid, m.end))
def test_dungeon_rooms_random_rooms(self):
""" test Dungeon Rooms maze-creation mazes a reasonably sane maze when generating some random rooms """
m = Maze()
m.generator = DungeonRooms(4,
4,
rooms=[[(1, 1), (3, 3)]],
hunt_order='random')
m.generate()
assert boundary_is_solid(m.grid)
assert all_passages_open(m.grid)
def test_dungeon_rooms_serpentine_rooms(self):
""" test DungeonRooms mazes are reasonably when generating some random rooms in a serpentine fashion """
m = Maze()
m.generator = DungeonRooms(4,
4,
rooms=[[(1, 1), (3, 3)]],
hunt_order='serpentine')
m.generate()
assert boundary_is_solid(m.grid)
assert all_passages_open(m.grid)
def testGridSize(self):
h = 4
w = 5
H = 2 * h + 1
W = 2 * w + 1
m = Maze()
m.generator = Prims(h, w)
m.generate()
self.assertEqual(m.grid.height, H)
self.assertEqual(m.grid.width, W)
def testGridSize(self):
h = 4
w = 5
H = 2 * h + 1
W = 2 * w + 1
m = Maze()
m.generator = Prims(h, w)
m.generate()
self.assertEqual(m.grid.shape[0], H)
self.assertEqual(m.grid.shape[1], W)
def test_perturbation(self):
""" Test the Perturbation algorithm leaves the maze in a solvable state """
m = Maze()
m.generator = TrivialMaze(4, 5)
m.generate()
m.transmuters = [Perturbation()]
m.transmute()
assert boundary_is_solid(m.grid)
assert all_passages_open(m.grid)
assert all_corners_complete(m.grid)
def test_outer_entrances(self):
""" Test that the entrances can be correctly generated on the edges of the map """
h = 4
w = 5
m = Maze()
m.generator = Prims(h, w)
m.generate()
m.generate_entrances()
assert self._on_edge(m.grid, m.start)
assert self._on_edge(m.grid, m.end)
def test_trivial_maze_serpentine(self):
""" test that the trivial/spiral maze is reasonably sane when using the serpentine alternative
run this test enough times to trip the different skewness parameters
"""
for _ in range(10):
m = Maze()
m.generator = TrivialMaze(4, 5, 'serpentine')
m.generate()
assert boundary_is_solid(m.grid)
assert all_passages_open(m.grid)
assert all_corners_complete(m.grid)
def testGeneratorWipe(self):
h = 4
w = 5
m = Maze()
m.generator = Prims(h, w)
m.generate()
m.generate_entrances()
m.generate()
self.assertTrue(m.start is None)
self.assertTrue(m.end is None)
self.assertTrue(m.solutions is None)
