Index: Ringtoets/Piping/src/Ringtoets.Piping.Calculation/PipingCalculator.cs
===================================================================
diff -u -r4512af7782ee31b36941bb280b54d9da2953dd71 -r847f6b97f0a6e007a89364ad12d0541bc0d84d1e
--- Ringtoets/Piping/src/Ringtoets.Piping.Calculation/PipingCalculator.cs	(.../PipingCalculator.cs)	(revision 4512af7782ee31b36941bb280b54d9da2953dd71)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Calculation/PipingCalculator.cs	(.../PipingCalculator.cs)	(revision 847f6b97f0a6e007a89364ad12d0541bc0d84d1e)
@@ -22,9 +22,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-
 using Deltares.WTIPiping;
-
 using Ringtoets.Piping.Calculation.Properties;
 
 namespace Ringtoets.Piping.Calculation
@@ -67,7 +65,7 @@
                 heaveResult.FoSh,
                 sellmeijerResult.Zp,
                 sellmeijerResult.FoSp
-            );
+                );
         }
 
         /// <summary>
@@ -94,6 +92,33 @@
                 .ToList();
         }
 
+        /// <summary>
+        /// Calculates the thickness of the coverage layer based on the values of the <see cref="PipingCalculatorInput"/>.
+        /// </summary>
+        /// <returns>The thickness of the coverage layer.</returns>
+        /// <exception cref="PipingCalculatorException">Thrown when:
+        /// <list type="bullet">
+        /// <item>surface at exit point's x-coordinate is higher than the soil profile</item>
+        /// <item>surface line is <c>null</c></item>
+        /// <item>soil profile is <c>null</c></item>
+        /// <item>soil profile's aquifer layer</item>
+        /// </list></exception>
+        public double CalculateThicknessCoverageLayer()
+        {
+            try
+            {
+                return CalculateEffectiveThickness().EffectiveHeight;
+            }
+            catch (SoilVolumicMassCalculatorException e)
+            {
+                throw new PipingCalculatorException(e.Message, e);
+            }
+            catch (NullReferenceException e)
+            {
+                throw new PipingCalculatorException(e.Message, e);
+            }
+        }
+
         private List<string> ValidateSurfaceLine()
         {
             var validationResults = new List<string>();
@@ -192,7 +217,7 @@
         {
             EffectiveThicknessCalculator calculatedEffectiveStressResult = CalculateEffectiveThickness();
             WTIUpliftCalculator upliftCalculator = CreateUpliftCalculator(calculatedEffectiveStressResult.EffectiveStress);
-            
+
             try
             {
                 upliftCalculator.Calculate();
Index: Ringtoets/Piping/src/Ringtoets.Piping.Forms/Extensions/PipingInputExtensions.cs
===================================================================
diff -u -r98a291d574281a04a9e0a243d8a4429a1ffb9379 -r847f6b97f0a6e007a89364ad12d0541bc0d84d1e
--- Ringtoets/Piping/src/Ringtoets.Piping.Forms/Extensions/PipingInputExtensions.cs	(.../PipingInputExtensions.cs)	(revision 98a291d574281a04a9e0a243d8a4429a1ffb9379)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Forms/Extensions/PipingInputExtensions.cs	(.../PipingInputExtensions.cs)	(revision 847f6b97f0a6e007a89364ad12d0541bc0d84d1e)
@@ -2,6 +2,7 @@
 using System.Linq;
 using Ringtoets.Piping.Data;
 using Ringtoets.Piping.Forms.Properties;
+using Ringtoets.Piping.Service;
 
 namespace Ringtoets.Piping.Forms.Extensions
 {
@@ -21,45 +22,17 @@
         public static void SetSurfaceLine(this PipingInput input, RingtoetsPipingSurfaceLine surfaceLine)
         {
             input.SurfaceLine = surfaceLine;
-            UpdateValuesBasedOnSurfaceLine(input);
+            input.UpdateValuesBasedOnSurfaceLine();
+            input.UpdateThicknessCoverageLayer();
         }
 
-        private static void UpdateValuesBasedOnSurfaceLine(PipingInput input)
+        public static void SetSoilProfile(this PipingInput input, PipingSoilProfile soilProfile)
         {
-            var entryPointIndex = Array.IndexOf(input.SurfaceLine.Points, input.SurfaceLine.DikeToeAtRiver);
-            var exitPointIndex = Array.IndexOf(input.SurfaceLine.Points, input.SurfaceLine.DikeToeAtPolder);
-
-            var localGeometry = input.SurfaceLine.ProjectGeometryToLZ().ToArray();
-
-            var tempEntryPointL = localGeometry[0].X;
-            var tempExitPointL = localGeometry[localGeometry.Length - 1].X;
-
-            var differentPoints = entryPointIndex < 0 || exitPointIndex < 0 || entryPointIndex < exitPointIndex;
-            if (differentPoints && exitPointIndex > 0)
-            {
-                tempExitPointL = localGeometry.ElementAt(exitPointIndex).X;
-            }
-            if (differentPoints && entryPointIndex > -1)
-            {
-                tempEntryPointL = localGeometry.ElementAt(entryPointIndex).X;
-            }
-
-            input.ExitPointL = tempExitPointL;
-            input.SetSeepageLengthMean(tempExitPointL - tempEntryPointL);
+            input.SoilProfile = soilProfile;
+            input.UpdateThicknessCoverageLayer();
         }
 
         /// <summary>
-        /// Sets the mean of the seepage length stochast.
-        /// </summary>
-        /// <param name="input">The <see cref="PipingInput"/> to update the seepage length for.</param>
-        /// <param name="mean">The mean to set.</param>
-        public static void SetSeepageLengthMean(this PipingInput input, double mean)
-        {
-            input.SeepageLength.Mean = mean;
-            input.SeepageLength.StandardDeviation = mean * PipingInput.SeepageLengthStandardDeviationFraction;
-        }
-
-        /// <summary>
         /// Sets the L-coordinate of the entry point.
         /// </summary>
         /// <param name="input">The <see cref="PipingInput"/> to update the entry point for.</param>
@@ -95,6 +68,52 @@
                 throw new ArgumentException(message);
             }
             input.ExitPointL = exitPointL;
+            input.UpdateThicknessCoverageLayer();
         }
+
+        private static void UpdateThicknessCoverageLayer(this PipingInput input)
+        {
+            if (input.SurfaceLine == null || input.SoilProfile == null)
+            {
+                return;
+            }
+
+            input.ThicknessCoverageLayer.Mean = PipingCalculationService.CalculateThicknessCoverageLayer(input);
+        }
+
+        private static void UpdateValuesBasedOnSurfaceLine(this PipingInput input)
+        {
+            var entryPointIndex = Array.IndexOf(input.SurfaceLine.Points, input.SurfaceLine.DikeToeAtRiver);
+            var exitPointIndex = Array.IndexOf(input.SurfaceLine.Points, input.SurfaceLine.DikeToeAtPolder);
+
+            var localGeometry = input.SurfaceLine.ProjectGeometryToLZ().ToArray();
+
+            var tempEntryPointL = localGeometry[0].X;
+            var tempExitPointL = localGeometry[localGeometry.Length - 1].X;
+
+            var differentPoints = entryPointIndex < 0 || exitPointIndex < 0 || entryPointIndex < exitPointIndex;
+            if (differentPoints && exitPointIndex > 0)
+            {
+                tempExitPointL = localGeometry.ElementAt(exitPointIndex).X;
+            }
+            if (differentPoints && entryPointIndex > -1)
+            {
+                tempEntryPointL = localGeometry.ElementAt(entryPointIndex).X;
+            }
+
+            input.ExitPointL = tempExitPointL;
+            input.SetSeepageLengthMean(tempExitPointL - tempEntryPointL);
+        }
+
+        /// <summary>
+        /// Sets the mean of the seepage length stochast.
+        /// </summary>
+        /// <param name="input">The <see cref="PipingInput"/> to update the seepage length for.</param>
+        /// <param name="mean">The mean to set.</param>
+        private static void SetSeepageLengthMean(this PipingInput input, double mean)
+        {
+            input.SeepageLength.Mean = mean;
+            input.SeepageLength.StandardDeviation = mean*PipingInput.SeepageLengthStandardDeviationFraction;
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/Piping/src/Ringtoets.Piping.Service/PipingCalculationService.cs
===================================================================
diff -u -r94417e55fa4f44b35c8b9876c6423a94631df967 -r847f6b97f0a6e007a89364ad12d0541bc0d84d1e
--- Ringtoets/Piping/src/Ringtoets.Piping.Service/PipingCalculationService.cs	(.../PipingCalculationService.cs)	(revision 94417e55fa4f44b35c8b9876c6423a94631df967)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Service/PipingCalculationService.cs	(.../PipingCalculationService.cs)	(revision 847f6b97f0a6e007a89364ad12d0541bc0d84d1e)
@@ -100,6 +100,22 @@
             }
         }
 
+        /// <summary>
+        /// Calculates the thickness of the coverage layer based on the values of the <see cref="PipingInput"/>.
+        /// </summary>
+        /// <returns>The thickness of the coverage layer, or -1 if the thickness could not be calculated.</returns>
+        /// <exception cref="PipingCalculatorException">Thrown when:
+        /// <list type="bullet">
+        /// <item>surface at exit point's x-coordinate is higher than the soil profile</item>
+        /// <item>surface line is <c>null</c></item>
+        /// <item>soil profile is <c>null</c></item>
+        /// <item>soil profile's aquifer layer</item>
+        /// </list></exception>
+        public static double CalculateThicknessCoverageLayer(PipingInput input)
+        {
+            return new PipingCalculator(CreateInputFromData(input)).CalculateThicknessCoverageLayer();
+        }
+
         private static PipingCalculatorInput CreateInputFromData(PipingInput inputParameters)
         {
             return new PipingCalculatorInput(
Index: Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/Extensions/PipingInputExtensionsTest.cs
===================================================================
diff -u -r98a291d574281a04a9e0a243d8a4429a1ffb9379 -r847f6b97f0a6e007a89364ad12d0541bc0d84d1e
--- Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/Extensions/PipingInputExtensionsTest.cs	(.../PipingInputExtensionsTest.cs)	(revision 98a291d574281a04a9e0a243d8a4429a1ffb9379)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/Extensions/PipingInputExtensionsTest.cs	(.../PipingInputExtensionsTest.cs)	(revision 847f6b97f0a6e007a89364ad12d0541bc0d84d1e)
@@ -158,19 +158,20 @@
         [TestCase(4, 2, 6)]
         [TestCase(4, 0.5, 4.5)]
         [TestCase(1e-6, 4, 4 + 1e-6)]
-        [TestCase(3, -1e-6, 3 - 1e-6)]
-        [TestCase(0.5, 1e-6, 0.5 + 1e-6)]
+        [TestCase(0.5, 0.1 + 1e-6, 0.6 + 1e-6)]
         public void SetExitPointL_ExitPointAndSeepageLengthSet_UpdatesSeepageLength(double seepageLength, double exitPoint, double newSeepageLength)
         {
             // Setup
-            var random = new Random(22);
-
             var surfaceLine = ValidSurfaceLine(0.0, 4.0);
-            var soilProfile = new PipingSoilProfile(String.Empty, random.NextDouble(), new[]
+            var soilProfile = new PipingSoilProfile(String.Empty, -2, new[]
             {
-                new PipingSoilLayer(random.NextDouble())
+                new PipingSoilLayer(0.0)
                 {
                     IsAquifer = true
+                },
+                new PipingSoilLayer(1.0)
+                {
+                    IsAquifer = false
                 }
             });
             var input = new PipingInput
@@ -213,7 +214,6 @@
                 ExitPointL = l
             };
 
-
             // Call
             TestDelegate test = () => input.SetEntryPointL(l);
 
@@ -256,6 +256,201 @@
             TestHelper.AssertThrowsArgumentExceptionAndTestMessage<ArgumentException>(test, message);
         }
 
+        [Test]
+        [TestCase(0)]
+        [TestCase(1)]
+        public void ThicknessCoverageLayer_WithMissingInput_NoChangeInThickness(int inputIndexMissing)
+        {
+            // Setup
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+            surfaceLine.SetGeometry(new[]
+            {
+                new Point3D(0,0,2.0), 
+                new Point3D(1.0,0,2.0), 
+            });
+            var soilProfile = new PipingSoilProfile(String.Empty, 0, new[]
+            {
+                new PipingSoilLayer(1.0)
+                {
+                    IsAquifer = true
+                },
+                new PipingSoilLayer(2.0)
+                {
+                    IsAquifer = false
+                }
+            });
+            var input = new PipingInput();
+            var previousResult = input.ThicknessCoverageLayer.Mean;
+
+            if (inputIndexMissing != 0)
+            {
+                input.SetSurfaceLine(surfaceLine);
+            }
+            if (inputIndexMissing != 1)
+            {
+                input.SetSoilProfile(soilProfile);
+            }
+
+            // Call
+            var result = input.ThicknessCoverageLayer.Mean;
+
+            // Assert
+            Assert.AreEqual(previousResult, result);
+        }
+
+        [Test]
+        public void ThicknessCoverageLayer_InputResultsInZeroThickness_ThrowsExceptionNoChangeInThickness()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+            surfaceLine.SetGeometry(new[]
+            {
+                new Point3D(0,0,2.0), 
+                new Point3D(1.0,0,2.0), 
+            });
+            var soilProfile = new PipingSoilProfile(String.Empty, 0, new[]
+            {
+                new PipingSoilLayer(2.0)
+                {
+                    IsAquifer = true
+                }
+            });
+
+            var input = new PipingInput();
+            var previousResult = input.ThicknessCoverageLayer.Mean;
+
+            input.SetSurfaceLine(surfaceLine);
+            input.SetExitPointL(0.5);
+
+            // Call
+            TestDelegate test = () => input.SetSoilProfile(soilProfile);
+
+            // Assert
+            Assert.Throws<ArgumentOutOfRangeException>(test);
+            Assert.AreEqual(previousResult, input.ThicknessCoverageLayer.Mean);
+        }
+
+        [Test]
+        public void SetSurfaceLine_WithSoilProfileAndExitPointL_ThicknessUpdated()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+            surfaceLine.SetGeometry(new[]
+            {
+                new Point3D(0,0,2.0), 
+                new Point3D(1.0,0,2.0), 
+            });
+            var soilProfile = new PipingSoilProfile(String.Empty, 0, new[]
+            {
+                new PipingSoilLayer(1.0)
+                {
+                    IsAquifer = true
+                },
+                new PipingSoilLayer(2.0)
+                {
+                    IsAquifer = false
+                }
+            });
+            var input = new PipingInput
+            {
+                SoilProfile = soilProfile,
+                ExitPointL = 0.5
+            };
+
+            var previousResult = input.ThicknessCoverageLayer.Mean;
+
+            input.SetSurfaceLine(surfaceLine);
+
+            // Call
+            var result = input.ThicknessCoverageLayer.Mean;
+
+            // Assert
+            Assert.AreSame(surfaceLine, input.SurfaceLine);
+            Assert.AreNotEqual(previousResult, result);
+            Assert.AreEqual(1.0, result);
+        }
+
+        [Test]
+        public void SetSoilProfile_WithSurfaceLineAndExitPointL_ThicknessUpdated()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+            surfaceLine.SetGeometry(new []
+            {
+                new Point3D(0,0,2.0), 
+                new Point3D(1.0,0,2.0), 
+            });
+            var soilProfile = new PipingSoilProfile(String.Empty, 0, new[]
+            {
+                new PipingSoilLayer(1.0)
+                {
+                    IsAquifer = true
+                },
+                new PipingSoilLayer(2.0)
+                {
+                    IsAquifer = false
+                }
+            });
+            var input = new PipingInput
+            {
+                SurfaceLine = surfaceLine,
+                ExitPointL = 0.5
+            };
+
+            var previousResult = input.ThicknessCoverageLayer.Mean;
+
+            input.SetSoilProfile(soilProfile);
+
+            // Call
+            var result = input.ThicknessCoverageLayer.Mean;
+
+            // Assert
+            Assert.AreSame(soilProfile, input.SoilProfile);
+            Assert.AreNotEqual(previousResult, result);
+            Assert.AreEqual(1.0, result);
+        }
+
+        [Test]
+        public void SetExitPointL_WithSoilProfileAndExitPointL_ThicknessUpdated()
+        {
+            // Setup
+            var surfaceLine = new RingtoetsPipingSurfaceLine();
+            surfaceLine.SetGeometry(new[]
+            {
+                new Point3D(0,0,2.0), 
+                new Point3D(1.0,0,2.0), 
+            });
+            var soilProfile = new PipingSoilProfile(String.Empty, 0, new[]
+            {
+                new PipingSoilLayer(1.0)
+                {
+                    IsAquifer = true
+                },
+                new PipingSoilLayer(2.0)
+                {
+                    IsAquifer = false
+                }
+            });
+            var input = new PipingInput
+            {
+                SurfaceLine = surfaceLine,
+                SoilProfile = soilProfile
+            };
+
+            var previousResult = input.ThicknessCoverageLayer.Mean;
+
+            var exitPointL = 0.5;
+            input.SetExitPointL(exitPointL);
+
+            // Call
+            var result = input.ThicknessCoverageLayer.Mean;
+
+            // Assert
+            Assert.AreEqual(exitPointL, input.ExitPointL);
+            Assert.AreNotEqual(previousResult, result);
+            Assert.AreEqual(1.0, result);
+        }
+
         private static RingtoetsPipingSurfaceLine ValidSurfaceLine(double xMin, double xMax)
         {
             var surfaceLine = new RingtoetsPipingSurfaceLine();
Index: Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/PropertyClasses/PipingInputContextPropertiesTest.cs
===================================================================
diff -u -r1ce62a05fe624df22af3f1d83288457ec163dabc -r847f6b97f0a6e007a89364ad12d0541bc0d84d1e
--- Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/PropertyClasses/PipingInputContextPropertiesTest.cs	(.../PipingInputContextPropertiesTest.cs)	(revision 1ce62a05fe624df22af3f1d83288457ec163dabc)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Forms.Test/PropertyClasses/PipingInputContextPropertiesTest.cs	(.../PipingInputContextPropertiesTest.cs)	(revision 847f6b97f0a6e007a89364ad12d0541bc0d84d1e)
@@ -236,11 +236,9 @@
         }
 
         [Test]
