Index: DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SurfaceLine2Tests.cs
===================================================================
diff -u -r6086 -r6106
--- DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SurfaceLine2Tests.cs	(.../SurfaceLine2Tests.cs)	(revision 6086)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SurfaceLine2Tests.cs	(.../SurfaceLine2Tests.cs)	(revision 6106)
@@ -34,109 +34,134 @@
     public void TestAddingCharacteristicPointsOnSameLocationDoesNotAddDoublePointsInGeometry()
     {
         SurfaceLine2 surfaceLine = FillSurfaceLine2();
-        Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(10));
+        Assert.That(surfaceLine.CharacteristicPoints, Has.Count.EqualTo(10));
         ValidateSurfaceLine(surfaceLine);
     }
 
     [Test]
     public void TestDeepCloneWithoutGeometryMustContainPoint()
     {
         SurfaceLine2 surfaceLine = FillSurfaceLine2();
-        Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(10));
-        Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9));
+        Assert.Multiple(() =>
+        {
+            Assert.That(surfaceLine.CharacteristicPoints, Has.Count.EqualTo(10));
+            Assert.That(surfaceLine.Geometry.CalcPoints, Has.Count.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.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(0));
+        Assert.That(surfaceLine.CharacteristicPoints, Is.Empty);
         SurfaceLine2 newSurfaceLine = surfaceLine.FullDeepClone();
         surfaceLine.CharacteristicPoints.Clear();
         surfaceLine.Geometry.CalcPoints.Clear();
-        Assert.That(newSurfaceLine.CharacteristicPoints.Count, Is.EqualTo(0));
-        Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9));
+        Assert.Multiple(() =>
+        {
+            Assert.That(newSurfaceLine.CharacteristicPoints, Is.Empty);
+            Assert.That(newSurfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9));
+        });
     }
 
     [Test]
     public void TestDeepCloneWithGeometryMustContainPoint()
     {
         SurfaceLine2 surfaceLine = FillSurfaceLine2();
-        Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(10));
-        Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9));
+        Assert.Multiple(() =>
+        {
+            Assert.That(surfaceLine.CharacteristicPoints, Has.Count.EqualTo(10));
+            Assert.That(surfaceLine.Geometry.CalcPoints, Has.Count.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.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9));
-        Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(9));
+        Assert.Multiple(() =>
+        {
+            Assert.That(surfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9));
+            Assert.That(surfaceLine.CharacteristicPoints, Has.Count.EqualTo(9));
+        });
         SurfaceLine2 newSurfaceLine = surfaceLine.FullDeepClone();
         surfaceLine.CharacteristicPoints.Clear();
         surfaceLine.Geometry.CalcPoints.Clear();
-        
-        Assert.That(newSurfaceLine.CharacteristicPoints.Count, Is.EqualTo(9));
-        Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9));
+        Assert.Multiple(() =>
+        {
+            Assert.That(newSurfaceLine.CharacteristicPoints, Has.Count.EqualTo(9));
+            Assert.That(newSurfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9));
+        });
     }
 
     [Test]
     public void TestDeepCloneWithoutSettingGeometryMustContainPoint()
     {
         SurfaceLine2 surfaceLine = FillSurfaceLine2();
-        Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(10));
-        Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9));
+        Assert.Multiple(() =>
+        {
+            Assert.That(surfaceLine.CharacteristicPoints, Has.Count.EqualTo(10));
+            Assert.That(surfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9));
+        });
         SurfaceLine2 newSurfaceLine = surfaceLine.FullDeepClone();
         surfaceLine.CharacteristicPoints.Clear();
         surfaceLine.Geometry.CalcPoints.Clear();
-        
-        Assert.That(newSurfaceLine.CharacteristicPoints.Count, Is.EqualTo(10));
-        Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9));
+        Assert.Multiple(() =>
+        {
+            Assert.That(newSurfaceLine.CharacteristicPoints, Has.Count.EqualTo(10));
+            Assert.That(newSurfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9));
+        });
         var tolerance = 1e-8;
         surfaceLine = FillSurfaceLine2();
