Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableFailureMechanismFactory.cs
===================================================================
diff -u
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableFailureMechanismFactory.cs	(revision 0)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableFailureMechanismFactory.cs	(revision 0fd76a0bde626efdb5058ada2df39285ca4333cf)
@@ -0,0 +1,34 @@
+using System.Linq;
+using Ringtoets.AssemblyTool.Data;
+using Ringtoets.Integration.IO.Assembly;
+
+namespace Ringtoets.Integration.IO.Factories
+{
+    /// <summary>
+    /// Factory to create instances of <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/>.
+    /// </summary>
+    public static class ExportableFailureMechanismFactory
+    {
+        /// <summary>
+        /// Creates a default instance of a <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/>
+        /// with a probability based on its input parameters.
+        /// </summary>
+        /// <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>A <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> with default values.</returns>
+        public static ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> CreateDefaultExportableFailureMechanismWithProbability(ExportableFailureMechanismType failureMechanismCode,
+                                                                                                                                                                 ExportableFailureMechanismGroup failureMechanismGroup,
+                                                                                                                                                                 ExportableAssemblyMethod assemblyMethod)
+        {
+            return new ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>(
+                new ExportableFailureMechanismAssemblyResultWithProbability(assemblyMethod,
+                                                                            FailureMechanismAssemblyCategoryGroup.NotApplicable,
+                                                                            0),
+                Enumerable.Empty<ExportableFailureMechanismSection>(),
+                Enumerable.Empty<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability>(),
+                failureMechanismCode,
+                failureMechanismGroup);
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableMacroStabilityInwardsFailureMechanismFactory.cs
===================================================================
diff -u -r80ea1805f5f517b9723f9195e8674cb2bc8f3b9f -r0fd76a0bde626efdb5058ada2df39285ca4333cf
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableMacroStabilityInwardsFailureMechanismFactory.cs	(.../ExportableMacroStabilityInwardsFailureMechanismFactory.cs)	(revision 80ea1805f5f517b9723f9195e8674cb2bc8f3b9f)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableMacroStabilityInwardsFailureMechanismFactory.cs	(.../ExportableMacroStabilityInwardsFailureMechanismFactory.cs)	(revision 0fd76a0bde626efdb5058ada2df39285ca4333cf)
@@ -15,6 +15,10 @@
     /// </summary>
     public static class ExportableMacroStabilityInwardsFailureMechanismFactory
     {
+        private const ExportableFailureMechanismGroup failureMechanismGroup = ExportableFailureMechanismGroup.Group2;
+        private const ExportableFailureMechanismType failureMechanismCode = ExportableFailureMechanismType.STBI;
+        private const ExportableAssemblyMethod failureMechanismAssemblyMethod = ExportableAssemblyMethod.WBI1B1;
+
         /// <summary>
         /// Creates a <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/>
         /// with assmebly results based on the input parameters.
@@ -39,6 +43,13 @@
                 throw new ArgumentNullException(nameof(assessmentSection));
             }
 
+            if (!failureMechanism.IsRelevant)
+            {
+                return ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithProbability(failureMechanismCode,
+                                                                                                                failureMechanismGroup,
+                                                                                                                failureMechanismAssemblyMethod);
+            }
+
             FailureMechanismAssembly failureMechanismAssembly = MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
 
             Dictionary<MacroStabilityInwardsFailureMechanismSectionResult, ExportableFailureMechanismSection> failureMechanismSectionsLookup =
@@ -48,14 +59,14 @@
                                                   ExportableFailureMechanismSectionFactory.CreateExportableFailureMechanismSection(sectionResult.Section));
 
             return new ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>(
-                new ExportableFailureMechanismAssemblyResultWithProbability(ExportableAssemblyMethod.WBI1B1,
+                new ExportableFailureMechanismAssemblyResultWithProbability(failureMechanismAssemblyMethod,
                                                                             failureMechanismAssembly.Group,
                                                                             failureMechanismAssembly.Probability),
                 failureMechanismSectionsLookup.Values, CreateExportableMacroStabilityInwardsFailureMechanismSectionResults(failureMechanismSectionsLookup,
                                                                                                                            failureMechanism,
                                                                                                                            assessmentSection),
-                ExportableFailureMechanismType.STBI,
-                ExportableFailureMechanismGroup.Group2);
+                failureMechanismCode,
+                failureMechanismGroup);
         }
 
         /// <summary>
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportablePipingFailureMechanismFactory.cs
===================================================================
diff -u -r80ea1805f5f517b9723f9195e8674cb2bc8f3b9f -r0fd76a0bde626efdb5058ada2df39285ca4333cf
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportablePipingFailureMechanismFactory.cs	(.../ExportablePipingFailureMechanismFactory.cs)	(revision 80ea1805f5f517b9723f9195e8674cb2bc8f3b9f)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportablePipingFailureMechanismFactory.cs	(.../ExportablePipingFailureMechanismFactory.cs)	(revision 0fd76a0bde626efdb5058ada2df39285ca4333cf)
@@ -15,6 +15,10 @@
     /// </summary>
     public static class ExportablePipingFailureMechanismFactory
     {
+        private const ExportableFailureMechanismType failureMechanismCode = ExportableFailureMechanismType.STPH;
+        private const ExportableFailureMechanismGroup failureMechanismGroup = ExportableFailureMechanismGroup.Group2;
+        private const ExportableAssemblyMethod failureMechanismAssemblyMethod = ExportableAssemblyMethod.WBI1B1;
+
         /// <summary>
         /// Creates a <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/>
         /// with assmebly results based on the input parameters.
@@ -39,6 +43,13 @@
                 throw new ArgumentNullException(nameof(assessmentSection));
             }
 
+            if (!failureMechanism.IsRelevant)
+            {
+                return ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithProbability(failureMechanismCode,
+                                                                                                                failureMechanismGroup,
+                                                                                                                failureMechanismAssemblyMethod);
+            }
+
             FailureMechanismAssembly failureMechanismAssembly = PipingFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
 
             Dictionary<PipingFailureMechanismSectionResult, ExportableFailureMechanismSection> failureMechanismSectionsLookup =
@@ -47,14 +58,14 @@
                                               sectionResult => ExportableFailureMechanismSectionFactory.CreateExportableFailureMechanismSection(sectionResult.Section));
 
             return new ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>(
-                new ExportableFailureMechanismAssemblyResultWithProbability(ExportableAssemblyMethod.WBI1B1,
+                new ExportableFailureMechanismAssemblyResultWithProbability(failureMechanismAssemblyMethod,
                                                                             failureMechanismAssembly.Group,
                                                                             failureMechanismAssembly.Probability),
                 failureMechanismSectionsLookup.Values, CreateExportablePipingFailureMechanismSectionResults(failureMechanismSectionsLookup,
                                                                                                             failureMechanism,
                                                                                                             assessmentSection),
-                ExportableFailureMechanismType.STPH,
-                ExportableFailureMechanismGroup.Group2);
+                failureMechanismCode,
+                failureMechanismGroup);
         }
 
         /// <summary>
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Ringtoets.Integration.IO.csproj
===================================================================
diff -u -rfe7f036a5bea0c75556c1f1f8d1d8c422acf5177 -r0fd76a0bde626efdb5058ada2df39285ca4333cf
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Ringtoets.Integration.IO.csproj	(.../Ringtoets.Integration.IO.csproj)	(revision fe7f036a5bea0c75556c1f1f8d1d8c422acf5177)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Ringtoets.Integration.IO.csproj	(.../Ringtoets.Integration.IO.csproj)	(revision 0fd76a0bde626efdb5058ada2df39285ca4333cf)
@@ -37,6 +37,7 @@
     <Compile Include="Exporters\HydraulicBoundaryLocationsExporter.cs" />
     <Compile Include="Exporters\HydraulicBoundaryLocationsWriter.cs" />
     <Compile Include="Factories\ExportableAssessmentSectionFactory.cs" />
