/** * Load puzzle from provided puzzle examples. * @see SudokuPuzzles * @see SudokuStore#getPuzzleExample(int) */ private void loadFromExample() { JanetConsole.println(); JanetConsole.print("Please provide example number (between 0 and " + (SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES - 1) + "): "); int example = JanetConsole.readInt(); if ((example >= 0) && (example < SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES)) { JanetConsole.println("Loading example: " + example); trackPuzzleUndo(); puzzle = SudokuStore.boardCopy(SudokuStore.getPuzzleExample(example)); } else { JanetConsole.println(">>> !!! Incorrect example number !!! <<<"); } }
/** * Default constructor based on puzzle example. * * @param example Example number between 0 and {@link SudokuPuzzles#NUMBER_OF_PUZZLE_EXAMPLES}. * @param parameters Optional parameters. * * @see #PARAM_DO_NOT_SOLVE * @see #PARAM_DO_NOT_TRANSFORM * @see #PARAM_GEN_RND_BOARD */ public SudokuGenerator(int example, params char[] parameters) { setParameters(parameters); initInternalVars(); if ((example >= 0) && (example < SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES)) { int[,] board = SudokuStore.boardCopy(SudokuStore.getPuzzleExample(example)); if (transformBeforeGeneration == true) { boardInit(SudokuStore.seqOfRandomBoardTransf(board), "transformed example: " + example); } else { boardInit(board, "example: " + example); } } else { generatorState = GENERATOR_INIT_FAILED; addMessage("(SudokuGenerator) Generator not initialized incorrect example number: " + example + " - should be between 1 and " + SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES + ".", MSG_ERROR); } }
/** * Default constructor based on random Sudoku puzzle example. * * @param parameters Optional parameters. * * @see #PARAM_DO_NOT_SOLVE * @see #PARAM_DO_NOT_TRANSFORM * @see #PARAM_GEN_RND_BOARD */ public SudokuGenerator(params char[] parameters) { setParameters(parameters); initInternalVars(); if (generateRandomBoard == true) { boardInit(null, "random board"); } else { int example = SudokuStore.randomIndex(SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES); int[,] board = SudokuStore.boardCopy(SudokuStore.getPuzzleExample(example)); if (transformBeforeGeneration == true) { boardInit(SudokuStore.seqOfRandomBoardTransf(board), "transformed example: " + example); } else { boardInit(board, "example: " + example); } } }
/** * Test scenario implementation. * @param testId Test id. * @param threadId Thread id. * @return True is test successful, otherwise false. */ static bool runTest(int testId, int threadId) { SudokuSolver s; int sol; int solNum; int solUnq; int solvingState; int boardState; int[,] solution; int[,] puzzle; bool solCorr; bool testResult = true; switch (testId) { case 0: for (int example = 0; example < SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES; example++) { s = new SudokuSolver(example); solNum = s.findAllSolutions(); ErrorCodes.consolePrintlnIfError(solNum); if (solNum != 1) { testResult = false; } SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", findAllSolutions, example: " + example + ", solutions: " + solNum + ", time: " + s.getComputingTime() + " s."); } break; case 1: for (int example = 0; example < SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES; example++) { s = new SudokuSolver(example); solUnq = s.checkIfUniqueSolution(); ErrorCodes.consolePrintlnIfError(solUnq); if (solUnq != SudokuSolver.SOLUTION_UNIQUE) { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", checkIfUniqueSolution, example: " + example + ", is solution unique: NO, time: " + s.getComputingTime() + " s."); } else { SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", checkIfUniqueSolution, example: " + example + ", is solution unique: YES, time: " + s.getComputingTime() + " s."); } } break; case 2: for (int example = 0; example < SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES; example++) { s = new SudokuSolver(example); sol = s.solve(); ErrorCodes.consolePrintlnIfError(sol); solution = s.getSolvedBoard(); solCorr = SudokuStore.checkSolvedBoard(solution); if (solCorr != true) { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", solve, example: " + example + ", is solution correct: NO, time: " + s.getComputingTime() + " s."); } else { SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", solve, example: " + example + ", is solution correct: YES, time: " + s.getComputingTime() + " s."); } } break; case 3: for (int example = 0; example < SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES; example++) { puzzle = SudokuStore.seqOfRandomBoardTransf(SudokuStore.getPuzzleExample(example)); s = new SudokuSolver(puzzle); solNum = s.findAllSolutions(); ErrorCodes.consolePrintlnIfError(solNum); if (solNum != 1) { testResult = false; } SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", seqOfRandomBoardTransf + findAllSolutions, example: " + example + ", solutions: " + solNum + ", time: " + s.getComputingTime() + " s."); } break; case 4: for (int example = 0; example < SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES; example++) { puzzle = SudokuStore.seqOfRandomBoardTransf(SudokuStore.getPuzzleExample(example)); s = new SudokuSolver(puzzle); solUnq = s.checkIfUniqueSolution(); ErrorCodes.consolePrintlnIfError(solUnq); if (solUnq != SudokuSolver.SOLUTION_UNIQUE) { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", seqOfRandomBoardTransf + checkIfUniqueSolution, example: " + example + ", is solution unique: NO, time: " + s.getComputingTime() + " s."); } else { SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", seqOfRandomBoardTransf + checkIfUniqueSolution, example: " + example + ", is solution unique: YES, time: " + s.getComputingTime() + " s."); } } break; case 5: for (int example = 0; example < SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES; example++) { puzzle = SudokuStore.seqOfRandomBoardTransf(SudokuStore.getPuzzleExample(example)); s = new SudokuSolver(puzzle); sol = s.solve(); ErrorCodes.consolePrintlnIfError(sol); solution = s.getSolvedBoard(); solCorr = SudokuStore.checkSolvedBoard(solution); if (solCorr != true) { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", seqOfRandomBoardTransf + solve, example: " + example + ", is solution correct: NO, time: " + s.getComputingTime() + " s."); } else { SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", seqOfRandomBoardTransf + solve, example: " + example + ", is solution correct: YES, time: " + s.getComputingTime() + " s."); } } break; case 6: s = new SudokuSolver(SudokuPuzzles.PUZZLE_NON_UNIQUE_SOLUTION); solNum = s.findAllSolutions(); ErrorCodes.consolePrintlnIfError(solNum); if (solNum <= 1) { testResult = false; } SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", findAllSolutions, example: non unique, solutions: " + solNum + ", time: " + s.getComputingTime() + " s."); break; case 7: s = new SudokuSolver(SudokuPuzzles.PUZZLE_NON_UNIQUE_SOLUTION); solUnq = s.checkIfUniqueSolution(); ErrorCodes.consolePrintlnIfError(solUnq); if (solUnq != SudokuSolver.SOLUTION_NON_UNIQUE) { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", checkIfUniqueSolution, example: non unique, is solution unique: YES, time: " + s.getComputingTime() + " s."); } else { SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", checkIfUniqueSolution, example: non unique, is solution unique: NO, time: " + s.getComputingTime() + " s."); } break; case 8: s = new SudokuSolver(SudokuPuzzles.PUZZLE_NON_UNIQUE_SOLUTION); sol = s.solve(); ErrorCodes.consolePrintlnIfError(sol); solution = s.getSolvedBoard(); solCorr = SudokuStore.checkSolvedBoard(solution); if (solCorr != true) { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", solve, example: non unique, is solution correct: NO, time: " + s.getComputingTime() + " s."); } else { SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", solve, example: non unique, is solution correct: YES, time: " + s.getComputingTime() + " s."); } break; case 9: puzzle = SudokuStore.seqOfRandomBoardTransf(SudokuPuzzles.PUZZLE_NON_UNIQUE_SOLUTION); s = new SudokuSolver(puzzle); solNum = s.findAllSolutions(); ErrorCodes.consolePrintlnIfError(solNum); if (solNum <= 1) { testResult = false; } SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", seqOfRandomBoardTransf + findAllSolutions, example: non unique, solutions: " + solNum + ", time: " + s.getComputingTime() + " s."); break; case 10: puzzle = SudokuStore.seqOfRandomBoardTransf(SudokuPuzzles.PUZZLE_NON_UNIQUE_SOLUTION); s = new SudokuSolver(puzzle); solUnq = s.checkIfUniqueSolution(); ErrorCodes.consolePrintlnIfError(solUnq); if (solUnq != SudokuSolver.SOLUTION_NON_UNIQUE) { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", seqOfRandomBoardTransf + checkIfUniqueSolution, example: non unique, is solution unique: YES, time: " + s.getComputingTime() + " s."); } else { SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", seqOfRandomBoardTransf + checkIfUniqueSolution, example: non unique, is solution unique: NO, time: " + s.getComputingTime() + " s."); } break; case 11: puzzle = SudokuStore.seqOfRandomBoardTransf(SudokuPuzzles.PUZZLE_NON_UNIQUE_SOLUTION); s = new SudokuSolver(puzzle); sol = s.solve(); ErrorCodes.consolePrintlnIfError(sol); solution = s.getSolvedBoard(); solCorr = SudokuStore.checkSolvedBoard(solution); if (solCorr != true) { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", seqOfRandomBoardTransf + solve, example: non unique, is solution correct: NO, time: " + s.getComputingTime() + " s."); } else { SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", seqOfRandomBoardTransf + solve, example: non unique, is solution correct: YES, time: " + s.getComputingTime() + " s."); } break; case 12: s = new SudokuSolver(SudokuPuzzles.PUZZLE_NO_SOLUTION); solNum = s.findAllSolutions(); ErrorCodes.consolePrintlnIfError(solNum); if (solNum != 0) { testResult = false; } SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", findAllSolutions, example: no solution, solutions: " + solNum + ", time: " + s.getComputingTime() + " s."); break; case 13: s = new SudokuSolver(SudokuPuzzles.PUZZLE_NO_SOLUTION); solUnq = s.checkIfUniqueSolution(); ErrorCodes.consolePrintlnIfError(solUnq); if (solUnq == SudokuSolver.SOLUTION_NOT_EXISTS) { SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", checkIfUniqueSolution, example: no solution, no solutions found: YES, time: " + s.getComputingTime() + " s."); } else { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", checkIfUniqueSolution, example: no solution, no solutions found: NO, time: " + s.getComputingTime() + " s."); } break; case 14: s = new SudokuSolver(SudokuPuzzles.PUZZLE_NO_SOLUTION); sol = s.solve(); solution = s.getSolvedBoard(); if (s.getSolvingState() == ErrorCodes.SUDOKUSOLVER_SOLVE_SOLVING_FAILED) { SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", solve, example: no solution, solving failed: YES, time: " + s.getComputingTime() + " s."); } else { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", solve, example: no solution, solving failed: NO, time: " + s.getComputingTime() + " s."); } break; case 15: s = new SudokuSolver(SudokuPuzzles.PUZZLE_ERROR); solvingState = s.solve(); boardState = s.getBoardState(); if ((boardState == SudokuBoard.BOARD_STATE_ERROR) && (solvingState == ErrorCodes.SUDOKUSOLVER_SOLVE_SOLVING_NOT_STARTED)) { SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", solve, example: board with error, board state error and solving not started: YES, time: " + s.getComputingTime() + " s."); } else { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", solve, example: board with error, board state error and solving not started: NO, time: " + s.getComputingTime() + " s."); } break; case 16: s = new SudokuSolver(SudokuPuzzles.PUZZLE_REGTESTS); sol = s.solve(); ErrorCodes.consolePrintlnIfError(sol); if (SudokuStore.boardsAreEqual(s.getSolvedBoard(), SudokuPuzzles.PUZZLE_REGTESTS_SOLUTION)) { SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", solve, example: with solution, solutions are equal: YES, time: " + s.getComputingTime() + " s."); } else { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", solve, example: with solution, solutions are equal: NO, time: " + s.getComputingTime() + " s."); } break; case 17: s = new SudokuSolver(SudokuPuzzles.PUZZLE_EMPTY); sol = s.solve(); solUnq = s.checkIfUniqueSolution(); ErrorCodes.consolePrintlnIfError(sol); ErrorCodes.consolePrintlnIfError(solUnq); if ((SudokuStore.checkSolvedBoard(s.getSolvedBoard()) == true) & (solUnq == SudokuSolver.SOLUTION_NON_UNIQUE)) { SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", solve, example: empty puzzle, found solution and solution non unique: YES, time: " + s.getComputingTime() + " s."); } else { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", solve, example: empty puzzle, found solution and solution non unique: NO, time: " + s.getComputingTime() + " s."); } break; } if (testResult == true) { SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + " >>>>>>>>>>>>>>>>>>>>>> SudokuSolver, result: OK"); } else { SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + " >>>>>>>>>>>>>>>>>>>>>> SudokuSolver, result: ERROR"); } return(testResult); }
/** * Test scenario implementation. * @param testId Test id. * @param threadId Thread id. * @return True is test successful, otherwise false. */ static bool runTest(int testId, int threadId) { SudokuSolver solverGen, solverInit; SudokuGenerator g; int solUnq; int[,] genPuzzle; int[,] solvedGen, solvedInit, initBoard; bool testResult = true; switch (testId) { case 0: for (int example = 0; example < SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES; example++) { g = new SudokuGenerator(example, SudokuGenerator.PARAM_DO_NOT_TRANSFORM); genPuzzle = g.generate(); solverGen = new SudokuSolver(genPuzzle); ErrorCodes.consolePrintlnIfError(solverGen.solve()); solverInit = new SudokuSolver(example); ErrorCodes.consolePrintlnIfError(solverInit.solve()); solUnq = solverGen.checkIfUniqueSolution(); ErrorCodes.consolePrintlnIfError(solUnq); solvedGen = solverGen.getSolvedBoard(); solvedInit = solverInit.getSolvedBoard(); if ((solUnq == SudokuSolver.SOLUTION_UNIQUE) && (SudokuStore.boardsAreEqual(solvedGen, solvedInit) == true)) { //SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example number, example: " + example + ", solution unique and correct: YES, time (g, s1, s2): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., " + solverInit.getComputingTime() + " s."); } else { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example number, example: " + example + ", solution unique and correct: NO, time (g, s1, s2): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., " + solverInit.getComputingTime() + " s."); Console.WriteLine("Initial board"); SudokuStore.consolePrintBoard(SudokuStore.getPuzzleExample(example)); Console.WriteLine("Generated puzzle"); SudokuStore.consolePrintBoard(genPuzzle); Console.WriteLine("Solved initial board"); SudokuStore.consolePrintBoard(solvedInit); Console.WriteLine("Solved generated puzzle"); SudokuStore.consolePrintBoard(solvedGen); } } break; case 1: for (int example = 0; example < SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES; example++) { initBoard = SudokuStore.getPuzzleExample(example); g = new SudokuGenerator(initBoard, SudokuGenerator.PARAM_DO_NOT_TRANSFORM, SudokuGenerator.PARAM_DO_NOT_SOLVE); genPuzzle = g.generate(); solverGen = new SudokuSolver(genPuzzle); ErrorCodes.consolePrintlnIfError(solverGen.solve()); solverInit = new SudokuSolver(initBoard); ErrorCodes.consolePrintlnIfError(solverInit.solve()); solUnq = solverGen.checkIfUniqueSolution(); ErrorCodes.consolePrintlnIfError(solUnq); solvedGen = solverGen.getSolvedBoard(); solvedInit = solverInit.getSolvedBoard(); if ((solUnq == SudokuSolver.SOLUTION_UNIQUE) && (SudokuStore.boardsAreEqual(solvedGen, solvedInit) == true)) { //SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example board, example: " + example + ", solution unique and correct: YES, time (g, s1, s2): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., " + solverInit.getComputingTime() + " s."); } else { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example board, example: " + example + ", solution unique and correct: NO, time (g, s1, s2): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., " + solverInit.getComputingTime() + " s."); Console.WriteLine("Initial board"); SudokuStore.consolePrintBoard(initBoard); Console.WriteLine("Generated puzzle"); SudokuStore.consolePrintBoard(genPuzzle); Console.WriteLine("Solved initial board"); SudokuStore.consolePrintBoard(solvedInit); Console.WriteLine("Solved generated puzzle"); SudokuStore.consolePrintBoard(solvedGen); } } break; case 2: for (int example = 0; example < SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES; example++) { g = new SudokuGenerator(example); genPuzzle = g.generate(); solverGen = new SudokuSolver(genPuzzle); ErrorCodes.consolePrintlnIfError(solverGen.solve()); solUnq = solverGen.checkIfUniqueSolution(); ErrorCodes.consolePrintlnIfError(solUnq); solvedGen = solverGen.getSolvedBoard(); if ((solUnq == SudokuSolver.SOLUTION_UNIQUE) && (SudokuStore.checkPuzzle(genPuzzle) == true)) { //SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example number, example: " + example + ", solution unique and correct: YES, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., "); } else { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example number, example: " + example + ", solution unique and correct: NO, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., "); Console.WriteLine("Generated puzzle"); SudokuStore.consolePrintBoard(genPuzzle); Console.WriteLine("Solved generated puzzle"); SudokuStore.consolePrintBoard(solvedGen); } } break; case 3: for (int example = 0; example < SudokuPuzzles.NUMBER_OF_PUZZLE_EXAMPLES; example++) { initBoard = SudokuStore.getPuzzleExample(example); g = new SudokuGenerator(initBoard, SudokuGenerator.PARAM_DO_NOT_SOLVE); genPuzzle = g.generate(); solverGen = new SudokuSolver(genPuzzle); ErrorCodes.consolePrintlnIfError(solverGen.solve()); solUnq = solverGen.checkIfUniqueSolution(); ErrorCodes.consolePrintlnIfError(solUnq); solvedGen = solverGen.getSolvedBoard(); if ((solUnq == SudokuSolver.SOLUTION_UNIQUE) && (SudokuStore.checkPuzzle(genPuzzle) == true)) { //SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example board, example: " + example + ", solution unique and correct: YES, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., "); } else { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by example board, example: " + example + ", solution unique and correct: NO, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., "); Console.WriteLine("Generated puzzle"); SudokuStore.consolePrintBoard(genPuzzle); Console.WriteLine("Solved initial board"); SudokuStore.consolePrintBoard(solvedGen); } } break; case 5: initBoard = SudokuPuzzles.PUZZLE_EMPTY; g = new SudokuGenerator(initBoard); genPuzzle = g.generate(); solverGen = new SudokuSolver(genPuzzle); ErrorCodes.consolePrintlnIfError(solverGen.solve()); solUnq = solverGen.checkIfUniqueSolution(); ErrorCodes.consolePrintlnIfError(solUnq); solvedGen = solverGen.getSolvedBoard(); if ((solUnq == SudokuSolver.SOLUTION_UNIQUE) && (SudokuStore.checkPuzzle(genPuzzle) == true)) { //SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by empty board, solution unique and correct: YES, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., "); } else { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by empty board, solution unique and correct: NO, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., "); Console.WriteLine("Generated puzzle"); SudokuStore.consolePrintBoard(genPuzzle); Console.WriteLine("Solved initial board"); SudokuStore.consolePrintBoard(solvedGen); } break; case 6: initBoard = SudokuPuzzles.PUZZLE_EMPTY; g = new SudokuGenerator(initBoard, SudokuGenerator.PARAM_DO_NOT_SOLVE); if (g.getGeneratorState() == SudokuGenerator.GENERATOR_INIT_FAILED) { SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by empty board, solution unique and correct: YES, time (g, s): "); } else { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by empty board, solution unique and correct: NO, time (g, s): "); SudokuStore.consolePrintln("Generator state: " + g.getGeneratorState()); Console.WriteLine(g.getMessages()); } break; case 7: initBoard = SudokuPuzzles.PUZZLE_ERROR; g = new SudokuGenerator(initBoard, SudokuGenerator.PARAM_DO_NOT_SOLVE); if (g.getGeneratorState() == SudokuGenerator.GENERATOR_INIT_FAILED) { SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by PUZZLE_ERROR + PARAM_DO_NOT_SOLVE, init failed: YES."); } else { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by PUZZLE_ERROR + PARAM_DO_NOT_SOLVE, init failed: NO."); SudokuStore.consolePrintln("Generator state: " + g.getGeneratorState()); Console.WriteLine(g.getMessages()); } break; case 8: initBoard = SudokuPuzzles.PUZZLE_NON_UNIQUE_SOLUTION; g = new SudokuGenerator(initBoard); genPuzzle = g.generate(); solverGen = new SudokuSolver(genPuzzle); ErrorCodes.consolePrintlnIfError(solverGen.solve()); solUnq = solverGen.checkIfUniqueSolution(); ErrorCodes.consolePrintlnIfError(solUnq); solvedGen = solverGen.getSolvedBoard(); if ((solUnq == SudokuSolver.SOLUTION_UNIQUE) && (SudokuStore.checkPuzzle(genPuzzle) == true)) { //SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by empty board, solution unique and correct: YES, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., "); } else { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by empty board, solution unique and correct: NO, time (g, s): " + g.getComputingTime() + " s., " + solverGen.getComputingTime() + " s., "); Console.WriteLine("Generated puzzle"); SudokuStore.consolePrintBoard(genPuzzle); Console.WriteLine("Solved initial board"); SudokuStore.consolePrintBoard(solvedGen); } break; case 9: initBoard = SudokuPuzzles.PUZZLE_NON_UNIQUE_SOLUTION; g = new SudokuGenerator(initBoard, SudokuGenerator.PARAM_DO_NOT_SOLVE); if (g.getGeneratorState() == SudokuGenerator.GENERATOR_INIT_FAILED) { SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by PUZZLE_NON_UNIQUE_SOLUTION + PARAM_DO_NOT_SOLVE, init failed: YES."); } else { testResult = false; SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + ", generate by PUZZLE_NON_UNIQUE_SOLUTION + PARAM_DO_NOT_SOLVE, init failed: NO."); SudokuStore.consolePrintln("Generator state: " + g.getGeneratorState()); Console.WriteLine(g.getMessages()); } break; } if (testResult == true) { SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + " >>>>>>>>>>>>>>>>>>>>>> SudokuGenerator, result: OK"); } else { SudokuStore.consolePrintln("(Thread: " + threadId + ") " + "Test: " + testId + " >>>>>>>>>>>>>>>>>>>>>> SudokuGenerator, result: ERROR"); } return(testResult); }
/** * Test scenario implementation. * @param testId Test id. * @param threadId Thread id. * @return True is test successful, otherwise false. */ static bool runTest(int testId, int threadId) { bool 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(); foreach (BoardCell bc in 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(); foreach (BoardCell cell in 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(); List <SudokuBoard> solList; solList = s.getAllSolutionsList(); foreach (SudokuBoard sb in 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); }
/** * Start the Janet-Sudoku Tutorial code. * @param args No arguments are considered. */ public static void Start() { String tmpDir = FileX.getTmpDir(); { /* * Simple sudoku generation. */ SudokuStore.consolePrintln(""); SudokuStore.consolePrintln("Simple sudoku generation."); SudokuGenerator sg = new SudokuGenerator(); int[,] puzzle = sg.generate(); SudokuStore.consolePrintBoard(puzzle); } { /* * Simple sudoku generation + parameters. */ SudokuStore.consolePrintln(""); SudokuStore.consolePrintln("Simple sudoku generation + parameters."); SudokuGenerator sg = new SudokuGenerator(SudokuGenerator.PARAM_GEN_RND_BOARD); int[,] puzzle = sg.generate(); SudokuStore.consolePrintBoard(puzzle); } { /* * Simple sudoku generation + puzzle rating. */ SudokuStore.consolePrintln(""); SudokuStore.consolePrintln("Simple sudoku generation + puzzle rating."); SudokuGenerator sg = new SudokuGenerator(); int[,] puzzle = sg.generate(); int rating = SudokuStore.calculatePuzzleRating(puzzle); SudokuStore.consolePrintBoard(puzzle); SudokuStore.consolePrintln("Puzzle rating: " + rating); } { /* * Solving sudoku example. */ SudokuStore.consolePrintln(""); SudokuStore.consolePrintln("Solving sudoku example."); SudokuSolver ss = new SudokuSolver(SudokuPuzzles.PUZZLE_EXAMPLE_001); SudokuStore.consolePrintBoard(ss.getBoard()); ss.solve(); SudokuStore.consolePrintBoard(ss.getSolvedBoard()); } { /* * Saving board examples */ SudokuStore.consolePrintln(""); SudokuStore.consolePrintln("Saving board examples " + tmpDir); SudokuStore.saveBoard(SudokuPuzzles.PUZZLE_EXAMPLE_001, tmpDir + "sudoku-board-ex-1.txt"); SudokuStore.saveBoard(SudokuPuzzles.PUZZLE_EXAMPLE_001, tmpDir + "sudoku-board-ex-2.txt", "This is a head comment"); SudokuStore.saveBoard(SudokuPuzzles.PUZZLE_EXAMPLE_001, tmpDir + "sudoku-board-ex-3.txt", "This is a head comment", "And a tail comment"); SudokuSolver ss = new SudokuSolver(1); ss.solve(); ss.saveSolvedBoard(tmpDir + "sudoku-board-ex-sol.txt", "Solution for the PUZZLE_EXAMPLE_001"); } { /* * Puzzle modification - i.e. rotation */ SudokuStore.consolePrintln("----------------------------------------------------"); SudokuStore.consolePrintln(">>>>>>>> Puzzle modification"); int[,] puzzle = SudokuStore.getPuzzleExample(0); int[,] puzzleRotated = SudokuStore.rotateClockWise(puzzle); SudokuStore.consolePrintBoard(puzzle); SudokuStore.consolePrintBoard(puzzleRotated); } /* * And many other staff provided by the library :-) */ }