Index: DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/StabilityInsideBishopGridTest.cs
===================================================================
diff -u -r4611 -r4626
--- DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/StabilityInsideBishopGridTest.cs	(.../StabilityInsideBishopGridTest.cs)	(revision 4611)
+++ DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/StabilityInsideBishopGridTest.cs	(.../StabilityInsideBishopGridTest.cs)	(revision 4626)
@@ -99,97 +99,97 @@
         string[] validParameterIDs = Enum.GetNames(typeof(TimeSerieParameters));
         foreach (TimeSerie timeSeries in series)
         {
-            Assert.IsTrue(validParameterIDs.Any(n => n == timeSeries.ParameterId));
-            Assert.IsTrue(locations.Any(l => l.Name == timeSeries.LocationId));
+            Assert.That(validParameterIDs.Any(n => n == timeSeries.ParameterId), Is.True);
+            Assert.That(locations.Any(l => l.Name == timeSeries.LocationId), Is.True);
             // StabilityInside check
             if (timeSeries.ParameterId == TimeSerieParameters.StabilityInsideFactor.ToString())
             {
                 if (timeSeries.LocationId == "Purmer_PU0042+00_K")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.548, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.548).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(1.725, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(1.725).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
 
                 if (timeSeries.LocationId == "Purmer_PU0042+00_K_V")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.493, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.493).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(1.649, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(1.649).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
                 
                 if (timeSeries.LocationId == "Purmer_PU0042+00_R")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.324, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.324).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(1.479, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(1.479).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
                 
                 if (timeSeries.LocationId == "Purmer_PU0042+00_R_V")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.279, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.279).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(1.419, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(1.419).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
                 
                 if (timeSeries.LocationId == "Purmer_PU0110+20_K")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.536, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.536).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(1.702, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(1.702).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
                 
                 if (timeSeries.LocationId == "Purmer_PU0110+20_K_V")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.480, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.480).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(1.636, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(1.636).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
                 
                 if (timeSeries.LocationId == "Purmer_PU0110+20_R")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.317, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.317).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(1.462, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(1.462).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
                 
                 if (timeSeries.LocationId == "Purmer_PU0110+20_R_V")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.270, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.270).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(1.406, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(1.406).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
             }
 
             seriesCount++;
         }
 
-        Assert.IsTrue(seriesCount > 0, "No output time series");
-        Assert.AreEqual(16, resultsCount, "Incorrect number of results");
+        Assert.That(seriesCount > 0, Is.True, "No output time series");
+        Assert.That(resultsCount, Is.EqualTo(16), "Incorrect number of results");
     }
 
     
Index: DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/Deltares.DamLive.Tests.csproj
===================================================================
diff -u -r4610 -r4626
--- DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/Deltares.DamLive.Tests.csproj	(.../Deltares.DamLive.Tests.csproj)	(revision 4610)
+++ DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/Deltares.DamLive.Tests.csproj	(.../Deltares.DamLive.Tests.csproj)	(revision 4626)
@@ -34,9 +34,6 @@
         <ProjectReference Include="..\Deltares.DamLive.TestHelper\Deltares.DamLive.TestHelper.csproj"/>
     </ItemGroup>
     <ItemGroup>
-        <PackageReference Include="NUnit" Version="3.13.3"/>
-    </ItemGroup>
-    <ItemGroup>
         <None Update="TestData\DamLive\Set3\output.Geometries\1C-31,5-bishop-binnen.sti">
             <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
         </None>
Index: DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/CalculationParametersAssemblerTest.cs
===================================================================
diff -u -r4069 -r4626
--- DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/CalculationParametersAssemblerTest.cs	(.../CalculationParametersAssemblerTest.cs)	(revision 4069)
+++ DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/CalculationParametersAssemblerTest.cs	(.../CalculationParametersAssemblerTest.cs)	(revision 4626)
@@ -107,18 +107,18 @@
         // Calculation modules
         Assert.IsNotNull(calculationParameters.CalculationModules);
 
