def test_square(self):

for square in chess.SQUARES:

file_index = chess.file_index(square)

rank_index = chess.rank_index(square)

def test_equality(self):

a = chess.Move(chess.A1, chess.A2)

b = chess.Move(chess.A1, chess.A2)

c = chess.Move(chess.H7, chess.H8, chess.BISHOP)

d1 = chess.Move(chess.H7, chess.H8)

d2 = chess.Move(chess.H7, chess.H8)

self.assertEqual(a, b)

self.assertEqual(b, a)

self.assertEqual(d1, d2)

self.assertNotEqual(a, c)

self.assertNotEqual(c, d1)

self.assertNotEqual(b, d1)

self.assertFalse(d1 != d2)

def test_uci_parsing(self):

self.assertEqual(chess.Move.from_uci("b5c7").uci(), "b5c7")

def test_equality(self):

a = chess.Piece(chess.BISHOP, chess.WHITE)

b = chess.Piece(chess.KING, chess.BLACK)

c = chess.Piece(chess.KING, chess.WHITE)

d1 = chess.Piece(chess.BISHOP, chess.WHITE)

d2 = chess.Piece(chess.BISHOP, chess.WHITE)

self.assertEqual(a, d1)

self.assertEqual(d1, a)

self.assertEqual(d1, d2)

self.assertEqual(repr(a), repr(d1))

self.assertNotEqual(a, b)

self.assertNotEqual(b, c)

self.assertNotEqual(b, d1)

self.assertNotEqual(a, c)

self.assertFalse(d1 != d2)

self.assertNotEqual(repr(a), repr(b))

self.assertNotEqual(repr(b), repr(c))

self.assertNotEqual(repr(b), repr(d1))

self.assertNotEqual(repr(a), repr(c))

def test_from_symbol(self):

white_knight = chess.Piece.from_symbol("N")

self.assertEqual(white_knight.color, chess.WHITE)

self.assertEqual(white_knight.piece_type, chess.KNIGHT)

self.assertEqual(white_knight.symbol(), "N")

black_queen = chess.Piece.from_symbol("q")

self.assertEqual(black_queen.color, chess.BLACK)

self.assertEqual(black_queen.piece_type, chess.QUEEN)

def test_default_position(self):

board = chess.Board()

self.assertEqual(board.piece_at(chess.B1), chess.Piece.from_symbol("N"))

self.assertEqual(board.fen(), chess.STARTING_FEN)

self.assertEqual(board.turn, chess.WHITE)

def test_empty(self):

board = chess.Board.empty()

self.assertEqual(board.fen(), "8/8/8/8/8/8/8/8 w - - 0 1")

self.assertEqual(board, chess.Board(None))

def test_from_epd(self):

base_epd = "rnbqkb1r/ppp1pppp/5n2/3P4/8/8/PPPP1PPP/RNBQKBNR w KQkq -"

board, ops = chess.Board.from_epd(base_epd + " ce 55;")

self.assertEqual(ops["ce"], 55)

self.assertEqual(board.fen(), base_epd + " 0 1")

def test_move_making(self):

board = chess.Board()

move = chess.Move(chess.E2, chess.E4)

board.push(move)

self.assertEqual(board.peek(), move)

def test_fen(self):

board = chess.Board()

self.assertEqual(board.fen(), chess.STARTING_FEN)

fen = "6k1/pb3pp1/1p2p2p/1Bn1P3/8/5N2/PP1q1PPP/6K1 w - - 0 24"

board.set_fen(fen)

self.assertEqual(board.fen(), fen)

board.push(chess.Move.from_uci("f3d2"))

self.assertEqual(board.fen(), "6k1/pb3pp1/1p2p2p/1Bn1P3/8/8/PP1N1PPP/6K1 b - - 0 24")

def test_xfen(self):

# https://de.wikipedia.org/wiki/Forsyth-Edwards-Notation#Beispiel

xfen = "rn2k1r1/ppp1pp1p/3p2p1/5bn1/P7/2N2B2/1PPPPP2/2BNK1RR w Gkq - 4 11"

board = chess.Board(xfen, chess960=True)

self.assertEqual(board.castling_rights, chess.BB_G1 | chess.BB_A8 | chess.BB_G8)

self.assertEqual(board.clean_castling_rights(), chess.BB_G1 | chess.BB_A8 | chess.BB_G8)

self.assertEqual(board.shredder_fen(), "rn2k1r1/ppp1pp1p/3p2p1/5bn1/P7/2N2B2/1PPPPP2/2BNK1RR w Gga - 4 11")

self.assertEqual(board.fen(), xfen)

self.assertTrue(board.has_castling_rights(chess.WHITE))

self.assertTrue(board.has_castling_rights(chess.BLACK))

self.assertTrue(board.has_kingside_castling_rights(chess.BLACK))

self.assertTrue(board.has_kingside_castling_rights(chess.WHITE))

self.assertTrue(board.has_queenside_castling_rights(chess.BLACK))

self.assertFalse(board.has_queenside_castling_rights(chess.WHITE))

# Chess960 position #284.

board = chess.Board("rkbqrbnn/pppppppp/8/8/8/8/PPPPPPPP/RKBQRBNN w - - 0 1", chess960=True)

board.castling_rights = board.rooks

self.assertTrue(board.clean_castling_rights() & chess.BB_A1)

self.assertEqual(board.fen(), "rkbqrbnn/pppppppp/8/8/8/8/PPPPPPPP/RKBQRBNN w KQkq - 0 1")

self.assertEqual(board.shredder_fen(), "rkbqrbnn/pppppppp/8/8/8/8/PPPPPPPP/RKBQRBNN w EAea - 0 1")

