def testEqualWithGap(self):
state = """\
0|4 0|5
0 x x 2
- -
0 0|1 0
"""
board1 = Board.create(state)
board2 = Board.create(state)
eq_result = (board1 == board2)
neq_result = (board1 != board2)
self.assertTrue(eq_result)
self.assertFalse(neq_result)
def testEqualWithGap(self):
state = """\
0|4 0|5
0 x x 2
- -
0 0|1 0
"""
board1 = Board.create(state)
board2 = Board.create(state)
eq_result = (board1 == board2)
neq_result = (board1 != board2)
self.assertTrue(eq_result)
self.assertFalse(neq_result)
def testCreateWithSpaces(self):
board = Board.create("""\
4
-
3|1 4|6 4 1
-
2 4 4 2|5
- -
3 2 4|0 5
-
5 0|0 1|1 4
-
6 5|5 3|3 6|3
""")
expected_display = """\
x x x x x x 4 x
-
3|1 x 4|6 4 1 x
-
x 2 4 x x 4 2|5
- -
x 3 2 x 4|0 5 x
-
x 5 0|0 1|1 4 x
-
x 6 5|5 3|3 6|3
"""
display = board.display()
self.assertMultiLineEqual(expected_display, display)
def testDisconnectedBeforeCapture(self):
""" Board must be connected after move and after capture.
Here, move 62L is disconnected after the move, but connected after
the capture removes most of the dominoes. Test that the move is still
not allowed.
"""
board = Board.create("""\
x x x x 5
-
x x 6|2 3
6|6 2|4 x
""")
graph = CaptureBoardGraph()
expected_states = set("""\
x x x x 5
-
x x 6|2 3
6|6 2|4 x
""".split('---\n'))
states = graph.walk(board)
self.assertEqual(expected_states, states)
def testDisconnectedBeforeCapture(self):
""" Board must be connected after move and after capture.
Here, move 62L is disconnected after the move, but connected after
the capture removes most of the dominoes. Test that the move is still
not allowed.
"""
board = Board.create("""\
x x x x 5
-
x x 6|2 3
6|6 2|4 x
""")
graph = CaptureBoardGraph()
expected_states = set("""\
x x x x 5
-
x x 6|2 3
6|6 2|4 x
""".split('---\n'))
states = graph.walk(board)
self.assertEqual(expected_states, states)
def testHasMatch(self):
state = """\
1 2
- -
0 0
"""
board = Board.create(state)
self.assertTrue(board.hasMatch())
def testHasNoMatch(self):
state = """\
1 0
- -
0 2
"""
board = Board.create(state)
self.assertFalse(board.hasMatch())
def testHasMatch(self):
state = """\
1 2
- -
0 0
"""
board = Board.create(state)
self.assertTrue(board.hasMatch())
def testIsConnected(self):
state = """\
1 0|2 x x
-
0 0|4 0|3
"""
board = Board.create(state)
self.assertTrue(board.isConnected())
def testIsNotConnected(self):
state = """\
1 0|2 x x
-
0 x x 0|3
"""
board = Board.create(state)
self.assertFalse(board.isConnected())
def testHasNoLoner(self):
state = """\
1 0 x 1|3
- -
0 2 x 0|3
"""
board = Board.create(state)
self.assertFalse(board.hasLoner())
def testIsConnected(self):
state = """\
1 0|2 x x
-
0 0|4 0|3
"""
board = Board.create(state)
self.assertTrue(board.isConnected())
def testIsNotConnected(self):
state = """\
1 0|2 x x
-
0 x x 0|3
"""
board = Board.create(state)
self.assertFalse(board.isConnected())
def testHasLoner(self):
state = """\
1 0 x 1|2
- -
0 2 x 0|3
"""
board = Board.create(state)
self.assertTrue(board.hasLoner())
def testHasNoMatch(self):
state = """\
1 0
- -
0 2
"""
board = Board.create(state)
self.assertFalse(board.hasMatch())
def testHasNoLoner(self):
state = """\
1 0 x 1|3
- -
0 2 x 0|3
"""
board = Board.create(state)
self.assertFalse(board.hasLoner())
def testHasLoner(self):
state = """\
1 0 x 1|2
- -
0 2 x 0|3
"""
board = Board.create(state)
self.assertTrue(board.hasLoner())
def testHasNoMatch(self):
state = """\
1 0
- -
0 2
"""
board = Board.create(state)
domino = board[1][1].domino
self.assertFalse(domino.hasMatch())
def testCreateRightEdge(self):
state = """\
x 0|2
0|1 x
"""
board = Board.create(state)
self.assertMultiLineEqual(state, board.display())
def testCreateVertical(self):
state = """\
1 0|2
-
0 x x
"""
board = Board.create(state)
self.assertMultiLineEqual(state, board.display())
def testDifferentAlignment(self):
state1 = """\
0|4 0|5
0 0|3 2
- -
0 0|1 0
"""
state2 = """\
0|4 0|5
0 0 3 2
- - - -
0 0 1 0
"""
board1 = Board.create(state1)
board2 = Board.create(state2)
self.assertNotEqual(board1, board2)
def testHasMatch(self):
state = """\
1 2
- -
0 0
"""
board = Board.create(state)
domino = board[1][1].domino
self.assertTrue(domino.hasMatch())
def testCreateRightEdge(self):
state = """\
x 0|2
0|1 x
"""
board = Board.create(state)
self.assertMultiLineEqual(state, board.display())
def testCreateVertical(self):
state = """\
1 0|2
-
0 x x
"""
board = Board.create(state)
self.assertMultiLineEqual(state, board.display())
def testDifferentAlignment(self):
state1 = """\
0|4 0|5
0 0|3 2
- -
0 0|1 0
"""
state2 = """\
0|4 0|5
0 0 3 2
- - - -
0 0 1 0
"""
board1 = Board.create(state1)
board2 = Board.create(state2)
self.assertNotEqual(board1, board2)
def testHasMatch(self):
state = """\
1 2
- -
0 0
"""
board = Board.create(state)
domino = board[1][1].domino
self.assertTrue(domino.hasMatch())
def testNoSolution(self):
graph = CaptureBoardGraph()
board = Board.create("""\
6|2 3
-
2|4 5
""")
graph.walk(board)
self.assertRaises(NetworkXNoPath, graph.get_solution)
def testHasNoMatch(self):
state = """\
1 0
- -
0 2
"""
board = Board.create(state)
domino = board[1][1].domino
self.assertFalse(domino.hasMatch())
def testFindNoMatch(self):
state = """\
1 0
- -
0 2
"""
board = Board.create(state)
matches = board.findMatches()
expected_matches = []
self.assertEqual(expected_matches, matches)
def testCreate(self):
state = """\
0|2 x
0|1 x
"""
board = Board.create(state)
display = board.display()
self.assertMultiLineEqual(state, display)
def testFindNoMatch(self):
state = """\
1 0
- -
0 2
"""
board = Board.create(state)
matches = board.findMatches()
expected_matches = []
self.assertEqual(expected_matches, matches)
def testCreate(self):
state = """\
0|2 x
0|1 x
"""
board = Board.create(state)
display = board.display()
self.assertMultiLineEqual(state, display)
def testHasEvenGapsTwoUnevenGaps(self):
state = """\
4|5 x 0
-
1 2 6 5
- - -
0 3 1 x
"""
board = Board.create(state)
has_even_gaps = board.hasEvenGaps()
self.assertFalse(has_even_gaps)
def testFindMatch(self):
state = """\
1 2
- -
0 0
"""
board = Board.create(state)
matches = board.findMatches()
coordinates = [(cell.x, cell.y) for cell in matches]
expected_coordinates = [(0, 0), (1, 0)]
self.assertEqual(expected_coordinates, coordinates)
def testWalkNoSplit(self):
board = Board.create("""\
x 3|2 3|1 x
""")
graph = BoardGraph()
expected_states = set("""\
3|2 3|1
""".split('---\n'))
states = graph.walk(board)
self.assertEqual(expected_states, states)
def testHasEvenGapsTwoUnevenGaps(self):
state = """\
4|5 x 0
-
1 2 6 5
- - -
0 3 1 x
"""
board = Board.create(state)
has_even_gaps = board.hasEvenGaps()
self.assertFalse(has_even_gaps)
def testFindMatch(self):
state = """\
1 2
- -
0 0
"""
board = Board.create(state)
matches = board.findMatches()
coordinates = [(cell.x, cell.y) for cell in matches]
expected_coordinates = [(0, 0), (1, 0)]
self.assertEqual(expected_coordinates, coordinates)
def testFindNeighbours(self):
board = Board.create("""\
x 3|2
1|0 x
""")
cell = board[1][0]
expected_neighbours = {board[1][1]}
neighbours = set(cell.find_neighbours())
self.assertEqual(expected_neighbours, neighbours)
def testHasEvenGapsOneEvenGap(self):
state = """\
4|5 6 0
- -
1 2 1 5
- -
0 3 x x
"""
board = Board.create(state)
has_even_gaps = board.hasEvenGaps()
self.assertTrue(has_even_gaps)
def testWalkNoSplit(self):
board = Board.create("""\
x 3|2 3|1 x
""")
graph = BoardGraph()
expected_states = set("""\
3|2 3|1
""".split('---\n'))
states = graph.walk(board)
self.assertEqual(expected_states, states)
def testSolution(self):
graph = CaptureBoardGraph()
expected_solution = ['34u', '24r']
board = Board.create("""\
6|2 3
-
2|4 4
""")
graph.walk(board)
solution = graph.get_solution()
self.assertEqual(expected_solution, solution)
def testFindNeighbours(self):
board = Board.create("""\
x 3|2
1|0 x
""")
cell = board[1][0]
expected_neighbours = set([board[1][1]])
neighbours = set(cell.findNeighbours())
self.assertEqual(expected_neighbours, neighbours)
def testHasEvenGapsOneEvenGap(self):
state = """\
4|5 6 0
- -
1 2 1 5
- -
0 3 x x
"""
board = Board.create(state)
has_even_gaps = board.hasEvenGaps()
self.assertTrue(has_even_gaps)
def testPartialSolution(self):
graph = CaptureBoardGraph()
expected_solution = ['62l']
board = Board.create("""\
6|2 3
-
2|4 5
""")
graph.walk(board)
solution = graph.get_solution(partial=True)
self.assertEqual(expected_solution, solution)
def testBadMove(self):
start_state = """\
0|2 x
0|1 x
"""
board = Board.create(start_state)
domino1 = board[0][0].domino
with self.assertRaises(BoardError):
domino1.move(-1, 0)
self.assertMultiLineEqual(start_state, board.display())
def testPartialSolution(self):
graph = CaptureBoardGraph()
expected_solution = ['62l']
board = Board.create("""\
6|2 3
-
2|4 5
""")
graph.walk(board)
solution = graph.get_solution(return_partial=True)
self.assertEqual(expected_solution, solution)
def testFindNeighbours(self):
state = """\
1 0|2 x x
-
0 0|4 0|3
"""
board = Board.create(state)
domino1 = board[1][1].domino
expected_neighbours = {board[0][1].domino, board[1][0].domino}
neighbours = domino1.find_neighbours()
self.assertEqual(expected_neighbours, neighbours)
def testFindNeighbours(self):
state = """\
1 0|2 x x
-
0 0|4 0|3
"""
board = Board.create(state)
domino1 = board[1][1].domino
expected_neighbours = set([board[0][1].domino, board[1][0].domino])
neighbours = domino1.findNeighbours()
self.assertEqual(expected_neighbours, neighbours)
def testDifferentPips(self):
state1 = """\
0|4 0|5
0 0|3 2
- -
0 0|1 0
"""
state2 = """\
6|4 0|5
0 0|3 2
- -
0 0|1 0
"""
board1 = Board.create(state1)
board2 = Board.create(state2)
eq_result = (board1 == board2)
neq_result = (board1 != board2)
self.assertFalse(eq_result)
self.assertTrue(neq_result)
def test_solution(self):
board = Board.create("""\
1|2 3
-
2|4 2
""")
graph = BlockingBoardGraph()
expected_solution = ['12l', '12l', '32u']
graph.walk(board)
solution = graph.get_solution()
self.assertEqual(expected_solution, solution)
def test_choice_counts(self):
board = Board.create("""\
1|2 3
-
2|4 2
""")
graph = BlockingBoardGraph()
expected_counts = [1, 2, 2]
graph.walk(board)
counts = graph.get_choice_counts()
self.assertEqual(expected_counts, counts)
def testDifferentPips(self):
state1 = """\
0|4 0|5
0 0|3 2
- -
0 0|1 0
"""
state2 = """\
6|4 0|5
0 0|3 2
- -
0 0|1 0
"""
board1 = Board.create(state1)
board2 = Board.create(state2)
eq_result = (board1 == board2)
neq_result = (board1 != board2)
self.assertFalse(eq_result)
self.assertTrue(neq_result)
def testBadMove(self):
start_state = """\
0|2 x
0|1 x
"""
board = Board.create(start_state)
domino1 = board[0][0].domino
with self.assertRaises(BoardError):
domino1.move(-1, 0)
self.assertMultiLineEqual(start_state, board.display())
def testSolution(self):
graph = CaptureBoardGraph()
expected_solution = ['34u', '24r']
expected_closest = ''
board = Board.create("""\
6|2 3
-
2|4 4
""")
graph.walk(board)
solution = graph.get_solution()
self.assertEqual(expected_solution, solution)
self.assertEqual(expected_closest, graph.closest)
def testExtraDominoes(self):
state = """\
0|0 x
1|1 x
"""
max_pips = 2
expected_extra_dominoes = [Domino(0, 1),
Domino(0, 2),
Domino(1, 2),
Domino(2, 2)]
board = Board.create(state, max_pips=max_pips)
self.assertEqual(expected_extra_dominoes, board.extra_dominoes)
def testCreateWithOtherMarkers(self):
state = """\
1 0?2
*
0 x x
"""
expected_display = """\
1 0|2
-
0 x x
"""
board = Board.create(state)
self.assertMultiLineEqual(expected_display, board.display())
def testFillFailForMatching(self):
""" Fail because all of the remaining dominoes have matches.
"""
random = Random()
start = """\
0 x x
-
0 1|1
"""
board = Board.create(start, max_pips=1)
result = board.fill(random, matches_allowed=False)
self.assertFalse(result)
self.assertMultiLineEqual(start, board.display())
def testCreateWithOtherMarkers(self):
state = """\
1 0?2
*
0 x x
"""
expected_display = """\
1 0|2
-
0 x x
"""
board = Board.create(state)
self.assertMultiLineEqual(expected_display, board.display())
def testFillFailForMatching(self):
""" Fail because all of the remaining dominoes have matches.
"""
random = Random()
start = """\
0 x x
-
0 1|1
"""
board = Board.create(start, max_pips=1)
result = board.fill(random, matches_allowed=False)
self.assertFalse(result)
self.assertMultiLineEqual(start, board.display())
def testDisplayCropped(self):
board = Board.create("""\
3 x x x
-
2 0|2 x
x x x x
""")
expected_display = """\
3 x x
-
2 0|2
"""
self.assertMultiLineEqual(expected_display,
board.display(cropped=True))
