Python Board.place方法代码示例

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import place [as 别名]
 def play(self):
     board = Board()
     pieces = {i:Piece(val=i) for i in range(16)}
     placePiece = self.p1.get_piece(board, pieces.values())
     del pieces[placePiece.val]
     nextPlayer = self.p2
     victory = None
     while not victory and board.placed != 16:
         placePos = nextPlayer.get_placement(board, placePiece, pieces.values())
         try:
             board.place(placePiece, *placePos)
         except PlaceTakenError:
             raise PlaceTakenError(placePos, '1' if nextPlayer==self.p1 else
                     '2', board)
         if pieces:
             placePiece = nextPlayer.get_piece(board, pieces.values())
             del pieces[placePiece.val]
         victory = board.check_victory(placePos)
         if nextPlayer == self.p1:
             nextPlayer = self.p2
         else:
             nextPlayer = self.p1
     if not victory:
         winningPlayer = None
     elif nextPlayer == self.p1:
       winningPlayer = self.p2
     else:
       winningPlayer = self.p1
     return (winningPlayer, board, victory, placePos)

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import place [as 别名]
    def test_pieces_are_placed_and_restored(self):
        width = 4000
        height = 4000
        board = Board(width, height)
        pieces = [(random.randint(0, width), random.randint(0, height), { "i" : random.randint(0, 5000)}) for x in range(0, random.randint(0, 57000))]

        for piece in pieces:
            board.place(piece[0], piece[1],  piece[2])
            self.assertEquals(board.get(piece[0], piece[1])["i"], piece[2])

        self.assertEquals(len(board.contents()), len(pieces))

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import place [as 别名]
class TestBoard(TestCase):
    def setUp(self):
        self.board = Board(5, 7)

    def test_n_rows(self):
        self.assertEqual(self.board.n_rows, 5)

    def test_n_cols(self):
        self.assertEqual(self.board.n_cols, 7)

    def test_repr(self):
        board = Board(0, 0)
        self.assertEqual(repr(board), '')

        board = Board(3, 3)
        self.assertEqual(repr(board), 9 * ' ')

    def test_str(self):
        board = Board(1, 1)
        self.assertEqual(str(board), '+-+\n| |\n+-+\n')

    def test_eq(self):
        a = Board(5, 5)
        b = Board(5, 5)
        c = Board(3, 5)
        self.assertEqual(a, b)
        self.assertNotEqual(a, c)

    def test__hash__(self):
        c = {Board(5, 5)}
        c.add(Board(5, 5))
        self.assertEqual(len(c), 1)

    def test__contains__(self):
        M, N = 5, 7
        board = Board(M, N)
        self.assertIn(Position(M - 1, N - 1), board)
        self.assertNotIn(Position(-1, -1), board)
        self.assertNotIn(Position(M, N), board)

    def test_place(self):
        self.board.place(Rook, Position(3, 4))
        self.assertIsInstance(self.board[3][4], Rook)

    def test_place_at(self):
        self.board.place_at(Rook, 3, 4)
        self.assertIsInstance(self.board[3][4], Rook)

    def test_place_out_of_range(self):
        self.assertRaises(AssertionError, self.board.place, Rook, Position(7, 4))

    def test_place_is_empty(self):
        self.board.place_at(Rook, 3, 2)
        self.assertRaises(AssertionError, self.board.place, list, Position(3, 2))

    def test_place_is_subclass(self):
        self.assertRaises(AssertionError, self.board.place, list, Position(3, 2))

    def test_pieces(self):
        self.board.place_at(Rook, 3, 2)
        self.board.place_at(Queen, 1, 1)
        self.board.place_at(Knight, 2, 4)
        self.assertListEqual([str(x) for x in self.board.pieces], ['R', 'Q', 'N'])

    def test_copy(self):
        self.board.place_at(Rook, 3, 2)
        self.board.place_at(Queen, 1, 1)
        self.board.place_at(Knight, 2, 4)
        tmp = self.board.copy()
        self.assertEqual(self.board, tmp)
        self.assertIsNot(self.board, tmp)

    def test_attacked(self):
        self.board.place_at(Rook, 3, 2)
        self.board.place_at(Queen, 1, 1)
        self.board.place_at(Knight, 2, 4)
        self.assertSetEqual(self.board.attacked, set.union(*[x.attacked_positions for x in self.board.pieces]))

    def test_at(self):
        self.board.place_at(Rook, 3, 2)
        self.board.place_at(Queen, 1, 1)
        self.board.place_at(Knight, 2, 4)

        self.assertEqual(self.board.at(Position(3, 2)), self.board[3][2])
        self.assertEqual(self.board.at(Position(1, 1)), self.board[1][1])
        self.assertEqual(self.board.at(Position(2, 4)), self.board[2][4])

        self.assertEqual(self.board.at(Position(0, 2)), self.board[0][2])

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import place [as 别名]
class TestQuartoBoard(unittest.TestCase):
    def setUp(self):
        self.b1 = Board()

    def test_place(self):
        self.b1.place(Piece(), 0, 0)
        with self.assertRaises(PlaceTakenError):
            self.b1.place(Piece(), 0, 0)

    def test_get(self):
        self.assertEqual(None, self.b1.get(0, 0))
        self.b1.place(Piece(), 0, 0)
        self.assertEqual(Piece(), self.b1.get(0, 0))
        self.b1.place(Piece(False), 0, 1)
        self.assertEqual(self.b1.get(0, 0), self.b1.get(0, 1))
        self.b1.place(Piece(True, False, False, False), 0, 2)
        self.assertNotEqual(self.b1.get(0, 1), self.b1.get(0, 2))

    def test_col_victory(self):
        self.assertIsNone(self.b1.check_victory((0, 0)), None)
        self.b1.place(Piece(), 0, 0)
        self.b1.place(Piece(), 0, 1)
        self.b1.place(Piece(), 0, 2)
        for i in range(4):
            self.assertIsNone(self.b1.check_victory((0, i)))
        self.b1.place(Piece(), 0, 3)
        for i in range(4):
            self.assertIsNotNone(self.b1.check_victory((0, i)))

    def test_row_victory(self):
        self.assertIsNone(self.b1.check_victory((0, 0)), None)
        self.b1.place(Piece(), 0, 0)
        self.b1.place(Piece(), 1, 0)
        self.b1.place(Piece(), 2, 0)
        for i in range(4):
            self.assertIsNone(self.b1.check_victory((i, 0)))
        self.b1.place(Piece(), 3, 0)
        for i in range(4):
            self.assertIsNotNone(self.b1.check_victory((i, 0)))

    def test_cross_victory(self):
        self.assertIsNone(self.b1.check_victory((0, 0)), None)
        self.b1.place(Piece(), 0, 0)
        self.b1.place(Piece(), 1, 1)
        self.b1.place(Piece(), 2, 2)
        self.b1.place(Piece(), 0, 3)
        for i in range(4):
            self.assertIsNone(self.b1.check_victory((i, i)))
            self.assertIsNone(self.b1.check_victory((i, 3 - i)))
        self.b1.place(Piece(), 3, 3)
        for i in range(4):
            self.assertIsNotNone(self.b1.check_victory((i, i)))
            self.assertIsNone(self.b1.check_victory((i, 3 - i)))

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import place [as 别名]
 def test_piece_check_neighbour(self):
     b = Board(10, 10)
     b.place(2,1,"Foo")
     b.place(2,2,"Bar")
     self.assertEquals(b.neighbours(2,1), ["Bar"])

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import place [as 别名]
 def test_piece_placed(self):
     b = Board(2,3)
     b.place(2,1,"Foo")
     self.assertEquals(b.get(2,1), "Foo")

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import place [as 别名]
 def test_piece_placement(self):
     b = Board(64, 64)
     b.place(20, 20, {})
     self.assertEquals(len(b.contents()), 1)

# 需要导入模块: from board import Board [as 别名]
# 或者: from board.Board import place [as 别名]
 def testPlace(self):
     board = Board(5, 5)
     board.place(2, 3, "string")
     self.assertEqual(board.rows[2][3], "string")