[REFACTOR] Test Case classes rewritten

Author: Gonzalo Diaz

src/algorithm_exercises_csharp_test/hackerrank/warmup/AVeryBigSumTest.cs

@@ -1,34 +1,53 @@
 namespace algorithm_exercises_csharp_test.hackerrank.warmup;
 using algorithm_exercises_csharp.hackerrank.warmup;
 
+using algorithm_exercises_csharp_test.lib;
+
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 [TestClass]
 public class AVeryBigSumTest
 {
-  public class AVeryBigSumTestCase
+  public class AVeryBigSumTestCase(List<long> ar, long expected)
   {
-    public List<long> ar = [];
-    public long expected = 0;
-  }
+    private readonly List<long> ar = ar;
+    private readonly long expected = expected;
+
+    public List<long> Ar
+    {
+      get { return ar; }
+    }
 
-  private static readonly AVeryBigSumTestCase[] tests = [
-    new()
+    public long Expected
     {
-      ar = [1000000001, 1000000002, 1000000003, 1000000004, 1000000005],
-      expected = 5000000015
+      get { return expected; }
     }
-  ];
+  }
+
+  private List<AVeryBigSumTestCase> testCases { get; set; } = default!;
+
+  [TestInitialize]
+  public void testInitialize()
+  {
+    testCases = JsonLoader.stringLoad<List<AVeryBigSumTestCase>>(/*lang=json,strict*/ @"
+      [
+        {
+          ""ar"": [1000000001, 1000000002, 1000000003, 1000000004, 1000000005],
+          ""expected"": 5000000015
+        }
+      ]
+      ") ?? [];
+  }
 
   [TestMethod]
   public void testSimpleArraySum()
   {
     long result;
 
-    foreach (AVeryBigSumTestCase test in tests)
+    foreach (AVeryBigSumTestCase test in testCases)
     {
-      result = AVeryBigSum.aVeryBigSum(test.ar);
-      Assert.AreEqual(test.expected, result);
+      result = AVeryBigSum.aVeryBigSum(test.Ar);
+      Assert.AreEqual(test.Expected, result);
     }
   }
 }

src/algorithm_exercises_csharp_test/hackerrank/warmup/BirthdayCakeCandles.Test.cs

@@ -1,29 +1,49 @@
 namespace algorithm_exercises_csharp_test.hackerrank.warmup;
 using algorithm_exercises_csharp.hackerrank.warmup;
 