# Valid en passant square on illegal board.

fen = "8/8/8/pP6/8/8/8/8 w - a6 0 1"

board = chess.Board(fen)

self.assertEqual(board.fen(), fen)

# Illegal en passant square in illegal board.

fen = "1r6/8/8/pP6/8/8/8/1K6 w - a6 0 1"

board = chess.Board(fen)

self.assertEqual(board.fen(), "1r6/8/8/pP6/8/8/8/1K6 w - - 0 1")

def test_get_set(self):

board = chess.Board()

self.assertEqual(board.piece_at(chess.B1), chess.Piece.from_symbol("N"))

board.remove_piece_at(chess.E2)

self.assertEqual(board.piece_at(chess.E2), None)

board.set_piece_at(chess.E4, chess.Piece.from_symbol("r"))

self.assertEqual(board.piece_type_at(chess.E4), chess.ROOK)

board.set_piece_at(chess.F1, None)

self.assertEqual(board.piece_at(chess.F1), None)

def test_pawn_captures(self):

board = chess.Board()

# Kings gambit.

board.push(chess.Move.from_uci("e2e4"))

board.push(chess.Move.from_uci("e7e5"))

board.push(chess.Move.from_uci("f2f4"))

# Accepted.

exf4 = chess.Move.from_uci("e5f4")

self.assertTrue(exf4 in board.pseudo_legal_moves)

self.assertTrue(exf4 in board.legal_moves)

board.push(exf4)

board.pop()

def test_pawn_move_generation(self):

board = chess.Board("8/2R1P3/8/2pp4/2k1r3/P7/8/1K6 w - - 1 55")

self.assertEqual(len(list(board.generate_pseudo_legal_moves())), 16)

def test_single_step_pawn_move(self):

board = chess.Board()

a3 = chess.Move.from_uci("a2a3")

self.assertTrue(a3 in board.pseudo_legal_moves)

self.assertTrue(a3 in board.legal_moves)

board.push(a3)

board.pop()

self.assertEqual(board.fen(), chess.STARTING_FEN)

def test_castling(self):

board = chess.Board("r3k2r/8/8/8/8/8/8/R3K2R w KQkq - 1 1")

# Let white castle short.

move = board.parse_san("O-O")

self.assertEqual(move, chess.Move.from_uci("e1g1"))

self.assertEqual(board.san(move), "O-O")

self.assertTrue(move in board.legal_moves)

board.push(move)

# Let black castle long.

move = board.parse_san("O-O-O")

self.assertEqual(board.san(move), "O-O-O")

self.assertTrue(move in board.legal_moves)

board.push(move)

self.assertEqual(board.fen(), "2kr3r/8/8/8/8/8/8/R4RK1 w - - 3 2")

# Undo both castling moves.

board.pop()

board.pop()

self.assertEqual(board.fen(), "r3k2r/8/8/8/8/8/8/R3K2R w KQkq - 1 1")

# Let white castle long.

move = board.parse_san("O-O-O")

self.assertEqual(board.san(move), "O-O-O")

self.assertTrue(move in board.legal_moves)

board.push(move)

# Let black castle short.

move = board.parse_san("O-O")

self.assertEqual(board.san(move), "O-O")

self.assertTrue(move in board.legal_moves)

board.push(move)

self.assertEqual(board.fen(), "r4rk1/8/8/8/8/8/8/2KR3R w - - 3 2")

# Undo both castling moves.

board.pop()

board.pop()

self.assertEqual(board.fen(), "r3k2r/8/8/8/8/8/8/R3K2R w KQkq - 1 1")

def test_ninesixty_castling(self):

fen = "3r1k1r/4pp2/8/8/8/8/8/4RKR1 w Gd - 1 1"

board = chess.Board(fen, chess960=True)

# Let white do the king side swap.

move = board.parse_san("O-O")

self.assertEqual(board.san(move), "O-O")

self.assertEqual(move.from_square, chess.F1)

self.assertEqual(move.to_square, chess.G1)

self.assertTrue(move in board.legal_moves)

board.push(move)

self.assertEqual(board.shredder_fen(), "3r1k1r/4pp2/8/8/8/8/8/4RRK1 b d - 2 1")

# Black can not castle kingside.

self.assertFalse(chess.Move.from_uci("e8h8") in board.legal_moves)

# Let black castle queenside.

move = board.parse_san("O-O-O")

self.assertEqual(board.san(move), "O-O-O")

self.assertEqual(move.from_square, chess.F8)

self.assertEqual(move.to_square, chess.D8)

self.assertTrue(move in board.legal_moves)

board.push(move)

self.assertEqual(board.shredder_fen(), "2kr3r/4pp2/8/8/8/8/8/4RRK1 w - - 3 2")

# Restore initial position.

board.pop()

board.pop()

self.assertEqual(board.shredder_fen(), fen)

fen = "Qr4k1/4pppp/8/8/8/8/8/R5KR w Hb - 0 1"

board = chess.Board(fen, True)

# White can just hop the rook over.

move = board.parse_san("O-O")

self.assertEqual(board.san(move), "O-O")

self.assertEqual(move.from_square, chess.G1)

self.assertEqual(move.to_square, chess.H1)

self.assertTrue(move in board.legal_moves)

board.push(move)

self.assertEqual(board.shredder_fen(), "Qr4k1/4pppp/8/8/8/8/8/R4RK1 b b - 1 1")

# Black can not castle queenside nor kingside.

self.assertFalse(any(board.generate_castling_moves()))

# Restore initial position.

board.pop()

self.assertEqual(board.shredder_fen(), fen)

def test_selective_castling(self):

