Index: Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/AssessmentSectionCompositionChangeHandlerTest.cs
===================================================================
diff -u -rcf55284bcecdef7b9ef6cbd0d5a00c27870e4f85 -r78cc5b59d47ca61eb812d0c69c7a17a4570e4ddc
--- Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/AssessmentSectionCompositionChangeHandlerTest.cs	(.../AssessmentSectionCompositionChangeHandlerTest.cs)	(revision cf55284bcecdef7b9ef6cbd0d5a00c27870e4f85)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/AssessmentSectionCompositionChangeHandlerTest.cs	(.../AssessmentSectionCompositionChangeHandlerTest.cs)	(revision 78cc5b59d47ca61eb812d0c69c7a17a4570e4ddc)
@@ -132,7 +132,7 @@
         public void ChangeComposition_ChangeToSameValue_DoNothing()
         {
             // Setup
-            AssessmentSection assessmentSection = TestDataGenerator.GetFullyConfiguredAssessmentSection();
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
             AssessmentSectionComposition originalComposition = assessmentSection.Composition;
             ICalculation[] calculationsWithOutput = assessmentSection.GetFailureMechanisms()
                                                                      .SelectMany(fm => fm.Calculations)
@@ -171,7 +171,7 @@
                                                                                                                                         AssessmentSectionComposition newComposition)
         {
             // Setup
-            AssessmentSection assessmentSection = TestDataGenerator.GetFullyConfiguredAssessmentSection(oldComposition);
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations(oldComposition);
 
             GrassCoverErosionOutwardsFailureMechanism grassCoverErosionOutwardsFailureMechanism = assessmentSection.GetFailureMechanisms()
                                                                                                                    .OfType<GrassCoverErosionOutwardsFailureMechanism>()
@@ -187,7 +187,7 @@
                 .ToList();
 
             IEnumerable<IObservable> expectedAffectedObjects =
-                duneErosionFailureMechanism.DuneLocations.Cast<IObservable>()
+                duneErosionFailureMechanism.DuneLocations.Where(dl => dl.Output != null).Cast<IObservable>()
                                            .Concat(grassCoverErosionOutwardsFailureMechanism.HydraulicBoundaryLocations)
                                            .Concat(new IObservable[]
                                            {
@@ -238,7 +238,7 @@
                                                                                                                                         AssessmentSectionComposition newComposition)
         {
             // Setup
-            AssessmentSection assessmentSection = TestDataGenerator.GetFullyConfiguredAssessmentSection(oldComposition);
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations(oldComposition);
 
             DuneErosionFailureMechanism duneErosionFailureMechanism = assessmentSection.GetFailureMechanisms()
                                                                                        .OfType<DuneErosionFailureMechanism>()
@@ -249,7 +249,7 @@
                                                                                    .Where(calc => calc.HasOutput)
                                                                                    .ToList();
 
-            IEnumerable<IObservable> expectedAffectedObjects = duneErosionFailureMechanism.DuneLocations
+            IEnumerable<IObservable> expectedAffectedObjects = duneErosionFailureMechanism.DuneLocations.Where(dl => dl.Output != null)
                                                                                           .Concat(new IObservable[]
                                                                                           {
                                                                                               assessmentSection,
@@ -291,7 +291,7 @@
                                                                                                                             AssessmentSectionComposition newComposition)
         {
             // Setup
-            AssessmentSection assessmentSection = TestDataGenerator.GetFullyConfiguredAssessmentSection(oldComposition);
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations(oldComposition);
             RingtoetsDataSynchronizationService.ClearFailureMechanismCalculationOutputs(assessmentSection);
 
             // Precondition
@@ -306,7 +306,7 @@
                                                                                        .First();
 
             IEnumerable<IObservable> expectedAffectedObjects =
-                duneErosionFailureMechanism.DuneLocations.Cast<IObservable>()
+                duneErosionFailureMechanism.DuneLocations.Where(dl => dl.Output != null).Cast<IObservable>()
                                            .Concat(grassCoverErosionOutwardsFailureMechanism.HydraulicBoundaryLocations)
                                            .Concat(new IObservable[]
                                            {
@@ -350,7 +350,7 @@
                                                                                                                                AssessmentSectionComposition newComposition)
         {
             // Setup
-            AssessmentSection assessmentSection = TestDataGenerator.GetFullyConfiguredAssessmentSection(oldComposition);
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations(oldComposition);
             RingtoetsDataSynchronizationService.ClearFailureMechanismCalculationOutputs(assessmentSection);
 
             // Precondition
@@ -360,7 +360,7 @@
                                                                                        .OfType<DuneErosionFailureMechanism>()
                                                                                        .First();
 
-            IEnumerable<IObservable> expectedAffectedObjects = duneErosionFailureMechanism.DuneLocations
+            IEnumerable<IObservable> expectedAffectedObjects = duneErosionFailureMechanism.DuneLocations.Where(dl => dl.Output != null)
                                                                                           .Concat(new IObservable[]
                                                                                           {
                                                                                               assessmentSection,
@@ -399,7 +399,7 @@
                                                                                                                                          AssessmentSectionComposition newComposition)
         {
             // Setup
-            AssessmentSection assessmentSection = TestDataGenerator.GetFullyConfiguredAssessmentSection(oldComposition);
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations(oldComposition);
             RingtoetsDataSynchronizationService.ClearHydraulicBoundaryLocationOutputOfFailureMechanisms(assessmentSection);
 
             // Precondition
@@ -443,7 +443,7 @@
                                                                                                                                             AssessmentSectionComposition newComposition)
         {
             // Setup
-            AssessmentSection assessmentSection = TestDataGenerator.GetFullyConfiguredAssessmentSection(oldComposition);
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations(oldComposition);
             RingtoetsDataSynchronizationService.ClearHydraulicBoundaryLocationOutputOfFailureMechanisms(assessmentSection);
 
             // Precondition
Index: Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/FailureMechanismContributionNormChangeHandlerTest.cs
===================================================================
diff -u -r4bd863e75942710beedfe1ea7c2c5a097b46497f -r78cc5b59d47ca61eb812d0c69c7a17a4570e4ddc
--- Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/FailureMechanismContributionNormChangeHandlerTest.cs	(.../FailureMechanismContributionNormChangeHandlerTest.cs)	(revision 4bd863e75942710beedfe1ea7c2c5a097b46497f)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/FailureMechanismContributionNormChangeHandlerTest.cs	(.../FailureMechanismContributionNormChangeHandlerTest.cs)	(revision 78cc5b59d47ca61eb812d0c69c7a17a4570e4ddc)
@@ -27,6 +27,7 @@
 using NUnit.Extensions.Forms;
 using NUnit.Framework;
 using Ringtoets.Common.Data.AssessmentSection;
+using Ringtoets.Common.Data.Calculation;
 using Ringtoets.Common.Data.Hydraulics;
 using Ringtoets.DuneErosion.Data;
 using Ringtoets.Integration.Data;
@@ -151,11 +152,26 @@
         public void ChangeNorm_FullyConfiguredAssessmentSection_AllCalculationOutputClearedAndContributionsUpdatedAndReturnsAllAffectedObjects()
         {
             // Setup
-            AssessmentSection section = TestDataGenerator.GetFullyConfiguredAssessmentSection();
-            var expectedAffectedCalculations = section.GetFailureMechanisms()
+            AssessmentSection section = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
+            ICalculation[] expectedAffectedCalculations = section.GetFailureMechanisms()
                                                       .SelectMany(fm => fm.Calculations)
                                                       .Where(c => c.HasOutput)
                                                       .ToArray();
+
+            IEnumerable<IObservable> expectedAffectedObjects =
+                expectedAffectedCalculations.Cast<IObservable>()
+                                            .Concat(section.GetFailureMechanisms())
+                                            .Concat(section.GrassCoverErosionOutwards.HydraulicBoundaryLocations)
+                                            .Concat(section.HydraulicBoundaryDatabase.Locations)
+                                            .Concat(section.DuneErosion.DuneLocations.Where(dl => dl.Output != null))
+                                            .Concat(new IObservable[]
+                                            {
+                                                section.FailureMechanismContribution,
+                                                section.GrassCoverErosionOutwards.HydraulicBoundaryLocations,
+                                                section.HydraulicBoundaryDatabase,
+                                                section.DuneErosion.DuneLocations
+                                            }).ToList();
+
             var handler = new FailureMechanismContributionNormChangeHandler();
 
             IEnumerable<IObservable> affectedObjects = null;
@@ -177,18 +193,6 @@
             CollectionAssert.IsEmpty(section.GetFailureMechanisms().SelectMany(fm => fm.Calculations).Where(c => c.HasOutput),
                                      "There should be no calculations with output.");
 
-            var expectedAffectedObjects = expectedAffectedCalculations.Cast<IObservable>()
-                                                                      .Concat(section.GetFailureMechanisms())
-                                                                      .Concat(section.GrassCoverErosionOutwards.HydraulicBoundaryLocations)
-                                                                      .Concat(section.HydraulicBoundaryDatabase.Locations)
-                                                                      .Concat(section.DuneErosion.DuneLocations)
-                                                                      .Concat(new IObservable[]
-                                                                      {
-                                                                          section.FailureMechanismContribution,
-                                                                          section.GrassCoverErosionOutwards.HydraulicBoundaryLocations,
-                                                                          section.HydraulicBoundaryDatabase,
-                                                                          section.DuneErosion.DuneLocations
-                                                                      });
             foreach (HydraulicBoundaryLocation location in section.HydraulicBoundaryDatabase.Locations
                                                                   .Concat(section.GrassCoverErosionOutwards.HydraulicBoundaryLocations))
             {
@@ -206,12 +210,25 @@
         public void ChangeNorm_FullyConfiguredAssessmentSectionWithoutCalculationOutput_NormChangedContributionsUpdatedAndReturnsAllAffectedObjects()
         {
             // Setup
-            AssessmentSection section = TestDataGenerator.GetFullyConfiguredAssessmentSection();
+            AssessmentSection section = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
             RingtoetsDataSynchronizationService.ClearFailureMechanismCalculationOutputs(section);
 
             // Precondition
             CollectionAssert.IsEmpty(section.GetFailureMechanisms().SelectMany(fm => fm.Calculations).Where(c => c.HasOutput));
 
+            IEnumerable<IObservable> expectedAffectedObjects =
+                section.GetFailureMechanisms().Cast<IObservable>()
+                       .Concat(section.GrassCoverErosionOutwards.HydraulicBoundaryLocations)
+                       .Concat(section.HydraulicBoundaryDatabase.Locations)
+                       .Concat(section.DuneErosion.DuneLocations.Where(dl => dl.Output != null))
+                       .Concat(new IObservable[]
+                       {
+                           section.FailureMechanismContribution,
+                           section.GrassCoverErosionOutwards.HydraulicBoundaryLocations,
+                           section.HydraulicBoundaryDatabase,
+                           section.DuneErosion.DuneLocations
+                       }).ToList();
+
             var handler = new FailureMechanismContributionNormChangeHandler();
 
             IEnumerable<IObservable> affectedObjects = null;
@@ -226,17 +243,6 @@
 
             Assert.AreEqual(newNormValue, section.FailureMechanismContribution.Norm);
 
-            var expectedAffectedObjects = section.GetFailureMechanisms().Cast<IObservable>()
-                                                 .Concat(section.GrassCoverErosionOutwards.HydraulicBoundaryLocations)
-                                                 .Concat(section.HydraulicBoundaryDatabase.Locations)
-                                                 .Concat(section.DuneErosion.DuneLocations)
-                                                 .Concat(new IObservable[]
-                                                 {
-                                                     section.FailureMechanismContribution,
-                                                     section.GrassCoverErosionOutwards.HydraulicBoundaryLocations,
-                                                     section.HydraulicBoundaryDatabase,
-                                                     section.DuneErosion.DuneLocations
-                                                 });
             foreach (HydraulicBoundaryLocation location in section.HydraulicBoundaryDatabase.Locations
                                                                   .Concat(section.GrassCoverErosionOutwards.HydraulicBoundaryLocations))
             {
@@ -254,7 +260,7 @@
         public void ChangeNorm_FullyConfiguredAssessmentSectionWithoutCalculatedHydraulicBoundaryLocations_AllFailureMechanismCalculationOutputClearedAndContributionsUpdatedAndReturnsAllAffectedObjects()
         {
             // Setup
-            AssessmentSection section = TestDataGenerator.GetFullyConfiguredAssessmentSection();
+            AssessmentSection section = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
             RingtoetsDataSynchronizationService.ClearHydraulicBoundaryLocationOutput(section.HydraulicBoundaryDatabase, section);
 
             // Precondition
Index: Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/ReferenceLineReplacementHandlerTest.cs
===================================================================
diff -u -r3c283aaf463f417b7769c26116b379959e4e405b -r78cc5b59d47ca61eb812d0c69c7a17a4570e4ddc
--- Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/ReferenceLineReplacementHandlerTest.cs	(.../ReferenceLineReplacementHandlerTest.cs)	(revision 3c283aaf463f417b7769c26116b379959e4e405b)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Handlers/ReferenceLineReplacementHandlerTest.cs	(.../ReferenceLineReplacementHandlerTest.cs)	(revision 78cc5b59d47ca61eb812d0c69c7a17a4570e4ddc)
@@ -146,7 +146,7 @@
             var viewCommands = mocks.Stub<IViewCommands>();
             mocks.ReplayAll();
 
-            AssessmentSection assessmentSection = TestDataGenerator.GetFullyConfiguredAssessmentSection();
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
             var handler = new ReferenceLineReplacementHandler(viewCommands);
 
             var referenceLine = new ReferenceLine();
@@ -314,7 +314,7 @@
         public void DoPostReplacementUpdates_AfterReplacingReferenceLine_CloseViewsForRemovedData()
         {
             // Setup
-            const int expectedNumberOfRemovedInstances = 102;
+            const int expectedNumberOfRemovedInstances = 112;
 
             var mocks = new MockRepository();
             var viewCommands = mocks.StrictMock<IViewCommands>();
@@ -324,7 +324,7 @@
 
             var handler = new ReferenceLineReplacementHandler(viewCommands);
 
-            AssessmentSection assessmentSection = TestDataGenerator.GetFullyConfiguredAssessmentSection();
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
             handler.Replace(assessmentSection, new ReferenceLine());
 
             // Call
@@ -338,7 +338,7 @@
         public void DoPostReplacementUpdates_CalledSecondTimeAfterReplaceAndUpdateCycle_DoNothing()
         {
             // Setup
-            const int expectedNumberOfRemovedInstances = 102;
+            const int expectedNumberOfRemovedInstances = 112;
 
             var mocks = new MockRepository();
             var viewCommands = mocks.StrictMock<IViewCommands>();
@@ -348,7 +348,7 @@
 
             var handler = new ReferenceLineReplacementHandler(viewCommands);
 
-            AssessmentSection assessmentSection = TestDataGenerator.GetFullyConfiguredAssessmentSection();
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
             handler.Replace(assessmentSection, new ReferenceLine());
             handler.DoPostReplacementUpdates();
 
Index: Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/RingtoetsDataSynchronizationServiceTest.cs
===================================================================
diff -u -rcf55284bcecdef7b9ef6cbd0d5a00c27870e4f85 -r78cc5b59d47ca61eb812d0c69c7a17a4570e4ddc
--- Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/RingtoetsDataSynchronizationServiceTest.cs	(.../RingtoetsDataSynchronizationServiceTest.cs)	(revision cf55284bcecdef7b9ef6cbd0d5a00c27870e4f85)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Service.Test/RingtoetsDataSynchronizationServiceTest.cs	(.../RingtoetsDataSynchronizationServiceTest.cs)	(revision 78cc5b59d47ca61eb812d0c69c7a17a4570e4ddc)
@@ -68,7 +68,7 @@
         public void ClearFailureMechanismCalculationOutputs_WithAssessmentSection_ClearsFailureMechanismCalculationsOutputAndReturnsAffectedCalculations()
         {
             // Setup
-            AssessmentSection assessmentSection = TestDataGenerator.GetFullyConfiguredAssessmentSection();
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
             IEnumerable<ICalculation> expectedAffectedItems = assessmentSection.GetFailureMechanisms()
                                                                                .SelectMany(f => f.Calculations)
                                                                                .Where(c => c.HasOutput)
@@ -145,7 +145,7 @@
         public void ClearAllCalculationOutputAndHydraulicBoundaryLocations_VariousCalculations_ClearsHydraulicBoundaryLocationAndCalculationsAndReturnsAffectedObjects()
         {
             // Setup
-            var assessmentSection = TestDataGenerator.GetFullyConfiguredAssessmentSection();
+            var assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
             var expectedAffectedItems = new List<IObservable>();
             expectedAffectedItems.AddRange(assessmentSection.ClosingStructures.Calculations
                                                             .Cast<StructuresCalculation<ClosingStructuresInput>>()
@@ -484,7 +484,7 @@
         public void ClearReferenceLine_FullyConfiguredAssessmentSection_AllReferenceLineDependentDataCleared()
         {
             // Setup
-            AssessmentSection assessmentSection = TestDataGenerator.GetFullyConfiguredAssessmentSection();
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
 
             // Call
             RingtoetsDataSynchronizationService.ClearReferenceLine(assessmentSection);
@@ -591,7 +591,7 @@
         public void ClearReferenceLine_FullyConfiguredAssessmentSection_ClearResultsContainAllAffectedObjectsAndAllRemovedObjects()
         {
             // Setup
-            AssessmentSection assessmentSection = TestDataGenerator.GetFullyConfiguredAssessmentSection();
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
 
             IList<object> expectedRemovedObjects = GetExpectedRemovedObjectsWhenClearingReferenceLine(assessmentSection);
 
@@ -686,7 +686,7 @@
         public void ClearReferenceLine_FullyConfiguredAssessmentSectionWithoutReferenceLine_ClearResultsDoesNotContainReferenceLineNorNullForRemovedObjects()
         {
             // Setup
-            AssessmentSection assessmentSection = TestDataGenerator.GetFullyConfiguredAssessmentSection();
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
             ReferenceLine originalReferenceLine = assessmentSection.ReferenceLine;
             assessmentSection.ReferenceLine = null;
 
Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtils.Test/Ringtoets.Integration.TestUtils.Test.csproj
===================================================================
diff -u -r5c426a1e8ae5225fb88d1960270bf2f3bf13153f -r78cc5b59d47ca61eb812d0c69c7a17a4570e4ddc
--- Ringtoets/Integration/test/Ringtoets.Integration.TestUtils.Test/Ringtoets.Integration.TestUtils.Test.csproj	(.../Ringtoets.Integration.TestUtils.Test.csproj)	(revision 5c426a1e8ae5225fb88d1960270bf2f3bf13153f)
+++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtils.Test/Ringtoets.Integration.TestUtils.Test.csproj	(.../Ringtoets.Integration.TestUtils.Test.csproj)	(revision 78cc5b59d47ca61eb812d0c69c7a17a4570e4ddc)
@@ -41,20 +41,96 @@
     <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.Data.SQLite, Version=1.0.104.0, Culture=neutral, PublicKeyToken=db937bc2d44ff139, processorArchitecture=x86">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\Checkout_Dev\packages\System.Data.SQLite.Core.1.0.104.0\lib\net40\System.Data.SQLite.dll</HintPath>
+    </Reference>
   </ItemGroup>
   <ItemGroup>
     <Compile Include="..\..\..\..\Core\Common\src\Core.Common.Version\GlobalAssembly.cs">
       <Link>Properties\GlobalAssembly.cs</Link>
     </Compile>
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="TestDataGeneratorTest.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="..\..\..\ClosingStructures\src\Ringtoets.ClosingStructures.Data\Ringtoets.ClosingStructures.Data.csproj">
+      <Project>{c6309704-d67b-434c-bc98-9f8910bc1d10}</Project>
+      <Name>Ringtoets.ClosingStructures.Data</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="..\..\..\DuneErosion\src\Ringtoets.DuneErosion.Data\Ringtoets.DuneErosion.Data.csproj">
+      <Project>{d1068432-c172-4aa6-847b-d9deb4c6de26}</Project>
+      <Name>Ringtoets.DuneErosion.Data</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\GrassCoverErosionInwards\src\Ringtoets.GrassCoverErosionInwards.Data\Ringtoets.GrassCoverErosionInwards.Data.csproj">
+      <Project>{90de728e-48ef-4665-ab38-3d88e41d9f4d}</Project>
+      <Name>Ringtoets.GrassCoverErosionInwards.Data</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\GrassCoverErosionOutwards\src\Ringtoets.GrassCoverErosionOutwards.Data\Ringtoets.GrassCoverErosionOutwards.Data.csproj">
+      <Project>{e7225477-577f-4a17-b7ec-6721158e1543}</Project>
+      <Name>Ringtoets.GrassCoverErosionOutwards.Data</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\HeightStructures\src\Ringtoets.HeightStructures.Data\Ringtoets.HeightStructures.Data.csproj">
+      <Project>{1c0017d8-35b5-4ca0-8fc7-a83f46dbdc99}</Project>
+      <Name>Ringtoets.HeightStructures.Data</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\Piping\src\Ringtoets.Piping.Data\Ringtoets.Piping.Data.csproj">
+      <Project>{ce994cc9-6f6a-48ac-b4be-02c30a21f4db}</Project>
+      <Name>Ringtoets.Piping.Data</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\Piping\src\Ringtoets.Piping.Primitives\Ringtoets.Piping.Primitives.csproj">
+      <Project>{14c6f716-64e2-4bc4-a1ef-05865fcefa4c}</Project>
+      <Name>Ringtoets.Piping.Primitives</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\Revetment\src\Ringtoets.Revetment.Data\Ringtoets.Revetment.Data.csproj">
+      <Project>{87c2c553-c0bc-40bf-b1ea-b83bff357f27}</Project>
+      <Name>Ringtoets.Revetment.Data</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\StabilityPointStructures\src\Ringtoets.StabilityPointStructures.Data\Ringtoets.StabilityPointStructures.Data.csproj">
+      <Project>{3d4b9740-8348-4434-8d77-b611fc6ee57f}</Project>
+      <Name>Ringtoets.StabilityPointStructures.Data</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\StabilityStoneCover\src\Ringtoets.StabilityStoneCover.Data\Ringtoets.StabilityStoneCover.Data.csproj">
+      <Project>{b479e3af-7c34-488c-bb73-d324100d36c9}</Project>
+      <Name>Ringtoets.StabilityStoneCover.Data</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\..\WaveImpactAsphaltCover\src\Ringtoets.WaveImpactAsphaltCover.Data\Ringtoets.WaveImpactAsphaltCover.Data.csproj">
+      <Project>{567e0b69-5280-41ce-add6-443725a61c86}</Project>
+      <Name>Ringtoets.WaveImpactAsphaltCover.Data</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\src\Ringtoets.Integration.Data\Ringtoets.Integration.Data.csproj">
+      <Project>{11f1f874-45af-43e4-8ae5-15a5c9593e28}</Project>
+      <Name>Ringtoets.Integration.Data</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\src\Ringtoets.Integration.Service\Ringtoets.Integration.Service.csproj">
+      <Project>{28811c4a-6c18-42c1-88b2-a03a3784e2d0}</Project>
+      <Name>Ringtoets.Integration.Service</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\Ringtoets.Integration.TestUtils\Ringtoets.Integration.TestUtils.csproj">
+      <Project>{174ba68d-6176-4ac5-8dfd-98cdd2c4d971}</Project>
+      <Name>Ringtoets.Integration.TestUtils</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/Integration/test/Ringtoets.Integration.TestUtils.Test/TestDataGeneratorTest.cs
===================================================================
diff -u
--- Ringtoets/Integration/test/Ringtoets.Integration.TestUtils.Test/TestDataGeneratorTest.cs	(revision 0)
+++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtils.Test/TestDataGeneratorTest.cs	(revision 78cc5b59d47ca61eb812d0c69c7a17a4570e4ddc)
@@ -0,0 +1,718 @@
+// Copyright (C) Stichting Deltares 2016. 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.Collections.Generic;
+using System.Linq;
+using NUnit.Framework;
+using NUnit.Framework.Internal.Filters;
+using Ringtoets.ClosingStructures.Data;
+using Ringtoets.Common.Data;
+using Ringtoets.Common.Data.AssessmentSection;
+using Ringtoets.Common.Data.Calculation;
+using Ringtoets.Common.Data.FailureMechanism;
+using Ringtoets.Common.Data.Structures;
+using Ringtoets.DuneErosion.Data;
+using Ringtoets.GrassCoverErosionInwards.Data;
+using Ringtoets.GrassCoverErosionOutwards.Data;
+using Ringtoets.HeightStructures.Data;
+using Ringtoets.Integration.Data;
+using Ringtoets.Piping.Data;
+using Ringtoets.StabilityPointStructures.Data;
+using Ringtoets.StabilityStoneCover.Data;
+using Ringtoets.WaveImpactAsphaltCover.Data;
+
+namespace Ringtoets.Integration.TestUtils.Test
+{
+    [TestFixture]
+    public class TestDataGeneratorTest
+    {
+        [Test]
+        public void GetAssessmentSectionWithAllCalculationConfigurations_NoArguments_ReturnsWithAllPossibleCalculationConfigurations()
+        {
+            // Call
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations();
+
+            // Assert
+            Assert.AreEqual(AssessmentSectionComposition.Dike, assessmentSection.Composition);
+            AssertFailureMechanismHasAllPossibleCalculationConfigurations(assessmentSection);
+            Assert.True(assessmentSection.GrassCoverErosionOutwards.HydraulicBoundaryLocations.All(loc => loc.DesignWaterLevelOutput != null
+                                                                                                          && loc.WaveHeightOutput != null));
+
+            DuneErosionFailureMechanism duneErosionFailureMechanism = assessmentSection.GetFailureMechanisms()
+                                                                                       .OfType<DuneErosionFailureMechanism>()
+                                                                                       .First();
+            AssertDuneErosionFailureMechanismCalculationConfigurationsWithoutOutputs(duneErosionFailureMechanism);
+            AssertDuneErosionFailureMechanismCalculationConfigurationsWithOutputs(duneErosionFailureMechanism);
+        }
+
+        [Test]
+        [TestCase(AssessmentSectionComposition.Dike)]
+        [TestCase(AssessmentSectionComposition.DikeAndDune)]
+        [TestCase(AssessmentSectionComposition.Dune)]
+        public void GetAssessmentSectionWithAllCalculationConfigurations_CompositionGiven_ReturnWithCompositionAndAllPossibleCalculationConfigurations(
+            AssessmentSectionComposition composition)
+        {
+            // Call 
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations(composition);
+
+            // Assert
+            Assert.AreEqual(composition, assessmentSection.Composition);
+            AssertFailureMechanismHasAllPossibleCalculationConfigurations(assessmentSection);
+            Assert.True(assessmentSection.GrassCoverErosionOutwards.HydraulicBoundaryLocations.All(loc => loc.DesignWaterLevelOutput != null
+                                                                                                          && loc.WaveHeightOutput != null));
+
+            DuneErosionFailureMechanism duneErosionFailureMechanism = assessmentSection.GetFailureMechanisms()
+                                                                           .OfType<DuneErosionFailureMechanism>()
+                                                                           .First();
+            AssertDuneErosionFailureMechanismCalculationConfigurationsWithoutOutputs(duneErosionFailureMechanism);
+            AssertDuneErosionFailureMechanismCalculationConfigurationsWithOutputs(duneErosionFailureMechanism);
+        }
+
+        [Test]
+        [TestCase(AssessmentSectionComposition.Dike, TestName = "GetAssessmentSectionWithAllCalculationConfigurationsWithoutHydraulicBoundaryLocationAndDuneOutput_CompositionGiven_ReturnWithOnlyCalculationOutputsAndComposition(Dike)")]
+        [TestCase(AssessmentSectionComposition.DikeAndDune, TestName = "GetAssessmentSectionWithAllCalculationConfigurationsWithoutHydraulicBoundaryLocationAndDuneOutput_CompositionGiven_ReturnWithOnlyCalculationOutputsAndComposition(DikeAndDune)")]
+        [TestCase(AssessmentSectionComposition.Dune, TestName = "GetAssessmentSectionWithAllCalculationConfigurationsWithoutHydraulicBoundaryLocationAndDuneOutput_CompositionGiven_ReturnWithOnlyCalculationOutputsAndComposition(Dune)")]
+        public void GetAssessmentSectionWithAllCalculationConfigurationsWithoutHydraulicBoundaryLocationAndDuneOutput_CompositionGiven_ReturnWithOnlyCalculationOutputsAndComposition(
+            AssessmentSectionComposition composition)
+        {
+            // Call 
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurationsWithoutHydraulicBoundaryLocationAndDuneOutput(composition);
+
+            // Assert
+            Assert.AreEqual(composition, assessmentSection.Composition);
+            AssertFailureMechanismHasAllPossibleCalculationConfigurations(assessmentSection);
+            Assert.True(assessmentSection.GrassCoverErosionOutwards.HydraulicBoundaryLocations.All(loc => loc.DesignWaterLevelOutput == null
+                                                                                                          && loc.WaveHeightOutput == null));
+            Assert.True(assessmentSection.DuneErosion.DuneLocations.All(dl => dl.Output == null));
+        }
+
+        [Test]
+        [TestCase(AssessmentSectionComposition.Dike, TestName = "GetAssessmentSectionWithAllCalculationConfigurationsWithoutCalculationOutput_CompositionGiven_ReturnWithCompositionAndOnlyHydraulicOutputs(Dike)")]
+        [TestCase(AssessmentSectionComposition.DikeAndDune, TestName = "GetAssessmentSectionWithAllCalculationConfigurationsWithoutCalculationOutput_CompositionGiven_ReturnWithCompositionAndOnlyHydraulicOutputs(DikeAndDune)")]
+        [TestCase(AssessmentSectionComposition.Dune, TestName = "GetAssessmentSectionWithAllCalculationConfigurationsWithoutCalculationOutput_CompositionGiven_ReturnWithCompositionAndOnlyHydraulicOutputs(Dune)")]
+        public void GetAssessmentSectionWithAllCalculationConfigurationsWithoutCalculationOutput_CompositionGiven_ReturnWithOnlyHydraulicBoundaryLocationAndDuneLocationOutputsAndComposition(
+            AssessmentSectionComposition composition)
+        {
+            // Call 
+            AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurationsWithoutCalculationOutput(composition);
+
+            // Assert
+            Assert.AreEqual(composition, assessmentSection.Composition);
+            AssertFailureMechanismHasAllCalculationConfigurationsWithoutCalculationOutputs(assessmentSection);
+            CollectionAssert.IsEmpty(assessmentSection.GetFailureMechanisms().SelectMany(fm => fm.Calculations).Where(calc => calc.HasOutput));
+            Assert.True(assessmentSection.GrassCoverErosionOutwards.HydraulicBoundaryLocations.All(loc => loc.DesignWaterLevelOutput != null
+                                                                                                          && loc.WaveHeightOutput != null));
+        }
+
+        private static void AssertFailureMechanismHasAllPossibleCalculationConfigurations(IAssessmentSection assessmentSection)
+        {
+            bool containsClosingStructuresFailureMechanism = false;
+            bool containsGrassCoverErosionInwardsFailureMechanism = false;
+            bool containsGrassCoverErosionOutwardsFailureMechanism = false;
+            bool containsHeightStructuresFailureMechanism = false;
+            bool containsPipingFailureMechanism = false;
+            bool containsStabilityPointStructuresFailureMechanism = false;
+            bool containsStabilityStoneCoverFailureMechanism = false;
+            bool containsWaveImpactAsphaltCoverFailureMechanism = false;
+            bool containsDuneErosionFailureMechanism = false;
+
+            foreach (IFailureMechanism failureMechanism in assessmentSection.GetFailureMechanisms())
+            {
+                var closingStructuresFailureMechanism = failureMechanism as ClosingStructuresFailureMechanism;
+                var grassCoverErosionInwardsFailureMechanism = failureMechanism as GrassCoverErosionInwardsFailureMechanism;
+                var grassCoverErosionOutwardsFailureMechanism = failureMechanism as GrassCoverErosionOutwardsFailureMechanism;
+                var heightStructuresFailureMechanism = failureMechanism as HeightStructuresFailureMechanism;
+                var pipingFailureMechanism = failureMechanism as PipingFailureMechanism;
+                var stabilityPointStructuresFailureMechanism = failureMechanism as StabilityPointStructuresFailureMechanism;
+                var stabilityStoneCoverFailureMechanism = failureMechanism as StabilityStoneCoverFailureMechanism;
+                var waveImpactAsphaltCoverFailureMechanism = failureMechanism as WaveImpactAsphaltCoverFailureMechanism;
+                var duneErosionFailureMechanism = failureMechanism as DuneErosionFailureMechanism;
+
+                if (closingStructuresFailureMechanism != null)
+                {
+                    AssertHasForeshoreProfiles(closingStructuresFailureMechanism);
+                    AssertClosingStructureFailuresMechanismCalculationsWithOutputs(closingStructuresFailureMechanism);
+                    AssertClosingStructureFailuresMechanismCalculationsWithoutOutputs(closingStructuresFailureMechanism);
+                    containsClosingStructuresFailureMechanism = true;
+                }
+
+                if (grassCoverErosionInwardsFailureMechanism != null)
+                {
+                    AssertHasDikeProfiles(grassCoverErosionInwardsFailureMechanism);
+                    AssertGrassCoverErosionInwardsFailureMechanismCalculationConfigurationsWithOutputs(grassCoverErosionInwardsFailureMechanism);
+                    AssertGrassCoverErosionInwardsFailureMechanismCalculationConfigurationsWithoutOutputs(grassCoverErosionInwardsFailureMechanism);
+                    containsGrassCoverErosionInwardsFailureMechanism = true;
+                }
+
+                if (grassCoverErosionOutwardsFailureMechanism != null)
+                {
+                    AssertHasForeshoreProfiles(grassCoverErosionOutwardsFailureMechanism);
+                    AssertGrassCoverErosionOutwardsFailureMechanismCalculationConfigurationsWithOutputs(grassCoverErosionOutwardsFailureMechanism);
+                    AssertGrassCoverErosionOutwardsFailureMechanismCalculationConfigurationsWithoutOutputs(grassCoverErosionOutwardsFailureMechanism);
+                    containsGrassCoverErosionOutwardsFailureMechanism = true;
+                }
+
+                if (heightStructuresFailureMechanism != null)
+                {
+                    AssertHasForeshoreProfiles(heightStructuresFailureMechanism);
+                    AssertHeightStructureFailureMechanismCalculationConfigurationsWithOutputs(heightStructuresFailureMechanism);
+                    AssertHeightStructureFailureMechanismCalculationConfigurationsWithoutOutputs(heightStructuresFailureMechanism);
+                    containsHeightStructuresFailureMechanism = true;
+                }
+
+                if (pipingFailureMechanism != null)
+                {
+                    AssertHasStochasticSoilModels(pipingFailureMechanism);
+                    AssertHasSurfaceLines(pipingFailureMechanism);
+                    AssertPipingFailureMechanismCalculationConfigurationsWithOutputs(pipingFailureMechanism);
+                    AssertPipingFailureMechanismCalculationConfigurationsWithoutOutputs(pipingFailureMechanism);
+                    containsPipingFailureMechanism = true;
+                }
+
+                if (stabilityPointStructuresFailureMechanism != null)
+                {
+                    AssertHasForeshoreProfiles(stabilityPointStructuresFailureMechanism);
+                    AssertStabilityPointStructuresFailureMechanismCalculationConfigurationsWithOutputs(stabilityPointStructuresFailureMechanism);
+                    AssertStabilityPointStructuresFailureMechanismCalculationConfigurationsWithoutOutputs(stabilityPointStructuresFailureMechanism);
+                    containsStabilityPointStructuresFailureMechanism = true;
+                }
+
+                if (stabilityStoneCoverFailureMechanism != null)
+                {
+                    AssertHasForeshoreProfiles(stabilityStoneCoverFailureMechanism);
+                    AssertStabilityStoneCoverWaveConditionsFailureMechanismCalculationConfigurationsWithOutputs(stabilityStoneCoverFailureMechanism);
+                    AssertStabilityStoneCoverWaveConditionsFailureMechanismCalculationConfigurationsWithoutOutputs(stabilityStoneCoverFailureMechanism);
+                    containsStabilityStoneCoverFailureMechanism = true;
+                }
+
+                if (waveImpactAsphaltCoverFailureMechanism != null)
+                {
+                    AssertHasForeshoreProfiles(waveImpactAsphaltCoverFailureMechanism);
+                    AssertWaveImpactAsphaltCoverWaveConditionsFailureMechanismCalculationConfigurationsWithOutputs(waveImpactAsphaltCoverFailureMechanism);
+                    AssertWaveImpactAsphaltCoverWaveConditionsFailureMechanismCalculationConfigurationsWithoutOutputs(waveImpactAsphaltCoverFailureMechanism);
+                    containsWaveImpactAsphaltCoverFailureMechanism = true;
+                }
+
+                if (duneErosionFailureMechanism != null)
+                {
+                    containsDuneErosionFailureMechanism = true;
+                }
+            }
+
+            Assert.IsTrue(containsClosingStructuresFailureMechanism);
+            Assert.IsTrue(containsGrassCoverErosionInwardsFailureMechanism);
+            Assert.IsTrue(containsGrassCoverErosionOutwardsFailureMechanism);
+            Assert.IsTrue(containsHeightStructuresFailureMechanism);
+            Assert.IsTrue(containsPipingFailureMechanism);
+            Assert.IsTrue(containsStabilityPointStructuresFailureMechanism);
+            Assert.IsTrue(containsStabilityStoneCoverFailureMechanism);
+            Assert.IsTrue(containsWaveImpactAsphaltCoverFailureMechanism);
+            Assert.IsTrue(containsDuneErosionFailureMechanism);
+        }
+
+        private static void AssertFailureMechanismHasAllCalculationConfigurationsWithoutCalculationOutputs(IAssessmentSection assessmentSection)
+        {
+            bool containsClosingStructuresFailureMechanism = false;
+            bool containsGrassCoverErosionInwardsFailureMechanism = false;
+            bool containsGrassCoverErosionOutwardsFailureMechanism = false;
+            bool containsHeightStructuresFailureMechanism = false;
+            bool containsPipingFailureMechanism = false;
+            bool containsStabilityPointStructuresFailureMechanism = false;
+            bool containsStabilityStoneCoverFailureMechanism = false;
+            bool containsWaveImpactAsphaltCoverFailureMechanism = false;
+            bool containsDuneErosionFailureMechanism = false;
+
+            foreach (IFailureMechanism failureMechanism in assessmentSection.GetFailureMechanisms())
+            {
+                var closingStructuresFailureMechanism = failureMechanism as ClosingStructuresFailureMechanism;
+                var grassCoverErosionInwardsFailureMechanism = failureMechanism as GrassCoverErosionInwardsFailureMechanism;
+                var coverErosionOutwards = failureMechanism as GrassCoverErosionOutwardsFailureMechanism;
+                var heightStructuresFailureMechanism = failureMechanism as HeightStructuresFailureMechanism;
+                var pipingFailureMechanism = failureMechanism as PipingFailureMechanism;
+                var stabilityPointStructuresFailureMechanism = failureMechanism as StabilityPointStructuresFailureMechanism;
+                var stabilityStoneCoverFailureMechanism = failureMechanism as StabilityStoneCoverFailureMechanism;
+                var waveImpactAsphaltCoverFailureMechanism = failureMechanism as WaveImpactAsphaltCoverFailureMechanism;
+                var duneErosionFailureMechanism = failureMechanism as DuneErosionFailureMechanism;
+
+                if (closingStructuresFailureMechanism != null)
+                {
+                    AssertHasForeshoreProfiles(closingStructuresFailureMechanism);
+                    AssertClosingStructureFailuresMechanismCalculationsWithoutOutputs(closingStructuresFailureMechanism);
+                    containsClosingStructuresFailureMechanism = true;
+                }
+
+                if (grassCoverErosionInwardsFailureMechanism != null)
+                {
+                    AssertHasDikeProfiles(grassCoverErosionInwardsFailureMechanism);
+                    AssertGrassCoverErosionInwardsFailureMechanismCalculationConfigurationsWithoutOutputs(grassCoverErosionInwardsFailureMechanism);
+                    containsGrassCoverErosionInwardsFailureMechanism = true;
+                }
+
+                if (coverErosionOutwards != null)
+                {
+                    AssertHasForeshoreProfiles(coverErosionOutwards);
+                    AssertGrassCoverErosionOutwardsFailureMechanismCalculationConfigurationsWithoutOutputs(coverErosionOutwards);
+                    containsGrassCoverErosionOutwardsFailureMechanism = true;
+                }
+
+                if (heightStructuresFailureMechanism != null)
+                {
+                    AssertHasForeshoreProfiles(heightStructuresFailureMechanism);
+                    AssertHeightStructureFailureMechanismCalculationConfigurationsWithoutOutputs(heightStructuresFailureMechanism);
+                    containsHeightStructuresFailureMechanism = true;
+                }
+
+                if (pipingFailureMechanism != null)
+                {
+                    AssertHasStochasticSoilModels(pipingFailureMechanism);
+                    AssertHasSurfaceLines(pipingFailureMechanism);
+                    AssertPipingFailureMechanismCalculationConfigurationsWithoutOutputs(pipingFailureMechanism);
+                    containsPipingFailureMechanism = true;
+                }
+
+                if (stabilityPointStructuresFailureMechanism != null)
+                {
+                    AssertHasForeshoreProfiles(stabilityPointStructuresFailureMechanism);
+                    AssertStabilityPointStructuresFailureMechanismCalculationConfigurationsWithoutOutputs(stabilityPointStructuresFailureMechanism);
+                    containsStabilityPointStructuresFailureMechanism = true;
+                }
+
+                if (stabilityStoneCoverFailureMechanism != null)
+                {
+                    AssertHasForeshoreProfiles(stabilityStoneCoverFailureMechanism);
+                    AssertStabilityStoneCoverWaveConditionsFailureMechanismCalculationConfigurationsWithoutOutputs(stabilityStoneCoverFailureMechanism);
+                    containsStabilityStoneCoverFailureMechanism = true;
+                }
+
+                if (waveImpactAsphaltCoverFailureMechanism != null)
+                {
+                    AssertHasForeshoreProfiles(waveImpactAsphaltCoverFailureMechanism);
+                    AssertWaveImpactAsphaltCoverWaveConditionsFailureMechanismCalculationConfigurationsWithoutOutputs(waveImpactAsphaltCoverFailureMechanism);
+                    containsWaveImpactAsphaltCoverFailureMechanism = true;
+                }
+
+                if (duneErosionFailureMechanism != null)
+                {
+                    containsDuneErosionFailureMechanism = true;
+                }
+            }
+
+            Assert.IsTrue(containsClosingStructuresFailureMechanism);
+            Assert.IsTrue(containsGrassCoverErosionOutwardsFailureMechanism);
+            Assert.IsTrue(containsHeightStructuresFailureMechanism);
+            Assert.IsTrue(containsPipingFailureMechanism);
+            Assert.IsTrue(containsStabilityPointStructuresFailureMechanism);
+            Assert.IsTrue(containsStabilityStoneCoverFailureMechanism);
+            Assert.IsTrue(containsWaveImpactAsphaltCoverFailureMechanism);
+            Assert.IsTrue(containsDuneErosionFailureMechanism);
+            Assert.IsTrue(containsGrassCoverErosionInwardsFailureMechanism);
+        }
+
+        #region Piping
+
+        private static void AssertPipingFailureMechanismCalculationConfigurationsWithOutputs(PipingFailureMechanism failureMechanism)
+        {
+            IEnumerable<ICalculationBase> calculationRoot = failureMechanism.CalculationsGroup.Children;
+            AssertPipingCalculationGroupWithOutput(calculationRoot.OfType<PipingCalculation>());
+
+            CalculationGroup nestedCalculations = calculationRoot.OfType<CalculationGroup>().First();
+            AssertPipingCalculationGroupWithOutput(nestedCalculations.Children.OfType<PipingCalculation>());
+        }
+
+        private static void AssertPipingFailureMechanismCalculationConfigurationsWithoutOutputs(PipingFailureMechanism failureMechanism)
+        {
+            IEnumerable<ICalculationBase> calculationRoot = failureMechanism.CalculationsGroup.Children;
+            AssertPipingCalculationGroupWithoutOutput(calculationRoot.OfType<PipingCalculation>());
+
+            CalculationGroup nestedCalculations = calculationRoot.OfType<CalculationGroup>().First();
+            AssertPipingCalculationGroupWithoutOutput(nestedCalculations.Children.OfType<PipingCalculation>());
+        }
+
+        private static void AssertPipingCalculationGroupWithOutput(IEnumerable<PipingCalculation> children)
+        {
+            AssertCalculationConfig(children, true, true);
+        }
+
+        private static void AssertPipingCalculationGroupWithoutOutput(IEnumerable<PipingCalculation> children)
+        {
+            AssertCalculationConfig(children, false, false);
+            AssertCalculationConfig(children, true, false);
+        }
+
+        private static void AssertCalculationConfig(
+            IEnumerable<PipingCalculation> children, bool hasHydraulicBoundaryLocation, bool hasOutput)
+        {
+            Assert.NotNull(children.FirstOrDefault(calc => (calc.InputParameters.HydraulicBoundaryLocation != null) == hasHydraulicBoundaryLocation
+                                                           && calc.HasOutput == hasOutput));
+        }
+
+        private static void AssertHasStochasticSoilModels(PipingFailureMechanism failureMechanism)
+        {
+            CollectionAssert.IsNotEmpty(failureMechanism.StochasticSoilModels);
+        }
+
+        private static void AssertHasSurfaceLines(PipingFailureMechanism failureMechanism)
+        {
+            CollectionAssert.IsNotEmpty(failureMechanism.SurfaceLines);
+        }
+
+        #endregion
+
+        #region Grass Cover Erosion Inwards
+
+        private static void AssertGrassCoverErosionInwardsFailureMechanismCalculationConfigurationsWithOutputs(GrassCoverErosionInwardsFailureMechanism failureMechanism)
+        {
+            IEnumerable<ICalculationBase> calculationRoot = failureMechanism.CalculationsGroup.Children;
+            AssertGrassCoverErosionInwardsCalculationGroupWithOutput(calculationRoot.OfType<GrassCoverErosionInwardsCalculation>());
+
+            CalculationGroup nestedCalculations = calculationRoot.OfType<CalculationGroup>().First();
+            AssertGrassCoverErosionInwardsCalculationGroupWithOutput(nestedCalculations.Children.OfType<GrassCoverErosionInwardsCalculation>());
+        }
+
+        private static void AssertGrassCoverErosionInwardsFailureMechanismCalculationConfigurationsWithoutOutputs(GrassCoverErosionInwardsFailureMechanism failureMechanism)
+        {
+            IEnumerable<ICalculationBase> calculationRoot = failureMechanism.CalculationsGroup.Children;
+            AssertGrassCoverErosionInwardsCalculationGroupWithoutOutput(calculationRoot.OfType<GrassCoverErosionInwardsCalculation>());
+
+            CalculationGroup nestedCalculations = calculationRoot.OfType<CalculationGroup>().First();
+            AssertGrassCoverErosionInwardsCalculationGroupWithoutOutput(nestedCalculations.Children.OfType<GrassCoverErosionInwardsCalculation>());
+        }
+
+        private static void AssertGrassCoverErosionInwardsCalculationGroupWithOutput(IEnumerable<GrassCoverErosionInwardsCalculation> children)
+        {
+            AssertCalculationConfig(children, true, false, true);
+            AssertCalculationConfig(children, true, true, true);
+        }
+
+        private static void AssertGrassCoverErosionInwardsCalculationGroupWithoutOutput(IEnumerable<GrassCoverErosionInwardsCalculation> children)
+        {
+            AssertCalculationConfig(children, false, false, false);
+            AssertCalculationConfig(children, true, false, false);
+            AssertCalculationConfig(children, true, true, false);
+        }
+
+        private static void AssertCalculationConfig(
+            IEnumerable<GrassCoverErosionInwardsCalculation> children, bool hasHydraulicBoundaryLocation, bool hasDikeProfile, bool hasOutput)
+        {
+            Assert.NotNull(children.FirstOrDefault(calc => (calc.InputParameters.HydraulicBoundaryLocation != null) == hasHydraulicBoundaryLocation
+                                                           && (calc.InputParameters.DikeProfile != null) == hasDikeProfile
+                                                           && calc.HasOutput == hasOutput));
+        }
+
+        private static void AssertHasDikeProfiles(GrassCoverErosionInwardsFailureMechanism failureMechanism)
+        {
+            CollectionAssert.IsNotEmpty(failureMechanism.DikeProfiles);
+        }
+
+        #endregion
+
+        #region Stability Stone Cover 
+
+        private static void AssertStabilityStoneCoverWaveConditionsFailureMechanismCalculationConfigurationsWithOutputs(
+            StabilityStoneCoverFailureMechanism failureMechanism)
+        {
+            IEnumerable<ICalculationBase> calculationRoot = failureMechanism.WaveConditionsCalculationGroup.Children;
+            AssertStabilityStoneCoverWaveConditionsCalculationGroupWithOutput(
+                calculationRoot.OfType<StabilityStoneCoverWaveConditionsCalculation>());
+
+            CalculationGroup nestedCalculations = calculationRoot.OfType<CalculationGroup>().First();
+            AssertStabilityStoneCoverWaveConditionsCalculationGroupWithOutput(
+                nestedCalculations.Children.OfType<StabilityStoneCoverWaveConditionsCalculation>());
+        }
+
+        private static void AssertStabilityStoneCoverWaveConditionsFailureMechanismCalculationConfigurationsWithoutOutputs(StabilityStoneCoverFailureMechanism failureMechanism)
+        {
+            IEnumerable<ICalculationBase> calculationRoot = failureMechanism.WaveConditionsCalculationGroup.Children;
+            AssertStabilityStoneCoverWaveCalculationGroupWithoutOutput(calculationRoot.OfType<StabilityStoneCoverWaveConditionsCalculation>());
+
+            CalculationGroup nestedCalculations = calculationRoot.OfType<CalculationGroup>().First();
+            AssertStabilityStoneCoverWaveCalculationGroupWithoutOutput(nestedCalculations.Children.OfType<StabilityStoneCoverWaveConditionsCalculation>());
+        }
+
+        private static void AssertStabilityStoneCoverWaveConditionsCalculationGroupWithOutput(IEnumerable<StabilityStoneCoverWaveConditionsCalculation> children)
+        {
+            AssertCalculationConfig(children, true, false, true);
+            AssertCalculationConfig(children, true, true, true);
+        }
+
+        private static void AssertStabilityStoneCoverWaveCalculationGroupWithoutOutput(IEnumerable<StabilityStoneCoverWaveConditionsCalculation> children)
+        {
+            AssertCalculationConfig(children, false, false, false);
+            AssertCalculationConfig(children, true, false, false);
+            AssertCalculationConfig(children, true, true, false);
+        }
+
+        private static void AssertCalculationConfig(
+            IEnumerable<StabilityStoneCoverWaveConditionsCalculation> children, bool hasHydraulicBoundaryLocation, bool hasDikeProfile, bool hasOutput)
+        {
+            Assert.NotNull(children.FirstOrDefault(calc => (calc.InputParameters.HydraulicBoundaryLocation != null) == hasHydraulicBoundaryLocation
+                                                           && (calc.InputParameters.ForeshoreProfile != null) == hasDikeProfile
+                                                           && calc.HasOutput == hasOutput));
+        }
+
+        private static void AssertHasForeshoreProfiles(StabilityStoneCoverFailureMechanism failureMechanism)
+        {
+            CollectionAssert.IsNotEmpty(failureMechanism.ForeshoreProfiles);
+        }
+
+        #endregion
+
+        #region Wave Impact Asphalt Cover
+
+        private static void AssertWaveImpactAsphaltCoverWaveConditionsFailureMechanismCalculationConfigurationsWithOutputs(
+            WaveImpactAsphaltCoverFailureMechanism failureMechanism)
+        {
+            IEnumerable<ICalculationBase> calculationRoot = failureMechanism.WaveConditionsCalculationGroup.Children;
+            AssertWaveImpactAsphaltCoverWaveConditionsCalculationGroupWithOutput(
+                calculationRoot.OfType<WaveImpactAsphaltCoverWaveConditionsCalculation>());
+
+            CalculationGroup nestedCalculations = calculationRoot.OfType<CalculationGroup>().First();
+            AssertWaveImpactAsphaltCoverWaveConditionsCalculationGroupWithOutput(
+                nestedCalculations.Children.OfType<WaveImpactAsphaltCoverWaveConditionsCalculation>());
+        }
+
+        private static void AssertWaveImpactAsphaltCoverWaveConditionsFailureMechanismCalculationConfigurationsWithoutOutputs(
+            WaveImpactAsphaltCoverFailureMechanism failureMechanism)
+        {
+            IEnumerable<ICalculationBase> calculationRoot = failureMechanism.WaveConditionsCalculationGroup.Children;
+            AssertWaveImpactAsphaltCoverWaveCalculationGroupWithoutOutput(calculationRoot.OfType<WaveImpactAsphaltCoverWaveConditionsCalculation>());
+
+            CalculationGroup nestedCalculations = calculationRoot.OfType<CalculationGroup>().First();
+            AssertWaveImpactAsphaltCoverWaveCalculationGroupWithoutOutput(nestedCalculations.Children.OfType<WaveImpactAsphaltCoverWaveConditionsCalculation>());
+        }
+
+        private static void AssertWaveImpactAsphaltCoverWaveConditionsCalculationGroupWithOutput(IEnumerable<WaveImpactAsphaltCoverWaveConditionsCalculation> children)
+        {
+            AssertCalculationConfig(children, true, false, true);
+            AssertCalculationConfig(children, true, true, true);
+        }
+
+        private static void AssertWaveImpactAsphaltCoverWaveCalculationGroupWithoutOutput(IEnumerable<WaveImpactAsphaltCoverWaveConditionsCalculation> children)
+        {
+            AssertCalculationConfig(children, false, false, false);
+            AssertCalculationConfig(children, true, false, false);
+            AssertCalculationConfig(children, true, true, false);
+        }
+
+        private static void AssertCalculationConfig(
+            IEnumerable<WaveImpactAsphaltCoverWaveConditionsCalculation> children, bool hasHydraulicBoundaryLocation, bool hasDikeProfile, bool hasOutput)
+        {
+            Assert.NotNull(children.FirstOrDefault(calc => (calc.InputParameters.HydraulicBoundaryLocation != null) == hasHydraulicBoundaryLocation
+                                                           && (calc.InputParameters.ForeshoreProfile != null) == hasDikeProfile
+                                                           && calc.HasOutput == hasOutput));
+        }
+
+        private static void AssertHasForeshoreProfiles(WaveImpactAsphaltCoverFailureMechanism failureMechanism)
+        {
+            CollectionAssert.IsNotEmpty(failureMechanism.ForeshoreProfiles);
+        }
+
+        #endregion
+
+        #region Grass Cover Erosion Outwards
+
+        private static void AssertGrassCoverErosionOutwardsFailureMechanismCalculationConfigurationsWithOutputs(GrassCoverErosionOutwardsFailureMechanism failureMechanism)
+        {
+            IEnumerable<ICalculationBase> calculationRoot = failureMechanism.WaveConditionsCalculationGroup.Children;
+            AssertGrassCoverErosionCalculationGroupWithOutput(calculationRoot.OfType<GrassCoverErosionOutwardsWaveConditionsCalculation>());
+
+            CalculationGroup nestedCalculations = calculationRoot.OfType<CalculationGroup>().First();
+            AssertGrassCoverErosionCalculationGroupWithOutput(nestedCalculations.Children.OfType<GrassCoverErosionOutwardsWaveConditionsCalculation>());
+        }
+
+        private static void AssertGrassCoverErosionOutwardsFailureMechanismCalculationConfigurationsWithoutOutputs(GrassCoverErosionOutwardsFailureMechanism failureMechanism)
+        {
+            IEnumerable<ICalculationBase> calculationRoot = failureMechanism.WaveConditionsCalculationGroup.Children;
+            AssertGrassCoverErosionCalculationGroupWithoutOutput(calculationRoot.OfType<GrassCoverErosionOutwardsWaveConditionsCalculation>());
+
+            CalculationGroup nestedCalculations = calculationRoot.OfType<CalculationGroup>().First();
+            AssertGrassCoverErosionCalculationGroupWithoutOutput(nestedCalculations.Children.OfType<GrassCoverErosionOutwardsWaveConditionsCalculation>());
+        }
+
+        private static void AssertGrassCoverErosionCalculationGroupWithOutput(IEnumerable<GrassCoverErosionOutwardsWaveConditionsCalculation> children)
+        {
+            AssertCalculationConfig(children, true, false, true);
+            AssertCalculationConfig(children, true, true, true);
+        }
+
+        private static void AssertGrassCoverErosionCalculationGroupWithoutOutput(IEnumerable<GrassCoverErosionOutwardsWaveConditionsCalculation> children)
+        {
+            AssertCalculationConfig(children, false, false, false);
+            AssertCalculationConfig(children, true, false, false);
+            AssertCalculationConfig(children, true, true, false);
+        }
+
+        private static void AssertCalculationConfig(
+            IEnumerable<GrassCoverErosionOutwardsWaveConditionsCalculation> children, bool hasHydraulicBoundaryLocation, bool hasDikeProfile, bool hasOutput)
+        {
+            Assert.NotNull(children.FirstOrDefault(calc => (calc.InputParameters.HydraulicBoundaryLocation != null) == hasHydraulicBoundaryLocation
+                                                           && (calc.InputParameters.ForeshoreProfile != null) == hasDikeProfile
+                                                           && calc.HasOutput == hasOutput));
+        }
+
+        private static void AssertHasForeshoreProfiles(GrassCoverErosionOutwardsFailureMechanism failureMechanism)
+        {
+            CollectionAssert.IsNotEmpty(failureMechanism.ForeshoreProfiles);
+        }
+
+        #endregion
+
+        #region Dune Erosion
+
+        private static void AssertDuneErosionFailureMechanismCalculationConfigurationsWithOutputs(DuneErosionFailureMechanism failureMechanism)
+        {
+            Assert.True(failureMechanism.DuneLocations.Any(dl => dl.Output != null));
+        }
+
+        private static void AssertDuneErosionFailureMechanismCalculationConfigurationsWithoutOutputs(DuneErosionFailureMechanism failureMechanism)
+        {
+            Assert.True(failureMechanism.DuneLocations.Any(dl => dl.Output == null));
+        }
+
+        #endregion
+
+        #region Structures
+
+        #region ClosingStructures
+
+        private static void AssertClosingStructureFailuresMechanismCalculationsWithOutputs(ClosingStructuresFailureMechanism failureMechanism)
+        {
+            IEnumerable<ICalculationBase> calculationsRoot = failureMechanism.CalculationsGroup.Children;
+            AssertStructuresCalculationGroupConfigurationWithOutputs<ClosingStructure, ClosingStructuresInput>(
+                calculationsRoot.OfType<StructuresCalculation<ClosingStructuresInput>>());
+
+            CalculationGroup nestedCalculations = calculationsRoot.OfType<CalculationGroup>().First();
+            AssertStructuresCalculationGroupConfigurationWithOutputs<ClosingStructure, ClosingStructuresInput>(
+                nestedCalculations.Children.OfType<StructuresCalculation<ClosingStructuresInput>>());
+        }
+
+        private static void AssertClosingStructureFailuresMechanismCalculationsWithoutOutputs(ClosingStructuresFailureMechanism failureMechanism)
+        {
+            IEnumerable<ICalculationBase> calculationsRoot = failureMechanism.CalculationsGroup.Children;
+            AssertStructuresCalculationGroupConfigurationWithoutOutputs<ClosingStructure, ClosingStructuresInput>(
+                calculationsRoot.OfType<StructuresCalculation<ClosingStructuresInput>>());
+
+            CalculationGroup nestedCalculations = calculationsRoot.OfType<CalculationGroup>().First();
+            AssertStructuresCalculationGroupConfigurationWithoutOutputs<ClosingStructure, ClosingStructuresInput>(
+                nestedCalculations.Children.OfType<StructuresCalculation<ClosingStructuresInput>>());
+        }
+
+        private static void AssertHasForeshoreProfiles(ClosingStructuresFailureMechanism failureMechanism)
+        {
+            CollectionAssert.IsNotEmpty(failureMechanism.ForeshoreProfiles);
+        }
+
+        #endregion
+
+        #region StabilityPointStructures
+
+        private static void AssertStabilityPointStructuresFailureMechanismCalculationConfigurationsWithOutputs(StabilityPointStructuresFailureMechanism failureMechanism)
+        {
+            IEnumerable<ICalculationBase> calculationsRoot = failureMechanism.CalculationsGroup.Children;
+            AssertStructuresCalculationGroupConfigurationWithOutputs<StabilityPointStructure, StabilityPointStructuresInput>(
+                calculationsRoot.OfType<StructuresCalculation<StabilityPointStructuresInput>>());
+
+            CalculationGroup nestedCalculations = calculationsRoot.OfType<CalculationGroup>().First();
+            AssertStructuresCalculationGroupConfigurationWithOutputs<StabilityPointStructure, StabilityPointStructuresInput>(
+                nestedCalculations.Children.OfType<StructuresCalculation<StabilityPointStructuresInput>>());
+        }
+
+        private static void AssertStabilityPointStructuresFailureMechanismCalculationConfigurationsWithoutOutputs(StabilityPointStructuresFailureMechanism failureMechanism)
+        {
+            IEnumerable<ICalculationBase> calculationsRoot = failureMechanism.CalculationsGroup.Children;
+            AssertStructuresCalculationGroupConfigurationWithoutOutputs<StabilityPointStructure, StabilityPointStructuresInput>(
+                calculationsRoot.OfType<StructuresCalculation<StabilityPointStructuresInput>>());
+
+            CalculationGroup nestedCalculations = calculationsRoot.OfType<CalculationGroup>().First();
+            AssertStructuresCalculationGroupConfigurationWithoutOutputs<StabilityPointStructure, StabilityPointStructuresInput>(
+                nestedCalculations.Children.OfType<StructuresCalculation<StabilityPointStructuresInput>>());
+        }
+
+        private static void AssertHasForeshoreProfiles(StabilityPointStructuresFailureMechanism failureMechanism)
+        {
+            CollectionAssert.IsNotEmpty(failureMechanism.ForeshoreProfiles);
+        }
+
+        #endregion
+
+        #region HeightStructures
+
+        private static void AssertHeightStructureFailureMechanismCalculationConfigurationsWithOutputs(HeightStructuresFailureMechanism failureMechanism)
+        {
+            IEnumerable<ICalculationBase> calculationsRoot = failureMechanism.CalculationsGroup.Children;
+            AssertStructuresCalculationGroupConfigurationWithOutputs<HeightStructure, HeightStructuresInput>(
+                calculationsRoot.OfType<StructuresCalculation<HeightStructuresInput>>());
+
+            CalculationGroup nestedCalculations = calculationsRoot.OfType<CalculationGroup>().First();
+            AssertStructuresCalculationGroupConfigurationWithOutputs<HeightStructure, HeightStructuresInput>(
+                nestedCalculations.Children.OfType<StructuresCalculation<HeightStructuresInput>>());
+        }
+
+        private static void AssertHeightStructureFailureMechanismCalculationConfigurationsWithoutOutputs(HeightStructuresFailureMechanism failureMechanism)
+        {
+            IEnumerable<ICalculationBase> calculationsRoot = failureMechanism.CalculationsGroup.Children;
+            AssertStructuresCalculationGroupConfigurationWithoutOutputs<HeightStructure, HeightStructuresInput>(
+                calculationsRoot.OfType<StructuresCalculation<HeightStructuresInput>>());
+
+            CalculationGroup nestedCalculations = calculationsRoot.OfType<CalculationGroup>().First();
+            AssertStructuresCalculationGroupConfigurationWithoutOutputs<HeightStructure, HeightStructuresInput>(
+                nestedCalculations.Children.OfType<StructuresCalculation<HeightStructuresInput>>());
+        }
+
+        private static void AssertHasForeshoreProfiles(HeightStructuresFailureMechanism failureMechanism)
+        {
+            CollectionAssert.IsNotEmpty(failureMechanism.ForeshoreProfiles);
+        }
+
+        #endregion
+
+        private static void AssertStructuresCalculationGroupConfigurationWithOutputs<TStructureBase, TCalculationInput>(
+            IEnumerable<StructuresCalculation<TCalculationInput>> children)
+            where TStructureBase : StructureBase
+            where TCalculationInput : StructuresInputBase<TStructureBase>, new()
+        {
+            AssertCalculationConfig<TStructureBase, TCalculationInput>(children, true, false, true);
+            AssertCalculationConfig<TStructureBase, TCalculationInput>(children, true, true, true);
+        }
+
+        private static void AssertStructuresCalculationGroupConfigurationWithoutOutputs<TStructureBase, TCalculationInput>(
+            IEnumerable<StructuresCalculation<TCalculationInput>> children)
+            where TStructureBase : StructureBase
+            where TCalculationInput : StructuresInputBase<TStructureBase>, new()
+        {
+            AssertCalculationConfig<TStructureBase, TCalculationInput>(children, false, false, false);
+            AssertCalculationConfig<TStructureBase, TCalculationInput>(children, true, false, false);
+            AssertCalculationConfig<TStructureBase, TCalculationInput>(children, true, true, false);
+        }
+
+        private static void AssertCalculationConfig<TStructureBase, TCalculationInput>(
+            IEnumerable<StructuresCalculation<TCalculationInput>> children, bool hasHydraulicBoundaryLocation, bool hasDikeProfile, bool hasOutput)
+            where TStructureBase : StructureBase
+            where TCalculationInput : StructuresInputBase<TStructureBase>, new()
+        {
+            Assert.NotNull(children.FirstOrDefault(calc => (calc.InputParameters.HydraulicBoundaryLocation != null) == hasHydraulicBoundaryLocation
+                                                           && (calc.InputParameters.ForeshoreProfile != null) == hasDikeProfile
+                                                           && calc.HasOutput == hasOutput));
+        }
+
+        #endregion
+    }
+}
\ No newline at end of file
Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtils.Test/packages.config
===================================================================
diff -u
--- Ringtoets/Integration/test/Ringtoets.Integration.TestUtils.Test/packages.config	(revision 0)
+++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtils.Test/packages.config	(revision 78cc5b59d47ca61eb812d0c69c7a17a4570e4ddc)
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+Copyright (C) Stichting Deltares 2016. 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
Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/Ringtoets.Integration.TestUtils.csproj
===================================================================
diff -u -ra59b471e3b6a02319f91b7317b3814a099ef0221 -r78cc5b59d47ca61eb812d0c69c7a17a4570e4ddc
--- Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/Ringtoets.Integration.TestUtils.csproj	(.../Ringtoets.Integration.TestUtils.csproj)	(revision a59b471e3b6a02319f91b7317b3814a099ef0221)
+++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/Ringtoets.Integration.TestUtils.csproj	(.../Ringtoets.Integration.TestUtils.csproj)	(revision 78cc5b59d47ca61eb812d0c69c7a17a4570e4ddc)
@@ -171,6 +171,10 @@
       <Project>{c8383b76-b3f1-4e6e-b56c-527b469fa20a}</Project>
       <Name>Ringtoets.Integration.Plugin</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\src\Ringtoets.Integration.Service\Ringtoets.Integration.Service.csproj">
+      <Project>{28811c4a-6c18-42c1-88b2-a03a3784e2d0}</Project>
+      <Name>Ringtoets.Integration.Service</Name>
+    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="Properties\Resources.resx">
Index: Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/TestDataGenerator.cs
===================================================================
diff -u -r4bd863e75942710beedfe1ea7c2c5a097b46497f -r78cc5b59d47ca61eb812d0c69c7a17a4570e4ddc
--- Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/TestDataGenerator.cs	(.../TestDataGenerator.cs)	(revision 4bd863e75942710beedfe1ea7c2c5a097b46497f)
+++ Ringtoets/Integration/test/Ringtoets.Integration.TestUtils/TestDataGenerator.cs	(.../TestDataGenerator.cs)	(revision 78cc5b59d47ca61eb812d0c69c7a17a4570e4ddc)
@@ -35,6 +35,7 @@
 using Ringtoets.GrassCoverErosionOutwards.Data;
 using Ringtoets.HeightStructures.Data;
 using Ringtoets.Integration.Data;
+using Ringtoets.Integration.Service;
 using Ringtoets.Piping.Integration.TestUtils;
 using Ringtoets.Revetment.Data;
 using Ringtoets.StabilityPointStructures.Data;
@@ -49,20 +50,22 @@
     public static class TestDataGenerator
     {
         /// <summary>
-        /// Gets a fully configured <see cref="AssessmentSection"/>.
+        /// Gets a fully configured <see cref="AssessmentSection"/> with all possible configurations for the 
+        /// parent and nested calculations of the failure mechanisms.
         /// </summary>
         /// <returns>A fully configured <see cref="AssessmentSection"/>.</returns>
-        public static AssessmentSection GetFullyConfiguredAssessmentSection()
+        public static AssessmentSection GetAssessmentSectionWithAllCalculationConfigurations()
         {
-            return GetFullyConfiguredAssessmentSection(AssessmentSectionComposition.Dike);
+            return GetAssessmentSectionWithAllCalculationConfigurations(AssessmentSectionComposition.Dike);
         }
 
         /// <summary>
-        /// Gets a fully configured <see cref="AssessmentSection"/> with a desired <see cref="AssessmentSectionComposition"/>.
+        /// Gets a fully configured <see cref="AssessmentSection"/> with a desired <see cref="AssessmentSectionComposition"/>
+        /// and with all possible configurations for the parent and nested calculations of the failure mechanisms.
         /// </summary>
         /// <param name="composition">The desired <see cref="AssessmentSectionComposition"/> to initialize the <see cref="AssessmentSection"/> with.</param>
         /// <returns>A fully configured <see cref="AssessmentSection"/>.</returns>
-        public static AssessmentSection GetFullyConfiguredAssessmentSection(AssessmentSectionComposition composition)
+        public static AssessmentSection GetAssessmentSectionWithAllCalculationConfigurations(AssessmentSectionComposition composition)
         {
             var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, string.Empty, 0, 0)
             {
@@ -98,6 +101,37 @@
         }
 
         /// <summary>
+        /// Gets a fully configured <see cref="AssessmentSection"/> with a desired <see cref="AssessmentSectionComposition"/> and 
+        /// possible configurations of the parent and nested calculations, but without the output of the 
+        /// <see cref="HydraulicBoundaryLocation.DesignWaterLevel"/>,  <see cref="HydraulicBoundaryLocation.WaveHeightOutput"/> 
+        /// and <see cref="DuneLocation.Output"/>
+        /// </summary>
+        /// <param name="composition">The desired <see cref="AssessmentSectionComposition"/> to initialize the <see cref="AssessmentSection"/> with.</param>
+        /// <returns>A fully configured <see cref="AssessmentSection"/> without the output of the <see cref="HydraulicBoundaryLocation"/> and the 
+        /// <see cref="DuneLocation"/>.</returns>
+        public static AssessmentSection GetAssessmentSectionWithAllCalculationConfigurationsWithoutHydraulicBoundaryLocationAndDuneOutput(AssessmentSectionComposition composition)
+        {
+            AssessmentSection assessmentSection = GetAssessmentSectionWithAllCalculationConfigurations(composition);
+            RingtoetsDataSynchronizationService.ClearHydraulicBoundaryLocationOutput(assessmentSection.HydraulicBoundaryDatabase, assessmentSection);
+
+            return assessmentSection;
+        }
+
+        /// <summary>
+        /// Gets a fully configured <see cref="AssessmentSection"/> with a desired <see cref="AssessmentSectionComposition"/> and 
+        /// possible configurations of the parent and nested calculations, but without the calculation outputs.
+        /// </summary>
+        /// <param name="composition">The desired <see cref="AssessmentSectionComposition"/> to initiailize the <see cref="AssessmentSection"/> with.</param>
+        /// <returns>A fully configured <see cref="AssessmentSection"/>, but without the calculation output.</returns>
+        public static AssessmentSection GetAssessmentSectionWithAllCalculationConfigurationsWithoutCalculationOutput(AssessmentSectionComposition composition)
+        {
+            AssessmentSection assessmentSection = GetAssessmentSectionWithAllCalculationConfigurations(composition);
+            RingtoetsDataSynchronizationService.ClearFailureMechanismCalculationOutputs(assessmentSection);
+
+            return assessmentSection;
+        }
+
+        /// <summary>
         /// Gets a fully configured <see cref="StabilityStoneCoverFailureMechanism"/>.
         /// </summary>
         public static StabilityStoneCoverFailureMechanism GetFullyConfiguredStabilityStoneCoverFailureMechanism()
@@ -235,7 +269,7 @@
             failureMechanism.DikeProfiles.Add(dikeprofile2);
 
             var calculation = new GrassCoverErosionInwardsCalculation();
-            var calculationWithOutput = new GrassCoverErosionInwardsCalculation
+            var calculationWithOutputAndDikeProfileAndHydraulicBoundaryLocation = new GrassCoverErosionInwardsCalculation
             {
                 InputParameters =
                 {
@@ -250,7 +284,6 @@
                 InputParameters =
                 {
                     HydraulicBoundaryLocation = hydraulicBoundaryLocation,
-                    DikeProfile = dikeprofile2
                 },
                 Output = new GrassCoverErosionInwardsOutput(0, false, new ProbabilityAssessmentOutput(0, 0, 0, 0, 0),
                                                             new DikeHeightAssessmentOutput(0, 0, 0, 0, 0, CalculationConvergence.CalculatedConverged))
@@ -262,9 +295,17 @@
                     HydraulicBoundaryLocation = hydraulicBoundaryLocation
                 }
             };
+            var calculationWitDikeProfileAndHydraulicBoundaryLocation = new GrassCoverErosionInwardsCalculation
+            {
+                InputParameters =
+                {
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
+                    DikeProfile = dikeprofile2
+                }
+            };
 
             var subCalculation = new GrassCoverErosionInwardsCalculation();
-            var subCalculationWithOutput = new GrassCoverErosionInwardsCalculation
+            var subCalculationWithOutputAndDikeProfileAndHydraulicBoundaryLocation = new GrassCoverErosionInwardsCalculation
             {
                 InputParameters =
                 {
@@ -279,7 +320,6 @@
                 InputParameters =
                 {
                     HydraulicBoundaryLocation = hydraulicBoundaryLocation,
-                    DikeProfile = dikeprofile1
                 },
                 Output = new GrassCoverErosionInwardsOutput(0, false, new ProbabilityAssessmentOutput(0, 0, 0, 0, 0),
                                                             new DikeHeightAssessmentOutput(0, 0, 0, 0, 0, CalculationConvergence.CalculatedConverged))
@@ -291,19 +331,29 @@
                     HydraulicBoundaryLocation = hydraulicBoundaryLocation
                 }
             };
+            var subCalculationWitDikeProfileAndHydraulicBoundaryLocation = new GrassCoverErosionInwardsCalculation
+            {
+                InputParameters =
+                {
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
+                    DikeProfile = dikeprofile2
+                }
+            };
 
             failureMechanism.CalculationsGroup.Children.Add(calculation);
-            failureMechanism.CalculationsGroup.Children.Add(calculationWithOutput);
+            failureMechanism.CalculationsGroup.Children.Add(calculationWithOutputAndDikeProfileAndHydraulicBoundaryLocation);
             failureMechanism.CalculationsGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocation);
             failureMechanism.CalculationsGroup.Children.Add(calculationWithHydraulicBoundaryLocation);
+            failureMechanism.CalculationsGroup.Children.Add(calculationWitDikeProfileAndHydraulicBoundaryLocation);
             failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup
             {
                 Children =
                 {
                     subCalculation,
-                    subCalculationWithOutput,
+                    subCalculationWithOutputAndDikeProfileAndHydraulicBoundaryLocation,
                     subCalculationWithOutputAndHydraulicBoundaryLocation,
-                    subCalculationWithHydraulicBoundaryLocation
+                    subCalculationWithHydraulicBoundaryLocation,
+                    subCalculationWitDikeProfileAndHydraulicBoundaryLocation
                 }
             });
 
@@ -322,8 +372,8 @@
             failureMechanism.AddSection(section1);
             failureMechanism.AddSection(section2);
 
-            failureMechanism.SectionResults.ElementAt(0).Calculation = calculationWithOutput;
-            failureMechanism.SectionResults.ElementAt(1).Calculation = subCalculationWithOutput;
+            failureMechanism.SectionResults.ElementAt(0).Calculation = calculationWithOutputAndDikeProfileAndHydraulicBoundaryLocation;
+            failureMechanism.SectionResults.ElementAt(1).Calculation = subCalculationWithOutputAndDikeProfileAndHydraulicBoundaryLocation;
         }
 
         private static void SetFullyConfiguredFailureMechanism(HeightStructuresFailureMechanism failureMechanism,
@@ -434,24 +484,23 @@
             where TCalculationInput : StructuresInputBase<TStructureBase>, new()
         {
             var calculation = new StructuresCalculation<TCalculationInput>();
-            var calculationWithOutput = new StructuresCalculation<TCalculationInput>
+            var calculationWithOutputAndHydraulicBoundaryLocation = new StructuresCalculation<TCalculationInput>
             {
                 InputParameters =
                 {
-                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
-                    ForeshoreProfile = profile1
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation
                 },
                 Output = new ProbabilityAssessmentOutput(0, 0, 0, 0, 0)
             };
-            var calculationWithForeshoreProfile = new StructuresCalculation<TCalculationInput>
+            var calculationWithHydraulicBoundaryLocationAndForeshoreProfile = new StructuresCalculation<TCalculationInput>
             {
                 InputParameters =
                 {
                     HydraulicBoundaryLocation = hydraulicBoundaryLocation,
                     ForeshoreProfile = profile1
                 }
             };
-            var calculationWithOutputAndHydraulicBoundaryLocation = new StructuresCalculation<TCalculationInput>
+            var calculationWithOutputAndHydraulicBoundaryLocationAndForeshoreProfiles = new StructuresCalculation<TCalculationInput>
             {
                 InputParameters =
                 {
@@ -469,21 +518,20 @@
             };
 
             var subCalculation = new StructuresCalculation<TCalculationInput>();
-            var subCalculationWithOutput = new StructuresCalculation<TCalculationInput>
+            var subCalculationWithOutputAndHydraulicBoundaryLocation = new StructuresCalculation<TCalculationInput>
             {
                 InputParameters =
                 {
                     HydraulicBoundaryLocation = hydraulicBoundaryLocation,
-                    ForeshoreProfile = profile2
                 },
                 Output = new ProbabilityAssessmentOutput(0, 0, 0, 0, 0)
             };
-            var subCalculationWithOutputAndHydraulicBoundaryLocation = new StructuresCalculation<TCalculationInput>
+            var subCalculationWithOutputAndHydraulicBoundaryLocationAndForeshoreProfile = new StructuresCalculation<TCalculationInput>
             {
                 InputParameters =
                 {
                     HydraulicBoundaryLocation = hydraulicBoundaryLocation,
-                    ForeshoreProfile = profile1
+                    ForeshoreProfile = profile2
                 },
                 Output = new ProbabilityAssessmentOutput(0, 0, 0, 0, 0)
             };
@@ -494,20 +542,29 @@
                     HydraulicBoundaryLocation = hydraulicBoundaryLocation
                 }
             };
+            var subCalculationWithHydraulicBoundaryLocationAndForeshoreProfile = new StructuresCalculation<TCalculationInput>
+            {
+                InputParameters =
+                {
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
+                    ForeshoreProfile = profile1
+                }
+            };
 
             failureMechanism.CalculationsGroup.Children.Add(calculation);
-            failureMechanism.CalculationsGroup.Children.Add(calculationWithOutput);
-            failureMechanism.CalculationsGroup.Children.Add(calculationWithForeshoreProfile);
             failureMechanism.CalculationsGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocation);
+            failureMechanism.CalculationsGroup.Children.Add(calculationWithHydraulicBoundaryLocationAndForeshoreProfile);
+            failureMechanism.CalculationsGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocationAndForeshoreProfiles);
             failureMechanism.CalculationsGroup.Children.Add(calculationWithHydraulicBoundaryLocation);
             failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup
             {
                 Children =
                 {
                     subCalculation,
-                    subCalculationWithOutput,
                     subCalculationWithOutputAndHydraulicBoundaryLocation,
-                    subCalculationWithHydraulicBoundaryLocation
+                    subCalculationWithOutputAndHydraulicBoundaryLocationAndForeshoreProfile,
+                    subCalculationWithHydraulicBoundaryLocation,
+                    subCalculationWithHydraulicBoundaryLocationAndForeshoreProfile
                 }
             });
         }
@@ -542,14 +599,12 @@
 
             failureMechanism.ForeshoreProfiles.Add(profile1);
             failureMechanism.ForeshoreProfiles.Add(profile2);
-
             var calculation = new StabilityStoneCoverWaveConditionsCalculation();
-            var calculationWithOutput = new StabilityStoneCoverWaveConditionsCalculation
+            var calculationWithOutputAndHydraulicBoundaryLocation = new StabilityStoneCoverWaveConditionsCalculation
             {
                 InputParameters =
                 {
                     HydraulicBoundaryLocation = hydraulicBoundaryLocation,
-                    ForeshoreProfile = profile1
                 },
                 Output = new StabilityStoneCoverWaveConditionsOutput(Enumerable.Empty<WaveConditionsOutput>(),
                                                                      Enumerable.Empty<WaveConditionsOutput>())
@@ -562,7 +617,7 @@
                     ForeshoreProfile = profile1
                 }
             };
-            var calculationWithOutputAndHydraulicBoundaryLocation = new StabilityStoneCoverWaveConditionsCalculation
+            var calculationWithOutputAndHydraulicBoundaryLocationAndForeshoreProfile = new StabilityStoneCoverWaveConditionsCalculation
             {
                 InputParameters =
                 {
@@ -581,7 +636,7 @@
             };
 
             var subCalculation = new StabilityStoneCoverWaveConditionsCalculation();
-            var subCalculationWithOutput = new StabilityStoneCoverWaveConditionsCalculation
+            var subCalculationWithOutputAndHydraulicBoundarLocationAndForeshoreProfile = new StabilityStoneCoverWaveConditionsCalculation
             {
                 InputParameters =
                 {
@@ -596,7 +651,6 @@
                 InputParameters =
                 {
                     HydraulicBoundaryLocation = hydraulicBoundaryLocation,
-                    ForeshoreProfile = profile1
                 },
                 Output = new StabilityStoneCoverWaveConditionsOutput(Enumerable.Empty<WaveConditionsOutput>(),
                                                                      Enumerable.Empty<WaveConditionsOutput>())
@@ -608,20 +662,29 @@
                     HydraulicBoundaryLocation = hydraulicBoundaryLocation
                 }
             };
+            var subCalculationWithHydraulicBoundaryLocationAndForeshoreProfile = new StabilityStoneCoverWaveConditionsCalculation
+            {
+                InputParameters =
+                {
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
+                    ForeshoreProfile = profile2
+                }
+            };
 
             failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculation);
-            failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithOutput);
-            failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithForeshoreProfile);
             failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocation);
+            failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithForeshoreProfile);
+            failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocationAndForeshoreProfile);
             failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithHydraulicBoundaryLocation);
             failureMechanism.WaveConditionsCalculationGroup.Children.Add(new CalculationGroup
             {
                 Children =
                 {
                     subCalculation,
-                    subCalculationWithOutput,
+                    subCalculationWithOutputAndHydraulicBoundarLocationAndForeshoreProfile,
                     subCalculationWithOutputAndHydraulicBoundaryLocation,
-                    subCalculationWithHydraulicBoundaryLocation
+                    subCalculationWithHydraulicBoundaryLocation,
+                    subCalculationWithHydraulicBoundaryLocationAndForeshoreProfile
                 }
             });
         }
@@ -658,12 +721,11 @@
             failureMechanism.ForeshoreProfiles.Add(profile2);
 
             var calculation = new WaveImpactAsphaltCoverWaveConditionsCalculation();
-            var calculationWithOutput = new WaveImpactAsphaltCoverWaveConditionsCalculation
+            var calculationWithOutputAndHydraulicBoundaryLocation = new WaveImpactAsphaltCoverWaveConditionsCalculation
             {
                 InputParameters =
                 {
                     HydraulicBoundaryLocation = hydraulicBoundaryLocation,
-                    ForeshoreProfile = profile1
                 },
                 Output = new WaveImpactAsphaltCoverWaveConditionsOutput(Enumerable.Empty<WaveConditionsOutput>())
             };
@@ -675,7 +737,7 @@
                     ForeshoreProfile = profile1
                 }
             };
-            var calculationWithOutputAndHydraulicBoundaryLocation = new WaveImpactAsphaltCoverWaveConditionsCalculation
+            var calculationWithOutputAndHydraulicBoundaryLocationAndForeshoreProfile = new WaveImpactAsphaltCoverWaveConditionsCalculation
             {
                 InputParameters =
                 {
@@ -693,7 +755,7 @@
             };
 
             var subCalculation = new WaveImpactAsphaltCoverWaveConditionsCalculation();
-            var subCalculationWithOutput = new WaveImpactAsphaltCoverWaveConditionsCalculation
+            var subCalculationWithOutputAndHydraulicBoundarLocationAndForeshoreProfile = new WaveImpactAsphaltCoverWaveConditionsCalculation
             {
                 InputParameters =
                 {
@@ -707,7 +769,6 @@
                 InputParameters =
                 {
                     HydraulicBoundaryLocation = hydraulicBoundaryLocation,
-                    ForeshoreProfile = profile1
                 },
                 Output = new WaveImpactAsphaltCoverWaveConditionsOutput(Enumerable.Empty<WaveConditionsOutput>())
             };
@@ -718,20 +779,29 @@
                     HydraulicBoundaryLocation = hydraulicBoundaryLocation
                 }
             };
+            var subCalculationWithHydraulicBoundaryLocationAndForeshoreProfile = new WaveImpactAsphaltCoverWaveConditionsCalculation
+            {
+                InputParameters =
+                {
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
+                    ForeshoreProfile = profile2
+                }
+            };
 
             failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculation);
-            failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithOutput);
-            failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithForeshoreProfile);
             failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocation);
+            failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithForeshoreProfile);
+            failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocationAndForeshoreProfile);
             failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithHydraulicBoundaryLocation);
             failureMechanism.WaveConditionsCalculationGroup.Children.Add(new CalculationGroup
             {
                 Children =
                 {
                     subCalculation,
-                    subCalculationWithOutput,
+                    subCalculationWithOutputAndHydraulicBoundarLocationAndForeshoreProfile,
                     subCalculationWithOutputAndHydraulicBoundaryLocation,
-                    subCalculationWithHydraulicBoundaryLocation
+                    subCalculationWithHydraulicBoundaryLocation,
+                    subCalculationWithHydraulicBoundaryLocationAndForeshoreProfile
                 }
             });
         }
