Exemplo n.º 1
0
    def test_pawn_black_capture_promo(self):
        """Tests that a pawn that is about to promote can do so via capture."""
        board, white, black = create_board_and_players()
        pawn_black = Pawn(black, [3, 6])  # d2
        board.add_to_board(pawn_black)
        rook_white1 = Rook(white, [2, 7])  # c1
        board.add_to_board(rook_white1)
        rook_white2 = Rook(white, [4, 7])  # e1
        board.add_to_board(rook_white2)
        king_white = King(white, [3, 7])  # d1
        board.add_to_board(king_white)

        correct_move1 = [2, "Q"]  # c8
        correct_move2 = [2, "N"]  # c8
        correct_move3 = [2, "B"]  # c8
        correct_move4 = [2, "R"]  # c8
        correct_move5 = [4, "Q"]  # e8
        correct_move6 = [4, "N"]  # e8
        correct_move7 = [4, "B"]  # e8
        correct_move8 = [4, "R"]  # e8

        returned_moves = pawn_black.get_legal_moves(board, True)
        self.assertTrue(len(returned_moves) == 8)
        self.assertTrue(correct_move1 in returned_moves)
        self.assertTrue(correct_move2 in returned_moves)
        self.assertTrue(correct_move3 in returned_moves)
        self.assertTrue(correct_move4 in returned_moves)
        self.assertTrue(correct_move5 in returned_moves)
        self.assertTrue(correct_move6 in returned_moves)
        self.assertTrue(correct_move7 in returned_moves)
        self.assertTrue(correct_move8 in returned_moves)
Exemplo n.º 2
0
 def test_pawn_black_path_impeded(self):
     """Tests that no moves are returned if the pawn's path is impeded."""
     board, white, black = create_board_and_players()
     pawn_white = Pawn(white, [3, 6])  # d2
     board.add_to_board(pawn_white)
     pawn_black = Pawn(black, [3, 5])  # d3
     board.add_to_board(pawn_black)
     returned_moves = pawn_black.get_legal_moves(board, True)
     self.assertTrue(len(returned_moves) == 0)  
Exemplo n.º 3
0
    def test_pawn_black_simple(self):
        """Tests that a simple forward move is in the pawn's move list."""
        board, black = Board(), Player(Color.B)
        pawn_black = Pawn(black, [3, 4])  # d4
        pawn_black.first_move = False
        board.add_to_board(pawn_black)

        correct_move = [3, 5]  # d3

        returned_moves = pawn_black.get_legal_moves(board, True)
        self.assertTrue(len(returned_moves) == 1)
        self.assertTrue(correct_move in returned_moves)
Exemplo n.º 4
0
    def test_pawn_white_simple(self):
        """Tests that a simple forward move is in the pawn's move list."""
        board, white = Board(), Player(Color.W)
        pawn_white = Pawn(white, [3, 4])  # d4
        pawn_white.first_move = False
        board.add_to_board(pawn_white)

        correct_move = [3, 3]  # d5

        returned_moves = pawn_white.get_legal_moves(board, True)
        self.assertTrue(len(returned_moves) == 1)
        self.assertTrue(correct_move in returned_moves)
Exemplo n.º 5
0
    def test_pawn_white_first_move(self):
        """Tests that two moves are available to a new unimpeded pawn."""
        board, white = Board(), Player(Color.W)
        pawn_white = Pawn(white, [3, 6])  # d2
        board.add_to_board(pawn_white)

        correct_move1 = [3, 5]  # d3
        correct_move2 = [3, 4]  # d4

        returned_moves = pawn_white.get_legal_moves(board, True)
        self.assertTrue(len(returned_moves) == 2)
        self.assertTrue(correct_move1 in returned_moves)
        self.assertTrue(correct_move2 in returned_moves)
