Index: DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SurfaceLine2Tests.cs
===================================================================
diff -u -r4540 -r4624
--- DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SurfaceLine2Tests.cs	(.../SurfaceLine2Tests.cs)	(revision 4540)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SurfaceLine2Tests.cs	(.../SurfaceLine2Tests.cs)	(revision 4624)
@@ -34,111 +34,111 @@
     public void TestAddingCharacteristicPointsOnSameLocationDoesNotAddDoublePointsInGeometry()
     {
         SurfaceLine2 surfaceLine = FillSurfaceLine2();
-        Assert.AreEqual(10, surfaceLine.CharacteristicPoints.Count);
+        Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(10));
         ValidateSurfaceLine(surfaceLine);
     }
 
     [Test]
     public void TestDeepCloneWithoutGeometryMustContainPoint()
     {
         SurfaceLine2 surfaceLine = FillSurfaceLine2();
-        Assert.AreEqual(10, surfaceLine.CharacteristicPoints.Count);
-        Assert.AreEqual(9, surfaceLine.Geometry.Points.Count);
+        Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(10));
+        Assert.That(surfaceLine.Geometry.Points.Count, Is.EqualTo(9));
         // Note: resetting GeometryMustContainPoint to false after filling the surface line will erase all Characteristic Points.
         // So the actual code should NEVER reset the GeometryMustContainPoint for filled surface lines. 
         surfaceLine.CharacteristicPoints.GeometryMustContainPoint = false;
-        Assert.AreEqual(0, surfaceLine.CharacteristicPoints.Count);
+        Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(0));
         SurfaceLine2 newSurfaceLine = surfaceLine.FullDeepClone();
         surfaceLine.CharacteristicPoints.Clear();
         surfaceLine.Geometry.CalcPoints.Clear();
         surfaceLine.Geometry.SyncPoints();
-        Assert.AreEqual(0, newSurfaceLine.CharacteristicPoints.Count);
-        Assert.AreEqual(9, newSurfaceLine.Geometry.Points.Count);
+        Assert.That(newSurfaceLine.CharacteristicPoints.Count, Is.EqualTo(0));
+        Assert.That(newSurfaceLine.Geometry.Points.Count, Is.EqualTo(9));
     }
 
     [Test]
     public void TestDeepCloneWithGeometryMustContainPoint()
     {
         SurfaceLine2 surfaceLine = FillSurfaceLine2();
-        Assert.AreEqual(10, surfaceLine.CharacteristicPoints.Count);
-        Assert.AreEqual(9, surfaceLine.Geometry.Points.Count);
+        Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(10));
+        Assert.That(surfaceLine.Geometry.Points.Count, Is.EqualTo(9));
         // Note: resetting GeometryMustContainPoint to true after filling the surface line reset the Characteristic Points to be
         // equal to the amount of geometry points, keeping only one type, possibly making the surface line invalid.
         // So the actual code should NEVER reset the GeometryMustContainPoint for filled surface lines.
         surfaceLine.CharacteristicPoints.GeometryMustContainPoint = true;
-        Assert.AreEqual(9, surfaceLine.Geometry.Points.Count);
-        Assert.AreEqual(9, surfaceLine.CharacteristicPoints.Count);
+        Assert.That(surfaceLine.Geometry.Points.Count, Is.EqualTo(9));
+        Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(9));
         SurfaceLine2 newSurfaceLine = surfaceLine.FullDeepClone();
         surfaceLine.CharacteristicPoints.Clear();
         surfaceLine.Geometry.CalcPoints.Clear();
         surfaceLine.Geometry.SyncPoints();
-        Assert.AreEqual(9, newSurfaceLine.CharacteristicPoints.Count);
-        Assert.AreEqual(9, newSurfaceLine.Geometry.Points.Count);
+        Assert.That(newSurfaceLine.CharacteristicPoints.Count, Is.EqualTo(9));
+        Assert.That(newSurfaceLine.Geometry.Points.Count, Is.EqualTo(9));
     }
 
     [Test]
     public void TestDeepCloneWithoutSettingGeometryMustContainPoint()
     {
         SurfaceLine2 surfaceLine = FillSurfaceLine2();
-        Assert.AreEqual(10, surfaceLine.CharacteristicPoints.Count);
-        Assert.AreEqual(9, surfaceLine.Geometry.Points.Count);
+        Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(10));
+        Assert.That(surfaceLine.Geometry.Points.Count, Is.EqualTo(9));
         SurfaceLine2 newSurfaceLine = surfaceLine.FullDeepClone();
         surfaceLine.CharacteristicPoints.Clear();
         surfaceLine.Geometry.CalcPoints.Clear();
         surfaceLine.Geometry.SyncPoints();