@@ -781,28 +851,27 @@
             failureMechanism.ForeshoreProfiles.Add(profile2);
 
             var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation();
-            var calculationWithOutput = new GrassCoverErosionOutwardsWaveConditionsCalculation
+            var calculationWithOutputAndHydraulicBoundaryLocation = new GrassCoverErosionOutwardsWaveConditionsCalculation
             {
                 InputParameters =
                 {
-                    HydraulicBoundaryLocation = internalHydroLocation,
-                    ForeshoreProfile = profile1
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
                 },
                 Output = new GrassCoverErosionOutwardsWaveConditionsOutput(Enumerable.Empty<WaveConditionsOutput>())
             };
-            var calculationWithForeshoreProfile = new GrassCoverErosionOutwardsWaveConditionsCalculation
+            var calculationWitHydraulicBoundaryLocationAndhForeshoreProfile = new GrassCoverErosionOutwardsWaveConditionsCalculation
             {
                 InputParameters =
                 {
-                    HydraulicBoundaryLocation = internalHydroLocation,
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
                     ForeshoreProfile = profile1
                 }
             };
-            var calculationWithOutputAndHydraulicBoundaryLocation = new GrassCoverErosionOutwardsWaveConditionsCalculation
+            var calculationWithOutputAndHydraulicBoundaryLocationAndForeshoreProfile = new GrassCoverErosionOutwardsWaveConditionsCalculation
             {
                 InputParameters =
                 {
-                    HydraulicBoundaryLocation = internalHydroLocation,
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
                     ForeshoreProfile = profile2
                 },
                 Output = new GrassCoverErosionOutwardsWaveConditionsOutput(Enumerable.Empty<WaveConditionsOutput>())
@@ -811,16 +880,16 @@
             {
                 InputParameters =
                 {
-                    HydraulicBoundaryLocation = internalHydroLocation
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation
                 }
             };
 
             var subCalculation = new GrassCoverErosionOutwardsWaveConditionsCalculation();
-            var subCalculationWithOutput = new GrassCoverErosionOutwardsWaveConditionsCalculation
+            var subCalculationWithOutputAndHydraulicBoundarLocationAndForeshoreProfile = new GrassCoverErosionOutwardsWaveConditionsCalculation
             {
                 InputParameters =
                 {
-                    HydraulicBoundaryLocation = internalHydroLocation,
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
                     ForeshoreProfile = profile2
                 },
                 Output = new GrassCoverErosionOutwardsWaveConditionsOutput(Enumerable.Empty<WaveConditionsOutput>())
@@ -829,49 +898,68 @@
             {
                 InputParameters =
                 {
-                    HydraulicBoundaryLocation = internalHydroLocation,
-                    ForeshoreProfile = profile1
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
                 },
                 Output = new GrassCoverErosionOutwardsWaveConditionsOutput(Enumerable.Empty<WaveConditionsOutput>())
             };
             var subCalculationWithHydraulicBoundaryLocation = new GrassCoverErosionOutwardsWaveConditionsCalculation
             {
                 InputParameters =
                 {
-                    HydraulicBoundaryLocation = internalHydroLocation
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation
                 }
             };
+            var subCalculationWithHydraulicBoundaryLocationAndForeshoreProfile = new GrassCoverErosionOutwardsWaveConditionsCalculation
+            {
+                InputParameters =
+                {
+                    HydraulicBoundaryLocation = hydraulicBoundaryLocation,
+                    ForeshoreProfile = profile2
+                }
+            };
 
             failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculation);
-            failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithOutput);
-            failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithForeshoreProfile);
             failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocation);