Exemplo n.º 6
0
    def test_pawn_black_first_move(self):
        """Tests that two moves are available to a new unimpeded pawn."""
        board, black = Board(), Player(Color.B)
        pawn_black = Pawn(black, [3, 1])  # d7
        board.add_to_board(pawn_black)

        correct_move1 = [3, 2]  # d6
        correct_move2 = [3, 3]  # d5

        returned_moves = pawn_black.get_legal_moves(board, True)
        self.assertTrue(len(returned_moves) == 2)
        self.assertTrue(correct_move1 in returned_moves)
        self.assertTrue(correct_move2 in returned_moves)
Exemplo n.º 7
0
    def test_make_move_pawn_en_passant(self):
        """Verifies that taking a pawn en passant removes enemy pawn."""
        board, white, black = create_board_and_players()
        pawn_pos_white = [5, 3]  # f5
        pawn_white = Pawn(white, pawn_pos_white)
        board.add_to_board(pawn_white)

        pawn_pos_black = [4, 3]  # e5
        pawn_black = Pawn(black, pawn_pos_black)
        board.add_to_board(pawn_black)
        # simulate having made its first move.
        board.en_passant = pawn_black

        board.make_move(pawn_white, [4, 2])  # e6
        self.assertTrue(board.get_piece_at_position([4, 2]) is pawn_white)
        self.assertTrue(board.get_piece_at_position([4, 3]) is None)
Exemplo n.º 8
0
    def test_get_all_legal_moves_check(self):
        """Assures that get_all_legal_moves won't return a move that puts
        the owner in check."""
        board, white, black = create_board_and_players()
        pawn_pos_white = [4, 6]  # e2
        pawn_white = Pawn(white, pawn_pos_white)
        board.add_to_board(pawn_white)

        king_pos_white = [5, 6]
        king_white = King(white, king_pos_white)
        board.add_to_board(king_white)

        found_a_move = False
        for move in board.get_all_legal_moves(white):
            if move[0] == pawn_white:
                found_a_move = True
        self.assertTrue(found_a_move)

        rook_pos_black = [1, 6]
        rook_black = Rook(black, rook_pos_black)
        board.add_to_board(rook_black)

        found_a_move = False
        for move in board.get_all_legal_moves(white):
            if move[0] == pawn_white:
                found_a_move = True
        self.assertFalse(found_a_move)
Exemplo n.º 9
0
    def test_check_if_opponent(self):
        """Add one piece from each player to the board, verify booleans
        are correct."""
        board, white, black = create_board_and_players()
        pos_white = [4, 6]  # e2
        pawn_white = Pawn(white, pos_white)

        pos_black = [4, 1]
        pawn_black = Pawn(black, pos_black)

        board.add_to_board(pawn_white)
        board.add_to_board(pawn_black)

        self.assertFalse(board.check_if_opponent(pos_white, white))
        self.assertFalse(board.check_if_opponent(pos_black, black))
        self.assertTrue(board.check_if_opponent(pos_black, white))
        self.assertTrue(board.check_if_opponent(pos_white, black))
Exemplo n.º 10
0
    def test_make_move_pawn_promotion(self):
        """Verifies that making promition moves work appropriately."""
        board, white = Board(), Player(Color.W)
        pawn_white = Pawn(white, [3, 1])  # d7
        board.add_to_board(pawn_white)

        board.make_move(pawn_white, [3, 'Q'])  # promotion at d8 square
        # ensure the new piece is a queen.
        self.assertTrue(isinstance(board.get_piece_at_position([3, 0]), Queen))
Exemplo n.º 11
0
 def test_Pawn(self):
     self.assertEqual(str(Pawn(1, 1, WHITE, None)), 'Pa1')
     self.assertEqual(str(Pawn(1, 1, BLACK, None)), 'pa1')
     cases = [
         ('Pe2', ['e3', 'e4']),
         ('Pe3', ['e4']),
         ('Pe7', ['e8']),
         ('Pe2,Be4', ['e3']),
         ('Pe2,Be3', []),
         ('Pe4,pf5', ['e5', 'f5']),
         ('Pe4,pd5,pe5,pf5', ['d5', 'f5']),
     ]
     cases_vis = [
         ('Pe2', ['e3', 'e4', 'd3', 'f3']),
         ('Pe2,qe3', ['e3', 'd3', 'f3']),
     ]
     self.check_cases(WHITE, PAWN, cases)
     self.check_cases_visible(WHITE, PAWN, cases_vis)
