Index: DamFailureMechanisms/damPiping/trunk/src/build/Test.targets
===================================================================
diff -u -r4612 -r4623
--- DamFailureMechanisms/damPiping/trunk/src/build/Test.targets	(.../Test.targets)	(revision 4612)
+++ DamFailureMechanisms/damPiping/trunk/src/build/Test.targets	(.../Test.targets)	(revision 4623)
@@ -9,14 +9,12 @@
     </PropertyGroup>
     <ItemGroup>
         <PackageReference Include="NUnit">
-            <Version>3.13.3</Version>
+            <Version>4.1.0</Version>
         </PackageReference>
         <PackageReference Include="NUnit3TestAdapter">
-            <Version>4.4.2</Version>
+            <Version>4.6.0</Version>
         </PackageReference>
-        <PackageReference Include="Microsoft.NET.Test.Sdk">
-            <Version>17.5.0</Version>
-        </PackageReference>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.11.0-release-24373-02"/>
         <PackageReference Include="System.Threading.Tasks.Extensions">
             <Version>4.5.4</Version>
         </PackageReference>
Index: DamFailureMechanisms/damPiping/trunk/src/Deltares.DamPiping.BlighCalculator.Tests/PipingCalculatorBlighTests.cs
===================================================================
diff -u -r4361 -r4623
--- DamFailureMechanisms/damPiping/trunk/src/Deltares.DamPiping.BlighCalculator.Tests/PipingCalculatorBlighTests.cs	(.../PipingCalculatorBlighTests.cs)	(revision 4361)
+++ DamFailureMechanisms/damPiping/trunk/src/Deltares.DamPiping.BlighCalculator.Tests/PipingCalculatorBlighTests.cs	(.../PipingCalculatorBlighTests.cs)	(revision 4623)
@@ -33,7 +33,7 @@
         public void TestIf64Bit()
         {
             int ls = IntPtr.Size;
-            Assert.AreEqual(8, ls);
+            Assert.That(ls, Is.EqualTo(8));
             Assert.That(Environment.Is64BitProcess, Is.True);
         }
 
@@ -45,8 +45,8 @@
                 HRiver = 1
             };
             calculator.Calculate();
-            Assert.AreEqual(0, calculator.FoSp);
-            Assert.AreEqual(0, calculator.Hc);
+            Assert.That(calculator.FoSp, Is.EqualTo(0));
+            Assert.That(calculator.Hc, Is.EqualTo(0));
         }
 
         [Test]
@@ -68,8 +68,8 @@
                 D70 = 180.0
             };
             calculator.Calculate();
-            Assert.AreEqual(4.5, calculator.FoSp, diff);
-            Assert.AreEqual(2.25, calculator.Hc, diff);
+            Assert.That(calculator.FoSp, Is.EqualTo(4.5).Within(diff));
+            Assert.That(calculator.Hc, Is.EqualTo(2.25).Within(diff));
         }
 
         [Test]
@@ -79,19 +79,19 @@
             var calculator = new PipingCalculatorBligh();
             calculator.D70 = 180.0; // d50 < 150 
             double factor = calculator.CreepFactor();
-            Assert.AreEqual(18.0, factor);
+            Assert.That(factor, Is.EqualTo(18.0));
 
             calculator.D70 = 200; // 150 < d50 < 300 
             factor = calculator.CreepFactor();
-            Assert.AreEqual(15.0, factor);
+            Assert.That(factor, Is.EqualTo(15.0));
 
             calculator.D70 = 400; // 300 > d50 
             factor = calculator.CreepFactor();
-            Assert.AreEqual(12.0, factor);
+            Assert.That(factor, Is.EqualTo(12.0));
 
             calculator.D70 = null; // d70 not specified
             factor = calculator.CreepFactor();
-            Assert.AreEqual(18.0, factor);
+            Assert.That(factor, Is.EqualTo(18.0));
         }
 
         [Test]
@@ -107,14 +107,14 @@
                 DTotal = 2.0
             };
             double reducedFall = calculator.GetReducedFall();
-            Assert.AreEqual(0.40, reducedFall, cTolerance);
+            Assert.That(reducedFall, Is.EqualTo(0.40).Within(cTolerance));
 
             calculator.HRiver = 0.0;
             calculator.HExit = -2.0;
             calculator.Rc = 0.2;
             calculator.DTotal = 6.0;
             reducedFall = calculator.GetReducedFall();
