Index: Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/Assembly/AssessmentSectionHelperTest.cs
===================================================================
diff -u -r02aa5c4ae3ee7698a4cd0cd077037ff239350739 -rd152836a2a6cc65a9b29894ea0157255702cb127
--- Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/Assembly/AssessmentSectionHelperTest.cs	(.../AssessmentSectionHelperTest.cs)	(revision 02aa5c4ae3ee7698a4cd0cd077037ff239350739)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/Assembly/AssessmentSectionHelperTest.cs	(.../AssessmentSectionHelperTest.cs)	(revision d152836a2a6cc65a9b29894ea0157255702cb127)
@@ -25,20 +25,10 @@
 using Core.Common.TestUtil;
 using Core.Common.Util.Extensions;
 using NUnit.Framework;
-using Ringtoets.ClosingStructures.Data;
 using Ringtoets.Common.Data.AssessmentSection;
+using Ringtoets.Common.Data.FailureMechanism;
 using Ringtoets.Common.Data.TestUtil;
-using Ringtoets.DuneErosion.Data;
-using Ringtoets.GrassCoverErosionInwards.Data;
-using Ringtoets.GrassCoverErosionOutwards.Data;
-using Ringtoets.HeightStructures.Data;
 using Ringtoets.Integration.Data.Assembly;
