public void Equals_WithEqualSolveStats_IsTrue(SolveStats a, SolveStats b)
{
Assert.Equal(a, b);
Assert.True(a.Equals(b));
Assert.True(a == b);
Assert.False(a != b);
}
public void ToString_IsCorrect()
{
var stats = new SolveStats()
{
NumSolutionsFound = 1, NumSquaresGuessed = 2, NumTotalGuesses = 3
};
Assert.Equal("NumSolutionsFound: 1, NumSquaresGuessed: 2, NumTotalGuesses: 3", stats.ToString());
}
public void ComputeStatsForAllSolutions_WithoutHeuristics_ReturnsExpectedResults(
int?[][] matrix, SolveStats expectedStats)
{
// Skip heuristics so the stats are easy to fully define.
var ruleKeeper = new StandardRuleKeeper();
var solver = new PuzzleSolver <PuzzleWithPossibleValues>(ruleKeeper);
Assert.Equal(expectedStats, solver.ComputeStatsForAllSolutions(new PuzzleWithPossibleValues(matrix)));
}
public void Generate_CreatesPuzzleWithUniqueSolution(int size, int numToSet)
{
var generator = new StandardPuzzleGenerator();
PuzzleWithPossibleValues puzzle = generator.Generate(size, numToSet, TimeSpan.FromSeconds(60));
Assert.Equal(size * size - numToSet, puzzle.NumEmptySquares);
var solver = StandardPuzzles.CreateSolver();
SolveStats stats = solver.ComputeStatsForAllSolutions(puzzle);
Assert.Equal(1, stats.NumSolutionsFound);
}
public void Generate_CreatesPuzzleWithUniqueSolution(int size, int numToSet)
{
var generator = new PuzzleGenerator <Puzzle>(
() => new Puzzle(size), puzzle => new PuzzleSolver(puzzle));
Puzzle puzzle = generator.Generate(numToSet, TimeSpan.FromSeconds(60));
Assert.Equal(size * size - numToSet, puzzle.NumEmptySquares);
var solver = new PuzzleSolver(puzzle);
SolveStats stats = solver.GetStatsForAllSolutions();
Assert.Equal(1, stats.NumSolutionsFound);
}
public void ComputeStatsForAllSolutions_WithHeuristics_ReturnsExpectedNumSolutions(
int?[][] matrix, SolveStats expectedStats)
{
var ruleKeeper = new StandardRuleKeeper();
IRule rule = ruleKeeper.GetRules()[0];
var heuristics = new StandardHeuristic(
(IMissingRowValuesTracker)rule,
(IMissingColumnValuesTracker)rule, (IMissingBoxValuesTracker)rule);
var solver = new PuzzleSolver <PuzzleWithPossibleValues>(ruleKeeper, heuristics);
Assert.Equal(
expectedStats.NumSolutionsFound,
solver.ComputeStatsForAllSolutions(new PuzzleWithPossibleValues(matrix)).NumSolutionsFound);
}
private static SolveStats _TryAllSolutionsWithGuess(
SquareTracker tracker,
Coordinate c,
List <int> valuesToGuess)
{
var solveStats = new SolveStats();
for (int i = 0; i < valuesToGuess.Count - 1; i++)
{
var trackerCopy = new SquareTracker(tracker);
if (trackerCopy.TrySet(in c, valuesToGuess[i]))
{
SolveStats guessStats = _TryAllSolutions(trackerCopy);
solveStats.NumSolutionsFound += guessStats.NumSolutionsFound;
solveStats.NumSquaresGuessed += guessStats.NumSquaresGuessed;
solveStats.NumTotalGuesses += guessStats.NumTotalGuesses;
}
}
if (tracker.TrySet(in c, valuesToGuess[^ 1]))
public void Generate_CreatesPuzzleWithUniqueSolution(int size, int numToSet)
{
var generator = new PuzzleGenerator <Puzzle>(
size => new Puzzle(size),
new PuzzleSolver <Puzzle>(
new IConstraint[] {
new RowUniquenessConstraint(),
new ColumnUniquenessConstraint(),
new BoxUniquenessConstraint()
}));
Puzzle puzzle = generator.Generate(size, numToSet, TimeSpan.FromSeconds(60));
Assert.Equal(size * size - numToSet, puzzle.NumEmptySquares);
var solver = RuleBased.StandardPuzzles.CreateSolver();
SolveStats stats = solver.ComputeStatsForAllSolutions(new RuleBased.PuzzleWithPossibleValues(puzzle));
Assert.Equal(1, stats.NumSolutionsFound);
}
public void GetStatsForAllSolutions_WithoutHeuristics_ReturnsExpectedResults(Puzzle puzzle, SolveStats expectedStats)
{
// Skip heuristics so the stats are easy to fully define.
var possibleValues = new PossibleValues(puzzle);
var ruleKeeper = new StandardRuleKeeper(puzzle, possibleValues);
var solver = new PuzzleSolver(puzzle, possibleValues, ruleKeeper);
Assert.Equal(expectedStats, solver.GetStatsForAllSolutions());
}
public void GetStatsForAllSolutions_WithHeuristics_ReturnsExpectedNumSolutions(Puzzle puzzle, SolveStats expectedStats)
{
var possibleValues = new PossibleValues(puzzle);
var ruleKeeper = new StandardRuleKeeper(puzzle, possibleValues);
ISudokuRule rule = ruleKeeper.GetRules()[0];
var heuristics = new StandardHeuristic(
puzzle, possibleValues, (IMissingRowValuesTracker)rule,
(IMissingColumnValuesTracker)rule, (IMissingBoxValuesTracker)rule);
var solver = new PuzzleSolver(puzzle, possibleValues, ruleKeeper, heuristics);
Assert.Equal(expectedStats.NumSolutionsFound, solver.GetStatsForAllSolutions().NumSolutionsFound);
}
public void Equals_WithObject_IsCorrect(SolveStats stats, object other, bool isEqual) => Assert.Equal(isEqual, stats.Equals(other));