Exemplo n.º 12
0
    def test_pawn_black_promotion(self):
        """Tests that the four promotion moves are available to a promoting
         pawn."""
        board, black = Board(), Player(Color.B)
        pawn_black = Pawn(black, [3, 6])  # d2
        board.add_to_board(pawn_black)

        correct_move1 = [3, "Q"]  # d1
        correct_move2 = [3, "N"]  # d1
        correct_move3 = [3, "B"]  # d1
        correct_move4 = [3, "R"]  # d1

        returned_moves = pawn_black.get_legal_moves(board, True)
        self.assertTrue(len(returned_moves) == 4)
        self.assertTrue(correct_move1 in returned_moves)
        self.assertTrue(correct_move2 in returned_moves)
        self.assertTrue(correct_move3 in returned_moves)
        self.assertTrue(correct_move4 in returned_moves)
Exemplo n.º 13
0
 def test_get_piece_at_position(self):
     """Fetch a piece we add to the board, fetch an empty square
     and make sure we get None."""
     board, white = Board(), Player(Color.W)
     pos_white = [4, 6]  # e2
     pawn_white = Pawn(white, pos_white)
     board.add_to_board(pawn_white)
     self.assertTrue(board.get_piece_at_position(pos_white) is pawn_white)
     self.assertTrue(board.get_piece_at_position([1, 1]) is None)
Exemplo n.º 14
0
    def test_pawn_white_promotion(self):
        """Tests that the four promotion moves are available to a promoting
         pawn."""
        board, white = Board(), Player(Color.W)
        pawn_white = Pawn(white, [3, 1])  # d7
        board.add_to_board(pawn_white)

        correct_move1 = [3, "Q"]  # d8
        correct_move2 = [3, "N"]  # d8
        correct_move3 = [3, "B"]  # d8
        correct_move4 = [3, "R"]  # d8

        returned_moves = pawn_white.get_legal_moves(board, True)
        self.assertTrue(len(returned_moves) == 4)
        self.assertTrue(correct_move1 in returned_moves)
        self.assertTrue(correct_move2 in returned_moves)
        self.assertTrue(correct_move3 in returned_moves)
        self.assertTrue(correct_move4 in returned_moves)
Exemplo n.º 15
0
    def test_determine_check(self):
        """Creates two check situations and verifies that is_in_check returns
        True in both situations."""
        # Check 1:
        board, white, black = create_board_and_players()

        pos_rook_black = [4, 0]  # e8
        rook_black = Rook(black, pos_rook_black)

        pos_king_white = [4, 7]  # e1
        king_white = King(white, pos_king_white)

        board.add_to_board(rook_black)
        board.add_to_board(king_white)

        self.assertTrue(board.is_in_check(white))

        # Add a separation pawn, should no longer be in check

        pos_pawn_black = [4, 3]  # e5
        pawn_black = Pawn(black, pos_pawn_black)
        board.add_to_board(pawn_black)
        self.assertFalse(board.is_in_check(white))

        # Check 2:
        board, white, black = create_board_and_players()

        pos_bishop_black = [1, 0]  # b8
        bishop_black = Bishop(black, pos_bishop_black)

        pos_king_white = [5, 4]  # f4
        king_white = King(white, pos_king_white)

        board.add_to_board(bishop_black)
        board.add_to_board(king_white)

        self.assertTrue(board.is_in_check(white))

        # Add a separation pawn, should no longer be in check

        pos_pawn_black = [3, 2]  # d6
        pawn_black = Pawn(black, pos_pawn_black)
        board.add_to_board(pawn_black)
        self.assertFalse(board.is_in_check(white))
