Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableGrassCoverSlipOffInwardsFailureMechanismFactory.cs
===================================================================
diff -u -r23a944dbdd57753d15e0e0369a1a851bb83f60c8 -raf392dc2e2f82efb5e3e675e4a65ae7b221072df
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableGrassCoverSlipOffInwardsFailureMechanismFactory.cs	(.../ExportableGrassCoverSlipOffInwardsFailureMechanismFactory.cs)	(revision 23a944dbdd57753d15e0e0369a1a851bb83f60c8)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableGrassCoverSlipOffInwardsFailureMechanismFactory.cs	(.../ExportableGrassCoverSlipOffInwardsFailureMechanismFactory.cs)	(revision af392dc2e2f82efb5e3e675e4a65ae7b221072df)
@@ -22,6 +22,7 @@
 using System;
 using System.Collections.Generic;
 using Ringtoets.AssemblyTool.Data;
+using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.Exceptions;
 using Ringtoets.Integration.Data.StandAlone;
 using Ringtoets.Integration.Data.StandAlone.AssemblyFactories;
@@ -47,21 +48,30 @@
         /// </summary>
         /// <param name="failureMechanism">The <see cref="GrassCoverSlipOffInwardsFailureMechanism"/> to create an
         /// <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> for.</param>
+        /// <param name="assessmentSection">The assessment section this failure mechanism belongs to.</param>
         /// <returns>An <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> with assembly results.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/> is <c>null</c>.</exception>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
         /// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
         public static ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> CreateExportableFailureMechanism(
-            GrassCoverSlipOffInwardsFailureMechanism failureMechanism)
+            GrassCoverSlipOffInwardsFailureMechanism failureMechanism,
+            IAssessmentSection assessmentSection)
         {
             if (failureMechanism == null)
             {
                 throw new ArgumentNullException(nameof(failureMechanism));
             }
 
+            if (assessmentSection == null)
+            {
+                throw new ArgumentNullException(nameof(assessmentSection));
+            }
+
             if (!failureMechanism.IsRelevant)
             {
-                return ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithoutProbability(
-                    failureMechanismCode, failureMechanismGroup, failureMechanismAssemblyMethod);
+                return ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithoutProbability(assessmentSection,
+                                                                                                                   failureMechanismCode,
+                                                                                                                   failureMechanismGroup,
+                                                                                                                   failureMechanismAssemblyMethod);
             }
 
             FailureMechanismAssemblyCategoryGroup failureMechanismAssembly = GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, false);
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableGrassCoverSlipOffOutwardsFailureMechanismFactory.cs
===================================================================
diff -u -r23a944dbdd57753d15e0e0369a1a851bb83f60c8 -raf392dc2e2f82efb5e3e675e4a65ae7b221072df
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableGrassCoverSlipOffOutwardsFailureMechanismFactory.cs	(.../ExportableGrassCoverSlipOffOutwardsFailureMechanismFactory.cs)	(revision 23a944dbdd57753d15e0e0369a1a851bb83f60c8)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableGrassCoverSlipOffOutwardsFailureMechanismFactory.cs	(.../ExportableGrassCoverSlipOffOutwardsFailureMechanismFactory.cs)	(revision af392dc2e2f82efb5e3e675e4a65ae7b221072df)
@@ -22,6 +22,7 @@
 using System;
 using System.Collections.Generic;
 using Ringtoets.AssemblyTool.Data;
+using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.Exceptions;
 using Ringtoets.Integration.Data.StandAlone;
 using Ringtoets.Integration.Data.StandAlone.AssemblyFactories;
@@ -47,21 +48,30 @@
         /// </summary>
         /// <param name="failureMechanism">The <see cref="GrassCoverSlipOffOutwardsFailureMechanism"/> to create an
         /// <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> for.</param>
+        /// <param name="assessmentSection">The assessment section this failure mechanism belongs to.</param>
         /// <returns>An <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> with assembly results.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/> is <c>null</c>.</exception>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
         /// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
         public static ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> CreateExportableFailureMechanism(
-            GrassCoverSlipOffOutwardsFailureMechanism failureMechanism)
+            GrassCoverSlipOffOutwardsFailureMechanism failureMechanism,
+            IAssessmentSection assessmentSection)
         {
             if (failureMechanism == null)
             {
                 throw new ArgumentNullException(nameof(failureMechanism));
             }
 
+            if (assessmentSection == null)
+            {
+                throw new ArgumentNullException(nameof(assessmentSection));
+            }
+
             if (!failureMechanism.IsRelevant)
             {
-                return ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithoutProbability(
-                    failureMechanismCode, failureMechanismGroup, failureMechanismAssemblyMethod);
+                return ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithoutProbability(assessmentSection, 
+                                                                                                                   failureMechanismCode,
+                                                                                                                   failureMechanismGroup, 
+                                                                                                                   failureMechanismAssemblyMethod);
             }
 
             FailureMechanismAssemblyCategoryGroup failureMechanismAssembly = GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, false);
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableMacroStabilityOutwardsFailureMechanismFactory.cs
===================================================================
diff -u -r23a944dbdd57753d15e0e0369a1a851bb83f60c8 -raf392dc2e2f82efb5e3e675e4a65ae7b221072df
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableMacroStabilityOutwardsFailureMechanismFactory.cs	(.../ExportableMacroStabilityOutwardsFailureMechanismFactory.cs)	(revision 23a944dbdd57753d15e0e0369a1a851bb83f60c8)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableMacroStabilityOutwardsFailureMechanismFactory.cs	(.../ExportableMacroStabilityOutwardsFailureMechanismFactory.cs)	(revision af392dc2e2f82efb5e3e675e4a65ae7b221072df)
@@ -68,8 +68,10 @@
 
             if (!failureMechanism.IsRelevant)
             {
-                return ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithoutProbability(
-                    failureMechanismCode, failureMechanismGroup, failureMechanismAssemblyMethod);
+                return ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithoutProbability(assessmentSection,
+                                                                                                                   failureMechanismCode,
+                                                                                                                   failureMechanismGroup,
+                                                                                                                   failureMechanismAssemblyMethod);
             }
 
             FailureMechanismAssemblyCategoryGroup failureMechanismAssembly = MacroStabilityOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism,
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableMicrostabilityFailureMechanismFactory.cs
===================================================================
diff -u -r23a944dbdd57753d15e0e0369a1a851bb83f60c8 -raf392dc2e2f82efb5e3e675e4a65ae7b221072df
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableMicrostabilityFailureMechanismFactory.cs	(.../ExportableMicrostabilityFailureMechanismFactory.cs)	(revision 23a944dbdd57753d15e0e0369a1a851bb83f60c8)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableMicrostabilityFailureMechanismFactory.cs	(.../ExportableMicrostabilityFailureMechanismFactory.cs)	(revision af392dc2e2f82efb5e3e675e4a65ae7b221072df)
@@ -22,6 +22,7 @@
 using System;
 using System.Collections.Generic;
 using Ringtoets.AssemblyTool.Data;
