Index: Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil.Test/RingtoetsProjectTestHelperTest.cs
===================================================================
diff -u -r9e9789b7d71ba1bcf4f648f4131855e266756877 -r8023e248794a5f3b27b9f272213393f54e96d11b
--- Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil.Test/RingtoetsProjectTestHelperTest.cs	(.../RingtoetsProjectTestHelperTest.cs)	(revision 9e9789b7d71ba1bcf4f648f4131855e266756877)
+++ Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil.Test/RingtoetsProjectTestHelperTest.cs	(.../RingtoetsProjectTestHelperTest.cs)	(revision 8023e248794a5f3b27b9f272213393f54e96d11b)
@@ -21,7 +21,6 @@
 
 using System.Collections.Generic;
 using System.Linq;
-using Core.Common.Base;
 using Core.Common.Base.Geometry;
 using NUnit.Framework;
 using Ringtoets.ClosingStructures.Data;
@@ -424,29 +423,6 @@
             Assert.IsFalse(calculationWithoutOutput.HasOutput);
         }
 
-        private static void AssertDuneErosionFailureMechanism(AssessmentSection assessmentSection)
-        {
-            DuneErosionFailureMechanism failureMechanism = assessmentSection.DuneErosion;
-            Assert.AreEqual(5.5, failureMechanism.GeneralInput.N, failureMechanism.GeneralInput.N.GetAccuracy());
-
-            CollectionAssert.IsEmpty(failureMechanism.Calculations);
-
-            IObservableEnumerable<DuneLocation> duneLocations = failureMechanism.DuneLocations;
-
-            Assert.AreEqual(3, duneLocations.Count());
-            Assert.IsNull(duneLocations.ElementAt(0).Calculation.Output);
-
-            DuneLocationCalculationOutput duneLocationCalculationOutput1 = duneLocations.ElementAt(1).Calculation.Output;
-            Assert.IsNotNull(duneLocationCalculationOutput1);
-            Assert.AreEqual(CalculationConvergence.NotCalculated, duneLocationCalculationOutput1.CalculationConvergence);
-
-            DuneLocationCalculationOutput duneLocationCalculationOutput2 = duneLocations.ElementAt(2).Calculation.Output;
-            Assert.IsNotNull(duneLocationCalculationOutput2);
-            Assert.AreEqual(CalculationConvergence.CalculatedConverged, duneLocationCalculationOutput2.CalculationConvergence);
-
-            Assert.AreEqual(3, failureMechanism.SectionResults.Count());
-        }
-
         private static void AssertStabilityPointStructuresFailureMechanism(AssessmentSection assessmentSection)
         {
             StabilityPointStructuresFailureMechanism failureMechanism = assessmentSection.StabilityPointStructures;
@@ -539,6 +515,39 @@
             Assert.AreEqual(5293.8, hydraulicBoundaryLocationWithIllustrationPoints.Location.Y);
         }
 
+        #region Dune Erosion Failure Mechanism
+
+        private static void AssertDuneErosionFailureMechanism(AssessmentSection assessmentSection)
+        {
+            DuneErosionFailureMechanism failureMechanism = assessmentSection.DuneErosion;
+            Assert.AreEqual(5.5, failureMechanism.GeneralInput.N, failureMechanism.GeneralInput.N.GetAccuracy());
+
+            IEnumerable<DuneLocation> duneLocations = failureMechanism.DuneLocations;
+
+            Assert.AreEqual(1, duneLocations.Count());
+            AssertDuneLocationCalculationWithoutOutput(failureMechanism.CalculationsForMechanismSpecificFactorizedSignalingNorm.Single());
+            AssertDuneLocationCalculationWithOutput(failureMechanism.CalculationsForMechanismSpecificSignalingNorm.Single());
+            AssertDuneLocationCalculationWithoutOutput(failureMechanism.CalculationsForMechanismSpecificLowerLimitNorm.Single());
+            AssertDuneLocationCalculationWithOutput(failureMechanism.CalculationsForLowerLimitNorm.Single());
+            AssertDuneLocationCalculationWithoutOutput(failureMechanism.CalculationsForFactorizedLowerLimitNorm.Single());
+
+            Assert.AreEqual(3, failureMechanism.SectionResults.Count());
+        }
+
+        private static void AssertDuneLocationCalculationWithoutOutput(DuneLocationCalculation calculation)
+        {
+            Assert.IsNull(calculation.Output);
+        }
+
+        private static void AssertDuneLocationCalculationWithOutput(DuneLocationCalculation calculation)
+        {
+            DuneLocationCalculationOutput calculationOutput = calculation.Output;
+            Assert.IsNotNull(calculationOutput);
+            Assert.AreEqual(CalculationConvergence.CalculatedConverged, calculationOutput.CalculationConvergence);
+        }
+
+        #endregion
+
         #region Hydraulic Boundary Location Calculations
 
         private static void AssertHydraulicBoundaryLocationCalculations(AssessmentSection assessmentSection)