+        [TestCase(4, 2, 2)]
         [TestCase(2, 2, 0)]
-        [TestCase(2, 4, -2)]
-        [TestCase(0.5, 4, -3.5)]
-        [TestCase(1e-6, 4, -(4 - 1e-6))]
-        [TestCase(3, 1e-6, 3 - 1e-6)]
+        [TestCase(4 + 1e-6, 4,  1e-6)]
         [TestCase(0.5, 1e-6, 0.5-1e-6)]
         public void EntryPointL_ExitPointAndSeepageLengthSet_ExpectedValue(double exitPoint, double seepageLength, double entryPoint)
         {
@@ -252,14 +250,16 @@
             inputObserver.Expect(o => o.UpdateObserver()).Repeat.Times(numberProperties);
             mocks.ReplayAll();
 
-            var random = new Random(22);
-
             var surfaceLine = ValidSurfaceLine(0.0, 4.0);
-            var soilProfile = new PipingSoilProfile(String.Empty, random.NextDouble(), new[]
+            var soilProfile = new PipingSoilProfile(String.Empty, -1, new[]
             {
-                new PipingSoilLayer(random.NextDouble())
+                new PipingSoilLayer(0)
                 {
                     IsAquifer = true
+                },
+                new PipingSoilLayer(1)
+                {
+                    IsAquifer = false
                 }
             });
             var inputParameters = new PipingInput
@@ -281,7 +281,7 @@
             properties.SeepageLength.Distribution.Mean = seepageLength;
 
             // Call & Assert
-            Assert.AreEqual(entryPoint, properties.EntryPointL);
+            Assert.AreEqual(entryPoint, properties.EntryPointL, 1e-6);
             Assert.AreEqual(properties.ExitPointL, inputParameters.ExitPointL);
             Assert.AreEqual(properties.SeepageLength.Distribution.Mean, inputParameters.SeepageLength.Mean);
 
@@ -293,7 +293,7 @@
         [TestCase(2, 4, 2)]
         [TestCase(1e-6, 4, 4 - 1e-6)]
         [TestCase(1e-6, 3, 3 - 1e-6)]
-        [TestCase(0, 1e-6, 1e-6)]
+        [TestCase(1, 1 + 1e-6, 1e-6)]
         public void SeepageLength_ExitPointAndEntryPointSet_ExpectedValue(double entryPoint, double exitPoint, double seepageLength)
         {
             // Setup
@@ -304,14 +304,16 @@
             inputObserver.Expect(o => o.UpdateObserver()).Repeat.Times(numberProperties);
             mocks.ReplayAll();
 
-            var random = new Random(22);
-
             var surfaceLine = ValidSurfaceLine(0.0, 4.0);
-            var soilProfile = new PipingSoilProfile(string.Empty, random.NextDouble(), new[]
+            var soilProfile = new PipingSoilProfile(String.Empty, -1, new[]
             {
-                new PipingSoilLayer(random.NextDouble())
+                new PipingSoilLayer(0)
                 {
                     IsAquifer = true
+                },
+                new PipingSoilLayer(1)
+                {
+                    IsAquifer = false
                 }
             });
             var inputParameters = new PipingInput
@@ -333,7 +335,7 @@
             properties.EntryPointL = entryPoint;
 
             // Call & Assert
-            Assert.AreEqual(seepageLength, properties.SeepageLength.Distribution.Mean);
+            Assert.AreEqual(seepageLength, properties.SeepageLength.Distribution.Mean, 1e-6);
             Assert.AreEqual(properties.ExitPointL, inputParameters.ExitPointL);
             Assert.AreEqual(properties.SeepageLength.Distribution.Mean, inputParameters.SeepageLength.Mean);
 
@@ -351,14 +353,16 @@
             inputObserver.Expect(o => o.UpdateObserver()).Repeat.Times(numberProperties);
             mocks.ReplayAll();
 
-            var random = new Random(22);
-
             var surfaceLine = ValidSurfaceLine(0.0, 4.0);
-            var soilProfile = new PipingSoilProfile(string.Empty, random.NextDouble(), new[]
+            var soilProfile = new PipingSoilProfile(String.Empty, -1, new[]
             {
-                new PipingSoilLayer(random.NextDouble())
+                new PipingSoilLayer(0)
                 {
                     IsAquifer = true
+                },
+                new PipingSoilLayer(1)
+                {
+                    IsAquifer = false
                 }
             });
             var inputParameters = new PipingInput
@@ -396,14 +400,16 @@
             var inputObserver = mocks.StrictMock<IObserver>();
             mocks.ReplayAll();
 
-            var random = new Random(22);
-
             var surfaceLine = ValidSurfaceLine(0.0, 4.0);
-            var soilProfile = new PipingSoilProfile(String.Empty, random.NextDouble(), new[]
+            var soilProfile = new PipingSoilProfile(String.Empty, -1, new[]
             {
-                new PipingSoilLayer(random.NextDouble())
+                new PipingSoilLayer(0)
                 {
                     IsAquifer = true
+                },
+                new PipingSoilLayer(1)
+                {
+                    IsAquifer = false
                 }
             });
             var inputParameters = new PipingInput
Index: Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/PipingCalculationServiceTest.cs
===================================================================
diff -u -rd6e6eadf4a2521df75b6d371bacbb181a43058a3 -r847f6b97f0a6e007a89364ad12d0541bc0d84d1e
--- Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/PipingCalculationServiceTest.cs	(.../PipingCalculationServiceTest.cs)	(revision d6e6eadf4a2521df75b6d371bacbb181a43058a3)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/PipingCalculationServiceTest.cs	(.../PipingCalculationServiceTest.cs)	(revision 847f6b97f0a6e007a89364ad12d0541bc0d84d1e)
@@ -1,10 +1,11 @@
 using System;
 using System.Linq;
+using Core.Common.Base.Geometry;
 using Core.Common.TestUtil;
 using Ringtoets.Piping.Calculation.TestUtil;
 
 using NUnit.Framework;
-
+using Ringtoets.Piping.Calculation;
 using Ringtoets.Piping.Data;
 using Ringtoets.Piping.Data.TestUtil;
 
@@ -71,6 +72,69 @@
         }
 
         [Test]
+        public void CalculateThicknessCoverageLayer_ValidInput_ReturnsThickness()
+        {
+            // Setup
+            PipingInput input = new PipingInput();
+            input.ExitPointL = 10;
+            input.SurfaceLine = new RingtoetsPipingSurfaceLine();
+            input.SurfaceLine.SetGeometry(new []
+            {
+                new Point3D(0, 0, 10),
+                new Point3D(20, 0, 10)
+            });
+            input.SoilProfile = new PipingSoilProfile(string.Empty, 0, new []
+            {
+                new PipingSoilLayer(5)
+                {
+                    IsAquifer = true
+                },
+                new PipingSoilLayer(20)
+                {
+                    IsAquifer = false
+                }
+            });
+
+            // Call
+            var thickness = PipingCalculationService.CalculateThicknessCoverageLayer(input);
+
+            // Assert
+            Assert.AreEqual(5, thickness);
+        }
+
+        [Test]
+        public void CalculateThicknessCoverageLayer_SurfaceLineOutsideProfile_ThrowsPipingCalculatorException()
+        {
+            // Setup
+            PipingInput input = new PipingInput();
+            input.ExitPointL = 10;
+            input.SurfaceLine = new RingtoetsPipingSurfaceLine();
+            input.SurfaceLine.SetGeometry(new[]
+            {
+                new Point3D(0, 0, 10),
+                new Point3D(10, 0, 20+1e-3),
+                new Point3D(20, 0, 10)
+            });
+            input.SoilProfile = new PipingSoilProfile(string.Empty, 0, new[]
+            {
+                new PipingSoilLayer(5)
+                {
+                    IsAquifer = true
+                },
+                new PipingSoilLayer(20)
+                {
+                    IsAquifer = false
+                }
+            });
+
+            // Call
+            TestDelegate test = () => PipingCalculationService.CalculateThicknessCoverageLayer(input);
+
+            // Assert
+            Assert.Throws<PipingCalculatorException>(test);
+        }
+
+        [Test]
         public void PerformValidatedCalculation_ValidPipingCalculation_LogStartAndEndOfValidatingInputsAndCalculation()
         {
             // Setup
Index: Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/Ringtoets.Piping.Service.Test.csproj
===================================================================
diff -u -rf98cc7191a717793f69485dad2923cd34f6d48de -r847f6b97f0a6e007a89364ad12d0541bc0d84d1e
--- Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/Ringtoets.Piping.Service.Test.csproj	(.../Ringtoets.Piping.Service.Test.csproj)	(revision f98cc7191a717793f69485dad2923cd34f6d48de)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Service.Test/Ringtoets.Piping.Service.Test.csproj	(.../Ringtoets.Piping.Service.Test.csproj)	(revision 847f6b97f0a6e007a89364ad12d0541bc0d84d1e)
@@ -76,6 +76,10 @@
       <Name>Ringtoets.Common.Data</Name>
       <Private>True</Private>
     </ProjectReference>
+    <ProjectReference Include="..\..\src\Ringtoets.Piping.Calculation\Ringtoets.Piping.Calculation.csproj">
+      <Project>{D64E4F0E-E341-496F-82B2-941AD202B4E3}</Project>
+      <Name>Ringtoets.Piping.Calculation</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\src\Ringtoets.Piping.Service\Ringtoets.Piping.Service.csproj">
       <Project>{10B8D63D-87E8-46DF-ACA9-A8CF22EE8FB5}</Project>
       <Name>Ringtoets.Piping.Service</Name>