Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableFailureMechanismFactory.cs
===================================================================
diff -u -rc2e1b46490dfdc848647c515e3ea04c1f7f69535 -ree587321dad3fd68330c5acc8e5401f918535d10
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableFailureMechanismFactory.cs	(.../ExportableFailureMechanismFactory.cs)	(revision c2e1b46490dfdc848647c515e3ea04c1f7f69535)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableFailureMechanismFactory.cs	(.../ExportableFailureMechanismFactory.cs)	(revision ee587321dad3fd68330c5acc8e5401f918535d10)
@@ -19,6 +19,9 @@
 // Stichting Deltares and remain full property of Stichting Deltares at all times.
 // All rights reserved.
 
+using System;
+using System.Collections.Generic;
+using Core.Common.Base.Geometry;
 using Ringtoets.AssemblyTool.Data;
 using Ringtoets.Integration.IO.Assembly;
 
@@ -33,19 +36,36 @@
         /// Creates a default instance of an <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/>
         /// with a probability based on its input parameters.
         /// </summary>
+        /// <param name="failureMechanismSectionGeometry">The section geometry.</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>
+        /// <param name="failureMechanismAssemblyMethod">The assembly method which is used to obtain the general assembly result of the failure mechanism.</param>
+        /// <param name="combinedSectionAssemblyResultMethod">The assembly method which is used to obtain the combined assembly result of a failure mechanism section.</param>
         /// <returns>An <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> with default values.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanismSectionGeometry"/> is <c>null</c>.</exception>
         public static ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> CreateDefaultExportableFailureMechanismWithProbability(
+            IEnumerable<Point2D> failureMechanismSectionGeometry,
             ExportableFailureMechanismType failureMechanismCode,
             ExportableFailureMechanismGroup failureMechanismGroup,
-            ExportableAssemblyMethod assemblyMethod)
+            ExportableAssemblyMethod failureMechanismAssemblyMethod,
+            ExportableAssemblyMethod combinedSectionAssemblyResultMethod)
         {
+            if (failureMechanismSectionGeometry == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanismSectionGeometry));
+            }
+
             return new ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>(
-                new ExportableFailureMechanismAssemblyResultWithProbability(assemblyMethod,
+                new ExportableFailureMechanismAssemblyResultWithProbability(failureMechanismAssemblyMethod,
                                                                             FailureMechanismAssemblyCategoryGroup.NotApplicable,
                                                                             0),
+                new[]
+                {
+                    new ExportableAggregatedFailureMechanismSectionAssemblyWithCombinedProbabilityResult(CreateExportableFailureMechanismSection(failureMechanismSectionGeometry),
+                                                                                                         new ExportableSectionAssemblyResultWithProbability(combinedSectionAssemblyResultMethod,
+                                                                                                                                                            FailureMechanismSectionAssemblyCategoryGroup.NotApplicable,
+                                                                                                                                                            0))
+                },
                 failureMechanismCode,
                 failureMechanismGroup);
         }
@@ -69,5 +89,10 @@
                 failureMechanismCode,
                 failureMechanismGroup);
         }