Index: Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil/RingtoetsProjectTestHelper.cs
===================================================================
diff -u -re57e79927485e44d681b0617f17bada42dbfb862 -r8023e248794a5f3b27b9f272213393f54e96d11b
--- Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil/RingtoetsProjectTestHelper.cs	(.../RingtoetsProjectTestHelper.cs)	(revision e57e79927485e44d681b0617f17bada42dbfb862)
+++ Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil/RingtoetsProjectTestHelper.cs	(.../RingtoetsProjectTestHelper.cs)	(revision 8023e248794a5f3b27b9f272213393f54e96d11b)
@@ -825,50 +825,35 @@
 
         private static void SetDuneLocations(DuneErosionFailureMechanism failureMechanism)
         {
-            var locationWithoutOutput = new DuneLocation(12, "DuneLocation without output", new Point2D(790, 456),
-                                                         new DuneLocation.ConstructionProperties());
+            var location = new DuneLocation(12, "DuneLocation", new Point2D(790, 456),
+                                            new DuneLocation.ConstructionProperties());
 
-            var locationWithOutput = new DuneLocation(13, "DuneLocation with output", new Point2D(791, 456),
-                                                      new DuneLocation.ConstructionProperties())
+            failureMechanism.SetDuneLocations(new[]
             {
-                Calculation =
-                {
-                    Output = new DuneLocationCalculationOutput(CalculationConvergence.NotCalculated,
-                                                               new DuneLocationCalculationOutput.ConstructionProperties())
-                }
-            };
+                location
+            });
+            ConfigureDuneLocationCalculations(failureMechanism);
+        }
 
-            var locationCalculated = new DuneLocation(14, "DuneLocation with calculated output",
-                                                      new Point2D(792, 456), new DuneLocation.ConstructionProperties
-                                                      {
-                                                          CoastalAreaId = 1,
-                                                          Offset = 2,
-                                                          Orientation = 3,
-                                                          D50 = 4
-                                                      })
-            {
-                Calculation =
-                {
-                    Output = new DuneLocationCalculationOutput(CalculationConvergence.CalculatedConverged,
-                                                               new DuneLocationCalculationOutput.ConstructionProperties
-                                                               {
-                                                                   WaterLevel = 10,
-                                                                   WaveHeight = 20,
-                                                                   WavePeriod = 30,
-                                                                   TargetProbability = 0.4,
-                                                                   TargetReliability = 50,
-                                                                   CalculatedProbability = 0.6,
-                                                                   CalculatedReliability = 70
-                                                               })
-                }
-            };
+        private static void ConfigureDuneLocationCalculations(DuneErosionFailureMechanism failureMechanism)
+        {
+            SetCalculationOutput(failureMechanism.CalculationsForMechanismSpecificSignalingNorm.Single());
+            SetCalculationOutput(failureMechanism.CalculationsForLowerLimitNorm.Single());
+        }
 
-            failureMechanism.SetDuneLocations(new []
-            {
-                locationWithoutOutput,
-                locationWithOutput,
-                locationCalculated
-            });
+        private static void SetCalculationOutput(DuneLocationCalculation calculation)
+        {
+            calculation.Output = new DuneLocationCalculationOutput(CalculationConvergence.CalculatedConverged,
+                                                                   new DuneLocationCalculationOutput.ConstructionProperties
+                                                                   {
+                                                                       WaterLevel = 10,
+                                                                       WaveHeight = 20,
+                                                                       WavePeriod = 30,
+                                                                       TargetProbability = 0.4,
+                                                                       TargetReliability = 50,
+                                                                       CalculatedProbability = 0.6,
+                                                                       CalculatedReliability = 70
+                                                                   });
         }
 
         #endregion