+using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.Exceptions;
 using Ringtoets.Integration.Data.StandAlone;
 using Ringtoets.Integration.Data.StandAlone.AssemblyFactories;
@@ -47,21 +48,30 @@
         /// </summary>
         /// <param name="failureMechanism">The <see cref="MicrostabilityFailureMechanism"/> to create an
         /// <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> for.</param>
+        /// <param name="assessmentSection">The assessment section this failure mechanism belongs to.</param>
         /// <returns>An <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> with assembly results.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when any <paramref name="failureMechanism"/> is <c>null</c>.</exception>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
         /// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
         public static ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> CreateExportableFailureMechanism(
-            MicrostabilityFailureMechanism failureMechanism)
+            MicrostabilityFailureMechanism failureMechanism,
+            IAssessmentSection assessmentSection)
         {
             if (failureMechanism == null)
             {
                 throw new ArgumentNullException(nameof(failureMechanism));
             }
 
+            if (assessmentSection == null)
+            {
+                throw new ArgumentNullException(nameof(assessmentSection));
+            }
+
             if (!failureMechanism.IsRelevant)
             {
-                return ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithoutProbability(
-                    failureMechanismCode, failureMechanismGroup, failureMechanismAssemblyMethod);
+                return ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithoutProbability(assessmentSection,
+                                                                                                                   failureMechanismCode,
+                                                                                                                   failureMechanismGroup,
+                                                                                                                   failureMechanismAssemblyMethod);
             }
 
             FailureMechanismAssemblyCategoryGroup failureMechanismAssembly = MicrostabilityFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, false);
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportablePipingStructureFailureMechanismFactory.cs
===================================================================
diff -u -r23a944dbdd57753d15e0e0369a1a851bb83f60c8 -raf392dc2e2f82efb5e3e675e4a65ae7b221072df
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportablePipingStructureFailureMechanismFactory.cs	(.../ExportablePipingStructureFailureMechanismFactory.cs)	(revision 23a944dbdd57753d15e0e0369a1a851bb83f60c8)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportablePipingStructureFailureMechanismFactory.cs	(.../ExportablePipingStructureFailureMechanismFactory.cs)	(revision af392dc2e2f82efb5e3e675e4a65ae7b221072df)
@@ -22,6 +22,7 @@
 using System;
 using System.Collections.Generic;
 using Ringtoets.AssemblyTool.Data;
+using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.Exceptions;
 using Ringtoets.Integration.Data.StandAlone;
 using Ringtoets.Integration.Data.StandAlone.AssemblyFactories;
@@ -47,21 +48,30 @@
         /// </summary>
         /// <param name="failureMechanism">The <see cref="PipingStructureFailureMechanism"/> to create an
         /// <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> for.</param>
+        /// <param name="assessmentSection">The assessment section this failure mechanism belongs to.</param>
         /// <returns>An <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> with assembly results.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/> is <c>null</c>.</exception>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
         /// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
         public static ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> CreateExportableFailureMechanism(
-            PipingStructureFailureMechanism failureMechanism)
+            PipingStructureFailureMechanism failureMechanism,
+            IAssessmentSection assessmentSection)
         {
             if (failureMechanism == null)
             {
                 throw new ArgumentNullException(nameof(failureMechanism));
             }
 
+            if (assessmentSection == null)
+            {
+                throw new ArgumentNullException(nameof(assessmentSection));
+            }
+
             if (!failureMechanism.IsRelevant)
             {
-                return ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithoutProbability(
-                    failureMechanismCode, failureMechanismGroup, failureMechanismAssemblyMethod);
+                return ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithoutProbability(assessmentSection,
+                                                                                                                   failureMechanismCode, 
+                                                                                                                   failureMechanismGroup, 
+                                                                                                                   failureMechanismAssemblyMethod);
             }
 
             FailureMechanismAssemblyCategoryGroup failureMechanismAssembly = PipingStructureFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, false);
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableStrengthStabilityLengthwiseConstructionFailureMechanismFactory.cs
===================================================================
diff -u -r23a944dbdd57753d15e0e0369a1a851bb83f60c8 -raf392dc2e2f82efb5e3e675e4a65ae7b221072df
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableStrengthStabilityLengthwiseConstructionFailureMechanismFactory.cs	(.../ExportableStrengthStabilityLengthwiseConstructionFailureMechanismFactory.cs)	(revision 23a944dbdd57753d15e0e0369a1a851bb83f60c8)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableStrengthStabilityLengthwiseConstructionFailureMechanismFactory.cs	(.../ExportableStrengthStabilityLengthwiseConstructionFailureMechanismFactory.cs)	(revision af392dc2e2f82efb5e3e675e4a65ae7b221072df)
@@ -22,6 +22,7 @@
 using System;
 using System.Collections.Generic;
 using Ringtoets.AssemblyTool.Data;
+using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.Exceptions;
 using Ringtoets.Integration.Data.StandAlone;
 using Ringtoets.Integration.Data.StandAlone.AssemblyFactories;
@@ -47,21 +48,30 @@
         /// </summary>
         /// <param name="failureMechanism">The <see cref="StrengthStabilityLengthwiseConstructionFailureMechanism"/> to create an
         /// <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> for.</param>
