#442 Update NUnit to 4.0.1

Algorithms.Tests/Algorithms.Tests.csproj

@@ -20,7 +20,7 @@
     </PackageReference>
     <PackageReference Include="FluentAssertions" Version="6.12.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0" />
-    <PackageReference Include="nunit" Version="3.12.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="3.15.1" />
+    <PackageReference Include="nunit" Version="4.0.1" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
   </ItemGroup>
 </Project>

Algorithms.Tests/Compressors/BurrowsWheelerTransformTests.cs

@@ -15,8 +15,8 @@ public void Encode(string input, string expectedString, int expectedIndex)
 
         var (encoded, index) = bwt.Encode(input);
 
-        Assert.AreEqual(expectedString, encoded);
-        Assert.AreEqual(expectedIndex, index);
+        Assert.That(encoded, Is.EqualTo(expectedString));
+        Assert.That(index, Is.EqualTo(expectedIndex));
     }
 
     [TestCase("nnbaaa", 3, "banana")]
@@ -28,7 +28,7 @@ public void Decode(string encoded, int index, string expected)
 
         var result = bwt.Decode(encoded, index);
 
-        Assert.AreEqual(expected, result);
+        Assert.That(result, Is.EqualTo(expected));
     }
 
     [Test]
@@ -42,6 +42,6 @@ public void RandomEncodeDecode()
         var (encoded, index) = bwt.Encode(inputString);
         var result = bwt.Decode(encoded, index);
 
-        Assert.AreEqual(inputString, result);
+        Assert.That(result, Is.EqualTo(inputString));
     }
 }

Algorithms.Tests/Compressors/HuffmanCompressorTests.cs

@@ -25,8 +25,8 @@ public static void CompressingPhrase(string uncompressedText, string expectedCom
         var decompressedText = translator.Translate(compressedText, decompressionKeys);
 
         //Assert
-        Assert.AreEqual(expectedCompressedText, compressedText);
-        Assert.AreEqual(uncompressedText, decompressedText);
+        Assert.That(compressedText, Is.EqualTo(expectedCompressedText));
+        Assert.That(decompressedText, Is.EqualTo(uncompressedText));
     }
 
     [Test]
@@ -45,7 +45,7 @@ public static void DecompressedTextTheSameAsOriginal(
         var decompressedText = translator.Translate(compressedText, decompressionKeys);
 
         //Assert
-        Assert.AreEqual(text, decompressedText);
+        Assert.That(decompressedText, Is.EqualTo(text));
     }
 
     [Test]

Algorithms.Tests/Compressors/ShannonFanoCompressorTests.cs

@@ -22,8 +22,8 @@ public static void CompressingPhrase(string uncompressedText, string expectedCom
         var decompressedText = translator.Translate(compressedText, decompressionKeys);
 
         //Assert
-        Assert.AreEqual(expectedCompressedText, compressedText);
-        Assert.AreEqual(uncompressedText, decompressedText);
+        Assert.That(compressedText, Is.EqualTo(expectedCompressedText));
+        Assert.That(decompressedText, Is.EqualTo(uncompressedText));
     }
 
     [Test]
@@ -40,6 +40,6 @@ public static void DecompressedTextTheSameAsOriginal([Random(0, 1000, 100)] int
         var decompressedText = translator.Translate(compressedText, decompressionKeys);
 
         //Assert
-        Assert.AreEqual(text, decompressedText);
+        Assert.That(decompressedText, Is.EqualTo(text));
     }
 }

Algorithms.Tests/Compressors/TranslatorTests.cs

@@ -23,6 +23,6 @@ public static void TranslateCorrectly()
         var translatedText = translator.Translate("Hey man!", dict);
 
         // Assert
-        Assert.AreEqual("Good day sir.", translatedText);
+        Assert.That(translatedText, Is.EqualTo("Good day sir."));
     }
 }

Algorithms.Tests/Encoders/CaesarEncoderTests.cs

@@ -19,6 +19,6 @@ public static void DecodedStringIsTheSame([Random(100)] int key)
         var decoded = encoder.Decode(encoded, key);
 
         // Assert
-        Assert.AreEqual(message, decoded);
+        Assert.That(decoded, Is.EqualTo(message));
     }
 }

Algorithms.Tests/Encoders/FeistelCipherTest.cs

@@ -23,7 +23,7 @@ public static void DecodedStringIsTheSame([Random(100)] uint key)
         var decoded = encoder.Decode(encoded, key);
 
         // Assert
-        Assert.AreEqual(message, decoded);
+        Assert.That(decoded, Is.EqualTo(message));
     }
 
     [TestCase("00001111",                           (uint)0x12345678)]