Exemplo n.º 16
0
    def test_make_move_pawn_double_jump(self):
        """Verifies that making a double jump opens up the piece for
         en passant."""
        board, white = Board(), Player(Color.W)
        pawn_pos_white = [5, 6]  # f2
        pawn_white = Pawn(white, pawn_pos_white)
        board.add_to_board(pawn_white)

        board.make_move(pawn_white, [5, 4])
        self.assertTrue(board.en_passant is pawn_white)
Exemplo n.º 17
0
    def test_check_if_empty(self):
        """Make sure check_if_empty returns True at first,
        and then False when we add a piece."""
        board, white = Board(), Player(Color.W)
        pos_white = [4, 6]  # e2
        pawn_white = Pawn(white, pos_white)

        self.assertTrue(board.check_if_empty(pos_white))
        board.add_to_board(pawn_white)
        self.assertFalse(board.check_if_empty(pos_white))
Exemplo n.º 18
0
    def test_get_all_legal_moves_simple(self):
        """Simply verify that getting the legal moves of two pieces
        sum to the returned value of get_all_legal_moves."""
        board, white = Board(), Player(Color.W)
        pos_white = [4, 6]  # e2
        pawn_white = Pawn(white, pos_white)
        board.add_to_board(pawn_white)

        pos_white2 = [3, 3]  # d5
        rook_white = Rook(white, pos_white2)
        board.add_to_board(rook_white)

        combined_positions = []
        for move in pawn_white.get_legal_moves(board, True):
            combined_positions += [pawn_white, move],
        for move in rook_white.get_legal_moves(board, True):
            combined_positions += [rook_white, move],

        self.assertEqual(board.get_all_legal_moves(white), combined_positions)
Exemplo n.º 19
0
    def test_remove_a_piece(self):
        """Add a piece, then remove it, and verify space is empty"""
        board, white = Board(), Player(Color.W)
        pos_white = [4, 6]  # e2
        pawn_white = Pawn(white, pos_white)
        board.add_to_board(pawn_white)

        # emptySpace
        self.assertFalse(board.check_if_empty(pos_white))
        board.remove_from_board(pos_white)
        self.assertTrue(board.check_if_empty(pos_white))
Exemplo n.º 20
0
    def test_pawn_black_en_passant(self):
        """Tests that en passant opportunities are returned correctly."""
        board, white, black = create_board_and_players()
        pawn_black = Pawn(black, [3, 4])  # d4
        pawn_black.first_move = False
        board.add_to_board(pawn_black)
        pawn_white = Pawn(white, [2, 6])  # c2
        board.add_to_board(pawn_white)

        # simulate a move to c4, creating en passant opportunity.
        board.make_move(pawn_white, [2, 4])

        correct_move1 = [3, 5]  # d3
        correct_move2 = [2, 5]  # c3, en passant capture

        returned_moves = pawn_black.get_legal_moves(board, True)
        self.assertTrue(len(returned_moves) == 2)

        self.assertTrue(correct_move1 in returned_moves)
        self.assertTrue(correct_move2 in returned_moves)
Exemplo n.º 21
0
    def test_path_impeded(self):
        """Verifies that a bishop's returned moves stops when encountering
        another of the bishop's owner's pieces."""
        board, white = Board(), Player(Color.W)
        queen_white = Queen(white, [3, 4])  # d4
        board.add_to_board(queen_white)

        pawn_white1 = Pawn(white, [2, 3])  # c5
        board.add_to_board(pawn_white1)

        incorrect_move1 = [2, 3]  # c6

        pawn_white2 = Pawn(white, [2, 4])  # c4
        board.add_to_board(pawn_white2)

        incorrect_move2 = [2, 4]  # c4

        returned_moves = queen_white.get_legal_moves(board, True)
        self.assertTrue(len(returned_moves) == 21)
        self.assertTrue(incorrect_move1 not in returned_moves)
        self.assertTrue(incorrect_move2 not in returned_moves)
