Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs
===================================================================
diff -u -r6056937ae2b62d8d74261b245888702f00b69747 -r67ccd648ef0db4b9e75c60d2e060128fa8f54691
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs	(.../ExportableAssessmentSectionFactory.cs)	(revision 6056937ae2b62d8d74261b245888702f00b69747)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs	(.../ExportableAssessmentSectionFactory.cs)	(revision 67ccd648ef0db4b9e75c60d2e060128fa8f54691)
@@ -75,7 +75,8 @@
                 ExportableMacroStabilityInwardsFailureMechanismFactory.CreateExportableMacroStabilityInwardsFailureMechanism(assessmentSection.MacroStabilityInwards, assessmentSection),
                 ExportableGrassCoverErosionInwardsFailureMechanismFactory.CreateExportableGrassCoverErosionInwardsFailureMechanism(assessmentSection.GrassCoverErosionInwards, assessmentSection),
                 ExportableHeightStructuresFailureMechanismFactory.CreateExportableHeightStructuresFailureMechanism(assessmentSection.HeightStructures, assessmentSection),
-                ExportableClosingStructuresFailureMechanismFactory.CreateExportableClosingStructuresFailureMechanism(assessmentSection.ClosingStructures, assessmentSection)
+                ExportableClosingStructuresFailureMechanismFactory.CreateExportableClosingStructuresFailureMechanism(assessmentSection.ClosingStructures, assessmentSection),
+                ExportableStabilityPointStructuresFailureMechanismFactory.CreateExportableStabilityPointStructuresFailureMechanism(assessmentSection.StabilityPointStructures, assessmentSection)
             };
         }
     }
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableStabilityPointStructuresFailureMechanismFactory.cs
===================================================================
diff -u
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableStabilityPointStructuresFailureMechanismFactory.cs	(revision 0)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableStabilityPointStructuresFailureMechanismFactory.cs	(revision 67ccd648ef0db4b9e75c60d2e060128fa8f54691)
@@ -0,0 +1,118 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Ringtoets.AssemblyTool.Data;
+using Ringtoets.Common.Data.AssessmentSection;
+using Ringtoets.Common.Data.Exceptions;
+using Ringtoets.Integration.IO.Assembly;
+using Ringtoets.StabilityPointStructures.Data;
+
+namespace Ringtoets.Integration.IO.Factories
+{
+    /// <summary>
+    /// Factory to create instances of <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/>
+    /// with assembly results for stability point structures.
+    /// </summary>
+    public static class ExportableStabilityPointStructuresFailureMechanismFactory
+    {
+        private const ExportableFailureMechanismType failureMechanismCode = ExportableFailureMechanismType.STKWp;
+        private const ExportableFailureMechanismGroup failureMechanismGroup = ExportableFailureMechanismGroup.Group1;
+        private const ExportableAssemblyMethod failureMechanismAssemblyMethod = ExportableAssemblyMethod.WBI1B1;
+
+        /// <summary>
+        /// Creates a <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/>
+        /// with assmebly results based on the input parameters.
+        /// </summary>
+        /// <param name="failureMechanism">The <see cref="StabilityPointStructuresFailureMechanism"/> to create a
+        /// <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> for.</param>
+        /// <param name="assessmentSection">The assessment section this failure mechanism belongs to.</param>
+        /// <returns>A <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> with assembly results.</returns>
+        /// <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<ExportableFailureMechanismAssemblyResultWithProbability> CreateExportableStabilityPointStructuresFailureMechanism(
+            StabilityPointStructuresFailureMechanism failureMechanism,
+            IAssessmentSection assessmentSection)
+        {
+            if (failureMechanism == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanism));
+            }
+
+            if (assessmentSection == null)
+            {
+                throw new ArgumentNullException(nameof(assessmentSection));
+            }
+
+            if (!failureMechanism.IsRelevant)
+            {
+                return ExportableFailureMechanismFactory.CreateDefaultExportableFailureMechanismWithProbability(failureMechanismCode,
+                                                                                                                failureMechanismGroup,
+                                                                                                                failureMechanismAssemblyMethod);
+            }
+
+            FailureMechanismAssembly failureMechanismAssembly = StabilityPointStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
+
+            Dictionary<StabilityPointStructuresFailureMechanismSectionResult, ExportableFailureMechanismSection> failureMechanismSectionsLookup =
+                failureMechanism.SectionResults
+                                .ToDictionary(sectionResult => sectionResult,
+                                              sectionResult => ExportableFailureMechanismSectionFactory.CreateExportableFailureMechanismSection(sectionResult.Section));
+
+            return new ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>(
+                new ExportableFailureMechanismAssemblyResultWithProbability(failureMechanismAssemblyMethod,
+                                                                            failureMechanismAssembly.Group,
+                                                                            failureMechanismAssembly.Probability),
+                failureMechanismSectionsLookup.Values, CreateExportablePipingFailureMechanismSectionResults(failureMechanismSectionsLookup,
+                                                                                                            failureMechanism,
+                                                                                                            assessmentSection),
+                failureMechanismCode,
+                failureMechanismGroup);
+        }
+
+        /// <summary>
+        /// Creates a collection of <see cref="ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability"/>
+        /// with assembly results based on the sections in <paramref name="failureMechanismSections"/>.
+        /// </summary>
+        /// <param name="failureMechanismSections">The mapping between the <see cref="StabilityPointStructuresFailureMechanismSectionResult"/>
+        /// and <see cref="ExportableFailureMechanismSection"/>.</param>
+        /// <param name="failureMechanism">The <see cref="StabilityPointStructuresFailureMechanism"/> the sections belong to.</param>
+        /// <param name="assessmentSection">The assessment section the sections belong to.</param>
+        /// <returns>A collection of <see cref="ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability"/>.</returns>
+        /// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
+        private static IEnumerable<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability> CreateExportablePipingFailureMechanismSectionResults(
+            Dictionary<StabilityPointStructuresFailureMechanismSectionResult, ExportableFailureMechanismSection> failureMechanismSections,
+            StabilityPointStructuresFailureMechanism failureMechanism,
+            IAssessmentSection assessmentSection)
+        {
+            var exportableResults = new List<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability>();
+            foreach (KeyValuePair<StabilityPointStructuresFailureMechanismSectionResult, ExportableFailureMechanismSection> failureMechanismSectionPair in failureMechanismSections)
+            {
+                StabilityPointStructuresFailureMechanismSectionResult failureMechanismSectionResult = failureMechanismSectionPair.Key;
+                FailureMechanismSectionAssembly simpleAssembly =
+                    StabilityPointStructuresFailureMechanismAssemblyFactory.AssembleSimpleAssessment(failureMechanismSectionResult);
+
+                FailureMechanismSectionAssembly detailedAssembly =
+                    StabilityPointStructuresFailureMechanismAssemblyFactory.AssembleDetailedAssessment(failureMechanismSectionResult,
+                                                                                                       failureMechanism,
+                                                                                                       assessmentSection);
+                FailureMechanismSectionAssembly tailorMadeAssembly =
+                    StabilityPointStructuresFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(failureMechanismSectionResult,
+                                                                                                         failureMechanism,
+                                                                                                         assessmentSection);
+                FailureMechanismSectionAssembly combinedAssembly =
+                    StabilityPointStructuresFailureMechanismAssemblyFactory.AssembleCombinedAssessment(failureMechanismSectionResult,
+                                                                                                       failureMechanism,
+                                                                                                       assessmentSection);
+
+                exportableResults.Add(
+                    new ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability(
+                        failureMechanismSectionPair.Value,
+                        ExportableSectionAssemblyResultFactory.CreateExportableSectionAssemblyResultWithProbability(simpleAssembly, ExportableAssemblyMethod.WBI0E3),
+                        ExportableSectionAssemblyResultFactory.CreateExportableSectionAssemblyResultWithProbability(detailedAssembly, ExportableAssemblyMethod.WBI0G3),
+                        ExportableSectionAssemblyResultFactory.CreateExportableSectionAssemblyResultWithProbability(tailorMadeAssembly, ExportableAssemblyMethod.WBI0T3),
+                        ExportableSectionAssemblyResultFactory.CreateExportableSectionAssemblyResultWithProbability(combinedAssembly, ExportableAssemblyMethod.WBI0A1)));
+            }
+
+            return exportableResults;
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Ringtoets.Integration.IO.csproj
===================================================================
diff -u -r6056937ae2b62d8d74261b245888702f00b69747 -r67ccd648ef0db4b9e75c60d2e060128fa8f54691
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Ringtoets.Integration.IO.csproj	(.../Ringtoets.Integration.IO.csproj)	(revision 6056937ae2b62d8d74261b245888702f00b69747)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Ringtoets.Integration.IO.csproj	(.../Ringtoets.Integration.IO.csproj)	(revision 67ccd648ef0db4b9e75c60d2e060128fa8f54691)
@@ -45,6 +45,7 @@
     <Compile Include="Factories\ExportableMacroStabilityInwardsFailureMechanismFactory.cs" />
     <Compile Include="Factories\ExportablePipingFailureMechanismFactory.cs" />
     <Compile Include="Factories\ExportableSectionAssemblyResultFactory.cs" />
+    <Compile Include="Factories\ExportableStabilityPointStructuresFailureMechanismFactory.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
@@ -130,6 +131,11 @@
       <Name>Ringtoets.Piping.Data</Name>
       <Private>False</Private>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\StabilityPointStructures\src\Ringtoets.StabilityPointStructures.Data\Ringtoets.StabilityPointStructures.Data.csproj">
+      <Project>{3d4b9740-8348-4434-8d77-b611fc6ee57f}</Project>
+      <Name>Ringtoets.StabilityPointStructures.Data</Name>
+      <Private>False</Private>
+    </ProjectReference>
     <ProjectReference Include="..\Ringtoets.Integration.Data\Ringtoets.Integration.Data.csproj">
       <Project>{11F1F874-45AF-43E4-8AE5-15A5C9593E28}</Project>
       <Name>Ringtoets.Integration.Data</Name>
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs
===================================================================
diff -u -r6056937ae2b62d8d74261b245888702f00b69747 -r67ccd648ef0db4b9e75c60d2e060128fa8f54691
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs	(.../ExportableAssessmentSectionFactoryTest.cs)	(revision 6056937ae2b62d8d74261b245888702f00b69747)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs	(.../ExportableAssessmentSectionFactoryTest.cs)	(revision 67ccd648ef0db4b9e75c60d2e060128fa8f54691)
@@ -17,6 +17,7 @@
 using Ringtoets.Integration.IO.Factories;
 using Ringtoets.MacroStabilityInwards.Data;
 using Ringtoets.Piping.Data;
+using Ringtoets.StabilityPointStructures.Data;
 
 namespace Ringtoets.Integration.IO.Test.Factories
 {
@@ -91,7 +92,7 @@
             FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator,
             AssessmentSection assessmentSection)
         {
-            Assert.AreEqual(5, exportableFailureMechanisms.Count());
+            Assert.AreEqual(6, exportableFailureMechanisms.Count());
 
             ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> exportablePiping = exportableFailureMechanisms.First();
             Assert.AreEqual(failureMechanismAssemblyCalculator.FailureMechanismAssemblyOutput.Group, exportablePiping.FailureMechanismAssembly.AssemblyCategory);
@@ -137,6 +138,15 @@
             ClosingStructuresFailureMechanism closingStructures = assessmentSection.ClosingStructures;
             Assert.AreEqual(closingStructures.Sections.Count(), closingStructures.Sections.Count());
             Assert.AreEqual(closingStructures.SectionResults.Count(), exportableClosingStructures.SectionAssemblyResults.Count());
+
+            ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> exportableStabilityPointStructures = exportableFailureMechanisms.ElementAt(5);
+            Assert.AreEqual(failureMechanismAssemblyCalculator.FailureMechanismAssemblyOutput.Group, exportableStabilityPointStructures.FailureMechanismAssembly.AssemblyCategory);
+            Assert.AreEqual(failureMechanismAssemblyCalculator.FailureMechanismAssemblyOutput.Probability, exportableStabilityPointStructures.FailureMechanismAssembly.Probability);
+            Assert.AreEqual(ExportableFailureMechanismType.STKWp, exportableStabilityPointStructures.Code);
+            Assert.AreEqual(ExportableFailureMechanismGroup.Group1, exportableStabilityPointStructures.Group);
+            StabilityPointStructuresFailureMechanism stabilityPointStructures = assessmentSection.StabilityPointStructures;
+            Assert.AreEqual(stabilityPointStructures.Sections.Count(), stabilityPointStructures.Sections.Count());
+            Assert.AreEqual(stabilityPointStructures.SectionResults.Count(), exportableStabilityPointStructures.SectionAssemblyResults.Count());
         }
     }
 }
