class Test_testAlgIntersectValue(unittest.TestCase):
def setUp(self):
self.board = SudokuBoard()
self.board.loadBoard('preloads/sudoku3.txt')
self.alg = AlgIntersectValue(self.board)
def test_AlgIntersectNonBlankValue(self):
coords = (0,1)
self.assertTrue(self.alg.runAlg(coords) == None)
def test_AlgIntersectNotSolvable(self):
coords = (8,8)
self.assertTrue(self.alg.runAlg(coords) == None)
def test_AlgIntersectSolve(self):
coords = (1,1)
self.assertTrue(self.alg.runAlg(coords) == 9)
from SudokuBoard import SudokuBoard
from AlgIntersectValue2 import AlgIntersectValue2
from AlgNumbersInLayers import AlgNumbersInLayers
# Create and load board
sb = SudokuBoard()
sb.loadBoard('preloads/sudoku1.txt')
sb.printBoard()
def solveUsingIntersect(sb):
alg2 = AlgIntersectValue2(sb)
goodRun = False
solutions = []
contSolving = True
iteration = 0
while contSolving:
# Check each place
anyFound = False;
for index in range(81):
place = sb.getDigit(index)
if place is None:
# Place is empty, check if we can solve it
solution = alg2.runAlg(SudokuBoard.coordsFromIndex(index))
if solution is not None:
solutions.append((index, solution))
anyFound = True
goodRun = True
print("Iteration {0}: Found {1} solutions!".format(iteration, len(solutions)))
for i in solutions:
class TestSudokuBoard(unittest.TestCase):
def setUp(self):
self.sudokuBoard = SudokuBoard()
# Init the object
def test_initAllToNone(self):
self.setUp()
vals = []
for k in range(81):
vals.append(self.sudokuBoard.baseData[k])
#self.assertIsInstance(self.sudokuBoard.baseData[0], NoneType)
self.assertTrue(all(vals[0] == item for item in vals))
def test_startAtVer0(self):
self.setUp()
self.assertEqual(self.sudokuBoard.version, 0)
# Get the value
def test_getDigitIndexIsInt(self):
with self.assertRaises(TypeError):
self.sudokuBoard.getDigit("string")
def test_getDigitIndexMin(self):
with self.assertRaises(ValueError):
self.sudokuBoard.getDigit(-1)
def test_getDigitIndexMax(self):
with self.assertRaises(ValueError):
self.sudokuBoard.getDigit(81)
def test_getDigitIndexWork(self):
index = 5
value = 5
self.sudokuBoard.baseData[index] = value
self.assertEqual(self.sudokuBoard.getDigit(index), value)
def test_getDigitIndexRetNone(self):
self.setUp()
self.assertIsNone(self.sudokuBoard.getDigit(1))
def test_getDigitIndexRetInt(self):
index = 1
value = 1
self.sudokuBoard.baseData[index] = value
self.assertIsInstance(self.sudokuBoard.getDigit(index), int)
# Set the value
def test_setDigitIndexIsInt(self):
with self.assertRaises(TypeError):
self.sudokuBoard.setDigit(1, "string")
def test_setDigitValueIsInt(self):
with self.assertRaises(TypeError):
self.sudokuBoard.setDigit("string", 1)
def test_setDigitIndexMin(self):
with self.assertRaises(ValueError):
self.sudokuBoard.setDigit(1, -1)
def test_setDigitIndexMax(self):
with self.assertRaises(ValueError):
self.sudokuBoard.setDigit(1, 81)
def test_setDigitValueMin(self):
with self.assertRaises(ValueError):
self.sudokuBoard.setDigit(0, 1)
def test_setDigitValueMax(self):
with self.assertRaises(ValueError):
self.sudokuBoard.setDigit(10, 1)
def test_setDigitValueSet(self):
index = 1
value = 2
self.sudokuBoard.setDigit(value, index)
self.assertEqual(self.sudokuBoard.baseData[index], value)
def test_setDigitVerIncr(self):
verOld = self.sudokuBoard.version
self.sudokuBoard.setDigit(1, 1)
self.assertTrue(self.sudokuBoard.version > verOld)
# Get row
def test_getRowNumIsInt(self):
with self.assertRaises(TypeError):
for i in self.sudokuBoard.getRow("string"):
a = i
def test_getRowNumMin(self):
with self.assertRaises(ValueError):
for i in self.sudokuBoard.getRow(-1):
a = i
def test_getRowNumMax(self):
with self.assertRaises(ValueError):
for i in self.sudokuBoard.getRow(9):
a = i
def test_getRowReturnIter(self):
i = self.sudokuBoard.getRow(1)
iter(i)
# Get col
def test_getColNumIsInt(self):
with self.assertRaises(TypeError):
for i in self.sudokuBoard.getCol("string"):
a = i
def test_getColNumMin(self):
with self.assertRaises(ValueError):
for i in self.sudokuBoard.getCol(-1):
a = i
def test_getColNumMax(self):
with self.assertRaises(ValueError):
for i in self.sudokuBoard.getCol(9):
a = i
def test_getColReturnIter(self):
i = self.sudokuBoard.getCol(1)
iter(i)
# Get square
def test_getSqrNumIsInt(self):
with self.assertRaises(TypeError):
for i in self.sudokuBoard.getSqr("string"):
a = i
def test_getSqrNumMin(self):
with self.assertRaises(ValueError):
for i in self.sudokuBoard.getSqr(-1):
a = i
def test_getSqrNumMax(self):
with self.assertRaises(ValueError):
for i in self.sudokuBoard.getSqr(9):
a = i
def test_getSqrReturnIter(self):
i = self.sudokuBoard.getSqr(1)
iter(i)
def test_getSqrReturnVal(self):
self.sudokuBoard.clearBoard()
self.sudokuBoard.loadBoard('preloads/sudoku1.txt')
actual = list(i for i in self.sudokuBoard.getSqr(0))
expected = [None, None,None, 8, None, None, None, 4, 9]
self.assertTrue(actual == expected)
# Multitest for coords - index translation
def test_coordsFromIndexAgainstValue(self):
self.sudokuBoard.clearBoard()
self.sudokuBoard.loadBoard('preloads/sudoku1.txt')
for index in range(81):
valByIndex = self.sudokuBoard.getDigit(index)
coords = SudokuBoard.coordsFromIndex(index)
index2 = SudokuBoard.indexFromCoords(coords)
valByIndex2 = self.sudokuBoard.getDigit(index2)
self.assertTrue(valByIndex == valByIndex2)
# Validity test
def test_testGroup(self):
# Empty iterator
self.assertFalse(self.sudokuBoard.testGroup([]))
# Too short iterator
self.assertFalse(self.sudokuBoard.testGroup(range(5)))
# Too long iterator
self.assertFalse(self.sudokuBoard.testGroup(range(11)))
# Good length wrong numbers
self.assertFalse(self.sudokuBoard.testGroup(range(9)))
# Good length, some Nones
self.assertFalse(self.sudokuBoard.testGroup([1,2,3,4,5,6,7,8,None]))
# Valid group
self.assertTrue(self.sudokuBoard.testGroup(range(1,10)))
def test_indexFromCoords(self):
self.assertTrue(SudokuBoard.indexFromCoords((0,0)) == 0)
self.assertTrue(SudokuBoard.indexFromCoords((1,1)) == 10)
self.assertTrue(SudokuBoard.indexFromCoords((8,8)) == 80)
def test_squareFromCoords(self):
self.assertTrue(SudokuBoard.squareFromCoords((0,0)) == 0)
self.assertTrue(SudokuBoard.squareFromCoords((4,1)) == 1)
self.assertTrue(SudokuBoard.squareFromCoords((8,2)) == 2)
self.assertTrue(SudokuBoard.squareFromCoords((0,3)) == 3)
self.assertTrue(SudokuBoard.squareFromCoords((4,4)) == 4)
self.assertTrue(SudokuBoard.squareFromCoords((8,5)) == 5)
self.assertTrue(SudokuBoard.squareFromCoords((0,6)) == 6)
self.assertTrue(SudokuBoard.squareFromCoords((4,7)) == 7)
self.assertTrue(SudokuBoard.squareFromCoords((8,8)) == 8)