-        Assert.IsTrue(calculationParameters.CalculationModules.StabilityOutside, "CalculationModules.StabilityOutside");
-        Assert.IsTrue(calculationParameters.CalculationModules.StabilityInside, "CalculationModules.Stability");
-        Assert.IsTrue(calculationParameters.CalculationModules.PipingWti, "CalculationModules.PipingWti");
-        Assert.IsTrue(calculationParameters.CalculationModules.PipingBligh, "CalculationModules.PipingBligh");
-        Assert.IsTrue(calculationParameters.CalculationModules.PipingSellmeijer, "CalculationModules.PipingSellmeijer");
+        Assert.That(calculationParameters.CalculationModules.StabilityOutside, Is.True, "CalculationModules.StabilityOutside");
+        Assert.That(calculationParameters.CalculationModules.StabilityInside, Is.True, "CalculationModules.Stability");
+        Assert.That(calculationParameters.CalculationModules.PipingWti, Is.True, "CalculationModules.PipingWti");
+        Assert.That(calculationParameters.CalculationModules.PipingBligh, Is.True, "CalculationModules.PipingBligh");
+        Assert.That(calculationParameters.CalculationModules.PipingSellmeijer, Is.True, "CalculationModules.PipingSellmeijer");
 
         // MStab parameters
         Assert.IsNotNull(calculationParameters.MStabParameters);
 
-        Assert.AreEqual(false, calculationParameters.MStabParameters.IsCalculateAllStabilityProjectsAtOnce, "MStabParameters.IsCalculateAllStabilityProjectsAtOnce");
-        Assert.AreEqual(MStabModelType.UpliftVan, calculationParameters.MStabParameters.Model, "MStabParameters.Model");
-        Assert.AreEqual(MStabSearchMethod.Grid, calculationParameters.MStabParameters.SearchMethod, "MStabParameters.SearchMethod");
-        Assert.IsTrue(calculationParameters.MStabParameters.CalculationOptions.ZonesType.Equals(MStabZonesType.ForbiddenZone), "MStabParameters.CalculationOptions.ZonesType");
+        Assert.That(calculationParameters.MStabParameters.IsCalculateAllStabilityProjectsAtOnce, Is.EqualTo(false), "MStabParameters.IsCalculateAllStabilityProjectsAtOnce");
+        Assert.That(calculationParameters.MStabParameters.Model, Is.EqualTo(MStabModelType.UpliftVan), "MStabParameters.Model");
+        Assert.That(calculationParameters.MStabParameters.SearchMethod, Is.EqualTo(MStabSearchMethod.Grid), "MStabParameters.SearchMethod");
+        Assert.That(calculationParameters.MStabParameters.CalculationOptions.ZonesType.Equals(MStabZonesType.ForbiddenZone), Is.True, "MStabParameters.CalculationOptions.ZonesType");
     }
 }
\ No newline at end of file
Index: DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/DamLivePulauTekongStabilityOutwardTest.cs
===================================================================
diff -u -r4528 -r4626
--- DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/DamLivePulauTekongStabilityOutwardTest.cs	(.../DamLivePulauTekongStabilityOutwardTest.cs)	(revision 4528)
+++ DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/DamLivePulauTekongStabilityOutwardTest.cs	(.../DamLivePulauTekongStabilityOutwardTest.cs)	(revision 4626)
@@ -79,31 +79,31 @@
         string[] validParameterIDs = Enum.GetNames(typeof(TimeSerieParameters));
         foreach (TimeSerie timeSeries in series)
         {
-            Assert.IsTrue(validParameterIDs.Any(n => n == timeSeries.ParameterId));
-            Assert.IsTrue(locations.Any(l => l.Name == timeSeries.LocationId));
+            Assert.That(validParameterIDs.Any(n => n == timeSeries.ParameterId), Is.True);
+            Assert.That(locations.Any(l => l.Name == timeSeries.LocationId), Is.True);
             // StabilityOutside check
             if (timeSeries.ParameterId == TimeSerieParameters.StabilityOutsideFactor.ToString())
             {
                 if (timeSeries.LocationId == "SD CS1 3-3")
                 {
                     calculatedLocationCount++;
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(valueEntry1, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(valueEntry1).Within(cTolerance), "The computed safety factory is not correct");
                 }
 
                 if (timeSeries.LocationId == "SD CS2 8-8")
                 {
                     calculatedLocationCount++;
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(valueEntry2, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(valueEntry2).Within(cTolerance), "The computed safety factory is not correct");
                 }
             }
 
             seriesCount++;
         }
 