\ No newline at end of file
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableStabilityPointStructuresFailureMechanismFactoryTest.cs
===================================================================
diff -u
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableStabilityPointStructuresFailureMechanismFactoryTest.cs	(revision 0)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableStabilityPointStructuresFailureMechanismFactoryTest.cs	(revision 67ccd648ef0db4b9e75c60d2e060128fa8f54691)
@@ -0,0 +1,175 @@
+using System;
+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;
+using Ringtoets.Integration.IO.TestUtil;
+using Ringtoets.StabilityPointStructures.Data;
+
+namespace Ringtoets.Integration.IO.Test.Factories
+{
+    [TestFixture]
+    public class ExportableStabilityPointStructuresFailureMechanismFactoryTest
+    {
+        [Test]
+        public void CreateExportableStabilityPointStructuresFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var mocks = new MockRepository();
+            var assessmentSection = mocks.Stub<IAssessmentSection>();
+            mocks.ReplayAll();
+
+            // Call
+            TestDelegate call = () =>
+                ExportableStabilityPointStructuresFailureMechanismFactory.CreateExportableStabilityPointStructuresFailureMechanism(null,
+                                                                                                                                   assessmentSection);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("failureMechanism", exception.ParamName);
+
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void CreateExportableStabilityPointStructuresFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () =>
+                ExportableStabilityPointStructuresFailureMechanismFactory.CreateExportableStabilityPointStructuresFailureMechanism(new StabilityPointStructuresFailureMechanism(),
+                                                                                                                                   null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("assessmentSection", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateExportableStabilityPointStructuresFailureMechanism_WithFailureMechanismNotRelevant_ReturnsDefaultExportableFailureMechanism()
+        {
+            // Setup
+            var random = new Random(21);
+            var failureMechanism = new StabilityPointStructuresFailureMechanism
+            {
+                IsRelevant = false
+            };
+            FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
+
+            var assessmentSection = new AssessmentSectionStub();
+
+            // Call
+            ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> exportableFailureMechanism =
+                ExportableStabilityPointStructuresFailureMechanismFactory.CreateExportableStabilityPointStructuresFailureMechanism(failureMechanism, assessmentSection);
+
+            // Assert
+            Assert.AreEqual(ExportableFailureMechanismType.STKWp, exportableFailureMechanism.Code);
+            Assert.AreEqual(ExportableFailureMechanismGroup.Group1, 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 CreateExportableStabilityPointStructuresFailureMechanism_WithFailureMechanismRelevant_ReturnsExportableFailureMechanism()
+        {
+            // Setup
+            var random = new Random(21);
+            var failureMechanism = new StabilityPointStructuresFailureMechanism();
+            FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
+
+            var assessmentSection = new AssessmentSectionStub();
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance;
+                FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorfactory.LastCreatedFailureMechanismAssemblyCalculator;
+                FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
+
+                // Call
+                ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> exportableFailureMechanism =
+                    ExportableStabilityPointStructuresFailureMechanismFactory.CreateExportableStabilityPointStructuresFailureMechanism(failureMechanism, assessmentSection);
+
+                // Assert
+                Assert.AreEqual(ExportableFailureMechanismType.STKWp, exportableFailureMechanism.Code);
+                Assert.AreEqual(ExportableFailureMechanismGroup.Group1, exportableFailureMechanism.Group);
+
+                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,
+                                                               exportableFailureMechanism.Sections,
+                                                               exportableFailureMechanism.SectionAssemblyResults.Cast<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability>());
+            }
+        }
+
+        private static void AssertExportableFailureMechanismSectionResults(FailureMechanismSectionAssembly expectedSimpleAssembly,
+                                                                           FailureMechanismSectionAssembly expectedDetailedAssembly,
+                                                                           FailureMechanismSectionAssembly expectedTailorMadeAssembly,
+                                                                           FailureMechanismSectionAssembly expectedCombinedAssembly,
+                                                                           IEnumerable<ExportableFailureMechanismSection> sections,
+                                                                           IEnumerable<ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability> results)
+        {
+            int expectedNrOfResults = sections.Count();
+            Assert.AreEqual(expectedNrOfResults, results.Count());
+
+            for (var i = 0; i < expectedNrOfResults; i++)
+            {
+                ExportableFailureMechanismSection section = sections.ElementAt(i);
+                ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability result = results.ElementAt(i);
+
+                AssertExportableFailureMechanismSectionResult(expectedSimpleAssembly,
+                                                              expectedDetailedAssembly,
+                                                              expectedTailorMadeAssembly,
+                                                              expectedCombinedAssembly,
+                                                              section,
+                                                              result);
+            }
+        }
+
+        private static void AssertExportableFailureMechanismSectionResult(FailureMechanismSectionAssembly expectedSimpleAssembly,
+                                                                          FailureMechanismSectionAssembly expectedDetailedAssembly,
+                                                                          FailureMechanismSectionAssembly expectedTailorMadeAssembly,
+                                                                          FailureMechanismSectionAssembly expectedCombinedAssembly,
+                                                                          ExportableFailureMechanismSection expectedSection,
+                                                                          ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability actualResult)
+        {
+            Assert.AreSame(expectedSection, actualResult.FailureMechanismSection);
+
+            ExportableSectionAssemblyResultTestHelper.AssertExportableSectionAssemblyResult(expectedSimpleAssembly,
+                                                                                            ExportableAssemblyMethod.WBI0E3,
+                                                                                            actualResult.SimpleAssembly);
+
+            ExportableSectionAssemblyResultTestHelper.AssertExportableSectionAssemblyResult(expectedDetailedAssembly,
+                                                                                            ExportableAssemblyMethod.WBI0G3,
+                                                                                            actualResult.DetailedAssembly);
+
+            ExportableSectionAssemblyResultTestHelper.AssertExportableSectionAssemblyResult(expectedTailorMadeAssembly,
+                                                                                            ExportableAssemblyMethod.WBI0T3,
+                                                                                            actualResult.TailorMadeAssembly);
+
+            ExportableSectionAssemblyResultTestHelper.AssertExportableSectionAssemblyResult(expectedCombinedAssembly,
+                                                                                            ExportableAssemblyMethod.WBI0A1,
+                                                                                            actualResult.CombinedAssembly);
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Ringtoets.Integration.IO.Test.csproj
===================================================================
diff -u -r6056937ae2b62d8d74261b245888702f00b69747 -r67ccd648ef0db4b9e75c60d2e060128fa8f54691
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Ringtoets.Integration.IO.Test.csproj	(.../Ringtoets.Integration.IO.Test.csproj)	(revision 6056937ae2b62d8d74261b245888702f00b69747)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Ringtoets.Integration.IO.Test.csproj	(.../Ringtoets.Integration.IO.Test.csproj)	(revision 67ccd648ef0db4b9e75c60d2e060128fa8f54691)
@@ -47,6 +47,7 @@
     <Compile Include="Factories\ExportableMacroStabilityInwardsFailureMechanismFactoryTest.cs" />
     <Compile Include="Factories\ExportablePipingFailureMechanismFactoryTest.cs" />
     <Compile Include="Factories\ExportableSectionAssemblyResultFactoryTest.cs" />
+    <Compile Include="Factories\ExportableStabilityPointStructuresFailureMechanismFactoryTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
@@ -116,6 +117,10 @@
       <Project>{ce994cc9-6f6a-48ac-b4be-02c30a21f4db}</Project>
       <Name>Ringtoets.Piping.Data</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\..\StabilityPointStructures\src\Ringtoets.StabilityPointStructures.Data\Ringtoets.StabilityPointStructures.Data.csproj">
+      <Project>{3D4B9740-8348-4434-8D77-B611FC6EE57F}</Project>
+      <Name>Ringtoets.StabilityPointStructures.Data</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\src\Ringtoets.Integration.Data\Ringtoets.Integration.Data.csproj">
       <Project>{11F1F874-45AF-43E4-8AE5-15A5C9593E28}</Project>
       <Name>Ringtoets.Integration.Data</Name>