def test_get_path(self): """ Unit test for ChessPiece.get_path() method """ pcs = { 'white': { 'initial': [(7, 0), (7, 2)], 'final': [(3, 3), (3, 4)] } } test_board = generate_scenario(pcs) # test for vertical/horizontal case piece = test_board.get_piece('d5') self.assertEqual(piece.get_path((3, 0)), [(3, 3), (3, 2), (3, 1), (3, 0)]) self.assertEqual(piece.get_path((3, 6)), [(3, 3), (3, 4), (3, 5), (3, 6)]) self.assertEqual(piece.get_path((0, 3)), [(3, 3), (2, 3), (1, 3), (0, 3)]) self.assertEqual(piece.get_path((6, 3)), [(3, 3), (4, 3), (5, 3), (6, 3)]) # test for diagonal case piece = test_board.get_piece('e5') self.assertEqual(piece.get_path((1, 2)), [(3, 4), (2, 3), (1, 2)]) self.assertEqual(piece.get_path((1, 6)), [(3, 4), (2, 5), (1, 6)]) self.assertEqual(piece.get_path((5, 2)), [(3, 4), (4, 3), (5, 2)]) self.assertEqual(piece.get_path((5, 6)), [(3, 4), (4, 5), (5, 6)])
def test_is_move_valid(self): """ Unit test for King.is_move_valid() method """ pcs = { 'black': { 'initial': [(1, 3)], 'final': [(4, 3)] }, 'white': { 'initial': [(7, 4)], 'final': [(5, 4)] } } test_board = generate_scenario(pcs) # test rejection of one-square vertical move blocked by friendly piece king = test_board.get_piece('e3') self.assertFalse(king.is_move_valid((6, 4), test_board.board)) # test success of one-square diagonal move to eliminate opponent piece self.assertTrue(king.is_move_valid((4, 3), test_board.board)) # test success of one-square horizontal move to empty square self.assertTrue(king.is_move_valid((5, 5), test_board.board)) # test rejection of multi-square vertical move to empty square self.assertFalse(king.is_move_valid((3, 4), test_board.board))
def test_is_checked(self): """ Unit test for King.is_checked() method """ # test king is not in check at beginning of game test_board = Board() king = test_board.get_piece('e1') self.assertFalse( king.is_checked(king.position, test_board.board, test_board.active_pieces)) # test king is checked in checked scenario pcs = { 'black': { 'initial': [(0, 3)], 'final': [(3, 0)] }, 'white': { 'initial': [(7, 4)], 'final': [(4, 0)] } } test_board = generate_scenario(pcs) king = test_board.get_piece('a4') self.assertTrue( king.is_checked(king.position, test_board.board, test_board.active_pieces))
def test_is_move_valid(self): """ Unit test for Queen.is_move_valid() method """ pcs = {'white': {'initial': [(7, 3)], 'final': [(4, 3)]}} test_board = generate_scenario(pcs) # test rejection of vertical move blocked by friendly piece queen = test_board.get_piece('d4') self.assertFalse(queen.is_move_valid((7, 3), test_board.board)) # test rejection of diagonal move blocked by friendly piece self.assertFalse(queen.is_move_valid((7, 0), test_board.board)) # test rejection of vertical move blocked by opponent piece self.assertFalse(queen.is_move_valid((0, 3), test_board.board)) # test rejection of diagonal move blocked by opponent piece self.assertFalse(queen.is_move_valid((0, 7), test_board.board)) # test success of vertical move to eliminate opponent piece self.assertTrue(queen.is_move_valid((1, 3), test_board.board)) # test success of diagonal move to eliminate opponent piece self.assertTrue(queen.is_move_valid((1, 6), test_board.board)) # test success of horizontal move to empty square self.assertTrue(queen.is_move_valid((4, 7), test_board.board)) # test rejection of L-shaped move to empty square self.assertFalse(queen.is_move_valid((2, 4), test_board.board))
def test_check(self): """ Unit test for Match.check() method """ test_match = Match() # craft scenario where black made a move that placed white king in check, but not checkmate pcs = { 'black': { 'initial': [(0, 0)], 'final': [(4, 0)] }, 'white': { 'initial': [(7, 4)], 'final': [(4, 4)] } } test_match.chessboard = generate_scenario(pcs) test_match.turn = 'black' test_match.not_turn = 'white' # test Match can detect king is in check without checkmate test_match.check() self.assertTrue(test_match.incheck) self.assertFalse(test_match.checkmate) # craft complex checkmate scenario where black wins (involves 5 black pieces) pcs = { 'black': { 'initial': [(0, 0), (0, 2), (1, 3), (0, 5), (1, 6), (0, 6)], 'final': [(4, 0), (2, 2), (2, 3), (2, 7), (4, 7), (1, 6)] }, 'white': { 'initial': [(7, 4), (6, 3)], 'final': [(4, 4), (5, 3)] } } test_match.chessboard = generate_scenario(pcs) test_match.black = 'black' test_match.check() # test Match can detect complex checkmate scenario self.assertTrue(test_match.checkmate)
def test_is_move_valid(self): """ Unit test for Knight.is_move_valid() method """ pcs = {'white': {'initial': [(7, 6)], 'final': [(2, 6)]}} test_board = generate_scenario(pcs) # test rejection of move blocked by friendly piece knight = test_board.get_piece('b1') self.assertFalse(knight.is_move_valid((6, 3), test_board.board)) # test success of L-shaped move into empty square self.assertTrue(knight.is_move_valid((5, 2), test_board.board)) # test success of L-shaped move to eliminate opponent piece knight = test_board.get_piece('g6') self.assertTrue(knight.is_move_valid((0, 5), test_board.board)) # test success of different L-shaped move to eliminate opponent piece self.assertTrue(knight.is_move_valid((1, 4), test_board.board))
def test_is_move_valid(self): """ Unit test for Rook.is_move_valid() method """ pcs = {'white': {'initial': [(7, 7)], 'final': [(5, 7)]}} test_board = generate_scenario(pcs) # test for rejection of move that is blocked by friendly piece rook = test_board.get_piece('a1') self.assertFalse(rook.is_move_valid((5, 0), test_board.board)) # test for success of horizontal move across board rook = test_board.get_piece('h3') self.assertTrue(rook.is_move_valid((5, 0), test_board.board)) # test for success of move to eliminate opponent piece self.assertTrue(rook.is_move_valid((1, 7), test_board.board)) # test for rejection of move that is blocked by opponent piece self.assertFalse(rook.is_move_valid((0, 7), test_board.board))
def test_is_move_valid(self): """ Unit test for Bishop.is_move_valid() method """ pcs = {'white': {'initial': [(7, 5)], 'final': [(4, 4)]}} test_board = generate_scenario(pcs) # test rejection of diagonal move into square occupied by friendly piece bishop = test_board.get_piece('e4') self.assertFalse(bishop.is_move_valid((6, 2), test_board.board)) # test rejection of diagonal move that is blocked by opponent piece self.assertFalse(bishop.is_move_valid((0, 0), test_board.board)) # test success of diagonal move to eliminate opponent piece self.assertTrue(bishop.is_move_valid((1, 7), test_board.board)) # test success of diagonal move into empty square self.assertTrue(bishop.is_move_valid((2, 6), test_board.board)) # test rejection of non-diagonal move into empty square self.assertFalse(bishop.is_move_valid((2, 4), test_board.board))
def test_en_passant(self): """ Unit test for Pawn.en_passant() method """ # craft en passant scenario pcs = { 'black': { 'initial': [(1, 2)], 'final': [(3, 2)] }, 'white': { 'initial': [(6, 1)], 'final': [(3, 1)] } } test_board = generate_scenario(pcs) wpawn = test_board.get_piece('b5') # white pawn in en passant position bpawn = test_board.get_piece('c5') # black pawn bpawn.first_move = 2 bpawn.two_step = True # test proper detection of en passant move turn = 3 result, side = wpawn.en_passant(test_board.board, turn) self.assertTrue(result) # assert en passant move is valid self.assertEqual(side, 'E') # assert correct direction of en passant move # test no detection of valid en passant move turn = 5 result, side = wpawn.en_passant(test_board.board, turn) self.assertFalse( result ) # assert move is invalid since en passant move was forfeited turn = 3 bpawn.two_step = False result, side = wpawn.en_passant(test_board.board, turn) self.assertFalse( result ) # assert move is invalid since black pawn did not use two step
def test_move(self): """ Unit test for Match.move() method """ test_match = Match() # test success of moving pawn two spaces forward on first turn test_match.select_piece('d2') # select white pawn self.assertTrue(test_match.move('d4')) # move two spaces forward pawn = test_match.chessboard.get_piece( 'd4') # get occupant at new position self.assertIs(type(pawn), Pawn) # ensure pawn is at the new position empty = test_match.chessboard.get_piece( 'd2') # get occupant at pawn's old position self.assertEqual(empty, 0) # ensure pawn's old position is empty # test rejection of moving pawn two spaces forward after first turn self.assertFalse(test_match.move('d6')) # test success of moving pawn one space forward after first turn self.assertTrue(test_match.move('d5')) # craft scenario where moving a white pawn forward one space will result in white's king in check pcs = { 'black': { 'initial': [(0, 0)], 'final': [(4, 0)] }, 'white': { 'initial': [(7, 4), (6, 3)], 'final': [(4, 4), (4, 3)] } } test_match.chessboard = generate_scenario(pcs) # test rejection of moving white pawn forward leaving white king in check test_match.select_piece('d4') # select white pawn self.assertFalse(test_match.move('d5'))
def test_is_move_valid(self): """ Unit test for Pawn.is_move_valid() method """ pcs = { 'black': { 'initial': [(1, 2)], 'final': [(5, 2)] }, 'white': { 'initial': [(6, 5)], 'final': [(4, 5)] } } test_board = generate_scenario(pcs) # test for success of two spaces forward on first move pawn = test_board.get_piece('a2') self.assertTrue(pawn.is_move_valid((4, 0), test_board.board)) # test for rejection of two spaces forward after first move pawn.moved = True self.assertFalse(pawn.is_move_valid((4, 0), test_board.board)) # test for success of one space forward self.assertTrue(pawn.is_move_valid((5, 0), test_board.board)) # test for rejection of move one space forward when opponent is blocking pawn = test_board.get_piece('c2') self.assertFalse(pawn.is_move_valid((5, 2), test_board.board)) # test for rejection of move two spaces forward when opponent is blocking first space but not second self.assertFalse(pawn.is_move_valid((4, 2), test_board.board)) # test for success of diagonal move to eliminate opponent pawn = test_board.get_piece('d2') self.assertTrue(pawn.is_move_valid((5, 2), test_board.board)) # test for rejection of diagonal move into an empty square self.assertFalse(pawn.is_move_valid((5, 4), test_board.board)) # test for rejection of move backward pawn = test_board.get_piece('f4') self.assertFalse(pawn.is_move_valid((5, 5), test_board.board)) # craft en passant scenario pcs = { 'black': { 'initial': [(1, 2)], 'final': [(3, 2)] }, 'white': { 'initial': [(6, 1)], 'final': [(3, 1)] } } test_board = generate_scenario(pcs) wpawn = test_board.get_piece('b5') # white pawn in en passant position bpawn = test_board.get_piece('c5') # black pawn bpawn.first_move = 2 bpawn.two_step = True # test success of en passant move turn = 3 # immediate turn after black pawn moved forward two spaces self.assertTrue(wpawn.is_move_valid( (2, 2), test_board.board, turn)) # assert en passant move is valid self.assertTrue( wpawn.enpassant) # assert enpassant attribute was turned on self.assertFalse(wpawn.is_move_valid( (0, 2), test_board.board, turn)) # assert move only goes one direction # test rejection of en passant move after it is forfeited turn = 5 self.assertFalse(wpawn.is_move_valid( (2, 2), test_board.board, turn)) # assert en passant move is invalid