Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableFailureMechanismFactory.cs
===================================================================
diff -u -r36cbe3953e6106ff92f09faa67b69ed8c666bd5e -re95af7d5b640887adf56f6bbd822d7d9341c49c2
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableFailureMechanismFactory.cs	(.../ExportableFailureMechanismFactory.cs)	(revision 36cbe3953e6106ff92f09faa67b69ed8c666bd5e)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableFailureMechanismFactory.cs	(.../ExportableFailureMechanismFactory.cs)	(revision e95af7d5b640887adf56f6bbd822d7d9341c49c2)
@@ -38,22 +38,22 @@
         /// <param name="assessmentSection">The assessment section the failure mechanism belongs to.</param>
         /// <param name="failureMechanismCode">The <see cref="ExportableFailureMechanismType"/> of the failure mechanism.</param>
         /// <param name="failureMechanismGroup">The <see cref="ExportableFailureMechanismGroup"/> of the failure mechanism.</param>
-        /// <param name="failureMechanismAssemblyMethod">The assembly method which is used to obtain the general assembly result of the failure mechanism.</param>
+        /// <param name="assemblyMethod">The assembly method which is used to obtain the general assembly result of the failure mechanism.</param>
         /// <returns>An <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> with default values.</returns>
         /// <exception cref="ArgumentNullException">Thrown when <paramref name="assessmentSection"/> is <c>null</c>.</exception>
         public static ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> CreateDefaultExportableFailureMechanismWithProbability(
             IAssessmentSection assessmentSection,
             ExportableFailureMechanismType failureMechanismCode,
             ExportableFailureMechanismGroup failureMechanismGroup,
-            ExportableAssemblyMethod failureMechanismAssemblyMethod)
+            ExportableAssemblyMethod assemblyMethod)
         {
             if (assessmentSection == null)
             {
                 throw new ArgumentNullException(nameof(assessmentSection));
             }
 
             return new ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>(
-                new ExportableFailureMechanismAssemblyResultWithProbability(failureMechanismAssemblyMethod,
+                new ExportableFailureMechanismAssemblyResultWithProbability(assemblyMethod,
                                                                             FailureMechanismAssemblyCategoryGroup.NotApplicable,
                                                                             0),
                 new[]
@@ -71,18 +71,26 @@
         /// Creates a default instance of an <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/>
         /// without a probability based on its input parameters.
         /// </summary>
+        /// <param name="assessmentSection">The assessment section the failure mechanism belongs to.</param>
         /// <param name="failureMechanismCode">The <see cref="ExportableFailureMechanismType"/> of the failure mechanism.</param>
         /// <param name="failureMechanismGroup">The <see cref="ExportableFailureMechanismGroup"/> of the failure mechanism.</param>
         /// <param name="assemblyMethod">The assembly method which is used to obtain the general assembly result of the failure mechanism.</param>
         /// <returns>An <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> with default values.</returns>
         public static ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> CreateDefaultExportableFailureMechanismWithoutProbability(
+            IAssessmentSection assessmentSection,
             ExportableFailureMechanismType failureMechanismCode,
             ExportableFailureMechanismGroup failureMechanismGroup,
             ExportableAssemblyMethod assemblyMethod)
         {
             return new ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>(
                 new ExportableFailureMechanismAssemblyResult(assemblyMethod,
                                                              FailureMechanismAssemblyCategoryGroup.NotApplicable),
+                new[]
+                {
+                    new ExportableAggregatedFailureMechanismSectionAssemblyWithCombinedResult(CreateExportableFailureMechanismSection(assessmentSection.ReferenceLine),
+                                                                                              new ExportableSectionAssemblyResult(ExportableAssemblyMethod.WBI0A1,
+                                                                                                                                  FailureMechanismSectionAssemblyCategoryGroup.NotApplicable))
+                },
                 failureMechanismCode,
                 failureMechanismGroup);
         }
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableFailureMechanismFactoryTest.cs
===================================================================
diff -u -r6016e12690fd7208602a3236b0b09550a57ceb8f -re95af7d5b640887adf56f6bbd822d7d9341c49c2
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableFailureMechanismFactoryTest.cs	(.../ExportableFailureMechanismFactoryTest.cs)	(revision 6016e12690fd7208602a3236b0b09550a57ceb8f)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableFailureMechanismFactoryTest.cs	(.../ExportableFailureMechanismFactoryTest.cs)	(revision e95af7d5b640887adf56f6bbd822d7d9341c49c2)
@@ -58,15 +58,14 @@
         public void CreateDefaultExportableFailureMechanismWithProbability_WithValidArguments_ReturnsExportableFailureMechanism()
         {
             // Setup
-            var random = new Random(21);
-
             var mocks = new MockRepository();
             var assessmentSection = mocks.Stub<IAssessmentSection>();
             mocks.ReplayAll();
 
             ReferenceLine referenceLine = ReferenceLineTestFactory.CreateReferenceLineWithGeometry();
             assessmentSection.ReferenceLine = referenceLine;
 
+            var random = new Random(21);
             var group = random.NextEnumValue<ExportableFailureMechanismGroup>();
             var failureMechanismCode = random.NextEnumValue<ExportableFailureMechanismType>();
             var failureMechanismAssemblyMethod = random.NextEnumValue<ExportableAssemblyMethod>();
@@ -101,17 +100,46 @@
         }
 
         [Test]
-        public void CreateDefaultExportableFailureMechanismWithoutProbability_Always_ReturnsExportableFailureMechanism()
+        public void CreateDefaultExportableFailureMechanismWithoutProbability_AssessmentSectionNull_ThrowsArgumentNullException()
         {
+            var random = new Random(21);
+            var group = random.NextEnumValue<ExportableFailureMechanismGroup>();
+            var failureMechanismCode = random.NextEnumValue<ExportableFailureMechanismType>();
+            var failureMechanismAssemblyMethod = random.NextEnumValue<ExportableAssemblyMethod>();
+
+            // Call
+            TestDelegate call = () => ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithoutProbability(null, 
+                                                                                                                                  failureMechanismCode,
+                                                                                                                                  group,
+                                                                                                                                  failureMechanismAssemblyMethod);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("assessmentSection", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateDefaultExportableFailureMechanismWithoutProbability_WithValidArguments_ReturnsExportableFailureMechanism()
+        {
             // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            ReferenceLine referenceLine = ReferenceLineTestFactory.CreateReferenceLineWithGeometry();
+            assessmentSection.ReferenceLine = referenceLine;
+
             var random = new Random(21);
             var group = random.NextEnumValue<ExportableFailureMechanismGroup>();
             var failureMechanismCode = random.NextEnumValue<ExportableFailureMechanismType>();
             var assemblyMethod = random.NextEnumValue<ExportableAssemblyMethod>();
 
             // Call
             ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult> exportableFailureMechanism =
-                ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithoutProbability(failureMechanismCode, group, assemblyMethod);
+                ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithoutProbability(assessmentSection, 
+                                                                                                            failureMechanismCode, 
+                                                                                                            group, 
+                                                                                                            assemblyMethod);
 
             // Assert
             Assert.AreEqual(group, exportableFailureMechanism.Group);
@@ -121,7 +149,16 @@
             Assert.AreEqual(assemblyMethod, failureMechanismAssemblyResult.AssemblyMethod);
             Assert.AreEqual(FailureMechanismAssemblyCategoryGroup.NotApplicable, failureMechanismAssemblyResult.AssemblyCategory);
 
-            CollectionAssert.IsEmpty(exportableFailureMechanism.SectionAssemblyResults);
+            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(referenceLine.Points, failureMechanismSection.Geometry);
+            Assert.AreEqual(0, failureMechanismSection.StartDistance);
+            Assert.AreEqual(referenceLine.Length, failureMechanismSection.EndDistance);
         }
     }
 }
\ No newline at end of file