+            failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWitHydraulicBoundaryLocationAndhForeshoreProfile);
+            failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocationAndForeshoreProfile);
             failureMechanism.WaveConditionsCalculationGroup.Children.Add(calculationWithHydraulicBoundaryLocation);
             failureMechanism.WaveConditionsCalculationGroup.Children.Add(new CalculationGroup
             {
                 Children =
                 {
                     subCalculation,
-                    subCalculationWithOutput,
+                    subCalculationWithOutputAndHydraulicBoundarLocationAndForeshoreProfile,
                     subCalculationWithOutputAndHydraulicBoundaryLocation,
-                    subCalculationWithHydraulicBoundaryLocation
+                    subCalculationWithHydraulicBoundaryLocation,
+                    subCalculationWithHydraulicBoundaryLocationAndForeshoreProfile
                 }
             });
         }
 
         private static void SetFullyConfiguredFailureMechanism(DuneErosionFailureMechanism failureMechanism,
                                                                HydraulicBoundaryLocation hydraulicBoundaryLocation)
         {
-            DuneLocation duneLocation = new DuneLocation(hydraulicBoundaryLocation.Id,
-                                                         hydraulicBoundaryLocation.Name,
-                                                         new Point2D(hydraulicBoundaryLocation.Location.X, hydraulicBoundaryLocation.Location.Y),
-                                                         new DuneLocation.ConstructionProperties
-                                                         {
-                                                             CoastalAreaId = 7,
-                                                             Offset = 20,
-                                                             Orientation = 180,
-                                                             D50 = 0.00008
-                                                         })
+            var duneLocation = new DuneLocation(hydraulicBoundaryLocation.Id,
+                                    hydraulicBoundaryLocation.Name,
+                                    new Point2D(hydraulicBoundaryLocation.Location.X, hydraulicBoundaryLocation.Location.Y),
+                                    new DuneLocation.ConstructionProperties
+                                    {
+                                        CoastalAreaId = 7,
+                                        Offset = 20,
+                                        Orientation = 180,
+                                        D50 = 0.00008
+                                    });
+
+            var duneLocationWithOutput = new DuneLocation(hydraulicBoundaryLocation.Id,
+                                                          hydraulicBoundaryLocation.Name,
+                                                          new Point2D(hydraulicBoundaryLocation.Location.X, hydraulicBoundaryLocation.Location.Y),
+                                                          new DuneLocation.ConstructionProperties
+                                                          {
+                                                              CoastalAreaId = 7,
+                                                              Offset = 20,
+                                                              Orientation = 180,
+                                                              D50 = 0.00008
+                                                          })
             {
                 Output = new DuneLocationOutput(CalculationConvergence.CalculatedConverged, new DuneLocationOutput.ConstructionProperties
                 {
@@ -882,6 +970,7 @@
             };
 
             failureMechanism.DuneLocations.Add(duneLocation);
+            failureMechanism.DuneLocations.Add(duneLocationWithOutput);
         }
     }
 }