-        Assert.IsTrue(seriesCount > 0, "No output time series");
-        Assert.IsTrue(calculatedLocationCount == 2, "Not all locations have output for stability outside");
+        Assert.That(seriesCount > 0, Is.True, "No output time series");
+        Assert.That(calculatedLocationCount == 2, Is.True, "Not all locations have output for stability outside");
     }
 
     #region Helper methods
Index: DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/PipingWtiInsideTest.cs
===================================================================
diff -u -r4611 -r4626
--- DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/PipingWtiInsideTest.cs	(.../PipingWtiInsideTest.cs)	(revision 4611)
+++ DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/PipingWtiInsideTest.cs	(.../PipingWtiInsideTest.cs)	(revision 4626)
@@ -95,42 +95,42 @@
         string[] validParameterIDs = Enum.GetNames(typeof(TimeSerieParameters));
         foreach (TimeSerie timeSeries in series)
         {
-            Assert.IsTrue(validParameterIDs.Any(n => n == timeSeries.ParameterId));
-            Assert.IsTrue(locations.Any(l => l.Name == timeSeries.LocationId));
+            Assert.That(validParameterIDs.Any(n => n == timeSeries.ParameterId), Is.True);
+            Assert.That(locations.Any(l => l.Name == timeSeries.LocationId), Is.True);
             // StabilityInside check
             if (timeSeries.ParameterId == TimeSerieParameters.PipingFactor.ToString())
             {
                 resultsCount += timeSeries.Entries.Count;
                 if (timeSeries.LocationId == "Purmer_PU0042+00_K")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(0.740, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(0.740).Within(cTolerance), "The computed safety factory is not correct");
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(0.680, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(0.680).Within(cTolerance), "The computed safety factory is not correct");
                 }
 
                 if (timeSeries.LocationId == "Purmer_PU0042+00_K_V")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(0.740, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(0.740).Within(cTolerance), "The computed safety factory is not correct");
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(0.680, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(0.680).Within(cTolerance), "The computed safety factory is not correct");
                 }
 
                 if (timeSeries.LocationId == "Purmer_PU0110+20_R")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(90, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(90).Within(cTolerance), "The computed safety factory is not correct");
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(90, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(90).Within(cTolerance), "The computed safety factory is not correct");
                 }
             }
 
             seriesCount++;
         }
 
-        Assert.IsTrue(seriesCount > 0, "No output time series");
-        Assert.AreEqual(16, resultsCount, "Incorrect number of results");
+        Assert.That(seriesCount > 0, Is.True, "No output time series");
+        Assert.That(resultsCount, Is.EqualTo(16), "Incorrect number of results");
     }
 
 }
\ No newline at end of file
Index: DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/DamLivePulauTekongMissingValuesTest.cs
===================================================================
diff -u -r4528 -r4626
--- DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/DamLivePulauTekongMissingValuesTest.cs	(.../DamLivePulauTekongMissingValuesTest.cs)	(revision 4528)
+++ DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/DamLivePulauTekongMissingValuesTest.cs	(.../DamLivePulauTekongMissingValuesTest.cs)	(revision 4626)
@@ -80,31 +80,31 @@
         string[] validParameterIDs = Enum.GetNames(typeof(TimeSerieParameters));
         foreach (TimeSerie timeSeries in series)
         {
-            Assert.IsTrue(validParameterIDs.Any(n => n == timeSeries.ParameterId));
-            Assert.IsTrue(locations.Any(l => l.Name == timeSeries.LocationId));
+            Assert.That(validParameterIDs.Any(n => n == timeSeries.ParameterId), Is.True);
+            Assert.That(locations.Any(l => l.Name == timeSeries.LocationId), Is.True);
             // StabilityOutside check
             if (timeSeries.ParameterId == TimeSerieParameters.StabilityOutsideFactor.ToString())
             {
                 if (timeSeries.LocationId == "CD CS1 X1")
                 {
                     calculatedLocationCount++;
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(valueEntry1, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(valueEntry1).Within(cTolerance), "The computed safety factory is not correct");
                 }
 
                 if (timeSeries.LocationId == "CD CS2 X3")
                 {
                     calculatedLocationCount++;
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(valueEntry2, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(valueEntry2).Within(cTolerance), "The computed safety factory is not correct");
                 }
             }
 
             seriesCount++;
         }
 