+        /// <param name="assessmentSection">The assessment section this failure mechanism belongs to.</param>
         /// <returns>An <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> with assembly results.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/> is <c>null</c>.</exception>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
         /// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
         public static ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> CreateExportableFailureMechanism(
-            StrengthStabilityLengthwiseConstructionFailureMechanism failureMechanism)
+            StrengthStabilityLengthwiseConstructionFailureMechanism failureMechanism,
+            IAssessmentSection assessmentSection)
         {
             if (failureMechanism == null)
             {
                 throw new ArgumentNullException(nameof(failureMechanism));
             }
 
+            if (assessmentSection == null)
+            {
+                throw new ArgumentNullException(nameof(assessmentSection));
+            }
+
             if (!failureMechanism.IsRelevant)
             {
-                return ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithoutProbability(
-                    failureMechanismCode, failureMechanismGroup, failureMechanismAssemblyMethod);
+                return ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithoutProbability(assessmentSection, 
+                                                                                                                   failureMechanismCode, 
+                                                                                                                   failureMechanismGroup, 
+                                                                                                                   failureMechanismAssemblyMethod);
             }
 
             FailureMechanismAssemblyCategoryGroup failureMechanismAssembly = StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, false);
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableTechnicalInnovationFailureMechanismFactory.cs
===================================================================
diff -u -r23a944dbdd57753d15e0e0369a1a851bb83f60c8 -raf392dc2e2f82efb5e3e675e4a65ae7b221072df
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableTechnicalInnovationFailureMechanismFactory.cs	(.../ExportableTechnicalInnovationFailureMechanismFactory.cs)	(revision 23a944dbdd57753d15e0e0369a1a851bb83f60c8)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableTechnicalInnovationFailureMechanismFactory.cs	(.../ExportableTechnicalInnovationFailureMechanismFactory.cs)	(revision af392dc2e2f82efb5e3e675e4a65ae7b221072df)
@@ -22,6 +22,7 @@
 using System;
 using System.Collections.Generic;
 using Ringtoets.AssemblyTool.Data;
+using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.Exceptions;
 using Ringtoets.Integration.Data.StandAlone;
 using Ringtoets.Integration.Data.StandAlone.AssemblyFactories;
@@ -47,21 +48,30 @@
         /// </summary>
         /// <param name="failureMechanism">The <see cref="TechnicalInnovationFailureMechanism"/> to create an
         /// <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> for.</param>
+        /// <param name="assessmentSection">The assessment section this failure mechanism belongs to.</param>
         /// <returns>An <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> with assembly results.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/> is <c>null</c>.</exception>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
         /// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
         public static ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> CreateExportableFailureMechanism(
-            TechnicalInnovationFailureMechanism failureMechanism)
+            TechnicalInnovationFailureMechanism failureMechanism,
+            IAssessmentSection assessmentSection)
         {
             if (failureMechanism == null)
             {
                 throw new ArgumentNullException(nameof(failureMechanism));
             }
 
+            if (assessmentSection == null)
+            {
+                throw new ArgumentNullException(nameof(assessmentSection));
+            }
+
             if (!failureMechanism.IsRelevant)
             {
-                return ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithoutProbability(
-                    failureMechanismCode, failureMechanismGroup, failureMechanismAssemblyMethod);
+                return ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithoutProbability(assessmentSection,
+                                                                                                                   failureMechanismCode,
+                                                                                                                   failureMechanismGroup,
+                                                                                                                   failureMechanismAssemblyMethod);
             }
 
             FailureMechanismAssemblyCategoryGroup failureMechanismAssembly = TechnicalInnovationFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, false);
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableWaterPressureAsphaltCoverFailureMechanismFactory.cs
===================================================================
diff -u -r23a944dbdd57753d15e0e0369a1a851bb83f60c8 -raf392dc2e2f82efb5e3e675e4a65ae7b221072df
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableWaterPressureAsphaltCoverFailureMechanismFactory.cs	(.../ExportableWaterPressureAsphaltCoverFailureMechanismFactory.cs)	(revision 23a944dbdd57753d15e0e0369a1a851bb83f60c8)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableWaterPressureAsphaltCoverFailureMechanismFactory.cs	(.../ExportableWaterPressureAsphaltCoverFailureMechanismFactory.cs)	(revision af392dc2e2f82efb5e3e675e4a65ae7b221072df)
@@ -22,6 +22,7 @@
 using System;
 using System.Collections.Generic;
 using Ringtoets.AssemblyTool.Data;
+using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.Exceptions;
 using Ringtoets.Integration.Data.StandAlone;
 using Ringtoets.Integration.Data.StandAlone.AssemblyFactories;
@@ -47,21 +48,30 @@
         /// </summary>
         /// <param name="failureMechanism">The <see cref="WaterPressureAsphaltCoverFailureMechanism"/> to create an
         /// <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> for.</param>
+        /// <param name="assessmentSection">The assessment section this failure mechanism belongs to.</param>
         /// <returns>An <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> with assembly results.</returns>
-        /// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/> is <c>null</c>.</exception>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
         /// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
         public static ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> CreateExportableFailureMechanism(
-            WaterPressureAsphaltCoverFailureMechanism failureMechanism)
+            WaterPressureAsphaltCoverFailureMechanism failureMechanism,
+            IAssessmentSection assessmentSection)
         {
             if (failureMechanism == null)
             {
                 throw new ArgumentNullException(nameof(failureMechanism));
             }
 
+            if (assessmentSection == null)
+            {
+                throw new ArgumentNullException(nameof(assessmentSection));
+            }
+
             if (!failureMechanism.IsRelevant)
             {
-                return ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithoutProbability(
-                    failureMechanismCode, failureMechanismGroup, failureMechanismAssemblyMethod);
+                return ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithoutProbability(assessmentSection,
+                                                                                                                   failureMechanismCode,
+                                                                                                                   failureMechanismGroup,
+                                                                                                                   failureMechanismAssemblyMethod);
             }
 
             FailureMechanismAssemblyCategoryGroup failureMechanismAssembly = WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, false);
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableGrassCoverSlipOffInwardsFailureMechanismFactoryTest.cs
===================================================================
diff -u -r6016e12690fd7208602a3236b0b09550a57ceb8f -raf392dc2e2f82efb5e3e675e4a65ae7b221072df
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableGrassCoverSlipOffInwardsFailureMechanismFactoryTest.cs	(.../ExportableGrassCoverSlipOffInwardsFailureMechanismFactoryTest.cs)	(revision 6016e12690fd7208602a3236b0b09550a57ceb8f)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableGrassCoverSlipOffInwardsFailureMechanismFactoryTest.cs	(.../ExportableGrassCoverSlipOffInwardsFailureMechanismFactoryTest.cs)	(revision af392dc2e2f82efb5e3e675e4a65ae7b221072df)
@@ -23,10 +23,12 @@
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using Rhino.Mocks;
 using Ringtoets.AssemblyTool.Data;
 using Ringtoets.AssemblyTool.KernelWrapper.Calculators;
 using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators;
 using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators.Assembly;
+using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.TestUtil;
 using Ringtoets.Common.Primitives;
 using Ringtoets.Integration.Data.StandAlone;
@@ -43,19 +45,44 @@
         [Test]
         public void CreateExportableFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
         {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             // Call
             TestDelegate call = () =>
-                ExportableGrassCoverSlipOffInwardsFailureMechanismFactory.CreateExportableFailureMechanism(null);
+                ExportableGrassCoverSlipOffInwardsFailureMechanismFactory.CreateExportableFailureMechanism(null, assessmentSection);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
             Assert.AreEqual("failureMechanism", exception.ParamName);
+
+            mocks.VerifyAll();
         }
 
         [Test]
