Added tests for SingleStepSolution and SudokuFilePuzzleProvider.

SudokuFilePuzzleProvider now ignores lines which start with '#' and can read files where there is no separator between values.

Author: kurtanr

SimpleSudokuSolver.Tests/PuzzleProviders/SudokuFilePuzzleProviderTests.cs

@@ -0,0 +1,45 @@
+using NUnit.Framework;
+using SimpleSudokuSolver.Model;
+using SimpleSudokuSolver.PuzzleProviders;
+using System;
+using System.IO;
+
+namespace SimpleSudokuSolver.Tests.PuzzleProviders
+{
+  [TestFixture]
+  public class SudokuFilePuzzleProviderTests
+  {
+    [Test]
+    public void SudokuFilePuzzleProvider_ThrowsExceptionForEmptyPath_Test()
+    {
+      Assert.That(() => new SudokuFilePuzzleProvider(null), Throws.InstanceOf<ArgumentException>());
+      Assert.That(() => new SudokuFilePuzzleProvider(string.Empty), Throws.InstanceOf<ArgumentException>());
+    }
+
+    [Test]
+    public void SudokuFilePuzzleProvider_WorksWithAllFormats_Test()
+    {
+      var filePath = Path.GetTempFileName();
+      var separators = new[] { ",", " ", "\t", "" };
+      var sudoku = new int[9, 9];
+      sudoku[1, 2] = 5;
+
+      foreach(var separator in separators)
+      {
+        SaveSudokuUsingSeparator(sudoku, separator, filePath);
+        var provider = new SudokuFilePuzzleProvider(filePath);
+        var sudokuPuzzle = provider.GetPuzzle();
+        Assert.That(sudokuPuzzle[1, 2], Is.EqualTo(5));
+      }
+
+      File.Delete(filePath);
+    }
+
+    private void SaveSudokuUsingSeparator(int[,] sudoku, string separator, string filePath)
+    {
+      var sudokuToString = new SudokuPuzzle(sudoku).ToString();
+      var sudokuToStringWithSeparator = sudokuToString.Replace(" ", separator);
+      File.WriteAllText(filePath, sudokuToStringWithSeparator);
+    }
+  }
+}

SimpleSudokuSolver.Tests/SingleStepSolutionTests.cs

@@ -0,0 +1,60 @@
+using NUnit.Framework;
+using System;
+
+namespace SimpleSudokuSolver.Tests
+{
+  [TestFixture]
+  public class SingleStepSolutionTests
+  {
+    [Test]
+    public void CandidateEqualityTest()
+    {
+      var candidate = new SingleStepSolution.Candidate(1, 2, 3);
+      var otherCandidate = new SingleStepSolution.Candidate(1, 2, 3);
+
+      Assert.That(candidate != null);
+      Assert.That(null != candidate);
+      Assert.That(candidate == otherCandidate);
+      Assert.That(candidate.Equals(otherCandidate));
+      Assert.That(candidate.GetHashCode() == otherCandidate.GetHashCode());
+
+      var rowDiffers = new SingleStepSolution.Candidate(0, 2, 3);
+      Assert.That(candidate != rowDiffers);
+
+      var columnDiffers = new SingleStepSolution.Candidate(1, 0, 3);
+      Assert.That(candidate != columnDiffers);
+
+      var valueDiffers = new SingleStepSolution.Candidate(1, 2, 0);
+      Assert.That(candidate != valueDiffers);
+
+      candidate = null;
+      otherCandidate = null;
+      Assert.That(candidate == otherCandidate);
+    }
+
+    [Test]
+    public void CandidateToStringTest()
+    {
+      var candidate = new SingleStepSolution.Candidate(1, 2, 3);
+      Assert.That(candidate.ToString(), Is.EqualTo("[1,2] - 3"));
+    }
+
+    [Test]
+    public void SingleStepSolutionToStringTest()
+    {
+      var resultSolution = new SingleStepSolution(1, 2, 3, "test");
+      var expectedResultText = "Row 2 Column 3 Value 3 [test]";
+      Assert.That(resultSolution.ToString(), Is.EqualTo(expectedResultText));
+      Assert.That(resultSolution.SolutionDescription, Is.EqualTo(expectedResultText));
+
+      var eliminationSolution = new SingleStepSolution(new[]
+      {
+        new SingleStepSolution.Candidate(1, 2, 3),
+        new SingleStepSolution.Candidate(1, 2, 4)
+      }, "test");
+      var expectedEliminationText = $"Eliminated candidates [test]:{Environment.NewLine}- Row 2 Column 3 Values 3,4";
+      Assert.That(eliminationSolution.ToString(), Is.EqualTo(expectedEliminationText));
+      Assert.That(eliminationSolution.SolutionDescription, Is.EqualTo(expectedEliminationText));
+    }
+  }
+}