board = chess.Board("r3k2r/pppppppp/8/8/8/8/PPPPPPPP/R3K2R w KQkq - 0 1")

# King not selected

self.assertFalse(any(board.generate_castling_moves(chess.BB_ALL & ~board.kings)))

# Rook on h1 not selected

moves = board.generate_castling_moves(chess.BB_ALL, chess.BB_ALL & ~chess.BB_H1)

self.assertEqual(len(list(moves)), 1)

def test_castling_right_not_destroyed_bug(self):

# A rook move from H8 to H1 was only taking whites possible castling

# rights away.

board = chess.Board("2r1k2r/2qbbpp1/p2pp3/1p3PP1/Pn2P3/1PN1B3/1P3QB1/1K1R3R b k - 0 22")

board.push_san("Rxh1")

self.assertEqual(board.epd(), "2r1k3/2qbbpp1/p2pp3/1p3PP1/Pn2P3/1PN1B3/1P3QB1/1K1R3r w - -")

def test_invalid_castling_rights(self):

# KQkq is not valid in this standard chess position.

board = chess.Board("1r2k3/8/8/8/8/8/8/R3KR2 w KQkq - 0 1")

self.assertEqual(board.status(), chess.STATUS_BAD_CASTLING_RIGHTS)

self.assertEqual(board.fen(), "1r2k3/8/8/8/8/8/8/R3KR2 w Q - 0 1")

self.assertTrue(board.has_queenside_castling_rights(chess.WHITE))

self.assertFalse(board.has_kingside_castling_rights(chess.WHITE))

self.assertFalse(board.has_queenside_castling_rights(chess.BLACK))

self.assertFalse(board.has_kingside_castling_rights(chess.BLACK))

board = chess.Board("4k2r/8/8/8/8/8/8/R1K5 w KQkq - 0 1", chess960=True)

self.assertEqual(board.status(), chess.STATUS_BAD_CASTLING_RIGHTS)

self.assertEqual(board.fen(), "4k2r/8/8/8/8/8/8/R1K5 w k - 0 1")

board = chess.Board("1r2k3/8/1p6/8/8/5P2/8/1R2KR2 w KQkq - 0 1", chess960=True)

self.assertEqual(board.status(), chess.STATUS_BAD_CASTLING_RIGHTS)

self.assertEqual(board.fen(), "1r2k3/8/1p6/8/8/5P2/8/1R2KR2 w KQq - 0 1")

def test_ninesixty_prevented_castle(self):

board = chess.Board("4k3/8/8/1b6/8/8/8/5RKR w KQ - 0 1", chess960=True)

self.assertFalse(board.is_legal(chess.Move.from_uci("g1f1")))

def test_insufficient_material(self):

# Starting position.

board = chess.Board()

self.assertFalse(board.is_insufficient_material())

# King vs. King + 2 bishops of the same color.

board = chess.Board("k1K1B1B1/8/8/8/8/8/8/8 w - - 7 32")

self.assertTrue(board.is_insufficient_material())

# Add bishop of opposite color for the weaker side.

board.set_piece_at(chess.B8, chess.Piece.from_symbol("b"))

self.assertFalse(board.is_insufficient_material())

def test_promotion_with_check(self):

board = chess.Board("8/6P1/2p5/1Pqk4/6P1/2P1RKP1/4P1P1/8 w - - 0 1")

board.push(chess.Move.from_uci("g7g8q"))

self.assertTrue(board.is_check())

self.assertEqual(board.fen(), "6Q1/8/2p5/1Pqk4/6P1/2P1RKP1/4P1P1/8 b - - 0 1")

board = chess.Board("8/8/8/3R1P2/8/2k2K2/3p4/r7 b - - 0 82")

board.push_san("d1=Q+")

self.assertEqual(board.fen(), "8/8/8/3R1P2/8/2k2K2/8/r2q4 w - - 0 83")

def test_scholars_mate(self):

board = chess.Board()

e4 = chess.Move.from_uci("e2e4")

self.assertTrue(e4 in board.legal_moves)

board.push(e4)

e5 = chess.Move.from_uci("e7e5")

self.assertTrue(e5 in board.legal_moves)

board.push(e5)

Qf3 = chess.Move.from_uci("d1f3")

self.assertTrue(Qf3 in board.legal_moves)

board.push(Qf3)

Nc6 = chess.Move.from_uci("b8c6")

self.assertTrue(Nc6 in board.legal_moves)

board.push(Nc6)

Bc4 = chess.Move.from_uci("f1c4")

self.assertTrue(Bc4 in board.legal_moves)

board.push(Bc4)

Rb8 = chess.Move.from_uci("a8b8")

self.assertTrue(Rb8 in board.legal_moves)

board.push(Rb8)

self.assertFalse(board.is_check())

self.assertFalse(board.is_checkmate())

self.assertFalse(board.is_game_over())

self.assertFalse(board.is_stalemate())

Qf7_mate = chess.Move.from_uci("f3f7")

self.assertTrue(Qf7_mate in board.legal_moves)

board.push(Qf7_mate)

self.assertTrue(board.is_check())

self.assertTrue(board.is_checkmate())

self.assertTrue(board.is_game_over())

self.assertTrue(board.is_game_over(claim_draw=True))

self.assertFalse(board.is_stalemate())

self.assertEqual(board.fen(), "1rbqkbnr/pppp1Qpp/2n5/4p3/2B1P3/8/PPPP1PPP/RNB1K1NR b KQk - 0 4")

def test_result(self):

# Undetermined.

board = chess.Board()

self.assertEqual(board.result(claim_draw=True), "*")

# White checkmated.