+        public void CreateExportableFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () =>
+                ExportableGrassCoverSlipOffInwardsFailureMechanismFactory.CreateExportableFailureMechanism(new GrassCoverSlipOffInwardsFailureMechanism(), null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("assessmentSection", exception.ParamName);
+        }
+
+        [Test]
         public void CreateExportableFailureMechanism_WithFailureMechanismNotRelevant_ReturnsDefaultExportableFailureMechanism()
         {
             // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            assessmentSection.ReferenceLine = ReferenceLineTestFactory.CreateReferenceLineWithGeometry();
+
             var random = new Random(21);
             var failureMechanism = new GrassCoverSlipOffInwardsFailureMechanism
             {
@@ -65,23 +92,25 @@
 
             // Call
             ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                ExportableGrassCoverSlipOffInwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportableGrassCoverSlipOffInwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
             // Assert
-            Assert.AreEqual(ExportableFailureMechanismType.GABI, exportableFailureMechanism.Code);
-            Assert.AreEqual(ExportableFailureMechanismGroup.Group4, exportableFailureMechanism.Group);
-
-            ExportableFailureMechanismAssemblyResult failureMechanismAssemblyResult = exportableFailureMechanism.FailureMechanismAssembly;
-            Assert.AreEqual(ExportableAssemblyMethod.WBI1A1, failureMechanismAssemblyResult.AssemblyMethod);
-            Assert.AreEqual(FailureMechanismAssemblyCategoryGroup.NotApplicable, failureMechanismAssemblyResult.AssemblyCategory);
-
-            CollectionAssert.IsEmpty(exportableFailureMechanism.SectionAssemblyResults);
+            ExportableFailureMechanismTestHelper.AssertDefaultFailureMechanismWithoutProbability(assessmentSection.ReferenceLine.Points,
+                                                                                                 ExportableFailureMechanismType.GABI,
+                                                                                                 ExportableFailureMechanismGroup.Group4,
+                                                                                                 ExportableAssemblyMethod.WBI1A1,
+                                                                                                 exportableFailureMechanism);
+            mocks.VerifyAll();
         }
 
         [Test]
         public void CreateExportableFailureMechanism_WithFailureMechanismRelevant_ReturnsExportableFailureMechanism()
         {
             // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             var random = new Random(21);
             var failureMechanism = new GrassCoverSlipOffInwardsFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
@@ -94,7 +123,7 @@
 
                 // Call
                 ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                    ExportableGrassCoverSlipOffInwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                    ExportableGrassCoverSlipOffInwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Assert
                 Assert.AreEqual(ExportableFailureMechanismType.GABI, exportableFailureMechanism.Code);
@@ -114,12 +143,18 @@
                                                                exportableFailureMechanismSections,
                                                                exportableFailureMechanism.SectionAssemblyResults.Cast<ExportableAggregatedFailureMechanismSectionAssemblyResult>());
             }
+
+            mocks.VerifyAll();
         }
 
         [Test]
         public void GivenFailureMechanismWithManualAssessment_WhenCreatingExportableFailureMechanism_ThenManualAssemblyIgnored()
         {
             // Given
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             var failureMechanism = new GrassCoverSlipOffInwardsFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, 1);
             GrassCoverSlipOffInwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
@@ -132,11 +167,13 @@
                 FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
 
                 // When
-                ExportableGrassCoverSlipOffInwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportableGrassCoverSlipOffInwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Then
                 Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single());
             }
+
+            mocks.VerifyAll();
         }
 
         private static void AssertExportableFailureMechanismSectionResults(FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly,
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableGrassCoverSlipOffOutwardsFailureMechanismFactoryTest.cs
===================================================================
diff -u -r23a944dbdd57753d15e0e0369a1a851bb83f60c8 -raf392dc2e2f82efb5e3e675e4a65ae7b221072df
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableGrassCoverSlipOffOutwardsFailureMechanismFactoryTest.cs	(.../ExportableGrassCoverSlipOffOutwardsFailureMechanismFactoryTest.cs)	(revision 23a944dbdd57753d15e0e0369a1a851bb83f60c8)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableGrassCoverSlipOffOutwardsFailureMechanismFactoryTest.cs	(.../ExportableGrassCoverSlipOffOutwardsFailureMechanismFactoryTest.cs)	(revision af392dc2e2f82efb5e3e675e4a65ae7b221072df)
@@ -23,10 +23,12 @@
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using Rhino.Mocks;
 using Ringtoets.AssemblyTool.Data;
 using Ringtoets.AssemblyTool.KernelWrapper.Calculators;
 using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators;
 using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators.Assembly;
+using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.TestUtil;
 using Ringtoets.Common.Primitives;
 using Ringtoets.Integration.Data.StandAlone;
@@ -43,19 +45,44 @@
         [Test]
         public void CreateExportableFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
         {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             // Call
             TestDelegate call = () =>
-                ExportableGrassCoverSlipOffOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(null);
+                ExportableGrassCoverSlipOffOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(null, assessmentSection);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
             Assert.AreEqual("failureMechanism", exception.ParamName);
+
+            mocks.VerifyAll();
         }
 
         [Test]
+        public void CreateExportableFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () =>
+                ExportableGrassCoverSlipOffOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(new GrassCoverSlipOffOutwardsFailureMechanism(), null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("assessmentSection", exception.ParamName);
+        }
+
+        [Test]
         public void CreateExportableFailureMechanism_WithFailureMechanismNotRelevant_ReturnsDefaultExportableFailureMechanism()
         {
             // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            assessmentSection.ReferenceLine = ReferenceLineTestFactory.CreateReferenceLineWithGeometry();
+
             var random = new Random(21);
             var failureMechanism = new GrassCoverSlipOffOutwardsFailureMechanism
             {
@@ -65,23 +92,25 @@
 
             // Call
             ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                ExportableGrassCoverSlipOffOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportableGrassCoverSlipOffOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
             // Assert
-            Assert.AreEqual(ExportableFailureMechanismType.GABU, exportableFailureMechanism.Code);
-            Assert.AreEqual(ExportableFailureMechanismGroup.Group4, exportableFailureMechanism.Group);
-
-            ExportableFailureMechanismAssemblyResult failureMechanismAssemblyResult = exportableFailureMechanism.FailureMechanismAssembly;
-            Assert.AreEqual(ExportableAssemblyMethod.WBI1A1, failureMechanismAssemblyResult.AssemblyMethod);
-            Assert.AreEqual(FailureMechanismAssemblyCategoryGroup.NotApplicable, failureMechanismAssemblyResult.AssemblyCategory);
-
-            CollectionAssert.IsEmpty(exportableFailureMechanism.SectionAssemblyResults);
+            ExportableFailureMechanismTestHelper.AssertDefaultFailureMechanismWithoutProbability(assessmentSection.ReferenceLine.Points,
+                                                                                                 ExportableFailureMechanismType.GABU,
+                                                                                                 ExportableFailureMechanismGroup.Group4,
+                                                                                                 ExportableAssemblyMethod.WBI1A1,
+                                                                                                 exportableFailureMechanism);
+            mocks.VerifyAll();
         }
 
         [Test]
         public void CreateExportableFailureMechanism_WithFailureMechanismRelevant_ReturnsExportableFailureMechanism()
         {
             // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             var random = new Random(21);
             var failureMechanism = new GrassCoverSlipOffOutwardsFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
@@ -94,7 +123,7 @@
 
                 // Call
                 ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                    ExportableGrassCoverSlipOffOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                    ExportableGrassCoverSlipOffOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Assert
                 Assert.AreEqual(ExportableFailureMechanismType.GABU, exportableFailureMechanism.Code);
@@ -114,12 +143,18 @@
                                                                exportableFailureMechanismSections,
                                                                exportableFailureMechanism.SectionAssemblyResults.Cast<ExportableAggregatedFailureMechanismSectionAssemblyResult>());
             }
+
+            mocks.VerifyAll();
         }
 
         [Test]
         public void GivenFailureMechanismWithManualAssessment_WhenCreatingExportableFailureMechanism_ThenManualAssemblyIgnored()
         {
             // Given
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             var failureMechanism = new GrassCoverSlipOffOutwardsFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, 1);
             GrassCoverSlipOffOutwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
