/** * Runs SudokuStore regression tests. * * @param threadsNumber Number of threads. * @return Number of tests with errors. */ public static int start(int threadsNumber) { int numberOfTests = ApiTests.NUMBER_OF_TESTS; int resultsError = 0; int resultsOk = 0; long startTime = DateTimeX.currentTimeMillis(); ApiTests at = new ApiTests(threadsNumber); at.start(); boolean[] testResults = at.testsResults; for (int t = 0; t < numberOfTests; t++) { if (testResults[t] == true) resultsOk++; else resultsError++; } long endtTime = DateTimeX.currentTimeMillis(); double computingTime = (endtTime - startTime) / 1000.0; SudokuStore.consolePrintln("============================================================="); SudokuStore.consolePrintln( "Number of API test: " + numberOfTests + ", OK: " + resultsOk + ", ERRORS: " + resultsError + ", computing time: " + computingTime); for (int t = 0; t < numberOfTests; t++) if (testResults[t] == false) SudokuStore.consolePrintln("ERROR: " + t); SudokuStore.consolePrintln("============================================================="); return resultsError; }
/** * Default constructor. * * @param threadsNumber Threads number. */ ApiTests(int threadsNumber) { THREADS_NUMBER = threadsNumber; threads = new Thread[THREADS_NUMBER]; runners = new TestRunner[THREADS_NUMBER]; testsResults = new boolean[NUMBER_OF_TESTS]; int[] testsIds = new int[NUMBER_OF_TESTS]; for (int i = 0; i < NUMBER_OF_TESTS; i++) testsIds[i] = i; /* * Randomization of tests before assignments to threads */ for (int i = 0; i < NUMBER_OF_TESTS; i++) { int lastIndex = NUMBER_OF_TESTS - i - 1; int j = SudokuStore.randomIndex(NUMBER_OF_TESTS - i); if (j != lastIndex) { int l = testsIds[lastIndex]; testsIds[lastIndex] = testsIds[j]; testsIds[j] = l; } } /* * Tests assignments to threads */ int defThreadSize = NUMBER_OF_TESTS / THREADS_NUMBER; int remaining = NUMBER_OF_TESTS - defThreadSize * THREADS_NUMBER; int t = 0; for (int i = 0; i < THREADS_NUMBER; i++) { int threadSize = defThreadSize; if (i < remaining) threadSize++; int[] assigments = new int[threadSize]; for (int j = 0; j < threadSize; j++) { assigments[j] = testsIds[t]; t++; } runners[i] = new TestRunner(i, assigments); threads[i] = new Thread(runners[i]); } }
/** * Test scenario implementation. * * @param testId Test id. * @param threadId Thread id. * @return True is test successful, otherwise false. */ static boolean runTest(int testId, int threadId) { boolean testResult = true; String testDesc = "", resultDesc = ""; int[][] a = { {0, 0, 0, 8, 0, 0, 0, 0, 0}, {4, 0, 0, 0, 1, 5, 0, 3, 0}, {0, 2, 9, 0, 4, 0, 5, 1, 8}, {0, 4, 0, 0, 0, 0, 1, 2, 0}, {0, 0, 0, 6, 0, 2, 0, 0, 0}, {0, 3, 2, 0, 0, 0, 0, 9, 0}, {6, 9, 3, 0, 5, 0, 8, 7, 0}, {0, 5, 0, 4, 8, 0, 0, 0, 1}, {0, 0, 0, 0, 0, 3, 0, 0, 0} }; switch (testId) { case 0: testDesc = "SudokuSolver.setCell(int, int, int)"; { SudokuSolver s = new SudokuSolver(); s.setCell(0, 0, 0); s.setCell(1, 0, 4); s.setCell(2, 0, 0); s.setCell(3, 0, 0); s.setCell(4, 0, 0); s.setCell(5, 0, 0); s.setCell(6, 0, 6); s.setCell(7, 0, 0); s.setCell(8, 0, 0); s.setCell(0, 1, 0); s.setCell(1, 1, 0); s.setCell(2, 1, 2); s.setCell(3, 1, 4); s.setCell(4, 1, 0); s.setCell(5, 1, 3); s.setCell(6, 1, 9); s.setCell(7, 1, 5); s.setCell(8, 1, 0); s.setCell(0, 2, 0); s.setCell(1, 2, 0); s.setCell(2, 2, 9); s.setCell(3, 2, 0); s.setCell(4, 2, 0); s.setCell(5, 2, 2); s.setCell(6, 2, 3); s.setCell(7, 2, 0); s.setCell(8, 2, 0); s.setCell(0, 3, 8); s.setCell(1, 3, 0); s.setCell(2, 3, 0); s.setCell(3, 3, 0); s.setCell(4, 3, 6); s.setCell(5, 3, 0); s.setCell(6, 3, 0); s.setCell(7, 3, 4); s.setCell(8, 3, 0); s.setCell(0, 4, 0); s.setCell(1, 4, 1); s.setCell(2, 4, 4); s.setCell(3, 4, 0); s.setCell(4, 4, 0); s.setCell(5, 4, 0); s.setCell(6, 4, 5); s.setCell(7, 4, 8); s.setCell(8, 4, 0); s.setCell(0, 5, 0); s.setCell(1, 5, 5); s.setCell(2, 5, 0); s.setCell(3, 5, 0); s.setCell(4, 5, 2); s.setCell(5, 5, 0); s.setCell(6, 5, 0); s.setCell(7, 5, 0); s.setCell(8, 5, 3); s.setCell(0, 6, 0); s.setCell(1, 6, 0); s.setCell(2, 6, 5); s.setCell(3, 6, 1); s.setCell(4, 6, 0); s.setCell(5, 6, 0); s.setCell(6, 6, 8); s.setCell(7, 6, 0); s.setCell(8, 6, 0); s.setCell(0, 7, 0); s.setCell(1, 7, 3); s.setCell(2, 7, 1); s.setCell(3, 7, 2); s.setCell(4, 7, 0); s.setCell(5, 7, 9); s.setCell(6, 7, 7); s.setCell(7, 7, 0); s.setCell(8, 7, 0); s.setCell(0, 8, 0); s.setCell(1, 8, 0); s.setCell(2, 8, 8); s.setCell(3, 8, 0); s.setCell(4, 8, 0); s.setCell(5, 8, 0); s.setCell(6, 8, 0); s.setCell(7, 8, 1); s.setCell(8, 8, 0); int[][] b = s.getBoard(); if ((SudokuStore.boardsAreEqual(a, b) == true)) { resultDesc = "Expecting equal - are equal."; } else { resultDesc = "Expecting equal - are not equal."; testResult = false; SudokuStore.consolePrintln(s.getMessages()); } } break; case 1: testDesc = "SudokuSolver.getCellDigit(int, int)"; { SudokuSolver s1 = new SudokuSolver(a); SudokuSolver s2 = new SudokuSolver(); for (int i = 0; i < SudokuBoard.BOARD_SIZE; i++) for (int j = 0; j < SudokuBoard.BOARD_SIZE; j++) { int d = s1.getCellDigit(i, j); s2.setCell(i, j, d); } int[][] b = s2.getBoard(); if ((SudokuStore.boardsAreEqual(a, b) == true)) { resultDesc = "Expecting equal - are equal."; } else { resultDesc = "Expecting equal - are not equal."; testResult = false; } } break; case 2: testDesc = "SudokuSolver.getBoardCopy()"; { SudokuSolver s = new SudokuSolver(a); int[][] b = s.getBoard(); int[][] c = s.getBoardCopy(); if ((SudokuStore.boardsAreEqual(b, c) == true)) { resultDesc = "Expecting equal - are equal."; } else { resultDesc = "Expecting equal - are not equal."; testResult = false; } } break; case 3: testDesc = "SudokuSolver.getSolutionBoardCells()"; { SudokuSolver s = new SudokuSolver(a); s.solve(); int[][] b = s.getSolvedBoard(); int[][] c = SudokuStore.boardCopy(a); BoardCell[] sol = s.getSolutionBoardCells(); for (BoardCell bc : sol) c[bc.rowIndex][bc.colIndex] = bc.digit; if ((SudokuStore.boardsAreEqual(b, c) == true)) { resultDesc = "Expecting equal - are equal."; } else { resultDesc = "Expecting equal - are not equal."; testResult = false; } } break; case 4: testDesc = "SudokuSolver.getAllBoardCells()"; { SudokuSolver s = new SudokuSolver(a); int[][] b = s.getBoardCopy(); int[][] c = new int[SudokuBoard.BOARD_SIZE][SudokuBoard.BOARD_SIZE]; BoardCell[] bc = s.getAllBoardCells(); for (BoardCell cell : bc) { c[cell.rowIndex][cell.colIndex] = cell.digit; } if ((SudokuStore.boardsAreEqual(b, c) == true)) { resultDesc = "Expecting equal - are equal."; } else { resultDesc = "Expecting equal - are not equal."; testResult = false; } } break; case 5: testDesc = "SudokuSolver.getAllSolutionsList()"; { SudokuSolver s = new SudokuSolver(SudokuPuzzles.PUZZLE_NON_UNIQUE_SOLUTION); s.findAllSolutions(); ArrayList<SudokuBoard> solList; solList = s.getAllSolutionsList(); for (SudokuBoard sb : solList) { if (SudokuStore.checkSolvedBoard(sb.board) == false) { testResult = false; break; } } if (testResult == true) { resultDesc = "Expecting each solution valid - each is valid."; } else { resultDesc = "Expecting each solution valid - found not valid."; } } break; case 6: testDesc = "SudokuGenerator -> generate -> save -> load -> compare"; { String filePath = FileX.getTmpDir() + FileX.genRndFileName(20, "txt"); SudokuGenerator g = new SudokuGenerator(SudokuGenerator.PARAM_GEN_RND_BOARD); int[][] generated = g.generate(); g.saveBoard(filePath, "generated", "saved"); int[][] loaded = SudokuStore.loadBoard(filePath); FileX.removeFile(filePath); if (SudokuStore.boardsAreEqual(generated, loaded) == false) testResult = false; if (testResult == true) { resultDesc = "Expecting equal - are equal."; } else { resultDesc = "Expecting equal - are not equal."; } } break; case 7: testDesc = "SudokuSolver -> solve -> save -> load -> compare"; { String filePath = FileX.getTmpDir() + FileX.genRndFileName(20, "txt"); SudokuSolver s = new SudokuSolver(SudokuStore.getPuzzleExample()); s.solve(); int[][] solved = s.getSolvedBoard(); s.saveSolvedBoard(filePath, "solved", "saved"); int[][] loaded = SudokuStore.loadBoard(filePath); FileX.removeFile(filePath); if (SudokuStore.boardsAreEqual(solved, loaded) == false) testResult = false; if (testResult == true) { resultDesc = "Expecting equal - are equal."; } else { resultDesc = "Expecting equal - are not equal."; } } break; } if (testResult == true) SudokuStore.consolePrintln( "(Thread: " + threadId + ") " + "Test: " + testId + " " + testDesc + " " + resultDesc + " >>> ApiTests, result: OK"); else SudokuStore.consolePrintln( "(Thread: " + threadId + ") " + "Test: " + testId + " " + testDesc + " " + resultDesc + " >>> ApiTests, result: ERROR"); return testResult; }