SimpleSudokuSolver/PuzzleProviders/SudokuFilePuzzleProvider.cs

@@ -1,13 +1,17 @@
 using System;
 using System.IO;
 using System.Linq;
+using System.Text.RegularExpressions;
 
 namespace SimpleSudokuSolver.PuzzleProviders
 {
   /// <summary>
   /// Reads sudoku puzzle from file.
   /// Each row in the file represents one row of the puzzle.
-  /// Values must be separated using either comma, space or tab.
+  /// Values in the row are:
+  /// - separated using either comma, space or tab
+  /// - or not separated at all
+  /// Lines starting with '#' are ignored.
   /// </summary>
   public class SudokuFilePuzzleProvider : ISudokuPuzzleProvider
   {
@@ -24,7 +28,14 @@ public SudokuFilePuzzleProvider(string filePath)
     /// <inheritdoc />
     public int[,] GetPuzzle()
     {
-      var lines = File.ReadAllLines(_filePath).Where(x => !string.IsNullOrWhiteSpace(x.Trim())).ToArray();
+      var lines = File.ReadAllLines(_filePath).Where(x =>
+      {
+        var trimmed = x.Trim();
+        if (trimmed.StartsWith("#"))
+          return false;
+
+        return !string.IsNullOrWhiteSpace(trimmed);
+      }).ToArray();
       var firstRowElements = GetRowElements(lines[0]);
 
       int rowCount = lines.Length;
@@ -46,8 +57,15 @@ public SudokuFilePuzzleProvider(string filePath)
 
     private int[] GetRowElements(string row)
     {
-      var splitCharacters = new char[] { ',', ' ', '\t' };
-      return row.Split(splitCharacters)
+      var separators = new[] { ",", " ", "\t" };
+
+      // if there are no separators, add them
+      if (!separators.Any(x => row.Contains(x)))
+      {
+        row = Regex.Replace(row, ".{1}", "$0,");
+      }
+
+      return row.Split(separators, StringSplitOptions.RemoveEmptyEntries)
         .Where(x => !string.IsNullOrWhiteSpace(x.Trim()))
         .Select(x => int.Parse(x.Trim()))
         .ToArray();

SimpleSudokuSolver/SingleStepSolution.cs

@@ -37,6 +37,33 @@ public Candidate(int indexOfRow, int indexOfColumn, int value)
       /// </summary>
       public int Value { get; }
 
+      /// <remarks>
+      /// For implementation details see:
+      /// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/statements-expressions-operators/how-to-define-value-equality-for-a-type
+      /// </remarks>
+      public static bool operator ==(Candidate lhs, Candidate rhs)
+      {
+        // Check for null on left side.
+        if (object.ReferenceEquals(lhs, null))
+        {
+          if (object.ReferenceEquals(rhs, null))
+          {
+            // null == null = true.
+            return true;
+          }
+
+          // Only the left side is null.
+          return false;
+        }
+        // Equals handles case of null on right side.
+        return lhs.Equals(rhs);
+      }
+
+      public static bool operator !=(Candidate lhs, Candidate rhs)
+      {
+        return !(lhs == rhs);
+      }
+
       public override bool Equals(object obj)
       {
         return obj is Candidate candidate &&