class TestLiberties(unittest.TestCase):

	def setUp(self):
		self.s = GameState()
		self.s.do_move((4,5))
		self.s.do_move((5,5))
		self.s.do_move((5,6))
		self.s.do_move((10,10))
		self.s.do_move((4,6))

		self.syms = self.s.symmetries()

	def test_lib_count(self):
		self.assertEqual(self.s.liberty_count(5,5), 2)
		print("liberty_count checked")

	def test_lib_pos(self):
		self.assertEqual(self.s.liberty_pos(5,5), ((6,5), (5,4)))
		print("liberty_pos checked")

	def test_curr_liberties(self):
		self.assertEqual(self.s.update_current_liberties()[5][5], 2)
		self.assertEqual(self.s.update_current_liberties()[4][5], 6)
		self.assertEqual(self.s.update_current_liberties()[5][6], 6)

		print("curr_liberties checked")

	def test_future_liberties(self):

		self.assertEqual(self.s.update_future_liberties((6,5))[6][5], 4)
		self.assertEqual(self.s.update_future_liberties((5,4))[5][4], 4)
		self.assertEqual(self.s.update_future_liberties((6,6))[5][6], 5)

		print("future_liberties checked")
class TestLiberties(unittest.TestCase):
    def setUp(self):
        self.s = GameState()
        self.s.do_move((4, 5))
        self.s.do_move((5, 5))
        self.s.do_move((5, 6))
        self.s.do_move((10, 10))
        self.s.do_move((4, 6))
        self.s.do_move((10, 11))
        self.s.do_move((6, 6))
        self.s.do_move((9, 10))

        self.syms = self.s.symmetries()

    def test_lib_count(self):
        self.assertEqual(self.s.liberty_count((5, 5)), 2)
        print("liberty_count checked")

    def test_lib_pos(self):
        self.assertEqual(self.s.liberty_pos((5, 5)), [(6, 5), (5, 4)])
        print("liberty_pos checked")

    def test_curr_liberties(self):
        self.assertEqual(self.s.update_current_liberties()[5][5], 2)
        self.assertEqual(self.s.update_current_liberties()[4][5], 8)
        self.assertEqual(self.s.update_current_liberties()[5][6], 8)

        print("curr_liberties checked")

    def test_future_liberties(self):
        print(self.s.update_future_liberties((4, 4)))
        self.assertEqual(self.s.update_future_liberties((6, 5))[6][5], 9)
        self.assertEqual(self.s.update_future_liberties((5, 4))[5][4], 3)
        self.assertEqual(self.s.update_future_liberties((4, 4))[4][4], 10)

        print("future_liberties checked")

    def test_neighbors_edge_cases(self):

        st = GameState()
        st.do_move((0, 0))  #  B B . . . . .
        st.do_move((5, 5))  #  B W . . . . .
        st.do_move((0, 1))  #  . . . . . . .
        st.do_move((6, 6))  #  . . . . . . .
        st.do_move((1, 0))  #  . . . . . W .
        st.do_move((1, 1))  #  . . . . . . W

        # visit_neighbor in the corner
        self.assertEqual(len(st.visit_neighbor((0, 0))), 3,
                         "group size in corner")

        # visit_neighbor of an empty space
        self.assertEqual(len(st.visit_neighbor((4, 4))), 0,
                         "group size of empty space")

        # visit_neighbor of a single piece
        self.assertEqual(len(st.visit_neighbor((5, 5))), 1,
                         "group size of single piece")