@@ -132,11 +167,13 @@
                 FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
 
                 // When
-                ExportableGrassCoverSlipOffOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportableGrassCoverSlipOffOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Then
                 Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single());
             }
+
+            mocks.VerifyAll();
         }
 
         private static void AssertExportableFailureMechanismSectionResults(FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly,
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableMicrostabilityFailureMechanismFactoryTest.cs
===================================================================
diff -u -r23a944dbdd57753d15e0e0369a1a851bb83f60c8 -raf392dc2e2f82efb5e3e675e4a65ae7b221072df
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableMicrostabilityFailureMechanismFactoryTest.cs	(.../ExportableMicrostabilityFailureMechanismFactoryTest.cs)	(revision 23a944dbdd57753d15e0e0369a1a851bb83f60c8)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableMicrostabilityFailureMechanismFactoryTest.cs	(.../ExportableMicrostabilityFailureMechanismFactoryTest.cs)	(revision af392dc2e2f82efb5e3e675e4a65ae7b221072df)
@@ -23,10 +23,12 @@
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using Rhino.Mocks;
 using Ringtoets.AssemblyTool.Data;
 using Ringtoets.AssemblyTool.KernelWrapper.Calculators;
 using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators;
 using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators.Assembly;
+using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.TestUtil;
 using Ringtoets.Common.Primitives;
 using Ringtoets.Integration.Data.StandAlone;
@@ -43,19 +45,43 @@
         [Test]
         public void CreateExportableFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
         {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             // Call
             TestDelegate call = () =>
-                ExportableMicrostabilityFailureMechanismFactory.CreateExportableFailureMechanism(null);
+                ExportableMicrostabilityFailureMechanismFactory.CreateExportableFailureMechanism(null, assessmentSection);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
             Assert.AreEqual("failureMechanism", exception.ParamName);
+
+            mocks.VerifyAll();
         }
 
+        public void CreateExportableFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () =>
+                ExportableMicrostabilityFailureMechanismFactory.CreateExportableFailureMechanism(new MicrostabilityFailureMechanism(), null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("assessmentSection", exception.ParamName);
+        }
+
         [Test]
         public void CreateExportableFailureMechanism_WithFailureMechanismNotRelevant_ReturnsDefaultExportableFailureMechanism()
         {
             // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            assessmentSection.ReferenceLine = ReferenceLineTestFactory.CreateReferenceLineWithGeometry();
+
             var random = new Random(21);
             var failureMechanism = new MicrostabilityFailureMechanism
             {
@@ -65,23 +91,25 @@
 
             // Call
             ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                ExportableMicrostabilityFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportableMicrostabilityFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
             // Assert
-            Assert.AreEqual(ExportableFailureMechanismType.STMI, exportableFailureMechanism.Code);
-            Assert.AreEqual(ExportableFailureMechanismGroup.Group4, exportableFailureMechanism.Group);
-
-            ExportableFailureMechanismAssemblyResult failureMechanismAssemblyResult = exportableFailureMechanism.FailureMechanismAssembly;
-            Assert.AreEqual(ExportableAssemblyMethod.WBI1A1, failureMechanismAssemblyResult.AssemblyMethod);
-            Assert.AreEqual(FailureMechanismAssemblyCategoryGroup.NotApplicable, failureMechanismAssemblyResult.AssemblyCategory);
-
-            CollectionAssert.IsEmpty(exportableFailureMechanism.SectionAssemblyResults);
+            ExportableFailureMechanismTestHelper.AssertDefaultFailureMechanismWithoutProbability(assessmentSection.ReferenceLine.Points,
+                                                                                                 ExportableFailureMechanismType.STMI,
+                                                                                                 ExportableFailureMechanismGroup.Group4,
+                                                                                                 ExportableAssemblyMethod.WBI1A1,
+                                                                                                 exportableFailureMechanism);
+            mocks.VerifyAll();
         }
 
         [Test]
         public void CreateExportableFailureMechanism_WithFailureMechanismRelevant_ReturnsExportableFailureMechanism()
         {
             // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             var random = new Random(21);
             var failureMechanism = new MicrostabilityFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
@@ -94,7 +122,7 @@
 
                 // Call
                 ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                    ExportableMicrostabilityFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                    ExportableMicrostabilityFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Assert
                 Assert.AreEqual(ExportableFailureMechanismType.STMI, exportableFailureMechanism.Code);
@@ -114,12 +142,18 @@
                                                                exportableFailureMechanismSections,
                                                                exportableFailureMechanism.SectionAssemblyResults.Cast<ExportableAggregatedFailureMechanismSectionAssemblyResult>());
             }
+
+            mocks.VerifyAll();
         }
 
         [Test]
         public void GivenFailureMechanismWithManualAssessment_WhenCreatingExportableFailureMechanism_ThenManualAssemblyIgnored()
         {
             // Given
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             var failureMechanism = new MicrostabilityFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, 1);
             MicrostabilityFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
