class TestPawn(unittest.TestCase):
def setUp(self):
self.coords = Coordinates('d', 4)
self.pawn = Pawn(self.coords, 'white')
def test_pawn_initialization(self):
self.assertEqual(self.pawn.coordinates, self.coords)
def test_pawn_position(self):
self.assertTupleEqual((3, 3), self.pawn.position)
def test_pawn_resource_name(self):
self.assertEqual('white_pawn.png', self.pawn.resource_name)
def test_pawn_can_move_ahead(self):
new_coord = Coordinates('d', 5)
self.assertTrue(self.pawn.can_move_to(new_coord))
def test_pawn_cant_move_behind(self):
new_coord = Coordinates('d', 3)
self.assertFalse(self.pawn.can_move_to(new_coord))
def test_cant_move_more_than_one_tile(self):
new_coord = Coordinates('d', 8)
self.assertFalse(self.pawn.can_move_to(new_coord))
def test_pawn_cant_move_at_the_sides(self):
new_coord = Coordinates('c', 4)
self.assertFalse(self.pawn.can_move_to(new_coord))
new_coord = Coordinates('e', 4)
self.assertFalse(self.pawn.can_move_to(new_coord))
def _place_pieces(self):
self.tiles[0][0].piece = Rook(Color.BLACK)
self.tiles[0][1].piece = Knight(Color.BLACK)
self.tiles[0][2].piece = Bishop(Color.BLACK)
self.tiles[0][3].piece = Queen(Color.BLACK)
self.tiles[0][4].piece = King(Color.BLACK)
self.tiles[0][5].piece = Bishop(Color.BLACK)
self.tiles[0][6].piece = Knight(Color.BLACK)
self.tiles[0][7].piece = Rook(Color.BLACK)
for i in range(self.width):
self.tiles[1][i].piece = Pawn(Color.BLACK)
self.tiles[6][i].piece = Pawn(Color.WHITE)
self.tiles[7][0].piece = Rook(Color.WHITE)
self.tiles[7][1].piece = Knight(Color.WHITE)
self.tiles[7][2].piece = Bishop(Color.WHITE)
self.tiles[7][3].piece = Queen(Color.WHITE)
self.tiles[7][4].piece = King(Color.WHITE)
self.tiles[7][5].piece = Bishop(Color.WHITE)
self.tiles[7][6].piece = Knight(Color.WHITE)
self.tiles[7][7].piece = Rook(Color.WHITE)
def reset_board(self):
boxes = self.__boxes
# initialize white pieces
boxes[0][0] = Box(Rook(True), 0, 0);
boxes[0][1] = Box(Knight(True), 0, 1);
boxes[0][2] = Box(Bishop(True), 0, 2);
#...
boxes[1][0] = Box(Pawn(True), 1, 0);
boxes[1][1] = Box(Pawn(True), 1, 1);
#...
# initialize black pieces
boxes[7][0] = Box(Rook(False), 7, 0);
boxes[7][1] = Box(Knight(False), 7, 1);
boxes[7][2] = Box(Bishop(False), 7, 2);
#...
boxes[6][0] = Box(Pawn(False), 6, 0);
boxes[6][1] = Box(Pawn(False), 6, 1);
# ...
# initialize remaining boxes without any piece
for i in range(2, 6):
for j in range(0, 8):
boxes[i][j] = Box(i, j, None)
def test_is_at_starting_rank_correctness(self):
with self.subTest('white'):
wp = Pawn(Color.WHITE)
for file in File:
self.assertTrue(wp.is_at_starting_pos(Position(Rank.TWO,
file)))
self.assertFalse(
wp.is_at_starting_pos(Position(Rank.SEVEN, File.G)))
with self.subTest('black'):
bp = Pawn(Color.BLACK)
for file in File:
self.assertTrue(
bp.is_at_starting_pos(Position(Rank.SEVEN, file)))
self.assertFalse(bp.is_at_starting_pos(Position(Rank.TWO, File.G)))
from chess.pieces.queen import Queen
from chess.pieces.king import King
from chess.position import Position
from chess.team import Team
from chess.check import *
chessBoard_init = [
[
Rook(Position(0, 0), Team.BLACK), Knight(Position(1, 0), Team.BLACK), Bishop(Position(2, 0), Team.BLACK), Queen(Position(3, 0), Team.BLACK), King(Position(4, 0), Team.BLACK), Bishop(Position(5, 0), Team.BLACK), Knight(Position(6, 0), Team.BLACK), Rook(Position(7, 0), Team.BLACK)
],
[
Pawn(Position(x, 1), Team.BLACK) for x in range(8)
],
[None for _ in range(8)],
[None for _ in range(8)],
[None for _ in range(8)],
[None for _ in range(8)],
[
Pawn(Position(x, 6), Team.WHITE) for x in range(8)
],
[
Rook(Position(0, 7), Team.WHITE), Knight(Position(1, 7), Team.WHITE), Bishop(Position(2, 7), Team.WHITE), Queen(Position(3, 7), Team.WHITE), King(Position(4, 7), Team.WHITE), Bishop(Position(5, 7), Team.WHITE), Knight(Position(6, 7), Team.WHITE), Rook(Position(7, 7), Team.WHITE)
],
]
checkBoard_init = fillCheckBoard(chessBoard_init, Team.WHITE)[0]
def setUp(self):
self.coords = Coordinates('d', 4)
self.pawn = Pawn(self.coords, 'white')
def test_it_can_be_instantiated(self):
pawn = Pawn(Color.BLACK)
self.assertIsInstance(pawn, Pawn)
def test_it_has_the_proper_strong_representation_for_its_color(self):
b_pawn = Pawn(Color.BLACK)
self.assertEqual(str(b_pawn), '\u265F')
w_pawn = Pawn(Color.WHITE)
self.assertEqual(str(w_pawn), '\u2659')
def test_it_can_validate_moves(self):
b_pawn = Pawn(Color.BLACK)
self.assertTrue(b_pawn.is_valid_move('b7', 'b6'))
self.assertTrue(b_pawn.is_valid_move('b7', 'b5'))
self.assertTrue(b_pawn.is_valid_move('a7', 'a5'))
self.assertFalse(b_pawn.is_valid_move('b7', 'b4'))
self.assertFalse(b_pawn.is_valid_move('b6', 'b4'))
self.assertFalse(b_pawn.is_valid_move('b7', 'b1'))
self.assertFalse(b_pawn.is_valid_move('a7', 'b1'))
self.assertFalse(b_pawn.is_valid_move('b7', 'a8'))
self.assertFalse(b_pawn.is_valid_move('b7', 'b8'))
self.assertFalse(b_pawn.is_valid_move('b7', 'c8'))
self.assertFalse(b_pawn.is_valid_move('b7', 'c7'))
w_pawn = Pawn(Color.WHITE)
self.assertTrue(w_pawn.is_valid_move('b2', 'b3'))
self.assertTrue(w_pawn.is_valid_move('b2', 'b4'))
self.assertTrue(w_pawn.is_valid_move('a2', 'a4'))
self.assertFalse(w_pawn.is_valid_move('b2', 'b5'))
self.assertFalse(w_pawn.is_valid_move('b2', 'b1'))
self.assertFalse(w_pawn.is_valid_move('c2', 'b1'))
self.assertFalse(w_pawn.is_valid_move('a2', 'b1'))
self.assertFalse(w_pawn.is_valid_move('a3', 'b1'))
self.assertFalse(w_pawn.is_valid_move('c3', 'b1'))
self.assertFalse(w_pawn.is_valid_move('c1', 'b1'))
self.assertFalse(w_pawn.is_valid_move('a1', 'b1'))
def test_is_white_correctness(self):
with self.subTest('white'):
self.assertTrue(Pawn(Color.WHITE).is_white)
with self.subTest('black'):
self.assertFalse(Pawn(Color.BLACK).is_white)