Beispiel #3
0
class TestLiberties(unittest.TestCase):

	def setUp(self):
		self.s = GameState()
		self.s.do_move((4,5))
		self.s.do_move((5,5))
		self.s.do_move((5,6))
		self.s.do_move((10,10))
		self.s.do_move((4,6))
		self.s.do_move((10,11))
		self.s.do_move((6,6))
		self.s.do_move((9, 10))

		self.syms = self.s.symmetries()

	def test_lib_count(self):
		self.assertEqual(self.s.liberty_count((5,5)), 2)
		print("liberty_count checked")

	def test_lib_pos(self):
		self.assertEqual(self.s.liberty_pos((5,5)), [(6,5), (5,4)])
		print("liberty_pos checked")

	def test_curr_liberties(self):
		self.assertEqual(self.s.update_current_liberties()[5][5], 2)
		self.assertEqual(self.s.update_current_liberties()[4][5], 8)
		self.assertEqual(self.s.update_current_liberties()[5][6], 8)

		print("curr_liberties checked")

	def test_future_liberties(self):
		print(self.s.update_future_liberties((4,4)))
		self.assertEqual(self.s.update_future_liberties((6,5))[6][5], 9)
		self.assertEqual(self.s.update_future_liberties((5,4))[5][4], 3)
		self.assertEqual(self.s.update_future_liberties((4,4))[4][4], 10)

		print("future_liberties checked")

	def test_neighbors_edge_cases(self):

		st = GameState()
		st.do_move((0,0)) #  B B . . . . . 
		st.do_move((5,5)) #  B W . . . . . 
		st.do_move((0,1)) #  . . . . . . . 
		st.do_move((6,6)) #  . . . . . . . 
		st.do_move((1,0)) #  . . . . . W . 
		st.do_move((1,1)) #  . . . . . . W

		# visit_neighbor in the corner
		self.assertEqual(len(st.visit_neighbor((0,0))), 3, "group size in corner")

		# visit_neighbor of an empty space
		self.assertEqual(len(st.visit_neighbor((4,4))), 0, "group size of empty space")

		# visit_neighbor of a single piece
		self.assertEqual(len(st.visit_neighbor((5,5))), 1, "group size of single piece")
Beispiel #4
0
class TestLiberties(unittest.TestCase):
    def setUp(self):
        self.s = GameState()
        self.s.do_move((4, 5))
        self.s.do_move((5, 5))
        self.s.do_move((5, 6))
        self.s.do_move((10, 10))
        self.s.do_move((4, 6))
        self.s.do_move((10, 11))
        self.s.do_move((6, 6))
        self.s.do_move((9, 10))

        self.syms = self.s.symmetries()

    def test_curr_liberties(self):
        self.assertEqual(self.s.liberty_counts[5][5], 2)
        self.assertEqual(self.s.liberty_counts[4][5], 8)
        self.assertEqual(self.s.liberty_counts[5][6], 8)

        print("curr_liberties checked")

    def test_neighbors_edge_cases(self):

        st = GameState()
        st.do_move((0, 0))  #  B B . . . . .
        st.do_move((5, 5))  #  B W . . . . .
        st.do_move((0, 1))  #  . . . . . . .
        st.do_move((6, 6))  #  . . . . . . .
        st.do_move((1, 0))  #  . . . . . W .
        st.do_move((1, 1))  #  . . . . . . W

        # get_group in the corner
        self.assertEqual(len(st.get_group((0, 0))), 3, "group size in corner")

        # get_group of an empty space
        self.assertEqual(len(st.get_group((4, 4))), 0,
                         "group size of empty space")

        # get_group of a single piece
        self.assertEqual(len(st.get_group((5, 5))), 1,
                         "group size of single piece")