board = chess.Board("rnb1kbnr/pppp1ppp/8/4p3/6Pq/5P2/PPPPP2P/RNBQKBNR w KQkq - 1 3")

self.assertEqual(board.result(claim_draw=True), "0-1")

# Stalemate.

board = chess.Board("7K/7P/7k/8/6q1/8/8/8 w - - 0 1")

self.assertEqual(board.result(), "1/2-1/2")

# Insufficient material.

board = chess.Board("4k3/8/8/8/8/5B2/8/4K3 w - - 0 1")

self.assertEqual(board.result(), "1/2-1/2")

# Fiftyseven-move rule.

board = chess.Board("4k3/8/6r1/8/8/8/2R5/4K3 w - - 369 1")

self.assertEqual(board.result(), "1/2-1/2")

# Fifty-move rule.

board = chess.Board("4k3/8/6r1/8/8/8/2R5/4K3 w - - 120 1")

self.assertEqual(board.result(), "*")

self.assertEqual(board.result(claim_draw=True), "1/2-1/2")

def test_san(self):

# Castling with check.

fen = "rnbk1b1r/ppp2pp1/5n1p/4p1B1/2P5/2N5/PP2PPPP/R3KBNR w KQ - 0 7"

board = chess.Board(fen)

long_castle_check = chess.Move.from_uci("e1a1")

self.assertEqual(board.san(long_castle_check), "O-O-O+")

self.assertEqual(board.fen(), fen)

# En passant mate.

fen = "6bk/7b/8/3pP3/8/8/8/Q3K3 w - d6 0 2"

board = chess.Board(fen)

fxe6_mate_ep = chess.Move.from_uci("e5d6")

self.assertEqual(board.san(fxe6_mate_ep), "exd6#")

self.assertEqual(board.fen(), fen)

# Test ambiguation.

fen = "N3k2N/8/8/3N4/N4N1N/2R5/1R6/4K3 w - - 0 1"

board = chess.Board(fen)

self.assertEqual(board.san(chess.Move.from_uci("e1f1")), "Kf1")

self.assertEqual(board.san(chess.Move.from_uci("c3c2")), "Rcc2")

self.assertEqual(board.san(chess.Move.from_uci("b2c2")), "Rbc2")

self.assertEqual(board.san(chess.Move.from_uci("a4b6")), "N4b6")

self.assertEqual(board.san(chess.Move.from_uci("h8g6")), "N8g6")

self.assertEqual(board.san(chess.Move.from_uci("h4g6")), "Nh4g6")

self.assertEqual(board.fen(), fen)

# Do not disambiguate illegal alternatives.

fen = "8/8/8/R2nkn2/8/8/2K5/8 b - - 0 1"

board = chess.Board(fen)

self.assertEqual(board.san(chess.Move.from_uci("f5e3")), "Ne3+")

self.assertEqual(board.fen(), fen)

# Promotion.

fen = "7k/1p2Npbp/8/2P5/1P1r4/3b2QP/3q1pPK/2RB4 b - - 1 29"

board = chess.Board(fen)

self.assertEqual(board.san(chess.Move.from_uci("f2f1q")), "f1=Q")

self.assertEqual(board.san(chess.Move.from_uci("f2f1n")), "f1=N+")

self.assertEqual(board.fen(), fen)

def test_variations(self):

board = chess.Board()

self.assertEqual('1. e4 e5 2. Nf3',

board.variation_san([chess.Move.from_uci(m) for m in

['e2e4', 'e7e5', 'g1f3']]))

self.assertEqual('1. e4 e5 2. Nf3 Nc6 3. Bb5 a6',

board.variation_san([chess.Move.from_uci(m) for m in

['e2e4', 'e7e5', 'g1f3', 'b8c6', 'f1b5', 'a7a6']]))

fen = "rn1qr1k1/1p2bppp/p3p3/3pP3/P2P1B2/2RB1Q1P/1P3PP1/R5K1 w - - 0 19"

board = chess.Board(fen)

variation = ['d3h7', 'g8h7', 'f3h5', 'h7g8', 'c3g3', 'e7f8', 'f4g5',

'e8e7', 'g5f6', 'b8d7', 'h5h6', 'd7f6', 'e5f6', 'g7g6',

'f6e7', 'f8e7']

var_w = board.variation_san([chess.Move.from_uci(m) for m in variation])

self.assertEqual(("19. Bxh7+ Kxh7 20. Qh5+ Kg8 21. Rg3 Bf8 22. Bg5 Re7 "

"23. Bf6 Nd7 24. Qh6 Nxf6 25. exf6 g6 26. fxe7 Bxe7"),

var_w)

self.assertEqual(fen, board.fen(), msg="Board unchanged by variation_san")

board.push(chess.Move.from_uci(variation.pop(0)))

var_b = board.variation_san([chess.Move.from_uci(m) for m in variation])

self.assertEqual(("19...Kxh7 20. Qh5+ Kg8 21. Rg3 Bf8 22. Bg5 Re7 "

"23. Bf6 Nd7 24. Qh6 Nxf6 25. exf6 g6 26. fxe7 Bxe7"),

var_b)

illegal_variation = ['d3h7', 'g8h7', 'f3h6', 'h7g8']

board = chess.Board(fen)

with self.assertRaises(ValueError) as err:

board.variation_san([chess.Move.from_uci(m) for m in illegal_variation])

message = str(err.exception)

self.assertTrue('illegal move' in message.lower(),

msg="Error [{0}] mentions illegal move".format(message))

self.assertTrue('f3h6' in message,

msg="Illegal move f3h6 appears in message [{0}]".format(message))

def test_is_legal_move(self):