-        Assert.AreEqual(10, newSurfaceLine.CharacteristicPoints.Count);
-        Assert.AreEqual(9, newSurfaceLine.Geometry.Points.Count);
+        Assert.That(newSurfaceLine.CharacteristicPoints.Count, Is.EqualTo(10));
+        Assert.That(newSurfaceLine.Geometry.Points.Count, Is.EqualTo(9));
         var tolerance = 1e-8;
         surfaceLine = FillSurfaceLine2();
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[0].X, newSurfaceLine.CharacteristicPoints[0].X, tolerance);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[0].Z, newSurfaceLine.CharacteristicPoints[0].Z, tolerance);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[0].CharacteristicPointType,
-                        newSurfaceLine.CharacteristicPoints[0].CharacteristicPointType);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[1].X, newSurfaceLine.CharacteristicPoints[1].X, tolerance);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[1].Z, newSurfaceLine.CharacteristicPoints[1].Z, tolerance);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[1].CharacteristicPointType,
-                        newSurfaceLine.CharacteristicPoints[1].CharacteristicPointType);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[2].X, newSurfaceLine.CharacteristicPoints[2].X, tolerance);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[2].Z, newSurfaceLine.CharacteristicPoints[2].Z, tolerance);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[2].CharacteristicPointType,
-                        newSurfaceLine.CharacteristicPoints[2].CharacteristicPointType);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[3].X, newSurfaceLine.CharacteristicPoints[3].X, tolerance);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[3].Z, newSurfaceLine.CharacteristicPoints[3].Z, tolerance);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[3].CharacteristicPointType,
-                        newSurfaceLine.CharacteristicPoints[3].CharacteristicPointType);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[4].X, newSurfaceLine.CharacteristicPoints[4].X, tolerance);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[4].Z, newSurfaceLine.CharacteristicPoints[4].Z, tolerance);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[4].CharacteristicPointType,
-                        newSurfaceLine.CharacteristicPoints[4].CharacteristicPointType);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[5].X, newSurfaceLine.CharacteristicPoints[5].X, tolerance);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[5].Z, newSurfaceLine.CharacteristicPoints[5].Z, tolerance);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[5].CharacteristicPointType,
-                        newSurfaceLine.CharacteristicPoints[5].CharacteristicPointType);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[6].X, newSurfaceLine.CharacteristicPoints[6].X, tolerance);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[6].Z, newSurfaceLine.CharacteristicPoints[6].Z, tolerance);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[6].CharacteristicPointType,
-                        newSurfaceLine.CharacteristicPoints[6].CharacteristicPointType);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[7].X, newSurfaceLine.CharacteristicPoints[7].X, tolerance);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[7].Z, newSurfaceLine.CharacteristicPoints[7].Z, tolerance);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[7].CharacteristicPointType,
-                        newSurfaceLine.CharacteristicPoints[7].CharacteristicPointType);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[8].X, newSurfaceLine.CharacteristicPoints[8].X, tolerance);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[8].Z, newSurfaceLine.CharacteristicPoints[8].Z, tolerance);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[8].CharacteristicPointType,
-                        newSurfaceLine.CharacteristicPoints[8].CharacteristicPointType);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[9].X, newSurfaceLine.CharacteristicPoints[9].X, tolerance);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[9].Z, newSurfaceLine.CharacteristicPoints[9].Z, tolerance);
-        Assert.AreEqual(surfaceLine.CharacteristicPoints[9].CharacteristicPointType,
-                        newSurfaceLine.CharacteristicPoints[9].CharacteristicPointType);
+        Assert.That(newSurfaceLine.CharacteristicPoints[0].X, Is.EqualTo(surfaceLine.CharacteristicPoints[0].X).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[0].Z, Is.EqualTo(surfaceLine.CharacteristicPoints[0].Z).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[0].CharacteristicPointType,
+                        Is.EqualTo(surfaceLine.CharacteristicPoints[0].CharacteristicPointType));
+        Assert.That(newSurfaceLine.CharacteristicPoints[1].X, Is.EqualTo(surfaceLine.CharacteristicPoints[1].X).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[1].Z, Is.EqualTo(surfaceLine.CharacteristicPoints[1].Z).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[1].CharacteristicPointType,
+                        Is.EqualTo(surfaceLine.CharacteristicPoints[1].CharacteristicPointType));
+        Assert.That(newSurfaceLine.CharacteristicPoints[2].X, Is.EqualTo(surfaceLine.CharacteristicPoints[2].X).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[2].Z, Is.EqualTo(surfaceLine.CharacteristicPoints[2].Z).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[2].CharacteristicPointType,
+                        Is.EqualTo(surfaceLine.CharacteristicPoints[2].CharacteristicPointType));
+        Assert.That(newSurfaceLine.CharacteristicPoints[3].X, Is.EqualTo(surfaceLine.CharacteristicPoints[3].X).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[3].Z, Is.EqualTo(surfaceLine.CharacteristicPoints[3].Z).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[3].CharacteristicPointType,
+                        Is.EqualTo(surfaceLine.CharacteristicPoints[3].CharacteristicPointType));
+        Assert.That(newSurfaceLine.CharacteristicPoints[4].X, Is.EqualTo(surfaceLine.CharacteristicPoints[4].X).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[4].Z, Is.EqualTo(surfaceLine.CharacteristicPoints[4].Z).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[4].CharacteristicPointType,
+                        Is.EqualTo(surfaceLine.CharacteristicPoints[4].CharacteristicPointType));
+        Assert.That(newSurfaceLine.CharacteristicPoints[5].X, Is.EqualTo(surfaceLine.CharacteristicPoints[5].X).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[5].Z, Is.EqualTo(surfaceLine.CharacteristicPoints[5].Z).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[5].CharacteristicPointType,
+                        Is.EqualTo(surfaceLine.CharacteristicPoints[5].CharacteristicPointType));
+        Assert.That(newSurfaceLine.CharacteristicPoints[6].X, Is.EqualTo(surfaceLine.CharacteristicPoints[6].X).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[6].Z, Is.EqualTo(surfaceLine.CharacteristicPoints[6].Z).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[6].CharacteristicPointType,
+                        Is.EqualTo(surfaceLine.CharacteristicPoints[6].CharacteristicPointType));
+        Assert.That(newSurfaceLine.CharacteristicPoints[7].X, Is.EqualTo(surfaceLine.CharacteristicPoints[7].X).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[7].Z, Is.EqualTo(surfaceLine.CharacteristicPoints[7].Z).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[7].CharacteristicPointType,
+                        Is.EqualTo(surfaceLine.CharacteristicPoints[7].CharacteristicPointType));
+        Assert.That(newSurfaceLine.CharacteristicPoints[8].X, Is.EqualTo(surfaceLine.CharacteristicPoints[8].X).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[8].Z, Is.EqualTo(surfaceLine.CharacteristicPoints[8].Z).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[8].CharacteristicPointType,
+                        Is.EqualTo(surfaceLine.CharacteristicPoints[8].CharacteristicPointType));
+        Assert.That(newSurfaceLine.CharacteristicPoints[9].X, Is.EqualTo(surfaceLine.CharacteristicPoints[9].X).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[9].Z, Is.EqualTo(surfaceLine.CharacteristicPoints[9].Z).Within(tolerance));
+        Assert.That(newSurfaceLine.CharacteristicPoints[9].CharacteristicPointType,
+                        Is.EqualTo(surfaceLine.CharacteristicPoints[9].CharacteristicPointType));
     }
 
     private static void ValidateSurfaceLine(SurfaceLine2 surfaceLine)
     {
         var tolerance = 0.001;
-        Assert.AreEqual(2, surfaceLine.CharacteristicPoints.Count(cp => Math.Abs(cp.X - 13.0) < tolerance && Math.Abs(cp.Z - 5.4) < tolerance));
+        Assert.That(surfaceLine.CharacteristicPoints.Count(cp => Math.Abs(cp.X - 13.0) < tolerance && Math.Abs(cp.Z - 5.4) < tolerance), Is.EqualTo(2));
         // Because TrafficLoadOutside and DikeTopAtPolder are on the same location, 1 point less should be in the geometry
-        Assert.AreEqual(9, surfaceLine.Geometry.Points.Count);
-        Assert.AreEqual(1, surfaceLine.Geometry.Points.Count(cp => Math.Abs(cp.X - 13.0) < tolerance && Math.Abs(cp.Z - 5.4) < tolerance));
+        Assert.That(surfaceLine.Geometry.Points.Count, Is.EqualTo(9));
+        Assert.That(surfaceLine.Geometry.Points.Count(cp => Math.Abs(cp.X - 13.0) < tolerance && Math.Abs(cp.Z - 5.4) < tolerance), Is.EqualTo(1));
     }
 
     private SurfaceLine2 FillSurfaceLine2()