Beispiel #5
0
class TestSymmetries(unittest.TestCase):
    def setUp(self):
        self.s = GameState()
        self.s.do_move((4, 5))
        self.s.do_move((5, 5))
        self.s.do_move((5, 6))

        self.syms = self.s.symmetries()

    def test_num_syms(self):
        # make sure we got exactly 8 back
        self.assertEqual(len(self.syms), 8)

    def test_copy_fields(self):
        # make sure each copy has the correct non-board fields
        for copy in self.syms:
            self.assertEqual(self.s.size, copy.size)
            self.assertEqual(self.s.turns_played, copy.turns_played)
            self.assertEqual(self.s.current_player, copy.current_player)

    def test_sym_boards(self):
        # construct by hand the 8 boards we expect to see
        expectations = [GameState() for i in range(8)]

        descriptions = [
            "noop", "rot90", "rot180", "rot270", "mirror LR", "mirror UD",
            "mirror \\", "mirror /"
        ]

        # copy of self.s
        expectations[0].do_move((4, 5))
        expectations[0].do_move((5, 5))
        expectations[0].do_move((5, 6))

        # rotate 90 CCW
        expectations[1].do_move((13, 4))
        expectations[1].do_move((13, 5))
        expectations[1].do_move((12, 5))

        # rotate 180
        expectations[2].do_move((14, 13))
        expectations[2].do_move((13, 13))
        expectations[2].do_move((13, 12))

        # rotate CCW 270
        expectations[3].do_move((5, 14))
        expectations[3].do_move((5, 13))
        expectations[3].do_move((6, 13))

        # mirror left-right
        expectations[4].do_move((4, 13))
        expectations[4].do_move((5, 13))
        expectations[4].do_move((5, 12))

        # mirror up-down
        expectations[5].do_move((14, 5))
        expectations[5].do_move((13, 5))
        expectations[5].do_move((13, 6))

        # mirror \ diagonal
        expectations[6].do_move((5, 4))
        expectations[6].do_move((5, 5))
        expectations[6].do_move((6, 5))

        # mirror / diagonal (equivalently: rotate 90 CCW then flip LR)
        expectations[7].do_move((13, 14))
        expectations[7].do_move((13, 13))
        expectations[7].do_move((12, 13))

        for i in range(8):
            self.assertTrue(
                np.array_equal(expectations[i].board, self.syms[i].board),
                descriptions[i])
Beispiel #6
0
class TestSymmetries(unittest.TestCase):

	def setUp(self):
		self.s = GameState()
		self.s.do_move((4,5))
		self.s.do_move((5,5))
		self.s.do_move((5,6))

		self.syms = self.s.symmetries()

	def test_num_syms(self):
		# make sure we got exactly 8 back
		self.assertEqual(len(self.syms), 8)

	def test_copy_fields(self):
		# make sure each copy has the correct non-board fields
		for copy in self.syms:
			self.assertEqual(self.s.size, copy.size)
			self.assertEqual(self.s.turns_played, copy.turns_played)
			self.assertEqual(self.s.current_player, copy.current_player)

	def test_sym_boards(self):
		# construct by hand the 8 boards we expect to see
		expectations = [GameState() for i in range(8)]

		descriptions = ["noop", "rot90", "rot180", "rot270", "mirror LR", "mirror UD", "mirror \\", "mirror /"]

		# copy of self.s
		expectations[0].do_move((4,5))
		expectations[0].do_move((5,5))
		expectations[0].do_move((5,6))

		# rotate 90 CCW
		expectations[1].do_move((13,4))
		expectations[1].do_move((13,5))
		expectations[1].do_move((12,5))

		# rotate 180
		expectations[2].do_move((14,13))
		expectations[2].do_move((13,13))
		expectations[2].do_move((13,12))

		# rotate CCW 270
		expectations[3].do_move((5,14))
		expectations[3].do_move((5,13))
		expectations[3].do_move((6,13))

		# mirror left-right
		expectations[4].do_move((4,13))
		expectations[4].do_move((5,13))
		expectations[4].do_move((5,12))

		# mirror up-down
		expectations[5].do_move((14,5))
		expectations[5].do_move((13,5))
		expectations[5].do_move((13,6))

		# mirror \ diagonal
		expectations[6].do_move((5,4))
		expectations[6].do_move((5,5))
		expectations[6].do_move((6,5))

		# mirror / diagonal (equivalently: rotate 90 CCW then flip LR)
		expectations[7].do_move((13,14))
		expectations[7].do_move((13,13))
		expectations[7].do_move((12,13))

		for i in range(8):
			self.assertTrue(np.array_equal(expectations[i].board, self.syms[i].board), descriptions[i])