Index: Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Primitives/MacroStabilityInwardsSoilLayer.cs
===================================================================
diff -u -r5906f61fff270a7526253bea07dfecdf680898ed -r9caa7daa14d0070e2a3f68c4b9e66109318bd9ab
--- Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Primitives/MacroStabilityInwardsSoilLayer.cs	(.../MacroStabilityInwardsSoilLayer.cs)	(revision 5906f61fff270a7526253bea07dfecdf680898ed)
+++ Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Primitives/MacroStabilityInwardsSoilLayer.cs	(.../MacroStabilityInwardsSoilLayer.cs)	(revision 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab)
@@ -30,45 +30,388 @@
     /// </summary>
     public class MacroStabilityInwardsSoilLayer
     {
-        private string materialName;
-
         /// <summary>
         /// Creates a new instance of <see cref="MacroStabilityInwardsSoilLayer"/>, where the top is set to <paramref name="top"/>.
         /// </summary>
         /// <param name="top">The top level of the layer.</param>
         public MacroStabilityInwardsSoilLayer(double top)
         {
             Top = top;
-            MaterialName = string.Empty;
+            Properties = new SoilLayerProperties();
         }
 
         /// <summary>
+        /// Gets the properties of the <see cref="MacroStabilityInwardsSoilLayer"/>.
+        /// </summary>
+        public SoilLayerProperties Properties { get; }
+
+        /// <summary>
         /// Gets the top level of the <see cref="MacroStabilityInwardsSoilLayer"/>.
         /// </summary>
         public double Top { get; }
 
         /// <summary>
         /// Gets or sets a value indicating whether or not the <see cref="MacroStabilityInwardsSoilLayer"/> is an aquifer.
         /// </summary>
-        public bool IsAquifer { get; set; }
+        public bool IsAquifer
+        {
+            get
+            {
+                return Properties.IsAquifer;
+            }
+            set
+            {
+                Properties.IsAquifer = value;
+            }
+        }
 
         /// <summary>
+        /// Gets or sets a value indicating whether or not to use POP for the <see cref="MacroStabilityInwardsSoilLayer"/>.
+        /// </summary>
+        public bool UsePop
+        {
+            get
+            {
+                return Properties.UsePop;
+            }
+            set
+            {
+                Properties.UsePop = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the shear strength model used for the <see cref="MacroStabilityInwardsSoilLayer"/>.
+        /// </summary>
+        public ShearStrengthModel ShearStrengthModel
+        {
+            get
+            {
+                return Properties.ShearStrengthModel;
+            }
+            set
+            {
+                Properties.ShearStrengthModel = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the mean of the distrubtion for the volumic weight of the <see cref="MacroStabilityInwardsSoilLayer"/> above the phreatic level.
+        /// [kN/m³]
+        /// </summary>
+        public double AbovePhreaticLevelMean
+        {
+            get
+            {
+                return Properties.AbovePhreaticLevelMean;
+            }
+            set
+            {
+                Properties.AbovePhreaticLevelMean = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the deviation of the distrubtion for the volumic weight of the <see cref="MacroStabilityInwardsSoilLayer"/> above the phreatic level.
+        /// [kN/m³]
+        /// </summary>
+        public double AbovePhreaticLevelDeviation
+        {
+            get
+            {
+                return Properties.AbovePhreaticLevelDeviation;
+            }
+            set
+            {
+                Properties.AbovePhreaticLevelDeviation = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the mean of the distrubtion for the volumic weight of the <see cref="MacroStabilityInwardsSoilLayer"/> below the phreatic level.
+        /// [kN/m³]
+        /// </summary>
+        public double BelowPhreaticLevelMean
+        {
+            get
+            {
+                return Properties.BelowPhreaticLevelMean;
+            }
+            set
+            {
+                Properties.BelowPhreaticLevelMean = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the deviation of the distrubtion for the volumic weight of the <see cref="MacroStabilityInwardsSoilLayer"/> below the phreatic level.
+        /// [kN/m³]
+        /// </summary>
+        public double BelowPhreaticLevelDeviation
+        {
+            get
+            {
+                return Properties.BelowPhreaticLevelDeviation;
+            }
+            set
+            {
+                Properties.BelowPhreaticLevelDeviation = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the mean of the distribution for the friction angle of the <see cref="MacroStabilityInwardsSoilLayer"/>
+        /// [°]
+        /// </summary>
+        public double FrictionAngleMean
+        {
+            get
+            {
+                return Properties.FrictionAngleMean;
+            }
+            set
+            {
+                Properties.FrictionAngleMean = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the deviation of the distribution for the friction angle of the <see cref="MacroStabilityInwardsSoilLayer"/>.
+        /// [°]
+        /// </summary>
+        public double FrictionAngleDeviation
+        {
+            get
+            {
+                return Properties.FrictionAngleDeviation;
+            }
+            set
+            {
+                Properties.FrictionAngleDeviation = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the shift of the distrubtion for the friction angle of the <see cref="MacroStabilityInwardsSoilLayer"/>.
+        /// [°]
+        /// </summary>
+        public double FrictionAngleShift
+        {
+            get
+            {
+                return Properties.FrictionAngleShift;
+            }
+            set
+            {
+                Properties.FrictionAngleShift = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the mean of the distribution for the ratio of shear strength S of the <see cref="MacroStabilityInwardsSoilLayer"/>
+        /// [-]
+        /// </summary>
+        public double ShearStrengthRatioMean
+        {
+            get
+            {
+                return Properties.ShearStrengthRatioMean;
+            }
+            set
+            {
+                Properties.ShearStrengthRatioMean = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the deviation of the distribution for the ratio of shear strength S of the <see cref="MacroStabilityInwardsSoilLayer"/>.
+        /// [-]
+        /// </summary>
+        public double ShearStrengthRatioDeviation
+        {
+            get
+            {
+                return Properties.ShearStrengthRatioDeviation;
+            }
+            set
+            {
+                Properties.ShearStrengthRatioDeviation = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the shift of the distrubtion for the ratio of shear strength S of the <see cref="MacroStabilityInwardsSoilLayer"/>.
+        /// [-]
+        /// </summary>
+        public double ShearStrengthRatioShift
+        {
+            get
+            {
+                return Properties.ShearStrengthRatioShift;
+            }
+            set
+            {
+                Properties.ShearStrengthRatioShift = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the mean of the distribution for the strength increase exponent (m) of the <see cref="MacroStabilityInwardsSoilLayer"/>
+        /// [-]
+        /// </summary>
+        public double StrengthIncreaseExponentMean
+        {
+            get
+            {
+                return Properties.StrengthIncreaseExponentMean;
+            }
+            set
+            {
+                Properties.StrengthIncreaseExponentMean = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the deviation of the distribution for the strength increase exponent (m) of the <see cref="MacroStabilityInwardsSoilLayer"/>.
+        /// [-]
+        /// </summary>
+        public double StrengthIncreaseExponentDeviation
+        {
+            get
+            {
+                return Properties.StrengthIncreaseExponentDeviation;
+            }
+            set
+            {
+                Properties.StrengthIncreaseExponentDeviation = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the shift of the distrubtion for the strength increase exponent (m) of the <see cref="MacroStabilityInwardsSoilLayer"/>.
+        /// [-]
+        /// </summary>
+        public double StrengthIncreaseExponentShift
+        {
+            get
+            {
+                return Properties.StrengthIncreaseExponentShift;
+            }
+            set
+            {
+                Properties.StrengthIncreaseExponentShift = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the mean of the distribution for the cohesion of the <see cref="MacroStabilityInwardsSoilLayer"/>
+        /// [kN/m³]
+        /// </summary>
+        public double CohesionMean
+        {
+            get
+            {
+                return Properties.CohesionMean;
+            }
+            set
+            {
+                Properties.CohesionMean = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the deviation of the distribution for the cohesion of the <see cref="MacroStabilityInwardsSoilLayer"/>.
+        /// [kN/m³]
+        /// </summary>
+        public double CohesionDeviation
+        {
+            get
+            {
+                return Properties.CohesionDeviation;
+            }
+            set
+            {
+                Properties.CohesionDeviation = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the shift of the distrubtion for the cohesion of the <see cref="MacroStabilityInwardsSoilLayer"/>.
+        /// [kN/m³]
+        /// </summary>
+        public double CohesionShift
+        {
+            get
+            {
+                return Properties.CohesionShift;
+            }
+            set
+            {
+                Properties.CohesionShift = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the mean of the distribution for the POP of the <see cref="MacroStabilityInwardsSoilLayer"/>
+        /// [kN/m²]
+        /// </summary>
+        public double PopMean
+        {
+            get
+            {
+                return Properties.PopMean;
+            }
+            set
+            {
+                Properties.PopMean = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the deviation of the distribution for the POP of the <see cref="MacroStabilityInwardsSoilLayer"/>.
+        /// [kN/m²]
+        /// </summary>
+        public double PopDeviation
+        {
+            get
+            {
+                return Properties.PopDeviation;
+            }
+            set
+            {
+                Properties.PopDeviation = value;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the shift of the distrubtion for the POP of the <see cref="MacroStabilityInwardsSoilLayer"/>.
+        /// [kN/m²]
+        /// </summary>
+        public double PopShift
+        {
+            get
+            {
+                return Properties.PopShift;
+            }
+            set
+            {
+                Properties.PopShift = value;
+            }
+        }
+
+        /// <summary>
         /// Gets or sets the name of the material that was assigned to the <see cref="MacroStabilityInwardsSoilLayer"/>.
         /// </summary>
         /// <exception cref="ArgumentNullException">Thrown when <paramref name="value"/> is <c>null</c>.</exception>
         public string MaterialName
         {
             get
             {
-                return materialName;
+                return Properties.MaterialName;
             }
             set
             {
-                if (value == null)
-                {
-                    throw new ArgumentNullException(nameof(value));
-                }
-                materialName = value;
+                Properties.MaterialName = value;
             }
         }
 
@@ -98,7 +441,7 @@
         {
             unchecked
             {
-                int hashCode = materialName?.GetHashCode() ?? 0;
+                int hashCode = MaterialName?.GetHashCode() ?? 0;
                 hashCode = (hashCode * 397) ^ Top.GetHashCode();
                 hashCode = (hashCode * 397) ^ IsAquifer.GetHashCode();
                 hashCode = (hashCode * 397) ^ Color.GetHashCode();
@@ -108,7 +451,7 @@
 
         private bool Equals(MacroStabilityInwardsSoilLayer other)
         {
-            return string.Equals(materialName, other.materialName)
+            return string.Equals(MaterialName, other.MaterialName)
                    && Top.Equals(other.Top)
                    && IsAquifer == other.IsAquifer
                    && Color.Equals(other.Color);
Index: Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Primitives/Ringtoets.MacroStabilityInwards.Primitives.csproj
===================================================================
diff -u -ra940166534b3dd6e778de2e7c8e7e5241f3d3381 -r9caa7daa14d0070e2a3f68c4b9e66109318bd9ab
--- Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Primitives/Ringtoets.MacroStabilityInwards.Primitives.csproj	(.../Ringtoets.MacroStabilityInwards.Primitives.csproj)	(revision a940166534b3dd6e778de2e7c8e7e5241f3d3381)
+++ Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Primitives/Ringtoets.MacroStabilityInwards.Primitives.csproj	(.../Ringtoets.MacroStabilityInwards.Primitives.csproj)	(revision 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab)
@@ -52,6 +52,8 @@
       <DesignTime>True</DesignTime>
     </Compile>
     <Compile Include="RingtoetsMacroStabilityInwardsSurfaceLine.cs" />
+    <Compile Include="ShearStrengthModel.cs" />
+    <Compile Include="SoilLayerProperties.cs" />
     <Compile Include="SoilProfileType.cs" />
   </ItemGroup>
   <ItemGroup>
Index: Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Primitives/ShearStrengthModel.cs
===================================================================
diff -u
--- Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Primitives/ShearStrengthModel.cs	(revision 0)
+++ Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Primitives/ShearStrengthModel.cs	(revision 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab)
@@ -0,0 +1,31 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+namespace Ringtoets.MacroStabilityInwards.Primitives
+{
+    public enum ShearStrengthModel
+    {
+        None,
+        SuCalculated,
+        CPhi,
+        CPhiOrSuCalculated
+    }
+}
\ No newline at end of file
Index: Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Primitives/SoilLayerProperties.cs
===================================================================
diff -u
--- Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Primitives/SoilLayerProperties.cs	(revision 0)
+++ Ringtoets/MacroStabilityInwards/src/Ringtoets.MacroStabilityInwards.Primitives/SoilLayerProperties.cs	(revision 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab)
@@ -0,0 +1,71 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Drawing;
+
+namespace Ringtoets.MacroStabilityInwards.Primitives
+{
+    public class SoilLayerProperties
+    {
+        private string materialName = string.Empty;
+        public bool IsAquifer { get; set; }
+
+        public string MaterialName
+        {
+            get
+            {
+                return materialName;
+            }
+            set
+            {
+                if (value == null)
+                {
+                    throw new ArgumentNullException(nameof(value));
+                }
+                materialName = value;
+            }
+        }
+
+        public Color Color { get; set; }
+        public bool UsePop { get; set; }
+        public ShearStrengthModel ShearStrengthModel { get; set; }
+        public double AbovePhreaticLevelMean { get; set; } = double.NaN;
+        public double AbovePhreaticLevelDeviation { get; set; } = double.NaN;
+        public double BelowPhreaticLevelMean { get; set; } = double.NaN;
+        public double BelowPhreaticLevelDeviation { get; set; } = double.NaN;
+        public double CohesionMean { get; set; } = double.NaN;
+        public double CohesionDeviation { get; set; } = double.NaN;
+        public double CohesionShift { get; set; } = double.NaN;
+        public double FrictionAngleMean { get; set; } = double.NaN;
+        public double FrictionAngleDeviation { get; set; } = double.NaN;
+        public double FrictionAngleShift { get; set; } = double.NaN;
+        public double ShearStrengthRatioMean { get; set; } = double.NaN;
+        public double ShearStrengthRatioDeviation { get; set; } = double.NaN;
+        public double ShearStrengthRatioShift { get; set; } = double.NaN;
+        public double StrengthIncreaseExponentMean { get; set; } = double.NaN;
+        public double StrengthIncreaseExponentDeviation { get; set; } = double.NaN;
+        public double StrengthIncreaseExponentShift { get; set; } = double.NaN;
+        public double PopMean { get; set; } = double.NaN;
+        public double PopDeviation { get; set; } = double.NaN;
+        public double PopShift { get; set; } = double.NaN;
+    }
+}
\ No newline at end of file
Fisheye: Tag 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab refers to a dead (removed) revision in file `Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/Exceptions/RingtoetsMacroStabilityInwardsSurfaceLineExceptionTest.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Fisheye: Tag 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab refers to a dead (removed) revision in file `Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsSoilLayerTest.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Fisheye: Tag 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab refers to a dead (removed) revision in file `Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/MacroStabilityInwardsSoilProfileTest.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/Ringtoets.MacroStabilityInwards.Data.Test.csproj
===================================================================
diff -u -r650fc7b43cb6729baee51d079f0377df8d7a3de9 -r9caa7daa14d0070e2a3f68c4b9e66109318bd9ab
--- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/Ringtoets.MacroStabilityInwards.Data.Test.csproj	(.../Ringtoets.MacroStabilityInwards.Data.Test.csproj)	(revision 650fc7b43cb6729baee51d079f0377df8d7a3de9)
+++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/Ringtoets.MacroStabilityInwards.Data.Test.csproj	(.../Ringtoets.MacroStabilityInwards.Data.Test.csproj)	(revision 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab)
@@ -57,7 +57,6 @@
     <Compile Include="..\..\..\..\Core\Common\src\Core.Common.Version\GlobalAssembly.cs">
       <Link>Properties\GlobalAssembly.cs</Link>
     </Compile>
-    <Compile Include="Exceptions\RingtoetsMacroStabilityInwardsSurfaceLineExceptionTest.cs" />
     <Compile Include="GeneralMacroStabilityInwardsInputTest.cs" />
     <Compile Include="MacroStabilityInwardsCalculationScenarioExtensionsTest.cs" />
     <Compile Include="MacroStabilityInwardsCalculationScenarioTest.cs" />
@@ -68,11 +67,8 @@
     <Compile Include="MacroStabilityInwardsInputTest.cs" />
     <Compile Include="MacroStabilityInwardsOutputTest.cs" />
     <Compile Include="MacroStabilityInwardsSemiProbabilisticOutputTest.cs" />
-    <Compile Include="MacroStabilityInwardsSoilLayerTest.cs" />
     <Compile Include="MacroStabilityInwardsSoilProfileExtensionsTest.cs" />
-    <Compile Include="MacroStabilityInwardsSoilProfileTest.cs" />
     <Compile Include="RingtoetsMacroStabilityInwardsSurfaceLineCollectionTest.cs" />
-    <Compile Include="RingtoetsMacroStabilityInwardsSurfaceLineTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="MacroStabilityInwardsProbabilityAssessmentInputTest.cs" />
     <Compile Include="StochasticSoilModelCollectionTest.cs" />
Fisheye: Tag 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab refers to a dead (removed) revision in file `Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Data.Test/RingtoetsMacroStabilityInwardsSurfaceLineTest.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/Exceptions/RingtoetsMacroStabilityInwardsSurfaceLineExceptionTest.cs
===================================================================
diff -u
--- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/Exceptions/RingtoetsMacroStabilityInwardsSurfaceLineExceptionTest.cs	(revision 0)
+++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/Exceptions/RingtoetsMacroStabilityInwardsSurfaceLineExceptionTest.cs	(revision 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab)
@@ -0,0 +1,32 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using Core.Common.TestUtil;
+using NUnit.Framework;
+using Ringtoets.MacroStabilityInwards.Primitives.Exceptions;
+
+namespace Ringtoets.MacroStabilityInwards.Primitives.Test.Exceptions
+{
+    [TestFixture]
+    public class RingtoetsMacroStabilityInwardsSurfaceLineExceptionTest :
+        CustomExceptionDesignGuidelinesTestFixture<RingtoetsMacroStabilityInwardsSurfaceLineException, Exception> {}
+}
\ No newline at end of file
Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/MacroStabilityInwardsSoilLayerTest.cs
===================================================================
diff -u
--- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/MacroStabilityInwardsSoilLayerTest.cs	(revision 0)
+++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/MacroStabilityInwardsSoilLayerTest.cs	(revision 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab)
@@ -0,0 +1,174 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Drawing;
+using System.Linq;
+using Core.Common.TestUtil;
+using NUnit.Framework;
+
+namespace Ringtoets.MacroStabilityInwards.Primitives.Test
+{
+    [TestFixture]
+    public class MacroStabilityInwardsSoilLayerTest
+    {
+        [Test]
+        public void Constructor_WithTop_ReturnsNewInstanceWithTopSet()
+        {
+            // Setup
+            double top = new Random(22).NextDouble();
+
+            // Call
+            var layer = new MacroStabilityInwardsSoilLayer(top);
+
+            // Assert
+            Assert.NotNull(layer);
+            Assert.AreEqual(top, layer.Top);
+            Assert.IsFalse(layer.IsAquifer);
+            Assert.IsEmpty(layer.MaterialName);
+            Assert.AreEqual(Color.Empty, layer.Color);
+
+            Assert.IsFalse(layer.UsePop);
+            Assert.AreEqual(ShearStrengthModel.None, layer.ShearStrengthModel);
+
+            Assert.IsNaN(layer.AbovePhreaticLevelMean);
+            Assert.IsNaN(layer.AbovePhreaticLevelDeviation);
+
+            Assert.IsNaN(layer.BelowPhreaticLevelMean);
+            Assert.IsNaN(layer.BelowPhreaticLevelDeviation);
+
+            Assert.IsNaN(layer.CohesionMean);
+            Assert.IsNaN(layer.CohesionDeviation);
+            Assert.IsNaN(layer.CohesionShift);
+
+            Assert.IsNaN(layer.FrictionAngleMean);
+            Assert.IsNaN(layer.FrictionAngleDeviation);
+            Assert.IsNaN(layer.FrictionAngleShift);
+
+            Assert.IsNaN(layer.ShearStrengthRatioMean);
+            Assert.IsNaN(layer.ShearStrengthRatioDeviation);
+            Assert.IsNaN(layer.ShearStrengthRatioShift);
+
+            Assert.IsNaN(layer.StrengthIncreaseExponentMean);
+            Assert.IsNaN(layer.StrengthIncreaseExponentDeviation);
+            Assert.IsNaN(layer.StrengthIncreaseExponentShift);
+
+            Assert.IsNaN(layer.PopMean);
+            Assert.IsNaN(layer.PopDeviation);
+            Assert.IsNaN(layer.PopShift);
+        }
+
+        [Test]
+        public void MaterialName_Null_ThrowsArgumentNullException()
+        {
+            // Setup
+            double top = new Random(22).NextDouble();
+            var layer = new MacroStabilityInwardsSoilLayer(top);
+
+            // Call
+            TestDelegate test = () => layer.MaterialName = null;
+
+            // Assert
+            string paramName = Assert.Throws<ArgumentNullException>(test).ParamName;
+            Assert.AreEqual("value", paramName);
+        }
+
+        [Test]
+        [TestCase("")]
+        [TestCase("A name")]
+        public void MaterialName_NotNullValue_ValueSet(string materialName)
+        {
+            // Setup
+            double top = new Random(22).NextDouble();
+            var layer = new MacroStabilityInwardsSoilLayer(top);
+
+            // Call
+            layer.MaterialName = materialName;
+
+            // Assert
+            Assert.AreEqual(materialName, layer.MaterialName);
+        }
+
+        [Test]
+        public void Equals_Null_ReturnsFalse()
+        {
+            // Setup
+            MacroStabilityInwardsSoilLayer layer = CreateRandomLayer(21);
+
+            // Call
+            bool areEqual = layer.Equals(null);
+
+            // Assert
+            Assert.IsFalse(areEqual);
+        }
+
+        [Test]
+        [TestCaseSource(nameof(LayerCombinations))]
+        public void Equals_DifferentScenarios_ReturnsExpectedResult(MacroStabilityInwardsSoilLayer layer, MacroStabilityInwardsSoilLayer otherLayer, bool expectedEqual)
+        {
+            // Call
+            bool areEqualOne = layer.Equals(otherLayer);
+            bool areEqualTwo = otherLayer.Equals(layer);
+
+            // Assert
+            Assert.AreEqual(expectedEqual, areEqualOne);
+            Assert.AreEqual(expectedEqual, areEqualTwo);
+        }
+
+        private static TestCaseData[] LayerCombinations()
+        {
+            MacroStabilityInwardsSoilLayer layerA = CreateRandomLayer(21);
+            MacroStabilityInwardsSoilLayer layerB = CreateRandomLayer(21);
+            MacroStabilityInwardsSoilLayer layerC = CreateRandomLayer(73);
+
+            return new[]
+            {
+                new TestCaseData(layerA, layerA, true)
+                {
+                    TestName = "Equals_LayerALayerA_True"
+                },
+                new TestCaseData(layerA, layerB, true)
+                {
+                    TestName = "Equals_LayerALayerB_True"
+                },
+                new TestCaseData(layerB, layerC, false)
+                {
+                    TestName = "Equals_LayerBLayerC_False"
+                },
+                new TestCaseData(layerC, layerC, true)
+                {
+                    TestName = "Equals_LayerCLayerC_True"
+                }
+            };
+        }
+
+        private static MacroStabilityInwardsSoilLayer CreateRandomLayer(int randomSeed)
+        {
+            var random = new Random(randomSeed);
+            return new MacroStabilityInwardsSoilLayer(random.NextDouble())
+            {
+                MaterialName = string.Join("", Enumerable.Repeat('x', random.Next(0, 40))),
+                Color = Color.FromKnownColor(random.NextEnumValue<KnownColor>()),
+                IsAquifer = random.NextBoolean()
+            };
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/MacroStabilityInwardsSoilProfileTest.cs
===================================================================
diff -u
--- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/MacroStabilityInwardsSoilProfileTest.cs	(revision 0)
+++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/MacroStabilityInwardsSoilProfileTest.cs	(revision 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab)
@@ -0,0 +1,337 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Drawing;
+using System.Linq;
+using Core.Common.TestUtil;
+using NUnit.Framework;
+
+namespace Ringtoets.MacroStabilityInwards.Primitives.Test
+{
+    [TestFixture]
+    public class MacroStabilityInwardsSoilProfileTest
+    {
+        private static readonly Random profileIdRandom = new Random(32);
+
+        [Test]
+        [TestCase(SoilProfileType.SoilProfile1D)]
+        [TestCase(SoilProfileType.SoilProfile2D)]
+        public void Constructor_WithNameBottomLayersAndAquifer_ReturnsInstanceWithPropsAndEquivalentLayerCollection(SoilProfileType type)
+        {
+            // Setup
+            const string name = "Profile";
+            var random = new Random(22);
+            double bottom = random.NextDouble();
+            var layers = new Collection<MacroStabilityInwardsSoilLayer>
+            {
+                new MacroStabilityInwardsSoilLayer(bottom)
+            };
+            const long soilProfileId = 1234L;
+
+            // Call
+            var profile = new MacroStabilityInwardsSoilProfile(name, bottom, layers, type, soilProfileId);
+
+            // Assert
+            Assert.AreNotSame(layers, profile.Layers);
+            Assert.AreEqual(name, profile.Name);
+            Assert.AreEqual(bottom, profile.Bottom);
+            Assert.AreEqual(type, profile.SoilProfileType);
+            Assert.AreEqual(soilProfileId, profile.MacroStabilityInwardsSoilProfileId);
+        }
+
+        [Test]
+        public void Constructor_WithNameBottomLayersEmpty_ThrowsArgumentException()
+        {
+            // Call
+            TestDelegate test = () => new MacroStabilityInwardsSoilProfile(string.Empty, double.NaN, new Collection<MacroStabilityInwardsSoilLayer>(), SoilProfileType.SoilProfile1D, 0);
+
+            // Assert
+            const string expectedMessage = "Geen lagen gevonden voor de ondergrondschematisatie.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentException>(test, expectedMessage);
+        }
+
+        [Test]
+        public void Constructor_WithNameBottomLayersNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate test = () => new MacroStabilityInwardsSoilProfile(string.Empty, double.NaN, null, SoilProfileType.SoilProfile1D, 0);
+
+            // Assert
+            const string expectedMessage = "Geen lagen gevonden voor de ondergrondschematisatie.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentNullException>(test, expectedMessage);
+        }
+
+        [Test]
+        [TestCase(1)]
+        [TestCase(5)]
+        [TestCase(15)]
+        public void Layers_Always_ReturnsDescendingByTopOrderedList(int layerCount)
+        {
+            // Setup
+            var random = new Random(21);
+            const double bottom = 0.0;
+            var equivalentLayers = new List<MacroStabilityInwardsSoilLayer>(layerCount);
+            for (var i = 0; i < layerCount; i++)
+            {
+                equivalentLayers.Add(new MacroStabilityInwardsSoilLayer(random.NextDouble())
+                {
+                    IsAquifer = i == 0
+                });
+            }
+
+            var profile = new MacroStabilityInwardsSoilProfile(string.Empty, bottom, equivalentLayers, SoilProfileType.SoilProfile1D, 0);
+
+            // Call
+            MacroStabilityInwardsSoilLayer[] result = profile.Layers.ToArray();
+
+            // Assert
+            CollectionAssert.AreEquivalent(equivalentLayers, result);
+            CollectionAssert.AreEqual(equivalentLayers.OrderByDescending(l => l.Top).Select(l => l.Top), result.Select(l => l.Top));
+        }
+
+        [Test]
+        [TestCase(1e-6)]
+        [TestCase(4)]
+        public void Constructor_WithNameBottomLayersBelowBottom_ThrowsArgumentException(double deltaBelowBottom)
+        {
+            // Setup
+            const double bottom = 0.0;
+            var soilLayers = new[]
+            {
+                new MacroStabilityInwardsSoilLayer(bottom - deltaBelowBottom),
+                new MacroStabilityInwardsSoilLayer(1.1)
+            };
+
+            // Call
+            TestDelegate test = () => new MacroStabilityInwardsSoilProfile(string.Empty, bottom, soilLayers, SoilProfileType.SoilProfile1D, 0);
+
+            // Assert
+            const string expectedMessage = "Eén of meerdere lagen hebben een top onder de bodem van de ondergrondschematisatie.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentException>(test, expectedMessage);
+        }
+
+        [Test]
+        [TestCase(0, 0)]
+        [TestCase(1, 1.1)]
+        public void GetLayerThickness_LayerInProfile_ReturnsThicknessOfLayer(int layerIndex, double expectedThickness)
+        {
+            // Setup
+            var soilLayers = new[]
+            {
+                new MacroStabilityInwardsSoilLayer(0.0),
+                new MacroStabilityInwardsSoilLayer(1.1)
+            };
+            var profile = new MacroStabilityInwardsSoilProfile(string.Empty, 0.0, soilLayers, SoilProfileType.SoilProfile1D, 0);
+
+            // Call
+            double thickness = profile.GetLayerThickness(soilLayers[layerIndex]);
+
+            // Assert
+            Assert.AreEqual(expectedThickness, thickness);
+        }
+
+        [Test]
+        public void GetLayerThickness_LayerNotInProfile_ThrowsArgumentException()
+        {
+            // Setup
+            var soilLayers = new[]
+            {
+                new MacroStabilityInwardsSoilLayer(0.0),
+                new MacroStabilityInwardsSoilLayer(1.1)
+            };
+            var profile = new MacroStabilityInwardsSoilProfile(string.Empty, 0.0, soilLayers, SoilProfileType.SoilProfile1D, 0);
+
+            // Call
+            TestDelegate test = () => profile.GetLayerThickness(new MacroStabilityInwardsSoilLayer(1.1));
+
+            // Assert
+            const string expectedMessage = "Layer not found in profile.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentException>(test, expectedMessage);
+        }
+
+        [Test]
+        public void ToString_WithNullName_ReturnsStringEmpty()
+        {
+            // Setup
+            var profile = new MacroStabilityInwardsSoilProfile(null, 0.0, new[]
+            {
+                new MacroStabilityInwardsSoilLayer(0.0)
+            }, SoilProfileType.SoilProfile1D, 0);
+
+            // Call
+            string text = profile.ToString();
+
+            // Assert
+            Assert.IsEmpty(text);
+        }
+
+        [Test]
+        [TestCase("")]
+        [TestCase("some name")]
+        public void ToString_WithName_ReturnsName(string name)
+        {
+            // Setup
+            var profile = new MacroStabilityInwardsSoilProfile(name, 0.0, new[]
+            {
+                new MacroStabilityInwardsSoilLayer(0.0)
+            }, SoilProfileType.SoilProfile1D, 0);
+
+            // Call
+            string text = profile.ToString();
+
+            // Assert
+            Assert.AreEqual(name, text);
+        }
+
+        [Test]
+        public void Equals_Null_ReturnsFalse()
+        {
+            // Setup
+            var profile = new MacroStabilityInwardsSoilProfile("name", 0, new[]
+            {
+                CreateRandomLayer(new Random(21))
+            }, SoilProfileType.SoilProfile1D, -1);
+
+            // Call
+            bool areEqual = profile.Equals(null);
+
+            // Assert
+            Assert.IsFalse(areEqual);
+        }
+
+        [Test]
+        [TestCaseSource(nameof(ProfileCombinations))]
+        public void Equals_DifferentScenarios_ReturnsExpectedResult(MacroStabilityInwardsSoilProfile profile, MacroStabilityInwardsSoilProfile otherProfile, bool expectedEqual)
+        {
+            // Call
+            bool areEqualOne = profile.Equals(otherProfile);
+            bool areEqualTwo = otherProfile.Equals(profile);
+
+            // Assert
+            Assert.AreEqual(expectedEqual, areEqualOne);
+            Assert.AreEqual(expectedEqual, areEqualTwo);
+        }
+
+        private static TestCaseData[] ProfileCombinations()
+        {
+            MacroStabilityInwardsSoilProfile profileA = CreateRandomProfile(21);
+            MacroStabilityInwardsSoilProfile profileB = CreateRandomProfile(21);
+            MacroStabilityInwardsSoilProfile profileC = CreateRandomProfile(73);
+
+            MacroStabilityInwardsSoilProfile profileD = CreateSingleLayerProfile("A", -3, SoilProfileType.SoilProfile1D);
+            MacroStabilityInwardsSoilProfile profileE = CreateSingleLayerProfile("A", -3, SoilProfileType.SoilProfile2D);
+            MacroStabilityInwardsSoilProfile profileF = CreateSingleLayerProfile("A", -2, SoilProfileType.SoilProfile1D);
+            MacroStabilityInwardsSoilProfile profileG = CreateSingleLayerProfile("B", -3, SoilProfileType.SoilProfile1D);
+
+            const int seed = 78;
+            var random = new Random(seed);
+            var profileH = new MacroStabilityInwardsSoilProfile(GetRandomName(random), -random.NextDouble(), new[]
+            {
+                CreateRandomLayer(random)
+            }, random.NextEnumValue<SoilProfileType>(), random.Next());
+
+            random = new Random(seed);
+            var profileI = new MacroStabilityInwardsSoilProfile(GetRandomName(random), -random.NextDouble(), new[]
+            {
+                CreateRandomLayer(random),
+                CreateRandomLayer(random)
+            }, random.NextEnumValue<SoilProfileType>(), random.Next());
+
+            var profileJ = new MacroStabilityInwardsSoilProfile("A", -3, new[]
+            {
+                new MacroStabilityInwardsSoilLayer(-2)
+            }, SoilProfileType.SoilProfile1D, 35);
+            var profileK = new MacroStabilityInwardsSoilProfile("A", -3, new[]
+            {
+                new MacroStabilityInwardsSoilLayer(-2)
+            }, SoilProfileType.SoilProfile1D, 56);
+
+            return new[]
+            {
+                new TestCaseData(profileA, profileB, true)
+                {
+                    TestName = "Equals_ProfileAProfileB_True"
+                },
+                new TestCaseData(profileB, profileC, false)
+                {
+                    TestName = "Equals_ProfileBProfileC_False"
+                },
+                new TestCaseData(profileD, profileE, false)
+                {
+                    TestName = "Equals_ProfileDProfileE_False"
+                },
+                new TestCaseData(profileD, profileF, false)
+                {
+                    TestName = "Equals_ProfileDProfileF_False"
+                },
+                new TestCaseData(profileD, profileG, false)
+                {
+                    TestName = "Equals_ProfileDProfileG_False"
+                },
+                new TestCaseData(profileH, profileI, false)
+                {
+                    TestName = "Equals_ProfileHProfileI_False"
+                },
+                new TestCaseData(profileJ, profileK, true)
+                {
+                    TestName = "Equals_DifferentIds_True"
+                }
+            };
+        }
+
+        private static MacroStabilityInwardsSoilProfile CreateSingleLayerProfile(string name, double bottom, SoilProfileType type)
+        {
+            return new MacroStabilityInwardsSoilProfile(name, bottom, new[]
+            {
+                new MacroStabilityInwardsSoilLayer(bottom + 1.0)
+            }, type, profileIdRandom.Next());
+        }
+
+        private static MacroStabilityInwardsSoilProfile CreateRandomProfile(int randomSeed)
+        {
+            var random = new Random(randomSeed);
+            var layers = new Collection<MacroStabilityInwardsSoilLayer>();
+            for (var i = 0; i < random.Next(2, 6); i++)
+            {
+                layers.Add(CreateRandomLayer(random));
+            }
+            return new MacroStabilityInwardsSoilProfile(GetRandomName(random), -1.0 - random.NextDouble(), layers, random.NextEnumValue<SoilProfileType>(), profileIdRandom.Next());
+        }
+
+        private static MacroStabilityInwardsSoilLayer CreateRandomLayer(Random random)
+        {
+            return new MacroStabilityInwardsSoilLayer(random.NextDouble())
+            {
+                MaterialName = GetRandomName(random),
+                Color = Color.FromKnownColor(random.NextEnumValue<KnownColor>()),
+                IsAquifer = random.NextBoolean()
+            };
+        }
+
+        private static string GetRandomName(Random random)
+        {
+            return new string('x', random.Next(0, 40));
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/Ringtoets.MacroStabilityInwards.Primitives.Test.csproj
===================================================================
diff -u -r650fc7b43cb6729baee51d079f0377df8d7a3de9 -r9caa7daa14d0070e2a3f68c4b9e66109318bd9ab
--- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/Ringtoets.MacroStabilityInwards.Primitives.Test.csproj	(.../Ringtoets.MacroStabilityInwards.Primitives.Test.csproj)	(revision 650fc7b43cb6729baee51d079f0377df8d7a3de9)
+++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/Ringtoets.MacroStabilityInwards.Primitives.Test.csproj	(.../Ringtoets.MacroStabilityInwards.Primitives.Test.csproj)	(revision 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab)
@@ -41,20 +41,53 @@
     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="nunit.framework, Version=3.6.0.0, Culture=neutral, PublicKeyToken=2638cd05610744eb, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\packages\NUnit.3.6.0\lib\net40\nunit.framework.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="..\..\..\..\Core\Common\src\Core.Common.Version\GlobalAssembly.cs">
       <Link>Properties\GlobalAssembly.cs</Link>
     </Compile>
+    <Compile Include="Exceptions\RingtoetsMacroStabilityInwardsSurfaceLineExceptionTest.cs" />
+    <Compile Include="MacroStabilityInwardsSoilLayerTest.cs" />
+    <Compile Include="MacroStabilityInwardsSoilProfileTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="RingtoetsMacroStabilityInwardsSurfaceLineTest.cs" />
+    <Compile Include="SoilLayerPropertiesTest.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="..\..\..\..\build\Copying.licenseheader">
       <Link>Copying.licenseheader</Link>
     </None>
+    <None Include="packages.config" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\Core\Common\src\Core.Common.Base\Core.Common.Base.csproj">
+      <Project>{3BBFD65B-B277-4E50-AE6D-BD24C3434609}</Project>
+      <Name>Core.Common.Base</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\..\Core\Common\test\Core.Common.TestUtil\Core.Common.TestUtil.csproj">
+      <Project>{D749EE4C-CE50-4C17-BF01-9A953028C126}</Project>
+      <Name>Core.Common.TestUtil</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\Common\src\Ringtoets.Common.Data\Ringtoets.Common.Data.csproj">
+      <Project>{d4200f43-3f72-4f42-af0a-8ced416a38ec}</Project>
+      <Name>Ringtoets.Common.Data</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\Common\test\Ringtoets.Common.Data.TestUtil\Ringtoets.Common.Data.TestUtil.csproj">
+      <Project>{4843D6E5-066F-4795-94F5-1D53932DD03C}</Project>
+      <Name>Ringtoets.Common.Data.TestUtil</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\src\Ringtoets.MacroStabilityInwards.Primitives\Ringtoets.MacroStabilityInwards.Primitives.csproj">
+      <Project>{E9B39743-2DC9-4922-9E0F-6BA3E0E54189}</Project>
+      <Name>Ringtoets.MacroStabilityInwards.Primitives</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: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/RingtoetsMacroStabilityInwardsSurfaceLineTest.cs
===================================================================
diff -u
--- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/RingtoetsMacroStabilityInwardsSurfaceLineTest.cs	(revision 0)
+++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/RingtoetsMacroStabilityInwardsSurfaceLineTest.cs	(revision 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab)
@@ -0,0 +1,1044 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Core.Common.Base;
+using Core.Common.Base.Data;
+using Core.Common.Base.Geometry;
+using Core.Common.TestUtil;
+using NUnit.Framework;
+using Ringtoets.Common.Data.TestUtil;
+using Ringtoets.MacroStabilityInwards.Primitives.Exceptions;
+
+namespace Ringtoets.MacroStabilityInwards.Primitives.Test
+{
+    [TestFixture]
+    public class RingtoetsMacroStabilityInwardsSurfaceLineTest
+    {
+        [Test]
+        public void DefaultConstructor_ExpectedValues()
+        {
+            // Call
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+
+            // Assert
+            Assert.IsInstanceOf<Observable>(surfaceLine);
+            Assert.IsEmpty(surfaceLine.Name);
+            CollectionAssert.IsEmpty(surfaceLine.Points);
+            Assert.IsNull(surfaceLine.StartingWorldPoint);
+            Assert.IsNull(surfaceLine.EndingWorldPoint);
+            Assert.IsNull(surfaceLine.ReferenceLineIntersectionWorldPoint);
+        }
+
+        [Test]
+        public void ReferenceLineIntersectionWorldPoint_SetNewValue_GetNewlySetValue()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+
+            var point = new Point2D(1.2, 3.4);
+
+            // Call
+            surfaceLine.ReferenceLineIntersectionWorldPoint = point;
+
+            // Assert
+            Assert.AreEqual(point, surfaceLine.ReferenceLineIntersectionWorldPoint);
+        }
+
+        [Test]
+        public void SetGeometry_EmptyCollection_PointsSetEmptyAndNullStartAndEndWorldPoints()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+
+            IEnumerable<Point3D> sourceData = Enumerable.Empty<Point3D>();
+
+            // Call
+            surfaceLine.SetGeometry(sourceData);
+
+            // Assert
+            CollectionAssert.IsEmpty(surfaceLine.Points);
+            Assert.IsNull(surfaceLine.StartingWorldPoint);
+            Assert.IsNull(surfaceLine.EndingWorldPoint);
+        }
+
+        [Test]
+        public void SetGeometry_CollectionOfOnePoint_InitializeStartAndEndWorldPointsToSameInstanceAndInitializePoints()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+
+            var sourceData = new[]
+            {
+                new Point3D(1.1, 2.2, 3.3)
+            };
+
+            // Call
+            surfaceLine.SetGeometry(sourceData);
+
+            // Assert
+            Assert.AreNotSame(sourceData, surfaceLine.Points);
+            CollectionAssert.AreEqual(sourceData, surfaceLine.Points);
+            TestHelper.AssertAreEqualButNotSame(sourceData[0], surfaceLine.StartingWorldPoint);
+            TestHelper.AssertAreEqualButNotSame(sourceData[0], surfaceLine.EndingWorldPoint);
+        }
+
+        [Test]
+        public void SetGeometry_CollectionOfMultiplePoints_InitializeStartAndEndWorldPointsInitializePoints()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+
+            var sourceData = new[]
+            {
+                new Point3D(1.1, 2.2, 3.3),
+                new Point3D(4.4, 5.5, 6.6),
+                new Point3D(7.7, 8.8, 9.9),
+                new Point3D(10.10, 11.11, 12.12)
+            };
+
+            // Call
+            surfaceLine.SetGeometry(sourceData);
+
+            // Assert
+            Assert.AreNotSame(sourceData, surfaceLine.Points);
+            CollectionAssert.AreEqual(sourceData, surfaceLine.Points);
+            TestHelper.AssertAreEqualButNotSame(sourceData[0], surfaceLine.StartingWorldPoint);
+            TestHelper.AssertAreEqualButNotSame(sourceData[3], surfaceLine.EndingWorldPoint);
+        }
+
+        [TestFixture]
+        public class SetDitchPolderSideAtTest : SetCharacteristicPointTest
+        {
+            protected override void SetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine, Point3D point)
+            {
+                surfaceLine.SetDitchPolderSideAt(point);
+            }
+
+            protected override Point3D GetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine)
+            {
+                return surfaceLine.DitchPolderSide;
+            }
+
+            protected override string CharacteristicPointDescription()
+            {
+                return "Insteek sloot polderzijde";
+            }
+        }
+
+        [TestFixture]
+        public class SetBottomDitchPolderSideAtTest : SetCharacteristicPointTest
+        {
+            protected override void SetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine, Point3D point)
+            {
+                surfaceLine.SetBottomDitchPolderSideAt(point);
+            }
+
+            protected override Point3D GetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine)
+            {
+                return surfaceLine.BottomDitchPolderSide;
+            }
+
+            protected override string CharacteristicPointDescription()
+            {
+                return "Slootbodem polderzijde";
+            }
+        }
+
+        [TestFixture]
+        public class SetBottomDitchDikeSideAtTest : SetCharacteristicPointTest
+        {
+            protected override void SetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine, Point3D point)
+            {
+                surfaceLine.SetBottomDitchDikeSideAt(point);
+            }
+
+            protected override Point3D GetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine)
+            {
+                return surfaceLine.BottomDitchDikeSide;
+            }
+
+            protected override string CharacteristicPointDescription()
+            {
+                return "Slootbodem dijkzijde";
+            }
+        }
+
+        [TestFixture]
+        public class SetDitchDikeSideAtTest : SetCharacteristicPointTest
+        {
+            protected override void SetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine, Point3D point)
+            {
+                surfaceLine.SetDitchDikeSideAt(point);
+            }
+
+            protected override Point3D GetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine)
+            {
+                return surfaceLine.DitchDikeSide;
+            }
+
+            protected override string CharacteristicPointDescription()
+            {
+                return "Insteek sloot dijkzijde";
+            }
+        }
+
+        [TestFixture]
+        public class SetDikeTopAtPolderAtTest : SetCharacteristicPointTest
+        {
+            protected override void SetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine, Point3D point)
+            {
+                surfaceLine.SetDikeTopAtPolderAt(point);
+            }
+
+            protected override Point3D GetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine)
+            {
+                return surfaceLine.DikeTopAtPolder;
+            }
+
+            protected override string CharacteristicPointDescription()
+            {
+                return "Kruin binnentalud";
+            }
+        }
+
+        [TestFixture]
+        public class SetShoulderBaseInsideAtTest : SetCharacteristicPointTest
+        {
+            protected override void SetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine, Point3D point)
+            {
+                surfaceLine.SetShoulderBaseInsideAt(point);
+            }
+
+            protected override Point3D GetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine)
+            {
+                return surfaceLine.ShoulderBaseInside;
+            }
+
+            protected override string CharacteristicPointDescription()
+            {
+                return "Insteek binnenberm";
+            }
+        }
+
+        [TestFixture]
+        public class SetShoulderTopInsideAtTest : SetCharacteristicPointTest
+        {
+            protected override void SetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine, Point3D point)
+            {
+                surfaceLine.SetShoulderTopInsideAt(point);
+            }
+
+            protected override Point3D GetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine)
+            {
+                return surfaceLine.ShoulderTopInside;
+            }
+
+            protected override string CharacteristicPointDescription()
+            {
+                return "Kruin binnenberm";
+            }
+        }
+
+        [TestFixture]
+        public class SetSurfaceLevelInsideAtTest : SetCharacteristicPointTest
+        {
+            protected override void SetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine, Point3D point)
+            {
+                surfaceLine.SetSurfaceLevelInsideAt(point);
+            }
+
+            protected override Point3D GetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine)
+            {
+                return surfaceLine.SurfaceLevelInside;
+            }
+
+            protected override string CharacteristicPointDescription()
+            {
+                return "Maaiveld binnenwaarts";
+            }
+        }
+
+        [TestFixture]
+        public class SetSurfaceLevelOutsideAtTest : SetCharacteristicPointTest
+        {
+            protected override void SetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine, Point3D point)
+            {
+                surfaceLine.SetSurfaceLevelOutsideAt(point);
+            }
+
+            protected override Point3D GetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine)
+            {
+                return surfaceLine.SurfaceLevelOutside;
+            }
+
+            protected override string CharacteristicPointDescription()
+            {
+                return "Maaiveld buitenwaarts";
+            }
+        }
+
+        [TestFixture]
+        public class SetTrafficLoadInsideAtTest : SetCharacteristicPointTest
+        {
+            protected override void SetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine, Point3D point)
+            {
+                surfaceLine.SetTrafficLoadInsideAt(point);
+            }
+
+            protected override Point3D GetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine)
+            {
+                return surfaceLine.TrafficLoadInside;
+            }
+
+            protected override string CharacteristicPointDescription()
+            {
+                return "Verkeersbelasting kant binnenwaarts";
+            }
+        }
+
+        [TestFixture]
+        public class SetTrafficLoadOutsideAtTest : SetCharacteristicPointTest
+        {
+            protected override void SetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine, Point3D point)
+            {
+                surfaceLine.SetTrafficLoadOutsideAt(point);
+            }
+
+            protected override Point3D GetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine)
+            {
+                return surfaceLine.TrafficLoadOutside;
+            }
+
+            protected override string CharacteristicPointDescription()
+            {
+                return "Verkeersbelasting kant buitenwaarts";
+            }
+        }
+
+        [TestFixture]
+        public class SetDikeToeAtRiverAtTest : SetCharacteristicPointTest
+        {
+            protected override void SetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine, Point3D point)
+            {
+                surfaceLine.SetDikeToeAtRiverAt(point);
+            }
+
+            protected override Point3D GetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine)
+            {
+                return surfaceLine.DikeToeAtRiver;
+            }
+
+            protected override string CharacteristicPointDescription()
+            {
+                return "Teen dijk buitenwaarts";
+            }
+        }
+
+        [TestFixture]
+        public class SetDikeToeAtPolderAtTest : SetCharacteristicPointTest
+        {
+            protected override void SetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine, Point3D point)
+            {
+                surfaceLine.SetDikeToeAtPolderAt(point);
+            }
+
+            protected override Point3D GetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine)
+            {
+                return surfaceLine.DikeToeAtPolder;
+            }
+
+            protected override string CharacteristicPointDescription()
+            {
+                return "Teen dijk binnenwaarts";
+            }
+        }
+
+        public abstract class SetCharacteristicPointTest
+        {
+            [Test]
+            public void PointInGeometry_PointSetFromGeometry()
+            {
+                // Setup
+                const double testX = 1.0;
+                const double testY = 2.2;
+                const double testZ = 4.4;
+                var testPoint = new Point3D(testX, testY, testZ);
+                var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+                CreateTestGeometry(testPoint, surfaceLine);
+
+                // Call
+                SetCharacteristicPoint(surfaceLine, testPoint);
+
+                // Assert
+                Assert.AreEqual(testPoint, GetCharacteristicPoint(surfaceLine));
+                Assert.AreNotSame(testPoint, GetCharacteristicPoint(surfaceLine));
+            }
+
+            [Test]
+            public void GeometryEmpty_ThrowsInvalidOperationException()
+            {
+                // Setup
+                var random = new Random(21);
+                var testPoint = new Point3D(random.NextDouble(), random.NextDouble(), random.NextDouble());
+                var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+
+                // Call
+                TestDelegate test = () => SetCharacteristicPoint(surfaceLine, testPoint);
+
+                // Assert
+                string expectedMessage = $"De geometrie bevat geen punt op locatie {testPoint} om als '{CharacteristicPointDescription()}' in te stellen.";
+                TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentException>(test, expectedMessage);
+            }
+
+            [Test]
+            public void Null_ThrowsArgumentNullException()
+            {
+                // Setup
+                var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+
+                // Call
+                TestDelegate test = () => SetCharacteristicPoint(surfaceLine, null);
+
+                // Assert
+                const string expectedMessage = "Cannot find a point in geometry using a null point.";
+                TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentNullException>(test, expectedMessage);
+            }
+
+            protected abstract void SetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine, Point3D point);
+            protected abstract Point3D GetCharacteristicPoint(RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine);
+            protected abstract string CharacteristicPointDescription();
+        }
+
+        [Test]
+        public void ProjectGeometryToLZ_EmptyCollection_ReturnEmptyCollection()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+
+            // Call
+            RoundedPoint2DCollection lzCoordinates = surfaceLine.ProjectGeometryToLZ();
+
+            // Assert
+            CollectionAssert.IsEmpty(lzCoordinates);
+            Assert.AreEqual(2, lzCoordinates.NumberOfDecimalPlaces);
+        }
+
+        [Test]
+        public void ProjectGeometryToLZ_GeometryWithOnePoint_ReturnSinglePointAtZeroXAndOriginalZ()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+            const double originalZ = 3.3;
+            surfaceLine.SetGeometry(new[]
+            {
+                new Point3D(1.1, 2.2, originalZ)
+            });
+
+            // Call
+            RoundedPoint2DCollection lzCoordinates = surfaceLine.ProjectGeometryToLZ();
+
+            // Assert
+            CollectionAssert.AreEqual(new[]
+            {
+                new Point2D(0.0, originalZ)
+            }, lzCoordinates);
+            Assert.AreEqual(2, lzCoordinates.NumberOfDecimalPlaces);
+        }
+
+        [Test]
+        public void ProjectGeometryToLZ_GeometryWithMultiplePoints_ProjectPointsOntoLzPlaneKeepingOriginalZ()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+            surfaceLine.SetGeometry(new[]
+            {
+                new Point3D(1.0, 1.0, 2.2),
+                new Point3D(2.0, 3.0, 4.4), // Outlier from line specified by extrema
+                new Point3D(3.0, 4.0, 7.7)
+            });
+
+            // Call
+            RoundedPoint2DCollection actual = surfaceLine.ProjectGeometryToLZ();
+
+            // Assert
+            double length = Math.Sqrt(2 * 2 + 3 * 3);
+            const double secondCoordinateFactor = (2.0 * 1.0 + 3.0 * 2.0) / (2.0 * 2.0 + 3.0 * 3.0);
+            var expectedCoordinatesX = new[]
+            {
+                0.0,
+                secondCoordinateFactor * length,
+                length
+            };
+            CollectionAssert.AreEqual(expectedCoordinatesX, actual.Select(p => p.X).ToArray(), new DoubleWithToleranceComparer(actual.GetAccuracy()));
+            CollectionAssert.AreEqual(surfaceLine.Points.Select(p => p.Z).ToArray(), actual.Select(p => p.Y).ToArray());
+            Assert.AreEqual(2, actual.NumberOfDecimalPlaces);
+        }
+
+        [Test]
+        public void SetGeometry_GeometryIsNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+
+            // Call
+            TestDelegate test = () => surfaceLine.SetGeometry(null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(test);
+            StringAssert.StartsWith("De geometrie die opgegeven werd voor de profielschematisatie heeft geen waarde.", exception.Message);
+        }
+
+        [Test]
+        public void SetGeometry_GeometryContainsNullPoint_ThrowsArgumentException()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+
+            // Call
+            TestDelegate test = () => surfaceLine.SetGeometry(new Point3D[]
+            {
+                null
+            });
+
+            // Assert
+            var exception = Assert.Throws<ArgumentException>(test);
+            StringAssert.StartsWith("Een punt in de geometrie voor de profielschematisatie heeft geen waarde.", exception.Message);
+        }
+
+        [Test]
+        public void GetZAtL_GeometryIsEmpty_ThrowInvalidOperationException()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+            var l = (RoundedDouble) new Random(21).NextDouble();
+
+            // Call
+            TestDelegate test = () => surfaceLine.GetZAtL(l);
+
+            // Assert
+            string exceptionMessage = Assert.Throws<InvalidOperationException>(test).Message;
+            Assert.AreEqual("De profielschematisatie heeft geen geometrie.", exceptionMessage);
+        }
+
+        [Test]
+        public void GetZAtL_SurfaceLineContainsPointAtL_ReturnsZOfPoint()
+        {
+            // Setup
+            double testZ = new Random(22).NextDouble();
+
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+            var l = (RoundedDouble) 2.0;
+            surfaceLine.SetGeometry(new[]
+            {
+                new Point3D(0.0, 0.0, 2.2),
+                new Point3D(l, 0.0, testZ),
+                new Point3D(3.0, 0.0, 7.7)
+            });
+
+            // Call
+            double result = surfaceLine.GetZAtL(l);
+
+            // Assert
+            Assert.AreEqual(testZ, result, 1e-2);
+        }
+
+        [Test]
+        [SetCulture("nl-NL")]
+        [TestCase(-1)]
+        [TestCase(-5e-3)]
+        [TestCase(3.1 + 5e-3)]
+        [TestCase(4.0)]
+        public void GetZAtL_SurfaceLineDoesNotContainsPointAtL_ThrowsArgumentOutOfRange(double l)
+        {
+            // Setup
+            double testZ = new Random(22).NextDouble();
+
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+            surfaceLine.SetGeometry(new[]
+            {
+                new Point3D(1.0, 0.0, 2.2),
+                new Point3D(2.0, 0.0, testZ),
+                new Point3D(4.1, 0.0, 7.7)
+            });
+
+            // Call
+            TestDelegate test = () => surfaceLine.GetZAtL((RoundedDouble) l);
+
+            // Assert
+            const string expectedMessage = "Kan geen hoogte bepalen. De lokale coördinaat moet in het bereik [0,0, 3,1] liggen.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentOutOfRangeException>(test, expectedMessage);
+        }
+
+        [Test]
+        public void GetZAtL_SurfaceLineVerticalAtL_ThrowsRingtoetsMacroStabilityInwardsSurfaceLineException()
+        {
+            // Setup
+            double testZ = new Random(22).NextDouble();
+
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+            var l = (RoundedDouble) 2.0;
+            surfaceLine.SetGeometry(new[]
+            {
+                new Point3D(0.0, 0.0, 2.2),
+                new Point3D(l, 0.0, testZ),
+                new Point3D(l, 0.0, testZ + 1),
+                new Point3D(3.0, 0.0, 7.7)
+            });
+
+            // Call
+            TestDelegate test = () => surfaceLine.GetZAtL(l);
+
+            // Assert
+            var exception = Assert.Throws<RingtoetsMacroStabilityInwardsSurfaceLineException>(test);
+            string message = $"Kan geen hoogte bepalen op het punt met de lokale coördinaat {l}, omdat de profielschematisatie verticaal loopt op dat punt.";
+            Assert.AreEqual(message, exception.Message);
+        }
+
+        [Test]
+        public void ToString_ReturnName()
+        {
+            // Setup
+            const string niceName = "Nice name";
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine
+            {
+                Name = niceName
+            };
+
+            // Call
+            string text = surfaceLine.ToString();
+
+            // Assert
+            Assert.AreEqual(niceName, text);
+        }
+
+        [Test]
+        [TestCase(5.0)]
+        [TestCase(1.375)]
+        [TestCase(-0.005)]
+        [TestCase(-5)]
+        public void ValidateInRange_PointNotInRange_ReturnsFalse(double invalidValue)
+        {
+            // Setup
+            const double testX = 1.0;
+            const double testY = 2.2;
+            const double testZ = 4.4;
+            var testPoint = new Point3D(testX, testY, testZ);
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+            CreateTestGeometry(testPoint, surfaceLine);
+
+            // Call
+            bool valid = surfaceLine.ValidateInRange(invalidValue);
+
+            // Assert
+            Assert.IsFalse(valid);
+        }
+
+        [Test]
+        [TestCase(-0e-3)]
+        [TestCase(1.37)]
+        [TestCase(1.0)]
+        public void ValidateInRange_PointInRange_ReturnsTrue(double validValue)
+        {
+            // Setup
+            const double testX = 1.0;
+            const double testY = 2.2;
+            const double testZ = 4.4;
+            var testPoint = new Point3D(testX, testY, testZ);
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+            CreateTestGeometry(testPoint, surfaceLine);
+
+            // Call
+            bool valid = surfaceLine.ValidateInRange(validValue);
+
+            // Assert
+            Assert.IsTrue(valid);
+        }
+
+        [Test]
+        public void GetLocalPointFromGeometry_ValidSurfaceLine_ReturnsLocalPoint()
+        {
+            // Setup
+            const double testX = 1.0;
+            const double testY = 2.2;
+            const double testZ = 4.4;
+            var testPoint = new Point3D(testX, testY, testZ);
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+            CreateTestGeometry(testPoint, surfaceLine);
+
+            // Call
+            Point2D localPoint = surfaceLine.GetLocalPointFromGeometry(testPoint);
+
+            // Assert
+            Assert.AreEqual(new Point2D(0.04, 4.4), localPoint);
+        }
+
+        [Test]
+        public void GetLocalPointFromGeometry_NoPointsOnSurfaceLine_ReturnsPointWithNanValues()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+
+            // Call
+            Point2D localPoint = surfaceLine.GetLocalPointFromGeometry(new Point3D(1.0, 2.2, 4.4));
+
+            // Assert
+            Assert.AreEqual(new Point2D(double.NaN, double.NaN), localPoint);
+        }
+
+        [Test]
+        public void GetLocalPointFromGeometry_OnePointOnSurfaceLine_ReturnsPointWithNanValues()
+        {
+            // Setup
+            const double testX = 1.0;
+            const double testY = 2.2;
+            const double testZ = 4.4;
+            var testPoint = new Point3D(testX, testY, testZ);
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+            surfaceLine.SetGeometry(new[]
+            {
+                testPoint
+            });
+
+            // Call
+            Point2D localPoint = surfaceLine.GetLocalPointFromGeometry(testPoint);
+
+            // Assert
+            Assert.AreEqual(new Point2D(double.NaN, double.NaN), localPoint);
+        }
+
+        [Test]
+        public void CopyProperties_WithSurfaceLineNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+
+            // Call
+            TestDelegate call = () => surfaceLine.CopyProperties(null);
+
+            // Assert
+            string paramName = Assert.Throws<ArgumentNullException>(call).ParamName;
+            Assert.AreEqual("fromSurfaceLine", paramName);
+        }
+
+        [Test]
+        public void CopyProperties_LineWithUpdatedGeometricPoints_PropertiesUpdated()
+        {
+            // Setup
+            RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine = CreateSurfaceLineWithCharacteristicPoints();
+
+            RingtoetsMacroStabilityInwardsSurfaceLine surfaceLineToUpdateFrom = CreateSurfaceLineWithCharacteristicPoints();
+            var expectedGeometry = new List<Point3D>
+            {
+                new Point3D(0, 1, 2),
+                new Point3D(3, 4, 5),
+                new Point3D(6, 7, 8)
+            };
+            expectedGeometry.AddRange(surfaceLine.Points);
+            surfaceLineToUpdateFrom.SetGeometry(expectedGeometry);
+
+            // Call
+            surfaceLine.CopyProperties(surfaceLineToUpdateFrom);
+
+            // Assert
+            AssertPropertiesUpdated(surfaceLineToUpdateFrom, surfaceLine);
+        }
+
+        [Test]
+        public void CopyProperties_LineUpdatedWithRemovedCharacteristicPoints_PropertiesUpdated()
+        {
+            // Setup
+            RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine = CreateSurfaceLineWithCharacteristicPoints();
+            var surfaceLineToUpdateFrom = new RingtoetsMacroStabilityInwardsSurfaceLine
+            {
+                Name = surfaceLine.Name,
+                ReferenceLineIntersectionWorldPoint = surfaceLine.ReferenceLineIntersectionWorldPoint
+            };
+            surfaceLineToUpdateFrom.SetGeometry(surfaceLine.Points);
+
+            // Call
+            surfaceLine.CopyProperties(surfaceLineToUpdateFrom);
+
+            // Assert
+            AssertPropertiesUpdated(surfaceLineToUpdateFrom, surfaceLine);
+        }
+
+        [Test]
+        public void CopyProperties_LineWithUpdatedReferenceLineWorldPoint_PropertiesUpdated()
+        {
+            // Setup
+            RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine = CreateSurfaceLineWithCharacteristicPoints();
+
+            var expectedIntersectionPoint = new Point2D(123, 456);
+            RingtoetsMacroStabilityInwardsSurfaceLine surfaceLineToUpdateFrom = CreateSurfaceLineWithCharacteristicPoints();
+            surfaceLineToUpdateFrom.ReferenceLineIntersectionWorldPoint = expectedIntersectionPoint;
+
+            // Call
+            surfaceLine.CopyProperties(surfaceLineToUpdateFrom);
+
+            // Assert
+            AssertPropertiesUpdated(surfaceLineToUpdateFrom, surfaceLine);
+        }
+
+        [Test]
+        public void CopyProperties_LineWithUpdatedGeometryAndReferenceLineIntersectionAndCharacteristicPoints_PropertiesUpdated()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine();
+            RingtoetsMacroStabilityInwardsSurfaceLine surfaceLineToUpdateFrom = CreateSurfaceLineWithCharacteristicPoints();
+
+            // Call
+            surfaceLine.CopyProperties(surfaceLineToUpdateFrom);
+
+            // Assert
+            AssertPropertiesUpdated(surfaceLineToUpdateFrom, surfaceLine);
+        }
+
+        [Test]
+        public void Equals_ToItself_ReturnsTrue()
+        {
+            // Setup
+            var surfaceLineOne = new RingtoetsMacroStabilityInwardsSurfaceLine();
+
+            // Call
+            bool isLineOneEqualToLineOne = surfaceLineOne.Equals(surfaceLineOne);
+
+            // Assert
+            Assert.IsTrue(isLineOneEqualToLineOne);
+        }
+
+        [Test]
+        public void Equal_SameReference_ReturnsTrue()
+        {
+            // Setup
+            var surfaceLineOne = new RingtoetsMacroStabilityInwardsSurfaceLine();
+            RingtoetsMacroStabilityInwardsSurfaceLine surfaceLineTwo = surfaceLineOne;
+
+            // Call
+            bool isLineOneEqualToLineTwo = surfaceLineOne.Equals(surfaceLineTwo);
+            bool isLineTwoEqualToLineOne = surfaceLineTwo.Equals(surfaceLineOne);
+
+            // Assert
+            Assert.IsTrue(isLineOneEqualToLineTwo);
+            Assert.IsTrue(isLineTwoEqualToLineOne);
+        }
+
+        [Test]
+        public void Equals_ToNull_ReturnsFalse()
+        {
+            // Setup
+            var surfaceLineOne = new RingtoetsMacroStabilityInwardsSurfaceLine
+            {
+                Name = "Name A"
+            };
+
+            // Call
+            bool isLineOneEqualToNull = surfaceLineOne.Equals(null);
+
+            // Assert
+            Assert.IsFalse(isLineOneEqualToNull);
+        }
+
+        [Test]
+        public void Equals_ToDifferentType_ReturnsFalse()
+        {
+            // Setup
+            var surfaceLineOne = new RingtoetsMacroStabilityInwardsSurfaceLine
+            {
+                Name = "Name A"
+            };
+
+            var differentType = new object();
+
+            // Call
+            bool isSurfaceLineEqualToDifferentType = surfaceLineOne.Equals(differentType);
+            bool isDifferentTypeEqualToSurfaceLine = differentType.Equals(surfaceLineOne);
+
+            // Assert
+            Assert.IsFalse(isSurfaceLineEqualToDifferentType);
+            Assert.IsFalse(isDifferentTypeEqualToSurfaceLine);
+        }
+
+        [Test]
+        public void Equals_DifferentNames_ReturnsFalse()
+        {
+            // Setup
+            RingtoetsMacroStabilityInwardsSurfaceLine surfaceLineOne = CreateSurfaceLineWithCharacteristicPoints();
+            surfaceLineOne.Name = "Name A";
+
+            RingtoetsMacroStabilityInwardsSurfaceLine surfaceLineTwo = CreateSurfaceLineWithCharacteristicPoints();
+            surfaceLineTwo.Name = "Name B";
+
+            // Call
+            bool isLineOneEqualToLineTwo = surfaceLineOne.Equals(surfaceLineTwo);
+            bool isLineTwoEqualToLineOne = surfaceLineTwo.Equals(surfaceLineOne);
+
+            // Assert
+            Assert.IsFalse(isLineOneEqualToLineTwo);
+            Assert.IsFalse(isLineTwoEqualToLineOne);
+        }
+
+        [Test]
+        public void Equals_DifferentGeometries_ReturnsFalse()
+        {
+            // Setup
+            var surfaceLineOne = new RingtoetsMacroStabilityInwardsSurfaceLine
+            {
+                Name = "Name A"
+            };
+            surfaceLineOne.SetGeometry(new[]
+            {
+                new Point3D(1, 2, 3)
+            });
+
+            var surfaceLineTwo = new RingtoetsMacroStabilityInwardsSurfaceLine
+            {
+                Name = "Name A"
+            };
+            surfaceLineTwo.SetGeometry(new[]
+            {
+                new Point3D(3, 4, 5)
+            });
+
+            // Call
+            bool isLineOneEqualToLineTwo = surfaceLineOne.Equals(surfaceLineTwo);
+            bool isLineTwoEqualToLineOne = surfaceLineTwo.Equals(surfaceLineOne);
+
+            // Assert
+            Assert.IsFalse(isLineOneEqualToLineTwo);
+            Assert.IsFalse(isLineTwoEqualToLineOne);
+        }
+
+        [Test]
+        public void Equals_DifferentReferenceLineIntersectionWorldPoint_ReturnsFalse()
+        {
+            // Setup
+            RingtoetsMacroStabilityInwardsSurfaceLine surfaceLineOne = CreateSurfaceLineWithCharacteristicPoints();
+            surfaceLineOne.ReferenceLineIntersectionWorldPoint = new Point2D(0, 0);
+
+            RingtoetsMacroStabilityInwardsSurfaceLine surfaceLineTwo = CreateSurfaceLineWithCharacteristicPoints();
+            surfaceLineTwo.ReferenceLineIntersectionWorldPoint = new Point2D(1, 1);
+
+            // Call
+            bool isLineOneEqualToLineTwo = surfaceLineOne.Equals(surfaceLineTwo);
+            bool isLineTwoEqualToLineOne = surfaceLineTwo.Equals(surfaceLineOne);
+
+            // Assert
+            Assert.IsFalse(isLineOneEqualToLineTwo);
+            Assert.IsFalse(isLineTwoEqualToLineOne);
+        }
+
+        [Test]
+        public void Equals_NamesGeometriesAndReferenceLineIntersectionWorldPointAndCharacteristicPointsEqual_ReturnsTrue()
+        {
+            // Setup
+            RingtoetsMacroStabilityInwardsSurfaceLine surfaceLineOne = CreateSurfaceLineWithCharacteristicPoints();
+            RingtoetsMacroStabilityInwardsSurfaceLine surfaceLineTwo = CreateSurfaceLineWithCharacteristicPoints();
+
+            // Call
+            bool isLineOneEqualToLineTwo = surfaceLineOne.Equals(surfaceLineTwo);
+            bool isLineTwoEqualToLineOne = surfaceLineTwo.Equals(surfaceLineOne);
+
+            // Assert
+            Assert.IsTrue(isLineOneEqualToLineTwo);
+            Assert.IsTrue(isLineTwoEqualToLineOne);
+        }
+
+        [Test]
+        public void Equals_TransitivePropertyWithSameNamesAndGeometry_ReturnsTrue()
+        {
+            // Setup
+            RingtoetsMacroStabilityInwardsSurfaceLine surfaceLineOne = CreateSurfaceLineWithCharacteristicPoints();
+            RingtoetsMacroStabilityInwardsSurfaceLine surfaceLineTwo = CreateSurfaceLineWithCharacteristicPoints();
+            RingtoetsMacroStabilityInwardsSurfaceLine surfaceLineThree = CreateSurfaceLineWithCharacteristicPoints();
+
+            // Call
+            bool isLineOneEqualToLineTwo = surfaceLineOne.Equals(surfaceLineTwo);
+            bool isLineTwoEqualToLineThree = surfaceLineTwo.Equals(surfaceLineThree);
+            bool isLineOneEqualToLineThree = surfaceLineOne.Equals(surfaceLineThree);
+
+            // Assert
+            Assert.IsTrue(isLineOneEqualToLineTwo);
+            Assert.IsTrue(isLineTwoEqualToLineThree);
+            Assert.IsTrue(isLineOneEqualToLineThree);
+        }
+
+        [Test]
+        public void GetHashCode_EqualSurfaceLines_ReturnSameHashCode()
+        {
+            // Setup
+            var surfaceLineOne = new RingtoetsMacroStabilityInwardsSurfaceLine();
+            var surfaceLineTwo = new RingtoetsMacroStabilityInwardsSurfaceLine();
+
+            // Call
+            int hashCodeOne = surfaceLineOne.GetHashCode();
+            int hashCodeTwo = surfaceLineTwo.GetHashCode();
+
+            // Assert
+            Assert.AreEqual(hashCodeOne, hashCodeTwo);
+        }
+
+        private static void AssertPropertiesUpdated(RingtoetsMacroStabilityInwardsSurfaceLine expectedSurfaceLine,
+                                                    RingtoetsMacroStabilityInwardsSurfaceLine actualSurfaceLine)
+        {
+            Assert.AreEqual(expectedSurfaceLine.Name, actualSurfaceLine.Name);
+            TestHelper.AssertAreEqualButNotSame(expectedSurfaceLine.ReferenceLineIntersectionWorldPoint,
+                                                actualSurfaceLine.ReferenceLineIntersectionWorldPoint);
+            CollectionAssert.AreEqual(expectedSurfaceLine.Points, actualSurfaceLine.Points);
+            TestHelper.AssertCollectionAreNotSame(expectedSurfaceLine.Points, actualSurfaceLine.Points);
+        }
+
+        private static RingtoetsMacroStabilityInwardsSurfaceLine CreateSurfaceLineWithCharacteristicPoints()
+        {
+            var surfaceLine = new RingtoetsMacroStabilityInwardsSurfaceLine
+            {
+                Name = "Name A",
+                ReferenceLineIntersectionWorldPoint = new Point2D(0, 0)
+            };
+            var geometry = new[]
+            {
+                new Point3D(0, 0, 0),
+                new Point3D(1, 0, 2),
+                new Point3D(2, 0, 3),
+                new Point3D(3, 0, 0),
+                new Point3D(4, 0, 2),
+                new Point3D(5, 0, 3)
+            };
+            surfaceLine.SetGeometry(geometry);
+
+            return surfaceLine;
+        }
+
+        private static void CreateTestGeometry(Point3D testPoint, RingtoetsMacroStabilityInwardsSurfaceLine surfaceLine)
+        {
+            var random = new Random(21);
+            var points = new[]
+            {
+                new Point3D(random.NextDouble(), random.NextDouble(), random.NextDouble()),
+                new Point3D(testPoint),
+                new Point3D(2 + random.NextDouble(), random.NextDouble(), random.NextDouble())
+            };
+            surfaceLine.SetGeometry(points);
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/SoilLayerPropertiesTest.cs
===================================================================
diff -u
--- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/SoilLayerPropertiesTest.cs	(revision 0)
+++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/SoilLayerPropertiesTest.cs	(revision 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab)
@@ -0,0 +1,103 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Drawing;
+using NUnit.Framework;
+
+namespace Ringtoets.MacroStabilityInwards.Primitives.Test
+{
+    [TestFixture]
+    public class SoilLayerPropertiesTest
+    {
+        [Test]
+        public void DefaultConstructor_DefaultValuesSet()
+        {
+            // Call
+            var properties = new SoilLayerProperties();
+
+            // Assert
+            Assert.IsFalse(properties.IsAquifer);
+            Assert.IsEmpty(properties.MaterialName);
+            Assert.AreEqual(Color.Empty, properties.Color);
+
+            Assert.IsFalse(properties.UsePop);
+            Assert.AreEqual(ShearStrengthModel.None, properties.ShearStrengthModel);
+
+            Assert.IsNaN(properties.AbovePhreaticLevelMean);
+            Assert.IsNaN(properties.AbovePhreaticLevelDeviation);
+
+            Assert.IsNaN(properties.BelowPhreaticLevelMean);
+            Assert.IsNaN(properties.BelowPhreaticLevelDeviation);
+
+            Assert.IsNaN(properties.CohesionMean);
+            Assert.IsNaN(properties.CohesionDeviation);
+            Assert.IsNaN(properties.CohesionShift);
+
+            Assert.IsNaN(properties.FrictionAngleMean);
+            Assert.IsNaN(properties.FrictionAngleDeviation);
+            Assert.IsNaN(properties.FrictionAngleShift);
+
+            Assert.IsNaN(properties.ShearStrengthRatioMean);
+            Assert.IsNaN(properties.ShearStrengthRatioDeviation);
+            Assert.IsNaN(properties.ShearStrengthRatioShift);
+
+            Assert.IsNaN(properties.StrengthIncreaseExponentMean);
+            Assert.IsNaN(properties.StrengthIncreaseExponentDeviation);
+            Assert.IsNaN(properties.StrengthIncreaseExponentShift);
+
+            Assert.IsNaN(properties.PopMean);
+            Assert.IsNaN(properties.PopDeviation);
+            Assert.IsNaN(properties.PopShift);
+        }
+
+        [Test]
+        public void MaterialName_Null_ThrowsArgumentNullException()
+        {
+            // Setup
+            double top = new Random(22).NextDouble();
+            var layer = new MacroStabilityInwardsSoilLayer(top);
+
+            // Call
+            TestDelegate test = () => layer.MaterialName = null;
+
+            // Assert
+            string paramName = Assert.Throws<ArgumentNullException>(test).ParamName;
+            Assert.AreEqual("value", paramName);
+        }
+
+        [Test]
+        [TestCase("")]
+        [TestCase("A name")]
+        public void MaterialName_NotNullValue_ValueSet(string materialName)
+        {
+            // Setup
+            double top = new Random(22).NextDouble();
+            var layer = new MacroStabilityInwardsSoilLayer(top);
+
+            // Call
+            layer.MaterialName = materialName;
+
+            // Assert
+            Assert.AreEqual(materialName, layer.MaterialName);
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/packages.config
===================================================================
diff -u
--- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/packages.config	(revision 0)
+++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.Primitives.Test/packages.config	(revision 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab)
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+Copyright (C) Stichting Deltares 2017. All rights reserved.
+
+This file is part of Ringtoets.
+
+Ringtoets is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+All names, logos, and references to "Deltares" are registered trademarks of
+Stichting Deltares and remain full property of Stichting Deltares at all times.
+All rights reserved.
+-->
+<packages>
+  <package id="NUnit" version="3.6.0" targetFramework="net40" />
+</packages>
\ No newline at end of file
Fisheye: Tag 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab refers to a dead (removed) revision in file `Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/Exceptions/RingtoetsPipingSurfaceLineExceptionTest.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Fisheye: Tag 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab refers to a dead (removed) revision in file `Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingSoilLayerTest.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Fisheye: Tag 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab refers to a dead (removed) revision in file `Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/PipingSoilProfileTest.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/Ringtoets.Piping.Data.Test.csproj
===================================================================
diff -u -r257b5b8c4e053ff875f75e0940a0f9d8775ef083 -r9caa7daa14d0070e2a3f68c4b9e66109318bd9ab
--- Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/Ringtoets.Piping.Data.Test.csproj	(.../Ringtoets.Piping.Data.Test.csproj)	(revision 257b5b8c4e053ff875f75e0940a0f9d8775ef083)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/Ringtoets.Piping.Data.Test.csproj	(.../Ringtoets.Piping.Data.Test.csproj)	(revision 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab)
@@ -58,7 +58,6 @@
       <Link>Properties\GlobalAssembly.cs</Link>
     </Compile>
     <Compile Include="DerivedPipingInputTest.cs" />
-    <Compile Include="Exceptions\RingtoetsPipingSurfaceLineExceptionTest.cs" />
     <Compile Include="GeneralPipingInputTest.cs" />
     <Compile Include="PipingCalculationScenarioExtensionsTest.cs" />
     <Compile Include="PipingCalculationScenarioTest.cs" />
@@ -69,11 +68,8 @@
     <Compile Include="PipingInputTest.cs" />
     <Compile Include="PipingOutputTest.cs" />
     <Compile Include="PipingSemiProbabilisticOutputTest.cs" />
-    <Compile Include="PipingSoilLayerTest.cs" />
     <Compile Include="PipingSoilProfileExtensionsTest.cs" />
-    <Compile Include="PipingSoilProfileTest.cs" />
     <Compile Include="RingtoetsPipingSurfaceLineCollectionTest.cs" />
-    <Compile Include="RingtoetsPipingSurfaceLineTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="PipingProbabilityAssessmentInputTest.cs" />
     <Compile Include="StochasticSoilModelCollectionTest.cs" />
Fisheye: Tag 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab refers to a dead (removed) revision in file `Ringtoets/Piping/test/Ringtoets.Piping.Data.Test/RingtoetsPipingSurfaceLineTest.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Ringtoets/Piping/test/Ringtoets.Piping.Primitives.Test/Exceptions/RingtoetsPipingSurfaceLineExceptionTest.cs
===================================================================
diff -u
--- Ringtoets/Piping/test/Ringtoets.Piping.Primitives.Test/Exceptions/RingtoetsPipingSurfaceLineExceptionTest.cs	(revision 0)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Primitives.Test/Exceptions/RingtoetsPipingSurfaceLineExceptionTest.cs	(revision 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab)
@@ -0,0 +1,32 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using Core.Common.TestUtil;
+using NUnit.Framework;
+using Ringtoets.Piping.Primitives.Exceptions;
+
+namespace Ringtoets.Piping.Primitives.Test.Exceptions
+{
+    [TestFixture]
+    public class RingtoetsPipingSurfaceLineExceptionTest :
+        CustomExceptionDesignGuidelinesTestFixture<RingtoetsPipingSurfaceLineException, Exception> {}
+}
\ No newline at end of file
Index: Ringtoets/Piping/test/Ringtoets.Piping.Primitives.Test/PipingSoilLayerTest.cs
===================================================================
diff -u
--- Ringtoets/Piping/test/Ringtoets.Piping.Primitives.Test/PipingSoilLayerTest.cs	(revision 0)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Primitives.Test/PipingSoilLayerTest.cs	(revision 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab)
@@ -0,0 +1,196 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Drawing;
+using System.Linq;
+using Core.Common.TestUtil;
+using NUnit.Framework;
+
+namespace Ringtoets.Piping.Primitives.Test
+{
+    [TestFixture]
+    public class PipingSoilLayerTest
+    {
+        [Test]
+        public void Constructor_WithTop_ReturnsNewInstanceWithTopSet()
+        {
+            // Setup
+            double top = new Random(22).NextDouble();
+
+            // Call
+            var layer = new PipingSoilLayer(top);
+
+            // Assert
+            Assert.NotNull(layer);
+            Assert.AreEqual(top, layer.Top);
+            Assert.IsFalse(layer.IsAquifer);
+            Assert.IsEmpty(layer.MaterialName);
+            Assert.AreEqual(Color.Empty, layer.Color);
+
+            Assert.IsNaN(layer.BelowPhreaticLevelMean);
+            Assert.IsNaN(layer.BelowPhreaticLevelDeviation);
+            Assert.IsNaN(layer.BelowPhreaticLevelShift);
+
+            Assert.IsNaN(layer.DiameterD70Mean);
+            Assert.IsNaN(layer.DiameterD70CoefficientOfVariation);
+
+            Assert.IsNaN(layer.PermeabilityMean);
+            Assert.IsNaN(layer.PermeabilityCoefficientOfVariation);
+        }
+
+        [Test]
+        public void MaterialName_Null_ThrowsArgumentNullException()
+        {
+            // Setup
+            double top = new Random(22).NextDouble();
+            var layer = new PipingSoilLayer(top);
+
+            // Call
+            TestDelegate test = () => layer.MaterialName = null;
+
+            // Assert
+            string paramName = Assert.Throws<ArgumentNullException>(test).ParamName;
+            Assert.AreEqual("value", paramName);
+        }
+
+        [Test]
+        [TestCase("")]
+        [TestCase("A name")]
+        public void MaterialName_NotNullValue_ValueSet(string materialName)
+        {
+            // Setup
+            double top = new Random(22).NextDouble();
+            var layer = new PipingSoilLayer(top);
+
+            // Call
+            layer.MaterialName = materialName;
+
+            // Assert
+            Assert.AreEqual(materialName, layer.MaterialName);
+        }
+
+        [Test]
+        public void Equals_Null_ReturnsFalse()
+        {
+            // Setup
+            PipingSoilLayer layer = CreateRandomLayer(21);
+
+            // Call
+            bool areEqual = layer.Equals(null);
+
+            // Assert
+            Assert.IsFalse(areEqual);
+        }
+
+        [Test]
+        [TestCaseSource(nameof(LayerCombinations))]
+        public void Equals_DifferentScenarios_ReturnsExpectedResult(PipingSoilLayer layer, PipingSoilLayer otherLayer, bool expectedEqual)
+        {
+            // Call
+            bool areEqualOne = layer.Equals(otherLayer);
+            bool areEqualTwo = otherLayer.Equals(layer);
+
+            // Assert
+            Assert.AreEqual(expectedEqual, areEqualOne);
+            Assert.AreEqual(expectedEqual, areEqualTwo);
+        }
+
+        private static TestCaseData[] LayerCombinations()
+        {
+            PipingSoilLayer layerA = CreateRandomLayer(21);
+            PipingSoilLayer layerB = CreateRandomLayer(21);
+            PipingSoilLayer layerC = CreateRandomLayer(73);
+
+            PipingSoilLayer layerD = CreateNaNLayer("C", Color.Aqua, true);
+            PipingSoilLayer layerE = CreateNaNLayer("C", Color.Aqua, false);
+            PipingSoilLayer layerF = CreateNaNLayer("C", Color.AliceBlue, false);
+            PipingSoilLayer layerG = CreateNaNLayer("A", Color.Aqua, false);
+
+            return new[]
+            {
+                new TestCaseData(layerA, layerA, true)
+                {
+                    TestName = "Equals_LayerALayerA_True"
+                },
+                new TestCaseData(layerA, layerB, true)
+                {
+                    TestName = "Equals_LayerALayerB_True"
+                },
+                new TestCaseData(layerB, layerC, false)
+                {
+                    TestName = "Equals_LayerBLayerC_False"
+                },
+                new TestCaseData(layerC, layerC, true)
+                {
+                    TestName = "Equals_LayerCLayerC_True"
+                },
+                new TestCaseData(layerD, layerE, false)
+                {
+                    TestName = "Equals_LayerDLayerE_False"
+                },
+                new TestCaseData(layerD, layerF, false)
+                {
+                    TestName = "Equals_LayerDLayerF_False"
+                },
+                new TestCaseData(layerD, layerG, false)
+                {
+                    TestName = "Equals_LayerDLayerG_False"
+                }
+            };
+        }
+
+        private static PipingSoilLayer CreateRandomLayer(int randomSeed)
+        {
+            var random = new Random(randomSeed);
+            return new PipingSoilLayer(random.NextDouble())
+            {
+                MaterialName = string.Join("", Enumerable.Repeat('x', random.Next(0, 40))),
+                Color = Color.FromKnownColor(random.NextEnumValue<KnownColor>()),
+                IsAquifer = random.NextBoolean(),
+                BelowPhreaticLevelDeviation = random.NextDouble(),
+                BelowPhreaticLevelMean = random.NextDouble(),
+                BelowPhreaticLevelShift = random.NextDouble(),
+                DiameterD70CoefficientOfVariation = random.NextDouble(),
+                DiameterD70Mean = random.NextDouble(),
+                PermeabilityCoefficientOfVariation = random.NextDouble(),
+                PermeabilityMean = random.NextDouble()
+            };
+        }
+
+        private static PipingSoilLayer CreateNaNLayer(string name, Color color, bool isAquifer)
+        {
+            return new PipingSoilLayer(double.NaN)
+            {
+                MaterialName = name,
+                Color = color,
+                IsAquifer = isAquifer,
+                BelowPhreaticLevelDeviation = double.NaN,
+                BelowPhreaticLevelMean = double.NaN,
+                BelowPhreaticLevelShift = double.NaN,
+                DiameterD70CoefficientOfVariation = double.NaN,
+                DiameterD70Mean = double.NaN,
+                PermeabilityCoefficientOfVariation = double.NaN,
+                PermeabilityMean = double.NaN
+            };
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Piping/test/Ringtoets.Piping.Primitives.Test/PipingSoilProfileTest.cs
===================================================================
diff -u
--- Ringtoets/Piping/test/Ringtoets.Piping.Primitives.Test/PipingSoilProfileTest.cs	(revision 0)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Primitives.Test/PipingSoilProfileTest.cs	(revision 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab)
@@ -0,0 +1,344 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Drawing;
+using System.Linq;
+using Core.Common.TestUtil;
+using NUnit.Framework;
+
+namespace Ringtoets.Piping.Primitives.Test
+{
+    [TestFixture]
+    public class PipingSoilProfileTest
+    {
+        private static readonly Random profileIdRandom = new Random(32);
+
+        [Test]
+        [TestCase(SoilProfileType.SoilProfile1D)]
+        [TestCase(SoilProfileType.SoilProfile2D)]
+        public void Constructor_WithNameBottomLayersAndAquifer_ReturnsInstanceWithPropsAndEquivalentLayerCollection(SoilProfileType type)
+        {
+            // Setup
+            const string name = "Profile";
+            var random = new Random(22);
+            double bottom = random.NextDouble();
+            var layers = new Collection<PipingSoilLayer>
+            {
+                new PipingSoilLayer(bottom)
+            };
+            const long pipingSoilProfileId = 1234L;
+
+            // Call
+            var profile = new PipingSoilProfile(name, bottom, layers, type, pipingSoilProfileId);
+
+            // Assert
+            Assert.AreNotSame(layers, profile.Layers);
+            Assert.AreEqual(name, profile.Name);
+            Assert.AreEqual(bottom, profile.Bottom);
+            Assert.AreEqual(type, profile.SoilProfileType);
+            Assert.AreEqual(pipingSoilProfileId, profile.PipingSoilProfileId);
+        }
+
+        [Test]
+        public void Constructor_WithNameBottomLayersEmpty_ThrowsArgumentException()
+        {
+            // Call
+            TestDelegate test = () => new PipingSoilProfile(string.Empty, double.NaN, new Collection<PipingSoilLayer>(), SoilProfileType.SoilProfile1D, 0);
+
+            // Assert
+            const string expectedMessage = "Geen lagen gevonden voor de ondergrondschematisatie.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentException>(test, expectedMessage);
+        }
+
+        [Test]
+        public void Constructor_WithNameBottomLayersNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate test = () => new PipingSoilProfile(string.Empty, double.NaN, null, SoilProfileType.SoilProfile1D, 0);
+
+            // Assert
+            const string expectedMessage = "Geen lagen gevonden voor de ondergrondschematisatie.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentNullException>(test, expectedMessage);
+        }
+
+        [Test]
+        [TestCase(1)]
+        [TestCase(5)]
+        [TestCase(15)]
+        public void Layers_Always_ReturnsDescendingByTopOrderedList(int layerCount)
+        {
+            // Setup
+            var random = new Random(21);
+            const double bottom = 0.0;
+            var equivalentLayers = new List<PipingSoilLayer>(layerCount);
+            for (var i = 0; i < layerCount; i++)
+            {
+                equivalentLayers.Add(new PipingSoilLayer(random.NextDouble())
+                {
+                    IsAquifer = i == 0
+                });
+            }
+
+            var profile = new PipingSoilProfile(string.Empty, bottom, equivalentLayers, SoilProfileType.SoilProfile1D, 0);
+
+            // Call
+            PipingSoilLayer[] result = profile.Layers.ToArray();
+
+            // Assert
+            CollectionAssert.AreEquivalent(equivalentLayers, result);
+            CollectionAssert.AreEqual(equivalentLayers.OrderByDescending(l => l.Top).Select(l => l.Top), result.Select(l => l.Top));
+        }
+
+        [Test]
+        [TestCase(1e-6)]
+        [TestCase(4)]
+        public void Constructor_WithNameBottomLayersBelowBottom_ThrowsArgumentException(double deltaBelowBottom)
+        {
+            // Setup
+            const double bottom = 0.0;
+            var pipingSoilLayers = new[]
+            {
+                new PipingSoilLayer(bottom - deltaBelowBottom),
+                new PipingSoilLayer(1.1)
+            };
+
+            // Call
+            TestDelegate test = () => new PipingSoilProfile(string.Empty, bottom, pipingSoilLayers, SoilProfileType.SoilProfile1D, 0);
+
+            // Assert
+            const string expectedMessage = "Eén of meerdere lagen hebben een top onder de bodem van de ondergrondschematisatie.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentException>(test, expectedMessage);
+        }
+
+        [Test]
+        [TestCase(0, 0)]
+        [TestCase(1, 1.1)]
+        public void GetLayerThickness_LayerInProfile_ReturnsThicknessOfLayer(int layerIndex, double expectedThickness)
+        {
+            // Setup
+            var pipingSoilLayers = new[]
+            {
+                new PipingSoilLayer(0.0),
+                new PipingSoilLayer(1.1)
+            };
+            var profile = new PipingSoilProfile(string.Empty, 0.0, pipingSoilLayers, SoilProfileType.SoilProfile1D, 0);
+
+            // Call
+            double thickness = profile.GetLayerThickness(pipingSoilLayers[layerIndex]);
+
+            // Assert
+            Assert.AreEqual(expectedThickness, thickness);
+        }
+
+        [Test]
+        public void GetLayerThickness_LayerNotInProfile_ThrowsArgumentException()
+        {
+            // Setup
+            var pipingSoilLayers = new[]
+            {
+                new PipingSoilLayer(0.0),
+                new PipingSoilLayer(1.1)
+            };
+            var profile = new PipingSoilProfile(string.Empty, 0.0, pipingSoilLayers, SoilProfileType.SoilProfile1D, 0);
+
+            // Call
+            TestDelegate test = () => profile.GetLayerThickness(new PipingSoilLayer(1.1));
+
+            // Assert
+            const string expectedMessage = "Layer not found in profile.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentException>(test, expectedMessage);
+        }
+
+        [Test]
+        public void ToString_WithNullName_ReturnsStringEmpty()
+        {
+            // Setup
+            var profile = new PipingSoilProfile(null, 0.0, new[]
+            {
+                new PipingSoilLayer(0.0)
+            }, SoilProfileType.SoilProfile1D, 0);
+
+            // Call
+            string text = profile.ToString();
+
+            // Assert
+            Assert.IsEmpty(text);
+        }
+
+        [Test]
+        [TestCase("")]
+        [TestCase("some name")]
+        public void ToString_WithName_ReturnsName(string name)
+        {
+            // Setup
+            var profile = new PipingSoilProfile(name, 0.0, new[]
+            {
+                new PipingSoilLayer(0.0)
+            }, SoilProfileType.SoilProfile1D, 0);
+
+            // Call
+            string text = profile.ToString();
+
+            // Assert
+            Assert.AreEqual(name, text);
+        }
+
+        [Test]
+        public void Equals_Null_ReturnsFalse()
+        {
+            // Setup
+            var profile = new PipingSoilProfile("name", 0, new[]
+            {
+                CreateRandomLayer(new Random(21))
+            }, SoilProfileType.SoilProfile1D, -1);
+
+            // Call
+            bool areEqual = profile.Equals(null);
+
+            // Assert
+            Assert.IsFalse(areEqual);
+        }
+
+        [Test]
+        [TestCaseSource(nameof(ProfileCombinations))]
+        public void Equals_DifferentScenarios_ReturnsExpectedResult(PipingSoilProfile profile, PipingSoilProfile otherProfile, bool expectedEqual)
+        {
+            // Call
+            bool areEqualOne = profile.Equals(otherProfile);
+            bool areEqualTwo = otherProfile.Equals(profile);
+
+            // Assert
+            Assert.AreEqual(expectedEqual, areEqualOne);
+            Assert.AreEqual(expectedEqual, areEqualTwo);
+        }
+
+        private static TestCaseData[] ProfileCombinations()
+        {
+            PipingSoilProfile profileA = CreateRandomProfile(21);
+            PipingSoilProfile profileB = CreateRandomProfile(21);
+            PipingSoilProfile profileC = CreateRandomProfile(73);
+
+            PipingSoilProfile profileD = CreateSingleLayerProfile("A", -3, SoilProfileType.SoilProfile1D);
+            PipingSoilProfile profileE = CreateSingleLayerProfile("A", -3, SoilProfileType.SoilProfile2D);
+            PipingSoilProfile profileF = CreateSingleLayerProfile("A", -2, SoilProfileType.SoilProfile1D);
+            PipingSoilProfile profileG = CreateSingleLayerProfile("B", -3, SoilProfileType.SoilProfile1D);
+
+            const int seed = 78;
+            var random = new Random(seed);
+            var profileH = new PipingSoilProfile(GetRandomName(random), -random.NextDouble(), new[]
+            {
+                CreateRandomLayer(random)
+            }, random.NextEnumValue<SoilProfileType>(), random.Next());
+
+            random = new Random(seed);
+            var profileI = new PipingSoilProfile(GetRandomName(random), -random.NextDouble(), new[]
+            {
+                CreateRandomLayer(random),
+                CreateRandomLayer(random)
+            }, random.NextEnumValue<SoilProfileType>(), random.Next());
+
+            var profileJ = new PipingSoilProfile("A", -3, new[]
+            {
+                new PipingSoilLayer(-2)
+            }, SoilProfileType.SoilProfile1D, 35);
+            var profileK = new PipingSoilProfile("A", -3, new[]
+            {
+                new PipingSoilLayer(-2)
+            }, SoilProfileType.SoilProfile1D, 56);
+
+            return new[]
+            {
+                new TestCaseData(profileA, profileB, true)
+                {
+                    TestName = "Equals_ProfileAProfileB_True"
+                },
+                new TestCaseData(profileB, profileC, false)
+                {
+                    TestName = "Equals_ProfileBProfileC_False"
+                },
+                new TestCaseData(profileD, profileE, false)
+                {
+                    TestName = "Equals_ProfileDProfileE_False"
+                },
+                new TestCaseData(profileD, profileF, false)
+                {
+                    TestName = "Equals_ProfileDProfileF_False"
+                },
+                new TestCaseData(profileD, profileG, false)
+                {
+                    TestName = "Equals_ProfileDProfileG_False"
+                },
+                new TestCaseData(profileH, profileI, false)
+                {
+                    TestName = "Equals_ProfileHProfileI_False"
+                },
+                new TestCaseData(profileJ, profileK, true)
+                {
+                    TestName = "Equals_DifferentIds_True"
+                }
+            };
+        }
+
+        private static PipingSoilProfile CreateSingleLayerProfile(string name, double bottom, SoilProfileType type)
+        {
+            return new PipingSoilProfile(name, bottom, new[]
+            {
+                new PipingSoilLayer(bottom + 1.0)
+            }, type, profileIdRandom.Next());
+        }
+
+        private static PipingSoilProfile CreateRandomProfile(int randomSeed)
+        {
+            var random = new Random(randomSeed);
+            var layers = new Collection<PipingSoilLayer>();
+            for (var i = 0; i < random.Next(2, 6); i++)
+            {
+                layers.Add(CreateRandomLayer(random));
+            }
+            return new PipingSoilProfile(GetRandomName(random), -1.0 - random.NextDouble(), layers, random.NextEnumValue<SoilProfileType>(), profileIdRandom.Next());
+        }
+
+        private static PipingSoilLayer CreateRandomLayer(Random random)
+        {
+            return new PipingSoilLayer(random.NextDouble())
+            {
+                MaterialName = GetRandomName(random),
+                Color = Color.FromKnownColor(random.NextEnumValue<KnownColor>()),
+                IsAquifer = random.NextBoolean(),
+                BelowPhreaticLevelDeviation = random.NextDouble(),
+                BelowPhreaticLevelMean = random.NextDouble(),
+                BelowPhreaticLevelShift = random.NextDouble(),
+                DiameterD70CoefficientOfVariation = random.NextDouble(),
+                DiameterD70Mean = random.NextDouble(),
+                PermeabilityCoefficientOfVariation = random.NextDouble(),
+                PermeabilityMean = random.NextDouble()
+            };
+        }
+
+        private static string GetRandomName(Random random)
+        {
+            return new string('x', random.Next(0, 40));
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Piping/test/Ringtoets.Piping.Primitives.Test/Ringtoets.Piping.Primitives.Test.csproj
===================================================================
diff -u -r23d1e296e2da4364fbfe346e68d582dfcf966bb0 -r9caa7daa14d0070e2a3f68c4b9e66109318bd9ab
--- Ringtoets/Piping/test/Ringtoets.Piping.Primitives.Test/Ringtoets.Piping.Primitives.Test.csproj	(.../Ringtoets.Piping.Primitives.Test.csproj)	(revision 23d1e296e2da4364fbfe346e68d582dfcf966bb0)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Primitives.Test/Ringtoets.Piping.Primitives.Test.csproj	(.../Ringtoets.Piping.Primitives.Test.csproj)	(revision 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab)
@@ -41,20 +41,48 @@
     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="nunit.framework, Version=3.6.0.0, Culture=neutral, PublicKeyToken=2638cd05610744eb, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\packages\NUnit.3.6.0\lib\net40\nunit.framework.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="..\..\..\..\Core\Common\src\Core.Common.Version\GlobalAssembly.cs">
       <Link>Properties\GlobalAssembly.cs</Link>
     </Compile>
+    <Compile Include="Exceptions\RingtoetsPipingSurfaceLineExceptionTest.cs" />
+    <Compile Include="PipingSoilLayerTest.cs" />
+    <Compile Include="PipingSoilProfileTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="RingtoetsPipingSurfaceLineTest.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="..\..\..\..\build\Copying.licenseheader">
       <Link>Copying.licenseheader</Link>
     </None>
+    <None Include="packages.config" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\..\Core\Common\src\Core.Common.Base\Core.Common.Base.csproj">
+      <Project>{3BBFD65B-B277-4E50-AE6D-BD24C3434609}</Project>
+      <Name>Core.Common.Base</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\..\Core\Common\test\Core.Common.TestUtil\Core.Common.TestUtil.csproj">
+      <Project>{D749EE4C-CE50-4C17-BF01-9A953028C126}</Project>
+      <Name>Core.Common.TestUtil</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\Common\src\Ringtoets.Common.Data\Ringtoets.Common.Data.csproj">
+      <Project>{d4200f43-3f72-4f42-af0a-8ced416a38ec}</Project>
+      <Name>Ringtoets.Common.Data</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\src\Ringtoets.Piping.Primitives\Ringtoets.Piping.Primitives.csproj">
+      <Project>{14C6F716-64E2-4BC4-A1EF-05865FCEFA4C}</Project>
+      <Name>Ringtoets.Piping.Primitives</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: Ringtoets/Piping/test/Ringtoets.Piping.Primitives.Test/RingtoetsPipingSurfaceLineTest.cs
===================================================================
diff -u
--- Ringtoets/Piping/test/Ringtoets.Piping.Primitives.Test/RingtoetsPipingSurfaceLineTest.cs	(revision 0)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Primitives.Test/RingtoetsPipingSurfaceLineTest.cs	(revision 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab)
@@ -0,0 +1,964 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Core.Common.Base;
+using Core.Common.Base.Data;
+using Core.Common.Base.Geometry;
+using Core.Common.TestUtil;
+using NUnit.Framework;
+using Ringtoets.Piping.Primitives.Exceptions;
+
+namespace Ringtoets.Piping.Primitives.Test
+{
+    [TestFixture]
+    public class RingtoetsPipingSurfaceLineTest
+    {
+        [Test]
+        public void DefaultConstructor_ExpectedValues()
+        {
+            // Call
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+
+            // Assert
+            Assert.IsInstanceOf<Observable>(surfaceLine);
+            Assert.IsEmpty(surfaceLine.Name);
+            CollectionAssert.IsEmpty(surfaceLine.Points);
+            Assert.IsNull(surfaceLine.StartingWorldPoint);
+            Assert.IsNull(surfaceLine.EndingWorldPoint);
+            Assert.IsNull(surfaceLine.ReferenceLineIntersectionWorldPoint);
+        }
+
+        [Test]
+        public void ReferenceLineIntersectionWorldPoint_SetNewValue_GetNewlySetValue()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+
+            var point = new Point2D(1.2, 3.4);
+
+            // Call
+            surfaceLine.ReferenceLineIntersectionWorldPoint = point;
+
+            // Assert
+            Assert.AreEqual(point, surfaceLine.ReferenceLineIntersectionWorldPoint);
+        }
+
+        [Test]
+        public void SetGeometry_EmptyCollection_PointsSetEmptyAndNullStartAndEndWorldPoints()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+
+            IEnumerable<Point3D> sourceData = Enumerable.Empty<Point3D>();
+
+            // Call
+            surfaceLine.SetGeometry(sourceData);
+
+            // Assert
+            CollectionAssert.IsEmpty(surfaceLine.Points);
+            Assert.IsNull(surfaceLine.StartingWorldPoint);
+            Assert.IsNull(surfaceLine.EndingWorldPoint);
+        }
+
+        [Test]
+        public void SetGeometry_CollectionOfOnePoint_InitializeStartAndEndWorldPointsToSameInstanceAndInitializePoints()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+
+            var sourceData = new[]
+            {
+                new Point3D(1.1, 2.2, 3.3)
+            };
+
+            // Call
+            surfaceLine.SetGeometry(sourceData);
+
+            // Assert
+            Assert.AreNotSame(sourceData, surfaceLine.Points);
+            CollectionAssert.AreEqual(sourceData, surfaceLine.Points);
+            TestHelper.AssertAreEqualButNotSame(sourceData[0], surfaceLine.StartingWorldPoint);
+            TestHelper.AssertAreEqualButNotSame(sourceData[0], surfaceLine.EndingWorldPoint);
+        }
+
+        [Test]
+        public void SetGeometry_CollectionOfMultiplePoints_InitializeStartAndEndWorldPointsInitializePoints()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+
+            var sourceData = new[]
+            {
+                new Point3D(1.1, 2.2, 3.3),
+                new Point3D(4.4, 5.5, 6.6),
+                new Point3D(7.7, 8.8, 9.9),
+                new Point3D(10.10, 11.11, 12.12)
+            };
+
+            // Call
+            surfaceLine.SetGeometry(sourceData);
+
+            // Assert
+            Assert.AreNotSame(sourceData, surfaceLine.Points);
+            CollectionAssert.AreEqual(sourceData, surfaceLine.Points);
+            Assert.AreEqual(sourceData[0], surfaceLine.StartingWorldPoint);
+            Assert.AreEqual(sourceData[3], surfaceLine.EndingWorldPoint);
+        }
+
+        [Test]
+        public void SetGeometry_GeometryIsNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+
+            // Call
+            TestDelegate test = () => surfaceLine.SetGeometry(null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(test);
+            StringAssert.StartsWith("De geometrie die opgegeven werd voor de profielschematisatie heeft geen waarde.", exception.Message);
+        }
+
+        [Test]
+        public void SetGeometry_GeometryContainsNullPoint_ThrowsArgumentException()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+
+            // Call
+            TestDelegate test = () => surfaceLine.SetGeometry(new Point3D[]
+            {
+                null
+            });
+
+            // Assert
+            var exception = Assert.Throws<ArgumentException>(test);
+            StringAssert.StartsWith("Een punt in de geometrie voor de profielschematisatie heeft geen waarde.", exception.Message);
+        }
+
+        [Test]
+        public void GetZAtL_GeometryIsEmpty_ThrowInvalidOperationException()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+            var l = (RoundedDouble) new Random(21).NextDouble();
+
+            // Call
+            TestDelegate test = () => surfaceLine.GetZAtL(l);
+
+            // Assert
+            string exceptionMessage = Assert.Throws<InvalidOperationException>(test).Message;
+            Assert.AreEqual("De profielschematisatie heeft geen geometrie.", exceptionMessage);
+        }
+
+        [Test]
+        public void GetZAtL_SurfaceLineContainsPointAtL_ReturnsZOfPoint()
+        {
+            // Setup
+            double testZ = new Random(22).NextDouble();
+
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+            var l = (RoundedDouble) 2.0;
+            surfaceLine.SetGeometry(new[]
+            {
+                new Point3D(0.0, 0.0, 2.2),
+                new Point3D(l, 0.0, testZ),
+                new Point3D(3.0, 0.0, 7.7)
+            });
+
+            // Call
+            double result = surfaceLine.GetZAtL(l);
+
+            // Assert
+            Assert.AreEqual(testZ, result, 1e-2);
+        }
+
+        [Test]
+        [SetCulture("nl-NL")]
+        [TestCase(-1)]
+        [TestCase(-5e-3)]
+        [TestCase(3.1 + 5e-3)]
+        [TestCase(4.0)]
+        public void GetZAtL_SurfaceLineDoesNotContainsPointAtL_ThrowsArgumentOutOfRange(double l)
+        {
+            // Setup
+            double testZ = new Random(22).NextDouble();
+
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+            surfaceLine.SetGeometry(new[]
+            {
+                new Point3D(1.0, 0.0, 2.2),
+                new Point3D(2.0, 0.0, testZ),
+                new Point3D(4.1, 0.0, 7.7)
+            });
+
+            // Call
+            TestDelegate test = () => surfaceLine.GetZAtL((RoundedDouble) l);
+
+            // Assert
+            const string expectedMessage = "Kan geen hoogte bepalen. De lokale coördinaat moet in het bereik [0,0, 3,1] liggen.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentOutOfRangeException>(test, expectedMessage);
+        }
+
+        [Test]
+        public void GetZAtL_SurfaceLineVerticalAtL_ThrowsRingtoetsPipingSurfaceLineException()
+        {
+            // Setup
+            double testZ = new Random(22).NextDouble();
+
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+            var l = (RoundedDouble) 2.0;
+            surfaceLine.SetGeometry(new[]
+            {
+                new Point3D(0.0, 0.0, 2.2),
+                new Point3D(l, 0.0, testZ),
+                new Point3D(l, 0.0, testZ + 1),
+                new Point3D(3.0, 0.0, 7.7)
+            });
+
+            // Call
+            TestDelegate test = () => surfaceLine.GetZAtL(l);
+
+            // Assert
+            var exception = Assert.Throws<RingtoetsPipingSurfaceLineException>(test);
+            string message = $"Kan geen hoogte bepalen op het punt met de lokale coördinaat {l}, omdat de profielschematisatie verticaal loopt op dat punt.";
+            Assert.AreEqual(message, exception.Message);
+        }
+
+        [Test]
+        public void ToString_ReturnName()
+        {
+            // Setup
+            const string niceName = "Nice name";
+            var surfaceLine = new RingtoetsPipingSurfaceLine
+            {
+                Name = niceName
+            };
+
+            // Call
+            string text = surfaceLine.ToString();
+
+            // Assert
+            Assert.AreEqual(niceName, text);
+        }
+
+        [Test]
+        [TestCase(5.0)]
+        [TestCase(1.375)]
+        [TestCase(-0.005)]
+        [TestCase(-5)]
+        public void ValidateInRange_PointNotInRange_ReturnsFalse(double invalidValue)
+        {
+            // Setup
+            const double testX = 1.0;
+            const double testY = 2.2;
+            const double testZ = 4.4;
+            var testPoint = new Point3D(testX, testY, testZ);
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+            CreateTestGeometry(testPoint, surfaceLine);
+
+            // Call
+            bool valid = surfaceLine.ValidateInRange(invalidValue);
+
+            // Assert
+            Assert.IsFalse(valid);
+        }
+
+        [Test]
+        [TestCase(-0e-3)]
+        [TestCase(1.37)]
+        [TestCase(1.0)]
+        public void ValidateInRange_PointInRange_ReturnsTrue(double validValue)
+        {
+            // Setup
+            const double testX = 1.0;
+            const double testY = 2.2;
+            const double testZ = 4.4;
+            var testPoint = new Point3D(testX, testY, testZ);
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+            CreateTestGeometry(testPoint, surfaceLine);
+
+            // Call
+            bool valid = surfaceLine.ValidateInRange(validValue);
+
+            // Assert
+            Assert.IsTrue(valid);
+        }
+
+        [Test]
+        public void GetLocalPointFromGeometry_ValidSurfaceLine_ReturnsLocalPoint()
+        {
+            // Setup
+            const double testX = 1.0;
+            const double testY = 2.2;
+            const double testZ = 4.4;
+            var testPoint = new Point3D(testX, testY, testZ);
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+            CreateTestGeometry(testPoint, surfaceLine);
+
+            // Call
+            Point2D localPoint = surfaceLine.GetLocalPointFromGeometry(testPoint);
+
+            // Assert
+            Assert.AreEqual(new Point2D(0.04, 4.4), localPoint);
+        }
+
+        [Test]
+        public void GetLocalPointFromGeometry_NoPointsOnSurfaceLine_ReturnsPointWithNanValues()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+
+            // Call
+            Point2D localPoint = surfaceLine.GetLocalPointFromGeometry(new Point3D(1.0, 2.2, 4.4));
+
+            // Assert
+            Assert.AreEqual(new Point2D(double.NaN, double.NaN), localPoint);
+        }
+
+        [Test]
+        public void GetLocalPointFromGeometry_OnePointOnSurfaceLine_ReturnsPointWithNanValues()
+        {
+            // Setup
+            const double testX = 1.0;
+            const double testY = 2.2;
+            const double testZ = 4.4;
+            var testPoint = new Point3D(testX, testY, testZ);
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+            surfaceLine.SetGeometry(new[]
+            {
+                testPoint
+            });
+
+            // Call
+            Point2D localPoint = surfaceLine.GetLocalPointFromGeometry(testPoint);
+
+            // Assert
+            Assert.AreEqual(new Point2D(double.NaN, double.NaN), localPoint);
+        }
+
+        [Test]
+        public void CopyProperties_WithSurfaceLineNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+
+            // Call
+            TestDelegate call = () => surfaceLine.CopyProperties(null);
+
+            // Assert
+            string paramName = Assert.Throws<ArgumentNullException>(call).ParamName;
+            Assert.AreEqual("fromSurfaceLine", paramName);
+        }
+
+        [Test]
+        public void CopyProperties_LineWithUpdatedGeometricPoints_PropertiesUpdated()
+        {
+            // Setup
+            RingtoetsPipingSurfaceLine surfaceLine = CreateSurfaceLineWithCharacteristicPoints();
+
+            RingtoetsPipingSurfaceLine surfaceLineToUpdateFrom = CreateSurfaceLineWithCharacteristicPoints();
+            var expectedGeometry = new List<Point3D>
+            {
+                new Point3D(0, 1, 2),
+                new Point3D(3, 4, 5),
+                new Point3D(6, 7, 8)
+            };
+            expectedGeometry.AddRange(surfaceLine.Points);
+            surfaceLineToUpdateFrom.SetGeometry(expectedGeometry);
+
+            // Call
+            surfaceLine.CopyProperties(surfaceLineToUpdateFrom);
+
+            // Assert
+            AssertPropertiesUpdated(surfaceLineToUpdateFrom, surfaceLine);
+        }
+
+        [Test]
+        public void CopyProperties_LineUpdatedWithRemovedCharacteristicPoints_PropertiesUpdated()
+        {
+            // Setup
+            RingtoetsPipingSurfaceLine surfaceLine = CreateSurfaceLineWithCharacteristicPoints();
+            var surfaceLineToUpdateFrom = new RingtoetsPipingSurfaceLine
+            {
+                Name = surfaceLine.Name,
+                ReferenceLineIntersectionWorldPoint = surfaceLine.ReferenceLineIntersectionWorldPoint
+            };
+            surfaceLineToUpdateFrom.SetGeometry(surfaceLine.Points);
+
+            // Call
+            surfaceLine.CopyProperties(surfaceLineToUpdateFrom);
+
+            // Assert
+            AssertPropertiesUpdated(surfaceLineToUpdateFrom, surfaceLine);
+        }
+
+        [Test]
+        public void CopyProperties_LineWithUpdatedReferenceLineWorldPoint_PropertiesUpdated()
+        {
+            // Setup
+            RingtoetsPipingSurfaceLine surfaceLine = CreateSurfaceLineWithCharacteristicPoints();
+
+            var expectedIntersectionPoint = new Point2D(123, 456);
+            RingtoetsPipingSurfaceLine surfaceLineToUpdateFrom = CreateSurfaceLineWithCharacteristicPoints();
+            surfaceLineToUpdateFrom.ReferenceLineIntersectionWorldPoint = expectedIntersectionPoint;
+
+            // Call
+            surfaceLine.CopyProperties(surfaceLineToUpdateFrom);
+
+            // Assert
+            AssertPropertiesUpdated(surfaceLineToUpdateFrom, surfaceLine);
+        }
+
+        [Test]
+        public void CopyProperties_LineWithUpdatedGeometryAndReferenceLineIntersectionAndCharacteristicPoints_PropertiesUpdated()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+            RingtoetsPipingSurfaceLine surfaceLineToUpdateFrom = CreateSurfaceLineWithCharacteristicPoints();
+
+            // Call
+            surfaceLine.CopyProperties(surfaceLineToUpdateFrom);
+
+            // Assert
+            AssertPropertiesUpdated(surfaceLineToUpdateFrom, surfaceLine);
+        }
+
+        [Test]
+        public void Equals_ToItself_ReturnsTrue()
+        {
+            // Setup
+            var surfaceLineOne = new RingtoetsPipingSurfaceLine();
+
+            // Call
+            bool isLineOneEqualToLineOne = surfaceLineOne.Equals(surfaceLineOne);
+
+            // Assert
+            Assert.IsTrue(isLineOneEqualToLineOne);
+        }
+
+        [Test]
+        public void Equal_SameReference_ReturnsTrue()
+        {
+            // Setup
+            var surfaceLineOne = new RingtoetsPipingSurfaceLine();
+            RingtoetsPipingSurfaceLine surfaceLineTwo = surfaceLineOne;
+
+            // Call
+            bool isLineOneEqualToLineTwo = surfaceLineOne.Equals(surfaceLineTwo);
+            bool isLineTwoEqualToLineOne = surfaceLineTwo.Equals(surfaceLineOne);
+
+            // Assert
+            Assert.IsTrue(isLineOneEqualToLineTwo);
+            Assert.IsTrue(isLineTwoEqualToLineOne);
+        }
+
+        [Test]
+        public void Equals_ToNull_ReturnsFalse()
+        {
+            // Setup
+            var surfaceLineOne = new RingtoetsPipingSurfaceLine
+            {
+                Name = "Name A"
+            };
+
+            // Call
+            bool isLineOneEqualToNull = surfaceLineOne.Equals(null);
+
+            // Assert
+            Assert.IsFalse(isLineOneEqualToNull);
+        }
+
+        [Test]
+        public void Equals_ToDifferentType_ReturnsFalse()
+        {
+            // Setup
+            var surfaceLineOne = new RingtoetsPipingSurfaceLine
+            {
+                Name = "Name A"
+            };
+
+            var differentType = new object();
+
+            // Call
+            bool isSurfaceLineEqualToDifferentType = surfaceLineOne.Equals(differentType);
+            bool isDifferentTypeEqualToSurfaceLine = differentType.Equals(surfaceLineOne);
+
+            // Assert
+            Assert.IsFalse(isSurfaceLineEqualToDifferentType);
+            Assert.IsFalse(isDifferentTypeEqualToSurfaceLine);
+        }
+
+        [Test]
+        public void Equals_DifferentNames_ReturnsFalse()
+        {
+            // Setup
+            RingtoetsPipingSurfaceLine surfaceLineOne = CreateSurfaceLineWithCharacteristicPoints();
+            surfaceLineOne.Name = "Name A";
+
+            RingtoetsPipingSurfaceLine surfaceLineTwo = CreateSurfaceLineWithCharacteristicPoints();
+            surfaceLineTwo.Name = "Name B";
+
+            // Call
+            bool isLineOneEqualToLineTwo = surfaceLineOne.Equals(surfaceLineTwo);
+            bool isLineTwoEqualToLineOne = surfaceLineTwo.Equals(surfaceLineOne);
+
+            // Assert
+            Assert.IsFalse(isLineOneEqualToLineTwo);
+            Assert.IsFalse(isLineTwoEqualToLineOne);
+        }
+
+        [Test]
+        public void Equals_DifferentGeometries_ReturnsFalse()
+        {
+            // Setup
+            var surfaceLineOne = new RingtoetsPipingSurfaceLine
+            {
+                Name = "Name A"
+            };
+            surfaceLineOne.SetGeometry(new[]
+            {
+                new Point3D(1, 2, 3)
+            });
+
+            var surfaceLineTwo = new RingtoetsPipingSurfaceLine
+            {
+                Name = "Name A"
+            };
+            surfaceLineTwo.SetGeometry(new[]
+            {
+                new Point3D(3, 4, 5)
+            });
+
+            // Call
+            bool isLineOneEqualToLineTwo = surfaceLineOne.Equals(surfaceLineTwo);
+            bool isLineTwoEqualToLineOne = surfaceLineTwo.Equals(surfaceLineOne);
+
+            // Assert
+            Assert.IsFalse(isLineOneEqualToLineTwo);
+            Assert.IsFalse(isLineTwoEqualToLineOne);
+        }
+
+        [Test]
+        public void Equals_DifferentReferenceLineIntersectionWorldPoint_ReturnsFalse()
+        {
+            // Setup
+            RingtoetsPipingSurfaceLine surfaceLineOne = CreateSurfaceLineWithCharacteristicPoints();
+            surfaceLineOne.ReferenceLineIntersectionWorldPoint = new Point2D(0, 0);
+
+            RingtoetsPipingSurfaceLine surfaceLineTwo = CreateSurfaceLineWithCharacteristicPoints();
+            surfaceLineTwo.ReferenceLineIntersectionWorldPoint = new Point2D(1, 1);
+
+            // Call
+            bool isLineOneEqualToLineTwo = surfaceLineOne.Equals(surfaceLineTwo);
+            bool isLineTwoEqualToLineOne = surfaceLineTwo.Equals(surfaceLineOne);
+
+            // Assert
+            Assert.IsFalse(isLineOneEqualToLineTwo);
+            Assert.IsFalse(isLineTwoEqualToLineOne);
+        }
+
+        [Test]
+        public void Equals_DifferentBottomDitchDikeSide_ReturnsFalse()
+        {
+            // Setup
+            RingtoetsPipingSurfaceLine surfaceLineOne = CreateSurfaceLineWithCharacteristicPoints();
+            RingtoetsPipingSurfaceLine surfaceLineTwo = CreateSurfaceLineWithCharacteristicPoints();
+            Point3D[] points = surfaceLineTwo.Points.ToArray();
+            surfaceLineTwo.SetBottomDitchDikeSideAt(points[5]);
+
+            // Call
+            bool isLineOneEqualToLineTwo = surfaceLineOne.Equals(surfaceLineTwo);
+            bool isLineTwoEqualToLineOne = surfaceLineTwo.Equals(surfaceLineOne);
+
+            // Assert
+            Assert.IsFalse(isLineOneEqualToLineTwo);
+            Assert.IsFalse(isLineTwoEqualToLineOne);
+        }
+
+        [Test]
+        public void Equals_DifferentBottomDitchPolderSide_ReturnsFalse()
+        {
+            // Setup
+            RingtoetsPipingSurfaceLine surfaceLineOne = CreateSurfaceLineWithCharacteristicPoints();
+            RingtoetsPipingSurfaceLine surfaceLineTwo = CreateSurfaceLineWithCharacteristicPoints();
+            Point3D[] points = surfaceLineTwo.Points.ToArray();
+            surfaceLineTwo.SetBottomDitchPolderSideAt(points[5]);
+
+            // Call
+            bool isLineOneEqualToLineTwo = surfaceLineOne.Equals(surfaceLineTwo);
+            bool isLineTwoEqualToLineOne = surfaceLineTwo.Equals(surfaceLineOne);
+
+            // Assert
+            Assert.IsFalse(isLineOneEqualToLineTwo);
+            Assert.IsFalse(isLineTwoEqualToLineOne);
+        }
+
+        [Test]
+        public void Equals_DifferentDikeToeAtPolder_ReturnsFalse()
+        {
+            // Setup
+            RingtoetsPipingSurfaceLine surfaceLineOne = CreateSurfaceLineWithCharacteristicPoints();
+            RingtoetsPipingSurfaceLine surfaceLineTwo = CreateSurfaceLineWithCharacteristicPoints();
+            Point3D[] points = surfaceLineTwo.Points.ToArray();
+            surfaceLineTwo.SetDikeToeAtPolderAt(points[5]);
+
+            // Call
+            bool isLineOneEqualToLineTwo = surfaceLineOne.Equals(surfaceLineTwo);
+            bool isLineTwoEqualToLineOne = surfaceLineTwo.Equals(surfaceLineOne);
+
+            // Assert
+            Assert.IsFalse(isLineOneEqualToLineTwo);
+            Assert.IsFalse(isLineTwoEqualToLineOne);
+        }
+
+        [Test]
+        public void Equals_DifferentDikeToeAtRiver_ReturnsFalse()
+        {
+            // Setup
+            RingtoetsPipingSurfaceLine surfaceLineOne = CreateSurfaceLineWithCharacteristicPoints();
+            RingtoetsPipingSurfaceLine surfaceLineTwo = CreateSurfaceLineWithCharacteristicPoints();
+            Point3D[] points = surfaceLineTwo.Points.ToArray();
+            surfaceLineTwo.SetDikeToeAtRiverAt(points[5]);
+
+            // Call
+            bool isLineOneEqualToLineTwo = surfaceLineOne.Equals(surfaceLineTwo);
+            bool isLineTwoEqualToLineOne = surfaceLineTwo.Equals(surfaceLineOne);
+
+            // Assert
+            Assert.IsFalse(isLineOneEqualToLineTwo);
+            Assert.IsFalse(isLineTwoEqualToLineOne);
+        }
+
+        [Test]
+        public void Equals_DifferentDitchDikeSide_ReturnsFalse()
+        {
+            // Setup
+            RingtoetsPipingSurfaceLine surfaceLineOne = CreateSurfaceLineWithCharacteristicPoints();
+            RingtoetsPipingSurfaceLine surfaceLineTwo = CreateSurfaceLineWithCharacteristicPoints();
+            Point3D[] points = surfaceLineTwo.Points.ToArray();
+            surfaceLineTwo.SetDitchDikeSideAt(points[1]);
+
+            // Call
+            bool isLineOneEqualToLineTwo = surfaceLineOne.Equals(surfaceLineTwo);
+            bool isLineTwoEqualToLineOne = surfaceLineTwo.Equals(surfaceLineOne);
+
+            // Assert
+            Assert.IsFalse(isLineOneEqualToLineTwo);
+            Assert.IsFalse(isLineTwoEqualToLineOne);
+        }
+
+        [Test]
+        public void Equals_DifferentDitchPolderSide_ReturnsFalse()
+        {
+            // Setup
+            RingtoetsPipingSurfaceLine surfaceLineOne = CreateSurfaceLineWithCharacteristicPoints();
+            RingtoetsPipingSurfaceLine surfaceLineTwo = CreateSurfaceLineWithCharacteristicPoints();
+            Point3D[] points = surfaceLineTwo.Points.ToArray();
+            surfaceLineTwo.SetDitchPolderSideAt(points[1]);
+
+            // Call
+            bool isLineOneEqualToLineTwo = surfaceLineOne.Equals(surfaceLineTwo);
+            bool isLineTwoEqualToLineOne = surfaceLineTwo.Equals(surfaceLineOne);
+
+            // Assert
+            Assert.IsFalse(isLineOneEqualToLineTwo);
+            Assert.IsFalse(isLineTwoEqualToLineOne);
+        }
+
+        [Test]
+        public void Equals_NamesGeometriesAndReferenceLineIntersectionWorldPointAndCharacteristicPointsEqual_ReturnsTrue()
+        {
+            // Setup
+            RingtoetsPipingSurfaceLine surfaceLineOne = CreateSurfaceLineWithCharacteristicPoints();
+            RingtoetsPipingSurfaceLine surfaceLineTwo = CreateSurfaceLineWithCharacteristicPoints();
+
+            // Call
+            bool isLineOneEqualToLineTwo = surfaceLineOne.Equals(surfaceLineTwo);
+            bool isLineTwoEqualToLineOne = surfaceLineTwo.Equals(surfaceLineOne);
+
+            // Assert
+            Assert.IsTrue(isLineOneEqualToLineTwo);
+            Assert.IsTrue(isLineTwoEqualToLineOne);
+        }
+
+        [Test]
+        public void Equals_TransitivePropertyWithSameNamesAndGeometry_ReturnsTrue()
+        {
+            // Setup
+            RingtoetsPipingSurfaceLine surfaceLineOne = CreateSurfaceLineWithCharacteristicPoints();
+            RingtoetsPipingSurfaceLine surfaceLineTwo = CreateSurfaceLineWithCharacteristicPoints();
+            RingtoetsPipingSurfaceLine surfaceLineThree = CreateSurfaceLineWithCharacteristicPoints();
+
+            // Call
+            bool isLineOneEqualToLineTwo = surfaceLineOne.Equals(surfaceLineTwo);
+            bool isLineTwoEqualToLineThree = surfaceLineTwo.Equals(surfaceLineThree);
+            bool isLineOneEqualToLineThree = surfaceLineOne.Equals(surfaceLineThree);
+
+            // Assert
+            Assert.IsTrue(isLineOneEqualToLineTwo);
+            Assert.IsTrue(isLineTwoEqualToLineThree);
+            Assert.IsTrue(isLineOneEqualToLineThree);
+        }
+
+        [Test]
+        public void GetHashCode_EqualSurfaceLines_ReturnSameHashCode()
+        {
+            // Setup
+            var surfaceLineOne = new RingtoetsPipingSurfaceLine();
+            var surfaceLineTwo = new RingtoetsPipingSurfaceLine();
+
+            // Call
+            int hashCodeOne = surfaceLineOne.GetHashCode();
+            int hashCodeTwo = surfaceLineTwo.GetHashCode();
+
+            // Assert
+            Assert.AreEqual(hashCodeOne, hashCodeTwo);
+        }
+
+        public abstract class SetCharacteristicPointTest
+        {
+            [Test]
+            public void PointInGeometry_PointSetFromGeometry()
+            {
+                // Setup
+                const double testX = 1.0;
+                const double testY = 2.2;
+                const double testZ = 4.4;
+                var testPoint = new Point3D(testX, testY, testZ);
+                var surfaceLine = new RingtoetsPipingSurfaceLine();
+                CreateTestGeometry(testPoint, surfaceLine);
+
+                // Call
+                SetCharacteristicPoint(surfaceLine, testPoint);
+
+                // Assert
+                Assert.AreEqual(testPoint, GetCharacteristicPoint(surfaceLine));
+                Assert.AreNotSame(testPoint, GetCharacteristicPoint(surfaceLine));
+            }
+
+            [Test]
+            public void GeometryEmpty_ThrowsInvalidOperationException()
+            {
+                // Setup
+                var random = new Random(21);
+                var testPoint = new Point3D(random.NextDouble(), random.NextDouble(), random.NextDouble());
+                var surfaceLine = new RingtoetsPipingSurfaceLine();
+
+                // Call
+                TestDelegate test = () => SetCharacteristicPoint(surfaceLine, testPoint);
+
+                // Assert
+                string expectedMessage = $"De geometrie bevat geen punt op locatie {testPoint} om als '{CharacteristicPointDescription()}' in te stellen.";
+                TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentException>(test, expectedMessage);
+            }
+
+            [Test]
+            public void Null_ThrowsArgumentNullException()
+            {
+                // Setup
+                var surfaceLine = new RingtoetsPipingSurfaceLine();
+
+                // Call
+                TestDelegate test = () => SetCharacteristicPoint(surfaceLine, null);
+
+                // Assert
+                const string expectedMessage = "Cannot find a point in geometry using a null point.";
+                TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentNullException>(test, expectedMessage);
+            }
+
+            protected abstract void SetCharacteristicPoint(RingtoetsPipingSurfaceLine surfaceLine, Point3D point);
+            protected abstract Point3D GetCharacteristicPoint(RingtoetsPipingSurfaceLine surfaceLine);
+            protected abstract string CharacteristicPointDescription();
+        }
+
+        [TestFixture]
+        public class SetDitchPolderSideAtTest : SetCharacteristicPointTest
+        {
+            protected override void SetCharacteristicPoint(RingtoetsPipingSurfaceLine surfaceLine, Point3D point)
+            {
+                surfaceLine.SetDitchPolderSideAt(point);
+            }
+
+            protected override Point3D GetCharacteristicPoint(RingtoetsPipingSurfaceLine surfaceLine)
+            {
+                return surfaceLine.DitchPolderSide;
+            }
+
+            protected override string CharacteristicPointDescription()
+            {
+                return "Insteek sloot polderzijde";
+            }
+        }
+
+        [TestFixture]
+        public class SetBottomDitchPolderSideAtTest : SetCharacteristicPointTest
+        {
+            protected override void SetCharacteristicPoint(RingtoetsPipingSurfaceLine surfaceLine, Point3D point)
+            {
+                surfaceLine.SetBottomDitchPolderSideAt(point);
+            }
+
+            protected override Point3D GetCharacteristicPoint(RingtoetsPipingSurfaceLine surfaceLine)
+            {
+                return surfaceLine.BottomDitchPolderSide;
+            }
+
+            protected override string CharacteristicPointDescription()
+            {
+                return "Slootbodem polderzijde";
+            }
+        }
+
+        [TestFixture]
+        public class SetBottomDitchDikeSideAtTest : SetCharacteristicPointTest
+        {
+            protected override void SetCharacteristicPoint(RingtoetsPipingSurfaceLine surfaceLine, Point3D point)
+            {
+                surfaceLine.SetBottomDitchDikeSideAt(point);
+            }
+
+            protected override Point3D GetCharacteristicPoint(RingtoetsPipingSurfaceLine surfaceLine)
+            {
+                return surfaceLine.BottomDitchDikeSide;
+            }
+
+            protected override string CharacteristicPointDescription()
+            {
+                return "Slootbodem dijkzijde";
+            }
+        }
+
+        [TestFixture]
+        public class SetDitchDikeSideAtTest : SetCharacteristicPointTest
+        {
+            protected override void SetCharacteristicPoint(RingtoetsPipingSurfaceLine surfaceLine, Point3D point)
+            {
+                surfaceLine.SetDitchDikeSideAt(point);
+            }
+
+            protected override Point3D GetCharacteristicPoint(RingtoetsPipingSurfaceLine surfaceLine)
+            {
+                return surfaceLine.DitchDikeSide;
+            }
+
+            protected override string CharacteristicPointDescription()
+            {
+                return "Insteek sloot dijkzijde";
+            }
+        }
+
+        [TestFixture]
+        public class SetDikeToeAtRiverAtTest : SetCharacteristicPointTest
+        {
+            protected override void SetCharacteristicPoint(RingtoetsPipingSurfaceLine surfaceLine, Point3D point)
+            {
+                surfaceLine.SetDikeToeAtRiverAt(point);
+            }
+
+            protected override Point3D GetCharacteristicPoint(RingtoetsPipingSurfaceLine surfaceLine)
+            {
+                return surfaceLine.DikeToeAtRiver;
+            }
+
+            protected override string CharacteristicPointDescription()
+            {
+                return "Teen dijk buitenwaarts";
+            }
+        }
+
+        [TestFixture]
+        public class SetDikeToeAtPolderAtTest : SetCharacteristicPointTest
+        {
+            protected override void SetCharacteristicPoint(RingtoetsPipingSurfaceLine surfaceLine, Point3D point)
+            {
+                surfaceLine.SetDikeToeAtPolderAt(point);
+            }
+
+            protected override Point3D GetCharacteristicPoint(RingtoetsPipingSurfaceLine surfaceLine)
+            {
+                return surfaceLine.DikeToeAtPolder;
+            }
+
+            protected override string CharacteristicPointDescription()
+            {
+                return "Teen dijk binnenwaarts";
+            }
+        }
+
+        private static RingtoetsPipingSurfaceLine CreateSurfaceLineWithCharacteristicPoints()
+        {
+            var surfaceLine = new RingtoetsPipingSurfaceLine
+            {
+                Name = "Name A",
+                ReferenceLineIntersectionWorldPoint = new Point2D(0, 0)
+            };
+            var geometry = new[]
+            {
+                new Point3D(0, 0, 0),
+                new Point3D(1, 0, 2),
+                new Point3D(2, 0, 3),
+                new Point3D(3, 0, 0),
+                new Point3D(4, 0, 2),
+                new Point3D(5, 0, 3)
+            };
+            surfaceLine.SetGeometry(geometry);
+            surfaceLine.SetBottomDitchDikeSideAt(geometry[0]);
+            surfaceLine.SetBottomDitchPolderSideAt(geometry[1]);
+            surfaceLine.SetDikeToeAtPolderAt(geometry[2]);
+            surfaceLine.SetDikeToeAtRiverAt(geometry[3]);
+            surfaceLine.SetDitchDikeSideAt(geometry[4]);
+            surfaceLine.SetDitchPolderSideAt(geometry[5]);
+
+            return surfaceLine;
+        }
+
+        private static void CreateTestGeometry(Point3D testPoint, RingtoetsPipingSurfaceLine surfaceLine)
+        {
+            var random = new Random(21);
+            var points = new[]
+            {
+                new Point3D(random.NextDouble(), random.NextDouble(), random.NextDouble()),
+                new Point3D(testPoint),
+                new Point3D(2 + random.NextDouble(), random.NextDouble(), random.NextDouble())
+            };
+            surfaceLine.SetGeometry(points);
+        }
+
+        private static void AssertPropertiesUpdated(RingtoetsPipingSurfaceLine expectedSurfaceLine, RingtoetsPipingSurfaceLine actualSurfaceLine)
+        {
+            Assert.AreEqual(expectedSurfaceLine.Name, actualSurfaceLine.Name);
+            TestHelper.AssertAreEqualButNotSame(expectedSurfaceLine.ReferenceLineIntersectionWorldPoint,
+                                                actualSurfaceLine.ReferenceLineIntersectionWorldPoint);
+            CollectionAssert.AreEqual(expectedSurfaceLine.Points, actualSurfaceLine.Points);
+            TestHelper.AssertCollectionAreNotSame(expectedSurfaceLine.Points, actualSurfaceLine.Points);
+            TestHelper.AssertAreEqualButNotSame(expectedSurfaceLine.BottomDitchDikeSide, actualSurfaceLine.BottomDitchDikeSide);
+            TestHelper.AssertAreEqualButNotSame(expectedSurfaceLine.BottomDitchPolderSide, actualSurfaceLine.BottomDitchPolderSide);
+            TestHelper.AssertAreEqualButNotSame(expectedSurfaceLine.DikeToeAtPolder, actualSurfaceLine.DikeToeAtPolder);
+            TestHelper.AssertAreEqualButNotSame(expectedSurfaceLine.DikeToeAtRiver, actualSurfaceLine.DikeToeAtRiver);
+            TestHelper.AssertAreEqualButNotSame(expectedSurfaceLine.DitchPolderSide, actualSurfaceLine.DitchPolderSide);
+            TestHelper.AssertAreEqualButNotSame(expectedSurfaceLine.DitchDikeSide, actualSurfaceLine.DitchDikeSide);
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Piping/test/Ringtoets.Piping.Primitives.Test/packages.config
===================================================================
diff -u
--- Ringtoets/Piping/test/Ringtoets.Piping.Primitives.Test/packages.config	(revision 0)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Primitives.Test/packages.config	(revision 9caa7daa14d0070e2a3f68c4b9e66109318bd9ab)
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+Copyright (C) Stichting Deltares 2017. All rights reserved.
+
+This file is part of Ringtoets.
+
+Ringtoets is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+All names, logos, and references to "Deltares" are registered trademarks of
+Stichting Deltares and remain full property of Stichting Deltares at all times.
+All rights reserved.
+-->
+<packages>
+  <package id="NUnit" version="3.6.0" targetFramework="net40" />
+</packages>
\ No newline at end of file