-using Ringtoets.Integration.Data.StandAlone;
-using Ringtoets.MacroStabilityInwards.Data;
-using Ringtoets.Piping.Data;
-using Ringtoets.StabilityPointStructures.Data;
-using Ringtoets.StabilityStoneCover.Data;
-using Ringtoets.WaveImpactAsphaltCover.Data;
 
 namespace Ringtoets.Integration.Data.Test.Assembly
 {
@@ -71,11 +61,13 @@
 
         [Test]
         [TestCaseSource(nameof(GetHasManualAssemblyResultCases))]
-        public void HasManualAssemblyResults_PipingHasManualAssemblyResult_ReturnsExpectedValue(bool isRelevant, bool expectedResult)
+        public void HasManualAssemblyResults_FailureMechanismHasManualAssemblyResult_ReturnsExpectedValue(
+            Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>> getFailureMechanismFunc,
+            bool isRelevant, bool expectedResult)
         {
             // Setup
             AssessmentSection assessmentSection = CreateConfiguredAssessmentSection(false);
-            PipingFailureMechanism failureMechanism = assessmentSection.Piping;
+            IHasSectionResults<FailureMechanismSectionResult> failureMechanism = getFailureMechanismFunc(assessmentSection);
             failureMechanism.IsRelevant = isRelevant;
             failureMechanism.SectionResults.Single().UseManualAssembly = true;
 
@@ -86,301 +78,91 @@
             Assert.AreEqual(expectedResult, hasManualAssemblyResults);
         }
 
-        [Test]
-        [TestCaseSource(nameof(GetHasManualAssemblyResultCases))]
-        public void HasManualAssemblyResults_MacroStabilityInwardsHasManualAssemblyResult_ReturnsExpectedValue(bool isRelevant, bool expectedResult)
+        private static IEnumerable<TestCaseData> GetHasManualAssemblyResultCases()
         {
-            // Setup
-            AssessmentSection assessmentSection = CreateConfiguredAssessmentSection(false);
-            MacroStabilityInwardsFailureMechanism failureMechanism = assessmentSection.MacroStabilityInwards;
-            failureMechanism.IsRelevant = isRelevant;
-            failureMechanism.SectionResults.Single().UseManualAssembly = true;
+            var getPipingFunc = new Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>>(
+                assessmentSection => assessmentSection.Piping);
 
-            // Call
-            bool hasManualAssemblyResults = AssessmentSectionHelper.HasManualAssemblyResults(assessmentSection);
+            var getMacroStabilityInwardsFunc = new Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>>(
+                assessmentSection => assessmentSection.MacroStabilityInwards);
 
-            // Assert
-            Assert.AreEqual(expectedResult, hasManualAssemblyResults);
-        }
+            var getGrassCoverErosionInwardsFunc = new Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>>(
+                assessmentSection => assessmentSection.GrassCoverErosionInwards);
 
-        [Test]
-        [TestCaseSource(nameof(GetHasManualAssemblyResultCases))]
-        public void HasManualAssemblyResults_GrassCoverErosionInwardsHasManualAssemblyResult_ReturnsExpectedValue(bool isRelevant, bool expectedResult)
-        {
-            // Setup
-            AssessmentSection assessmentSection = CreateConfiguredAssessmentSection(false);
-            GrassCoverErosionInwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverErosionInwards;
-            failureMechanism.IsRelevant = isRelevant;
-            failureMechanism.SectionResults.Single().UseManualAssembly = true;
+            var getClosingStructuresFunc = new Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>>(
+                assessmentSection => assessmentSection.ClosingStructures);
 
-            // Call
-            bool hasManualAssemblyResults = AssessmentSectionHelper.HasManualAssemblyResults(assessmentSection);
+            var getHeightStructuresFunc = new Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>>(
+                assessmentSection => assessmentSection.HeightStructures);
 
-            // Assert
-            Assert.AreEqual(expectedResult, hasManualAssemblyResults);
-        }
+            var getStabilityPointStructuresFunc = new Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>>(
+                assessmentSection => assessmentSection.StabilityPointStructures);
 
-        [Test]
-        [TestCaseSource(nameof(GetHasManualAssemblyResultCases))]
-        public void HasManualAssemblyResults_ClosingStructuresHasManualAssemblyResult_ReturnsExpectedValue(bool isRelevant, bool expectedResult)
-        {
-            // Setup
-            AssessmentSection assessmentSection = CreateConfiguredAssessmentSection(false);
-            ClosingStructuresFailureMechanism failureMechanism = assessmentSection.ClosingStructures;
-            failureMechanism.IsRelevant = isRelevant;
-            failureMechanism.SectionResults.Single().UseManualAssembly = true;
+            var getGrassCoverErosionOutwardsFunc = new Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>>(
+                assessmentSection => assessmentSection.GrassCoverErosionOutwards);
 
-            // Call
-            bool hasManualAssemblyResults = AssessmentSectionHelper.HasManualAssemblyResults(assessmentSection);
+            var getDuneErosionFunc = new Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>>(
+                assessmentSection => assessmentSection.DuneErosion);
 
-            // Assert
-            Assert.AreEqual(expectedResult, hasManualAssemblyResults);
-        }
+            var getWaveImpactAsphaltCoverFunc = new Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>>(
+                assessmentSection => assessmentSection.WaveImpactAsphaltCover);
 
-        [Test]
-        [TestCaseSource(nameof(GetHasManualAssemblyResultCases))]
-        public void HasManualAssemblyResults_HeightStructuresHasManualAssemblyResult_ReturnsExpectedValue(bool isRelevant, bool expectedResult)
-        {
-            // Setup
-            AssessmentSection assessmentSection = CreateConfiguredAssessmentSection(false);
-            HeightStructuresFailureMechanism failureMechanism = assessmentSection.HeightStructures;
-            failureMechanism.IsRelevant = isRelevant;
-            failureMechanism.SectionResults.Single().UseManualAssembly = true;
+            var getStabilityStoneCoverFunc = new Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>>(
+                assessmentSection => assessmentSection.StabilityStoneCover);
 
-            // Call
-            bool hasManualAssemblyResults = AssessmentSectionHelper.HasManualAssemblyResults(assessmentSection);
+            var getGrassCoverSlipOffInwardsFunc = new Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>>(
+                assessmentSection => assessmentSection.GrassCoverSlipOffInwards);
 
-            // Assert
-            Assert.AreEqual(expectedResult, hasManualAssemblyResults);
-        }
+            var getGrassCoverSlipOffOutwardsFunc = new Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>>(
+                assessmentSection => assessmentSection.GrassCoverSlipOffOutwards);
 
-        [Test]
-        [TestCaseSource(nameof(GetHasManualAssemblyResultCases))]
-        public void HasManualAssemblyResults_StabilityPointStructuresHasManualAssemblyResult_ReturnsExpectedValue(bool isRelevant, bool expectedResult)
-        {
-            // Setup
-            AssessmentSection assessmentSection = CreateConfiguredAssessmentSection(false);
-            StabilityPointStructuresFailureMechanism failureMechanism = assessmentSection.StabilityPointStructures;
-            failureMechanism.IsRelevant = isRelevant;
-            failureMechanism.SectionResults.Single().UseManualAssembly = true;
+            var getMacroStabilityOutwardsFunc = new Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>>(
+                assessmentSection => assessmentSection.MacroStabilityOutwards);
 
-            // Call
-            bool hasManualAssemblyResults = AssessmentSectionHelper.HasManualAssemblyResults(assessmentSection);
+            var getMicrostabilityFunc = new Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>>(
+                assessmentSection => assessmentSection.Microstability);
 
-            // Assert
-            Assert.AreEqual(expectedResult, hasManualAssemblyResults);
-        }
+            var getPipingStructureFunc = new Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>>(
+                assessmentSection => assessmentSection.PipingStructure);
 
-        [Test]
-        [TestCaseSource(nameof(GetHasManualAssemblyResultCases))]
-        public void HasManualAssemblyResults_GrassCoverErosionOutwardsHasManualAssemblyResult_ReturnsExpectedValue(bool isRelevant, bool expectedResult)
-        {
-            // Setup
-            AssessmentSection assessmentSection = CreateConfiguredAssessmentSection(false);
-            GrassCoverErosionOutwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverErosionOutwards;
-            failureMechanism.IsRelevant = isRelevant;
-            failureMechanism.SectionResults.Single().UseManualAssembly = true;
+            var getStrengthStabilityLengthwiseConstructionFunc = new Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>>(
+                assessmentSection => assessmentSection.StrengthStabilityLengthwiseConstruction);
 
-            // Call
-            bool hasManualAssemblyResults = AssessmentSectionHelper.HasManualAssemblyResults(assessmentSection);
+            var getTechnicalInnovationFunc = new Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>>(
+                assessmentSection => assessmentSection.TechnicalInnovation);
 
-            // Assert
-            Assert.AreEqual(expectedResult, hasManualAssemblyResults);
-        }
+            var getWaterPressureAsphaltCoverFunc = new Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>>(
+                assessmentSection => assessmentSection.WaterPressureAsphaltCover);
 
-        [Test]
-        [TestCaseSource(nameof(GetHasManualAssemblyResultCases))]
-        public void HasManualAssemblyResults_DuneErosionHasManualAssemblyResult_ReturnsExpectedValue(bool isRelevant, bool expectedResult)
-        {
-            // Setup
-            AssessmentSection assessmentSection = CreateConfiguredAssessmentSection(false);
-            DuneErosionFailureMechanism failureMechanism = assessmentSection.DuneErosion;
-            failureMechanism.IsRelevant = isRelevant;
-            failureMechanism.SectionResults.Single().UseManualAssembly = true;
+            Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>>[] getFailureMechanismFuncs =
+            {
+                getPipingFunc,
+                getMacroStabilityInwardsFunc,
+                getGrassCoverErosionInwardsFunc,
+                getClosingStructuresFunc,
+                getHeightStructuresFunc,
+                getStabilityPointStructuresFunc,
+                getGrassCoverErosionOutwardsFunc,
+                getDuneErosionFunc,
+                getWaveImpactAsphaltCoverFunc,
+                getStabilityStoneCoverFunc,
+                getGrassCoverSlipOffInwardsFunc,
+                getGrassCoverSlipOffOutwardsFunc,
+                getMacroStabilityOutwardsFunc,
+                getMicrostabilityFunc,
+                getPipingStructureFunc,
+                getStrengthStabilityLengthwiseConstructionFunc,
+                getTechnicalInnovationFunc,
+                getWaterPressureAsphaltCoverFunc
+            };
 
-            // Call
-            bool hasManualAssemblyResults = AssessmentSectionHelper.HasManualAssemblyResults(assessmentSection);
-
-            // Assert
-            Assert.AreEqual(expectedResult, hasManualAssemblyResults);
+            foreach (Func<AssessmentSection, IHasSectionResults<FailureMechanismSectionResult>> func in getFailureMechanismFuncs)
+            {
+                yield return new TestCaseData(func, true, true);
+                yield return new TestCaseData(func, false, false);
+            }
         }
 
-        [Test]
-        [TestCaseSource(nameof(GetHasManualAssemblyResultCases))]
-        public void HasManualAssemblyResults_StabilityStoneCoverHasManualAssemblyResult_ReturnsExpectedValue(bool isRelevant, bool expectedResult)
-        {
-            // Setup
-            AssessmentSection assessmentSection = CreateConfiguredAssessmentSection(false);
-            StabilityStoneCoverFailureMechanism failureMechanism = assessmentSection.StabilityStoneCover;
-            failureMechanism.IsRelevant = isRelevant;
-            failureMechanism.SectionResults.Single().UseManualAssembly = true;
-
-            // Call
-            bool hasManualAssemblyResults = AssessmentSectionHelper.HasManualAssemblyResults(assessmentSection);
-
-            // Assert
-            Assert.AreEqual(expectedResult, hasManualAssemblyResults);
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetHasManualAssemblyResultCases))]
-        public void HasManualAssemblyResults_WaveImpactAsphaltCoverHasManualAssemblyResult_ReturnsExpectedValue(bool isRelevant, bool expectedResult)
-        {
-            // Setup
-            AssessmentSection assessmentSection = CreateConfiguredAssessmentSection(false);
-            WaveImpactAsphaltCoverFailureMechanism failureMechanism = assessmentSection.WaveImpactAsphaltCover;
-            failureMechanism.IsRelevant = isRelevant;
-            failureMechanism.SectionResults.Single().UseManualAssembly = true;
-
-            // Call
-            bool hasManualAssemblyResults = AssessmentSectionHelper.HasManualAssemblyResults(assessmentSection);
-
-            // Assert
-            Assert.AreEqual(expectedResult, hasManualAssemblyResults);
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetHasManualAssemblyResultCases))]
-        public void HasManualAssemblyResults_GrassCoverSlipOffInwardsHasManualAssemblyResult_ReturnsExpectedValue(bool isRelevant, bool expectedResult)
-        {
-            // Setup
-            AssessmentSection assessmentSection = CreateConfiguredAssessmentSection(false);
-            GrassCoverSlipOffInwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverSlipOffInwards;
-            failureMechanism.IsRelevant = isRelevant;
-            failureMechanism.SectionResults.Single().UseManualAssembly = true;
-
-            // Call
-            bool hasManualAssemblyResults = AssessmentSectionHelper.HasManualAssemblyResults(assessmentSection);
-
-            // Assert
-            Assert.AreEqual(expectedResult, hasManualAssemblyResults);
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetHasManualAssemblyResultCases))]
-        public void HasManualAssemblyResults_GrassCoverSlipOffOutwardsHasManualAssemblyResult_ReturnsExpectedValue(bool isRelevant, bool expectedResult)
-        {
-            // Setup
-            AssessmentSection assessmentSection = CreateConfiguredAssessmentSection(false);
-            GrassCoverSlipOffOutwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverSlipOffOutwards;
-            failureMechanism.IsRelevant = isRelevant;
-            failureMechanism.SectionResults.Single().UseManualAssembly = true;
-
-            // Call
-            bool hasManualAssemblyResults = AssessmentSectionHelper.HasManualAssemblyResults(assessmentSection);
-
-            // Assert
-            Assert.AreEqual(expectedResult, hasManualAssemblyResults);
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetHasManualAssemblyResultCases))]
-        public void HasManualAssemblyResults_MacroStabilityOutwardsHasManualAssemblyResult_ReturnsExpectedValue(bool isRelevant, bool expectedResult)
-        {
-            // Setup
-            AssessmentSection assessmentSection = CreateConfiguredAssessmentSection(false);
-            MacroStabilityOutwardsFailureMechanism failureMechanism = assessmentSection.MacroStabilityOutwards;
-            failureMechanism.IsRelevant = isRelevant;
-            failureMechanism.SectionResults.Single().UseManualAssembly = true;
-
-            // Call
-            bool hasManualAssemblyResults = AssessmentSectionHelper.HasManualAssemblyResults(assessmentSection);
-
-            // Assert
-            Assert.AreEqual(expectedResult, hasManualAssemblyResults);
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetHasManualAssemblyResultCases))]
-        public void HasManualAssemblyResults_MicrostabilityHasManualAssemblyResult_ReturnsExpectedValue(bool isRelevant, bool expectedResult)
-        {
-            // Setup
-            AssessmentSection assessmentSection = CreateConfiguredAssessmentSection(false);
-            MicrostabilityFailureMechanism failureMechanism = assessmentSection.Microstability;
-            failureMechanism.IsRelevant = isRelevant;
-            failureMechanism.SectionResults.Single().UseManualAssembly = true;
-
-            // Call
-            bool hasManualAssemblyResults = AssessmentSectionHelper.HasManualAssemblyResults(assessmentSection);
-
-            // Assert
-            Assert.AreEqual(expectedResult, hasManualAssemblyResults);
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetHasManualAssemblyResultCases))]
-        public void HasManualAssemblyResults_PipingStructureHasManualAssemblyResult_ReturnsExpectedValue(bool isRelevant, bool expectedResult)
-        {
-            // Setup
-            AssessmentSection assessmentSection = CreateConfiguredAssessmentSection(false);
-            PipingStructureFailureMechanism failureMechanism = assessmentSection.PipingStructure;
-            failureMechanism.IsRelevant = isRelevant;
-            failureMechanism.SectionResults.Single().UseManualAssembly = true;
-
-            // Call
-            bool hasManualAssemblyResults = AssessmentSectionHelper.HasManualAssemblyResults(assessmentSection);
-
-            // Assert
-            Assert.AreEqual(expectedResult, hasManualAssemblyResults);
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetHasManualAssemblyResultCases))]
-        public void HasManualAssemblyResults_StrengthStabilityLengthwiseConstructionHasManualAssemblyResult_ReturnsExpectedValue(bool isRelevant, bool expectedResult)
-        {
-            // Setup
-            AssessmentSection assessmentSection = CreateConfiguredAssessmentSection(false);
-            StrengthStabilityLengthwiseConstructionFailureMechanism failureMechanism = assessmentSection.StrengthStabilityLengthwiseConstruction;
-            failureMechanism.IsRelevant = isRelevant;
-            failureMechanism.SectionResults.Single().UseManualAssembly = true;
-
-            // Call
-            bool hasManualAssemblyResults = AssessmentSectionHelper.HasManualAssemblyResults(assessmentSection);
-
-            // Assert
-            Assert.AreEqual(expectedResult, hasManualAssemblyResults);
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetHasManualAssemblyResultCases))]
-        public void HasManualAssemblyResults_TechnicalInnovationHasManualAssemblyResult_ReturnsExpectedValue(bool isRelevant, bool expectedResult)
-        {
-            // Setup
-            AssessmentSection assessmentSection = CreateConfiguredAssessmentSection(false);
-            TechnicalInnovationFailureMechanism failureMechanism = assessmentSection.TechnicalInnovation;
-            failureMechanism.IsRelevant = isRelevant;
-            failureMechanism.SectionResults.Single().UseManualAssembly = true;
-
-            // Call
-            bool hasManualAssemblyResults = AssessmentSectionHelper.HasManualAssemblyResults(assessmentSection);
-
-            // Assert
-            Assert.AreEqual(expectedResult, hasManualAssemblyResults);
-        }
-
-        [Test]
-        [TestCaseSource(nameof(GetHasManualAssemblyResultCases))]
-        public void HasManualAssemblyResults_WaterPressureAsphaltCoverHasManualAssemblyResult_ReturnsExpectedValue(bool isRelevant, bool expectedResult)
-        {
-            // Setup
-            AssessmentSection assessmentSection = CreateConfiguredAssessmentSection(false);
-            WaterPressureAsphaltCoverFailureMechanism failureMechanism = assessmentSection.WaterPressureAsphaltCover;
-            failureMechanism.IsRelevant = isRelevant;
-            failureMechanism.SectionResults.Single().UseManualAssembly = true;
-
-            // Call
-            bool hasManualAssemblyResults = AssessmentSectionHelper.HasManualAssemblyResults(assessmentSection);
-
-            // Assert
-            Assert.AreEqual(expectedResult, hasManualAssemblyResults);
-        }
-
-        private static IEnumerable<TestCaseData> GetHasManualAssemblyResultCases()
-        {
-            yield return new TestCaseData(true, true);
-            yield return new TestCaseData(false, false);
-        }
-
         private static AssessmentSection CreateConfiguredAssessmentSection(bool failureMechanismsRelevant)
         {
             var random = new Random(39);