fen = "3k4/6P1/7P/8/K7/8/8/4R3 w - - 0 1"

board = chess.Board(fen)

# Legal moves: Rg1, g8=R+.

self.assertTrue(chess.Move.from_uci("e1g1") in board.legal_moves)

self.assertTrue(chess.Move.from_uci("g7g8r") in board.legal_moves)

# Impossible promotion: Kb5, h7.

self.assertFalse(chess.Move.from_uci("a5b5q") in board.legal_moves)

self.assertFalse(chess.Move.from_uci("h6h7n") in board.legal_moves)

# Missing promotion.

self.assertFalse(chess.Move.from_uci("g7g8") in board.legal_moves)

self.assertEqual(board.fen(), fen)

def test_move_count(self):

board = chess.Board("1N2k3/P7/8/8/3n4/8/2PP4/R3K2R w KQ - 0 1")

self.assertEqual(len(board.pseudo_legal_moves), 8 + 4 + 3 + 2 + 1 + 6 + 9)

def test_polyglot(self):

# Test polyglot compability using test data from

# http://hardy.uhasselt.be/Toga/book_format.html. Forfeiting castling

# rights should not reset the half move counter, though.

board = chess.Board()

self.assertEqual(board.fen(), "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1")

self.assertEqual(board.zobrist_hash(), 0x463b96181691fc9c)

board.push_san("e4")

self.assertEqual(board.fen(), "rnbqkbnr/pppppppp/8/8/4P3/8/PPPP1PPP/RNBQKBNR b KQkq - 0 1")

self.assertEqual(board.zobrist_hash(), 0x823c9b50fd114196)

board.push_san("d5")

self.assertEqual(board.fen(), "rnbqkbnr/ppp1pppp/8/3p4/4P3/8/PPPP1PPP/RNBQKBNR w KQkq - 0 2")

self.assertEqual(board.zobrist_hash(), 0x0756b94461c50fb0)

board.push_san("e5")

self.assertEqual(board.fen(), "rnbqkbnr/ppp1pppp/8/3pP3/8/8/PPPP1PPP/RNBQKBNR b KQkq - 0 2")

self.assertEqual(board.zobrist_hash(), 0x662fafb965db29d4)

board.push_san("f5")

self.assertEqual(board.fen(), "rnbqkbnr/ppp1p1pp/8/3pPp2/8/8/PPPP1PPP/RNBQKBNR w KQkq f6 0 3")

self.assertEqual(board.zobrist_hash(), 0x22a48b5a8e47ff78)

board.push_san("Ke2")

self.assertEqual(board.fen(), "rnbqkbnr/ppp1p1pp/8/3pPp2/8/8/PPPPKPPP/RNBQ1BNR b kq - 1 3")

self.assertEqual(board.zobrist_hash(), 0x652a607ca3f242c1)

board.push_san("Kf7")

self.assertEqual(board.fen(), "rnbq1bnr/ppp1pkpp/8/3pPp2/8/8/PPPPKPPP/RNBQ1BNR w - - 2 4")

self.assertEqual(board.zobrist_hash(), 0x00fdd303c946bdd9)

board = chess.Board()

board.push_san("a4")

board.push_san("b5")

board.push_san("h4")

board.push_san("b4")

board.push_san("c4")

self.assertEqual(board.fen(), "rnbqkbnr/p1pppppp/8/8/PpP4P/8/1P1PPPP1/RNBQKBNR b KQkq c3 0 3")

self.assertEqual(board.zobrist_hash(), 0x3c8123ea7b067637)

board.push_san("bxc3")

board.push_san("Ra3")

self.assertEqual(board.fen(), "rnbqkbnr/p1pppppp/8/8/P6P/R1p5/1P1PPPP1/1NBQKBNR b Kkq - 1 4")

self.assertEqual(board.zobrist_hash(), 0x5c3f9b829b279560)

def test_castling_move_generation_bug(self):

# Specific test position right after castling.

fen = "rnbqkbnr/2pp1ppp/8/4p3/2BPP3/P1N2N2/PB3PPP/2RQ1RK1 b kq - 1 10"

board = chess.Board(fen)

illegal_move = chess.Move.from_uci("g1g2")

self.assertFalse(illegal_move in board.legal_moves)

self.assertFalse(illegal_move in list(board.legal_moves))

self.assertFalse(illegal_move in board.pseudo_legal_moves)

self.assertFalse(illegal_move in list(board.pseudo_legal_moves))

# Make a move.

board.push_san("exd4")

# Already castled short, can not castle long.

illegal_move = chess.Move.from_uci("e1c1")

self.assertFalse(illegal_move in board.pseudo_legal_moves)

self.assertFalse(illegal_move in board.generate_pseudo_legal_moves())

self.assertFalse(illegal_move in board.legal_moves)

self.assertFalse(illegal_move in list(board.legal_moves))

# Unmake the move.

board.pop()

# Generate all pseudo legal moves, two moves deep.

for move in board.pseudo_legal_moves:

board.push(move)

for move in board.pseudo_legal_moves:

board.push(move)

board.pop()

board.pop()

# Check that board is still consistent.

self.assertEqual(board.fen(), fen)

self.assertTrue(board.kings & chess.BB_G1)

self.assertTrue(board.occupied & chess.BB_G1)

self.assertTrue(board.occupied_co[chess.WHITE] & chess.BB_G1)

self.assertEqual(board.piece_at(chess.G1), chess.Piece(chess.KING, chess.WHITE))

self.assertEqual(board.piece_at(chess.C1), chess.Piece(chess.ROOK, chess.WHITE))

def test_move_generation_bug(self):

# Specific problematic position.

