Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableDuneErosionFailureMechanismFactory.cs
===================================================================
diff -u -rf64eced75276485428862c10ba94360e9b671890 -r167fd66fa9378da0a15ff7c6d2646fbe7ddabe06
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableDuneErosionFailureMechanismFactory.cs	(.../ExportableDuneErosionFailureMechanismFactory.cs)	(revision f64eced75276485428862c10ba94360e9b671890)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableDuneErosionFailureMechanismFactory.cs	(.../ExportableDuneErosionFailureMechanismFactory.cs)	(revision 167fd66fa9378da0a15ff7c6d2646fbe7ddabe06)
@@ -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.DuneErosion.Data;
 using Ringtoets.Integration.IO.Assembly;
@@ -45,21 +46,30 @@
         /// </summary>
         /// <param name="failureMechanism">The <see cref="DuneErosionFailureMechanism"/> 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(
-            DuneErosionFailureMechanism failureMechanism)
+            DuneErosionFailureMechanism 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 = DuneErosionFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, false);
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableGrassCoverErosionOutwardsFailureMechanismFactory.cs
===================================================================
diff -u -r23a944dbdd57753d15e0e0369a1a851bb83f60c8 -r167fd66fa9378da0a15ff7c6d2646fbe7ddabe06
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableGrassCoverErosionOutwardsFailureMechanismFactory.cs	(.../ExportableGrassCoverErosionOutwardsFailureMechanismFactory.cs)	(revision 23a944dbdd57753d15e0e0369a1a851bb83f60c8)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableGrassCoverErosionOutwardsFailureMechanismFactory.cs	(.../ExportableGrassCoverErosionOutwardsFailureMechanismFactory.cs)	(revision 167fd66fa9378da0a15ff7c6d2646fbe7ddabe06)
@@ -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.GrassCoverErosionOutwards.Data;
 using Ringtoets.Integration.IO.Assembly;
@@ -45,21 +46,30 @@
         /// </summary>
         /// <param name="failureMechanism">The <see cref="GrassCoverErosionOutwardsFailureMechanism"/> 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(
-            GrassCoverErosionOutwardsFailureMechanism failureMechanism)
+            GrassCoverErosionOutwardsFailureMechanism 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 = GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, false);
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableStabilityStoneCoverFailureMechanismFactory.cs
===================================================================
diff -u -rf4f9469d89fb6c1d214d4478bcf39b70f88de3e0 -r167fd66fa9378da0a15ff7c6d2646fbe7ddabe06
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableStabilityStoneCoverFailureMechanismFactory.cs	(.../ExportableStabilityStoneCoverFailureMechanismFactory.cs)	(revision f4f9469d89fb6c1d214d4478bcf39b70f88de3e0)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableStabilityStoneCoverFailureMechanismFactory.cs	(.../ExportableStabilityStoneCoverFailureMechanismFactory.cs)	(revision 167fd66fa9378da0a15ff7c6d2646fbe7ddabe06)
@@ -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.IO.Assembly;
 using Ringtoets.Integration.IO.Helpers;
@@ -45,21 +46,30 @@
         /// </summary>
         /// <param name="failureMechanism">The <see cref="StabilityStoneCoverFailureMechanism"/> 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(
-            StabilityStoneCoverFailureMechanism failureMechanism)
+            StabilityStoneCoverFailureMechanism 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 = StabilityStoneCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, false);
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableWaveImpactAsphaltCoverFailureMechanismFactory.cs
===================================================================
diff -u -rf4f9469d89fb6c1d214d4478bcf39b70f88de3e0 -r167fd66fa9378da0a15ff7c6d2646fbe7ddabe06
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableWaveImpactAsphaltCoverFailureMechanismFactory.cs	(.../ExportableWaveImpactAsphaltCoverFailureMechanismFactory.cs)	(revision f4f9469d89fb6c1d214d4478bcf39b70f88de3e0)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableWaveImpactAsphaltCoverFailureMechanismFactory.cs	(.../ExportableWaveImpactAsphaltCoverFailureMechanismFactory.cs)	(revision 167fd66fa9378da0a15ff7c6d2646fbe7ddabe06)
@@ -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.IO.Assembly;
 using Ringtoets.Integration.IO.Helpers;
@@ -45,21 +46,30 @@
         /// </summary>
         /// <param name="failureMechanism">The <see cref="WaveImpactAsphaltCoverFailureMechanism"/> 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(
