def setUp(self):
self.board_full = Board(4, 3)
self.board_full.create_board_without_holes(4)
self.board_holes = Board(4, 3)
self.board_holes.create_board_with_holes([(1, 0), (2, 0)], 3)
self.player1 = PlayerData(Color.RED, 5)
self.player2 = PlayerData(Color.WHITE, 10)
self.players = [self.player1, self.player2]
self.state_full = State(self.players, self.board_full)
self.state_holes = State(self.players, self.board_holes)
self.player1.add_penguin((0, 0))
self.player2.add_penguin((0, 2))
self.action1 = Move((0, 0), (1, 0))
self.game_tree = GameTree(self.state_full)
self.game_tree_holes = GameTree(self.state_holes)
self.state1_0 = self.state_full.move_penguin((0, 0), (1, 0))
self.state2_0 = self.state_full.move_penguin((0, 0), (2, 0))
self.state2_1 = self.state_full.move_penguin((0, 0), (2, 1))
self.state3_1 = self.state_full.move_penguin((0, 0), (3, 1))
def setUp(self):
self.state = State([
PlayerData(Color.RED),
PlayerData(Color.BROWN),
PlayerData(Color.WHITE)
], Board(4, 4))
self.sock = socket.socket()
self.json_sock = JSONSocket(self.sock)
self.json_sock.send_json = MagicMock()
self.json_sock.recv_json = MagicMock()
self.proxy_player = RemotePlayerProxy(self.json_sock)
def setUp(self):
self.player1 = Player()
self.player2 = Player()
mini_board_array = [[1, 5], [2, 1], [1, 5]]
self.mini_board = Board(3, 2)
self.mini_board.create_board_from_json(mini_board_array)
self.strategy = Strategy()
self.in_player1 = PlayerData(Color.RED)
self.in_player2 = PlayerData(Color.WHITE)
self.players = [self.in_player1, self.in_player2]
self.mini_state = State(self.players, self.mini_board)
self.mini_tree = GameTree(self.mini_state)
def setUp(self):
self.logical_player = LogicalPlayerInterface()
self.adapted_player = LegacyToLogicalPlayer(self.logical_player)
self.board = Board(4, 4)
self.board.create_board_without_holes(1)
self.players = [
PlayerData(Color.RED),
PlayerData(Color.WHITE),
PlayerData(Color.BROWN)
]
state = State(self.players, self.board)
state = state.place_penguin_for_player(Color.RED, (0, 0))
state = state.place_penguin_for_player(Color.WHITE, (1, 1))
state = state.place_penguin_for_player(Color.BROWN, (1, 3))
self.state = state
def test_from_json(self):
players_json = [
{
'color': "red",
'score': 0,
'places': []
},
{
'color': "black",
'score': 123,
'places': [[2, 3]]
},
{
'color': "white",
'score': 321,
'places': [[0, 0], [4, 5]]
},
{
'color': "brown",
'score': 7,
'places': [[0, 1], [321, 123]]
},
]
board_json = [
[1, 2],
[4, 0, 0, 5],
[1, 1, 0, 1]
]
state_json = {'players': players_json, 'board': board_json}
players = [PlayerData.from_json(player) for player in players_json]
board = Board.from_json(board_json)
self.assertEqual(State(players, board), State.from_json(state_json))
def test_from_json(self):
jsons = [
{
'color': "red",
'score': 0,
'places': []
},
{
'color': "black",
'score': 123,
'places': [[2, 3]]
},
{
'color': "white",
'score': 321,
'places': [[0, 0], [4, 5]]
},
{
'color': "brown",
'score': 7,
'places': [[0, 1], [321, 123]]
},
]
for json in jsons:
p = PlayerData.from_json(json)
self.assertEqual(Color(json['color']), p.get_color())
self.assertEqual(json['score'], p.get_score())
self.assertEqual([tuple(place) for place in json['places']],
p.get_penguins())
def from_json(value):
"""
Class method to create a State from a JSON value.
JSON value -> State
"""
players = [PlayerData.from_json(player) for player in value['players']]
board = Board.from_json(value['board'])
return State(players, board)
def __assign_player_colors(self, players):
internal_players = []
for p in range(0, len(players)):
maybe_color = self.__assign_color_to_player(p, players[p])
if maybe_color is False:
self.__kicked_players.add(players[p])
else:
self.__players[maybe_color] = players[p]
internal_players.append(PlayerData(maybe_color))
return internal_players
def setUp(self):
self.state = State(
[PlayerData(Color.RED), PlayerData(Color.BROWN), PlayerData(Color.WHITE)],
Board(4, 4))
self.sock = socket.socket()
self.json_sock = JSONSocket(self.sock)
self.player = LogicalPlayerInterface()
self.player.start = MagicMock()
self.player.end = MagicMock()
self.player.play_as = MagicMock()
self.player.play_with = MagicMock()
self.posn = (0, 0)
self.player.setup = MagicMock(return_value=self.posn)
self.move = Move((0, 0), (1, 0))
self.player.tt = MagicMock(return_value=self.move)
self.server_proxy = ServerProxy(self.player, self.json_sock)
def test_tt(self):
self.legacy_player.set_state = MagicMock(
wraps=self.legacy_player.set_state)
self.legacy_player.choose_next_move = MagicMock(
wraps=self.legacy_player.choose_next_move)
board = Board(3, 3)
board.create_board_without_holes(1)
state = State([PlayerData(Color.RED)], board)
state = state.place_penguin_for_player(Color.RED, (0, 0))
self.adapter.play_as(Color.RED)
actions = [Action(), Action(), Action()]
self.assertIsInstance(self.adapter.tt(state, actions), Action)
self.legacy_player.set_state.assert_called_once_with(state)
self.legacy_player.choose_next_move.assert_called_once_with()
def setUp(self):
self.board_full = Board(4, 3)
self.board_full.create_board_without_holes(4)
self.board_holes = Board(4, 3)
self.board_holes.create_board_with_holes([(0, 0), (1, 1)], 3)
self.player1 = PlayerData(Color.RED, 5)
self.player2 = PlayerData(Color.WHITE, 10)
self.player3 = PlayerData(Color.BROWN)
self.player4 = PlayerData(Color.BLACK)
self.player5 = PlayerData(Color.BLACK)
self.players = [self.player1, self.player2]
self.state_full = State(self.players, self.board_full)
self.state_holes = State(self.players, self.board_holes)
class StateTestCase(unittest.TestCase):
def setUp(self):
self.board_full = Board(4, 3)
self.board_full.create_board_without_holes(4)
self.board_holes = Board(4, 3)
self.board_holes.create_board_with_holes([(0, 0), (1, 1)], 3)
self.player1 = PlayerData(Color.RED, 5)
self.player2 = PlayerData(Color.WHITE, 10)
self.player3 = PlayerData(Color.BROWN)
self.player4 = PlayerData(Color.BLACK)
self.player5 = PlayerData(Color.BLACK)
self.players = [self.player1, self.player2]
self.state_full = State(self.players, self.board_full)
self.state_holes = State(self.players, self.board_holes)
def test_duplicate_player_colors(self):
duplicate_colors = [self.player1, self.player3, self.player4, self.player5]
self.assertRaisesRegex(ValueError, "Players cannot have duplicate colors",
State, duplicate_colors, self.board_full)
def test_place_penguin_for_player_success(self):
self.assertEqual(self.state_full.get_all_penguins(), [])
new_state = self.state_full.place_penguin_for_player(Color.RED, (1, 2))
self.assertEqual(new_state.get_all_penguins(), [(1, 2)])
def test_place_penguin_for_player_out_of_bounds(self):
self.assertEqual(self.state_full.get_all_penguins(), [])
self.assertFalse(self.state_full.place_penguin_for_player(Color.RED, (4, 3)))
def test_place_penguin_for_player_hole(self):
self.assertEqual(self.state_holes.get_all_penguins(), [])
self.assertFalse(self.state_holes.place_penguin_for_player(Color.RED, (0, 0)))
def test_place_penguin_for_player_no_player(self):
self.assertEqual(self.state_full.get_all_penguins(), [])
self.assertFalse(self.state_full.place_penguin_for_player(Color.BROWN, (1, 2)))
def test_get_all_penguins(self):
self.assertEqual(self.state_full.get_all_penguins(), [])
self.player1.get_penguins = MagicMock(return_value=[])
self.player2.get_penguins = MagicMock(return_value=[(0, 0), (3, 2)])
self.assertEqual(self.state_full.get_all_penguins(), [(0, 0), (3, 2)])
def test_get_player_success(self):
self.assertEqual(self.state_full.get_player(Color.RED), self.player1)
self.assertEqual(self.state_full.get_player(Color.WHITE), self.player2)
def test_get_player_no_player(self):
self.assertFalse(self.state_full.get_player(Color.BROWN))
def test_is_tile_available_true(self):
self.assertTrue(self.state_full.is_tile_available((1, 1)))
self.assertTrue(self.state_holes.is_tile_available((2, 2)))
def test_is_tile_available_holes(self):
self.assertFalse(self.state_holes.is_tile_available((0, 0)))
self.assertFalse(self.state_holes.is_tile_available((1, 1)))
def test_is_tile_available_out_of_bounds(self):
self.assertFalse(self.state_full.is_tile_available((4, 3)))
self.assertFalse(self.state_full.is_tile_available((-2, 3)))
def test_is_tile_available_occupied(self):
new_state = self.state_full.place_penguin_for_player(Color.RED, (1, 2))
self.assertFalse(new_state.is_tile_available((1, 2)))
def test_valid_move_success(self):
self.state_full.get_all_penguins = MagicMock(return_value=[(0, 0), (1, 0), (3, 2)])
self.assertTrue(self.state_full.valid_move((0, 0), (2, 0)))
def test_valid_move_occupied(self):
self.state_full.get_all_penguins = MagicMock(return_value=[(0, 0), (1, 0), (3, 2)])
self.assertFalse(self.state_full.valid_move((0, 0), (1, 0)))
def test_valid_move_hole(self):
self.state_holes.get_all_penguins = MagicMock(return_value=[(0, 1), (1, 0), (3, 2)])
self.assertFalse(self.state_holes.valid_move((0, 1), (1, 1)))
def test_valid_move_no_penguin(self):
self.state_holes.get_all_penguins = MagicMock(return_value=[(0, 1), (1, 0), (3, 2)])
self.assertFalse(self.state_holes.valid_move((0, 0), (2, 0)))
def test_valid_move_not_reachable(self):
self.state_holes.get_all_penguins = MagicMock(return_value=[(0, 1), (1, 0), (3, 2)])
self.assertFalse(self.state_holes.valid_move((0, 0), (3, 0)))
def test_get_player_from_penguin_exists(self):
self.player1.get_penguins = MagicMock(return_value=[(0, 0), (1, 0)])
self.player2.get_penguins = MagicMock(return_value=[(3, 2)])
self.assertEqual(self.state_full.get_player_from_penguin((3, 2)), self.player2)
def test_get_player_from_penguin_no_player(self):
self.player1.get_penguins = MagicMock(return_value=[(0, 0), (1, 0)])
self.assertFalse(self.state_full.get_player_from_penguin((3, 2)))
def test_move_penguin_success(self):
self.player1.add_penguin((0, 0))
self.assertTrue((0, 0) in self.state_full.get_all_penguins())
self.assertFalse((2, 0) in self.state_full.get_all_penguins())
self.assertEqual(self.state_full.get_current_player_color(), Color.RED)
new_state = self.state_full.move_penguin((0, 0), (2, 0))
self.assertTrue((2, 0) in new_state.get_all_penguins())
self.assertFalse((0, 0) in new_state.get_all_penguins())
self.assertEqual(new_state.get_current_player_color(), Color.WHITE)
def test_move_penguin_occupied(self):
self.player1.add_penguin((0, 0))
self.player2.add_penguin((2, 0))
self.assertEqual(self.state_full.get_all_penguins(), [(0, 0), (2, 0)])
self.assertEqual(self.state_full.get_current_player_color(), Color.RED)
self.assertFalse(self.state_full.move_penguin((0, 0), (2, 0)))
self.assertEqual(self.state_full.get_all_penguins(), [(0, 0), (2, 0)])
self.assertEqual(self.state_full.get_current_player_color(), Color.RED)
def test_any_remaining_moves_true(self):
self.player1.add_penguin((0, 0))
self.player2.add_penguin((2, 0))
self.assertTrue(self.state_full.any_remaining_moves())
def test_any_remaining_moves_no_penguins(self):
self.assertFalse(self.state_full.any_remaining_moves())
def test_any_remaining_moves_no_moves(self):
board = Board(4, 3)
board.create_board_with_holes([(1, 0), (2, 0)], 0)
state = State(self.players, board)
self.player1.add_penguin((0, 0))
self.assertFalse(state.any_remaining_moves())
def test_get_possible_moves(self):
self.player1.add_penguin((0, 0))
actions = [Move((0, 0), (1, 0)), Move((0, 0), (2, 0)),
Move((0, 0), (2, 1)), Move((0, 0), (3, 1))]
for action in self.state_full.get_possible_moves():
self.assertTrue(action in actions)
self.assertEqual(len(self.state_full.get_possible_moves()), len(actions))
def test_get_possible_moves_another_penguin(self):
self.player1.add_penguin((0, 0))
self.player2.add_penguin((2, 1))
actions = [Move((0, 0), (1, 0)), Move((0, 0), (2, 0))]
for action in self.state_full.get_possible_moves():
self.assertTrue(action in actions)
self.assertEqual(len(self.state_full.get_possible_moves()), len(actions))
def test_get_players_score_after_move(self):
self.assertEqual(self.state_full.get_players_score(Color.RED), 0)
self.player1.add_penguin((0, 0))
new_state = self.state_full.move_penguin((0, 0), (1, 0))
self.assertEqual(new_state.get_players_score(Color.RED), 4)
self.assertEqual(self.state_full.get_players_score(Color.WHITE), 0)
def test_get_players_score_mutate_player(self):
self.assertEqual(self.state_full.get_players_score(Color.RED), 0)
self.player1.add_to_score(10)
self.assertEqual(self.state_full.get_players_score(Color.RED), 10)
def test_from_json(self):
players_json = [
{
'color': "red",
'score': 0,
'places': []
},
{
'color': "black",
'score': 123,
'places': [[2, 3]]
},
{
'color': "white",
'score': 321,
'places': [[0, 0], [4, 5]]
},
{
'color': "brown",
'score': 7,
'places': [[0, 1], [321, 123]]
},
]
board_json = [
[1, 2],
[4, 0, 0, 5],
[1, 1, 0, 1]
]
state_json = {'players': players_json, 'board': board_json}
players = [PlayerData.from_json(player) for player in players_json]
board = Board.from_json(board_json)
self.assertEqual(State(players, board), State.from_json(state_json))
def setUp(self):
self.player1 = PlayerData(Color.RED, 5)
self.player2 = PlayerData(Color.WHITE, 10)
class PlayerTestCase(unittest.TestCase):
def setUp(self):
self.player1 = PlayerData(Color.RED, 5)
self.player2 = PlayerData(Color.WHITE, 10)
def test_invalid_color(self):
self.assertRaisesRegex(ValueError, "Invalid color", PlayerData, 5)
def test_get_penguins(self):
self.assertEqual(self.player1.get_penguins(), [])
self.player1.add_penguin((0, 0))
self.assertEqual(self.player1.get_penguins(), [(0, 0)])
def test_copy(self):
new_player = self.player1.copy()
self.assertEqual(self.player1.get_age(), new_player.get_age())
self.assertEqual(self.player1.get_color(), new_player.get_color())
self.assertEqual(self.player1.get_penguins(),
new_player.get_penguins())
self.assertFalse(self.player1 is new_player)
def test_add_penguin(self):
self.player1.add_penguin((0, 0))
self.player1.add_penguin((1, 0))
self.assertEqual(self.player1.get_penguins(), [(0, 0), (1, 0)])
def get_color(self):
self.assertEqual(self.player1.get_color(), Color.RED)
self.assertEqual(self.player2.get_color(), Color.WHITE)
def get_age(self):
self.assertEqual(self.player1.get_age(), 5)
self.assertEqual(self.player2.get_age(), 10)
def move_penguin_success(self):
self.player1.add_penguin((0, 0))
self.assertEqual(self.player1.get_penguins(), [(0, 0)])
self.player1.move_penguin((0, 0), (3, 0))
self.assertEqual(self.player1.get_penguins(), [(3, 0)])
def move_penguin_no_penguin(self):
self.player1.add_penguin((0, 0))
self.assertEqual(self.player1.get_penguins(), [(0, 0)])
self.player1.move_penguin((3, 1), (3, 0))
self.assertEqual(self.player1.get_penguins(), [(0, 0)])
def test_attempt_move_last_move(self):
mini_board_array = [[1, 5], [2, 1], [1, 5], [1, 5], [0, 5]]
player1 = PlayerData(Color.RED)
player2 = PlayerData(Color.WHITE)
player1.add_penguin((0, 0))
player1.add_penguin((1, 0))
player1.add_penguin((2, 0))
player1.add_penguin((3, 0))
player2.add_penguin((0, 1))
player2.add_penguin((1, 1))
player2.add_penguin((2, 1))
player2.add_penguin((3, 1))
players = [player1, player2]
board = Board(5, 2)
board.create_board_from_json(mini_board_array)
state = State(players, board)
game_tree = GameTree(state)
action = Move((3, 0), (4, 1))
self.assertEqual(type(game_tree.attempt_move(action)), GameEnded)
class GameTreeTestCase(unittest.TestCase):
def setUp(self):
self.board_full = Board(4, 3)
self.board_full.create_board_without_holes(4)
self.board_holes = Board(4, 3)
self.board_holes.create_board_with_holes([(1, 0), (2, 0)], 3)
self.player1 = PlayerData(Color.RED, 5)
self.player2 = PlayerData(Color.WHITE, 10)
self.players = [self.player1, self.player2]
self.state_full = State(self.players, self.board_full)
self.state_holes = State(self.players, self.board_holes)
self.player1.add_penguin((0, 0))
self.player2.add_penguin((0, 2))
self.action1 = Move((0, 0), (1, 0))
self.game_tree = GameTree(self.state_full)
self.game_tree_holes = GameTree(self.state_holes)
self.state1_0 = self.state_full.move_penguin((0, 0), (1, 0))
self.state2_0 = self.state_full.move_penguin((0, 0), (2, 0))
self.state2_1 = self.state_full.move_penguin((0, 0), (2, 1))
self.state3_1 = self.state_full.move_penguin((0, 0), (3, 1))
def test_attempt_move(self):
self.assertEqual(type(self.game_tree.attempt_move(self.action1)),
GameTree)
def test_attempt_move_last_move(self):
mini_board_array = [[1, 5], [2, 1], [1, 5], [1, 5], [0, 5]]
player1 = PlayerData(Color.RED)
player2 = PlayerData(Color.WHITE)
player1.add_penguin((0, 0))
player1.add_penguin((1, 0))
player1.add_penguin((2, 0))
player1.add_penguin((3, 0))
player2.add_penguin((0, 1))
player2.add_penguin((1, 1))
player2.add_penguin((2, 1))
player2.add_penguin((3, 1))
players = [player1, player2]
board = Board(5, 2)
board.create_board_from_json(mini_board_array)
state = State(players, board)
game_tree = GameTree(state)
action = Move((3, 0), (4, 1))
self.assertEqual(type(game_tree.attempt_move(action)), GameEnded)
def test_attempt_move_invalid(self):
self.assertFalse(self.game_tree.attempt_move(Move((0, 0), (2, 2))))
def test_create_child_trees(self):
trees = [
GameTree(self.state1_0),
GameTree(self.state2_0),
GameTree(self.state2_1),
GameTree(self.state3_1)
]
children = self.game_tree.create_child_trees()
for tree in trees:
self.assertTrue(tree in children.values())
self.assertEqual(len(children), len(trees))
def test_create_child_trees_no_children(self):
children = self.game_tree_holes.create_child_trees()
child_trees = list(children.values())
self.assertEqual(len(child_trees), 1)
self.state_holes.set_next_players_turn()
self.assertTrue(child_trees[0] in [GameTree(self.state_holes)])
def test_apply_to_children(self):
action = Move((0, 2), (1, 2))
states = [self.state1_0, self.state2_0, self.state2_1, self.state3_1]
new_states = self.game_tree.apply_to_children(action.apply_move)
for state in states:
move_state = state.move_penguin((0, 2), (1, 2))
self.assertTrue(move_state in new_states)
self.assertEqual(len(new_states), len(states))
def test_apply_to_children_create_trees(self):
child_trees = self.game_tree.apply_to_children(
GameTree.create_child_trees)
self.assertEqual(len(child_trees), 4)
num_children = 0
for c in child_trees:
num_children += len(c)
self.assertGreater(len(c), 0)
self.assertEqual(num_children, 18)
