Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Assembly/ExportableAssessmentSection.cs
===================================================================
diff -u -rfcb1a3246cfb27c4078ffc52215d71a340e02ea7 -r8b05b046823fdcab518defd3335b03f5df8ac4b6
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Assembly/ExportableAssessmentSection.cs	(.../ExportableAssessmentSection.cs)	(revision fcb1a3246cfb27c4078ffc52215d71a340e02ea7)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Assembly/ExportableAssessmentSection.cs	(.../ExportableAssessmentSection.cs)	(revision 8b05b046823fdcab518defd3335b03f5df8ac4b6)
@@ -16,20 +16,25 @@
         /// <param name="name">The name of the assessment section.</param>
         /// <param name="geometry">The geometry of the assessment section.</param>
         /// <param name="assessmentSectionAssembly">The assembly result of the assessment section.</param>
+        /// <param name="failureMechanismAssemblyWithProbability">The total assembly result with probability
+        /// of the failure mechanisms.</param>
+        /// <param name="failureMechanismAssemblyWithoutProbability">The total assembly result without probability
+        /// of the failure mechanisms.</param>
         /// <param name="failureMechanismsWithProbability">The assembly results with probability of failure
         /// mechanisms belonging to this assessment section.</param>
         /// <param name="failureMechanismsWithoutProbability">The assembly results without probability
         /// of failure mechanisms belonging to this assessment section.</param>
         /// <param name="combinedSectionAssemblyResults">The combined section assembly results
         /// of this assessment section.</param>
         /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
