def test_heuristic_manhattan(self):
size = 3
seed = 1
puzzle = SlidingTilePuzzle(size, seed)
distance = puzzle.heuristic('manhattan distance')
expected_distance = 3 + 2 + 2 + 1 + 1 + 3 + 3 + 3 + 2
self.assertEqual(distance, expected_distance)
def test_equals_false(self):
size = 3
seed1 = 1
seed2 = 2
a = SlidingTilePuzzle(size, seed1)
b = SlidingTilePuzzle(size, seed2)
self.assertFalse(a.equals(b))
def test_manhattan_distance_incomplete(self):
size = 3
seed = 1
puzzle = SlidingTilePuzzle(size, seed)
distance = puzzle.manhattan_distance()
expected_distance = 3 + 2 + 2 + 1 + 1 + 3 + 3 + 3 + 2
self.assertEqual(distance, expected_distance)
def test_misplaced_tiles_some(self):
size = 3
seed = 4
puzzle = SlidingTilePuzzle(size, seed)
num_tiles = puzzle.misplaced_tiles()
expected_num = 8
self.assertEqual(num_tiles, expected_num)
def test_heuristic_manhattan(self):
size = 3
seed = 1
puzzle = SlidingTilePuzzle(size, seed)
distance = puzzle.heuristic('manhattan distance')
expected_distance = 3 + 2 + 2 + 1 + 1 + 3 + 3 + 3 + 2
self.assertEqual(distance, expected_distance)
def test_value(self):
size = 2
seed = 1
puzzle = SlidingTilePuzzle(size, seed)
puzzle_value = puzzle.value()
expected_value = (3, 0, 2, 1)
self.assertEqual(puzzle_value, expected_value)
def test_manhattan_distance_incomplete(self):
size = 3
seed = 1
puzzle = SlidingTilePuzzle(size, seed)
distance = puzzle.manhattan_distance()
expected_distance = 3 + 2 + 2 + 1 + 1 + 3 + 3 + 3 + 2
self.assertEqual(distance, expected_distance)
def test_heuristic_misplaced(self):
size = 3
seed = 4
puzzle = SlidingTilePuzzle(size, seed)
num_tiles = puzzle.heuristic('misplaced tiles')
expected_num = 8
self.assertEqual(num_tiles, expected_num)
def test_misplaced_tiles_some(self):
size = 3
seed = 4
puzzle = SlidingTilePuzzle(size, seed)
num_tiles = puzzle.misplaced_tiles()
expected_num = 8
self.assertEqual(num_tiles, expected_num)
def test_equals_false(self):
size = 3
seed1 = 1
seed2 = 2
a = SlidingTilePuzzle(size, seed1)
b = SlidingTilePuzzle(size, seed2)
self.assertFalse(a.equals(b))
def test_heuristic_misplaced(self):
size = 3
seed = 4
puzzle = SlidingTilePuzzle(size, seed)
num_tiles = puzzle.heuristic('misplaced tiles')
expected_num = 8
self.assertEqual(num_tiles, expected_num)
def test_value(self):
size = 2
seed = 1
puzzle = SlidingTilePuzzle(size, seed)
puzzle_value = puzzle.value()
expected_value = (3, 0, 2, 1)
self.assertEqual(puzzle_value, expected_value)
def test_misplaced_tiles_rectangle(self):
size1 = 2
size2 = 3
seed = 1
puzzle = SlidingTilePuzzle(size1, seed, size2)
num_tiles = puzzle.misplaced_tiles()
expected_num = 5
self.assertEqual(num_tiles, expected_num)
def test_correct_tile(self):
size = 3
puzzle = SlidingTilePuzzle(size)
number = 0
for i in range(size):
for j in range(size):
self.assertEqual(puzzle.correct_tile(number), (i, j))
number += 1
def test_manhattan_distance_rectangle(self):
size1 = 2
size2 = 3
seed = 1
puzzle = SlidingTilePuzzle(size1, seed, size2)
num_tiles = puzzle.manhattan_distance()
expected_num = 1 + 2 + 2 + 2 + 0 + 1
self.assertEqual(num_tiles, expected_num)
def test_misplaced_tiles_rectangle(self):
size1 = 2
size2 = 3
seed = 1
puzzle = SlidingTilePuzzle(size1, seed, size2)
num_tiles = puzzle.misplaced_tiles()
expected_num = 5
self.assertEqual(num_tiles, expected_num)
def test_correct_tile(self):
size = 3
puzzle = SlidingTilePuzzle(size)
number = 0
for i in range(size):
for j in range(size):
self.assertEqual(puzzle.correct_tile(number), (i, j))
number += 1
def test_manhattan_distance_rectangle(self):
size1 = 2
size2 = 3
seed = 1
puzzle = SlidingTilePuzzle(size1, seed, size2)
num_tiles = puzzle.manhattan_distance()
expected_num = 1 + 2 + 2 + 2 + 0 + 1
self.assertEqual(num_tiles, expected_num)
def test_search_solution(self):
state = SlidingTilePuzzle(2, 10)
time = 5
search = BreadthFirstSearch(state, time)
solution = search.search()
for move in solution:
state.apply_move(move)
self.assertTrue(state.is_solved())
def test_correct_tile_rectangle(self):
size1 = 2
size2 = 3
puzzle = SlidingTilePuzzle(size1=size1, size2=size2)
number = 0
for i in range(size1):
for j in range(size2):
self.assertEqual(puzzle.correct_tile(number), (i, j))
number += 1
def test_search_solution(self):
state = SlidingTilePuzzle(2, 10)
time = 5
search = BreadthFirstSearch(state, time)
solution = search.search()
for move in solution:
state.apply_move(move)
self.assertTrue(state.is_solved())
def test_correct_tile_rectangle(self):
size1 = 2
size2 = 3
puzzle = SlidingTilePuzzle(size1=size1, size2=size2)
number = 0
for i in range(size1):
for j in range(size2):
self.assertEqual(puzzle.correct_tile(number), (i, j))
number += 1
def test_correct_num_rectangle(self):
size1 = 3
size2 = 2
puzzle = SlidingTilePuzzle(size1=size1, size2=size2)
number = 0
for i in range(size1):
for j in range(size2):
self.assertEqual(puzzle.correct_num((i, j)), number)
number += 1
def test_correct_num_rectangle(self):
size1 = 3
size2 = 2
puzzle = SlidingTilePuzzle(size1=size1, size2=size2)
number = 0
for i in range(size1):
for j in range(size2):
self.assertEqual(puzzle.correct_num((i, j)), number)
number += 1
def test_update_frontier_false(self):
state = SlidingTilePuzzle(3, 1)
time = 10
heuristic = 'misplaced tiles'
search = AStar(state, time, heuristic)
state2 = SlidingTilePuzzle(3, 2)
move = SlidingTilePuzzle.DIRECTIONS['up']
node = Node(state2, move, search.rootnode, heuristic)
self.assertFalse(search._update_frontier(node))
def test_apply_move_up(self):
size = 2
seed = 5
puzzle = SlidingTilePuzzle(size, seed)
puzzle.apply_move(SlidingTilePuzzle.DIRECTIONS['up'])
self.assertEqual(puzzle.puzzle[(0, 0)], 3)
self.assertEqual(puzzle.puzzle[(0, 1)], 1)
self.assertEqual(puzzle.puzzle[(1, 0)], 0)
self.assertEqual(puzzle.puzzle[(1, 1)], 2)
self.assertEqual(puzzle.puzzle[puzzle.blank_index], 0)
def test_str_moves(self):
size = 4
seed = 2
puzzle = SlidingTilePuzzle(size, seed)
moves = puzzle.valid_moves()
string_moves = puzzle.str_moves(moves)
string_moves.sort()
expected_moves = ['up', 'down', 'left', 'right']
expected_moves.sort()
self.assertEqual(string_moves, expected_moves)
def test_search_manhattan_distance(self):
state = SlidingTilePuzzle(2, 10)
time = 5
heuristic = 'manhattan distance'
search = AStar(state, time, heuristic)
solution = search.search()
for move in solution:
state.apply_move(move)
self.assertTrue(state.is_solved())
def test_valid_moves_some(self):
size = 2
seed = 1
puzzle = SlidingTilePuzzle(size, seed)
moves = puzzle.valid_moves()
moves.sort()
expected_moves = [SlidingTilePuzzle.DIRECTIONS['up'],
SlidingTilePuzzle.DIRECTIONS['right']]
expected_moves.sort()
self.assertEqual(moves, expected_moves)
def test_str_moves(self):
size = 4
seed = 2
puzzle = SlidingTilePuzzle(size, seed)
moves = puzzle.valid_moves()
string_moves = puzzle.str_moves(moves)
string_moves.sort()
expected_moves = ['up', 'down', 'left', 'right']
expected_moves.sort()
self.assertEqual(string_moves, expected_moves)
def test_search_misplaced_tiles(self):
state = SlidingTilePuzzle(2, 10)
time = 5
heuristic = 'misplaced tiles'
search = AStar(state, time, heuristic)
solution = search.search()
for move in solution:
state.apply_move(move)
self.assertTrue(state.is_solved())
def test_apply_move_up(self):
size = 2
seed = 5
puzzle = SlidingTilePuzzle(size, seed)
puzzle.apply_move(SlidingTilePuzzle.DIRECTIONS['up'])
self.assertEqual(puzzle.puzzle[(0, 0)], 3)
self.assertEqual(puzzle.puzzle[(0, 1)], 1)
self.assertEqual(puzzle.puzzle[(1, 0)], 0)
self.assertEqual(puzzle.puzzle[(1, 1)], 2)
self.assertEqual(puzzle.puzzle[puzzle.blank_index], 0)
def test_search_manhattan_distance(self):
state = SlidingTilePuzzle(2, 10)
time = 5
heuristic = 'manhattan distance'
search = AStar(state, time, heuristic)
solution = search.search()
for move in solution:
state.apply_move(move)
self.assertTrue(state.is_solved())
def test_search_misplaced_tiles(self):
state = SlidingTilePuzzle(2, 10)
time = 5
heuristic = 'misplaced tiles'
search = AStar(state, time, heuristic)
solution = search.search()
for move in solution:
state.apply_move(move)
self.assertTrue(state.is_solved())
def test_copy(self):
size = 3
a = SlidingTilePuzzle(size)
b = a.copy()
self.assertEqual(a.size1, b.size1)
self.assertEqual(a.size2, b.size2)
for i in range(size):
for j in range(size):
self.assertEqual(a.puzzle[(i, j)], b.puzzle[(i, j)])
self.assertEqual(a.blank_index, b.blank_index)
self.assertEqual(a.num_correct_tiles, b.num_correct_tiles)
def test_copy(self):
size = 3
a = SlidingTilePuzzle(size)
b = a.copy()
self.assertEqual(a.size1, b.size1)
self.assertEqual(a.size2, b.size2)
for i in range(size):
for j in range(size):
self.assertEqual(a.puzzle[(i, j)], b.puzzle[(i, j)])
self.assertEqual(a.blank_index, b.blank_index)
self.assertEqual(a.num_correct_tiles, b.num_correct_tiles)
def test_seed_init(self):
size = 3
seed = 1
a = SlidingTilePuzzle(size, seed)
b = SlidingTilePuzzle(size, seed)
self.assertEqual(a.size1, b.size1)
self.assertEqual(a.size2, b.size2)
for i in range(size):
for j in range(size):
self.assertEqual(a.puzzle[(i, j)], b.puzzle[(i, j)])
self.assertEqual(a.blank_index, b.blank_index)
self.assertEqual(a.num_correct_tiles, b.num_correct_tiles)
def test_valid_moves_some(self):
size = 2
seed = 1
puzzle = SlidingTilePuzzle(size, seed)
moves = puzzle.valid_moves()
moves.sort()
expected_moves = [
SlidingTilePuzzle.DIRECTIONS['up'],
SlidingTilePuzzle.DIRECTIONS['right']
]
expected_moves.sort()
self.assertEqual(moves, expected_moves)
def test_update_frontier_true(self):
state = SlidingTilePuzzle(3, 1)
time = 10
heuristic = 'misplaced tiles'
search = AStar(state, time, heuristic)
search.rootnode.level = 2
state2 = SlidingTilePuzzle(3, 1)
move = SlidingTilePuzzle.DIRECTIONS['up']
node = Node(state2, move, None, heuristic)
self.assertTrue(search._update_frontier(node))
self.assertIn(node, search.frontier)
self.assertNotIn(search.rootnode, search.frontier)
def test_str_rectangle(self):
size1 = 2
size2 = 3
seed = 1
puzzle = SlidingTilePuzzle(size1, seed, size2)
expected_str = '\n 2 3 5 \n B 4 1 \n'
self.assertEqual(str(puzzle), expected_str)
def test_init(self):
state = SlidingTilePuzzle(3)
time = 10
search = BreadthFirstSearch(state, time)
self.assertEqual(search.time_limit, time)
self.assertEqual(len(search.explored), 0)
self.assertEqual(search.rootnode.state, state)
self.assertEqual(len(search.frontier), 1)
def test_init(self):
size = 3
puzzle = SlidingTilePuzzle(size)
self.assertEqual(puzzle.size1, size)
self.assertEqual(puzzle.size2, size)
self.assertEqual(puzzle.puzzle.size(), (size, size))
self.assertEqual(puzzle.puzzle[puzzle.blank_index], 0)
self.assertLessEqual(puzzle.num_correct_tiles, size * size)
self.assertGreaterEqual(puzzle.num_correct_tiles, 0)
def test_str_double_digits(self):
size = 4
seed = 1
puzzle = SlidingTilePuzzle(size, seed)
expected_str = ('\n 2 10 B 14 '
'\n 6 5 3 8 '
'\n 7 11 15 1 '
'\n 12 13 9 4 \n')
self.assertEqual(str(puzzle), expected_str)
def test_solution(self):
time = 10
root_state = SlidingTilePuzzle(3, 1)
heuristic = "misplaced tiles"
move1 = SlidingTilePuzzle.DIRECTIONS['up']
move2 = SlidingTilePuzzle.DIRECTIONS['right']
move3 = SlidingTilePuzzle.DIRECTIONS['down']
state1 = root_state.copy()
state1.apply_move(move1)
state2 = state1.copy()
state2.apply_move(move2)
state3 = state2.copy()
state3.apply_move(move3)
search = Search(root_state, time)
node1 = Node(state1, move1, search.rootnode, heuristic)
node2 = Node(state2, move2, node1, heuristic)
node3 = Node(state3, move3, node2, heuristic)
self.assertEqual(search.solution(node3), [move1, move2, move3])
def test_reset(self):
state = SlidingTilePuzzle(2, 10)
time = 5
search = BreadthFirstSearch(state, time)
solution = search.search()
self.assertGreater(search.num_nodes_generated(), 1)
self.assertTrue(search.solved)
search.reset()
self.assertEqual(search.num_nodes_generated(), 1)
self.assertFalse(search.solved)
def test_init_rectangle(self):
size1 = 2
size2 = 3
puzzle = SlidingTilePuzzle(size1=size1, size2=size2)
self.assertEqual(puzzle.size1, size1)
self.assertEqual(puzzle.size2, size2)
self.assertEqual(puzzle.puzzle.size(), (size1, size2))
self.assertEqual(puzzle.puzzle[puzzle.blank_index], 0)
self.assertLessEqual(puzzle.num_correct_tiles, size1 * size2)
self.assertGreaterEqual(puzzle.num_correct_tiles, 0)
def test_init(self):
state = SlidingTilePuzzle(3)
time = 10
heuristic = 'misplaced tiles'
search = AStar(state, time, heuristic)
self.assertEqual(search.time_limit, time)
self.assertEqual(len(search.explored), 0)
self.assertEqual(search.rootnode.state, state)
self.assertEqual(search.heuristic, heuristic)
self.assertEqual(search.rootnode.heuristic_name, heuristic)
self.assertEqual(len(search.frontier), 1)
def test_reset(self):
state = SlidingTilePuzzle(2, 10)
time = 5
heuristic = 'manhattan distance'
search = AStar(state, time, heuristic)
solution = search.search()
self.assertGreater(search.num_nodes_generated(), 1)
self.assertTrue(search.solved)
search.reset()
self.assertEqual(search.num_nodes_generated(), 1)
self.assertFalse(search.solved)
class TestNode(unittest.TestCase):
def setUp(self):
self.state = SlidingTilePuzzle(3)
self.heuristic = "misplaced tiles"
self.move = SlidingTilePuzzle.DIRECTIONS['up']
self.node = Node(self.state, self.move, None, self.heuristic)
def test_init(self):
self.assertTrue(self.state.equals(self.node.state))
self.assertEqual(self.node.heuristic_name, self.heuristic)
self.assertEqual(self.node.move, self.move)
self.assertEqual(self.node.parent, None)
self.assertEqual(self.node.level, 0)
def test_set_heuristic(self):
new_heuristic = 'manhattan distance'
self.node.set_heuristic(new_heuristic)
self.assertEqual(self.node.heuristic_name, new_heuristic)
def test_eq_true(self):
other_state = SlidingTilePuzzle(3)
other_node = Node(other_state, self.move, None, self.heuristic)
self.state.heuristic = dummy_return1
other_state.heuristic = dummy_return1
self.assertEqual(self.node, other_node)
def test_eq_false(self):
other_state = SlidingTilePuzzle(3)
other_node = Node(other_state, self.move, self.node, self.heuristic)
self.state.heuristic = dummy_return1
other_state.heuristic = dummy_return1
self.assertNotEqual(self.node, other_node)
def test_lt_true(self):
other_state = SlidingTilePuzzle(3)
other_node = Node(other_state, self.move, None, self.heuristic)
self.state.heuristic = dummy_return1
other_state.heuristic = dummy_return2
self.assertTrue(self.node < other_node)
def test_lt_false(self):
other_state = SlidingTilePuzzle(3)
other_node = Node(other_state, self.move, None, self.heuristic)
self.state.heuristic = dummy_return2
other_state.heuristic = dummy_return1
self.assertFalse(self.node < other_node)
def test_misplaced_tiles_none(self):
size = 2
seed = 10
puzzle = SlidingTilePuzzle(size, seed)
puzzle.apply_move(SlidingTilePuzzle.DIRECTIONS["down"])
puzzle.apply_move(SlidingTilePuzzle.DIRECTIONS["right"])
puzzle.apply_move(SlidingTilePuzzle.DIRECTIONS["up"])
puzzle.apply_move(SlidingTilePuzzle.DIRECTIONS["left"])
puzzle.apply_move(SlidingTilePuzzle.DIRECTIONS["down"])
puzzle.apply_move(SlidingTilePuzzle.DIRECTIONS["right"])
num_tiles = puzzle.misplaced_tiles()
expected_num = 0
self.assertEqual(num_tiles, expected_num)
def test_eq_false(self):
other_state = SlidingTilePuzzle(3)
other_node = Node(other_state, self.move, self.node, self.heuristic)
self.state.heuristic = dummy_return1
other_state.heuristic = dummy_return1
self.assertNotEqual(self.node, other_node)
def test_equals_true(self):
size = 3
seed = 1
a = SlidingTilePuzzle(size, seed)
b = SlidingTilePuzzle(size, seed)
self.assertTrue(a.equals(b))
def setUp(self):
self.state = SlidingTilePuzzle(3)
self.heuristic = "misplaced tiles"
self.move = SlidingTilePuzzle.DIRECTIONS['up']
self.node = Node(self.state, self.move, None, self.heuristic)
def test_is_solved_true(self):
size = 2
seed = 10
puzzle = SlidingTilePuzzle(size, seed)
puzzle.apply_move(SlidingTilePuzzle.DIRECTIONS["down"])
puzzle.apply_move(SlidingTilePuzzle.DIRECTIONS["right"])
puzzle.apply_move(SlidingTilePuzzle.DIRECTIONS["up"])
puzzle.apply_move(SlidingTilePuzzle.DIRECTIONS["left"])
puzzle.apply_move(SlidingTilePuzzle.DIRECTIONS["down"])
puzzle.apply_move(SlidingTilePuzzle.DIRECTIONS["right"])
self.assertTrue(puzzle.is_solved())
def test_is_solved_false(self):
size = 2
seed = 10
puzzle = SlidingTilePuzzle(size, seed)
self.assertFalse(puzzle.is_solved())
def test_lt_false(self):
other_state = SlidingTilePuzzle(3)
other_node = Node(other_state, self.move, None, self.heuristic)
self.state.heuristic = dummy_return2
other_state.heuristic = dummy_return1
self.assertFalse(self.node < other_node)
def test_manhattan_distance_complete(self):
size = 2
seed = 10
puzzle = SlidingTilePuzzle(size, seed)
puzzle.apply_move(SlidingTilePuzzle.DIRECTIONS["down"])
puzzle.apply_move(SlidingTilePuzzle.DIRECTIONS["right"])
puzzle.apply_move(SlidingTilePuzzle.DIRECTIONS["up"])
puzzle.apply_move(SlidingTilePuzzle.DIRECTIONS["left"])
puzzle.apply_move(SlidingTilePuzzle.DIRECTIONS["down"])
puzzle.apply_move(SlidingTilePuzzle.DIRECTIONS["right"])
num_tiles = puzzle.manhattan_distance()
expected_num = 0
self.assertEqual(num_tiles, expected_num)