fen = "4kb1r/3b1ppp/8/1r2pNB1/6P1/pP2QP2/P6P/4R1K1 w k - 0 27"

board = chess.Board(fen)

# Make a move.

board.push_san("Re2")

# Check for the illegal move.

illegal_move = chess.Move.from_uci("e8f8")

self.assertFalse(illegal_move in board.pseudo_legal_moves)

self.assertFalse(illegal_move in board.generate_pseudo_legal_moves())

self.assertFalse(illegal_move in board.legal_moves)

self.assertFalse(illegal_move in board.generate_legal_moves())

# Generate all pseudo legal moves.

for a in board.pseudo_legal_moves:

board.push(a)

board.pop()

# Unmake the move.

board.pop()

# Check that board is still consistent.

self.assertEqual(board.fen(), fen)

def test_stateful_move_generation_bug(self):

board = chess.Board("r1b1k3/p2p1Nr1/n2b3p/3pp1pP/2BB1p2/P3P2R/Q1P3P1/R3K1N1 b Qq - 0 1")

count = 0

for move in board.legal_moves:

board.push(move)

list(board.generate_legal_moves())

count += 1

board.pop()

self.assertEqual(count, 26)

def test_ninesixty_castling_bug(self):

board = chess.Board("4r3/3k4/8/8/8/8/q5PP/1R1KR3 w Q - 2 2", chess960=True)

move = chess.Move.from_uci("d1b1")

self.assertTrue(board.is_castling(move))

self.assertTrue(move in board.generate_pseudo_legal_moves())

self.assertTrue(board.is_pseudo_legal(move))

self.assertTrue(move in board.generate_legal_moves())

self.assertTrue(board.is_legal(move))

self.assertEqual(board.parse_san("O-O-O+"), move)

self.assertEqual(board.san(move), "O-O-O+")

def test_equality(self):

self.assertEqual(chess.Board(), chess.Board())

self.assertFalse(chess.Board() != chess.Board())

a = chess.Board()

a.push_san("d4")

b = chess.Board()

b.push_san("d3")

self.assertNotEqual(a, b)

self.assertFalse(a == b)

def test_status(self):

board = chess.Board()

self.assertEqual(board.status(), chess.STATUS_VALID)

self.assertTrue(board.is_valid())

board.remove_piece_at(chess.H1)

self.assertTrue(board.status() & chess.STATUS_BAD_CASTLING_RIGHTS)

board.remove_piece_at(chess.E8)

self.assertTrue(board.status() & chess.STATUS_NO_BLACK_KING)

# The en passant square should be set even if no capture is actually

# possible.

board = chess.Board()

board.push_san("e4")

self.assertEqual(board.ep_square, chess.E3)

self.assertEqual(board.status(), chess.STATUS_VALID)

# But there must indeed be a pawn there.

board.remove_piece_at(chess.E4)

self.assertEqual(board.status(), chess.STATUS_INVALID_EP_SQUARE)

# King must be between the two rooks.

board = chess.Board("2rrk3/8/8/8/8/8/3PPPPP/2RK4 w cd - 0 1")

self.assertEqual(board.status(), chess.STATUS_BAD_CASTLING_RIGHTS)

# Generally valid position, but not valid standard chess position due

# to non-standard castling rights. Chess960 start position #0.

board = chess.Board("bbqnnrkr/pppppppp/8/8/8/8/PPPPPPPP/BBQNNRKR w KQkq - 0 1", chess960=True)

self.assertEqual(board.status(), chess.STATUS_VALID)

board = chess.Board("bbqnnrkr/pppppppp/8/8/8/8/PPPPPPPP/BBQNNRKR w KQkq - 0 1", chess960=False)

self.assertEqual(board.status(), chess.STATUS_BAD_CASTLING_RIGHTS)

def test_epd(self):

# Create an EPD with a move and a string.

board = chess.Board("1k1r4/pp1b1R2/3q2pp/4p3/2B5/4Q3/PPP2B2/2K5 b - - 0 1")

epd = board.epd(bm=chess.Move(chess.D6, chess.D1), id="BK.01")

self.assertTrue(epd in (

"1k1r4/pp1b1R2/3q2pp/4p3/2B5/4Q3/PPP2B2/2K5 b - - bm Qd1+; id \"BK.01\";",

"1k1r4/pp1b1R2/3q2pp/4p3/2B5/4Q3/PPP2B2/2K5 b - - id \"BK.01\"; bm Qd1+;"))

# Create an EPD with a noop.

board = chess.Board("4k3/8/8/8/8/8/8/4K3 w - - 0 1")

self.assertEqual(board.epd(noop=None), "4k3/8/8/8/8/8/8/4K3 w - - noop;")

# Create an EPD with a variation.

board = chess.Board("k7/8/8/8/8/8/4PPPP/4K1NR w K - 0 1")

epd = board.epd(pv=[

chess.Move.from_uci("g1f3"), # Nf3

chess.Move.from_uci("a8a7"), # Ka7

chess.Move.from_uci("e1h1"), # O-O

])

self.assertEqual(epd, "k7/8/8/8/8/8/4PPPP/4K1NR w K - pv Nf3 Ka7 O-O;")

# Create an EPD with a set of moves.

board = chess.Board("8/8/8/4k3/8/1K6/8/8 b - - 0 1")

epd = board.epd(bm=[

chess.Move.from_uci("e5e6"), # Ke6

chess.Move.from_uci("e5e4"), # Ke4

])

self.assertEqual(epd, "8/8/8/4k3/8/1K6/8/8 b - - bm Ke6 Ke4;")

# Test loading an EPD.

board = chess.Board()