@@ -132,11 +166,13 @@
                 FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
 
                 // When
-                ExportableMicrostabilityFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportableMicrostabilityFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Then
                 Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single());
             }
+
+            mocks.VerifyAll();
         }
 
         private static void AssertExportableFailureMechanismSectionResults(FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly,
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportablePipingStructureFailureMechanismFactoryTest.cs
===================================================================
diff -u -r23a944dbdd57753d15e0e0369a1a851bb83f60c8 -raf392dc2e2f82efb5e3e675e4a65ae7b221072df
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportablePipingStructureFailureMechanismFactoryTest.cs	(.../ExportablePipingStructureFailureMechanismFactoryTest.cs)	(revision 23a944dbdd57753d15e0e0369a1a851bb83f60c8)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportablePipingStructureFailureMechanismFactoryTest.cs	(.../ExportablePipingStructureFailureMechanismFactoryTest.cs)	(revision af392dc2e2f82efb5e3e675e4a65ae7b221072df)
@@ -23,10 +23,12 @@
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using Rhino.Mocks;
 using Ringtoets.AssemblyTool.Data;
 using Ringtoets.AssemblyTool.KernelWrapper.Calculators;
 using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators;
 using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators.Assembly;
+using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.TestUtil;
 using Ringtoets.Common.Primitives;
 using Ringtoets.Integration.Data.StandAlone;
@@ -43,19 +45,42 @@
         [Test]
         public void CreateExportableFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
         {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             // Call
             TestDelegate call = () =>
-                ExportablePipingStructureFailureMechanismFactory.CreateExportableFailureMechanism(null);
+                ExportablePipingStructureFailureMechanismFactory.CreateExportableFailureMechanism(null, assessmentSection);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
             Assert.AreEqual("failureMechanism", exception.ParamName);
         }
 
         [Test]
+        public void CreateExportableFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () =>
+                ExportablePipingStructureFailureMechanismFactory.CreateExportableFailureMechanism(new PipingStructureFailureMechanism(), null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("assessmentSection", exception.ParamName);
+        }
+
+        [Test]
         public void CreateExportableFailureMechanism_WithFailureMechanismNotRelevant_ReturnsDefaultExportableFailureMechanism()
         {
             // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            assessmentSection.ReferenceLine = ReferenceLineTestFactory.CreateReferenceLineWithGeometry();
+
             var random = new Random(21);
             var failureMechanism = new PipingStructureFailureMechanism
             {
@@ -65,23 +90,25 @@
 
             // Call
             ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                ExportablePipingStructureFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportablePipingStructureFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
             // Assert
-            Assert.AreEqual(ExportableFailureMechanismType.PKW, exportableFailureMechanism.Code);
-            Assert.AreEqual(ExportableFailureMechanismGroup.Group4, exportableFailureMechanism.Group);
-
-            ExportableFailureMechanismAssemblyResult failureMechanismAssemblyResult = exportableFailureMechanism.FailureMechanismAssembly;
-            Assert.AreEqual(ExportableAssemblyMethod.WBI1A1, failureMechanismAssemblyResult.AssemblyMethod);
-            Assert.AreEqual(FailureMechanismAssemblyCategoryGroup.NotApplicable, failureMechanismAssemblyResult.AssemblyCategory);
-
-            CollectionAssert.IsEmpty(exportableFailureMechanism.SectionAssemblyResults);
+            ExportableFailureMechanismTestHelper.AssertDefaultFailureMechanismWithoutProbability(assessmentSection.ReferenceLine.Points,
+                                                                                                 ExportableFailureMechanismType.PKW,
+                                                                                                 ExportableFailureMechanismGroup.Group4,
+                                                                                                 ExportableAssemblyMethod.WBI1A1,
+                                                                                                 exportableFailureMechanism);
+            mocks.VerifyAll();
         }
 
         [Test]
         public void CreateExportableFailureMechanism_WithFailureMechanismRelevant_ReturnsExportableFailureMechanism()
         {
             // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             var random = new Random(21);
             var failureMechanism = new PipingStructureFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
@@ -94,7 +121,7 @@
 
                 // Call
                 ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                    ExportablePipingStructureFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                    ExportablePipingStructureFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Assert
                 Assert.AreEqual(ExportableFailureMechanismType.PKW, exportableFailureMechanism.Code);
@@ -114,12 +141,18 @@
                                                                exportableFailureMechanismSections,
                                                                exportableFailureMechanism.SectionAssemblyResults.Cast<ExportableAggregatedFailureMechanismSectionAssemblyResult>());
             }
+
+            mocks.VerifyAll();
         }
 
         [Test]
         public void GivenFailureMechanismWithManualAssessment_WhenCreatingExportableFailureMechanism_ThenManualAssemblyIgnored()
         {
             // Given
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             var failureMechanism = new PipingStructureFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, 1);
             PipingStructureFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
@@ -132,11 +165,13 @@
                 FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
 
                 // When
-                ExportablePipingStructureFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportablePipingStructureFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Then
                 Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single());
             }