Algorithms.Tests/Encoders/HillEnconderTests.cs

@@ -22,6 +22,6 @@ public static void DecodedStringIsTheSame()
         var decodeText = encoder.Decode(encodedText, key);
 
         // Assert
-        Assert.AreEqual(message, decodeText);
+        Assert.That(decodeText, Is.EqualTo(message));
     }
 }

Algorithms.Tests/Encoders/NysiisEncoderTests.cs

@@ -26,6 +26,6 @@ public void AttemptNysiis(string source, string expected)
     {
         var enc = new NysiisEncoder();
         var nysiis = enc.Encode(source);
-        Assert.AreEqual(expected, nysiis);
+        Assert.That(nysiis, Is.EqualTo(expected));
     }
 }

Algorithms.Tests/Encoders/SoundexEncoderTest.cs

@@ -21,6 +21,6 @@ public static void AttemptSoundex(string source, string encoded)
     {
         SoundexEncoder enc = new();
         var nysiis = enc.Encode(source);
-        Assert.AreEqual(nysiis, encoded);
+        Assert.That(encoded, Is.EqualTo(nysiis));
     }
 }

Algorithms.Tests/Encoders/VigenereEncoderTests.cs

@@ -22,7 +22,7 @@ public static void DecodedStringIsTheSame()
         var decoded = encoder.Decode(encoded, key);
 
         // Assert
-        Assert.AreEqual(message, decoded);
+        Assert.That(decoded, Is.EqualTo(message));
     }
 
     [Test]
@@ -38,7 +38,7 @@ public static void Encode_KeyIsTooShort_KeyIsAppended()
         var decoded = encoder.Decode(encoded, key);
 
         // Assert
-        Assert.AreEqual(message, decoded);
+        Assert.That(decoded, Is.EqualTo(message));
     }
 
     [Test]

Algorithms.Tests/Graph/BreadthFirstSearchTests.cs

@@ -37,7 +37,7 @@ public void VisitAll_ShouldCountNumberOfVisitedVertix_ResultShouldBeTheSameAsNum
         dfsSearcher.VisitAll(graph, vertex1, _ => countOfVisitedVertices++);
 
         //Assert
-        Assert.AreEqual(countOfVisitedVertices, graph.Count);
+        Assert.That(graph.Count, Is.EqualTo(countOfVisitedVertices));
     }
 
     [Test]
@@ -78,9 +78,9 @@ public void VisitAll_ShouldCountNumberOfVisitedVerices_TwoSeparatedGraphInOne()
         dfsSearcher.VisitAll(graph, vertex4, _ => countOfVisitedVerticesPerSecondGraph++);
 
         //Assert
-        Assert.AreEqual(countOfVisitedVerticesPerFirstGraph, 3);
+        Assert.That(countOfVisitedVerticesPerFirstGraph, Is.EqualTo(3));
 
-        Assert.AreEqual(countOfVisitedVerticesPerSecondGraph, 3);
+        Assert.That(countOfVisitedVerticesPerSecondGraph, Is.EqualTo(3));
     }
 
     [Test]
@@ -126,6 +126,6 @@ public void VisitAll_ReturnTheSuqenceOfVertices_ShouldBeTheSameAsExpected()
         dfsSearcher.VisitAll(graph, vertex1, vertex => sequenceOfVisitedVertices.Add(vertex));
 
         //Assert
-        CollectionAssert.AreEqual(expectedSequenceOfVisitedVertices, sequenceOfVisitedVertices);
+        Assert.That(sequenceOfVisitedVertices, Is.EqualTo(expectedSequenceOfVisitedVertices));
     }
 }

Algorithms.Tests/Graph/BreadthFirstTreeTraversalTests.cs

@@ -1,7 +1,6 @@
 using Algorithms.Graph;
-using NUnit.Framework;
 using DataStructures.BinarySearchTree;
-using System;
+using NUnit.Framework;
 
 namespace Algorithms.Tests.Graph;
 
@@ -23,7 +22,7 @@ public static void CorrectLevelOrderTraversal()
         int[] levelOrder = BreadthFirstTreeTraversal<int>.LevelOrderTraversal(testTree);
 
         // Assert
-        Assert.AreEqual(levelOrder, correctPath);
+        Assert.That(correctPath, Is.EqualTo(levelOrder));
     }
 
     [Test]
@@ -36,11 +35,11 @@ public static void EmptyArrayForNullRoot()
         int[] levelOrder = BreadthFirstTreeTraversal<int>.LevelOrderTraversal(testTree);
 
         // Assert
