Index: Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Merge/AssessmentSectionMergeHandler.cs
===================================================================
diff -u -r08046749e4daaa308b5f528d3c8b43125aa204b0 -r6f85854e0948a2223ad9eeca2234dc46bf863655
--- Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Merge/AssessmentSectionMergeHandler.cs	(.../AssessmentSectionMergeHandler.cs)	(revision 08046749e4daaa308b5f528d3c8b43125aa204b0)
+++ Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Merge/AssessmentSectionMergeHandler.cs	(.../AssessmentSectionMergeHandler.cs)	(revision 6f85854e0948a2223ad9eeca2234dc46bf863655)
@@ -350,16 +350,17 @@
             HydraulicBoundaryLocationCalculation[] oldWaveHeightForMechanismSpecificLowerLimitNorm = targetFailureMechanism.WaveHeightCalculationsForMechanismSpecificLowerLimitNorm.ToArray();
             targetFailureMechanism.SetHydraulicBoundaryLocationCalculations(locations);
 
-            ReplaceCalculationData(oldWaterLevelForMechanismSpecificFactorizedSignalingNorm, targetFailureMechanism.WaterLevelCalculationsForMechanismSpecificFactorizedSignalingNorm);
-            ReplaceCalculationData(oldWaterLevelForMechanismSpecificSignalingNorm, targetFailureMechanism.WaterLevelCalculationsForMechanismSpecificSignalingNorm);
-            ReplaceCalculationData(oldWaterLevelForMechanismSpecificLowerLimitNorm, targetFailureMechanism.WaterLevelCalculationsForMechanismSpecificLowerLimitNorm);
+            ReplaceHydraulicBoundaryLocationCalculationData(oldWaterLevelForMechanismSpecificFactorizedSignalingNorm, targetFailureMechanism.WaterLevelCalculationsForMechanismSpecificFactorizedSignalingNorm);
+            ReplaceHydraulicBoundaryLocationCalculationData(oldWaterLevelForMechanismSpecificSignalingNorm, targetFailureMechanism.WaterLevelCalculationsForMechanismSpecificSignalingNorm);
+            ReplaceHydraulicBoundaryLocationCalculationData(oldWaterLevelForMechanismSpecificLowerLimitNorm, targetFailureMechanism.WaterLevelCalculationsForMechanismSpecificLowerLimitNorm);
 
-            ReplaceCalculationData(oldWaveHeightForMechanismSpecificFactorizedSignalingNorm, targetFailureMechanism.WaveHeightCalculationsForMechanismSpecificFactorizedSignalingNorm);
-            ReplaceCalculationData(oldWaveHeightForMechanismSpecificSignalingNorm, targetFailureMechanism.WaveHeightCalculationsForMechanismSpecificSignalingNorm);
-            ReplaceCalculationData(oldWaveHeightForMechanismSpecificLowerLimitNorm, targetFailureMechanism.WaveHeightCalculationsForMechanismSpecificLowerLimitNorm);
+            ReplaceHydraulicBoundaryLocationCalculationData(oldWaveHeightForMechanismSpecificFactorizedSignalingNorm, targetFailureMechanism.WaveHeightCalculationsForMechanismSpecificFactorizedSignalingNorm);
+            ReplaceHydraulicBoundaryLocationCalculationData(oldWaveHeightForMechanismSpecificSignalingNorm, targetFailureMechanism.WaveHeightCalculationsForMechanismSpecificSignalingNorm);
+            ReplaceHydraulicBoundaryLocationCalculationData(oldWaveHeightForMechanismSpecificLowerLimitNorm, targetFailureMechanism.WaveHeightCalculationsForMechanismSpecificLowerLimitNorm);
         }
 