-            WaveImpactAsphaltCoverFailureMechanism failureMechanism)
+            WaveImpactAsphaltCoverFailureMechanism 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 = WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, false);
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableDuneErosionFailureMechanismFactoryTest.cs
===================================================================
diff -u -rf64eced75276485428862c10ba94360e9b671890 -r167fd66fa9378da0a15ff7c6d2646fbe7ddabe06
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableDuneErosionFailureMechanismFactoryTest.cs	(.../ExportableDuneErosionFailureMechanismFactoryTest.cs)	(revision f64eced75276485428862c10ba94360e9b671890)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableDuneErosionFailureMechanismFactoryTest.cs	(.../ExportableDuneErosionFailureMechanismFactoryTest.cs)	(revision 167fd66fa9378da0a15ff7c6d2646fbe7ddabe06)
@@ -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.DuneErosion.Data;
 using Ringtoets.Integration.IO.Assembly;
@@ -41,19 +43,44 @@
         [Test]
         public void CreateExportableFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
         {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             // Call
             TestDelegate call = () =>
-                ExportableDuneErosionFailureMechanismFactory.CreateExportableFailureMechanism(null);
+                ExportableDuneErosionFailureMechanismFactory.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 = () =>
+                ExportableDuneErosionFailureMechanismFactory.CreateExportableFailureMechanism(new DuneErosionFailureMechanism(), 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 DuneErosionFailureMechanism
             {
@@ -63,23 +90,25 @@
 
             // Call
             ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                ExportableDuneErosionFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportableDuneErosionFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
             // Assert
-            Assert.AreEqual(ExportableFailureMechanismType.DA, exportableFailureMechanism.Code);
-            Assert.AreEqual(ExportableFailureMechanismGroup.Group3, 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.DA,
+                                                                                                 ExportableFailureMechanismGroup.Group3,
+                                                                                                 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 DuneErosionFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
@@ -92,7 +121,7 @@
 
                 // Call
                 ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                    ExportableDuneErosionFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                    ExportableDuneErosionFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Assert
                 Assert.AreEqual(ExportableFailureMechanismType.DA, exportableFailureMechanism.Code);
@@ -111,12 +140,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 DuneErosionFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, 1);
             DuneErosionFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
@@ -129,11 +164,13 @@
                 FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
 
                 // When
-                ExportableDuneErosionFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportableDuneErosionFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Then
                 Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.Iv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single());
             }
+
+            mocks.VerifyAll();
         }
 
         private static void AssertExportableFailureMechanismSectionResults(FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly,
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableGrassCoverErosionOutwardsFailureMechanismFactoryTest.cs
===================================================================
diff -u -r23a944dbdd57753d15e0e0369a1a851bb83f60c8 -r167fd66fa9378da0a15ff7c6d2646fbe7ddabe06
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableGrassCoverErosionOutwardsFailureMechanismFactoryTest.cs	(.../ExportableGrassCoverErosionOutwardsFailureMechanismFactoryTest.cs)	(revision 23a944dbdd57753d15e0e0369a1a851bb83f60c8)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableGrassCoverErosionOutwardsFailureMechanismFactoryTest.cs	(.../ExportableGrassCoverErosionOutwardsFailureMechanismFactoryTest.cs)	(revision 167fd66fa9378da0a15ff7c6d2646fbe7ddabe06)
@@ -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.GrassCoverErosionOutwards.Data;
 using Ringtoets.Integration.IO.Assembly;
@@ -41,19 +43,44 @@
         [Test]
         public void CreateExportableFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
         {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             // Call
             TestDelegate call = () =>
-                ExportableGrassCoverErosionOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(null);
+                ExportableGrassCoverErosionOutwardsFailureMechanismFactory.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 = () =>
+                ExportableGrassCoverErosionOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(new GrassCoverErosionOutwardsFailureMechanism(), 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 GrassCoverErosionOutwardsFailureMechanism
             {
@@ -63,23 +90,25 @@
 
             // Call
             ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                ExportableGrassCoverErosionOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportableGrassCoverErosionOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
             // Assert
-            Assert.AreEqual(ExportableFailureMechanismType.GEBU, exportableFailureMechanism.Code);
-            Assert.AreEqual(ExportableFailureMechanismGroup.Group3, 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.GEBU,
+                                                                                                 ExportableFailureMechanismGroup.Group3,
+                                                                                                 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 GrassCoverErosionOutwardsFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
@@ -92,7 +121,7 @@
 
                 // Call
                 ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                    ExportableGrassCoverErosionOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                    ExportableGrassCoverErosionOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Assert
                 Assert.AreEqual(ExportableFailureMechanismType.GEBU, exportableFailureMechanism.Code);
@@ -112,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 GrassCoverErosionOutwardsFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, 1);
             GrassCoverErosionOutwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
@@ -130,11 +165,13 @@
                 FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
 
                 // When
-                ExportableGrassCoverErosionOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportableGrassCoverErosionOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Then
                 Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.Iv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single());
             }
+
+            mocks.VerifyAll();
         }
 
         private static void AssertExportableFailureMechanismSectionResults(FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly,
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableStabilityStoneCoverFailureMechanismFactoryTest.cs
===================================================================
diff -u -rf4f9469d89fb6c1d214d4478bcf39b70f88de3e0 -r167fd66fa9378da0a15ff7c6d2646fbe7ddabe06
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableStabilityStoneCoverFailureMechanismFactoryTest.cs	(.../ExportableStabilityStoneCoverFailureMechanismFactoryTest.cs)	(revision f4f9469d89fb6c1d214d4478bcf39b70f88de3e0)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableStabilityStoneCoverFailureMechanismFactoryTest.cs	(.../ExportableStabilityStoneCoverFailureMechanismFactoryTest.cs)	(revision 167fd66fa9378da0a15ff7c6d2646fbe7ddabe06)
@@ -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.Integration.IO.Assembly;
 using Ringtoets.Integration.IO.Factories;
@@ -41,19 +43,44 @@
         [Test]
         public void CreateExportableFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
         {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             // Call
             TestDelegate call = () =>
-                ExportableStabilityStoneCoverFailureMechanismFactory.CreateExportableFailureMechanism(null);
+                ExportableStabilityStoneCoverFailureMechanismFactory.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 = () =>
+                ExportableStabilityStoneCoverFailureMechanismFactory.CreateExportableFailureMechanism(new StabilityStoneCoverFailureMechanism(), 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 StabilityStoneCoverFailureMechanism
             {
@@ -63,23 +90,25 @@
 
             // Call
             ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                ExportableStabilityStoneCoverFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportableStabilityStoneCoverFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
             // Assert
-            Assert.AreEqual(ExportableFailureMechanismType.ZST, exportableFailureMechanism.Code);
-            Assert.AreEqual(ExportableFailureMechanismGroup.Group3, 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.ZST,
+                                                                                                 ExportableFailureMechanismGroup.Group3,
+                                                                                                 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 StabilityStoneCoverFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
@@ -92,7 +121,7 @@
 
                 // Call
                 ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                    ExportableStabilityStoneCoverFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                    ExportableStabilityStoneCoverFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Assert
                 Assert.AreEqual(ExportableFailureMechanismType.ZST, exportableFailureMechanism.Code);
@@ -112,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 StabilityStoneCoverFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, 1);
             StabilityStoneCoverFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
@@ -130,11 +165,13 @@
                 FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
 
                 // When
-                ExportableStabilityStoneCoverFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportableStabilityStoneCoverFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Then
                 Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.Iv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single());
             }
+
+            mocks.VerifyAll();
         }
 
         private static void AssertExportableFailureMechanismSectionResults(FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly,
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableWaveImpactAsphaltCoverFailureMechanismFactoryTest.cs
===================================================================
diff -u -rf4f9469d89fb6c1d214d4478bcf39b70f88de3e0 -r167fd66fa9378da0a15ff7c6d2646fbe7ddabe06
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableWaveImpactAsphaltCoverFailureMechanismFactoryTest.cs	(.../ExportableWaveImpactAsphaltCoverFailureMechanismFactoryTest.cs)	(revision f4f9469d89fb6c1d214d4478bcf39b70f88de3e0)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableWaveImpactAsphaltCoverFailureMechanismFactoryTest.cs	(.../ExportableWaveImpactAsphaltCoverFailureMechanismFactoryTest.cs)	(revision 167fd66fa9378da0a15ff7c6d2646fbe7ddabe06)
@@ -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.Integration.IO.Assembly;
 using Ringtoets.Integration.IO.Factories;
@@ -41,19 +43,44 @@
         [Test]
         public void CreateExportableFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
         {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
             // Call
             TestDelegate call = () =>
-                ExportableWaveImpactAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(null);
+                ExportableWaveImpactAsphaltCoverFailureMechanismFactory.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 = () =>
+                ExportableWaveImpactAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(new WaveImpactAsphaltCoverFailureMechanism(), 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 WaveImpactAsphaltCoverFailureMechanism
             {
@@ -63,23 +90,25 @@
 
             // Call
             ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                ExportableWaveImpactAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportableWaveImpactAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
             // Assert
-            Assert.AreEqual(ExportableFailureMechanismType.AGK, exportableFailureMechanism.Code);
-            Assert.AreEqual(ExportableFailureMechanismGroup.Group3, 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.AGK,
+                                                                                                 ExportableFailureMechanismGroup.Group3,
+                                                                                                 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 WaveImpactAsphaltCoverFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
@@ -92,7 +121,7 @@
 
                 // Call
                 ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                    ExportableWaveImpactAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                    ExportableWaveImpactAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Assert
                 Assert.AreEqual(ExportableFailureMechanismType.AGK, exportableFailureMechanism.Code);
@@ -112,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 WaveImpactAsphaltCoverFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, 1);
             WaveImpactAsphaltCoverFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
@@ -130,11 +165,13 @@
                 FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
 
                 // When
-                ExportableWaveImpactAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism);
+                ExportableWaveImpactAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(failureMechanism, assessmentSection);
 
                 // Then
                 Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.Iv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single());
             }
+
+            mocks.VerifyAll();
         }
 
         private static void AssertExportableFailureMechanismSectionResults(FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly,
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.TestUtil/ExportableFailureMechanismTestHelper.cs
===================================================================
diff -u -r6016e12690fd7208602a3236b0b09550a57ceb8f -r167fd66fa9378da0a15ff7c6d2646fbe7ddabe06
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.TestUtil/ExportableFailureMechanismTestHelper.cs	(.../ExportableFailureMechanismTestHelper.cs)	(revision 6016e12690fd7208602a3236b0b09550a57ceb8f)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.TestUtil/ExportableFailureMechanismTestHelper.cs	(.../ExportableFailureMechanismTestHelper.cs)	(revision 167fd66fa9378da0a15ff7c6d2646fbe7ddabe06)
@@ -34,7 +34,7 @@
     public static class ExportableFailureMechanismTestHelper
     {
         /// <summary>
-        /// Asserts the default failure mechanism.
+        /// Asserts a default failure mechanism that contains assembly results with a probability.
         /// </summary>
         /// <param name="geometry">The expected geometry of the section it contains.</param>
         /// <param name="failureMechanismCode">The expected <see cref="ExportableFailureMechanismType"/>.</param>
@@ -74,5 +74,45 @@
             Assert.AreEqual(0, failureMechanismSection.StartDistance);
             Assert.AreEqual(Math2D.Length(geometry), failureMechanismSection.EndDistance);
         }
+
+        /// <summary>
+        /// Asserts a default failure mechanism that contains assembly results without a probability.
+        /// </summary>
+        /// <param name="geometry">The expected geometry of the section it contains.</param>
+        /// <param name="failureMechanismCode">The expected <see cref="ExportableFailureMechanismType"/>.</param>
+        /// <param name="group">The expected <see cref="ExportableFailureMechanismGroup"/>.</param>
+        /// <param name="failureMechanismAssemblyMethod">The expected <see cref="ExportableAssemblyMethod"/> which is used
+        /// to generate a failure mechanism assembly result.</param>
+        /// <param name="exportableFailureMechanism">The <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> to assert.</param>
+        /// <exception cref="AssertionException">Thrown when:
+        /// <list type="bullet">
+        /// <item>The geometry defined by <paramref name="geometry"/> does not match with the section contained in <paramref name="exportableFailureMechanism"/>.</item>
+        /// <item>The values in <paramref name="exportableFailureMechanism"/> do not match with
+        /// <paramref name="failureMechanismCode"/>, <paramref name="group"/> or <see cref="failureMechanismAssemblyMethod"/>.</item>
+        /// </list></exception>
+        public static void AssertDefaultFailureMechanismWithoutProbability(IEnumerable<Point2D> geometry,
+                                                                           ExportableFailureMechanismType failureMechanismCode,
+                                                                           ExportableFailureMechanismGroup group,
+                                                                           ExportableAssemblyMethod failureMechanismAssemblyMethod,
+                                                                           ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism)
+        {
+            Assert.AreEqual(group, exportableFailureMechanism.Group);
+            Assert.AreEqual(failureMechanismCode, exportableFailureMechanism.Code);
+
+            ExportableFailureMechanismAssemblyResult failureMechanismAssemblyResult = exportableFailureMechanism.FailureMechanismAssembly;
+            Assert.AreEqual(failureMechanismAssemblyMethod, failureMechanismAssemblyResult.AssemblyMethod);
+            Assert.AreEqual(FailureMechanismAssemblyCategoryGroup.NotApplicable, failureMechanismAssemblyResult.AssemblyCategory);
+
+            var exportableFailureMechanismSectionAssembly =
+                (ExportableAggregatedFailureMechanismSectionAssemblyWithCombinedResult) exportableFailureMechanism.SectionAssemblyResults.Single();
+            ExportableSectionAssemblyResult combinedAssembly = exportableFailureMechanismSectionAssembly.CombinedAssembly;
+            Assert.AreEqual(ExportableAssemblyMethod.WBI0A1, combinedAssembly.AssemblyMethod);
+            Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, combinedAssembly.AssemblyCategory);
+
+            ExportableFailureMechanismSection failureMechanismSection = exportableFailureMechanismSectionAssembly.FailureMechanismSection;
+            Assert.AreSame(geometry, failureMechanismSection.Geometry);
+            Assert.AreEqual(0, failureMechanismSection.StartDistance);
+            Assert.AreEqual(Math2D.Length(geometry), failureMechanismSection.EndDistance);
+        }
     }
 }
\ No newline at end of file