Index: dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/FactoryForSurfaceLineTests.cs
===================================================================
diff -u
--- dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/FactoryForSurfaceLineTests.cs	(revision 0)
+++ dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/FactoryForSurfaceLineTests.cs	(revision 275)
@@ -0,0 +1,142 @@
+using Deltares.DamPiping.ExitPointDeterminator;
+
+namespace Deltares.DamPiping.ExitPointDeterminatorTests
+
+{
+    public class FactoryForSurfaceLineTests
+    {
+        public static PipingSurfaceLine CreateSurfaceLineTutorial1()
+        {
+            //Surface line tutorial 1
+            var surfaceLine = new PipingSurfaceLine
+                {
+                    Name = "Tutorial1"
+                };
+
+            surfaceLine.Points.Add(new PipingPoint(0.0, 0, 0));
+            surfaceLine.Points.Add(new PipingPoint(10.0, 0, 0));
+            surfaceLine.Points.Add(new PipingPoint(34.5, 0, 5));
+            surfaceLine.Points.Add(new PipingPoint(40.5, 0, 5));
+            surfaceLine.Points.Add(new PipingPoint(50.5, 0, 0, PipingCharacteristicPointType.DikeToeAtPolder));
+            surfaceLine.Points.Add(new PipingPoint(58.5, 0, 0, PipingCharacteristicPointType.DitchDikeSide));
+            surfaceLine.Points.Add(new PipingPoint(59.5, 0, -2, PipingCharacteristicPointType.BottomDitchDikeSide));
+            surfaceLine.Points.Add(new PipingPoint(61.5, 0, -2, PipingCharacteristicPointType.BottomDitchPolderSide));
+            surfaceLine.Points.Add(new PipingPoint(61.5, 0, 0, PipingCharacteristicPointType.DitchPolderSide));
+            surfaceLine.Points.Add(new PipingPoint(75.0, 0, 0));
+            
+            return surfaceLine;
+        }
+
+        public static PipingSurfaceLine CreateSimpleSurfaceLineForExitPointTest()
+        {
+            var surfaceLine = new PipingSurfaceLine
+                {
+                    Name = "SimpleExitPoint"
+                };
+
+            surfaceLine.Points.Add(new PipingPoint(0.0, 0, 0));
+            surfaceLine.Points.Add(new PipingPoint(10.0, 0, 0));
+            surfaceLine.Points.Add(new PipingPoint(34.5, 0, 5));
+            surfaceLine.Points.Add(new PipingPoint(40.5, 0, 5));
+            surfaceLine.Points.Add(new PipingPoint(50.5, 0, 0, PipingCharacteristicPointType.DikeToeAtPolder));
+            surfaceLine.Points.Add(new PipingPoint(60.5, 0, -1));
+            surfaceLine.Points.Add(new PipingPoint(75.0, 0, 0));
+
+            return surfaceLine;
+        }
+
+        public static PipingSurfaceLine CreateHorizontalSurfaceLineForBenchmark1()
+        {
+            var surfaceLine = new PipingSurfaceLine
+                {
+                    Name = "HorizontalLine"
+                };
+            
+            surfaceLine.Points.Add(new PipingPoint(30, 0, -0.2, PipingCharacteristicPointType.DikeToeAtPolder));
+            surfaceLine.Points.Add(new PipingPoint(70, 0, -0.2));
+            
+            return surfaceLine;
+        }
+
+        public static PipingSurfaceLine CreateDescendingSurfaceLineForBenchmark2()
+        {
+            var surfaceLine = new PipingSurfaceLine
+                {
+                    Name = "NonHorizontalLine"
+                };
+            
+            surfaceLine.Points.Add(new PipingPoint(30, 0, -0.2, PipingCharacteristicPointType.DikeToeAtPolder));
+            surfaceLine.Points.Add(new PipingPoint(70, 0, -1.8));
+
+            return surfaceLine;
+        }
+
+        public static PipingSurfaceLine CreateHorizontalSurfaceLineWithSymmetricalDitchForBenchmark5()
+        {
+            var surfaceLine = new PipingSurfaceLine
+                {
+                    Name = "HorizontalLineWithSymmetricalDitch"
+                };
+            
+            surfaceLine.Points.Add(new PipingPoint(30, 0, 0, PipingCharacteristicPointType.DikeToeAtPolder));
+            surfaceLine.Points.Add(new PipingPoint(35, 0, 0, PipingCharacteristicPointType.DitchDikeSide));
+            surfaceLine.Points.Add(new PipingPoint(36, 0, -1.2, PipingCharacteristicPointType.BottomDitchDikeSide));
+            surfaceLine.Points.Add(new PipingPoint(37, 0, -1.2, PipingCharacteristicPointType.BottomDitchPolderSide));
+            surfaceLine.Points.Add(new PipingPoint(38, 0, 0, PipingCharacteristicPointType.DitchPolderSide));
+            surfaceLine.Points.Add(new PipingPoint(70, 0, 0));
+
+            return surfaceLine;
+        }
+
+        public static PipingSurfaceLine CreateNonHorizontalLineWithAsymmetricalDitchForBenchmark6()
+        {
+            var surfaceLine = new PipingSurfaceLine
+                {
+                    Name = "NonHorizontalLineWithAsymmetricalDitch"
+                };
+
+            surfaceLine.Points.Add(new PipingPoint(30, 0, 0, PipingCharacteristicPointType.DikeToeAtPolder));
+            surfaceLine.Points.Add(new PipingPoint(35.2, 0, -0.208, PipingCharacteristicPointType.DitchDikeSide));
+            surfaceLine.Points.Add(new PipingPoint(36, 0, -1.2, PipingCharacteristicPointType.BottomDitchDikeSide));
+            surfaceLine.Points.Add(new PipingPoint(37, 0, -1.3, PipingCharacteristicPointType.BottomDitchPolderSide));
+            surfaceLine.Points.Add(new PipingPoint(38, 0, -0.5, PipingCharacteristicPointType.DitchPolderSide));
+            surfaceLine.Points.Add(new PipingPoint(70, 0, -0.8));
+            
+            return surfaceLine;
+        }
+
+        public static PipingSurfaceLine CreateSurfaceLineWithAsymmetricalDitchHighPolderSide()
+        {
+            var surfaceLine = new PipingSurfaceLine
+                {
+                    Name = "AsymmetricalDitchHighPolderSide"
+                };
+
+            surfaceLine.Points.Add(new PipingPoint(30, 0, 0, PipingCharacteristicPointType.DikeToeAtPolder));
+            surfaceLine.Points.Add(new PipingPoint(35, 0, 0, PipingCharacteristicPointType.DitchDikeSide));
+            surfaceLine.Points.Add(new PipingPoint(36, 0, -1, PipingCharacteristicPointType.BottomDitchDikeSide));
+            surfaceLine.Points.Add(new PipingPoint(37, 0, -1, PipingCharacteristicPointType.BottomDitchPolderSide));
+            surfaceLine.Points.Add(new PipingPoint(38, 0, 1, PipingCharacteristicPointType.DitchPolderSide));
+            surfaceLine.Points.Add(new PipingPoint(70, 0, 0));
+
+            return surfaceLine;
+        }
+
+        public static PipingSurfaceLine CreateSurfaceLineWithAsymmetricalDitchHighDikeSide()
+        {
+            var surfaceLine = new PipingSurfaceLine
+                {
+                    Name = "AsymmetricalDitchHighPolderSide"
+                };
+
+            surfaceLine.Points.Add(new PipingPoint(30, 0, 0, PipingCharacteristicPointType.DikeToeAtPolder));
+            surfaceLine.Points.Add(new PipingPoint(35, 0, 3, PipingCharacteristicPointType.DitchDikeSide));
+            surfaceLine.Points.Add(new PipingPoint(36, 0, -1, PipingCharacteristicPointType.BottomDitchDikeSide));
+            surfaceLine.Points.Add(new PipingPoint(37, 0, -1, PipingCharacteristicPointType.BottomDitchPolderSide));
+            surfaceLine.Points.Add(new PipingPoint(38, 0, 0, PipingCharacteristicPointType.DitchPolderSide));
+            surfaceLine.Points.Add(new PipingPoint(70, 0, 0));
+            
+            return surfaceLine;
+        }
+    }
+}
\ No newline at end of file
Index: dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/PipingProfileTests.cs
===================================================================
diff -u
--- dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/PipingProfileTests.cs	(revision 0)
+++ dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/PipingProfileTests.cs	(revision 275)
@@ -0,0 +1,123 @@
+using NUnit.Framework;
+
+namespace Deltares.DamPiping.ExitPointDeterminatorTests
+{
+    [TestFixture]
+    public class PipingProfileTests
+    {
+        private const double cDiff = 1e-5;
+
+        [Test]
+        public void TestGetLayerHeight()
+        {
+            var profile = FactoryForSoilProfileTests.CreateTestProfile();
+            var topAquifer = profile.TopAquiferLayer;
+            var height = profile.GetLayerHeight(topAquifer);
+            Assert.AreEqual(20, height, cDiff);
+
+            height = profile.GetLayerHeight(profile.Layers[0]);
+            Assert.AreEqual(13, height, cDiff);
+        }
+
+        [Test]
+        public void TestAquiferDetermination()
+        {
+            // First only 1 aquifer layer at -10 so -10 expected for top and bottom aquifer.
+            var profile = FactoryForSoilProfileTests.CreateTestProfile();
+            var topAquifer = profile.TopAquiferLayer;
+            Assert.AreEqual(true, topAquifer.IsAquifer);
+            Assert.AreEqual(-10, topAquifer.TopLevel, cDiff);
+
+            var bottomAquifer = profile.BottomAquiferLayer;
+            Assert.AreEqual(true, bottomAquifer.IsAquifer);
+            Assert.AreEqual(-10, bottomAquifer.TopLevel, cDiff);
+
+            // Now 2 consecutive aquifer layers at -2.5 and -3.1 so -2.5 expected for top and bottom aquifer.
+            profile = FactoryForSoilProfileTests.CreateTestProfileTwoCoverSublayersTwoAquifers();
+            topAquifer = profile.TopAquiferLayer;
+            Assert.AreEqual(true, topAquifer.IsAquifer);
+            Assert.AreEqual(-2.5, topAquifer.TopLevel, cDiff);
+
+            bottomAquifer = profile.BottomAquiferLayer;
+            Assert.AreEqual(true, bottomAquifer.IsAquifer);
+            Assert.AreEqual(-2.5, bottomAquifer.TopLevel, cDiff);
+
+            // Now 2 non consecutive aquifer layers at -1.9 and -3.1 so -1.9 expected for top and -3.1 for bottom aquifer.
+            profile = FactoryForSoilProfileTests.CreateTestProfileOneCoverLayerOneInBetweenAquifer();
+            topAquifer = profile.TopAquiferLayer;
+            Assert.AreEqual(true, topAquifer.IsAquifer);
+            Assert.AreEqual(-1.9, topAquifer.TopLevel, cDiff);
+
+            bottomAquifer = profile.BottomAquiferLayer;
+            Assert.AreEqual(true, bottomAquifer.IsAquifer);
+            Assert.AreEqual(-3.1, bottomAquifer.TopLevel, cDiff);
+        }
+
+//        [Test]
+//        [TestCase(LanguageType.Dutch, "Het ondergrondprofiel heeft geen lagen, er moet tenminste 1 laag zijn.")]
+//        [TestCase(LanguageType.English, "The profile has no layers, it must have at least 1 layer.")]
+//        public void ValidateThrowsExceptionIfSoilProfileHasNoLayers(LanguageType type, string expectedMessage)
+//        {
+//            using(new LanguageTestHelper(type))
+//            {
+//                var profile = new PipingProfile
+//                {
+//                    BottomLevel = -1
+//                };
+//                TestDelegate test = () => profile.Validate();
+//                var message = Assert.Throws<PipingProfileException>(test).Message;
+//                Assert.AreEqual(expectedMessage, message);
+//            };
+//        }
+//
+//        [Test]
+//        [TestCase(LanguageType.Dutch, "De lagen zijn niet geordend van boven naar beneden.")]
+//        [TestCase(LanguageType.English, "The layers are not ordered from top to bottom.")]
+//        public void ValidateThrowsExceptionIfSoilProfileHasNonOrderedLayers(LanguageType type, string expectedMessage)
+//        {
+//            using (new LanguageTestHelper(type))
+//            {
+//                var profile = new PipingProfile
+//                {
+//                    BottomLevel = -1
+//                };
+//                var layer = new PipingLayer
+//                {
+//                    TopLevel = 0
+//                };
+//                profile.Layers.Add(layer);
+//                profile.Layers.Add(layer);
+//                TestDelegate test = () => profile.Validate();
+//                var message = Assert.Throws<PipingProfileException>(test).Message;
+//                Assert.AreEqual(expectedMessage, message);
+//            };
+//        }
+//
+//        [Test]
+//        [TestCase(LanguageType.Dutch, "De onderkant({0}) van het ondergrondprofiel is niet laag genoeg. Het moet tenminste {1} m onder de bovenkant van de diepste laag ({2}) liggen.")]
+//        [TestCase(LanguageType.English, "The bottomlevel ({0}) of the profile is not deep enough. It must be at least {1} m below the toplevel of the deepest layer ({2}).")]
+//        public void ValidateThrowsExceptionIfSoilProfileBottomIsNotDeepEnough(LanguageType type, string expectedMessageFormat)
+//        {
+//            using(new LanguageTestHelper(type))
+//            {
+//                var profile = new PipingProfile
+//                {
+//                    BottomLevel = -1
+//                };
+//                var layer = new PipingLayer
+//                {
+//                    TopLevel = 0
+//                };
+//                profile.Layers.Add(layer);
+//                var layer2 = new PipingLayer
+//                {
+//                    TopLevel = -1
+//                };
+//                profile.Layers.Add(layer2);
+//                TestDelegate test = () => profile.Validate();
+//                var message = Assert.Throws<PipingProfileException>(test).Message;
+//                Assert.AreEqual(string.Format(expectedMessageFormat, -1, 0.001, -1), message);
+//            };
+//        }
+    }
+}
Index: dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/PipingSurfaceLineTests.cs
===================================================================
diff -u
--- dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/PipingSurfaceLineTests.cs	(revision 0)
+++ dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/PipingSurfaceLineTests.cs	(revision 275)
@@ -0,0 +1,166 @@
+using Deltares.DamPiping.ExitPointDeterminator;
+using NUnit.Framework;
+
+namespace Deltares.DamPiping.ExitPointDeterminatorTests
+{
+    [TestFixture]
+    public class PipingSurfaceLineTests
+    {
+        [Test]
+        public void TestGetDikeToeInward()
+        {
+            var surfaceLine = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1();
+            var dikeToeInward = surfaceLine.GetDikeToeInward();
+            Assert.AreEqual(50.5, dikeToeInward.X);
+
+            // add point ShoulderBaseInside (just for this test, this is not how this should be done for real) 
+            surfaceLine.Points.Add(new PipingPoint(33.2, 0, 0, PipingCharacteristicPointType.ShoulderBaseInside));
+            dikeToeInward = surfaceLine.GetDikeToeInward();
+            Assert.AreEqual(33.2, dikeToeInward.X);
+
+            // now clear all points
+            surfaceLine.Points.Clear();
+            dikeToeInward = surfaceLine.GetDikeToeInward();
+            Assert.AreEqual(null, dikeToeInward);
+
+            //now just add two typeless points to check first! point is returned
+            surfaceLine.Points.Add(new PipingPoint(33.2, 0, 0));
+            surfaceLine.Points.Add(new PipingPoint(0, 0, 0));
+            dikeToeInward = surfaceLine.GetDikeToeInward();
+            Assert.AreEqual(33.2, dikeToeInward.X);
+        }
+
+//        [Test]
+//        public void ValidateDoesNotThrowExceptionOnEmptySurfaceLine()
+//        {
+//            var surfaceLine = new PipingSurfaceLine()
+//            {
+//                Name = "Surface line"
+//            };
+//            surfaceLine.Validate();
+//        }
+
+//        [Test]
+//        [TestCase(LanguageType.Dutch, "De x-coördinaten van de karakteristieke punten in de hoogtegeometrie Surface line zijn niet oplopend.")]
+//        [TestCase(LanguageType.English, "The characteristic point x coordinates are not ascending in surfaceline Surface line.")]
+//        public void ValidateThrowsExceptionIfCharacteristicPointsAreNotOrdered(LanguageType type, string expectedMessage)
+//        {
+//            using (new LanguageTestHelper(type))
+//            {
+//                var surfaceLine = new PipingSurfaceLine()
+//                {
+//                    Name = "Surface line"
+//                };
+//                surfaceLine.Points.Add(new PipingPoint(0, 0, 0, PipingCharacteristicPointType.DikeToeAtPolder));
+//                surfaceLine.Points.Add(new PipingPoint(3, 0, 0, PipingCharacteristicPointType.ShoulderBaseInside));
+//
+//                TestDelegate test = () => surfaceLine.Validate();
+//                var message = Assert.Throws<PipingSurfaceLineException>(test).Message;
+//                Assert.AreEqual(expectedMessage, message);
+//            }
+//        }
+//
+//        [Test]
+//        [TestCase(LanguageType.Dutch, "De sloot in de hoogtegeometrie Surface line is niet correct. Niet alle 4 punten zijn gedefinieerd of de volgorde is incorrect.")]
+//        [TestCase(LanguageType.English, "The ditch in surface line Surface line is incorrect. Not all 4 points are defined or the order is incorrect.")]
+//        public void ValidateThrowsExceptionIfCharacteristicPointsAreNotOrdered2(LanguageType type, string expectedMessage)
+//        {
+//            using (new LanguageTestHelper(type))
+//            {
+//                var surfaceLine = new PipingSurfaceLine()
+//                {
+//                    Name = "Surface line"
+//                };
+//                surfaceLine.Points.Add(new PipingPoint(0, 0, 0, PipingCharacteristicPointType.DikeToeAtPolder));
+//                surfaceLine.Points.Add(new PipingPoint(3, 0, 0, PipingCharacteristicPointType.BottomDitchDikeSide));
+//
+//                TestDelegate test = () => surfaceLine.Validate();
+//                var message = Assert.Throws<PipingSurfaceLineException>(test).Message;
+//                Assert.AreEqual(expectedMessage, message);
+//            }
+//        }
+//
+//        [Test]
+//        [TestCase(LanguageType.Dutch, "De sloot in de hoogtegeometrie Surface line is niet correct. Niet alle 4 punten zijn gedefinieerd of de volgorde is incorrect.")]
+//        [TestCase(LanguageType.English, "The ditch in surface line Surface line is incorrect. Not all 4 points are defined or the order is incorrect.")]
+//        public void ValidateThrowsExceptionIfCharacteristicPointsAreNotOrdered3(LanguageType type, string expectedMessage)
+//        {
+//            using (new LanguageTestHelper(type))
+//            {
+//                var surfaceLine = new PipingSurfaceLine()
+//                {
+//                    Name = "Surface line"
+//                };
+//                surfaceLine.Points.Add(new PipingPoint(0, 0, 0, PipingCharacteristicPointType.ShoulderBaseInside));
+//                surfaceLine.Points.Add(new PipingPoint(3, 0, 0, PipingCharacteristicPointType.DitchPolderSide));
+//
+//                TestDelegate test = () => surfaceLine.Validate();
+//                var message = Assert.Throws<PipingSurfaceLineException>(test).Message;
+//                Assert.AreEqual(expectedMessage, message);
+//            }
+//        }
+//
+//        [Test]
+//        [TestCase(LanguageType.Dutch, "De sloot in de hoogtegeometrie Surface line is niet correct. Niet alle 4 punten zijn gedefinieerd of de volgorde is incorrect.")]
+//        [TestCase(LanguageType.English, "The ditch in surface line Surface line is incorrect. Not all 4 points are defined or the order is incorrect.")]
+//        public void ValidateThrowsExceptionIfDitchIsIncomplete(LanguageType type, string expectedMessage)
+//        {
+//            using (new LanguageTestHelper(type))
+//            {
+//                var surfaceLine = new PipingSurfaceLine()
+//                {
+//                    Name = "Surface line"
+//                };
+//                surfaceLine.Points.Add(new PipingPoint(0, 0, 0, PipingCharacteristicPointType.DitchDikeSide));
+//                surfaceLine.Points.Add(new PipingPoint(3, 0, -1, PipingCharacteristicPointType.BottomDitchPolderSide));
+//                surfaceLine.Points.Add(new PipingPoint(3, 0, 0, PipingCharacteristicPointType.DitchPolderSide));
+//
+//                TestDelegate test = () => surfaceLine.Validate();
+//                var message = Assert.Throws<PipingSurfaceLineException>(test).Message;
+//                Assert.AreEqual(expectedMessage, message);
+//            }
+//        }
+//
+//        [Test]
+//        [TestCase(LanguageType.Dutch, "De sloot in de hoogtegeometrie Surface line is niet correct. Niet alle 4 punten zijn gedefinieerd of de volgorde is incorrect.")]
+//        [TestCase(LanguageType.English, "The ditch in surface line Surface line is incorrect. Not all 4 points are defined or the order is incorrect.")]
+//        public void ValidateThrowsExceptionIfDitchHasWrongOrder(LanguageType type, string expectedMessage)
+//        {
+//            using (new LanguageTestHelper(type))
+//            {
+//                var surfaceLine = new PipingSurfaceLine()
+//                {
+//                    Name = "Surface line"
+//                };
+//                surfaceLine.Points.Add(new PipingPoint(0, 0, 0, PipingCharacteristicPointType.DitchDikeSide));
+//                surfaceLine.Points.Add(new PipingPoint(2, 0, -1, PipingCharacteristicPointType.BottomDitchPolderSide));
+//                surfaceLine.Points.Add(new PipingPoint(3, 0, -1, PipingCharacteristicPointType.BottomDitchDikeSide));
+//                surfaceLine.Points.Add(new PipingPoint(3, 0, 0, PipingCharacteristicPointType.DitchPolderSide));
+//
+//                TestDelegate test = () => surfaceLine.Validate();
+//                var message = Assert.Throws<PipingSurfaceLineException>(test).Message;
+//                Assert.AreEqual(expectedMessage, message);
+//            }
+//        }
+//
+//        [Test]
+//        [TestCase(LanguageType.Dutch, "De x-coördinaten in de hoogtegeometrie Surface line zijn niet oplopend.")]
+//        [TestCase(LanguageType.English, "The point x coordinates are not ascending in surfaceline Surface line.")]
+//        public void ValidateThrowsExceptionIfAreNotOrdered(LanguageType type, string expectedMessage)
+//        {
+//            using (new LanguageTestHelper(type))
+//            {
+//                var surfaceLine = new PipingSurfaceLine()
+//                {
+//                    Name = "Surface line"
+//                };
+//                surfaceLine.Points.Add(new PipingPoint(4, 0, 0));
+//                surfaceLine.Points.Add(new PipingPoint(3, 0, 0));
+//
+//                TestDelegate test = () => surfaceLine.Validate();
+//                var message = Assert.Throws<PipingSurfaceLineException>(test).Message;
+//                Assert.AreEqual(expectedMessage, message);
+//            }
+//        }
+    }
+}
Index: dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/EffectiveThicknessCalculatorTests.cs
===================================================================
diff -u
--- dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/EffectiveThicknessCalculatorTests.cs	(revision 0)
+++ dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/EffectiveThicknessCalculatorTests.cs	(revision 275)
@@ -0,0 +1,187 @@
+using Deltares.DamPiping.ExitPointDeterminator;
+using NUnit.Framework;
+
+namespace Deltares.DamPiping.ExitPointDeterminatorTests
+{
+    [TestFixture]
+    public class EffectiveThicknessCalculatorTests
+    {
+        [Test]
+        public void CalculateEffectiveThicknessCalculatorResultIsInbetweenHeight()
+        {
+            var effectiveThicknessCalculator = FillSimpleEffectiveThicknessCalculator();
+            effectiveThicknessCalculator.SoilProfile.Layers[1].IsAquifer = true;
+            effectiveThicknessCalculator.ExitPointXCoordinate = 60; // left of ditch
+            effectiveThicknessCalculator.SurfaceLine.BottomDitchDikeSide.X = 61.0;
+            effectiveThicknessCalculator.Calculate();
+            // Surfacelevel = -2 (Inside ditch)
+            // So effective height = surfacelevel - top_bottom_aquifer = 1.0
+            // Width of bottom of ditch (0.5m) < height coverlayer in ditch (1m)
+            // So effective height must be calculated
+            //
+            // In effective stress calculator, the case 3 of par 3.3.3 is used
+            // Intersection left is at x = 60.583-*, y = 1.6666667: height = 1.333333
+            // Intersection right is at x = 62.75 , y = 0.0; is right of dictc, so take ditch top: x= 61.5, 0.0: height = 3 m
+            Assert.AreEqual(1.333333333, effectiveThicknessCalculator.EffectiveHeight, 0.001);
+            // From bottom to top
+            // effective height = 1.8m clay (submerged)= 1.8 * (20 - 10) = 10
+            Assert.AreEqual(13.3333333, effectiveThicknessCalculator.EffectiveStress, 0.001);
+        }
+
+        [Test]
+        public void CalculateEffectiveThicknessCalculatorResultIsMaximumHeight()
+        {
+            var effectiveThicknessCalculator = FillSimpleEffectiveThicknessCalculator();
+            // Set the top of the aquifer to the top of the second layer (-3)
+            effectiveThicknessCalculator.ExitPointXCoordinate = 56; // left of the ditch
+            effectiveThicknessCalculator.Calculate();
+            // Top of bottom aquifer is -3
+            // Surfacelevel = 0
+            // Outside ditch, so effective height = surfacelevel - top_bottom_aquifer = 10.0
+            Assert.AreEqual(10.0, effectiveThicknessCalculator.EffectiveHeight, 0.001);
+            // From bottom to top
+            // -10 to -3 = 7m clay2 (submerged)= 7 * (22 - 10) = 84
+            // -3 to -1 = 2m clay (submerged)= 2 * (20 - 10) = 20
+            // -1 to 0 = 1m clay (dry)= 1 * 18 = 18
+            Assert.AreEqual(122.0, effectiveThicknessCalculator.EffectiveStress, 0.001);
+
+            // Under the ditch effective stress and effective height are same as besides the ditch because 
+            // width of top of ditch (3m) < height coverlayer (10m) beside ditch
+            effectiveThicknessCalculator.ExitPointXCoordinate = 60; // left of ditch
+            effectiveThicknessCalculator.Calculate();
+            Assert.AreEqual(10.0, effectiveThicknessCalculator.EffectiveHeight, 0.001);
+            Assert.AreEqual(122.0, effectiveThicknessCalculator.EffectiveStress, 0.001);
+        }
+
+        [Test]
+        public void CalculateEffectiveThicknessCalculatorResultIsMinimumHeight()
+        {
+            var effectiveThicknessCalculator = new EffectiveThicknessCalculator
+                {
+                    SurfaceLine = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1(),
+                    SoilProfile = FactoryForSoilProfileTests.CreateTestProfile(),
+                    PhreaticLevel = -1,
+                    VolumicWeightOfWater = 10
+                };
+            effectiveThicknessCalculator.SoilProfile.Layers[1].IsAquifer = true;
+            effectiveThicknessCalculator.ExitPointXCoordinate = 60; // left of ditch
+            effectiveThicknessCalculator.Calculate();
+            // Surfacelevel = -2 (Inside ditch)
+            // So effective height = surfacelevel - top_bottom_aquifer = 1.0
+            // Width of bottom of ditch (2m) > height coverlayer in ditch (1m)
+            // So effective height = height coverlayer in ditch = 1m
+            Assert.AreEqual(1.0, effectiveThicknessCalculator.EffectiveHeight, 0.001);
+            // From bottom to top
+            // -3 to -2 = 1m clay (submerged)= 1 * (20 - 10) = 10
+            Assert.AreEqual(10.0, effectiveThicknessCalculator.EffectiveStress, 0.001);
+        }
+
+        [Test]
+        public void TestWidthOfASymmetricalDitchHighDikeSide()
+        {
+            var effectiveThicknessCalculator = new EffectiveThicknessCalculator
+                {
+                    SurfaceLine = FactoryForSurfaceLineTests.CreateSurfaceLineWithAsymmetricalDitchHighDikeSide()
+                };
+            Assert.AreEqual(2.25, effectiveThicknessCalculator.GetEffectiveWidthDitch(), 0.001);
+        }
+
+        [Test]
+        public void TestWidthOfASymmetricalDitchHighPolderSide()
+        {
+            var effectiveThicknessCalculator = new EffectiveThicknessCalculator
+                {
+                    SurfaceLine = FactoryForSurfaceLineTests.CreateSurfaceLineWithAsymmetricalDitchHighPolderSide()
+                };
+            Assert.AreEqual(2.5, effectiveThicknessCalculator.GetEffectiveWidthDitch(), 0.001);
+        }
+
+        [Test]
+        public void TestWidthOfSymmetricalDitch()
+        {
+            var effectiveThicknessCalculator = new EffectiveThicknessCalculator
+                {
+                    SurfaceLine = FactoryForSurfaceLineTests.CreateHorizontalSurfaceLineWithSymmetricalDitchForBenchmark5()
+                };
+            Assert.AreEqual(3.0, effectiveThicknessCalculator.GetEffectiveWidthDitch(), 0.001);
+        }
+
+        [Test]
+        [ExpectedException(typeof(EffectiveThicknessCalculatorException))]
+        public void ThrowsExceptionIfSoilProfileNotAssignedInEffectiveThicknessCalculator()
+        {
+            var effectiveThicknessCalculator = new EffectiveThicknessCalculator();
+            effectiveThicknessCalculator.Calculate();
+        }
+
+        [Test]
+        [ExpectedException(typeof(EffectiveThicknessCalculatorException))]
+        public void ThrowsExceptionIfSurfaceLIneNotAssignedInEffectiveThicknessCalculator()
+        {
+            var effectiveThicknessCalculator = new EffectiveThicknessCalculator
+                {
+                    SoilProfile = FactoryForSoilProfileTests.CreateTestProfile()
+                };
+            effectiveThicknessCalculator.Calculate();
+        }
+
+        [Test]
+        public void TestValidate()
+        {
+            var epCalc = new EffectiveThicknessCalculator();
+            var errors = epCalc.Validate();
+            // one error as soilprofile is missing
+            Assert.AreEqual(1, errors.Count);
+            var soilProfile = new PipingProfile();
+            epCalc.SoilProfile = soilProfile;
+            errors = epCalc.Validate();
+            // one error as surfaceline is missing
+            Assert.AreEqual(1, errors.Count);
+            var surfaceLine = new PipingSurfaceLine();
+            epCalc.SurfaceLine = surfaceLine;
+            errors = epCalc.Validate();
+            // one error as surfaceline has no points
+            Assert.AreEqual(1, errors.Count);
+            surfaceLine.Points.Add(new PipingPoint(0, 0, 0));
+            errors = epCalc.Validate();
+            // one error as surfaceline does not have at least two points
+            Assert.AreEqual(1, errors.Count);
+            surfaceLine.Points.Add(new PipingPoint(100, 0, 0));
+            errors = epCalc.Validate();
+            // two error as soilprofile has no layers and no aquifers.
+            Assert.AreEqual(2, errors.Count);
+            epCalc.SoilProfile = FactoryForSoilProfileTests.CreateSimpleTestProfile();
+            errors = epCalc.Validate();
+            // no errors
+            Assert.AreEqual(0, errors.Count);    
+        }
+
+        [Test]
+        public void TestValidateNaNParameter()
+        {
+            var calculator = FillSimpleEffectiveThicknessCalculator();
+            var originalErrors = calculator.Validate();
+
+            calculator.PhreaticLevel = double.NaN;
+            calculator.ExitPointXCoordinate = double.NaN;
+            calculator.VolumicWeightOfWater = double.NaN;
+            
+            var nanErrors = calculator.Validate();
+
+            // trivial check
+            Assert.AreEqual(originalErrors.Count + 3, nanErrors.Count); // 3 errors come from NaN's above
+        }
+
+        private EffectiveThicknessCalculator FillSimpleEffectiveThicknessCalculator()
+        {
+            var effectiveThicknessCalculator = new EffectiveThicknessCalculator
+            {
+                SurfaceLine = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1(),
+                SoilProfile = FactoryForSoilProfileTests.CreateTestProfile(),
+                PhreaticLevel = -1,
+                VolumicWeightOfWater = 10
+            };
+            return effectiveThicknessCalculator;
+        }
+    }
+}
\ No newline at end of file
Fisheye: Tag 275 refers to a dead (removed) revision in file `dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/Class1.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/ExitPointDeterminatorTests.cs
===================================================================
diff -u
--- dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/ExitPointDeterminatorTests.cs	(revision 0)
+++ dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/ExitPointDeterminatorTests.cs	(revision 275)
@@ -0,0 +1,267 @@
+using Deltares.DamPiping.ExitPointDeterminator;
+using NUnit.Framework;
+
+namespace Deltares.DamPiping.ExitPointDeterminatorTests
+{
+    [TestFixture]
+    public class ExitPointDeterminatorTests
+    {
+        [Test]
+        public void SimpleTest()
+        {
+            var epCalc = FillSimpleExitPointDeterminator();
+            epCalc.Calculate();
+            // No uplift so no exit point
+            Assert.AreEqual(null, epCalc.ExitPoint);
+        }
+
+        [Test]
+        public void SimpleTestWithFurtherdLoweredLevelJustAboveLimit()
+        {
+            var epCalc = FillSimpleExitPointDeterminator();
+            epCalc.HRiver = 1.01;
+            // Make leekage lenght very long so PhiAtX returns PhiToe (or near that).
+            epCalc.LeakageLength = 30000;
+            epCalc.Calculate();
+            // With this, the lowest point of the surface is expected
+            Assert.AreEqual(60.5, epCalc.ExitPoint.X);
+            Assert.AreEqual(-1, epCalc.ExitPoint.Z);
+        }
+
+        [Test]
+        public void SimpleTestWithFurtherdLoweredLevelJustAboveLimitWithLeakageLength()
+        {
+            var epCalc = FillSimpleExitPointDeterminator();
+            epCalc.HRiver = 1.01;
+            epCalc.LeakageLength = 30;
+            epCalc.Calculate();
+            // With this, phiExit is lower so no uplift
+            Assert.AreEqual(null, epCalc.ExitPoint);
+        }
+
+        [Test]
+        public void SimpleTestWithFurtherdLoweredLevelOnLimit()
+        {
+            var epCalc = FillSimpleExitPointDeterminator();
+            epCalc.HRiver = 1.0;
+            epCalc.Calculate();
+            // With this, Zu = 0 and FoS = 1 so point could just not be found
+            Assert.AreEqual(null, epCalc.ExitPoint);
+        }
+
+        [Test]
+        public void SimpleTestWithFurtherdLoweredLevelOnLimitWithLeakageLength()
+        {
+            var epCalc = FillSimpleExitPointDeterminator();
+            epCalc.HRiver = 1.0;
+            epCalc.LeakageLength = 30;
+            epCalc.Calculate();
+            // With this, phiExit is lower so for sure no uplift
+            Assert.AreEqual(null, epCalc.ExitPoint);
+        }
+
+        [Test]
+        public void SimpleTestWithLeakageLength()
+        {
+            var epCalc = FillSimpleExitPointDeterminator();
+            epCalc.LeakageLength = 30;
+            epCalc.Calculate();
+            Assert.AreEqual(50.5, epCalc.ExitPoint.X);
+            Assert.AreEqual(0, epCalc.ExitPoint.Z);
+        }
+
+        [Test]
+        public void SimpleTestWithLoweredLevel()
+        {
+            var epCalc = FillSimpleExitPointDeterminator();
+            // Make leekage lenght very long so PhiAtX returns PhiToe (or near that).
+            epCalc.LeakageLength = 3000000;
+            epCalc.HRiver = 2;
+            epCalc.Calculate();
+            Assert.AreEqual(56.0, epCalc.ExitPoint.X, CDiff);
+            Assert.AreEqual(-0.55, epCalc.ExitPoint.Z, CDiff);
+        }
+
+        [Test]
+        public void SimpleTestWithLoweredLevelAndLeakageLength()
+        {
+            var epCalc = FillSimpleExitPointDeterminator();
+            epCalc.HRiver = 2;
+            epCalc.LeakageLength = 30;
+            epCalc.Calculate();
+            Assert.AreEqual(58.0, epCalc.ExitPoint.X, CDiff);
+            Assert.AreEqual(-0.75, epCalc.ExitPoint.Z, CDiff);
+        }
+
+        [Test]
+        public void SimpleTestWithTooLowLevelSoNoUplift()
+        {
+            var epCalc = FillSimpleExitPointDeterminator();
+            epCalc.HRiver = 0;
+            epCalc.Calculate();
+            Assert.AreEqual(null, epCalc.ExitPoint);
+        }
+
+        [Test]
+        public void TestValidate()
+        {
+            var epCalc = new ExitPointDeterminator.ExitPointDeterminator();
+            var errors = epCalc.Validate();
+            // one error as soilprofile is missing
+            Assert.AreEqual(1, errors.Count);
+            var soilProfile = new PipingProfile();
+            epCalc.SoilProfile = soilProfile;
+            errors = epCalc.Validate();
+            // one error as surfaceline is missing
+            Assert.AreEqual(1, errors.Count);
+            var surfaceLine = new PipingSurfaceLine();
+            epCalc.SurfaceLine = surfaceLine;
+            errors = epCalc.Validate();
+            // one error as surfaceline has no points
+            Assert.AreEqual(1, errors.Count);
+            surfaceLine.Points.Add(new PipingPoint(0, 0, 0));
+            errors = epCalc.Validate();
+            // one error as surfaceline does not have at least two points
+            Assert.AreEqual(1, errors.Count);
+            surfaceLine.Points.Add(new PipingPoint(100, 0, 0));
+            errors = epCalc.Validate();
+            // two error as soilprofile has no layers and no aquifers.
+            Assert.AreEqual(2, errors.Count);
+            epCalc.SoilProfile = FactoryForSoilProfileTests.CreateSimpleTestProfile();
+            errors = epCalc.Validate();
+            // no errors
+            Assert.AreEqual(0, errors.Count);
+            epCalc.Calculate();
+            Assert.AreEqual(null, epCalc.ExitPoint);
+        }
+
+        [Test]
+        public void TwoAquifersAndDitchTest()
+        {
+            var epCalc = FillExitPointDeterminatorTwoAquifersAndDitch();
+            // Make leekage lenght very long so PhiAtX returns PhiToe (or near that).
+            epCalc.LeakageLength = 3000000;
+            epCalc.Calculate();
+            Assert.AreEqual(59, epCalc.ExitPoint.X, CDiff);
+            Assert.AreEqual(-1, epCalc.ExitPoint.Z, CDiff);
+        }
+
+        [Test]
+        public void TwoAquifersAndDitchWithLeakageLength()
+        {
+            var epCalc = FillExitPointDeterminatorTwoAquifersAndDitch();
+            epCalc.LeakageLength = 30;
+            epCalc.Calculate();
+            Assert.AreEqual(null, epCalc.ExitPoint);
+        }
+
+        [Test]
+        public void TwoAquifersTest()
+        {
+            var epCalc = FillExitPointDeterminatorTwoAquifers();
+            // Make leekage lenght very long so PhiAtX returns PhiToe (or near that).
+            epCalc.LeakageLength = 3000000;
+            epCalc.Calculate();
+            Assert.AreEqual(56.0, epCalc.ExitPoint.X, CDiff);
+            Assert.AreEqual(-0.55, epCalc.ExitPoint.Z, CDiff);
+        }
+
+        [Test]
+        public void TwoAquifersWithLeakageLength()
+        {
+            var epCalc = FillExitPointDeterminatorTwoAquifers();
+            epCalc.LeakageLength = 90;
+            epCalc.Calculate();
+            Assert.AreEqual(57.0, epCalc.ExitPoint.X, CDiff);
+            Assert.AreEqual(-0.65, epCalc.ExitPoint.Z, CDiff);
+        }
+
+        private const double CDiff = 0.001;
+
+        private static ExitPointDeterminator.ExitPointDeterminator FillSimpleExitPointDeterminator()
+        {
+            var soilProfile = FactoryForSoilProfileTests.CreateSimpleTestProfile();
+            var surfaceLine = FactoryForSurfaceLineTests.CreateSimpleSurfaceLineForExitPointTest();
+
+            var epCalc = new ExitPointDeterminator.ExitPointDeterminator();
+            epCalc.SoilProfile = soilProfile;
+            epCalc.SurfaceLine = surfaceLine;
+            epCalc.PhiPolder = 0;
+            epCalc.HRiver = 4;
+            epCalc.IsUseOvenDryUnitWeight = false;
+            epCalc.LeakageLength = 0;
+            epCalc.MinimumThicknessCoverLayer = 0;
+            epCalc.ModelFactorUplift = 1;
+            epCalc.RExit = 1;
+            epCalc.RToe = 1;
+            epCalc.RequiredFactorOfSafety = 1;
+            epCalc.VolumetricWeightOfWater = 10;
+            return epCalc;
+        }
+
+        private static ExitPointDeterminator.ExitPointDeterminator FillExitPointDeterminatorTwoAquifers()
+        {
+            var soilProfile = FactoryForSoilProfileTests.CreateTestProfileTwoAquifers();
+            var surfaceLine = FactoryForSurfaceLineTests.CreateSimpleSurfaceLineForExitPointTest();
+
+            var epCalc = new ExitPointDeterminator.ExitPointDeterminator();
+            epCalc.SoilProfile = soilProfile;
+            epCalc.SurfaceLine = surfaceLine;
+            epCalc.PhiPolder = 0;
+            epCalc.HRiver = 4;
+            epCalc.IsUseOvenDryUnitWeight = false;
+            epCalc.LeakageLength = 0;
+            epCalc.MinimumThicknessCoverLayer = 0;
+            epCalc.ModelFactorUplift = 1;
+            epCalc.RExit = 1;
+            epCalc.RToe = 1;
+            epCalc.RequiredFactorOfSafety = 1;
+            epCalc.VolumetricWeightOfWater = 10;
+            return epCalc;
+        }
+
+        private static ExitPointDeterminator.ExitPointDeterminator FillExitPointDeterminatorTwoAquifersAndDitch()
+        {
+            var soilProfile = FactoryForSoilProfileTests.CreateTestProfileTwoAquifers();
+            var surfaceLine = FactoryForSurfaceLineTests.CreateSurfaceLineTutorial1();
+
+            var epCalc = new ExitPointDeterminator.ExitPointDeterminator();
+            epCalc.SoilProfile = soilProfile;
+            epCalc.SurfaceLine = surfaceLine;
+            epCalc.PhiPolder = -1;
+            epCalc.HRiver = 4;
+            epCalc.IsUseOvenDryUnitWeight = false;
+            epCalc.LeakageLength = 0;
+            epCalc.MinimumThicknessCoverLayer = 0;
+            epCalc.ModelFactorUplift = 1;
+            epCalc.RExit = 1;
+            epCalc.RToe = 1;
+            epCalc.RequiredFactorOfSafety = 1;
+            epCalc.VolumetricWeightOfWater = 11.111;
+            return epCalc;
+        }
+
+        [Test]
+        public void TestValidateNaNParameter()
+        {
+            var calculator = FillSimpleExitPointDeterminator();
+            var originalErrors = calculator.Validate();
+            
+            calculator.PhiPolder = double.NaN;
+            calculator.RToe = double.NaN;
+            calculator.HRiver = double.NaN;
+            calculator.LeakageLength = double.NaN;
+            calculator.RequiredFactorOfSafety = double.NaN;
+            calculator.VolumetricWeightOfWater = double.NaN;
+            calculator.ModelFactorUplift = double.NaN;
+            calculator.MinimumThicknessCoverLayer = double.NaN;
+            calculator.RExit = double.NaN;
+            calculator.UpliftFactor = double.NaN;
+            
+            var nanErrors = calculator.Validate();
+
+            // trivial check
+            Assert.AreEqual(originalErrors.Count + 19, nanErrors.Count); // 10 errors come from NaN's above, the rest from sub-calculators
+        }
+    }
+}
\ No newline at end of file
Index: dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/Deltares.DamPiping.ExitPointDeterminatorTests.csproj
===================================================================
diff -u -r267 -r275
--- dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/Deltares.DamPiping.ExitPointDeterminatorTests.csproj	(.../Deltares.DamPiping.ExitPointDeterminatorTests.csproj)	(revision 267)
+++ dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/Deltares.DamPiping.ExitPointDeterminatorTests.csproj	(.../Deltares.DamPiping.ExitPointDeterminatorTests.csproj)	(revision 275)
@@ -31,6 +31,10 @@
     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="nunit.framework, Version=2.6.2.12296, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\lib\NUnit\nunit.framework.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Xml.Linq" />
@@ -41,9 +45,21 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Class1.cs" />
+    <Compile Include="EffectiveThicknessCalculatorTests.cs" />
+    <Compile Include="ExitPointDeterminatorTests.cs" />
+    <Compile Include="FactoryForSoilProfileTests.cs" />
+    <Compile Include="FactoryForSurfaceLineTests.cs" />
+    <Compile Include="PipingProfileTests.cs" />
+    <Compile Include="PipingSurfaceLineTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="SoilVolumicMassCalculatorTests.cs" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\Deltares.DamPiping.ExitPointDeterminator\Deltares.DamPiping.ExitPointDeterminator.csproj">
+      <Project>{9C749AA4-CFBF-4906-9057-4F4C771788B2}</Project>
+      <Name>Deltares.DamPiping.ExitPointDeterminator</Name>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
Index: dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/SoilVolumicMassCalculatorTests.cs
===================================================================
diff -u
--- dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/SoilVolumicMassCalculatorTests.cs	(revision 0)
+++ dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/SoilVolumicMassCalculatorTests.cs	(revision 275)
@@ -0,0 +1,36 @@
+using Deltares.DamPiping.ExitPointDeterminator;
+using NUnit.Framework;
+
+namespace Deltares.DamPiping.ExitPointDeterminatorTests
+{
+    [TestFixture]
+    class SoilVolumicMassCalculatorTests
+    {
+        [Test]
+        public void TestValidateNaNParameter()
+        {
+            var calculator = new SoilVolumicMassCalculator()
+            {
+                // seems like reasonable values
+                VolumicWeightOfWater = 1,
+                PhreaticLevel = 1, 
+                SurfaceLevel = 2, 
+                TopOfLayerToBeEvaluated = 3,
+                MinimumThicknessCoverLayer = 4
+            };
+
+            var originalErrors = calculator.Validate();
+            
+            calculator.VolumicWeightOfWater = double.NaN;
+            calculator.PhreaticLevel = double.NaN;
+            calculator.SurfaceLevel = double.NaN;
+            calculator.TopOfLayerToBeEvaluated = double.NaN;
+            calculator.MinimumThicknessCoverLayer = double.NaN;
+
+            var nanErrors = calculator.Validate();
+
+            // trivial check
+            Assert.AreEqual(originalErrors.Count + 5, nanErrors.Count);
+        }
+    }
+}
Index: dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/FactoryForSoilProfileTests.cs
===================================================================
diff -u
--- dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/FactoryForSoilProfileTests.cs	(revision 0)
+++ dam failuremechanisms/damPiping/trunk/src/Tests/Deltares.DamPiping.ExitPointDeterminatorTests/FactoryForSoilProfileTests.cs	(revision 275)
@@ -0,0 +1,293 @@
+using Deltares.DamPiping.ExitPointDeterminator;
+
+namespace Deltares.DamPiping.ExitPointDeterminatorTests
+{
+    public class FactoryForSoilProfileTests
+    {
+        public static PipingProfile CreateTestProfile()
+        {
+            var soilProfile = new PipingProfile
+            {
+                Name = "TestProf",
+                BottomLevel = -30
+            };
+
+            var layer1 = new PipingLayer
+            {
+                Name = "layer1 - klei",
+                AbovePhreaticLevel = 18,
+                BelowPhreaticLevel = 20,
+                TopLevel = 10,
+                IsAquifer = false
+            };
+            soilProfile.Layers.Add(layer1);
+
+            var layer2 = new PipingLayer
+            {
+                Name = "layer2 - klei2",
+                AbovePhreaticLevel = 20,
+                BelowPhreaticLevel = 22,
+                TopLevel = -3,
+                IsAquifer = false
+            };
+            soilProfile.Layers.Add(layer2);
+
+            var layer3 = new PipingLayer
+            {
+                Name = "layer3 - zand",
+                AbovePhreaticLevel = 15,
+                BelowPhreaticLevel = 17,
+                TopLevel = -10,
+                IsAquifer = true
+            };
+            soilProfile.Layers.Add(layer3);
+
+            return soilProfile;
+        }
+
+        public static PipingProfile CreateSimpleTestProfile()
+        {
+            var soilProfile = new PipingProfile
+            {
+                Name = "TestProf",
+                BottomLevel = -30
+            };
+
+            var layer1 = new PipingLayer
+            {
+                Name = "layer1 - klei",
+                AbovePhreaticLevel = 18,
+                BelowPhreaticLevel = 20,
+                TopLevel = 10,
+                IsAquifer = false
+            };
+            soilProfile.Layers.Add(layer1);
+
+            var layer2 = new PipingLayer
+            {
+                Name = "layer2 - zand",
+                AbovePhreaticLevel = 15,
+                BelowPhreaticLevel = 17,
+                TopLevel = -3,
+                IsAquifer = true
+            };
+            soilProfile.Layers.Add(layer2);
+
+            return soilProfile;
+        }
+
+        public static PipingProfile CreateTestProfileTwoAquifers()
+        {
+            var soilProfile = new PipingProfile
+            {
+                Name = "TestProf",
+                BottomLevel = -30
+            };
+
+            var layer1 = new PipingLayer
+            {
+                Name = "layer1 - klei",
+                AbovePhreaticLevel = 18,
+                BelowPhreaticLevel = 20,
+                TopLevel = 10,
+                IsAquifer = false
+            };
+            soilProfile.Layers.Add(layer1);
+
+            var layer2 = new PipingLayer
+            {
+                Name = "layer2 - zandtop",
+                AbovePhreaticLevel = 18,
+                BelowPhreaticLevel = 20,
+                TopLevel = -5,
+                IsAquifer = true
+            };
+            soilProfile.Layers.Add(layer2);
+
+            var layer3 = new PipingLayer
+            {
+                Name = "layer3 - veen",
+                AbovePhreaticLevel = 5,
+                BelowPhreaticLevel = 10.5,
+                TopLevel = -6,
+                IsAquifer = false
+            };
+            soilProfile.Layers.Add(layer3);
+
+            var layer4 = new PipingLayer
+            {
+                Name = "layer4 - zandbottom",
+                AbovePhreaticLevel = 15,
+                BelowPhreaticLevel = 17,
+                TopLevel = -10,
+                IsAquifer = true
+            };
+            soilProfile.Layers.Add(layer4);
+
+            var layer5 = new PipingLayer
+            {
+                Name = "layer5 - klei",
+                AbovePhreaticLevel = 18,
+                BelowPhreaticLevel = 20,
+                TopLevel = -13,
+                IsAquifer = false
+            };
+            soilProfile.Layers.Add(layer5);
+
+            return soilProfile;
+        }
+
+        public static PipingProfile CreateTestProfileThreeCoverSublayersOneAquifer()
+        {
+            var soilProfile = new PipingProfile
+            {
+                Name = "TestProfileWithThreeCoverSublayersOneAquifer",
+                BottomLevel = -30
+            };
+
+            var layer1 = new PipingLayer
+            {
+                Name = "layer1 - coverSublayer1",
+                AbovePhreaticLevel = 15,
+                BelowPhreaticLevel = 17,
+                TopLevel = 100,
+                IsAquifer = false
+            };
+            soilProfile.Layers.Add(layer1);
+
+            var layer2 = new PipingLayer
+            {
+                Name = "layer2 - coverSublayer2",
+                AbovePhreaticLevel = 12,
+                BelowPhreaticLevel = 14,
+                TopLevel = -1.9,
+                IsAquifer = false
+            };
+            soilProfile.Layers.Add(layer2);
+
+            var layer3 = new PipingLayer
+            {
+                Name = "layer3 - coverSublayer3",
+                AbovePhreaticLevel = 10,
+                BelowPhreaticLevel = 10.5,
+                TopLevel = -2.5,
+                IsAquifer = false
+            };
+            soilProfile.Layers.Add(layer3);
+
+            var layer4 = new PipingLayer
+            {
+                Name = "layer4 - pleistocene",
+                AbovePhreaticLevel = 18,
+                BelowPhreaticLevel = 20,
+                TopLevel = -3.1,
+                IsAquifer = true
+            };
+            soilProfile.Layers.Add(layer4);
+
+            return soilProfile;
+        }
+
+        public static PipingProfile CreateTestProfileTwoCoverSublayersTwoAquifers()
+        {
+            var soilProfile = new PipingProfile
+            {
+                Name = "TestProfileWithTwoCoverSublayersTwoAquifers",
+                BottomLevel = -30
+            };
+
+            var layer1 = new PipingLayer
+            {
+                Name = "layer1 - coverSublayer1",
+                AbovePhreaticLevel = 15,
+                BelowPhreaticLevel = 17,
+                TopLevel = 100,
+                IsAquifer = false
+            };
+            soilProfile.Layers.Add(layer1);
+
+            var layer2 = new PipingLayer
+            {
+                Name = "layer2 - coverSublayer2",
+                AbovePhreaticLevel = 12,
+                BelowPhreaticLevel = 14,
+                TopLevel = -1.9,
+                IsAquifer = false
+            };
+            soilProfile.Layers.Add(layer2);
+
+            var layer3 = new PipingLayer
+            {
+                Name = "layer3 - aquifer1",
+                AbovePhreaticLevel = 10,
+                BelowPhreaticLevel = 10.5,
+                TopLevel = -2.5,
+                IsAquifer = true
+            };
+            soilProfile.Layers.Add(layer3);
+
+            var layer4 = new PipingLayer
+            {
+                Name = "layer4 - aquifer2",
+                AbovePhreaticLevel = 18,
+                BelowPhreaticLevel = 20,
+                TopLevel = -3.1,
+                IsAquifer = true
+            };
+            soilProfile.Layers.Add(layer4);
+
+            return soilProfile;
+        }
+
+        public static PipingProfile CreateTestProfileOneCoverLayerOneInBetweenAquifer()
+        {
+            var soilProfile = new PipingProfile
+            {
+                Name = "TestProfileWithOneCoverLayerOneInBetweenAquifer",
+                BottomLevel = -30
+            };
+
+            var layer1 = new PipingLayer
+            {
+                Name = "layer1 - coverLayer",
+                AbovePhreaticLevel = 15,
+                BelowPhreaticLevel = 17,
+                TopLevel = 100,
+                IsAquifer = false
+            };
+            soilProfile.Layers.Add(layer1);
+
+            var layer2 = new PipingLayer
+            {
+                Name = "layer2 - inBetweenAquifer",
+                AbovePhreaticLevel = 12,
+                BelowPhreaticLevel = 14,
+                TopLevel = -1.9,
+                IsAquifer = true
+            };
+            soilProfile.Layers.Add(layer2);
+
+            var layer3 = new PipingLayer
+            {
+                Name = "layer3 - deepAquitard",
+                AbovePhreaticLevel = 10,
+                BelowPhreaticLevel = 10.5,
+                TopLevel = -2.5,
+                IsAquifer = false
+            };
+            soilProfile.Layers.Add(layer3);
+
+            var layer4 = new PipingLayer
+            {
+                Name = "layer4 - deepAquifer",
+                AbovePhreaticLevel = 18,
+                BelowPhreaticLevel = 20,
+                TopLevel = -3.1,
+                IsAquifer = true
+            };
+            soilProfile.Layers.Add(layer4);
+
+            return soilProfile;
+        }
+    }
+}
\ No newline at end of file