-            Assert.AreEqual(0.80, reducedFall, cTolerance);
+            Assert.That(reducedFall, Is.EqualTo(0.80).Within(cTolerance));
         }
 
         [Test]
@@ -126,24 +126,24 @@
             var hCritical = 3.65;
             var reducedFall = 1.00;
             double safetyFactor = PipingCalculatorBligh.DetermineFactorOfSafety(hCritical, reducedFall);
-            Assert.AreEqual(3.65, safetyFactor, cTolerance);
+            Assert.That(safetyFactor, Is.EqualTo(3.65).Within(cTolerance));
 
             hCritical = 3.65;
             reducedFall = 2.00;
             safetyFactor = PipingCalculatorBligh.DetermineFactorOfSafety(hCritical, reducedFall);
-            Assert.AreEqual(1.825, safetyFactor, cTolerance);
+            Assert.That(safetyFactor, Is.EqualTo(1.825).Within(cTolerance));
 
             // reducedFall <= 0 result is cDefaultMaxReturnValue = 90.0;
             hCritical = 3.65;
             reducedFall = 0.00;
             safetyFactor = PipingCalculatorBligh.DetermineFactorOfSafety(hCritical, reducedFall);
-            Assert.AreEqual(90.0, safetyFactor, cTolerance);
+            Assert.That(safetyFactor, Is.EqualTo(90.0).Within(cTolerance));
 
             // hCritical = 0 result is cDefaultMinReturnValue = 0.0;
             hCritical = 0.00;
             reducedFall = 1.00;
             safetyFactor = PipingCalculatorBligh.DetermineFactorOfSafety(hCritical, reducedFall);
-            Assert.AreEqual(0.0, safetyFactor, cTolerance);
+            Assert.That(safetyFactor, Is.EqualTo(0.0).Within(cTolerance));
         }
 
         [Test]
@@ -167,12 +167,12 @@
             calculator.SeepageLength = double.NaN;
             calculator.D70 = double.NaN;
             List<string> nanErrors = calculator.Validate();
-            Assert.AreEqual(originalErrors.Count + 6, nanErrors.Count);
+            Assert.That(nanErrors.Count, Is.EqualTo(originalErrors.Count + 6));
 
             //  D70 is allowed to be null
             calculator.D70 = null;
             nanErrors = calculator.Validate();
-            Assert.AreEqual(originalErrors.Count + 5, nanErrors.Count);
+            Assert.That(nanErrors.Count, Is.EqualTo(originalErrors.Count + 5));
         }
 
         [Test]
@@ -189,12 +189,12 @@
                 D70 = 180.0
             };
             List<string> errors = calculator.Validate();
-            Assert.AreEqual(1, errors.Count);
+            Assert.That(errors.Count, Is.EqualTo(1));
             var expectedMessageEN = "Rc may not be less than 0.";
-            CollectionAssert.AreEqual(new[]
+            Assert.That(errors, Is.EqualTo(new[]
             {
                 expectedMessageEN
-            }, errors);
+            }).AsCollection);
         }
 
         [Test]
@@ -211,12 +211,12 @@
                 D70 = 180.0
             };
             List<string> errors = calculator.Validate();
-            Assert.AreEqual(1, errors.Count);
+            Assert.That(errors.Count, Is.EqualTo(1));
             var expectedMessageNL = "De waarde voor de dempingsfactor mag niet lager dan 0 zijn.";
-            CollectionAssert.AreEqual(new[]
+            Assert.That(errors, Is.EqualTo(new[]
             {
                 expectedMessageNL
-            }, errors);
+            }).AsCollection);
         }
 
         [Test]
@@ -233,12 +233,12 @@
                 D70 = 180.0
             };
             List<string> errors = calculator.Validate();
-            Assert.AreEqual(1, errors.Count);
+            Assert.That(errors.Count, Is.EqualTo(1));
             var expectedMessageEN = "De term HRiver - HExit - (Rc*DTotal) mag niet nul zijn.";
-            CollectionAssert.AreEqual(new[]
+            Assert.That(errors, Is.EqualTo(new[]
             {
                 expectedMessageEN
-            }, errors);
+            }).AsCollection);
         }
     }
 }
\ No newline at end of file