def test_setplayercolour_black(self):
self.board.setplayercolour('black')
self.assertEqual(self.board.playercolour, 'black',
errormessage(self.board.playercolour, 'black'))
self.assertEqual(self.board.computercolour, 'white',
errormessage(self.board.computercolour, 'white'))
return None
def test__setitem__coordinate(self):
piece = pieces.BishopPiece('white')
self.board[(2, 1)] = piece
self.assertEqual(self.board._board[17], piece,
errormessage(self.board._board[17], piece))
return None
def test__setitem__index(self):
piece = pieces.KingPiece('white')
self.board[36] = piece
self.assertEqual(self.board._board[36], piece,
errormessage(self.board._board[36], piece))
return None
def test_notationsymbol_black(self):
piece = pieces.BasePiece('black', 'a', [core.Vector(0, 1)], crawler=True)
self.assertEqual(
piece.notationsymbol, 'a',
errormessage(piece.notationsymbol, 'a')
)
return None
def test__setitem__vector(self):
piece = pieces.QueenPiece('white')
self.board[core.Vector(6, 6)] = piece
self.assertEqual(self.board._board[54], piece,
errormessage(self.board._board[54], piece))
return None
def test_duplicateboard(self):
piece = pieces.QueenPiece('black')
self.board[11] = piece
newboard = self.board.duplicateboard()
self.board[12] = piece
self.assertNotEqual(
newboard[12], self.board[12],
errormessage('%s == %s' % (newboard[12], self.board[12]),
'%s =/= %s' % (newboard[12], self.board[12])))
self.assertEqual(
newboard[11], self.board[11],
errormessage('%s =/= %s' % (newboard[11], self.board[11]),
'%s == %s' % (newboard[11], self.board[11])))
return None
def test_addmovetohistory_capture(self):
movestring = 'Qe5xd5'
self.ui.addmovetohistory('Q', 36, 35, capture=True)
self.assertEqual(
self.ui.history[-1], movestring,
errormessage(self.ui.history[-1], movestring)
)
return None
def test_addmovetohistory_promotionto(self):
movestring = 'Pa7>a8=Q'
self.ui.addmovetohistory('P', 48, 56, promotionto='Q')
self.assertEqual(
self.ui.history[-1], movestring,
errormessage(self.ui.history[-1], movestring)
)
return None
def test_addmovetohistory_castleshort(self):
movestring = '0-0'
self.ui.addmovetohistory(castleshort=True)
self.assertEqual(
self.ui.history[-1], movestring,
errormessage(self.ui.history[-1], movestring)
)
return None
def test_addmovetohistory_checkmate(self):
movestring = 'Bh7>f5#'
self.ui.addmovetohistory('B', 55, 37, checkmate=True)
self.assertEqual(
self.ui.history[-1], movestring,
errormessage(self.ui.history[-1], movestring)
)
return None
def test_addmovetohistory_check(self):
movestring = 'Qe5>d5+'
self.ui.addmovetohistory('Q', 36, 35, check=True)
self.assertEqual(
self.ui.history[-1], movestring,
errormessage(self.ui.history[-1], movestring)
)
return None
def test_addmovetohistory_basicmove(self):
movestring = 'Pe2>e4'
self.ui.addmovetohistory('P', 12, 28)
self.assertEqual(
self.ui.history[-1], movestring,
errormessage(self.ui.history[-1], movestring)
)
return None
def test_findpiece_black(self):
self.board[22] = pieces.KingPiece('black')
blackkingpos = self.board.findpiece(pieces.KingPiece, 'black')[0]
self.assertEqual(
blackkingpos, 22,
errormessage("The king is at %i" % blackkingpos,
"The king is at %i" % 22))
return None
def test_findpiece_white(self):
self.board[25] = pieces.KingPiece('white')
whitekingpos = self.board.findpiece(pieces.KingPiece, 'white')[0]
self.assertEqual(
whitekingpos, 25,
errormessage("The king is at %i" % whitekingpos,
"The king is at %i" % 25))
return None
def test_piecesbetween_inclusive(self):
self.assertEqual(
len(self.generator._piecesbetween(18, 19, inclusive=True)), 2,
errormessage(
'%s piece(s)' % len(self.generator._piecesbetween(18, 19, inclusive=True)),
'2 pieces'
)
)
return None
def test_piecesbetween_twopieces(self):
self.assertEqual(
len(self.generator._piecesbetween(16, 23)), 2,
errormessage(
'%s piece(s)' % len(self.generator._piecesbetween(16, 23)),
'2 pieces'
)
)
return None
def test_type(self):
self.assertTrue(
self.piece.type is pieces.PawnPiece,
errormessage(
"%s is not %s" % (self.piece.type, "PawnPiece"),
"%s is %s" % (self.piece.type, "PawnPiece")
)
)
return None
def test_basicmoves_white(self):
movelist = self.generator.basicmoves('white')
# Make sure queen can't jump over white pawn.
self.assertNotIn(
(18, 19), movelist,
errormessage('Can capture white pawn', "Can't capture white pawn"))
self.assertNotIn(
(18, 20), movelist,
errormessage('Can move over pawn', 'Blocked by white pawn'))
# Make sure queen can't move past knight at 42.
self.assertIn(
(18, 42), movelist,
errormessage("Can't capture knight", 'Can capture black knight'))
self.assertNotIn(
(18, 50), movelist,
errormessage('Can move past black knight', 'Blocked by knight'))
def test_piecesbetween_onepiece(self):
self.assertEqual(
len(self.generator._piecesbetween(18, 23)), 1,
errormessage(
'%s pieces' % len(self.generator._piecesbetween(18, 23)),
'1 piece'
)
)
return None
def test_type(self):
self.assertTrue(
self.piece.type is pieces.BasePiece,
errormessage(
"%s is not BasePiece" % str(self.piece),
"%s is BasePiece" % str(self.piece)
)
)
return None
def test_basicmoves_black(self):
# XXX - This is the *exact* same method as for white. I forgot to change it.
movelist = self.generator.basicmoves('white')
# Make sure queen can't jump over white pawn.
self.assertNotIn(
(18, 19), movelist,
errormessage('Can capture white pawn', "Can't capture white pawn"))
self.assertNotIn(
(18, 20), movelist,
errormessage('Can move over pawn', 'Blocked by white pawn'))
# Make sure queen can't move past knight at 42.
self.assertIn(
(18, 42), movelist,
errormessage("Can't capture knight", 'Can capture black knight'))
self.assertNotIn(
(18, 50), movelist,
errormessage('Can move past black knight', 'Blocked by knight'))
def test_inequality(self):
piece2 = pieces.BishopPiece('white')
self.assertNotEqual(
self.piece, piece2,
errormessage(
"%s == %s" % (self.piece, "BishopPiece"),
"%s =/= %s" % (self.piece, "BishopPiece")
)
)
return None
def test_equality(self):
piece2 = pieces.PawnPiece('black')
self.assertEqual(
self.piece, piece2,
errormessage(
"%s =/= %s" % (self.piece, "PawnPiece"),
"%s == %s" % (self.piece, "PawnPiece")
)
)
return None
def test_equality(self):
piece2 = pieces.BasePiece(
'black', '?', [core.Vector(0, 1)], crawler=True)
self.assertEqual(
self.piece, piece2,
errormessage(
"%s =/= %s" % (self.piece, "BasePiece"),
"%s == %s" % (self.piece, "BasePiece")
)
)
return None
def test_piecesareonsameside_bothcolours(self):
self.assertFalse(
self.generator._piecesareonsameside(self.board[18], self.board[23]),
errormessage(True, False)
)
return None
def test_piecesareonsameside_black(self):
self.assertTrue(
self.generator._piecesareonsameside(self.board[23], self.board[42]),
errormessage(False, True)
)
return None
def test_piecesareonsameside_white(self):
self.assertTrue(
self.generator._piecesareonsameside(self.board[18], self.board[19]),
errormessage(False, True)
)
return None
def test__getitem__coordinate(self):
self.board._board[23] = 'Y' # Inject a piece at (2, 7)
self.assertEqual(self.board[(2, 7)], 'Y',
errormessage(self.board[(2, 7)], 'Y'))
return None
def test_notationsymbol_white(self):
self.assertEqual(
self.piece.notationsymbol, 'A',
errormessage(self.piece.notationsymbol, 'A')
)
return None
def test__getitem__vector(self):
self.board._board[0] = 'Z' # Inject a piece at (0, 0)
self.assertEqual(self.board[core.Vector(0, 0)], 'Z',
errormessage(self.board[core.Vector(0, 0)], 'Z'))
return None