-        Assert.IsEmpty(levelOrder);
+        Assert.That(levelOrder, Is.Empty);
     }
 
-    [TestCase(new [] {7, 9, 5})]
-    [TestCase(new [] { 7, 13, 11, 15, 14, 4, 5, 16, 2 })]
+    [TestCase(new[] { 7, 9, 5 })]
+    [TestCase(new[] { 7, 13, 11, 15, 14, 4, 5, 16, 2 })]
     public static void IncorrectLevelOrderTraversal(int[] insertion)
     {
         // Arrange
@@ -54,7 +53,7 @@ public static void IncorrectLevelOrderTraversal(int[] insertion)
         int[] levelOrder = BreadthFirstTreeTraversal<int>.LevelOrderTraversal(testTree);
 
         // Assert
-        Assert.AreNotEqual(levelOrder, insertion);
+        Assert.That(insertion, Is.Not.EqualTo(levelOrder));
     }
 
     [Test]
@@ -72,7 +71,7 @@ public static void DeepestNodeInTree()
         int deepest = BreadthFirstTreeTraversal<int>.DeepestNode(testTree);
 
         // Assert
-        Assert.AreEqual(12, deepest);
+        Assert.That(deepest, Is.EqualTo(12));
     }
 
     [Test]
@@ -85,7 +84,7 @@ public static void DeepestNodeOfEmptyTree()
         int? deepest = BreadthFirstTreeTraversal<int?>.DeepestNode(testTree);
 
         // Assert
-        Assert.IsNull(deepest);
+        Assert.That(deepest, Is.Null);
     }
 }
 

Algorithms.Tests/Graph/DepthFirstSearchTests.cs

@@ -37,7 +37,7 @@ public void VisitAll_ShouldCountNumberOfVisitedVertix_ResultShouldBeTheSameAsNum
         dfsSearcher.VisitAll(graph, vertex1, _ => countOfVisitedVertices++);
 
         //Assert
-        Assert.AreEqual(countOfVisitedVertices, graph.Count);
+        Assert.That(graph.Count, Is.EqualTo(countOfVisitedVertices));
     }
 
     [Test]
@@ -78,9 +78,9 @@ public void VisitAll_ShouldCountNumberOfVisitedVertices_TwoSeparatedGraphInOne()
         dfsSearcher.VisitAll(graph, vertex4, _ => countOfVisitedVerticesPerSecondGraph++);
 
         //Assert
-        Assert.AreEqual(countOfVisitedVerticesPerFirstGraph, 3);
+        Assert.That(3, Is.EqualTo(countOfVisitedVerticesPerFirstGraph));
 
-        Assert.AreEqual(countOfVisitedVerticesPerSecondGraph, 3);
+        Assert.That(3, Is.EqualTo(countOfVisitedVerticesPerSecondGraph));
     }
 
     [Test]
@@ -124,6 +124,6 @@ public void VisitAll_ReturnTheSuqenceOfVertices_ShouldBeTheSameAsExpected()
         dfsSearcher.VisitAll(graph, vertex1, vertex => sequenceOfVisitedVertices.Add(vertex));
 
         //Assert
-        CollectionAssert.AreEqual(expectedSequenceOfVisitedVertices, sequenceOfVisitedVertices);
+        Assert.That(sequenceOfVisitedVertices, Is.EqualTo(expectedSequenceOfVisitedVertices));
     }
 }

Algorithms.Tests/Knapsack/DynamicProgrammingKnapsackSolverTests.cs

@@ -28,7 +28,7 @@ public static void SmallSampleOfChar()
         var actual = solver.Solve(items, capacity, weightSelector, valueSelector);
 
         //Assert
-        Assert.AreEqual(expected.OrderBy(x => x), actual.OrderBy(x => x));
+        Assert.That(actual.OrderBy(x => x), Is.EqualTo(expected.OrderBy(x => x)));
     }
 
     [Test]
@@ -53,7 +53,7 @@ public static void FSU_P01()
         var actual = solver.Solve(items, capacity, weightSelector, valueSelector);
 
         //Assert
-        Assert.AreEqual(expected.OrderBy(x => x), actual.OrderBy(x => x));
+        Assert.That(actual.OrderBy(x => x), Is.EqualTo(expected.OrderBy(x => x)));
     }
 
     [Test]
@@ -80,7 +80,7 @@ public static void FSU_P07_WithNonIntegralValues()
         var actual = solver.Solve(items, capacity * 10, weightSelector, valueSelector);
 
         //Assert
-        Assert.AreEqual(expected.OrderBy(x => x), actual.OrderBy(x => x));
+        Assert.That(actual.OrderBy(x => x), Is.EqualTo(expected.OrderBy(x => x)));
     }
 
 