+    <Compile Include="Factories\ExportableFailureMechanismFactory.cs" />
     <Compile Include="Factories\ExportableFailureMechanismSectionFactory.cs" />
     <Compile Include="Factories\ExportableMacroStabilityInwardsFailureMechanismFactory.cs" />
     <Compile Include="Factories\ExportablePipingFailureMechanismFactory.cs" />
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableFailureMechanismFactoryTest.cs
===================================================================
diff -u
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableFailureMechanismFactoryTest.cs	(revision 0)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableFailureMechanismFactoryTest.cs	(revision 0fd76a0bde626efdb5058ada2df39285ca4333cf)
@@ -0,0 +1,39 @@
+using System;
+using Core.Common.TestUtil;
+using NUnit.Framework;
+using Ringtoets.AssemblyTool.Data;
+using Ringtoets.Integration.IO.Assembly;
+using Ringtoets.Integration.IO.Factories;
+
+namespace Ringtoets.Integration.IO.Test.Factories
+{
+    [TestFixture]
+    public class ExportableFailureMechanismFactoryTest
+    {
+        [Test]
+        public void CreateDefaultExportableFailureMechanismWithProbability_Always_ReturnsExportableFailureMechanism()
+        {
+            // Setup
+            var random = new Random(21);
+            var group = random.NextEnumValue<ExportableFailureMechanismGroup>();
+            var failureMechanismCode = random.NextEnumValue<ExportableFailureMechanismType>();
+            var assemblyMethod = random.NextEnumValue<ExportableAssemblyMethod>();
+
+            // Call
+            ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> exportableFailureMechanism =
+                ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithProbability(failureMechanismCode, @group, assemblyMethod);
+
+            // Assert
+            Assert.AreEqual(group, exportableFailureMechanism.Group);
+            Assert.AreEqual(failureMechanismCode, exportableFailureMechanism.Code);
+
+            ExportableFailureMechanismAssemblyResultWithProbability failureMechanismAssemblyResult = exportableFailureMechanism.FailureMechanismAssembly;
+            Assert.AreEqual(assemblyMethod, failureMechanismAssemblyResult.AssemblyMethod);
+            Assert.AreEqual(FailureMechanismAssemblyCategoryGroup.NotApplicable, failureMechanismAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(0, failureMechanismAssemblyResult.Probability);
+
+            CollectionAssert.IsEmpty(exportableFailureMechanism.Sections);
+            CollectionAssert.IsEmpty(exportableFailureMechanism.SectionAssemblyResults);
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableMacroStabilityInwardsFailureMechanismFactoryTest.cs
===================================================================
diff -u -r478684f737e6b775dd6b38fa3d874ea7e6dc3585 -r0fd76a0bde626efdb5058ada2df39285ca4333cf
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableMacroStabilityInwardsFailureMechanismFactoryTest.cs	(.../ExportableMacroStabilityInwardsFailureMechanismFactoryTest.cs)	(revision 478684f737e6b775dd6b38fa3d874ea7e6dc3585)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableMacroStabilityInwardsFailureMechanismFactoryTest.cs	(.../ExportableMacroStabilityInwardsFailureMechanismFactoryTest.cs)	(revision 0fd76a0bde626efdb5058ada2df39285ca4333cf)
@@ -53,10 +53,40 @@
         }
 
         [Test]
-        public void CreateExportableMacroStabilityInwardsFailureMechanism_WithValidArguments_ReturnsExportableFailureMechanism()
+        public void CreateExportableMacroStabilityInwardsFailureMechanism_WithFailureMechanismNotRelevant_ReturnsDefaultExportableFailureMechanism()
         {
             // Setup
             var random = new Random(21);
+            var failureMechanism = new MacroStabilityInwardsFailureMechanism
+            {
+                IsRelevant = false
+            };
+            FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
+
+            var assessmentSection = new AssessmentSectionStub();
+
+            // Call
+            ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> exportableFailureMechanism =
+                ExportableMacroStabilityInwardsFailureMechanismFactory.CreateExportableMacroStabilityInwardsFailureMechanism(failureMechanism, assessmentSection);
+
+            // Assert
+            Assert.AreEqual(ExportableFailureMechanismType.STBI, exportableFailureMechanism.Code);
+            Assert.AreEqual(ExportableFailureMechanismGroup.Group2, exportableFailureMechanism.Group);
+
+            ExportableFailureMechanismAssemblyResultWithProbability failureMechanismAssemblyResult = exportableFailureMechanism.FailureMechanismAssembly;
+            Assert.AreEqual(ExportableAssemblyMethod.WBI1B1, failureMechanismAssemblyResult.AssemblyMethod);
+            Assert.AreEqual(FailureMechanismAssemblyCategoryGroup.NotApplicable, failureMechanismAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(0, failureMechanismAssemblyResult.Probability);
+
+            CollectionAssert.IsEmpty(exportableFailureMechanism.Sections);
+            CollectionAssert.IsEmpty(exportableFailureMechanism.SectionAssemblyResults);
+        }
+
+        [Test]
+        public void CreateExportableMacroStabilityInwardsFailureMechanism_WithFailureMechanismRelevant_ReturnsExportableFailureMechanism()
+        {
+            // Setup
+            var random = new Random(21);
             var failureMechanism = new MacroStabilityInwardsFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
 
@@ -69,22 +99,26 @@
                 FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
 
                 // Call
-                ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> assemblyResult =
+                ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> exportableFailureMechanism =
                     ExportableMacroStabilityInwardsFailureMechanismFactory.CreateExportableMacroStabilityInwardsFailureMechanism(failureMechanism, assessmentSection);
 
                 // Assert
-                Assert.AreEqual(failureMechanismAssemblyCalculator.FailureMechanismAssemblyOutput.Group, assemblyResult.FailureMechanismAssembly.AssemblyCategory);
-                Assert.AreEqual(failureMechanismAssemblyCalculator.FailureMechanismAssemblyOutput.Probability, assemblyResult.FailureMechanismAssembly.Probability);
-                Assert.AreEqual(ExportableFailureMechanismType.STBI, assemblyResult.Code);
-                Assert.AreEqual(ExportableFailureMechanismGroup.Group2, assemblyResult.Group);
+                Assert.AreEqual(ExportableFailureMechanismType.STBI, exportableFailureMechanism.Code);
+                Assert.AreEqual(ExportableFailureMechanismGroup.Group2, exportableFailureMechanism.Group);
 
-                ExportableFailureMechanismSectionTestHelper.AssertExportableFailureMechanismSections(failureMechanism.Sections, assemblyResult.Sections);
+                FailureMechanismAssembly calculatorOutput = failureMechanismAssemblyCalculator.FailureMechanismAssemblyOutput;
+                ExportableFailureMechanismAssemblyResultWithProbability exportableFailureMechanismAssembly = exportableFailureMechanism.FailureMechanismAssembly;
+                Assert.AreEqual(ExportableAssemblyMethod.WBI1B1, exportableFailureMechanismAssembly.AssemblyMethod);
+                Assert.AreEqual(calculatorOutput.Group, exportableFailureMechanismAssembly.AssemblyCategory);
+                Assert.AreEqual(calculatorOutput.Probability, exportableFailureMechanismAssembly.Probability);
+                
+                ExportableFailureMechanismSectionTestHelper.AssertExportableFailureMechanismSections(failureMechanism.Sections, exportableFailureMechanism.Sections);
                 AssertExportableFailureMechanismSectionResults(failureMechanismSectionAssemblyCalculator.SimpleAssessmentAssemblyOutput,
                                                                failureMechanismSectionAssemblyCalculator.DetailedAssessmentAssemblyOutput,
                                                                failureMechanismSectionAssemblyCalculator.TailorMadeAssessmentAssemblyOutput,
                                                                failureMechanismSectionAssemblyCalculator.CombinedAssemblyOutput,
-                                                               assemblyResult.Sections,
-                                                               assemblyResult.SectionAssemblyResults.Cast<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability>());
+                                                               exportableFailureMechanism.Sections,
+                                                               exportableFailureMechanism.SectionAssemblyResults.Cast<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability>());
             }
         }
 
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportablePipingFailureMechanismFactoryTest.cs
===================================================================
diff -u -r478684f737e6b775dd6b38fa3d874ea7e6dc3585 -r0fd76a0bde626efdb5058ada2df39285ca4333cf
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportablePipingFailureMechanismFactoryTest.cs	(.../ExportablePipingFailureMechanismFactoryTest.cs)	(revision 478684f737e6b775dd6b38fa3d874ea7e6dc3585)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportablePipingFailureMechanismFactoryTest.cs	(.../ExportablePipingFailureMechanismFactoryTest.cs)	(revision 0fd76a0bde626efdb5058ada2df39285ca4333cf)
@@ -51,10 +51,40 @@
         }
 
         [Test]
-        public void CreateExportablePipingFailureMechanism_WithValidArguments_ReturnsExportableFailureMechanism()
+        public void CreateExportablePipingFailureMechanism_WithFailureMechanismNotRelevant_ReturnsDefaultExportableFailureMechanism()
         {
             // Setup
             var random = new Random(21);
+            var failureMechanism = new PipingFailureMechanism
+            {
+                IsRelevant = false
+            };
+            FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
+
+            var assessmentSection = new AssessmentSectionStub();
+
+            // Call
+            ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> exportableFailureMechanism =
+                ExportablePipingFailureMechanismFactory.CreateExportablePipingFailureMechanism(failureMechanism, assessmentSection);
+
+            // Assert
+            Assert.AreEqual(ExportableFailureMechanismType.STPH, exportableFailureMechanism.Code);
+            Assert.AreEqual(ExportableFailureMechanismGroup.Group2, exportableFailureMechanism.Group);
+
+            ExportableFailureMechanismAssemblyResultWithProbability failureMechanismAssemblyResult = exportableFailureMechanism.FailureMechanismAssembly;
+            Assert.AreEqual(ExportableAssemblyMethod.WBI1B1, failureMechanismAssemblyResult.AssemblyMethod);
+            Assert.AreEqual(FailureMechanismAssemblyCategoryGroup.NotApplicable, failureMechanismAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(0, failureMechanismAssemblyResult.Probability);
+
+            CollectionAssert.IsEmpty(exportableFailureMechanism.Sections);
+            CollectionAssert.IsEmpty(exportableFailureMechanism.SectionAssemblyResults);
+        }
+
+        [Test]
+        public void CreateExportablePipingFailureMechanism_WithFailureMechanismRelevant_ReturnsExportableFailureMechanism()
+        {
+            // Setup
+            var random = new Random(21);
             var failureMechanism = new PipingFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
 
@@ -67,22 +97,26 @@
                 FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
 
                 // Call
-                ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> assemblyResult =
+                ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> exportableFailureMechanism =
                     ExportablePipingFailureMechanismFactory.CreateExportablePipingFailureMechanism(failureMechanism, assessmentSection);
 
                 // Assert
-                Assert.AreEqual(failureMechanismAssemblyCalculator.FailureMechanismAssemblyOutput.Group, assemblyResult.FailureMechanismAssembly.AssemblyCategory);
-                Assert.AreEqual(failureMechanismAssemblyCalculator.FailureMechanismAssemblyOutput.Probability, assemblyResult.FailureMechanismAssembly.Probability);
-                Assert.AreEqual(ExportableFailureMechanismType.STPH, assemblyResult.Code);
-                Assert.AreEqual(ExportableFailureMechanismGroup.Group2, assemblyResult.Group);
+                Assert.AreEqual(ExportableFailureMechanismType.STPH, exportableFailureMechanism.Code);
+                Assert.AreEqual(ExportableFailureMechanismGroup.Group2, exportableFailureMechanism.Group);
 
-                ExportableFailureMechanismSectionTestHelper.AssertExportableFailureMechanismSections(failureMechanism.Sections, assemblyResult.Sections);
+                FailureMechanismAssembly calculatorOutput = failureMechanismAssemblyCalculator.FailureMechanismAssemblyOutput;
+                ExportableFailureMechanismAssemblyResultWithProbability exportableFailureMechanismAssembly = exportableFailureMechanism.FailureMechanismAssembly;
+                Assert.AreEqual(calculatorOutput.Group, exportableFailureMechanismAssembly.AssemblyCategory);
+                Assert.AreEqual(calculatorOutput.Probability, exportableFailureMechanismAssembly.Probability);
+                Assert.AreEqual(ExportableAssemblyMethod.WBI1B1, exportableFailureMechanismAssembly.AssemblyMethod);
+
+                ExportableFailureMechanismSectionTestHelper.AssertExportableFailureMechanismSections(failureMechanism.Sections, exportableFailureMechanism.Sections);
                 AssertExportableFailureMechanismSectionResults(failureMechanismSectionAssemblyCalculator.SimpleAssessmentAssemblyOutput,
                                                                failureMechanismSectionAssemblyCalculator.DetailedAssessmentAssemblyOutput,
                                                                failureMechanismSectionAssemblyCalculator.TailorMadeAssessmentAssemblyOutput,
                                                                failureMechanismSectionAssemblyCalculator.CombinedAssemblyOutput,
-                                                               assemblyResult.Sections,
-                                                               assemblyResult.SectionAssemblyResults.Cast<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability>());
+                                                               exportableFailureMechanism.Sections,
+                                                               exportableFailureMechanism.SectionAssemblyResults.Cast<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability>());
             }
         }
 
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Ringtoets.Integration.IO.Test.csproj
===================================================================
diff -u -rfe7f036a5bea0c75556c1f1f8d1d8c422acf5177 -r0fd76a0bde626efdb5058ada2df39285ca4333cf
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Ringtoets.Integration.IO.Test.csproj	(.../Ringtoets.Integration.IO.Test.csproj)	(revision fe7f036a5bea0c75556c1f1f8d1d8c422acf5177)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Ringtoets.Integration.IO.Test.csproj	(.../Ringtoets.Integration.IO.Test.csproj)	(revision 0fd76a0bde626efdb5058ada2df39285ca4333cf)
@@ -39,6 +39,7 @@
     <Compile Include="Factories\ExportableAssessmentSectionFactoryTest.cs" />
     <Compile Include="Exporters\HydraulicBoundaryLocationsExporterTest.cs" />
     <Compile Include="Exporters\HydraulicBoundaryLocationsWriterTest.cs" />
+    <Compile Include="Factories\ExportableFailureMechanismFactoryTest.cs" />
     <Compile Include="Factories\ExportableFailureMechanismSectionFactoryTest.cs" />
     <Compile Include="Factories\ExportableMacroStabilityInwardsFailureMechanismFactoryTest.cs" />
     <Compile Include="Factories\ExportablePipingFailureMechanismFactoryTest.cs" />