-        Assert.That(newSurfaceLine.CharacteristicPoints[0].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[0].Point.X).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[0].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[0].Point.Z).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[0].CharacteristicPointType,
-                    Is.EqualTo(surfaceLine.CharacteristicPoints[0].CharacteristicPointType));
-        Assert.That(newSurfaceLine.CharacteristicPoints[1].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[1].Point.X).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[1].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[1].Point.Z).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[1].CharacteristicPointType,
-                    Is.EqualTo(surfaceLine.CharacteristicPoints[1].CharacteristicPointType));
-        Assert.That(newSurfaceLine.CharacteristicPoints[2].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[2].Point.X).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[2].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[2].Point.Z).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[2].CharacteristicPointType,
-                    Is.EqualTo(surfaceLine.CharacteristicPoints[2].CharacteristicPointType));
-        Assert.That(newSurfaceLine.CharacteristicPoints[3].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[3].Point.X).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[3].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[3].Point.Z).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[3].CharacteristicPointType,
-                    Is.EqualTo(surfaceLine.CharacteristicPoints[3].CharacteristicPointType));
-        Assert.That(newSurfaceLine.CharacteristicPoints[4].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[4].Point.X).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[4].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[4].Point.Z).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[4].CharacteristicPointType,
-                    Is.EqualTo(surfaceLine.CharacteristicPoints[4].CharacteristicPointType));
-        Assert.That(newSurfaceLine.CharacteristicPoints[5].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[5].Point.X).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[5].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[5].Point.Z).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[5].CharacteristicPointType,
-                    Is.EqualTo(surfaceLine.CharacteristicPoints[5].CharacteristicPointType));
-        Assert.That(newSurfaceLine.CharacteristicPoints[6].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[6].Point.X).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[6].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[6].Point.Z).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[6].CharacteristicPointType,
-                    Is.EqualTo(surfaceLine.CharacteristicPoints[6].CharacteristicPointType));
-        Assert.That(newSurfaceLine.CharacteristicPoints[7].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[7].Point.X).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[7].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[7].Point.Z).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[7].CharacteristicPointType,
-                    Is.EqualTo(surfaceLine.CharacteristicPoints[7].CharacteristicPointType));
-        Assert.That(newSurfaceLine.CharacteristicPoints[8].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[8].Point.X).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[8].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[8].Point.Z).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[8].CharacteristicPointType,
-                    Is.EqualTo(surfaceLine.CharacteristicPoints[8].CharacteristicPointType));
-        Assert.That(newSurfaceLine.CharacteristicPoints[9].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[9].Point.X).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[9].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[9].Point.Z).Within(tolerance));
-        Assert.That(newSurfaceLine.CharacteristicPoints[9].CharacteristicPointType,
-                    Is.EqualTo(surfaceLine.CharacteristicPoints[9].CharacteristicPointType));
+        Assert.Multiple(() =>
+        {
+            Assert.That(newSurfaceLine.CharacteristicPoints[0].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[0].Point.X).Within(tolerance));
+            Assert.That(newSurfaceLine.CharacteristicPoints[0].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[0].Point.Z).Within(tolerance));
+            Assert.That(newSurfaceLine.CharacteristicPoints[0].CharacteristicPointType,
+                        Is.EqualTo(surfaceLine.CharacteristicPoints[0].CharacteristicPointType));
+            Assert.That(newSurfaceLine.CharacteristicPoints[1].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[1].Point.X).Within(tolerance));
+            Assert.That(newSurfaceLine.CharacteristicPoints[1].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[1].Point.Z).Within(tolerance));
+            Assert.That(newSurfaceLine.CharacteristicPoints[1].CharacteristicPointType,
+                        Is.EqualTo(surfaceLine.CharacteristicPoints[1].CharacteristicPointType));
+            Assert.That(newSurfaceLine.CharacteristicPoints[2].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[2].Point.X).Within(tolerance));
+            Assert.That(newSurfaceLine.CharacteristicPoints[2].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[2].Point.Z).Within(tolerance));
+            Assert.That(newSurfaceLine.CharacteristicPoints[2].CharacteristicPointType,
+                        Is.EqualTo(surfaceLine.CharacteristicPoints[2].CharacteristicPointType));
+            Assert.That(newSurfaceLine.CharacteristicPoints[3].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[3].Point.X).Within(tolerance));
+            Assert.That(newSurfaceLine.CharacteristicPoints[3].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[3].Point.Z).Within(tolerance));
+            Assert.That(newSurfaceLine.CharacteristicPoints[3].CharacteristicPointType,
+                        Is.EqualTo(surfaceLine.CharacteristicPoints[3].CharacteristicPointType));
+            Assert.That(newSurfaceLine.CharacteristicPoints[4].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[4].Point.X).Within(tolerance));
+            Assert.That(newSurfaceLine.CharacteristicPoints[4].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[4].Point.Z).Within(tolerance));
+            Assert.That(newSurfaceLine.CharacteristicPoints[4].CharacteristicPointType,
+                        Is.EqualTo(surfaceLine.CharacteristicPoints[4].CharacteristicPointType));
+            Assert.That(newSurfaceLine.CharacteristicPoints[5].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[5].Point.X).Within(tolerance));
+            Assert.That(newSurfaceLine.CharacteristicPoints[5].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[5].Point.Z).Within(tolerance));
+            Assert.That(newSurfaceLine.CharacteristicPoints[5].CharacteristicPointType,
+                        Is.EqualTo(surfaceLine.CharacteristicPoints[5].CharacteristicPointType));
+            Assert.That(newSurfaceLine.CharacteristicPoints[6].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[6].Point.X).Within(tolerance));
+            Assert.That(newSurfaceLine.CharacteristicPoints[6].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[6].Point.Z).Within(tolerance));
+            Assert.That(newSurfaceLine.CharacteristicPoints[6].CharacteristicPointType,
+                        Is.EqualTo(surfaceLine.CharacteristicPoints[6].CharacteristicPointType));
+            Assert.That(newSurfaceLine.CharacteristicPoints[7].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[7].Point.X).Within(tolerance));
+            Assert.That(newSurfaceLine.CharacteristicPoints[7].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[7].Point.Z).Within(tolerance));
+            Assert.That(newSurfaceLine.CharacteristicPoints[7].CharacteristicPointType,
+                        Is.EqualTo(surfaceLine.CharacteristicPoints[7].CharacteristicPointType));
+            Assert.That(newSurfaceLine.CharacteristicPoints[8].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[8].Point.X).Within(tolerance));
+            Assert.That(newSurfaceLine.CharacteristicPoints[8].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[8].Point.Z).Within(tolerance));
+            Assert.That(newSurfaceLine.CharacteristicPoints[8].CharacteristicPointType,
+                        Is.EqualTo(surfaceLine.CharacteristicPoints[8].CharacteristicPointType));
+            Assert.That(newSurfaceLine.CharacteristicPoints[9].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[9].Point.X).Within(tolerance));
+            Assert.That(newSurfaceLine.CharacteristicPoints[9].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[9].Point.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.That(surfaceLine.CharacteristicPoints.Count(cp => Math.Abs(cp.Point.X - 13.0) < tolerance && Math.Abs(cp.Point.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.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9));
+        const double tolerance = 0.001;
+        Assert.Multiple(() =>
+        {
+            Assert.That(surfaceLine.CharacteristicPoints.Count(cp => Math.Abs(cp.Point.X - 13.0) < tolerance && Math.Abs(cp.Point.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.That(surfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9));
+        });
         Assert.That(surfaceLine.Geometry.CalcPoints.Count(cp => Math.Abs(cp.X - 13.0) < tolerance && Math.Abs(cp.Z - 5.4) < tolerance), Is.EqualTo(1));
     }