-        public ExportableAssessmentSection(
-            string name,
-            IEnumerable<Point2D> geometry,
-            ExportableAssessmentSectionAssemblyResult assessmentSectionAssembly,
-            IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>> failureMechanismsWithProbability,
-            IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>> failureMechanismsWithoutProbability,
-            ExportableCombinedSectionAssemblyCollection combinedSectionAssemblyResults)
+        public ExportableAssessmentSection(string name,
+                                           IEnumerable<Point2D> geometry,
+                                           ExportableAssessmentSectionAssemblyResult assessmentSectionAssembly,
+                                           ExportableFailureMechanismAssemblyResultWithProbability failureMechanismAssemblyWithProbability,
+                                           ExportableFailureMechanismAssemblyResult failureMechanismAssemblyWithoutProbability,
+                                           IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>> failureMechanismsWithProbability,
+                                           IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>> failureMechanismsWithoutProbability,
+                                           ExportableCombinedSectionAssemblyCollection combinedSectionAssemblyResults)
         {
             if (name == null)
             {
@@ -46,6 +51,16 @@
                 throw new ArgumentNullException(nameof(assessmentSectionAssembly));
             }
 
+            if (failureMechanismAssemblyWithProbability == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanismAssemblyWithProbability));
+            }
+
+            if (failureMechanismAssemblyWithoutProbability == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanismAssemblyWithoutProbability));
+            }
+
             if (failureMechanismsWithProbability == null)
             {
                 throw new ArgumentNullException(nameof(failureMechanismsWithProbability));
@@ -64,6 +79,8 @@
             Name = name;
             Geometry = geometry;
             AssessmentSectionAssembly = assessmentSectionAssembly;
+            FailureMechanismAssemblyWithProbability = failureMechanismAssemblyWithProbability;
+            FailureMechanismAssemblyWithoutProbability = failureMechanismAssemblyWithoutProbability;
             FailureMechanismsWithProbability = failureMechanismsWithProbability;
             FailureMechanismsWithoutProbability = failureMechanismsWithoutProbability;
             CombinedSectionAssemblyResults = combinedSectionAssemblyResults;
@@ -85,6 +102,16 @@
         public ExportableAssessmentSectionAssemblyResult AssessmentSectionAssembly { get; }
 
         /// <summary>
+        /// Gets the total assembly result of the failure mechanisms with probability.
+        /// </summary>
+        public ExportableFailureMechanismAssemblyResultWithProbability FailureMechanismAssemblyWithProbability { get; }
+
+        /// <summary>
+        /// Gets the total assembly result of the failure mechanism without probability.
+        /// </summary>
+        public ExportableFailureMechanismAssemblyResult FailureMechanismAssemblyWithoutProbability { get; }
+
+        /// <summary>
         /// Gets the collection of assembly results with probability of failure mechanisms belonging to this assessment section.
         /// </summary>
         public IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>> FailureMechanismsWithProbability { get; }
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs
===================================================================
diff -u -r3d0e475d4e70d9b4c8ce5bb5a9735f553d1d4505 -r8b05b046823fdcab518defd3335b03f5df8ac4b6
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs	(.../ExportableAssessmentSectionFactory.cs)	(revision 3d0e475d4e70d9b4c8ce5bb5a9735f553d1d4505)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs	(.../ExportableAssessmentSectionFactory.cs)	(revision 8b05b046823fdcab518defd3335b03f5df8ac4b6)
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Ringtoets.AssemblyTool.Data;
 using Ringtoets.Common.Data.Exceptions;
 using Ringtoets.Integration.Data;
 using Ringtoets.Integration.Data.Assembly;
@@ -35,6 +36,8 @@
             return new ExportableAssessmentSection(assessmentSection.Name,
                                                    assessmentSection.ReferenceLine.Points,
                                                    CreateExportableAssessmentSectionAssemblyResult(assessmentSection),
+                                                   CreateExportableFailureMechanismAssemblyResultWithProbability(assessmentSection),
+                                                   CreateExportableFailureMechanismAssemblyResultWithoutProbability(assessmentSection),
                                                    CreateExportableFailureMechanismsWithProbability(assessmentSection),
                                                    CreateExportableFailureMechanismsWithoutProbability(assessmentSection),
                                                    new ExportableCombinedSectionAssemblyCollection(Enumerable.Empty<ExportableCombinedFailureMechanismSection>(),
@@ -47,8 +50,8 @@
         /// </summary>
         /// <param name="assessmentSection">The assessment section to create a
         /// <see cref="ExportableAssessmentSectionAssemblyResult"/> for.</param>
-        /// <returns>A <see cref="ExportableAssessmentSectionAssemblyResult"/> with assembly results.</returns>
-        /// <exception cref="AssemblyException">Thrown when assembly results cannot be created
+        /// <returns>A <see cref="ExportableAssessmentSectionAssemblyResult"/> with assembly result.</returns>
+        /// <exception cref="AssemblyException">Thrown when assembly result cannot be created
         /// for <paramref name="assessmentSection"/>.</exception>
         private static ExportableAssessmentSectionAssemblyResult CreateExportableAssessmentSectionAssemblyResult(AssessmentSection assessmentSection)
         {
@@ -57,6 +60,38 @@
         }
 
         /// <summary>
+        /// Creates a <see cref="ExportableFailureMechanismAssemblyResultWithProbability"/> with the assembly result
+        /// based on <paramref name="assessmentSection"/>.
+        /// </summary>
+        /// <param name="assessmentSection">The assessment section to create a
+        /// <see cref="ExportableFailureMechanismAssemblyResultWithProbability"/> for.</param>
+        /// <returns>A <see cref="ExportableFailureMechanismAssemblyResultWithProbability"/> with assembly result.</returns>
+        /// <exception cref="AssemblyException">Thrown when assembly result cannot be created
+        /// for <paramref name="assessmentSection"/>.</exception>
+        private static ExportableFailureMechanismAssemblyResultWithProbability CreateExportableFailureMechanismAssemblyResultWithProbability(AssessmentSection assessmentSection)
+        {
+            FailureMechanismAssembly assemblyResult = AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(assessmentSection);
+            return new ExportableFailureMechanismAssemblyResultWithProbability(ExportableAssemblyMethod.WBI2B1,
+                                                                               assemblyResult.Group,
+                                                                               assemblyResult.Probability);
+        }
+
+        /// <summary>
+        /// Creates a <see cref="ExportableFailureMechanismAssemblyResult"/> with the assembly result
+        /// based on <paramref name="assessmentSection"/>.
+        /// </summary>
+        /// <param name="assessmentSection">The assessment section to create a
+        /// <see cref="ExportableFailureMechanismAssemblyResult"/> for.</param>
+        /// <returns>A <see cref="ExportableFailureMechanismAssemblyResult"/> with assembly result.</returns>
+        /// <exception cref="AssemblyException">Thrown when assembly result cannot be created
+        /// for <paramref name="assessmentSection"/>.</exception>
+        private static ExportableFailureMechanismAssemblyResult CreateExportableFailureMechanismAssemblyResultWithoutProbability(AssessmentSection assessmentSection)
+        {
+            return new ExportableFailureMechanismAssemblyResult(ExportableAssemblyMethod.WBI2A1,
+                                                                AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection));
+        }
+
+        /// <summary>
         /// Creates a collection of <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/>
         /// for failure mechanisms with an assembly result with a probability based on <paramref name="assessmentSection"/>.
         /// </summary>
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Assembly/ExportableAssessmentSectionTest.cs
===================================================================
diff -u -rfcb1a3246cfb27c4078ffc52215d71a340e02ea7 -r8b05b046823fdcab518defd3335b03f5df8ac4b6
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Assembly/ExportableAssessmentSectionTest.cs	(.../ExportableAssessmentSectionTest.cs)	(revision fcb1a3246cfb27c4078ffc52215d71a340e02ea7)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Assembly/ExportableAssessmentSectionTest.cs	(.../ExportableAssessmentSectionTest.cs)	(revision 8b05b046823fdcab518defd3335b03f5df8ac4b6)
@@ -17,7 +17,6 @@
         {
             // Setup
             IEnumerable<Point2D> geometry = Enumerable.Empty<Point2D>();
-            ExportableAssessmentSectionAssemblyResult assessmentSectionAssembly = CreateAssessmentSectionAssembly();
             IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>> failureMechanismsWithProbability =
                 Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>>();
             IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>> failureMechanismsWithoutProbability =
@@ -26,7 +25,9 @@
             // Call
             TestDelegate call = () => new ExportableAssessmentSection(null,
                                                                       geometry,
-                                                                      assessmentSectionAssembly,
+                                                                      CreateAssessmentSectionAssembly(),
+                                                                      CreateFailureMechanismAssemblyResultWithProbability(),
+                                                                      CreateFailureMechanismAssemblyResultWithoutProbability(),
                                                                       failureMechanismsWithProbability,
                                                                       failureMechanismsWithoutProbability,
                                                                       CreateCombinedSectionAssemblyCollection());
@@ -40,7 +41,6 @@
         public void Constructor_GeometryNull_ThrowsArgumentNullException()
         {
             // Setup
-            ExportableAssessmentSectionAssemblyResult assessmentSectionAssembly = CreateAssessmentSectionAssembly();
             IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>> failureMechanismsWithProbability =
                 Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>>();
             IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>> failureMechanismsWithoutProbability =
@@ -49,7 +49,9 @@
             // Call
             TestDelegate call = () => new ExportableAssessmentSection(string.Empty,
                                                                       null,
-                                                                      assessmentSectionAssembly,
+                                                                      CreateAssessmentSectionAssembly(),
+                                                                      CreateFailureMechanismAssemblyResultWithProbability(),
+                                                                      CreateFailureMechanismAssemblyResultWithoutProbability(),
                                                                       failureMechanismsWithProbability,
                                                                       failureMechanismsWithoutProbability,
                                                                       CreateCombinedSectionAssemblyCollection());
@@ -73,34 +75,85 @@
             TestDelegate call = () => new ExportableAssessmentSection(string.Empty,
                                                                       geometry,
                                                                       null,
+                                                                      CreateFailureMechanismAssemblyResultWithProbability(),
+                                                                      CreateFailureMechanismAssemblyResultWithoutProbability(),
                                                                       failureMechanismsWithProbability,
+                                                                      failureMechanismsWithoutProbability, CreateCombinedSectionAssemblyCollection());
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("assessmentSectionAssembly", exception.ParamName);
+        }
+
+        [Test]
+        public void Constructor_FailureMechanismAssemblyWithProbabilityNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            IEnumerable<Point2D> geometry = Enumerable.Empty<Point2D>();
+            IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>> failureMechanismsWithProbability =
+                Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>>();
+            IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>> failureMechanismsWithoutProbability =
+                Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>>();
+
+            // Call
+            TestDelegate call = () => new ExportableAssessmentSection(string.Empty,
+                                                                      geometry,
+                                                                      CreateAssessmentSectionAssembly(),
+                                                                      null,
+                                                                      CreateFailureMechanismAssemblyResultWithoutProbability(),
+                                                                      failureMechanismsWithProbability,
                                                                       failureMechanismsWithoutProbability,
                                                                       CreateCombinedSectionAssemblyCollection());
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
-            Assert.AreEqual("assessmentSectionAssembly", exception.ParamName);
+            Assert.AreEqual("failureMechanismAssemblyWithProbability", exception.ParamName);
         }
 
         [Test]
-        public void Constructor_FailureMechanismsWithProbabilityNull_ThrowsArgumentNullException()
+        public void Constructor_FailureMechanismAssemblyWithoutProbabilityNull_ThrowsArgumentNullException()
         {
             // Setup
             IEnumerable<Point2D> geometry = Enumerable.Empty<Point2D>();
-            ExportableAssessmentSectionAssemblyResult assessmentSectionAssembly = CreateAssessmentSectionAssembly();
+            IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>> failureMechanismsWithProbability =
+                Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>>();
             IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>> failureMechanismsWithoutProbability =
                 Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>>();
 
             // Call
             TestDelegate call = () => new ExportableAssessmentSection(string.Empty,
                                                                       geometry,
-                                                                      assessmentSectionAssembly,
+                                                                      CreateAssessmentSectionAssembly(),
+                                                                      CreateFailureMechanismAssemblyResultWithProbability(),
                                                                       null,
+                                                                      failureMechanismsWithProbability,
                                                                       failureMechanismsWithoutProbability,
                                                                       CreateCombinedSectionAssemblyCollection());
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("failureMechanismAssemblyWithoutProbability", exception.ParamName);
+        }
+
+        [Test]
+        public void Constructor_FailureMechanismsWithProbabilityNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            IEnumerable<Point2D> geometry = Enumerable.Empty<Point2D>();
+            IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>> failureMechanismsWithoutProbability =
+                Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>>();
+
+            // Call
+            TestDelegate call = () => new ExportableAssessmentSection(string.Empty,
+                                                                      geometry,
+                                                                      CreateAssessmentSectionAssembly(),
+                                                                      CreateFailureMechanismAssemblyResultWithProbability(),
+                                                                      CreateFailureMechanismAssemblyResultWithoutProbability(),
+                                                                      null,
+                                                                      failureMechanismsWithoutProbability, CreateCombinedSectionAssemblyCollection());
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
             Assert.AreEqual("failureMechanismsWithProbability", exception.ParamName);
         }
 
@@ -109,14 +162,15 @@
         {
             // Setup
             IEnumerable<Point2D> geometry = Enumerable.Empty<Point2D>();
-            ExportableAssessmentSectionAssemblyResult assessmentSectionAssembly = CreateAssessmentSectionAssembly();
             IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>> failureMechanismsWithProbability =
                 Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>>();
 
             // Call
             TestDelegate call = () => new ExportableAssessmentSection(string.Empty,
                                                                       geometry,
-                                                                      assessmentSectionAssembly,
+                                                                      CreateAssessmentSectionAssembly(),
+                                                                      CreateFailureMechanismAssemblyResultWithProbability(),
+                                                                      CreateFailureMechanismAssemblyResultWithoutProbability(),
                                                                       failureMechanismsWithProbability,
                                                                       null,
                                                                       CreateCombinedSectionAssemblyCollection());
@@ -131,7 +185,6 @@
         {
             // Setup
             IEnumerable<Point2D> geometry = Enumerable.Empty<Point2D>();
-            ExportableAssessmentSectionAssemblyResult assessmentSectionAssembly = CreateAssessmentSectionAssembly();
             IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>> failureMechanismsWithProbability =
                 Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>>();
             IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>> failureMechanismsWithoutProbability =
@@ -140,7 +193,9 @@
             // Call
             TestDelegate call = () => new ExportableAssessmentSection(string.Empty,
                                                                       geometry,
-                                                                      assessmentSectionAssembly,
+                                                                      CreateAssessmentSectionAssembly(),
+                                                                      CreateFailureMechanismAssemblyResultWithProbability(),
+                                                                      CreateFailureMechanismAssemblyResultWithoutProbability(),
                                                                       failureMechanismsWithProbability,
                                                                       failureMechanismsWithoutProbability,
                                                                       null);
@@ -158,6 +213,8 @@
             // Setup
             IEnumerable<Point2D> geometry = Enumerable.Empty<Point2D>();
             ExportableAssessmentSectionAssemblyResult assessmentSectionAssembly = CreateAssessmentSectionAssembly();
+            ExportableFailureMechanismAssemblyResultWithProbability failureMechanismAssemblyResultWithProbability = CreateFailureMechanismAssemblyResultWithProbability();
+            ExportableFailureMechanismAssemblyResult failureMechanismAssemblyResultWithoutProbability = CreateFailureMechanismAssemblyResultWithoutProbability();
             IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>> failureMechanismsWithProbability =
                 Enumerable.Empty<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>>();
             IEnumerable<ExportableFailureMechanism<ExportableFailureMechanismAssemblyResult>> failureMechanismsWithoutProbability =
@@ -168,19 +225,37 @@
             var assessmentSection = new ExportableAssessmentSection(name,
                                                                     geometry,
                                                                     assessmentSectionAssembly,
+                                                                    failureMechanismAssemblyResultWithProbability,
+                                                                    failureMechanismAssemblyResultWithoutProbability,
                                                                     failureMechanismsWithProbability,
-                                                                    failureMechanismsWithoutProbability,
-                                                                    combinedSectionAssemblyResults);
+                                                                    failureMechanismsWithoutProbability, combinedSectionAssemblyResults);
 
             // Assert
             Assert.AreEqual(name, assessmentSection.Name);
             Assert.AreSame(geometry, assessmentSection.Geometry);
             Assert.AreSame(assessmentSectionAssembly, assessmentSection.AssessmentSectionAssembly);
+            Assert.AreSame(failureMechanismAssemblyResultWithProbability, assessmentSection.FailureMechanismAssemblyWithProbability);
+            Assert.AreSame(failureMechanismAssemblyResultWithoutProbability, assessmentSection.FailureMechanismAssemblyWithoutProbability);
             Assert.AreSame(failureMechanismsWithProbability, assessmentSection.FailureMechanismsWithProbability);
             Assert.AreSame(failureMechanismsWithoutProbability, assessmentSection.FailureMechanismsWithoutProbability);
             Assert.AreSame(combinedSectionAssemblyResults, assessmentSection.CombinedSectionAssemblyResults);
         }
 
+        private static ExportableFailureMechanismAssemblyResult CreateFailureMechanismAssemblyResultWithoutProbability()
+        {
+            var random = new Random(21);
+            return new ExportableFailureMechanismAssemblyResult(random.NextEnumValue<ExportableAssemblyMethod>(),
+                                                                random.NextEnumValue<FailureMechanismAssemblyCategoryGroup>());
+        }
+
+        private static ExportableFailureMechanismAssemblyResultWithProbability CreateFailureMechanismAssemblyResultWithProbability()
+        {
+            var random = new Random(21);
+            return new ExportableFailureMechanismAssemblyResultWithProbability(random.NextEnumValue<ExportableAssemblyMethod>(),
+                                                                               random.NextEnumValue<FailureMechanismAssemblyCategoryGroup>(),
+                                                                               random.NextDouble());
+        }
+
         private static ExportableCombinedSectionAssemblyCollection CreateCombinedSectionAssemblyCollection()
         {
             return new ExportableCombinedSectionAssemblyCollection(Enumerable.Empty<ExportableCombinedFailureMechanismSection>(),
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs
===================================================================
diff -u -r1c2bda6af93900e00924d260e4d18072cdc7f042 -r8b05b046823fdcab518defd3335b03f5df8ac4b6
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs	(.../ExportableAssessmentSectionFactoryTest.cs)	(revision 1c2bda6af93900e00924d260e4d18072cdc7f042)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs	(.../ExportableAssessmentSectionFactoryTest.cs)	(revision 8b05b046823fdcab518defd3335b03f5df8ac4b6)
@@ -85,6 +85,15 @@
                 Assert.AreEqual(name, exportableAssessmentSection.Name);
                 CollectionAssert.AreEqual(referenceLine.Points, exportableAssessmentSection.Geometry);
 
+                ExportableFailureMechanismAssemblyResultWithProbability failureMechanismAssemblyWithProbablity = exportableAssessmentSection.FailureMechanismAssemblyWithProbability;
+                Assert.AreEqual(ExportableAssemblyMethod.WBI2B1, failureMechanismAssemblyWithProbablity.AssemblyMethod);
+                Assert.AreEqual(assessmentSectionAssemblyCalculator.AssembleFailureMechanismsAssemblyOutput.Group, failureMechanismAssemblyWithProbablity.AssemblyCategory);
+                Assert.AreEqual(assessmentSectionAssemblyCalculator.AssembleFailureMechanismsAssemblyOutput.Probability, failureMechanismAssemblyWithProbablity.Probability);
+
+                ExportableFailureMechanismAssemblyResult failureMechanismAssemblyWithoutProbablity = exportableAssessmentSection.FailureMechanismAssemblyWithoutProbability;
+                Assert.AreEqual(ExportableAssemblyMethod.WBI2A1, failureMechanismAssemblyWithoutProbablity.AssemblyMethod);
+                Assert.AreEqual(assessmentSectionAssemblyCalculator.AssembleFailureMechanismsAssemblyCategoryGroupOutput, failureMechanismAssemblyWithoutProbablity.AssemblyCategory);
+
                 ExportableAssessmentSectionAssemblyResult exportableAssessmentSectionAssemblyResult = exportableAssessmentSection.AssessmentSectionAssembly;
                 Assert.AreEqual(assessmentSectionAssemblyCalculator.AssembleAssessmentSectionCategoryGroupOutput, exportableAssessmentSectionAssemblyResult.AssemblyCategory);
                 Assert.AreEqual(ExportableAssemblyMethod.WBI2C1, exportableAssessmentSectionAssemblyResult.AssemblyMethod);