-        private static void ReplaceCalculationData(IEnumerable<HydraulicBoundaryLocationCalculation> oldCalculations, IEnumerable<HydraulicBoundaryLocationCalculation> newCalculations)
+        private static void ReplaceHydraulicBoundaryLocationCalculationData(IEnumerable<HydraulicBoundaryLocationCalculation> oldCalculations,
+                                                                            IEnumerable<HydraulicBoundaryLocationCalculation> newCalculations)
         {
             for (var i = 0; i < newCalculations.Count(); i++)
             {
Index: Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Merge/AssessmentSectionMergeHandlerTest.cs
===================================================================
diff -u -re5dda4058c572ba943002d130b8591a90ee19ce9 -r6f85854e0948a2223ad9eeca2234dc46bf863655
--- Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Merge/AssessmentSectionMergeHandlerTest.cs	(.../AssessmentSectionMergeHandlerTest.cs)	(revision e5dda4058c572ba943002d130b8591a90ee19ce9)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Merge/AssessmentSectionMergeHandlerTest.cs	(.../AssessmentSectionMergeHandlerTest.cs)	(revision 6f85854e0948a2223ad9eeca2234dc46bf863655)
@@ -415,12 +415,12 @@
                 }
             });
 
-            HydraulicBoundaryLocationCalculation[] oldWaterLevelForMechanismSpecificFactorizedSignalingNorm = sourceAssessmentSection.GrassCoverErosionOutwards.WaterLevelCalculationsForMechanismSpecificFactorizedSignalingNorm.ToArray();
-            HydraulicBoundaryLocationCalculation[] oldWaterLevelForMechanismSpecificSignalingNorm = sourceAssessmentSection.GrassCoverErosionOutwards.WaterLevelCalculationsForMechanismSpecificSignalingNorm.ToArray();
-            HydraulicBoundaryLocationCalculation[] oldWaterLevelForMechanismSpecificLowerLimitNorm = sourceAssessmentSection.GrassCoverErosionOutwards.WaterLevelCalculationsForMechanismSpecificLowerLimitNorm.ToArray();
-            HydraulicBoundaryLocationCalculation[] oldWaveHeightForMechanismSpecificFactorizedSignalingNorm = sourceAssessmentSection.GrassCoverErosionOutwards.WaveHeightCalculationsForMechanismSpecificFactorizedSignalingNorm.ToArray();
-            HydraulicBoundaryLocationCalculation[] oldWaveHeightForMechanismSpecificSignalingNorm = sourceAssessmentSection.GrassCoverErosionOutwards.WaveHeightCalculationsForMechanismSpecificSignalingNorm.ToArray();
-            HydraulicBoundaryLocationCalculation[] oldWaveHeightForMechanismSpecificLowerLimitNorm = sourceAssessmentSection.GrassCoverErosionOutwards.WaveHeightCalculationsForMechanismSpecificLowerLimitNorm.ToArray();
+            HydraulicBoundaryLocationCalculation[] sourceWaterLevelForMechanismSpecificFactorizedSignalingNorm = sourceAssessmentSection.GrassCoverErosionOutwards.WaterLevelCalculationsForMechanismSpecificFactorizedSignalingNorm.ToArray();
+            HydraulicBoundaryLocationCalculation[] sourceWaterLevelForMechanismSpecificSignalingNorm = sourceAssessmentSection.GrassCoverErosionOutwards.WaterLevelCalculationsForMechanismSpecificSignalingNorm.ToArray();
+            HydraulicBoundaryLocationCalculation[] sourceWaterLevelForMechanismSpecificLowerLimitNorm = sourceAssessmentSection.GrassCoverErosionOutwards.WaterLevelCalculationsForMechanismSpecificLowerLimitNorm.ToArray();
+            HydraulicBoundaryLocationCalculation[] sourceWaveHeightForMechanismSpecificFactorizedSignalingNorm = sourceAssessmentSection.GrassCoverErosionOutwards.WaveHeightCalculationsForMechanismSpecificFactorizedSignalingNorm.ToArray();
+            HydraulicBoundaryLocationCalculation[] sourceWaveHeightForMechanismSpecificSignalingNorm = sourceAssessmentSection.GrassCoverErosionOutwards.WaveHeightCalculationsForMechanismSpecificSignalingNorm.ToArray();
+            HydraulicBoundaryLocationCalculation[] sourceWaveHeightForMechanismSpecificLowerLimitNorm = sourceAssessmentSection.GrassCoverErosionOutwards.WaveHeightCalculationsForMechanismSpecificLowerLimitNorm.ToArray();
 
             // When
             handler.PerformMerge(targetAssessmentSection, new AssessmentSectionMergeData(
@@ -435,7 +435,7 @@
                                          MergeGrassCoverErosionOutwards = true,
                                          MergeHeightStructures = true,
                                          MergeClosingStructures = true,
-                                         MergeStabilityPointStructures = true,
+                                         MergeStabilityPointStructures = true
                                      }));
 
             // Then