+
+            mocks.VerifyAll();
         }
 
         private static void AssertExportableFailureMechanismSectionResults(FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly,
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableStrengthStabilityLengthwiseConstructionFailureMechanismFactoryTest.cs
===================================================================
diff -u -r23a944dbdd57753d15e0e0369a1a851bb83f60c8 -raf392dc2e2f82efb5e3e675e4a65ae7b221072df
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableStrengthStabilityLengthwiseConstructionFailureMechanismFactoryTest.cs	(.../ExportableStrengthStabilityLengthwiseConstructionFailureMechanismFactoryTest.cs)	(revision 23a944dbdd57753d15e0e0369a1a851bb83f60c8)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableStrengthStabilityLengthwiseConstructionFailureMechanismFactoryTest.cs	(.../ExportableStrengthStabilityLengthwiseConstructionFailureMechanismFactoryTest.cs)	(revision af392dc2e2f82efb5e3e675e4a65ae7b221072df)
@@ -23,10 +23,12 @@
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using Rhino.Mocks;
 using Ringtoets.AssemblyTool.Data;
 using Ringtoets.AssemblyTool.KernelWrapper.Calculators;
 using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators;
 using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators.Assembly;
+using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.TestUtil;
 using Ringtoets.Common.Primitives;
 using Ringtoets.Integration.Data.StandAlone;
@@ -43,19 +45,44 @@
         [Test]
         public void CreateExportableFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
         {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             // Call
             TestDelegate call = () =>
-                ExportableStrengthStabilityLengthwiseConstructionFailureMechanismFactory.CreateExportableFailureMechanism(null);
+                ExportableStrengthStabilityLengthwiseConstructionFailureMechanismFactory.CreateExportableFailureMechanism(null, assessmentSection);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
             Assert.AreEqual("failureMechanism", exception.ParamName);
+
+            mocks.VerifyAll();
         }
+        
+        [Test]
+        public void CreateExportableFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () =>
+                ExportableStrengthStabilityLengthwiseConstructionFailureMechanismFactory.CreateExportableFailureMechanism(new StrengthStabilityLengthwiseConstructionFailureMechanism(), null);
 
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("assessmentSection", exception.ParamName);
+        }
+
         [Test]
         public void CreateExportableFailureMechanism_WithFailureMechanismNotRelevant_ReturnsDefaultExportableFailureMechanism()
         {
             // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            assessmentSection.ReferenceLine = ReferenceLineTestFactory.CreateReferenceLineWithGeometry();
+
             var random = new Random(21);
             var failureMechanism = new StrengthStabilityLengthwiseConstructionFailureMechanism
             {
@@ -65,23 +92,25 @@
 
             // Call
             ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                ExportableStrengthStabilityLengthwiseConstructionFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportableStrengthStabilityLengthwiseConstructionFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
             // Assert
-            Assert.AreEqual(ExportableFailureMechanismType.STKWl, exportableFailureMechanism.Code);
-            Assert.AreEqual(ExportableFailureMechanismGroup.Group4, exportableFailureMechanism.Group);
-
-            ExportableFailureMechanismAssemblyResult failureMechanismAssemblyResult = exportableFailureMechanism.FailureMechanismAssembly;
-            Assert.AreEqual(ExportableAssemblyMethod.WBI1A1, failureMechanismAssemblyResult.AssemblyMethod);
-            Assert.AreEqual(FailureMechanismAssemblyCategoryGroup.NotApplicable, failureMechanismAssemblyResult.AssemblyCategory);
-
-            CollectionAssert.IsEmpty(exportableFailureMechanism.SectionAssemblyResults);
+            ExportableFailureMechanismTestHelper.AssertDefaultFailureMechanismWithoutProbability(assessmentSection.ReferenceLine.Points,
+                                                                                                 ExportableFailureMechanismType.STKWl,
+                                                                                                 ExportableFailureMechanismGroup.Group4,
+                                                                                                 ExportableAssemblyMethod.WBI1A1,
+                                                                                                 exportableFailureMechanism);
+            mocks.VerifyAll();
         }
 
         [Test]
         public void CreateExportableFailureMechanism_WithFailureMechanismRelevant_ReturnsExportableFailureMechanism()
         {
             // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             var random = new Random(21);
             var failureMechanism = new StrengthStabilityLengthwiseConstructionFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
@@ -94,7 +123,7 @@
 
                 // Call
                 ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                    ExportableStrengthStabilityLengthwiseConstructionFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                    ExportableStrengthStabilityLengthwiseConstructionFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Assert
                 Assert.AreEqual(ExportableFailureMechanismType.STKWl, exportableFailureMechanism.Code);
@@ -113,6 +142,8 @@
                                                                exportableFailureMechanismSections,
                                                                exportableFailureMechanism.SectionAssemblyResults.Cast<ExportableAggregatedFailureMechanismSectionAssemblyResultWithoutDetailedAssembly>());
             }
+
+            mocks.VerifyAll();
         }
 
         [Test]
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableTechnicalInnovationFailureMechanismFactoryTest.cs
===================================================================
diff -u -r23a944dbdd57753d15e0e0369a1a851bb83f60c8 -raf392dc2e2f82efb5e3e675e4a65ae7b221072df
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableTechnicalInnovationFailureMechanismFactoryTest.cs	(.../ExportableTechnicalInnovationFailureMechanismFactoryTest.cs)	(revision 23a944dbdd57753d15e0e0369a1a851bb83f60c8)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableTechnicalInnovationFailureMechanismFactoryTest.cs	(.../ExportableTechnicalInnovationFailureMechanismFactoryTest.cs)	(revision af392dc2e2f82efb5e3e675e4a65ae7b221072df)
@@ -23,10 +23,12 @@
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using Rhino.Mocks;
 using Ringtoets.AssemblyTool.Data;
 using Ringtoets.AssemblyTool.KernelWrapper.Calculators;
 using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators;
 using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators.Assembly;
+using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.TestUtil;
 using Ringtoets.Common.Primitives;
 using Ringtoets.Integration.Data.StandAlone;
@@ -43,19 +45,44 @@
         [Test]
         public void CreateExportableFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
         {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             // Call
             TestDelegate call = () =>
-                ExportableTechnicalInnovationFailureMechanismFactory.CreateExportableFailureMechanism(null);
+                ExportableTechnicalInnovationFailureMechanismFactory.CreateExportableFailureMechanism(null, assessmentSection);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
             Assert.AreEqual("failureMechanism", exception.ParamName);
+
+            mocks.VerifyAll();
         }
 
         [Test]
+        public void CreateExportableFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () =>
+                ExportableTechnicalInnovationFailureMechanismFactory.CreateExportableFailureMechanism(new TechnicalInnovationFailureMechanism(), null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("assessmentSection", exception.ParamName);
+        }
+
+        [Test]
         public void CreateExportableFailureMechanism_WithFailureMechanismNotRelevant_ReturnsDefaultExportableFailureMechanism()
         {
             // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            assessmentSection.ReferenceLine = ReferenceLineTestFactory.CreateReferenceLineWithGeometry();
+
             var random = new Random(21);
             var failureMechanism = new TechnicalInnovationFailureMechanism
             {
@@ -65,23 +92,25 @@
 
             // Call
             ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                ExportableTechnicalInnovationFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportableTechnicalInnovationFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
             // Assert
-            Assert.AreEqual(ExportableFailureMechanismType.INN, exportableFailureMechanism.Code);
-            Assert.AreEqual(ExportableFailureMechanismGroup.Group4, exportableFailureMechanism.Group);
-
-            ExportableFailureMechanismAssemblyResult failureMechanismAssemblyResult = exportableFailureMechanism.FailureMechanismAssembly;
-            Assert.AreEqual(ExportableAssemblyMethod.WBI1A1, failureMechanismAssemblyResult.AssemblyMethod);
-            Assert.AreEqual(FailureMechanismAssemblyCategoryGroup.NotApplicable, failureMechanismAssemblyResult.AssemblyCategory);
-
-            CollectionAssert.IsEmpty(exportableFailureMechanism.SectionAssemblyResults);
+            ExportableFailureMechanismTestHelper.AssertDefaultFailureMechanismWithoutProbability(assessmentSection.ReferenceLine.Points,
+                                                                                                 ExportableFailureMechanismType.INN,
+                                                                                                 ExportableFailureMechanismGroup.Group4,
+                                                                                                 ExportableAssemblyMethod.WBI1A1,
+                                                                                                 exportableFailureMechanism);
+            mocks.VerifyAll();
         }
 
         [Test]
         public void CreateExportableFailureMechanism_WithFailureMechanismRelevant_ReturnsExportableFailureMechanism()
         {
             // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             var random = new Random(21);
             var failureMechanism = new TechnicalInnovationFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
@@ -94,7 +123,7 @@
 
                 // Call
                 ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                    ExportableTechnicalInnovationFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                    ExportableTechnicalInnovationFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Assert
                 Assert.AreEqual(ExportableFailureMechanismType.INN, exportableFailureMechanism.Code);
@@ -113,12 +142,18 @@
                                                                exportableFailureMechanismSections,
                                                                exportableFailureMechanism.SectionAssemblyResults.Cast<ExportableAggregatedFailureMechanismSectionAssemblyResultWithoutDetailedAssembly>());
             }