+using algorithm_exercises_csharp_test.lib;
+
 [TestClass]
 public class BirthdayCakeCandlesTest
 {
-  public class BirthdayCakeCandlesTestCase
+  public class BirthdayCakeCandlesTestCase(List<int> input, long expected)
   {
-    public List<int> input = [];
-    public int expected = 0;
+    private readonly List<int> input = input;
+    private readonly long expected = expected;
+
+    public List<int> Input
+    {
+      get { return input; }
+    }
+
+    public long Expected
+    {
+      get { return expected; }
+    }
   }
 
-  private static readonly BirthdayCakeCandlesTestCase[] tests = [
-    new() { input = [3, 2, 1, 3], expected = 2 },
-    new() { input = [1, 2, 3, 3], expected = 2 }
-  ];
+  private List<BirthdayCakeCandlesTestCase> testCases { get; set; } = default!;
+
+  [TestInitialize]
+  public void testInitialize()
+  {
+    testCases = JsonLoader.stringLoad<List<BirthdayCakeCandlesTestCase>>(/*lang=json,strict*/ @"
+      [
+        { ""input"": [3, 2, 1, 3], ""expected"": 2 },
+        { ""input"": [1, 2, 3, 3], ""expected"": 2 }
+      ]
+      ") ?? [];
+  }
 
   [TestMethod]
   public void testBirthdayCakeCandles()
   {
-    int? result;
+    long? result;
 
-    foreach (BirthdayCakeCandlesTestCase test in tests)
+    foreach (BirthdayCakeCandlesTestCase test in testCases)
     {
-      result = BirthdayCakeCandles.birthdayCakeCandles(test.input);
-      Assert.AreEqual(test.expected, result);
+      result = BirthdayCakeCandles.birthdayCakeCandles(test.Input);
+      Assert.AreEqual(test.Expected, result);
     }
   }
 

src/algorithm_exercises_csharp_test/hackerrank/warmup/CompareTriplets.Test.cs

@@ -1,37 +1,60 @@
 namespace algorithm_exercises_csharp_test.hackerrank.warmup;
 using algorithm_exercises_csharp.hackerrank.warmup;
 
+using algorithm_exercises_csharp_test.lib;
+
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 [TestClass]
 public class CompareTripletsTest
 {
-  public class CompareTripletsTestCase
+  public class CompareTripletsTestCase(List<int> a, List<int> b, List<int> expected)
   {
-    public List<int> a = [];
-    public List<int> b = [];
-    public List<int> expected = [];
-  }
+    private readonly List<int> a = a;
+    private readonly List<int> b = b;
+    private readonly List<int> expected = expected;
 
-  // dotnet_style_readonly_field = true
-  private static readonly CompareTripletsTestCase[] tests = [
-    new()
+    public List<int> A
     {
-      a = [5, 6, 7],
-      b = [3, 6, 10],
-      expected = [1, 1]
+      get { return a; }
     }
-  ];
+
+    public List<int> B
+    {
+      get { return b; }
+    }
+
+    public List<int> Expected
+    {
+      get { return expected; }
+    }
+  }
+
+  private List<CompareTripletsTestCase> testCases { get; set; } = default!;
+
+  [TestInitialize]
+  public void testInitialize()
+  {
+    testCases = JsonLoader.stringLoad<List<CompareTripletsTestCase>>(/*lang=json,strict*/ @"
+      [
+        {
+          ""a"": [5, 6, 7],
+          ""b"": [3, 6, 10],
+          ""expected"": [1, 1]
+        }
+      ]
+      ") ?? [];
+  }
 
   [TestMethod]
   public void testSimpleArraySum()
   {
     List<int> result;
 
-    foreach (CompareTripletsTestCase test in tests)
+    foreach (CompareTripletsTestCase test in testCases)
     {
-      result = CompareTriplets.compareTriplets(test.a, test.b);
-      CollectionAssert.AreEquivalent(test.expected, result);
+      result = CompareTriplets.compareTriplets(test.A, test.B);
+      CollectionAssert.AreEquivalent(test.Expected, result);
     }
   }
 }

src/algorithm_exercises_csharp_test/hackerrank/warmup/DiagonalDifference.Test.cs

@@ -1,23 +1,58 @@
 namespace algorithm_exercises_csharp_test.hackerrank.warmup;
 using algorithm_exercises_csharp.hackerrank.warmup;
 
+using algorithm_exercises_csharp_test.lib;
+
 [TestClass]
 public class DiagonalDifferenceTest
 {
+  public class DiagonalDifferenceTestCase(List<List<int>> arr, int expected)
+  {
+    private readonly List<List<int>> arr = arr;
+    private readonly int expected = expected;
+
+    public List<List<int>> Arr
+    {
+      get { return arr; }
+    }
+
+    public int Expected
+    {
+      get { return expected; }
+    }
+  }
+
+  private List<DiagonalDifferenceTestCase> testCases { get; set; } = default!;
+
+  [TestInitialize]
+  public void testInitialize()
+  {
+    testCases = JsonLoader.stringLoad<List<DiagonalDifferenceTestCase>>(/*lang=json,strict*/ @"
+      [
+        {
+          ""arr"": [
+            [11, 2, 4],
+            [4, 5, 6],
+            [10, 8, -12]
+          ],
+          ""expected"": 15
+        }
+      ]
+      ") ?? [];
+  }
+
   [TestMethod]
   public void testDiagonalDifference()
   {
-    List<List<int>> arr = [
-      [11, 2, 4],
-      [4, 5, 6],
-      [10, 8, -12]
-    ];
-    int expectedAnswer = 15;
-    int result = DiagonalDifference.diagonalDifference(arr);
-
-    Assert.AreEqual(expectedAnswer, result,
-      String.Format("DiagonalDifference.diagonalDifference answer must be: {0}", expectedAnswer)
-    );
+    int? result;
+
+    foreach (DiagonalDifferenceTestCase test in testCases)
+    {
+      result = DiagonalDifference.diagonalDifference(test.Arr);
+      Assert.AreEqual(test.Expected, result,
+        string.Format(System.Globalization.CultureInfo.InvariantCulture, "DiagonalDifference.diagonalDifference answer must be: {0}", test.Expected)
+      );
+    }
   }
 }
 

src/algorithm_exercises_csharp_test/hackerrank/warmup/MiniMaxSum.Test.cs

@@ -1,29 +1,49 @@
 namespace algorithm_exercises_csharp_test.hackerrank.warmup;
 using algorithm_exercises_csharp.hackerrank.warmup;
 
+using algorithm_exercises_csharp_test.lib;
+
 [TestClass]
 public class MiniMaxSumTest
 {
-  public class MiniMaxSumTestCase
+  public class MiniMaxSumTestCase(List<int> input, string expected)
   {
-    public List<int> input = [];
-    public string expected = "";
+    private readonly List<int> input = input;
+    private readonly string expected = expected;
+
+    public List<int> Input
+    {
+      get { return input; }
+    }
+
+    public string Expected
+    {
+      get { return expected; }
+    }
   }
 
-  private static readonly MiniMaxSumTestCase[] tests = [
-    new() { input = [1, 2, 3, 4, 5], expected = "10 14" },
-    new() { input = [5, 4, 3, 2, 1], expected = "10 14" }
-  ];
+  private List<MiniMaxSumTestCase> testCases { get; set; } = default!;
+
+  [TestInitialize]
+  public void testInitialize()
+  {
+    testCases = JsonLoader.stringLoad<List<MiniMaxSumTestCase>>(/*lang=json,strict*/ @"
+      [
+        { ""input"": [1, 2, 3, 4, 5], ""expected"": ""10 14"" },
+        { ""input"": [5, 4, 3, 2, 1], ""expected"": ""10 14"" }
+      ]
+      ") ?? [];
+  }
 
   [TestMethod]
   public void testMiniMaxSum()
   {
     string? result;
 
-    foreach (MiniMaxSumTestCase test in tests)
+    foreach (MiniMaxSumTestCase test in testCases)
     {
-      result = MiniMaxSum.miniMaxSum(test.input);
-      Assert.AreEqual(test.expected, result);
+      result = MiniMaxSum.miniMaxSum(test.Input);
+      Assert.AreEqual(test.Expected, result);
     }
   }
 

src/algorithm_exercises_csharp_test/hackerrank/warmup/TimeConversion.Test.cs

@@ -1,29 +1,49 @@
 namespace algorithm_exercises_csharp_test.hackerrank.warmup;
 using algorithm_exercises_csharp.hackerrank.warmup;
 
+using algorithm_exercises_csharp_test.lib;
+
 [TestClass]
 public class TimeConversionTest
 {
-  public class TimeConversionTestCase
+  public class TimeConversionTestCase(string input, string expected)
   {
-    public string input = "";
-    public string expected = "";
+    private readonly string input = input;
+    private readonly string expected = expected;
+
+    public string Input
+    {
+      get { return input; }
+    }
+
+    public string Expected
+    {
+      get { return expected; }
+    }
   }
 
-  private static readonly TimeConversionTestCase[] tests = [
-    new() { input = "12:01:00PM", expected = "12:01:00" },
-    new() { input = "12:01:00AM", expected = "00:01:00" }
-  ];
+  private List<TimeConversionTestCase> testCases { get; set; } = default!;
+
+  [TestInitialize]
+  public void testInitialize()
+  {
+    testCases = JsonLoader.stringLoad<List<TimeConversionTestCase>>(/*lang=json,strict*/ @"
+      [
+        { ""input"": ""12:01:00PM"", ""expected"": ""12:01:00"" },
+        { ""input"": ""12:01:00AM"", ""expected"": ""00:01:00"" }
+      ]
+    ") ?? [];
+  }
 
   [TestMethod]
   public void testTimeConversion()
   {
     string? result;
 
-    foreach (TimeConversionTestCase test in tests)
+    foreach (TimeConversionTestCase test in testCases)
     {
-      result = TimeConversion.timeConversion(test.input);
-      Assert.AreEqual(test.expected, result);
+      result = TimeConversion.timeConversion(test.Input);
+      Assert.AreEqual(test.Expected, result);
     }
   }
 }