\ No newline at end of file
Index: Ringtoets/Piping/test/Ringtoets.Piping.Integration.TestUtils/PipingTestDataGenerator.cs
===================================================================
diff -u -rd6d1b03ce8dc3c4e6bba565a85ea310f6196adea -r78cc5b59d47ca61eb812d0c69c7a17a4570e4ddc
--- Ringtoets/Piping/test/Ringtoets.Piping.Integration.TestUtils/PipingTestDataGenerator.cs	(.../PipingTestDataGenerator.cs)	(revision d6d1b03ce8dc3c4e6bba565a85ea310f6196adea)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Integration.TestUtils/PipingTestDataGenerator.cs	(.../PipingTestDataGenerator.cs)	(revision 78cc5b59d47ca61eb812d0c69c7a17a4570e4ddc)
@@ -152,6 +152,14 @@
                     HydraulicBoundaryLocation = hydraulicBoundaryLocation
                 }
             };
+            var calculationWithSurfaceLineAndStochasticSoilModel = new PipingCalculationScenario(new GeneralPipingInput())
+            {
+                InputParameters =
+                {
+                    SurfaceLine = surfaceline1,
+                    StochasticSoilModel = stochasticSoilModel2
+                }
+            };
 
             var subCalculation = new PipingCalculationScenario(new GeneralPipingInput());
             var subCalculationWithOutput = new PipingCalculationScenario(new GeneralPipingInput())