@@ -98,6 +98,6 @@ public static void TakesHalf(
         var result = solver.Solve(items, length, _ => 1, _ => 1);
 
         //Assert
-        Assert.AreEqual(expectedResult, result);
+        Assert.That(result, Is.EqualTo(expectedResult));
     }
 }

Algorithms.Tests/Knapsack/NaiveKnapsackSolverTests.cs

@@ -20,6 +20,6 @@ public static void TakesHalf(
         var result = solver.Solve(items, length, _ => 1, _ => 1);
 
         //Assert
-        Assert.AreEqual(expectedResult, result);
+        Assert.That(result, Is.EqualTo(expectedResult));
     }
 }

Algorithms.Tests/ModularArithmetic/ChineseRemainderTheoremTest.cs

@@ -17,7 +17,7 @@ public static void TestCompute1()
         var x = ChineseRemainderTheorem.Compute(new List<long> { 1L, 1L, 3L, 1L }, new List<long> { 2L, 3L, 5L, 7L });
 
         // Assert
-        Assert.AreEqual(expected, x);
+        Assert.That(x, Is.EqualTo(expected));
     }
 
     [Test]
@@ -29,7 +29,7 @@ public static void TestCompute2()
         var x = ChineseRemainderTheorem.Compute(new List<long> { 0L, 0L, 2L, 1L, 1L }, new List<long> { 2L, 5L, 7L, 9L, 11L });
 
         // Assert
-        Assert.AreEqual(expected, x);
+        Assert.That(x, Is.EqualTo(expected));
     }
 
     [Test]
@@ -41,7 +41,7 @@ public static void TestCompute3()
         var x = ChineseRemainderTheorem.Compute(new List<long> { 1L, 4L, 13L }, new List<long> { 4L, 9L, 25L });
 
         // Assert
-        Assert.AreEqual(expected, x);
+        Assert.That(x, Is.EqualTo(expected));
     }
 
     [Test]
@@ -105,7 +105,7 @@ public static void TestCompute_BigInteger_1()
         );
 
         // Assert
-        Assert.AreEqual(expected, x);
+        Assert.That(x, Is.EqualTo(expected));
     }
 
     [Test]
@@ -120,7 +120,7 @@ public static void TestCompute_BigInteger_2()
         );
 
         // Assert
-        Assert.AreEqual(expected, x);
+        Assert.That(x, Is.EqualTo(expected));
     }
 
     [Test]
@@ -135,7 +135,7 @@ public static void TestCompute_BigInteger_3()
         );
 
         // Assert
-        Assert.AreEqual(expected, x);
+        Assert.That(x, Is.EqualTo(expected));
     }
 
     [Test]

Algorithms.Tests/ModularArithmetic/ExtendedEuclideanAlgorithmTest.cs

@@ -23,9 +23,9 @@ public static void TestCompute(long a, long b, long expectedGCD, long expectedBe
         var eeaResult = ExtendedEuclideanAlgorithm.Compute(a, b);
 
         // Assert
-        Assert.AreEqual(expectedGCD, eeaResult.gcd);
-        Assert.AreEqual(expectedBezoutOfA, eeaResult.bezoutA);
-        Assert.AreEqual(expectedBezoutOfB, eeaResult.bezoutB);
+        Assert.That(eeaResult.gcd, Is.EqualTo(expectedGCD));
+        Assert.That(eeaResult.bezoutA, Is.EqualTo(expectedBezoutOfA));
+        Assert.That(eeaResult.bezoutB, Is.EqualTo(expectedBezoutOfB));
     }
 
     [TestCase(240, 46, 2, -9, 47)]
@@ -45,8 +45,8 @@ public static void TestCompute_BigInteger(long a, long b, long expectedGCD, long
         var eeaResult = ExtendedEuclideanAlgorithm.Compute(new BigInteger(a), new BigInteger(b));
 
         // Assert
-        Assert.AreEqual(new BigInteger(expectedGCD), eeaResult.gcd);
-        Assert.AreEqual(new BigInteger(expectedBezoutOfA), eeaResult.bezoutA);
-        Assert.AreEqual(new BigInteger(expectedBezoutOfB), eeaResult.bezoutB);
+        Assert.That(eeaResult.gcd, Is.EqualTo(new BigInteger(expectedGCD)));
+        Assert.That(eeaResult.bezoutA, Is.EqualTo(new BigInteger(expectedBezoutOfA)));
+        Assert.That(eeaResult.bezoutB, Is.EqualTo(new BigInteger(expectedBezoutOfB)));
     }
 }