+
+        private static ExportableFailureMechanismSection CreateExportableFailureMechanismSection(IEnumerable<Point2D> geometry)
+        {
+            return new ExportableFailureMechanismSection(geometry, 0, Math2D.Length(geometry));
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableFailureMechanismFactoryTest.cs
===================================================================
diff -u -r68318584c702cb11e38cd84a31d18c951595dda0 -ree587321dad3fd68330c5acc8e5401f918535d10
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableFailureMechanismFactoryTest.cs	(.../ExportableFailureMechanismFactoryTest.cs)	(revision 68318584c702cb11e38cd84a31d18c951595dda0)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableFailureMechanismFactoryTest.cs	(.../ExportableFailureMechanismFactoryTest.cs)	(revision ee587321dad3fd68330c5acc8e5401f918535d10)
@@ -20,6 +20,9 @@
 // All rights reserved.
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
+using Core.Common.Base.Geometry;
 using Core.Common.TestUtil;
 using NUnit.Framework;
 using Ringtoets.AssemblyTool.Data;
@@ -32,28 +35,65 @@
     public class ExportableFailureMechanismFactoryTest
     {
         [Test]
-        public void CreateDefaultExportableFailureMechanismWithProbability_Always_ReturnsExportableFailureMechanism()
+        public void CreateDefaultExportableFailureMechanismWithProbability_FailureMechanismSectionGeometryNull_ThrowsArgumentNullException()
         {
+            var random = new Random(21);
+            var group = random.NextEnumValue<ExportableFailureMechanismGroup>();
+            var failureMechanismCode = random.NextEnumValue<ExportableFailureMechanismType>();
+            var failureMechanismAssemblyMethod = random.NextEnumValue<ExportableAssemblyMethod>();
+            var combinedResultAssemblyMethod = random.NextEnumValue<ExportableAssemblyMethod>();
+
+            // Call
+            TestDelegate call = () => ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithProbability(null,
+                                                                                                                               failureMechanismCode,
+                                                                                                                               group,
+                                                                                                                               failureMechanismAssemblyMethod,
+                                                                                                                               combinedResultAssemblyMethod);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("failureMechanismSectionGeometry", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateDefaultExportableFailureMechanismWithProbability_WithValidArguments_ReturnsExportableFailureMechanism()
+        {
             // Setup
             var random = new Random(21);
+            IEnumerable<Point2D> failureMechanismSectionGeometry = CreateGeometry();
             var group = random.NextEnumValue<ExportableFailureMechanismGroup>();
             var failureMechanismCode = random.NextEnumValue<ExportableFailureMechanismType>();
-            var assemblyMethod = random.NextEnumValue<ExportableAssemblyMethod>();
+            var failureMechanismAssemblyMethod = random.NextEnumValue<ExportableAssemblyMethod>();
+            var combinedResultAssemblyMethod = random.NextEnumValue<ExportableAssemblyMethod>();
 
             // Call
             ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> exportableFailureMechanism =
-                ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithProbability(failureMechanismCode, group, assemblyMethod);
+                ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithProbability(failureMechanismSectionGeometry,
+                                                                                                         failureMechanismCode,
+                                                                                                         group,
+                                                                                                         failureMechanismAssemblyMethod,
+                                                                                                         combinedResultAssemblyMethod);
 
             // Assert
             Assert.AreEqual(group, exportableFailureMechanism.Group);
             Assert.AreEqual(failureMechanismCode, exportableFailureMechanism.Code);
 
             ExportableFailureMechanismAssemblyResultWithProbability failureMechanismAssemblyResult = exportableFailureMechanism.FailureMechanismAssembly;
-            Assert.AreEqual(assemblyMethod, failureMechanismAssemblyResult.AssemblyMethod);
+            Assert.AreEqual(failureMechanismAssemblyMethod, failureMechanismAssemblyResult.AssemblyMethod);
             Assert.AreEqual(FailureMechanismAssemblyCategoryGroup.NotApplicable, failureMechanismAssemblyResult.AssemblyCategory);
             Assert.AreEqual(0, failureMechanismAssemblyResult.Probability);
 
-            CollectionAssert.IsEmpty(exportableFailureMechanism.SectionAssemblyResults);
+            var exportableFailureMechanismSectionAssembly =
+                (ExportableAggregatedFailureMechanismSectionAssemblyWithCombinedProbabilityResult) exportableFailureMechanism.SectionAssemblyResults.Single();
+            ExportableSectionAssemblyResultWithProbability combinedAssembly = exportableFailureMechanismSectionAssembly.CombinedAssembly;
+            Assert.AreEqual(combinedResultAssemblyMethod, combinedAssembly.AssemblyMethod);
+            Assert.AreEqual(FailureMechanismAssemblyCategoryGroup.NotApplicable, combinedAssembly.AssemblyCategory);
+            Assert.AreEqual(0, combinedAssembly.Probability);
+
+            ExportableFailureMechanismSection failureMechanismSection = exportableFailureMechanismSectionAssembly.FailureMechanismSection;
+            Assert.AreSame(failureMechanismSectionGeometry, failureMechanismSection.Geometry);
+            Assert.AreEqual(0, failureMechanismSection.StartDistance);
+            Assert.AreEqual(Math2D.Length(failureMechanismSectionGeometry), failureMechanismSection.EndDistance);
         }
 
         [Test]
@@ -79,5 +119,16 @@
 
             CollectionAssert.IsEmpty(exportableFailureMechanism.SectionAssemblyResults);
         }
+
+        private static IEnumerable<Point2D> CreateGeometry()
+        {
+            return new[]
+            {
+                new Point2D(1, 1),
+                new Point2D(2, 2),
+                new Point2D(3, 3),
+                new Point2D(4, 4)
+            };
+        }
     }
 }
\ No newline at end of file