@@ -183,11 +191,20 @@
                     HydraulicBoundaryLocation = hydraulicBoundaryLocation
                 }
             };
+            var subCalculationWithSurfaceLineAndStochasticSoilModel = new PipingCalculationScenario(new GeneralPipingInput())
+            {
+                InputParameters =
+                {
+                    SurfaceLine = surfaceline1,
+                    StochasticSoilModel = stochasticSoilModel2
+                }
+            };
 
             failureMechanism.CalculationsGroup.Children.Add(calculation);
             failureMechanism.CalculationsGroup.Children.Add(calculationWithOutput);
             failureMechanism.CalculationsGroup.Children.Add(calculationWithSurfaceLineAndSoilModel);
             failureMechanism.CalculationsGroup.Children.Add(calculationWithOutputAndHydraulicBoundaryLocation);
+            failureMechanism.CalculationsGroup.Children.Add(calculationWithSurfaceLineAndStochasticSoilModel);
             failureMechanism.CalculationsGroup.Children.Add(calculationWithHydraulicBoundaryLocation);
             failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup
             {
@@ -196,7 +213,8 @@
                     subCalculation,
                     subCalculationWithOutput,
                     subCalculationWithOutputAndHydraulicBoundaryLocation,
-                    subCalculationWithHydraulicBoundaryLocation
+                    subCalculationWithHydraulicBoundaryLocation,
+                    subCalculationWithSurfaceLineAndStochasticSoilModel
                 }
             });
         }