def test_maze4(self):
maze = [
"XXXXXXXXX",
"XXXG..XXX",
"XXXXX.XXX",
"XX*...XXX",
"XXXXXXXXX"]
problem = MazeProblem(maze)
soln = Pathfinder.solve(self, problem)
soln_test = problem.solnTest(soln)
self.assertTrue(soln_test[1])
self.assertEqual(soln_test[0], 7)
def test_maze3(self):
maze = ["XXXXXXX",
"X.....X",
"X.M.MMX",
"X...M.X",
"XXXXXXX"]
problem = MazeProblem(maze)
initial = (5, 1)
goals = [(5, 3), (1, 3), (1, 1)]
soln = solve(problem, initial, goals)
(soln_cost, is_soln) = problem.soln_test(soln, initial, goals)
self.assertTrue(is_soln)
self.assertEqual(soln_cost, 12)
def test_maze9(self):
maze = [
"XXXGX", "X...X", "X.XXX", "X...X", "XXX.X", "X...X", "X.XXX",
"X...X", "XXX*X"
]
problem = MazeProblem(maze)
print("\n")
print("\n".join(problem.maze))
soln = Pathfinder.solve(problem)
solnTest = problem.solnTest(soln)
print(soln)
self.assertTrue(solnTest[1])
self.assertEqual(solnTest[0], 16)
def test_maze7(self):
maze = [
"XXXXXXXXXXXX", "X.MMMMMMMM.X", "X.MMMMMMMM.X", "X.M...M....X",
"X.M.M.M.MMMX", "X...M...M..X", "XXXXXXXXXXXX"
]
problem = MazeProblem(maze)
initial = (1, 1)
goals = [(10, 1), (10, 5)]
soln = Pathfinder.solve(problem, initial, goals)
(soln_cost, is_soln) = problem.soln_test(soln, initial, goals)
self.assertTrue(is_soln)
print(soln_cost)
self.assertEqual(soln_cost, 23)
def test_maze11(self):
maze = [
"XXXXXXXXXXXXXXXXXXXXXXXX", "XG.X................XXXX",
"XX.X*XXXXXXXXXX.XXX...XX", "X..XXX.......XX.X.XXX.XX",
"XX...XXXXXXX.XX.X.....XX", "X.X..X.....X.XXXXXX.XXXX",
"X.XX.X.X.X.X.XX...X..XXX", "X....X.X.X.X.XX.X.XX.XXX",
"XXXX...X.X......X....XXX", "XXXXXXXXXXXXXXXXXXXXXXXX"
]
problem = MazeProblem(maze)
soln = Pathfinder.solve(problem)
solnTest = problem.solnTest(soln)
self.assertTrue(solnTest[1])
self.assertEqual(solnTest[0], 64)
def test_maze5(self):
# Big boi test. Confirms that empirically, scales exactly as O(n!) should
maze = [
"XXXXXXXXXXXXXXXXXX", "X****************X", "X****************X",
"X****************X", "X****************X", "X****************X",
"X****************X", "X****************X", "XXXXXXXXXXXXXXXXXX"
]
problem = MazeProblem(maze)
initial = (3, 1)
goals = [(1, 5), (2, 5), (5, 4), (1, 7), (5, 5), (1, 6), (2, 2),
(6, 2), (5, 1), (3, 3)]
soln = solve(problem, initial, goals)
(soln_cost, is_soln) = problem.soln_test(soln, initial, goals)
print(soln)
self.assertTrue(is_soln)
def test_maze3(self):
maze = ["XXXXXXXXXXXX",\
"XG.......XGX",\
"X...XXX..X.X",\
"X...XGX..X.X",\
"X...XXX..X.X",\
"X.......XX.X",\
"X..........X",\
"X......XXXXX",\
"X.........*X",\
"XXXXXXXXXXXX"]
problem = MazeProblem(maze)
soln = Pathfinder.solve(problem)
soln_test = problem.soln_test(soln)
self.assertTrue(soln_test[1])
self.assertEqual(soln_test[0], 15)
def test_maze4(self):
maze = ["XXXXXXX", "X.....X", "X.M.XXX", "X...X.X", "XXXXXXX"]
problem = MazeProblem(maze)
initial = (5, 1)
goals = [(5, 3), (1, 3), (1, 1)]
soln = solve(problem, initial, goals)
self.assertTrue(soln == None)
def test_maze5(self):
#0123456789
maze = ["XXXXXXXXXX", #0
"X........X", #1
"X..MMMMXXX", #2
"X..M..M..X", #3
"XXXM..M..X", #4
"X..M..M..X", #5
"XXXXXXXXXX"] #6
problem = MazeProblem(maze)
initial = (1, 1)
goals = [(8, 1), (1, 3), (8, 3), (8, 5), (1, 5)]
soln = solve(problem, initial, goals)
(soln_cost, is_soln) = problem.soln_test(soln, initial, goals)
self.assertTrue(is_soln)
self.assertEqual(soln_cost, 34)
def getHeuristicCost(state, listOfGoals):
hScore = 1000
for goal in listOfGoals:
gHeuristic = MazeProblem.manhattanDist(state, goal)
if (gHeuristic < hScore):
hScore = gHeuristic
return hScore
def test_maze4(self):
maze = ["XXXXXX", "X....X", "X*.XXX", "X..XGX", "XXXXXX"]
problem = MazeProblem(maze)
print("\n")
print("\n".join(problem.maze))
soln = Pathfinder.solve(problem)
print(soln)
self.assertFalse(soln)
def test_maze8(self):
maze = [
"XXXXXXXXXXX", "X.X..MX...X", "X.XMM.MM.XX", "XM..XMM.X.X",
"X.X....MX.X", "X..MX.X..XX", "X.M..X..X.X", "XXXXXXXXXXX"
]
problem = MazeProblem(maze)
initial = (5, 2)
goals = [(9, 1), (9, 6), (1, 1), (4, 6), (5, 5)]
soln = solve(problem, initial, goals)
self.assertTrue(soln == None)
def test_maze6(self):
maze = [
"XXXXXXXXXXXX", "X.MMMMMMMM.X", "X.XXXXXXXX.X", "X.X...X....X",
"X.X.X.X.XXXX", "X...X...X..X", "XXXXXXXXXXXX"
]
problem = MazeProblem(maze)
initial = (1, 1)
goals = [(10, 1), (10, 5)]
soln = Pathfinder.solve(problem, initial, goals)
self.assertTrue(soln == None)
def test_maze10(self):
# 11111111112
#012345678901234567890
maze = ["XXXXXXXXXXXXXXXXXXXXX", #0
"X..X....M....X..M.X.X", #1
"X...X..M.M..M..MM..MX", #2
"XMM..XMMMMM..X....X.X", #3
"X..M..X.........M...X", #4
"XX.......XX.XXMXXMM.X", #5
"X.XXX.MM....X...X...X", #6
"X...X.MM....M.XX..XXX", #7
"XXM.X..MMMMMX..M..X.X", #8
"X.X.........X..M....X", #9
"XXXXXXXXXXXXXXXXXXXXX"] #10
problem = MazeProblem(maze)
initial = (1, 1)
goals = [(8, 2), (1, 4), (4, 1), (12, 2), (18, 2), (1, 6), (6, 8), (8, 7), (13, 6), (19, 8)]
soln = solve(problem, initial, goals)
(soln_cost, is_soln) = problem.soln_test(soln, initial, goals)
self.assertTrue(is_soln)
self.assertEqual(soln_cost, 93)
def test_maze6(self):
#0123456789
maze = ["XXXXXXXXXX", #0
"X........X", #1
"X..MMMMXXX", #2
"X..M..M..X", #3
"XXXM..M..X", #4
"X..X..M..X", #5
"XXXXXXXXXX"] #6
problem = MazeProblem(maze)
initial = (1, 1)
goals = [(8, 1), (1, 3), (8, 3), (8, 5), (1, 5)]
soln = solve(problem, initial, goals)
self.assertTrue(soln is None)
def test_maze7(self):
# 11111111112
#012345678901234567890
maze = ["XXXXXXXXXXXXXXXXXXXXX", #0
"X..X....M....X..M.X.X", #1
"X...X..M.M..M..MM..MX", #2
"XMM..XMMMMM..X....X.X", #3
"X..M..X.........M...X", #4
"XX.......XX.XXMXXMM.X", #5
"X.XXX.MM....X...X...X", #6
"X...X.MM....M.XX..XXX", #7
"XXM.X..MMMMMX..M..X.X", #8
"X.X.........X..M....X", #9
"XXXXXXXXXXXXXXXXXXXXX"] #10
problem = MazeProblem(maze)
initial = (10, 4)
goals = [(1, 1), (19, 1), (19, 8), (1, 9)]
soln = solve(problem, initial, goals)
self.assertTrue(soln is None)
def test_maze4(self):
maze = ["XXXXXX", "X....X", "X*.XXX", "X..XGX", "XXXXXX"]
problem = MazeProblem(maze)
soln = Pathfinder.solve(problem)
self.assertFalse(soln)