operations = board.set_epd("r2qnrnk/p2b2b1/1p1p2pp/2pPpp2/1PP1P3/PRNBB3/3QNPPP/5RK1 w - - bm f4; id \"BK.24\";")

self.assertEqual(board.fen(), "r2qnrnk/p2b2b1/1p1p2pp/2pPpp2/1PP1P3/PRNBB3/3QNPPP/5RK1 w - - 0 1")

self.assertTrue(chess.Move(chess.F2, chess.F4) in operations["bm"])

self.assertEqual(operations["id"], "BK.24")

# Test loading an EPD with half counter operations.

board = chess.Board()

operations = board.set_epd("4k3/8/8/8/8/8/8/4K3 b - - fmvn 17; hmvc 13")

self.assertEqual(board.fen(), "4k3/8/8/8/8/8/8/4K3 b - - 13 17")

self.assertEqual(operations["fmvn"], 17)

self.assertEqual(operations["hmvc"], 13)

# Test context of parsed SANs.

board = chess.Board()

operations = board.set_epd("4k3/8/8/2N5/8/8/8/4K3 w - - test Ne4")

self.assertEqual(operations["test"], chess.Move(chess.C5, chess.E4))

# Test parsing EPD with a set of moves.

board = chess.Board()

operations = board.set_epd("4k3/8/3QK3/8/8/8/8/8 w - - bm Qe7# Qb8#;")

self.assertEqual(board.fen(), "4k3/8/3QK3/8/8/8/8/8 w - - 0 1")

self.assertEqual(len(operations["bm"]), 2)

self.assertTrue(chess.Move.from_uci("d6b8") in operations["bm"])

self.assertTrue(chess.Move.from_uci("d6e7") in operations["bm"])

# Test parsing EPD with a stack of moves.

board = chess.Board()

operations = board.set_epd("6k1/1p6/6K1/8/8/8/8/7Q w - - pv Qh7+ Kf8 Qf7#;")

self.assertEqual(len(operations["pv"]), 3)

self.assertEqual(operations["pv"][0], chess.Move.from_uci("h1h7"))

self.assertEqual(operations["pv"][1], chess.Move.from_uci("g8f8"))

self.assertEqual(operations["pv"][2], chess.Move.from_uci("h7f7"))

def test_null_moves(self):

self.assertEqual(str(chess.Move.null()), "0000")

self.assertEqual(chess.Move.null().uci(), "0000")

self.assertFalse(chess.Move.null())

fen = "rnbqkbnr/ppp1pppp/8/2Pp4/8/8/PP1PPPPP/RNBQKBNR w KQkq d6 0 2"

board = chess.Board(fen)

self.assertEqual(chess.Move.from_uci("0000"), board.push_san("--"))

self.assertEqual(board.fen(), "rnbqkbnr/ppp1pppp/8/2Pp4/8/8/PP1PPPPP/RNBQKBNR b KQkq - 1 2")

self.assertEqual(chess.Move.null(), board.pop())

self.assertEqual(board.fen(), fen)

def test_attackers(self):

board = chess.Board("r1b1k2r/pp1n1ppp/2p1p3/q5B1/1b1P4/P1n1PN2/1P1Q1PPP/2R1KB1R b Kkq - 3 10")

attackers = board.attackers(chess.WHITE, chess.C3)

self.assertEqual(len(attackers), 3)

self.assertTrue(chess.C1 in attackers)

self.assertTrue(chess.D2 in attackers)

self.assertTrue(chess.B2 in attackers)

self.assertFalse(chess.D4 in attackers)

self.assertFalse(chess.E1 in attackers)

def test_en_passant_attackers(self):

board = chess.Board("4k3/8/8/8/4pPp1/8/8/4K3 b - f3 0 1")

# Attacking the en passant square.

attackers = board.attackers(chess.BLACK, chess.F3)

self.assertEqual(len(attackers), 2)

self.assertTrue(chess.E4 in attackers)

self.assertTrue(chess.G4 in attackers)

# Not attacking the pawn directly.

attackers = board.attackers(chess.BLACK, chess.F4)

self.assertEqual(attackers, chess.BB_VOID)

def test_attacks(self):

board = chess.Board("5rk1/p5pp/2p3p1/1p1pR3/3P2P1/2N5/PP3n2/2KB4 w - - 1 26")

attacks = board.attacks(chess.E5)

self.assertEqual(len(attacks), 11)

self.assertTrue(chess.D5 in attacks)

self.assertTrue(chess.E1 in attacks)

self.assertTrue(chess.F5 in attacks)

self.assertFalse(chess.E5 in attacks)

self.assertFalse(chess.C5 in attacks)

self.assertFalse(chess.F4 in attacks)

self.assertFalse(board.attacks(chess.G1))

def test_clear(self):

board = chess.Board()

board.clear()

self.assertEqual(board.turn, chess.WHITE)

self.assertEqual(board.fullmove_number, 1)

self.assertEqual(board.halfmove_clock, 0)

self.assertEqual(board.castling_rights, chess.BB_VOID)

self.assertFalse(board.ep_square)

self.assertFalse(board.piece_at(chess.E1))

self.assertEqual(chess.pop_count(board.occupied), 0)

def test_threefold_repetition(self):

board = chess.Board()

# Go back and forth with the nights to reach the starting position

# for a second time.

self.assertFalse(board.can_claim_threefold_repetition())

board.push_san("Nf3")

self.assertFalse(board.can_claim_threefold_repetition())

board.push_san("Nf6")

self.assertFalse(board.can_claim_threefold_repetition())

board.push_san("Ng1")

self.assertFalse(board.can_claim_threefold_repetition())

