def test_is_winning_row_3(self): board_size = 3 board_3 = Board(board_size) board_3.board = [['x', 'x', 'x'], ['o', '.', '.'], ['.', 'o', '.']] self.assertTrue(board_3.is_winning_row('x')) self.assertFalse(board_3.is_winning_row('o'))
def test_place(self): board = Board() board.place(1, "X") assert board.get(1) == "X" assert board.get(2) == None
def test_game_not_over(self): board_size = 3 game_manager = GameManager(self.a1, self.a2, board_size) board = Board(board_size) board.board = [['o', '.', '.'], ['x', 'x', '.'], ['o', '.', '.']] game_manager.board = board self.assertFalse(game_manager.game_over())
def initGameCallBack(self): if isinstance(self.interFrame, Frame): self.interFrame.destroy() self.timer.destroy() self.counter.destroy() if isinstance(self.gameFrame, Frame): self.gameFrame.destroy() storage = Storage() self.mines = storage.get("mines") h = storage.get("height") w = storage.get("width") self.isGameStarted = False self.tiles = [[j for j in range(w)] for i in range(h)] self.bombs = set() self.bombsPrediction = set() self.tilesAmount = w * h self.board = Board(w, h, self.mines) self.root.bind_class('Label', '<Button-1>', self.openTileEvent) self.root.bind_class('Label', '<Button-2>', self.flagTileEvent) self.root.bind('<KeyPress>', self.keyboardEvent) self.code = "" self.__createFrame() self.__initInterface()
def __min_value(self, state: Board, alpha: int, beta: int, depth: int, player: Player): """ Get next worst state for given state based on specified parameters. :param state: Board state from which algorithm will start looking for best/worst move. :param depth: Maximum tree depth that will be visited. :param player: Player for whom moves will be calculated. :return: Tuple containing information whether next move gives additional move and next move itself. """ if depth == 0 or state.no_more_moves(): return self.evaluator.rate_board_state(state, self.__player), False, state value = float('inf') moves = state.calculate_possible_states(player) self.moves_count += len(moves) outer_additional_move = False outer_state = state for additional_move, move in moves: if additional_move: v_prime, _, _ = self.__min_value(move, alpha, beta, depth - 1, player) else: v_prime, _, _ = self.__max_value(move, alpha, beta, depth - 1, player.next()) if v_prime < value: value = v_prime outer_additional_move = additional_move outer_state = move if alpha is not None and v_prime <= alpha: return value, outer_additional_move, outer_state if beta is None or v_prime < beta: beta = v_prime return value, outer_additional_move, outer_state
def test_king_capture_covered_piece(self): king = King("e4", "white") board = Board([king, Knight("e5", "black"), Bishop("a1", "black")]) board.create_board() output = king.move_to(board, "e5", "black") expected_output = (False, "illegal move: king in check") self.assertEqual(expected_output, output)
class Game: def __init__(self): self.bag = Bag() self.board = Board() self.trie = Trie.words() tiles1, tiles2 = [], [] for _ in range(7): tiles1.append(self.bag.draw_tile()) tiles2.append(self.bag.draw_tile()) self.player1 = Ai("Player 1", tiles1) self.player2 = Ai("Player 2", tiles2) self.cur_player = self.player1 self.skipped_turns = 0 def play(self): while True: self.play_one_move() self.board.print_b() print(self.cur_player.tiles) print(self.cur_player.recent_score) print("----------") if self.skipped_turns > 5 or not self.cur_player.tiles: break time.sleep(3) def play_one_move(self): if self.skipped_turns > 5 or not self.cur_player.tiles: return False self.cur_player = self.player1 if self.cur_player == self.player2 else self.player2 successful_play = self.cur_player.make_play(self.trie, self.board) if not successful_play: if len(self.cur_player.tiles) == 7: self.exchange_tiles() self.skipped_turns += 1 else: self.replenish_tiles(self.cur_player) self.skipped_turns = 0 return True def replenish_tiles(self, player): to_replen = 7 - len(player.tiles) while self.bag.has_tiles() and to_replen > 0: new_tile = self.bag.draw_tile() player.tiles.append(new_tile) to_replen -= 1 def exchange_tiles(self): to_exchange = random.randrange(1, len(self.cur_player.tiles)) exchange_list = [] while self.bag.has_tiles() and to_exchange > 0: to_remove = random.choice(self.cur_player.tiles) self.cur_player.tiles.remove(to_remove) exchange_list.append(to_remove) new_tile = self.bag.draw_tile() self.cur_player.tiles.append(new_tile) to_exchange -= 1 for t in exchange_list: self.bag.add_tile(t)
class Player(): def __init__(self): self.board = Board() self.ships = dict() self.ships['carrier'] = Ship(5) self.ships['battleship'] = Ship(4) self.ships['cruiser'] = Ship(3) self.ships['submarine'] = Ship(3) self.ships['destroyer'] = Ship(2) def mark_hit(self, x, y): for name, ship in self.ships.items(): try: ship.coordinates.index((x, y)) if ship.mark_hit(): return 'You sunk my %s!' % name return 'Direct hit!' except: continue def has_lost(self): for name, ship in self.ships.items(): if not ship.is_sunk(): return False return True def display_board(self): left_banner = figlet.renderText('Your Shots') left_grid = self.board.display_offense() right_banner = figlet.renderText('Your Ships') right_grid = self.board.display_defense() return side_by_side(left_banner, left_grid, right_banner, right_grid)
def test_board_equality_returns_false(self): pawn_a = Pawn(1, 0, 1, True) pawn_b = Pawn(1, 0, 2, True) king = King(1, 4, 0, True) board_a = Board([pawn_a, king]) board_b = Board([pawn_b, king]) self.assertFalse(board_a == board_b)
class Tetris(QMainWindow): def __init__(self): super().__init__() self.init_ui() def init_ui(self): """initiates application UI""" self.tboard = Board(self) self.setCentralWidget(self.tboard) self.statusbar = self.statusBar() self.tboard.msg2Statusbar[str].connect(self.statusbar.showMessage) self.tboard.start() self.resize(180 * 3, 380 * 3) #self.center() self.setWindowTitle('Tetris') self.show() def center(self): """centers the window on the screen""" screen = QDesktopWidget().screenGeometry() size = self.geometry() self.move((screen.width() - size.width()) / 2, (screen.height() - size.height()) / 2)
def test_game_end(self): # Can't move b = Board() b._board = [ 2, 4, 2, 4, 4, 2, 4, 2, 2, 4, 2, 4, 4, 2, 4, 2 ] self.assertEqual(True, b.is_terminal()) # Zero check b._board = [ 2, 4, 2, 4, 4, 2, 4, 2, 2, 4, 2, 4, 4, 2, 0, 2 ] self.assertEqual(False, b.is_terminal()) # Right or left b._board = [ 2, 4, 2, 4, 4, 2, 4, 2, 2, 4, 8, 4, 4, 2, 2, 2 ] self.assertEqual(False, b.is_terminal()) # Up or down b._board = [ 2, 4, 2, 4, 4, 2, 4, 2, 2, 4, 8, 4, 4, 2, 8, 2 ] self.assertEqual(False, b.is_terminal())
def test_king_capture_uncovered_piece(self): king = King("e4", "white") board = Board([king, Knight("e5", "black"), Bishop("a2", "black")]) board.create_board() output = king.move_to(board, "e5", "black") expected_output = (True, "legal move carried out") self.assertEqual(expected_output, output)
def __init__(self, window, player1, player2, data_dir_path, Q_learn=None, Q={}, alpha=0.3, gamma=0.9): self.data_dir_path = data_dir_path self.data_file_path = data_dir_path + "/" self.window = window self.user_interface = UserInterface(window, self) self.board = Board() self.evaluator = GameEvaluator() self.is_q_learn_mode = False self.player1 = player1 self.player2 = player2 self.current_player = player1 self.other_player = player2 self.games, self.game_stats, self.game_story = self.prepare_stats() self.Q_learn = QLearning(self.player1, self.player2)
def test_is_winning_second_diagonal(self): board_size = 3 board_3 = Board(board_size) board_3.board = [['.', 'o', 'x'], ['.', 'x', '.'], ['x', '.', 'o']] self.assertTrue(board_3.is_winning_second_diagonal('x')) self.assertFalse(board_3.is_winning_second_diagonal('o'))
def setUp(self): self.board_3x3 = Board(3) self.board_5x5 = Board(5) self.game = Game() self.game.board = Board(3) self.game.player1 = Player("Toothless", "X") self.game.player2 = Player("Hiccup", "O")
def test_out_of_bounds_check(): b = Board() assert b.is_oob(0) == False assert b.is_oob(30) == False assert b.is_oob(63) == False assert b.is_oob(64) == True assert b.is_oob(-1) == True
class Background(QWidget): def __init__(self, theme, parent=None): super(Background, self).__init__(parent) self.theme = theme self.board = Board(self.theme, self) self.pad = 20 def paintEvent(self, event): painter = QPainter() painter.begin(self) self.theme.render(painter, "kdiamond-background") painter.end() def resizeEvent(self, event): width = event.size().width() - self.pad height = event.size().height() - self.pad size = min(width, height) self.board.resize(QSize(size, size)) xPos = (width - size + self.pad) / 2 yPos = (height - size + self.pad) / 2 self.board.move(xPos, yPos)
def test_actual_round(self): """Verify actual round""" board = Board(4, 300, 20, 100, 1000, 1) board.actual_round = 2 self.assertEqual(board.actual_round, 2) board.actual_round = 1 self.assertEqual(board.actual_round, 2)
def test_game_over_full(self): board_size = 3 game_manager = GameManager(self.a1, self.a2, board_size) board = Board(board_size) board.board = [['o', 'o', 'x'], ['x', 'x', 'o'], ['o', 'x', 'o']] game_manager.board = board self.assertTrue(game_manager.game_over())
def __init__(self): self.board = Board() self.ships = dict() self.ships['carrier'] = Ship(5) self.ships['battleship'] = Ship(4) self.ships['cruiser'] = Ship(3) self.ships['submarine'] = Ship(3) self.ships['destroyer'] = Ship(2)
def __init__(self): self.run = True self.player = Player() self.board = Board(os.path.join("..", "worlds", "world.txt")) self.screen = pygame.display.set_mode(Game.RESOLUTION) self.clock = pygame.time.Clock() self.execute()
def __init__(self, board=None, color_to_move=None): if board is None: self.board = Board(MovesTracker()) self.board.set_up_board_for_new_game() self.color_to_move = WHITE_COLOR else: self.board = board self.color_to_move = color_to_move
def test_pawn_cant_go_diagonal_if_own_piece_is_there(self): with self.assertRaises(CannotCaptureOwnPieceError): new_board = Board([ Pawn(1, 4, 4, True), Pawn(1, 5, 5, True), King(1, 4, 0, True) ]) new_board.move_white_pawn_1(Position(5, 5))
def play(self, nested_array): if nested_array == None: nested_array = Board().draw_board() else: Board().draw_board() if not self.is_human: return self.computer(nested_array) return self.human(nested_array)
def test_is_empty_check(): test_board = [None for _ in range(64)] test_board[10] = "0q" b = Board(test_board) assert b.is_empty(10) == False assert b.is_empty(11) == True
class MovesTests(unittest.TestCase): def setUp(self): self.board = Board(8, 8) def test_movepiece(self): self.board.move_piece((1, 1), (2, 1)) self.assertEqual(self.board.get_pos_val((1, 1)), ' ') self.assertEqual(self.board.get_pos_val((1, 2)), 'PB ')
def test_would_cause_king_to_be_in_check_does_not_throw_exception(self): new_board = Board([ Rook(1, 4, 1, True), King(1, 4, 0, True), Rook(1, 4, 6, False), King(1, 4, 7, False) ]) new_board.move_white_rook_1(Position(4, 2))
def restart_game(self): self.menu = Menu() self.board = Board() self.players = [] self.number_players = 0 self.board.restart_board() self.previous_before_playing() self.start_play()
def test_get_surrounding(self): y = 10 x = 10 data = self.get_json_data() board = Board() tile_map = data["map"]["tiles"] result = board.get_surrounding(x, y, tile_map) != False self.assertEqual(result, True)
def test_creation(self): """testing board creationg""" my_board = Board(2, 2) self.assertTrue(my_board.width == 2) self.assertTrue(my_board.width == my_board.height) self.assertEqual(my_board.get_tile(X=0, Y=0), 0) self.assertEqual(my_board.get_tile(X=0, Y=1), 0) self.assertEqual(my_board.get_tile(X=1, Y=0), 0) self.assertEqual(my_board.get_tile(X=1, Y=1), 0)
def test_piece_color(): test_board = [None for _ in range(64)] test_board[10] = "0q" test_board[11] = "1q" b = Board(test_board) assert b.piece_color(10) == Piece.WHITE assert b.piece_color(11) == Piece.BLACK
def test_piece_type(): test_board = [None for _ in range(64)] test_board[10] = "0q" test_board[11] = "1n" b = Board(test_board) assert b.piece_type(10) == Piece.QUEEN assert b.piece_type(11) == Piece.KNIGHT
class ANewBoard(unittest.TestCase): def setUp(self): self.board = Board(3, 3) def test_is_empty(self): expected_board = 3 * "...\n" self.assertEqual(expected_board, str(self.board)) def test_has_no_falling_blocks(self): self.assertFalse(self.board.has_falling_pieces()) def test_cannot_tick(self): with self.assertRaises(IllegalStateException): self.board.tick()
class TestBoard(unittest.TestCase): def setUp(self): self.board = Board(3) def testItCreatesAThreeByThreeBoard(self): expected = ["1", "2", "3", "4", "5", "6", "7", "8", "9"] self.assertEquals(expected, self.board.slots) def testItReplacesSlot(self): index, mark = '5', 'X' self.board.replace_slot(index, mark) self.assertEquals(mark, self.board.slots.pop(int(index)-1))
def __init__(self, theme, parent=None): super(Background, self).__init__(parent) self.theme = theme self.board = Board(self.theme, self) self.pad = 20
def test_moves(self): """testing queen's invalid moves""" queen = Queen() self.board = Board(10, 10) queen.set_position(5, 5) self.board.set_tile(1, 5, 5) valid_moves_4 = queen.valid_moves(self.board) self.assertEqual(len(valid_moves_4), 35)
def setUp(self): self.board = Board(3, 3) self.board.drop(Piece('X')) self.board.tick() self.board.tick() self.board.tick() self.board.drop(Piece('Y')) self.board.tick() self.expected_board = "...\n" + ".Y.\n" + ".X.\n"
class WhenABlockReachesTheBottom(unittest.TestCase): def setUp(self): self.board = Board(3, 3) self.board.drop(Piece('X')) self.board.tick() self.board.tick() def test_block_is_still_falling_on_the_last_row(self): self.assertTrue(self.board.has_falling_pieces()) expected_board = 2 * "...\n" + ".X.\n" self.assertEqual(expected_board, str(self.board)) def test_block_stops_when_it_hits_the_bottom(self): self.board.tick() self.assertFalse(self.board.has_falling_pieces()) expected_board = 2 * "...\n" + ".X.\n" self.assertEqual(expected_board, str(self.board)) with self.assertRaises(IllegalStateException): self.board.tick()
def setUp(self): self.board = Board(['1', '2', '3', '4', '5', '6', '7', '8', '9']) self.mock_io = Mock() self.mock_ai = Mock() self.mock_board_analyzer = Mock() self.moves = [2, 3] self.mock_io.get_move.side_effect = self.moves self.game_over_values = [False, True] self.mock_board_analyzer.game_over.side_effect = self.game_over_values self.engine = GameEngine(self.mock_io, self.mock_ai, self.mock_board_analyzer)
def test_valid_moves(self): """testing queen's valid moves""" queen = Queen() self.board.set_tile(1, 0, 0) valid_moves_2 = queen.valid_moves(self.board) self.assertEqual(len(valid_moves_2), 3) self.board = Board(3, 3) self.board.set_tile(1, 0, 0) valid_moves_3 = queen.valid_moves(self.board) self.assertEqual(len(valid_moves_3), 6)
class BoardTest(TestCase): def setUp(self): self.board = Board() def test_standard_tuning(self): self.assertEquals(self.board.fretboard, standard_board) def test_other_tuning(self): board = Board('abcdef') self.assertEquals(board.fretboard, abcdef_board) def test_none_tuning(self): self.assertRaises(BadTuningError, Board, None) def test_empty_tuning(self): self.assertRaises(BadTuningError, Board, '') def test_int_tuning(self): self.assertRaises(BadTuningError, Board, 1) def test_get_note_from_string_6(self): expected = ('a', 2) self.assertEquals(expected, self.board.get_note(6, 5)) def test_get_note_from_string_5(self): expected = ('c', 3) self.assertEquals(expected, self.board.get_note(5, 3)) def test_get_note_from_string_4(self): expected = ('g#', 3) self.assertEquals(expected, self.board.get_note(4, 6)) def test_get_note_from_string_3(self): expected = ('a', 3) self.assertEquals(expected, self.board.get_note(3, 2)) def test_get_note_from_string_2(self): expected = ('c#', 4) self.assertEquals(expected, self.board.get_note(2, 2)) def test_get_note_from_string_1(self): expected = ('b', 4) self.assertEquals(expected, self.board.get_note(1, 7)) def test_get_note_none_string(self): self.assertRaises(StringNotInBoardError, self.board.get_note, None, 3) def test_get_note_none_fret(self): self.assertRaises(StringNotInBoardError, self.board.get_note, 1, None) def test_find_note(self): expected = [('5', 1), ('6', 6)] self.assertEquals(expected, self.board.find_note('a#', 2)) def test_find_unexistent_note(self): self.assertRaises(NoteNotFoundError, self.board.find_note, 'h', 3)
def post(self): user = users.get_current_user() dimension = int(self.request.POST['dimension']) board = Board() board.player1 = user board.dimension = dimension board.put() token = create_channel(str(board.key().id()) + user.user_id()) self.response.out.write(simplejson.dumps({'board_id': board.key().id(), 'token': token}))
class TestBoardMethods(unittest.TestCase): """testing methods for board""" def setUp(self): self.board = Board(2, 2) def test_creation(self): """testing board creationg""" my_board = Board(2, 2) self.assertTrue(my_board.width == 2) self.assertTrue(my_board.width == my_board.height) self.assertEqual(my_board.get_tile(X=0, Y=0), 0) self.assertEqual(my_board.get_tile(X=0, Y=1), 0) self.assertEqual(my_board.get_tile(X=1, Y=0), 0) self.assertEqual(my_board.get_tile(X=1, Y=1), 0) def test_set_tile(self): """ test set tile """ self.board.set_tile(val=-1, X=0, Y=1) self.assertEqual(self.board.get_tile(X=0, Y=1), -1) def test_invalid_tile(self): """get tile test""" error = self.board.get_tile(X=10, Y=10) self.assertEqual(error, -1) error = self.board.get_tile(X=-1, Y=0) self.assertEqual(error, -1) error = self.board.get_tile(X=0, Y=-1) self.assertEqual(error, -1)
class WhenAPieceIsDropped(unittest.TestCase): def setUp(self): self.board = Board(6, 8) def test_t_shape_starts_from_top_middle(self): self.board.drop(tetrominoe.T_SHAPE) self.assertEqual("....T...\n" + \ "...TTT..\n" + \ "........\n" + \ "........\n" + \ "........\n" + \ "........\n", str(self.board)) def test_o_shape_starts_from_top_middle(self): self.board.drop(tetrominoe.O_SHAPE) self.assertEqual("...OO...\n" + \ "...OO...\n" + \ "........\n" + \ "........\n" + \ "........\n" + \ "........\n", str(self.board)) def test_i_shape_starts_from_top_middle(self): self.board.drop(tetrominoe.I_SHAPE) self.assertEqual("..IIII..\n" + \ "........\n" + \ "........\n" + \ "........\n" + \ "........\n" + \ "........\n", str(self.board)) def test_l_shape_starts_from_top_middle(self): self.board.drop(tetrominoe.L_SHAPE) self.assertEqual("...LLL..\n" + \ "...L....\n" + \ "........\n" + \ "........\n" + \ "........\n" + \ "........\n", str(self.board))
def play_game(strategies): assert len(strategies) == NUM_PLAYERS board = Board(NUM_PLAYERS, strategies) last_moves = [] while not board.game_over: # Give each strategy a chance to make a move before checking for game over # again. while board.current_player_index < len(strategies): strategies[board.current_player_index].play_turn(board, last_moves) last_moves = board.moves_played_this_turn board.end_turn() board.current_player_index = 0 board.end_round() board.compute_victor() print "Rounds:", board.rounds for strategy in strategies: strategy.log_end_game(board.victor) return board
class WhenABlockIsDropped(unittest.TestCase): def setUp(self): self.board = Board(3, 3) self.board.drop(Piece('X')) def test_a_block_is_falling(self): self.assertTrue(self.board.has_falling_pieces()) def test_block_starts_from_the_top_middle(self): expected_board = ".X.\n" + 2 * "...\n" self.assertEqual(expected_board, str(self.board)) def test_block_moves_down_one_row_per_tick(self): self.board.tick() expected_board = "...\n" + ".X.\n" + "...\n" self.assertEqual(expected_board, str(self.board)) def test_at_most_one_block_may_be_falling_at_a_time(self): with self.assertRaises(IllegalStateException): self.board.drop(Piece('Y')) expected_board = ".X.\n" + 2 * "...\n" self.assertEqual(expected_board, str(self.board))
def get(self): board_id = self.request.get('board') token = '' other_player = '' user = users.get_current_user() logout_url = users.create_logout_url("/") board_dimention = '' if board_id: board = Board.get_by_id(int(board_id)) if board: board_dimention = board.dimension if board.may_join(user): token = create_channel(str(board.key().id()) + user.user_id()) other_player = board.player1 key = get_other_player_channel_key(board, user) channel.send_message(key, simplejson.dumps({'type':'join', 'user':get_user_dump(user, format='dict')})) else: self.redirect('/') else: self.redirect('/') path = os.path.join('templates', 'pvk.html') self.response.out.write(template.render(path, {'token': token, 'board_id': board_id, 'me_user': get_user_dump(user), 'board_dimention': board_dimention, 'logout_url': logout_url, 'other_player': get_user_dump(other_player)}))
class TestQueenMethods(unittest.TestCase): """testing methods for board""" def setUp(self): self.board = Board(2, 2) def test_valid_moves(self): """testing queen's valid moves""" queen = Queen() self.board.set_tile(1, 0, 0) valid_moves_2 = queen.valid_moves(self.board) self.assertEqual(len(valid_moves_2), 3) self.board = Board(3, 3) self.board.set_tile(1, 0, 0) valid_moves_3 = queen.valid_moves(self.board) self.assertEqual(len(valid_moves_3), 6) def test_moves(self): """testing queen's invalid moves""" queen = Queen() self.board = Board(10, 10) queen.set_position(5, 5) self.board.set_tile(1, 5, 5) valid_moves_4 = queen.valid_moves(self.board) self.assertEqual(len(valid_moves_4), 35)
def setUp(self): TestCase.setUp(self) self.b = Board()
class TestTicTacToe(TestCase): def setUp(self): TestCase.setUp(self) self.b = Board() def test_update(self): update = self.b.update('5', 'X') self.assertEqual(self.b.spaces['5'], 'X', "Space '5' should be X") def test_available_spaces(self): self.b.spaces['5'] = 'O' self.b.spaces['9'] = 'X' spaces = self.b.available_spaces() self.assertEqual(spaces, ['1','2','3','4','6','7', '8'], "Avalaible spaces incorrect. Returned {0}".format(spaces)) def test_get_available_edges(self): self.b.spaces['2'] = 'O' self.b.spaces['4'] = 'X' edges = self.b.available_edges() self.assertEqual(edges, ['6','8'], "Avalaible edges incorrect. Returned {0}".format(edges)) def test_get_available_corners(self): self.b.spaces['7'] = 'O' self.b.spaces['9'] = 'X' corners = self.b.available_corners() self.assertEqual(corners, ['1','3'], "Avalaible corners incorrect. Returned {0}".format(corners)) def test_check_for_win(self): check = self.b.check_for_win(['X', 'X', 'X'] ) self.assertTrue(check, "Should be true") def test_check_for_win_false(self): check = self.b.check_for_win(['X', 'X', '']) self.assertFalse(check, "Should be false") def test_get_winner(self): self.b.spaces['1'] = 'X' self.b.spaces['2'] = 'X' self.b.spaces['3'] = 'X' winner = self.b.get_winner() self.assertEqual(winner, 'X', "Winner should be 'X'") def test_get_winner_none(self): self.b.spaces['1'] = 'X' self.b.spaces['2'] = 'X' self.b.spaces['3'] = '' winner = self.b.get_winner() self.assertEqual(winner, None, "Winner should be 'None'") def test_is_first_move(self): fm = self.b.is_first_move(self.b.available_spaces()) self.assertTrue(fm, "Should be true") def test_is_first_move_false(self): self.b.spaces['1'] = 'X' fm = self.b.is_first_move(self.b.available_spaces()) self.assertFalse(fm, "Should be false") def test_is_move_valid(self): self.b.spaces['1'] = 'X' self.b.spaces['2'] = 'X' vm = self.b.is_move_valid('3', self.b.available_spaces()) self.assertTrue(vm, 'Should be true') def test_is_move_valid_false(self): self.b.spaces['1'] = 'X' self.b.spaces['2'] = 'X' vm = self.b.is_move_valid('2', self.b.available_spaces()) self.assertFalse(vm, 'Should be false')
class TestTicTacToe(TestCase): def setUp(self): TestCase.setUp(self) self.p = Player('X') self.c = ComputerPlayer('O') self.b = Board() # # - Test Human Player Object # def test_player_mark(self): move = self.p.mark self.assertEqual(move, 'X', "Player mark should be 'X'") def test_player_first_move(self): move = self.p.move(first_move=True) self.assertEqual(move, move, "Should return input from player") def test_player_subsequent_move(self): move = self.p.move() self.assertEqual(move, move, "Should return input from player") # # - Test Computer Player/AI Object # def test_computer_mark(self): m = self.c.mark self.assertEqual(m, 'O', "Computer mark should be 'X'") def test_counter_first_move_center(self): move = self.c.counter_first_move('4', self.b.center, self.b.corners) self.assertEqual(move, '5', "Should be '5'") def test_counter_first_move_corner(self): move = self.c.counter_first_move('5', self.b.center, self.b.corners) self.assertTrue(move in self.b.corners, "Should be a corner") def test_counter_second_move_edge(self): move = self.c.counter_second_move('1', '4', self.b.edges, self.b.corners, self.b.check_edges) self.assertTrue(move in self.b.edges, "Should be an edge") def test_counter_second_move_corner(self): move = self.c.counter_second_move('4', '7', self.b.edges, self.b.corners, self.b.check_edges) self.assertTrue(move in self.b.corners, "Should be a corner") def test_counter_second_move_two_edges(self): self.b.spaces['2'] = self.p.mark self.b.spaces['6'] = self.p.mark self.b.spaces['5'] = self.c.mark move = self.c.counter_second_move('2', '6', self.b.available_edges(), self.b.available_corners(), self.b.check_edges) self.assertEqual(move, '3', "Should be '3'. returned {0}".format(move)) def test_computer_move_none(self): move = self.c.move([]) self.assertEqual(move, None, "Should be None") def test_computer_move(self): move = self.c.move(self.b.available_spaces()) self.assertTrue(move in self.b.available_spaces(), "Should be one of {0}".format(self.b.available_spaces())) def test_prevent_win(self): self.b.spaces['1'] = self.p.mark self.b.spaces['2'] = self.p.mark self.b.spaces['3'] = ' ' space = self.c.prevent_win(self.b.spaces, self.p.mark, self.b.possible_wins) self.assertEqual(space, '3', "Space to update should be '3'") def test_prevent_win_none(self): self.b.spaces['1'] = self.p.mark self.b.spaces['2'] = ' ' self.b.spaces['3'] = ' ' space = self.c.prevent_win(self.b.spaces, self.p.mark, self.b.possible_wins) self.assertEqual(space, None, "Space to update should be None") def test_go_for_win(self): self.b.spaces['1'] = self.c.mark self.b.spaces['5'] = self.c.mark self.b.spaces['9'] = ' ' space = self.c.go_for_win(self.b.spaces, self.c.mark, self.b.possible_wins) self.assertEqual(space, '9', "Space to update should be '9'") def test_go_for_win_none(self): self.b.spaces['1'] = ' ' self.b.spaces['5'] = self.c.mark self.b.spaces['9'] = ' ' space = self.c.go_for_win(self.b.spaces, self.c.mark, self.b.possible_wins) self.assertEqual(space, None, "Space to update should be None") def tearDown(self): TestCase.tearDown(self)
class TestGameEngine(unittest.TestCase): def setUp(self): self.board = Board(['1', '2', '3', '4', '5', '6', '7', '8', '9']) self.mock_io = Mock() self.mock_ai = Mock() self.mock_board_analyzer = Mock() self.moves = [2, 3] self.mock_io.get_move.side_effect = self.moves self.game_over_values = [False, True] self.mock_board_analyzer.game_over.side_effect = self.game_over_values self.engine = GameEngine(self.mock_io, self.mock_ai, self.mock_board_analyzer) def test_start_displays_board(self): self.engine.start(src.game.PLAYER_VS_PLAYER, self.board) self.mock_io.assert_has_calls([call.display_board(self.board)]) def test_start_gets_player_move(self): self.engine.start(src.game.PLAYER_VS_PLAYER, self.board) self.mock_io.assert_has_calls([call.get_move(self.board)]) def test_start_puts_move_on_the_board(self): self.engine.start(src.game.PLAYER_VS_PLAYER, self.board) self.assertEqual(self.board.get_square(self.moves[0]), 'X') def test_start_checks_if_game_is_over(self): self.engine.start(src.game.PLAYER_VS_PLAYER, self.board) self.mock_board_analyzer.assert_has_calls([call.game_over(self.board)]) def test_start_displays_game_over_message_when_game_is_over(self): self.engine.start(src.game.PLAYER_VS_PLAYER, self.board) self.mock_io.assert_has_calls( [call.display_game_over_message(self.mock_board_analyzer.winner)]) def test_place_move_allows_two_players_to_play(self): game_over_values = [False, False, True] self.mock_board_analyzer.game_over.side_effect = game_over_values self.engine.start(src.game.PLAYER_VS_PLAYER, self.board) self.assertEqual(self.board.get_square(self.moves[0]), 'X') self.assertEqual(self.board.get_square(self.moves[1]), 'O') def test_place_move_does_not_allow_move_to_be_placed_in_same_square(self): self.moves = [2, 2] self.mock_io.get_move.side_effect = self.moves game_over_values = [False, False, True] self.mock_board_analyzer.game_over.side_effect = game_over_values self.mock_board_analyzer.square_is_available.side_effect = [True, False] self.engine.start(src.game.PLAYER_VS_PLAYER, self.board) self.assertEqual(self.board.get_square(self.moves[0]), 'X') self.assertEqual(self.board.get_square(self.moves[1]), 'X') def test_place_move_allows_ai_to_move_second(self): ai_moves = [5] self.mock_ai.get_move.side_effect = ai_moves game_over_values = [False, False, True] self.mock_board_analyzer.game_over.side_effect = game_over_values self.engine.start(src.game.PLAYER_VS_AI, self.board) self.mock_ai.assert_has_calls([call.get_move(self.board, self.mock_ai.PLAYER_O)]) def test_start_allows_ai_to_play_against_itself(self): ai_moves = [5, 6] self.mock_ai.get_move.side_effect = ai_moves game_over_values = [False, False, True] self.mock_board_analyzer.game_over.side_effect = game_over_values self.engine.start(src.game.AI_VS_AI, self.board) self.mock_ai.assert_has_calls([call.get_move(self.board, self.mock_ai.PLAYER_X), call.get_move(self.board, self.mock_ai.PLAYER_O)])
def setUp(self): self.board = Board(3, 3) self.board.drop(Piece('X')) self.board.tick() self.board.tick()
class WhenABlockLandsOnAnotherBlock(unittest.TestCase): def setUp(self): self.board = Board(3, 3) self.board.drop(Piece('X')) self.board.tick() self.board.tick() self.board.tick() self.board.drop(Piece('Y')) self.board.tick() self.expected_board = "...\n" + ".Y.\n" + ".X.\n" def test_block_is_still_falling_right_above_the_other_block(self): self.assertTrue(self.board.has_falling_pieces()) self.assertEqual(self.expected_board, str(self.board)) def test_block_stops_when_it_hits_another_block(self): self.board.tick() self.assertFalse(self.board.has_falling_pieces()) self.assertEqual(self.expected_board, str(self.board)) with self.assertRaises(IllegalStateException): self.board.tick()
class TestBoard(unittest.TestCase): def setUp(self): self.board = Board() def test_put_mark_in_square_is_true_when_the_square_has_not_been_taken(self): self.assertTrue(self.board.put_mark_in_square(src.game.PLAYER_ONE, 1)) def test_put_mark_in_square_is_false_when_the_square_has_already_been_taken(self): self.board.put_mark_in_square(src.game.PLAYER_ONE, 1) self.assertFalse(self.board.put_mark_in_square(src.game.PLAYER_ONE, 1)) def test_square_is_available_is_true_when_x_or_o_has_not_taken_it(self): self.assertTrue(self.board.square_is_available(1)) def test_square_is_available_is_false_when_it_has_been_taken(self): self.board.put_mark_in_square(src.game.PLAYER_ONE, 1) self.assertFalse(self.board.square_is_available(0)) def test_squares_returns_the_number_of_squares_on_the_board(self): self.assertEqual(9, self.board.number_of_squares()) def test_get_square_returns_the_contents_of_the_given_square(self): self.assertEqual('1', self.board.get_square(1)) self.board.put_mark_in_square(src.game.PLAYER_ONE, 1) self.assertEqual(src.game.PLAYER_ONE, self.board.get_square(1)) def test_get_available_squares_returns_an_array_of_the_squares_not_taken(self): self.board.put_mark_in_square(src.game.PLAYER_ONE, 1) self.board.put_mark_in_square(src.game.PLAYER_ONE, 3) self.board.put_mark_in_square(src.game.PLAYER_ONE, 5) self.assertEqual([2, 4, 6, 7, 8, 9], self.board.get_available_squares()) def test_no_open_squares_should_be_true_when_all_squares_have_been_taken(self): for square in range(9): self.board.put_mark_in_square(src.game.PLAYER_ONE, square + 1) self.assertTrue(self.board.no_open_squares()) def test_no_open_squares_should_be_false_when_any_square_has_not_been_taken(self): for square in range(8): self.board.put_mark_in_square(src.game.PLAYER_ONE, square + 1) self.assertFalse(self.board.no_open_squares())
def get_board_from_id(board_id): if id: return Board.get_by_id(int(board_id)) return None
def setUp(self): self.board = Board()
def get_board_from_request(request): board_id = request.get('board') if board_id: return Board.get_by_id(int(board_id)) return None
def setUp(self): TestCase.setUp(self) self.p = Player('X') self.c = ComputerPlayer('O') self.b = Board()
else: counter = c.counter_second_move(first_move, second_move, b.available_edges(), b.available_corners(), b.check_edges, ) b.update(counter, c.mark) return counter if __name__ == '__main__': start_new_game() mark = set_marks() p = Player(mark["player_mark"]) c = ComputerPlayer(mark["computer_mark"]) b = Board() first_move = player_move() counter_move(first_move) b.display() second_move = player_move() prevent = c.prevent_win(b.spaces, p.mark, b.possible_wins) if prevent is None: counter = counter_move(first_move, second_move) else: b.update(prevent, c.mark) b.display() for space in b.available_spaces(): player_move()