@@ -466,42 +466,42 @@
             var grassOutwardsCalculation = (GrassCoverErosionOutwardsWaveConditionsCalculation) targetAssessmentSection.GrassCoverErosionOutwards.Calculations.Single();
             Assert.AreSame(targetLocations[0], grassOutwardsCalculation.InputParameters.HydraulicBoundaryLocation);
 
-            AssertHydraulicBoundaryCalculations(oldWaterLevelForMechanismSpecificFactorizedSignalingNorm,
+            AssertHydraulicBoundaryCalculations(sourceWaterLevelForMechanismSpecificFactorizedSignalingNorm,
                                                 targetAssessmentSection.GrassCoverErosionOutwards.WaterLevelCalculationsForMechanismSpecificFactorizedSignalingNorm,
                                                 targetLocations);
-            AssertHydraulicBoundaryCalculations(oldWaterLevelForMechanismSpecificSignalingNorm,
+            AssertHydraulicBoundaryCalculations(sourceWaterLevelForMechanismSpecificSignalingNorm,
                                                 targetAssessmentSection.GrassCoverErosionOutwards.WaterLevelCalculationsForMechanismSpecificSignalingNorm,
                                                 targetLocations);
-            AssertHydraulicBoundaryCalculations(oldWaterLevelForMechanismSpecificLowerLimitNorm,
+            AssertHydraulicBoundaryCalculations(sourceWaterLevelForMechanismSpecificLowerLimitNorm,
                                                 targetAssessmentSection.GrassCoverErosionOutwards.WaterLevelCalculationsForMechanismSpecificLowerLimitNorm,
                                                 targetLocations);
 
-            AssertHydraulicBoundaryCalculations(oldWaveHeightForMechanismSpecificFactorizedSignalingNorm,
+            AssertHydraulicBoundaryCalculations(sourceWaveHeightForMechanismSpecificFactorizedSignalingNorm,
                                                 targetAssessmentSection.GrassCoverErosionOutwards.WaveHeightCalculationsForMechanismSpecificFactorizedSignalingNorm,
                                                 targetLocations);
-            AssertHydraulicBoundaryCalculations(oldWaveHeightForMechanismSpecificSignalingNorm,
+            AssertHydraulicBoundaryCalculations(sourceWaveHeightForMechanismSpecificSignalingNorm,
                                                 targetAssessmentSection.GrassCoverErosionOutwards.WaveHeightCalculationsForMechanismSpecificSignalingNorm,
                                                 targetLocations);
-            AssertHydraulicBoundaryCalculations(oldWaveHeightForMechanismSpecificLowerLimitNorm,
+            AssertHydraulicBoundaryCalculations(sourceWaveHeightForMechanismSpecificLowerLimitNorm,
                                                 targetAssessmentSection.GrassCoverErosionOutwards.WaveHeightCalculationsForMechanismSpecificLowerLimitNorm,
                                                 targetLocations);
         }
 
-        private void AssertHydraulicBoundaryCalculations(HydraulicBoundaryLocationCalculation[] sourceCalculations,
-                                                         IEnumerable<HydraulicBoundaryLocationCalculation> targetCalculations,
-                                                         HydraulicBoundaryLocation[] targetLocations)
+        private static void AssertHydraulicBoundaryCalculations(IEnumerable<HydraulicBoundaryLocationCalculation> sourceCalculations,
+                                                                IEnumerable<HydraulicBoundaryLocationCalculation> targetCalculations,
+                                                                IEnumerable<HydraulicBoundaryLocation> targetLocations)
         {
-            Assert.AreEqual(sourceCalculations.Length, targetLocations.Length);
-            Assert.AreEqual(targetCalculations.Count(), sourceCalculations.Length);
+            Assert.AreEqual(sourceCalculations.Count(), targetLocations.Count());
+            Assert.AreEqual(targetCalculations.Count(), sourceCalculations.Count());
 
-            for (var i = 0; i < sourceCalculations.Length; i++)
+            for (var i = 0; i < sourceCalculations.Count(); i++)
             {
-                HydraulicBoundaryLocationCalculation sourceCalculation = sourceCalculations[i];
+                HydraulicBoundaryLocationCalculation sourceCalculation = sourceCalculations.ElementAt(i);
                 HydraulicBoundaryLocationCalculation targetCalculation = targetCalculations.ElementAt(i);
                 Assert.AreEqual(sourceCalculation.InputParameters.ShouldIllustrationPointsBeCalculated,
                                 targetCalculation.InputParameters.ShouldIllustrationPointsBeCalculated);
                 Assert.AreSame(sourceCalculation.Output, targetCalculation.Output);
-                Assert.AreSame(targetLocations[i], targetCalculation.HydraulicBoundaryLocation);
+                Assert.AreSame(targetLocations.ElementAt(i), targetCalculation.HydraulicBoundaryLocation);
             }
         }
 
@@ -516,7 +516,7 @@
         #region HydraulicBoundaryLocationCalculations
 
         [Test]
-        [TestCaseSource(nameof(GetCalculationsFuncs))]
+        [TestCaseSource(nameof(GetHydraulicBoundaryLocationCalculationFuncs))]
         public void GivenAssessmentSectionWithHydraulicBoundaryLocationCalculations_WhenTargetAssessmentSectionHasOutput_ThenCalculationsNotChanged(
             Func<AssessmentSection, IEnumerable<HydraulicBoundaryLocationCalculation>> getCalculationsFunc)
         {
@@ -562,7 +562,7 @@
         }
 
         [Test]
-        [TestCaseSource(nameof(GetCalculationsFuncs))]
+        [TestCaseSource(nameof(GetHydraulicBoundaryLocationCalculationFuncs))]
         public void GivenAssessmentSectionWithHydraulicBoundaryLocationCalculations_WhenBothAssessmentSectionsHaveOutput_ThenCalculationsNotChanged(
             Func<AssessmentSection, IEnumerable<HydraulicBoundaryLocationCalculation>> getCalculationsFunc)
         {
@@ -592,8 +592,10 @@
             // Precondition
             Assert.IsTrue(targetCalculations.All(c => c.HasOutput));
             Assert.IsTrue(sourceCalculations.All(c => c.HasOutput));
+            Assert.IsTrue(targetCalculations.All(c => !c.Output.HasGeneralResult));
+            Assert.IsTrue(sourceCalculations.All(c => !c.Output.HasGeneralResult));
             Assert.IsTrue(targetCalculations.All(c => !c.InputParameters.ShouldIllustrationPointsBeCalculated));
-
+            
             // When
             handler.PerformMerge(targetAssessmentSection,
                                  new AssessmentSectionMergeData(
@@ -603,12 +605,14 @@
             // Then
             Assert.IsTrue(targetCalculations.All(c => c.HasOutput));
             Assert.IsTrue(sourceCalculations.All(c => c.HasOutput));
+            Assert.IsTrue(targetCalculations.All(c => !c.Output.HasGeneralResult));
+            Assert.IsTrue(sourceCalculations.All(c => !c.Output.HasGeneralResult));
             Assert.IsTrue(targetCalculations.All(c => !c.InputParameters.ShouldIllustrationPointsBeCalculated));
             mocks.VerifyAll();
         }
 
         [Test]
-        [TestCaseSource(nameof(GetCalculationsFuncs))]
+        [TestCaseSource(nameof(GetHydraulicBoundaryLocationCalculationFuncs))]
         public void GivenAssessmentSectionWithHydraulicBoundaryLocationCalculations_WhenSourceAssessmentSectionHasOutput_ThenCalculationDataMerged(
             Func<AssessmentSection, IEnumerable<HydraulicBoundaryLocationCalculation>> getCalculationsFunc)
         {
@@ -653,7 +657,7 @@
         }
 
         [Test]
-        [TestCaseSource(nameof(GetCalculationsFuncs))]
+        [TestCaseSource(nameof(GetHydraulicBoundaryLocationCalculationFuncs))]
         public void GivenAssessmentSectionWithHydraulicBoundaryLocationCalculations_WhenTargetAssessmentSectionHasOutputWithIllustrationPoints_ThenCalculationsNotChanged(
             Func<AssessmentSection, IEnumerable<HydraulicBoundaryLocationCalculation>> getCalculationsFunc)
         {
@@ -700,7 +704,7 @@
         }
 
         [Test]
-        [TestCaseSource(nameof(GetCalculationsFuncs))]
+        [TestCaseSource(nameof(GetHydraulicBoundaryLocationCalculationFuncs))]
         public void GivenAssessmentSectionWithHydraulicBoundaryLocationCalculations_WhenSourceAssessmentSectionHasOutputWithIllustrationPoints_ThenCalculationsMerged(
             Func<AssessmentSection, IEnumerable<HydraulicBoundaryLocationCalculation>> getCalculationsFunc)
         {
@@ -745,7 +749,7 @@
         }
 
         [Test]
-        [TestCaseSource(nameof(GetCalculationsFuncs))]
+        [TestCaseSource(nameof(GetHydraulicBoundaryLocationCalculationFuncs))]
         public void GivenAssessmentSectionWithHydraulicBoundaryLocationCalculations_WhenBothAssessmentSectionsHaveOutputAndIllustrationPoints_ThenCalculationsNotChanged(
             Func<AssessmentSection, IEnumerable<HydraulicBoundaryLocationCalculation>> getCalculationsFunc)
         {
@@ -775,6 +779,8 @@
             // Precondition
             Assert.IsTrue(targetCalculations.All(c => c.HasOutput));
             Assert.IsTrue(sourceCalculations.All(c => c.HasOutput));
+            Assert.IsTrue(targetCalculations.All(c => c.Output.HasGeneralResult));
+            Assert.IsTrue(sourceCalculations.All(c => c.Output.HasGeneralResult));
             Assert.IsTrue(targetCalculations.All(c => !c.InputParameters.ShouldIllustrationPointsBeCalculated));
 
             // When
@@ -786,12 +792,14 @@
             // Then
             Assert.IsTrue(targetCalculations.All(c => c.HasOutput));
             Assert.IsTrue(sourceCalculations.All(c => c.HasOutput));
+            Assert.IsTrue(targetCalculations.All(c => c.Output.HasGeneralResult));
+            Assert.IsTrue(sourceCalculations.All(c => c.Output.HasGeneralResult));
             Assert.IsTrue(targetCalculations.All(c => !c.InputParameters.ShouldIllustrationPointsBeCalculated));
             mocks.VerifyAll();
         }
 
         [Test]
-        [TestCaseSource(nameof(GetCalculationsFuncs))]
+        [TestCaseSource(nameof(GetHydraulicBoundaryLocationCalculationFuncs))]
         public void PerformMerge_HydraulicBoundaryLocationCalculationsMerged_ObserversNotified(
             Func<AssessmentSection, IEnumerable<HydraulicBoundaryLocationCalculation>> getCalculationsFunc)
         {
@@ -841,7 +849,7 @@
             }
         }
 
-        private static IEnumerable<TestCaseData> GetCalculationsFuncs()
+        private static IEnumerable<TestCaseData> GetHydraulicBoundaryLocationCalculationFuncs()
         {
             yield return new TestCaseData(new Func<AssessmentSection, IEnumerable<HydraulicBoundaryLocationCalculation>>(
                                               section => section.WaterLevelCalculationsForFactorizedSignalingNorm));