board.push_san("Ng8")

# Once more.

self.assertFalse(board.can_claim_threefold_repetition())

board.push_san("Nf3")

self.assertFalse(board.can_claim_threefold_repetition())

board.push_san("Nf6")

self.assertFalse(board.can_claim_threefold_repetition())

board.push_san("Ng1")

# Now black can go back to the starting position (thus reaching it a

# third time.)

self.assertTrue(board.can_claim_threefold_repetition())

board.push_san("Ng8")

# They indee do it. Also white can now claim.

self.assertTrue(board.can_claim_threefold_repetition())

# But not after a different move.

board.push_san("e4")

self.assertFalse(board.can_claim_threefold_repetition())

# Undo moves and check if everything works backwards.

board.pop() # e4

self.assertTrue(board.can_claim_threefold_repetition())

board.pop() # Ng8

self.assertTrue(board.can_claim_threefold_repetition())

while board.move_stack:

board.pop()

self.assertFalse(board.can_claim_threefold_repetition())

def test_fivefold_repetition(self):

fen = "rnbq1rk1/ppp3pp/3bpn2/3p1p2/2PP4/2NBPN2/PP3PPP/R1BQK2R w KQ - 3 7"

board = chess.Board(fen)

# Repeat the position up to the fourth time.

for i in range(3):

board.push_san("Be2")

self.assertFalse(board.is_fivefold_repetition())

board.push_san("Ne4")

self.assertFalse(board.is_fivefold_repetition())

board.push_san("Bd3")

self.assertFalse(board.is_fivefold_repetition())

board.push_san("Nf6")

self.assertEqual(board.fen().split()[0], fen.split()[0])

self.assertFalse(board.is_fivefold_repetition())

self.assertFalse(board.is_game_over())

# Repeat it once more. Now it is a five-fold repetition.

board.push_san("Be2")

self.assertFalse(board.is_fivefold_repetition())

board.push_san("Ne4")

self.assertFalse(board.is_fivefold_repetition())

board.push_san("Bd3")

self.assertFalse(board.is_fivefold_repetition())

board.push_san("Nf6")

self.assertEqual(board.fen().split()[0], fen.split()[0])

self.assertTrue(board.is_fivefold_repetition())

self.assertTrue(board.is_game_over())

# It is also a threefold repetition.

self.assertTrue(board.can_claim_threefold_repetition())

# Now no longer.

board.push_san("Qc2")

board.push_san("Qd7")

self.assertFalse(board.can_claim_threefold_repetition())

self.assertFalse(board.is_fivefold_repetition())

board.push_san("Qd2")

board.push_san("Qe7")

self.assertFalse(board.can_claim_threefold_repetition())

self.assertFalse(board.is_fivefold_repetition())

# Give the possibility to repeat.

board.push_san("Qd1")

self.assertFalse(board.is_fivefold_repetition())

self.assertFalse(board.is_game_over())

self.assertTrue(board.can_claim_threefold_repetition())

self.assertTrue(board.is_game_over(claim_draw=True))

# Do in fact repeat.

self.assertFalse(board.is_fivefold_repetition())

board.push_san("Qd8")

# This is a threefold repetition but not a fivefold repetition, because

# consecutive moves are required for that.

self.assertTrue(board.can_claim_threefold_repetition())

self.assertFalse(board.is_fivefold_repetition())

self.assertEqual(board.fen().split()[0], fen.split()[0])

def test_fifty_moves(self):

# Test positions from Timman - Lutz (1995).

board = chess.Board()

self.assertFalse(board.can_claim_fifty_moves())

board = chess.Board("8/5R2/8/r2KB3/6k1/8/8/8 w - - 19 79")

self.assertFalse(board.can_claim_fifty_moves())

board = chess.Board("8/8/6r1/4B3/8/4K2k/5R2/8 b - - 68 103")

self.assertFalse(board.can_claim_fifty_moves())

board = chess.Board("6R1/7k/8/8/1r3B2/5K2/8/8 w - - 99 119")

self.assertFalse(board.can_claim_fifty_moves())

board = chess.Board("8/7k/8/6R1/1r3B2/5K2/8/8 b - - 100 119")

self.assertTrue(board.can_claim_fifty_moves())

board = chess.Board("8/7k/8/1r3KR1/5B2/8/8/8 w - - 105 122")

self.assertTrue(board.can_claim_fifty_moves())

# Once checkmated it is too late to claim.

board = chess.Board("k7/8/NKB5/8/8/8/8/8 b - - 105 176")

self.assertFalse(board.can_claim_fifty_moves())

# A stalemate is a draw, but you can not and do not need to claim it by

# the fifty move rule.

board = chess.Board("k7/3N4/1K6/1B6/8/8/8/8 b - - 99 1")

self.assertTrue(board.is_stalemate())

self.assertTrue(board.is_game_over())

self.assertFalse(board.can_claim_fifty_moves())

self.assertFalse(board.can_claim_draw())

def test_ep_legality(self):

move = chess.Move.from_uci("h5g6")

board = chess.Board("rnbqkbnr/pppppp2/7p/6pP/8/8/PPPPPPP1/RNBQKBNR w KQkq g6 0 3")

self.assertTrue(board.is_legal(move))

board.push_san("Nf3")

self.assertFalse(board.is_legal(move))

board.push_san("Nf6")

self.assertFalse(board.is_legal(move))

move = chess.Move.from_uci("c4d3")

board = chess.Board("rnbqkbnr/pp1ppppp/8/8/2pP4/2P2N2/PP2PPPP/RNBQKB1R b KQkq d3 0 3")

self.assertTrue(board.is_legal(move))