Exemplo n.º 22
0
    def test_board_with_passed_in_board(self):
        """Tests the creation of a board using a previous
        board's array. Each peice should have a copy created."""
        board, white = Board(), Player(Color.W)
        pawn_white = Pawn(white, [3, 2])  # d6
        board.add_to_board(pawn_white)

        new_board = Board(board.board)
        self.assertEqual(len(new_board.pieces), 1)
        self.assertFalse(new_board.check_if_empty([3, 2]))
        self.assertFalse(new_board.get_piece_at_position([3, 2]) is
                         pawn_white)
Exemplo n.º 23
0
    def test_capture(self):
        """Verifies that a queen's returned movelist correctly includes
        a capture opportunity."""
        board, white, black = create_board_and_players()
        queen_white = Queen(white, [3, 4])  # d4
        board.add_to_board(queen_white)

        pawn_black = Pawn(black, [2, 3])  # c5
        board.add_to_board(pawn_black)

        correct_move1 = [2, 5]  # c6

        pawn_black = Pawn(black, [2, 4])  # c4
        board.add_to_board(pawn_black)

        correct_move2 = [2, 4]  # c4

        returned_moves = queen_white.get_legal_moves(board, True)
        self.assertTrue(len(returned_moves) == 23)
        self.assertTrue(correct_move1 in returned_moves)
        self.assertTrue(correct_move2 in returned_moves)
Exemplo n.º 24
0
    def test_pawn_black_capture(self):
        """Tests that pawn capture moves are returned correctly."""
        board, white, black = create_board_and_players()
        pawn_black = Pawn(black, [3, 4])  # d4
        pawn_black.first_move = False
        board.add_to_board(pawn_black)
        pawn_white1 = Pawn(white, [2, 5])  # c3
        board.add_to_board(pawn_white1)
        pawn_white2 = Pawn(white, [4, 5])  # e3
        board.add_to_board(pawn_white2)

        correct_move1 = [3, 5]  # d3
        correct_move2 = [2, 5]  # c3
        correct_move3 = [4, 5]  # e3

        returned_moves = pawn_black.get_legal_moves(board, True)
        self.assertTrue(len(returned_moves) == 3)

        self.assertTrue(correct_move1 in returned_moves)
        self.assertTrue(correct_move2 in returned_moves)
        self.assertTrue(correct_move3 in returned_moves)
Exemplo n.º 25
0
    def test_make_move_pawn_simple(self):
        """Makes a simple pawn move, verifies values are appropriately
         updated."""
        board, white = Board(), Player(Color.W)
        pawn_white = Pawn(white, [3, 6])  # d2
        board.add_to_board(pawn_white)

        board.make_move(pawn_white, [3, 4])  # d4
        # ensure make_move updated piece position
        self.assertTrue(pawn_white.position == [3, 4])
        # ensure make_move updated board position
        self.assertTrue(board.get_piece_at_position([3, 4]) is pawn_white)
        self.assertTrue(board.get_piece_at_position([3, 6]) is None)
Exemplo n.º 26
0
    def test_add_to_board(self):
        """Add a piece, verify the square is taken and that the board's
        pieces list has the piece in it."""
        board, white = Board(), Player(Color.W)
        pos_white = [4, 6]  # e2
        pawn_white = Pawn(white, pos_white)

        board.add_to_board(pawn_white)

        # fetch the piece using xy_conversion
        self.assertTrue(board.board[xy_to_num(pos_white)] is pawn_white)

        # assure that the piece is in the board's pieces list.
        self.assertTrue(pawn_white in board.pieces)