+
+            mocks.VerifyAll();
         }
 
         [Test]
         public void GivenFailureMechanismWithManualAssessment_WhenCreatingExportableFailureMechanism_ThenManualAssemblyIgnored()
         {
             // Given
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             var failureMechanism = new TechnicalInnovationFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, 1);
             TechnicalInnovationFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
@@ -131,11 +166,13 @@
                 FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
 
                 // When
-                ExportableTechnicalInnovationFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportableTechnicalInnovationFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Then
                 Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single());
             }
+
+            mocks.VerifyAll();
         }
 
         private static void AssertExportableFailureMechanismSectionResults(FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly,
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableWaterPressureAsphaltCoverFailureMechanismFactoryTest.cs
===================================================================
diff -u -r23a944dbdd57753d15e0e0369a1a851bb83f60c8 -raf392dc2e2f82efb5e3e675e4a65ae7b221072df
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableWaterPressureAsphaltCoverFailureMechanismFactoryTest.cs	(.../ExportableWaterPressureAsphaltCoverFailureMechanismFactoryTest.cs)	(revision 23a944dbdd57753d15e0e0369a1a851bb83f60c8)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableWaterPressureAsphaltCoverFailureMechanismFactoryTest.cs	(.../ExportableWaterPressureAsphaltCoverFailureMechanismFactoryTest.cs)	(revision af392dc2e2f82efb5e3e675e4a65ae7b221072df)
@@ -23,10 +23,12 @@
 using System.Collections.Generic;
 using System.Linq;
 using NUnit.Framework;
+using Rhino.Mocks;
 using Ringtoets.AssemblyTool.Data;
 using Ringtoets.AssemblyTool.KernelWrapper.Calculators;
 using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators;
 using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators.Assembly;
+using Ringtoets.Common.Data.AssessmentSection;
 using Ringtoets.Common.Data.TestUtil;
 using Ringtoets.Common.Primitives;
 using Ringtoets.Integration.Data.StandAlone;
@@ -43,19 +45,44 @@
         [Test]
         public void CreateExportableFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
         {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             // Call
             TestDelegate call = () =>
-                ExportableWaterPressureAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(null);
+                ExportableWaterPressureAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(null, assessmentSection);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
             Assert.AreEqual("failureMechanism", exception.ParamName);
+
+            mocks.VerifyAll();
         }
 
         [Test]
+        public void CreateExportableFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () =>
+                ExportableWaterPressureAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(new WaterPressureAsphaltCoverFailureMechanism(), null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("assessmentSection", exception.ParamName);
+        }
+
+        [Test]
         public void CreateExportableFailureMechanism_WithFailureMechanismNotRelevant_ReturnsDefaultExportableFailureMechanism()
         {
             // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            assessmentSection.ReferenceLine = ReferenceLineTestFactory.CreateReferenceLineWithGeometry();
+
             var random = new Random(21);
             var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism
             {
@@ -65,23 +92,25 @@
 
             // Call
             ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                ExportableWaterPressureAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportableWaterPressureAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
             // Assert
-            Assert.AreEqual(ExportableFailureMechanismType.AWO, exportableFailureMechanism.Code);
-            Assert.AreEqual(ExportableFailureMechanismGroup.Group4, exportableFailureMechanism.Group);
-
-            ExportableFailureMechanismAssemblyResult failureMechanismAssemblyResult = exportableFailureMechanism.FailureMechanismAssembly;
-            Assert.AreEqual(ExportableAssemblyMethod.WBI1A1, failureMechanismAssemblyResult.AssemblyMethod);
-            Assert.AreEqual(FailureMechanismAssemblyCategoryGroup.NotApplicable, failureMechanismAssemblyResult.AssemblyCategory);
-
-            CollectionAssert.IsEmpty(exportableFailureMechanism.SectionAssemblyResults);
+            ExportableFailureMechanismTestHelper.AssertDefaultFailureMechanismWithoutProbability(assessmentSection.ReferenceLine.Points,
+                                                                                                 ExportableFailureMechanismType.AWO,
+                                                                                                 ExportableFailureMechanismGroup.Group4,
+                                                                                                 ExportableAssemblyMethod.WBI1A1,
+                                                                                                 exportableFailureMechanism);
+            mocks.VerifyAll();
         }
 
         [Test]
         public void CreateExportableFailureMechanism_WithFailureMechanismRelevant_ReturnsExportableFailureMechanism()
         {
             // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             var random = new Random(21);
             var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
@@ -94,7 +123,7 @@
 
                 // Call
                 ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                    ExportableWaterPressureAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                    ExportableWaterPressureAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Assert
                 Assert.AreEqual(ExportableFailureMechanismType.AWO, exportableFailureMechanism.Code);
@@ -113,12 +142,18 @@
                                                                exportableFailureMechanismSections,
                                                                exportableFailureMechanism.SectionAssemblyResults.Cast<ExportableAggregatedFailureMechanismSectionAssemblyResultWithoutDetailedAssembly>());
             }
+
+            mocks.VerifyAll();
         }
 
         [Test]
         public void GivenFailureMechanismWithManualAssessment_WhenCreatingExportableFailureMechanism_ThenManualAssemblyIgnored()
         {
             // Given
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, 1);
             WaterPressureAsphaltCoverFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
@@ -131,11 +166,13 @@
                 FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
 
                 // When
-                ExportableWaterPressureAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportableWaterPressureAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Then
                 Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single());
             }
+
+            mocks.VerifyAll();
         }
 
         private static void AssertExportableFailureMechanismSectionResults(FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly,