import test_helper
import unittest, sys, cStringIO
import board, piece

class BoardTest(unittest.TestCase):
    def setUp(self):
        self.state = board.GameState()

    def test_put(self):
        piece = "p"
        self.state.putPieceAt(piece, (3,4))
        self.assertEqual(self.state.pieceAt((3,4)), piece)

    def test_whereIs(self):
        p = piece.Pawn(self.state, piece.WHITE)
        self.state.putPieceAt(p, (1,2))
        self.assertEqual(self.state.whereIs(p), (1,2))

    def test_movePiece(self):
        self.state.setup()
        p = self.state.pieceAt((1,1))
        self.state.movePiece((1,1),(5,5))
        self.assertEquals(p, self.state.pieceAt((5,5)))
        self.assertEquals(board.BLACK, self.state.nextMove)
        
    def test_coodinates(self):
        self.assertEquals("a1", board.positionName((0,0)))
        self.assertEquals("h1", board.positionName((7,0)))
        
        def test_position(self):
                self.assertEquals(board.position("a1"), (0,0))
        self.assertEquals(board.position("a8"), (0,7))
        
    def test_storeOn(self):
        output = cStringIO.StringIO()
        self.state.storeOn(output)
        self.assertEquals(output.getvalue(), "[ ]\n")

    def test_storeOn1(self):
        output = cStringIO.StringIO()
        self.state.putPieceAt(piece.Pawn(self.state, piece.BLACK), board.position("b2"))
        self.state.storeOn(output)
        self.assertEquals(output.getvalue(), "[ p@b2 ]\n")

    def test_storeOn2(self):
        output = cStringIO.StringIO()
        self.state.putPieceAt(piece.Pawn(self.state, piece.BLACK), board.position("b2")) 
        self.state.putPieceAt(piece.Knight(self.state, piece.WHITE), board.position("c8"))
        self.state.storeOn(output)
        self.assertEquals(output.getvalue(), "[ p@b2 N@c8 ]\n")

    def test_find_king(self):
        self.state.setup()
        # check white
        wking, wkpos = self.state.findKingAndPos(piece.WHITE)
        self.assertEquals(wkpos, board.position('e1'))
        self.assertEquals(wking, self.state.pieceAt(wkpos))
        self.assert_(isinstance(wking, piece.King))
        self.assertEquals(wking.color, piece.WHITE)
        # and now black
        bking, bkpos = self.state.findKingAndPos(piece.BLACK)
        self.assertEquals(bkpos, board.position('e8'))
        self.assertEquals(bking, self.state.pieceAt(bkpos))
        self.assert_(isinstance(bking, piece.King))
        self.assertEquals(bking.color, piece.BLACK)

    def test_find_king_neg(self):
        try:
            wking, wkpos = self.state.findKingAndPos(piece.WHITE)
            success = False
        except Exception:
            success = True
        self.assert_(success, 'should not be a white king!')


class CapturedTest(unittest.TestCase):
    def setUp(self):
        self.held, sys.stdout = sys.stdout, cStringIO.StringIO()
        self.state = board.GameState()

    def tearDown(self):
        sys.stdout = self.held

    def test_dump(self):
        board.dumpBoard(self.state)
        self.assertEqual(sys.stdout.getvalue(),"""\
#   #   #   #  
  #   #   #   #
#   #   #   #  
  #   #   #   #
#   #   #   #  
  #   #   #   #
#   #   #   #  
  #   #   #   #
White to move
""")

    def test_setup(self):
        self.state.setup()
        board.dumpBoard(self.state)
        self.assertEqual(sys.stdout.getvalue(),"""\
r n b q k b n r
p p p p p p p p
#   #   #   #  
  #   #   #   #
#   #   #   #  
  #   #   #   #
P P P P P P P P
R N B Q K B N R
White to move
""")

class CheckTest(unittest.TestCase):
    def setUp(self):
        self.state = board.GameState()


    def test_in_check(self):
        b = self.state
        king = piece.King(b, piece.WHITE)
        b.putPieceAt(king, board.position('d5'))
        bish = piece.Bishop(b, piece.BLACK)
        b.putPieceAt(bish, board.position('g2'))
        self.assert_(b.isInCheck(piece.WHITE),
                     'white should be in check!')
        
    def test_not_in_check(self):
        b = self.state
        king = piece.King(b, piece.WHITE)
        b.putPieceAt(king, board.position('d5'))
        bish = piece.Bishop(b, piece.BLACK)
        b.putPieceAt(bish, board.position('f2'))
        self.assert_(not b.isInCheck(piece.WHITE),
                     'white should not be in check!')
        

if __name__ == "__main__":
        unittest.main()