-        Assert.IsTrue(seriesCount > 0, "No output time series");
-        Assert.IsTrue(calculatedLocationCount == 2, "Not all locations have output for stability outside");
+        Assert.That(seriesCount > 0, Is.True, "No output time series");
+        Assert.That(calculatedLocationCount == 2, Is.True, "Not all locations have output for stability outside");
     }
 
     #region Helper methods
Index: DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/StabilityInsideUpliftVanBeeSwarmTest.cs
===================================================================
diff -u -r4611 -r4626
--- DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/StabilityInsideUpliftVanBeeSwarmTest.cs	(.../StabilityInsideUpliftVanBeeSwarmTest.cs)	(revision 4611)
+++ DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/StabilityInsideUpliftVanBeeSwarmTest.cs	(.../StabilityInsideUpliftVanBeeSwarmTest.cs)	(revision 4626)
@@ -103,96 +103,96 @@
         string[] validParameterIDs = Enum.GetNames(typeof(TimeSerieParameters));
         foreach (TimeSerie timeSeries in series)
         {
-            Assert.IsTrue(validParameterIDs.Any(n => n == timeSeries.ParameterId));
-            Assert.IsTrue(locations.Any(l => l.Name == timeSeries.LocationId));
+            Assert.That(validParameterIDs.Any(n => n == timeSeries.ParameterId), Is.True);
+            Assert.That(locations.Any(l => l.Name == timeSeries.LocationId), Is.True);
             // StabilityInside check
             if (timeSeries.ParameterId == TimeSerieParameters.StabilityInsideFactor.ToString())
             {
                 if (timeSeries.LocationId == "Purmer_PU0042+00_K")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.442, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.442).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(1.579, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(1.579).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
 
                 if (timeSeries.LocationId == "Purmer_PU0042+00_K_V")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.365, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.365).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(1.481, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(1.481).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
 
                 if (timeSeries.LocationId == "Purmer_PU0042+00_R")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.239, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.239).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(1.355, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(1.355).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
                 if (timeSeries.LocationId == "Purmer_PU0042+00_R_V")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.168, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.168).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(1.272, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(1.272).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
                 
                 if (timeSeries.LocationId == "Purmer_PU0110+20_K")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(Double.NaN, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(Double.NaN, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
                 
                 if (timeSeries.LocationId == "Purmer_PU0110+20_K_V")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(Double.NaN, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(Double.NaN, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
                 
                 if (timeSeries.LocationId == "Purmer_PU0110+20_R")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(Double.NaN, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(Double.NaN, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
 
                 if (timeSeries.LocationId == "Purmer_PU0110+20_R_V")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(Double.NaN, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(Double.NaN, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
             }
 
             seriesCount++;
         }
 
-        Assert.IsTrue(seriesCount > 0, "No output time series");
-        Assert.AreEqual(16, resultsCount, "Incorrect number of results");
+        Assert.That(seriesCount > 0, Is.True, "No output time series");
+        Assert.That(resultsCount, Is.EqualTo(16), "Incorrect number of results");
     }
     
     [Category("Integration")]
@@ -214,7 +214,7 @@
         Input input = DamXmlSerialization.LoadInputFromXmlString(inputString);
         DamXmlSerialization.SaveInputAsXmlFile(testName, input);
         string result = engineInterface.Validate();
-        Assert.IsTrue(result == null, "Validation must succeed but does not, see output xml in debugger");
+        Assert.That(result == null, Is.True, "Validation must succeed but does not, see output xml in debugger");
         string outputString = engineInterface.Run();
         string outputName = "Output" + maxCores + ".xml";
         File.WriteAllText(outputName, outputString);
@@ -237,88 +237,88 @@
                 if (timeSeries.LocationId == "Purmer_PU0042+00_K")
                 {
                     DamEngine.Data.General.TimeSeries.TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.442, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.442).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     DamEngine.Data.General.TimeSeries.TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(1.579, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(1.579).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
 
                 if (timeSeries.LocationId == "Purmer_PU0042+00_K_V")
                 {
                     DamEngine.Data.General.TimeSeries.TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.365, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.365).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     DamEngine.Data.General.TimeSeries.TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(1.481, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(1.481).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
 
                 if (timeSeries.LocationId == "Purmer_PU0042+00_R")
                 {
                     DamEngine.Data.General.TimeSeries.TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.239, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.239).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     DamEngine.Data.General.TimeSeries.TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(1.355, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(1.355).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
                 if (timeSeries.LocationId == "Purmer_PU0042+00_R_V")
                 {
                     DamEngine.Data.General.TimeSeries.TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.168, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.168).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     DamEngine.Data.General.TimeSeries.TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(1.272, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(1.272).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
                 
                 if (timeSeries.LocationId == "Purmer_PU0110+20_K")
                 {
                     DamEngine.Data.General.TimeSeries.TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(Double.NaN, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     DamEngine.Data.General.TimeSeries.TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(Double.NaN, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
                 
                 if (timeSeries.LocationId == "Purmer_PU0110+20_K_V")
                 {
                     DamEngine.Data.General.TimeSeries.TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(Double.NaN, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     DamEngine.Data.General.TimeSeries.TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(Double.NaN, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
                 
                 if (timeSeries.LocationId == "Purmer_PU0110+20_R")
                 {
                     DamEngine.Data.General.TimeSeries.TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(Double.NaN, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     DamEngine.Data.General.TimeSeries.TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(Double.NaN, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
 
                 if (timeSeries.LocationId == "Purmer_PU0110+20_R_V")
                 {
                     DamEngine.Data.General.TimeSeries.TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(Double.NaN, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     DamEngine.Data.General.TimeSeries.TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(Double.NaN, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
             }
 
             seriesCount++;
         }
 
-        Assert.IsTrue(seriesCount > 0, "No output time series");
-        Assert.AreEqual(16, resultsCount, "Incorrect number of results");
+        Assert.That(seriesCount > 0, Is.True, "No output time series");
+        Assert.That(resultsCount, Is.EqualTo(16), "Incorrect number of results");
         
     }
     
Index: DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/DamLiveGrebbedijkTest.cs
===================================================================
diff -u -r4528 -r4626
--- DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/DamLiveGrebbedijkTest.cs	(.../DamLiveGrebbedijkTest.cs)	(revision 4528)
+++ DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/DamLiveGrebbedijkTest.cs	(.../DamLiveGrebbedijkTest.cs)	(revision 4626)
@@ -77,30 +77,30 @@
         string[] validParameterIDs = Enum.GetNames(typeof(TimeSerieParameters));
         foreach (TimeSerie timeSeries in series)
         {
-            Assert.IsTrue(validParameterIDs.Any(n => n == timeSeries.ParameterId));
-            Assert.IsTrue(locations.Any(l => l.Name == timeSeries.LocationId));
+            Assert.That(validParameterIDs.Any(n => n == timeSeries.ParameterId), Is.True);
+            Assert.That(locations.Any(l => l.Name == timeSeries.LocationId), Is.True);
             // StabilityInside check
             if (timeSeries.ParameterId == TimeSerieParameters.StabilityInsideFactor.ToString())
             {
                 if (timeSeries.LocationId == "grebbedijk1a")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.603, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.603).Within(cTolerance), "The computed safety factory is not correct");
                 }
 
                 if (timeSeries.LocationId == "grebbedijk3a")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
                     // Following value was 0.590 in the previous DamLive version, but that has to do with how the 
                     // reference level Su is handled in D-GeoStability 18.1 and D-GeoStability 15.1
-                    Assert.AreEqual(1.007, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.007).Within(cTolerance), "The computed safety factory is not correct");
                 }
             }
 
             seriesCount++;
         }
 
-        Assert.IsTrue(seriesCount > 0, "No output time series");
+        Assert.That(seriesCount > 0, Is.True, "No output time series");
     }
 
     #region Helper methods
Index: DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/DamLiveIntegrationTest.cs
===================================================================
diff -u -r4065 -r4626
--- DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/DamLiveIntegrationTest.cs	(.../DamLiveIntegrationTest.cs)	(revision 4065)
+++ DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/DamLiveIntegrationTest.cs	(.../DamLiveIntegrationTest.cs)	(revision 4626)
@@ -68,20 +68,20 @@
         string[] validParameterIDs = Enum.GetNames(typeof(TimeSerieParameters));
         foreach (TimeSerie timeSeries in series)
         {
-            Assert.IsTrue(validParameterIDs.Any(n => n == timeSeries.ParameterId));
-            Assert.IsTrue(locations.Any(l => l.Name == timeSeries.LocationId));
+            Assert.That(validParameterIDs.Any(n => n == timeSeries.ParameterId), Is.True);
+            Assert.That(locations.Any(l => l.Name == timeSeries.LocationId), Is.True);
 
             if (timeSeries.LocationId == locations[0].Name)
             {
                 TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                Assert.AreEqual(expectedSafetyFactor, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                Assert.That(firstEntry.Value, Is.EqualTo(expectedSafetyFactor).Within(cTolerance), "The computed safety factory is not correct");
             }
 
             seriesCount++;
         }
 
-        Assert.AreEqual(locations.Count, seriesCount);
-        Assert.IsTrue(seriesCount > 0, "No output time series");
+        Assert.That(seriesCount, Is.EqualTo(locations.Count));
+        Assert.That(seriesCount > 0, Is.True, "No output time series");
     }
 
     #region Helper methods
Index: DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/StabilityInsideUpliftVanGridTest.cs
===================================================================
diff -u -r4611 -r4626
--- DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/StabilityInsideUpliftVanGridTest.cs	(.../StabilityInsideUpliftVanGridTest.cs)	(revision 4611)
+++ DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/StabilityInsideUpliftVanGridTest.cs	(.../StabilityInsideUpliftVanGridTest.cs)	(revision 4626)
@@ -96,87 +96,87 @@
         string[] validParameterIDs = Enum.GetNames(typeof(TimeSerieParameters));
         foreach (TimeSerie timeSeries in series)
         {
-            Assert.IsTrue(validParameterIDs.Any(n => n == timeSeries.ParameterId));
-            Assert.IsTrue(locations.Any(l => l.Name == timeSeries.LocationId));
+            Assert.That(validParameterIDs.Any(n => n == timeSeries.ParameterId), Is.True);
+            Assert.That(locations.Any(l => l.Name == timeSeries.LocationId), Is.True);
             // StabilityInside check
             if (timeSeries.ParameterId == TimeSerieParameters.StabilityInsideFactor.ToString())
             {
                 if (timeSeries.LocationId == "Purmer_PU0042+00_K")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.456, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.456).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(1.583, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(1.583).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
 
                 if (timeSeries.LocationId == "Purmer_PU0042+00_K_V")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.366, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.366).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(1.480, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(1.480).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
 
                 if (timeSeries.LocationId == "Purmer_PU0042+00_R")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.248, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.248).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(1.359, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(1.359).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
                 if (timeSeries.LocationId == "Purmer_PU0042+00_R_V")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(1.172, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(1.172).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(1.271, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(1.271).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
                 
                 if (timeSeries.LocationId == "Purmer_PU0110+20_K")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(Double.NaN, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(Double.NaN, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
                 
                 if (timeSeries.LocationId == "Purmer_PU0110+20_K_V")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(Double.NaN, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(Double.NaN, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
                 
                 if (timeSeries.LocationId == "Purmer_PU0110+20_R")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(Double.NaN, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(Double.NaN, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
 
                 if (timeSeries.LocationId == "Purmer_PU0110+20_R_V")
                 {
                     TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                    Assert.AreEqual(Double.NaN, firstEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(firstEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                     TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                    Assert.AreEqual(Double.NaN, lastEntry.Value, cTolerance, "The computed safety factory is not correct");
+                    Assert.That(lastEntry.Value, Is.EqualTo(Double.NaN).Within(cTolerance), "The computed safety factory is not correct");
                     resultsCount++;
                 }
 
@@ -185,8 +185,8 @@
             seriesCount++;
         }
 
-        Assert.IsTrue(seriesCount > 0, "No output time series");
-        Assert.AreEqual(16, resultsCount, "Incorrect number of results");
+        Assert.That(seriesCount > 0, Is.True, "No output time series");
+        Assert.That(resultsCount, Is.EqualTo(16), "Incorrect number of results");
     }
 
 }
\ No newline at end of file
Index: DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/DamLiveUsingCompleteDataSetTest.cs
===================================================================
diff -u -r4056 -r4626
--- DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/DamLiveUsingCompleteDataSetTest.cs	(.../DamLiveUsingCompleteDataSetTest.cs)	(revision 4056)
+++ DamClients/DamLive/trunk/src/Deltares.DamLive.Tests/DamLiveUsingCompleteDataSetTest.cs	(.../DamLiveUsingCompleteDataSetTest.cs)	(revision 4626)
@@ -78,37 +78,37 @@
         string[] validParameterIDs = Enum.GetNames(typeof(TimeSerieParameters));
         foreach (TimeSerie timeSeries in series)
         {
-            Assert.IsTrue(validParameterIDs.Any(n => n == timeSeries.ParameterId));
-            Assert.IsTrue(locations.Any(l => l.Name == timeSeries.LocationId));
+            Assert.That(validParameterIDs.Any(n => n == timeSeries.ParameterId), Is.True);
+            Assert.That(locations.Any(l => l.Name == timeSeries.LocationId), Is.True);
 
             if (timeSeries.LocationId == "1C_31_5_bishop_binnen")
             {
                 TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                Assert.AreEqual(1.226, firstEntry.Value, "The computed safety factory is not correct");
+                Assert.That(firstEntry.Value, Is.EqualTo(1.226), "The computed safety factory is not correct");
                 TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                Assert.AreEqual(0.800, lastEntry.Value, "The computed safety factory is not correct");
+                Assert.That(lastEntry.Value, Is.EqualTo(0.800), "The computed safety factory is not correct");
             }
 
             if (timeSeries.LocationId == "1D_34_bishop_binnen")
             {
                 TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                Assert.AreEqual(1.319, firstEntry.Value, "The computed safety factory is not correct");
+                Assert.That(firstEntry.Value, Is.EqualTo(1.319), "The computed safety factory is not correct");
                 TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                Assert.AreEqual(0.864, lastEntry.Value, "The computed safety factory is not correct");
+                Assert.That(lastEntry.Value, Is.EqualTo(0.864), "The computed safety factory is not correct");
             }
 
             if (timeSeries.LocationId == "2A_37_bishop_binnen")
             {
                 TimeSerieEntry firstEntry = timeSeries.Entries.First();
-                Assert.AreEqual(1.318, firstEntry.Value, "The computed safety factory is not correct");
+                Assert.That(firstEntry.Value, Is.EqualTo(1.318), "The computed safety factory is not correct");
                 TimeSerieEntry lastEntry = timeSeries.Entries.Last();
-                Assert.AreEqual(0.891, lastEntry.Value, "The computed safety factory is not correct");
+                Assert.That(lastEntry.Value, Is.EqualTo(0.891), "The computed safety factory is not correct");
             }
 
             seriesCount++;
         }
 
-        Assert.AreEqual(locations.Count, seriesCount, "Number of output time series not equal to number of locations");
+        Assert.That(seriesCount, Is.EqualTo(locations.Count), "Number of output time series not equal to number of locations");
     }
 
     #region Helper methods