Exemplo n.º 27
0
    def test_capture(self):
        """Verifies that a knights's returned movelist correctly includes
        a capture opportunity."""
        board, white, black = create_board_and_players()
        knight_white = Knight(white, [3, 4])  # d4
        board.add_to_board(knight_white)

        pawn_black = Pawn(black, [2, 2])  # c6
        board.add_to_board(pawn_black)

        correct_move1 = [2, 2]  # c6

        returned_moves = knight_white.get_legal_moves(board, True)
        self.assertTrue(len(returned_moves) == 8)
        self.assertTrue(correct_move1 in returned_moves)
Exemplo n.º 28
0
    def test_capture(self):
        """Verifies that a bishop's returned move list correctly includes
        a capture opportunity."""
        board, white, black = create_board_and_players()
        bishop_white = Bishop(white, [3, 4])  # d4
        board.add_to_board(bishop_white)

        pawn_black = Pawn(black, [2, 5])  # c3
        board.add_to_board(pawn_black)

        correct_move1 = [2, 5]  # c3

        returned_moves = bishop_white.get_legal_moves(board, True)
        self.assertTrue(len(returned_moves) == 11)
        self.assertTrue(correct_move1 in returned_moves)
Exemplo n.º 29
0
    def test_path_impeded(self):
        """Verifies that a rook's returned moves stops when encountering
        another of the rook's owner's pieces."""
        board, white = Board(), Player(Color.W)
        rook_white = Rook(white, [3, 4])  # d4
        board.add_to_board(rook_white)

        pawn_white = Pawn(white, [2, 4])  # c4
        board.add_to_board(pawn_white)

        incorrect_move1 = [2, 4]  # c4

        returned_moves = rook_white.get_legal_moves(board, True)
        self.assertTrue(len(returned_moves) == 11)
        self.assertTrue(incorrect_move1 not in returned_moves)
Exemplo n.º 30
0
    def test_capture(self):
        """Verifies that a rook's returned move list correctly includes
        a capture opportunity."""
        board, white, black = create_board_and_players()
        rook_white = Rook(white, [3, 4])  # d4
        board.add_to_board(rook_white)

        pawn_black = Pawn(black, [2, 4])  # c4
        board.add_to_board(pawn_black)

        correct_move1 = [2, 4]  # c4

        returned_moves = rook_white.get_legal_moves(board, True)
        self.assertTrue(len(returned_moves) == 12)
        self.assertTrue(correct_move1 in returned_moves)
Exemplo n.º 31
0
    def test_path_impeded(self):
        """Verifies that a bishop's returned moves stops when encountering
        another of the bishop's owner's pieces."""
        board, white = Board(), Player(Color.W)
        king_white = King(white, [3, 4])  # d4
        board.add_to_board(king_white)

        pawn_white = Pawn(white, [2, 4])  # c4
        board.add_to_board(pawn_white)

        incorrect_move1 = [2, 4]  # c4

        returned_moves = king_white.get_legal_moves(board, True)
        self.assertTrue(len(returned_moves) == 7)
        self.assertFalse(incorrect_move1 in returned_moves)
Exemplo n.º 32
0
    def test_filter_checks(self):
        """Assure that all moves that lead to check for the player are
        appropriately filtered out of the move list."""
        board, white, black = create_board_and_players()
        pawn_pos_white = [5, 3]  # f5
        pawn_white = Pawn(white, pawn_pos_white)
        pawn_white.first_move = False
        board.add_to_board(pawn_white)

        king_pos_white = [7, 3]  # h5
        king_white = King(white, king_pos_white)
        board.add_to_board(king_white)

        pawn_moves = pawn_white.get_legal_moves(board, False)
        filtered_pawn_moves = pawn_white.filter_checks(pawn_moves, board)
        self.assertEqual(pawn_moves, filtered_pawn_moves)

        rook_pos_black = [1, 3]  # a1
        rook_black = Rook(black, rook_pos_black)
        board.add_to_board(rook_black)

        pawn_moves = pawn_white.get_legal_moves(board, False)
        filtered_pawn_moves = pawn_white.filter_checks(pawn_moves, board)
        self.assertEqual(len(filtered_pawn_moves), 0)