Esempio n. 1
0
	def test_crowning_perform_undo(self):
		'''Test performing a crowning move and then undoing it'''
		#init:
		board = Board(10, 10)
		pawn = Pawn(board.white)

		i, j = 0, 1
		board[i, j].piece = pawn
		src_type = str(pawn).split(" ")[0].replace("<", "")

		move = filter(lambda x: x.type == "Crowning", pawn.get_moves((i, j), board))[0]

		#Preconditions:
		self.assertTrue(not board[i, j-1].piece)
		self.assertTrue(board[i, j].piece)

		move.perform(board)

		self.assertTrue(board[i, j-1].piece)
		self.assertTrue(not board[i, j].piece)
		self.assertTrue(move.performed)

		#compare piece types (should differ if crowning succeeded):
		dst_type = str(board[i, j-1].piece).split(" ")[0].replace("<","")
		self.assertTrue(src_type != dst_type)

		#undo move:
		move.undo(board)
		self.assertTrue(not board[i, j-1].piece)
		self.assertTrue(board[i, j].piece)
		self.assertTrue(not move.performed)

		#compare piece types (should be both pawns):
		dst_type = str(board[i, j].piece).split(" ")[0].replace("<","")
		self.assertTrue(src_type == dst_type)
Esempio n. 2
0
	def test_move_perform_undo(self):
		'''Test performing a move and then undoing it.'''
		#set up:
		board = Board(10, 10)

		pawn = Pawn(board.white)
		i, j = 0, 6
		board[i, j].piece = pawn

		move = pawn.get_moves((i, j), board)[0]

		#initial conditions:
		self.assertTrue(not board[i, j-1].piece)
		self.assertTrue(board[i, j].piece)

		#test performing the move:
		move.perform(board)
		self.assertTrue(board[i, j-1].piece)
		self.assertTrue(not board[i, j].piece)

		self.assertTrue(not move.dst_piece)
		self.assertTrue(move.performed)

		#test undoing the move:
		move.undo(board)
		self.assertTrue(not board[i, j-1].piece)
		self.assertTrue(board[i, j].piece)
		self.assertTrue(not move.performed)
Esempio n. 3
0
	def test_white_crowning(self):
		'''Test white crowning.'''
		board = Board(10, 10)
		pawn = Pawn(board.white)

		i, j = 1, 1
		board[i, j].piece = pawn

		moves = pawn.get_moves((i, j), board)

		self.assertEquals(len(moves), 1)
		self.assertTrue(moves[0].type == "Crowning")
Esempio n. 4
0
	def test_basic_white_moves(self):
		'''Test basic white pawn movement (step and double-step).'''
		board = Board(10, 10)
		pawn = Pawn(board.white)

		i, j = 1, 6
		board[i, j].piece = pawn

		moves = pawn.get_moves((i, j), board)

		self.assertEquals(len(moves), 2)
		self.assertTrue(Move((i,j), (i,j-1)) in moves)
		self.assertTrue(Move((i,j), (i,j-2)) in moves)
Esempio n. 5
0
	def test_en_passant_left(self):
		'''Test en passant for black pawn.'''
		board = Board(10, 10)
		white_pawn = Pawn(board.white)
		black_pawn = Pawn(board.black)

		board[4, 4].piece = black_pawn
		board[3, 6].piece = white_pawn

		board.perform_move(Move((3,6), (3,4)))
		moves = black_pawn.get_moves((4, 4), board)

		self.assertEquals(2, len(moves))
		self.assertTrue(Move((4,4),(4,5)) in moves)
		self.assertTrue(EnPassant((4,4), LEFT, board.black) in moves)
Esempio n. 6
0
	def test_white_crowning_attack(self):
		'''Test white crowning attack.'''
		board = Board(10, 10)
		pawn = Pawn(board.white)
		rook = Rook(board.black)

		i, j = 1, 1
		board[i, j].piece = pawn
		board[0, 0].piece = rook

		moves = pawn.get_moves((i, j), board)

		self.assertEquals(2, len(moves))
		self.assertTrue(Crowning((1,1),(1,0),Queen(board.white)) in moves)
		self.assertTrue(Crowning((1,1),(0,0),Queen(board.white)) in moves)
Esempio n. 7
0
	def test_white_attack_move(self):
		'''Test attack move for white pawn.'''
		board = Board(10, 10)
		white_pawn = Pawn(board.white)
		black_pawn = Pawn(board.black)

		i, j = 1, 6
		board[i, j].piece = white_pawn
		board[i-1, j-1].piece = black_pawn
		board[i+1, j-1].piece = black_pawn

		moves = white_pawn.get_moves((i, j), board)

		self.assertEquals(4, len(moves))
		self.assertTrue(Move((i,j),(i-1,j-1)) in moves)
		self.assertTrue(Move((i,j),(i+1,j-1)) in moves)