Index: Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs
===================================================================
diff -u -rb300d03dc113da59301ff092b7d47536f02d6238 -r5043fc31464a612ec3d6f7e0551691b013e70b9d
--- Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs	(.../ExportableAssessmentSectionFactory.cs)	(revision b300d03dc113da59301ff092b7d47536f02d6238)
+++ Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs	(.../ExportableAssessmentSectionFactory.cs)	(revision 5043fc31464a612ec3d6f7e0551691b013e70b9d)
@@ -24,6 +24,7 @@
 using Riskeer.AssemblyTool.Data;
 using Riskeer.Common.Data.AssessmentSection;
 using Riskeer.Common.Data.Exceptions;
+using Riskeer.Common.Data.FailurePath;
 using Riskeer.Integration.Data;
 using Riskeer.Integration.Data.Assembly;
 using Riskeer.Integration.IO.Assembly;
@@ -78,33 +79,45 @@
 
         /// <summary>
         /// Creates a collection of <see cref="ExportableFailureMechanism"/>
-        /// for failure mechanisms with an assembly result without a probability based on <paramref name="assessmentSection"/>.
+        /// for failure mechanisms that are in assembly based on <paramref name="assessmentSection"/>.
         /// </summary>
         /// <param name="assessmentSection">The assessment section to create a collection of
         /// <see cref="ExportableFailureMechanism"/> with probability for.</param>
         /// <returns>A collection of <see cref="ExportableFailureMechanism"/> based on failure
-        /// mechanisms with assembly results without a probability.</returns>
+        /// mechanisms that are in assembly.</returns>
         /// <exception cref="AssemblyException">Thrown when assembly results cannot be created for <paramref name="assessmentSection"/>.</exception>
         private static IEnumerable<ExportableFailureMechanism> CreateExportableFailureMechanisms(AssessmentSection assessmentSection)
         {
-            return new[]
+            var failureMechanisms = new List<ExportableFailureMechanism>();
+
+            AddFailureMechanismWhenInAssembly(failureMechanisms, assessmentSection.Piping, fm => ExportablePipingFailureMechanismFactory.CreateExportableFailureMechanism(fm, assessmentSection));
+            AddFailureMechanismWhenInAssembly(failureMechanisms, assessmentSection.MacroStabilityInwards, fm => ExportableMacroStabilityInwardsFailureMechanismFactory.CreateExportableFailureMechanism(fm, assessmentSection));
+            AddFailureMechanismWhenInAssembly(failureMechanisms, assessmentSection.GrassCoverErosionInwards, fm => ExportableGrassCoverErosionInwardsFailureMechanismFactory.CreateExportableFailureMechanism(fm, assessmentSection));
+            AddFailureMechanismWhenInAssembly(failureMechanisms, assessmentSection.HeightStructures, fm => ExportableHeightStructuresFailureMechanismFactory.CreateExportableFailureMechanism(fm, assessmentSection));
+            AddFailureMechanismWhenInAssembly(failureMechanisms, assessmentSection.ClosingStructures, fm => ExportableClosingStructuresFailureMechanismFactory.CreateExportableFailureMechanism(fm, assessmentSection));
+            AddFailureMechanismWhenInAssembly(failureMechanisms, assessmentSection.StabilityPointStructures, fm => ExportableStabilityPointStructuresFailureMechanismFactory.CreateExportableFailureMechanism(fm, assessmentSection));
+            AddFailureMechanismWhenInAssembly(failureMechanisms, assessmentSection.StabilityStoneCover, fm => ExportableStabilityStoneCoverFailureMechanismFactory.CreateExportableFailureMechanism(fm, assessmentSection));
+            AddFailureMechanismWhenInAssembly(failureMechanisms, assessmentSection.WaveImpactAsphaltCover, fm => ExportableWaveImpactAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(fm, assessmentSection));
+            AddFailureMechanismWhenInAssembly(failureMechanisms, assessmentSection.GrassCoverErosionOutwards, fm => ExportableGrassCoverErosionOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(fm, assessmentSection));
+            AddFailureMechanismWhenInAssembly(failureMechanisms, assessmentSection.DuneErosion, fm => ExportableDuneErosionFailureMechanismFactory.CreateExportableFailureMechanism(fm, assessmentSection));
+            AddFailureMechanismWhenInAssembly(failureMechanisms, assessmentSection.Microstability, fm => ExportableMicrostabilityFailureMechanismFactory.CreateExportableFailureMechanism(fm, assessmentSection));
+            AddFailureMechanismWhenInAssembly(failureMechanisms, assessmentSection.GrassCoverSlipOffOutwards, fm => ExportableGrassCoverSlipOffOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(fm, assessmentSection));
+            AddFailureMechanismWhenInAssembly(failureMechanisms, assessmentSection.GrassCoverSlipOffInwards, fm => ExportableGrassCoverSlipOffInwardsFailureMechanismFactory.CreateExportableFailureMechanism(fm, assessmentSection));
+            AddFailureMechanismWhenInAssembly(failureMechanisms, assessmentSection.PipingStructure, fm => ExportablePipingStructureFailureMechanismFactory.CreateExportableFailureMechanism(fm, assessmentSection));
+            AddFailureMechanismWhenInAssembly(failureMechanisms, assessmentSection.WaterPressureAsphaltCover, fm => ExportableWaterPressureAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(fm, assessmentSection));
+
+            return failureMechanisms;
+        }
+
+        private static void AddFailureMechanismWhenInAssembly<TFailureMechanism>(List<ExportableFailureMechanism> exportableFailureMechanisms,
+                                                                                 TFailureMechanism failureMechanism,
+                                                                                 Func<TFailureMechanism, ExportableFailureMechanism> createExportableFailureMechanismFunc)
+            where TFailureMechanism : IFailurePath
+        {
+            if (failureMechanism.InAssembly)
             {
-                ExportablePipingFailureMechanismFactory.CreateExportableFailureMechanism(assessmentSection.Piping, assessmentSection),
-                ExportableMacroStabilityInwardsFailureMechanismFactory.CreateExportableFailureMechanism(assessmentSection.MacroStabilityInwards, assessmentSection),
-                ExportableGrassCoverErosionInwardsFailureMechanismFactory.CreateExportableFailureMechanism(assessmentSection.GrassCoverErosionInwards, assessmentSection),
-                ExportableHeightStructuresFailureMechanismFactory.CreateExportableFailureMechanism(assessmentSection.HeightStructures, assessmentSection),
-                ExportableClosingStructuresFailureMechanismFactory.CreateExportableFailureMechanism(assessmentSection.ClosingStructures, assessmentSection),
-                ExportableStabilityPointStructuresFailureMechanismFactory.CreateExportableFailureMechanism(assessmentSection.StabilityPointStructures, assessmentSection),
-                ExportableStabilityStoneCoverFailureMechanismFactory.CreateExportableFailureMechanism(assessmentSection.StabilityStoneCover, assessmentSection),
-                ExportableWaveImpactAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(assessmentSection.WaveImpactAsphaltCover, assessmentSection),
-                ExportableGrassCoverErosionOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(assessmentSection.GrassCoverErosionOutwards, assessmentSection),
-                ExportableDuneErosionFailureMechanismFactory.CreateExportableFailureMechanism(assessmentSection.DuneErosion, assessmentSection),
-                ExportableMicrostabilityFailureMechanismFactory.CreateExportableFailureMechanism(assessmentSection.Microstability, assessmentSection),
-                ExportableGrassCoverSlipOffOutwardsFailureMechanismFactory.CreateExportableFailureMechanism(assessmentSection.GrassCoverSlipOffOutwards, assessmentSection),
-                ExportableGrassCoverSlipOffInwardsFailureMechanismFactory.CreateExportableFailureMechanism(assessmentSection.GrassCoverSlipOffInwards, assessmentSection),
-                ExportablePipingStructureFailureMechanismFactory.CreateExportableFailureMechanism(assessmentSection.PipingStructure, assessmentSection),
-                ExportableWaterPressureAsphaltCoverFailureMechanismFactory.CreateExportableFailureMechanism(assessmentSection.WaterPressureAsphaltCover, assessmentSection)
-            };
+                exportableFailureMechanisms.Add(createExportableFailureMechanismFunc(failureMechanism));
+            }
         }
 
         /// <summary>
Index: Riskeer/Integration/test/Riskeer.Integration.IO.Test/Exporters/AssemblyExporterTest.cs
===================================================================
diff -u -rdc9211089959e02aeea2ab96d684fb3fa731dd15 -r5043fc31464a612ec3d6f7e0551691b013e70b9d
--- Riskeer/Integration/test/Riskeer.Integration.IO.Test/Exporters/AssemblyExporterTest.cs	(.../AssemblyExporterTest.cs)	(revision dc9211089959e02aeea2ab96d684fb3fa731dd15)
+++ Riskeer/Integration/test/Riskeer.Integration.IO.Test/Exporters/AssemblyExporterTest.cs	(.../AssemblyExporterTest.cs)	(revision 5043fc31464a612ec3d6f7e0551691b013e70b9d)
@@ -47,10 +47,10 @@
             string filePath = TestHelper.GetScratchPadPath(Path.Combine("export", "test.gml"));
 
             // Call
-            TestDelegate call = () => new AssemblyExporter(null, filePath);
+            void Call() => new AssemblyExporter(null, filePath);
 
             // Assert
-            var exception = Assert.Throws<ArgumentNullException>(call);
+            var exception = Assert.Throws<ArgumentNullException>(Call);
             Assert.AreEqual("assessmentSection", exception.ParamName);
         }
 
@@ -62,10 +62,10 @@
             var assessmentSection = new AssessmentSection(random.NextEnumValue<AssessmentSectionComposition>());
 
             // Call
-            TestDelegate call = () => new AssemblyExporter(assessmentSection, null);
+            void Call() => new AssemblyExporter(assessmentSection, null);
 
             // Assert
-            Assert.Throws<ArgumentException>(call);
+            Assert.Throws<ArgumentException>(Call);
         }
 
         [Test]
Index: Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs
===================================================================
diff -u -rb300d03dc113da59301ff092b7d47536f02d6238 -r5043fc31464a612ec3d6f7e0551691b013e70b9d
--- Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs	(.../ExportableAssessmentSectionFactoryTest.cs)	(revision b300d03dc113da59301ff092b7d47536f02d6238)
+++ Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs	(.../ExportableAssessmentSectionFactoryTest.cs)	(revision 5043fc31464a612ec3d6f7e0551691b013e70b9d)
@@ -101,10 +101,68 @@
                 AssertExportableFailureMechanismsWithoutProbability(exportableAssessmentSection.FailureMechanisms,
                                                                     assessmentSection);
 
-                Assert.AreEqual(0, exportableAssessmentSection.CombinedSectionAssemblies.Count());
+                CollectionAssert.IsEmpty(exportableAssessmentSection.CombinedSectionAssemblies);
             }
         }
 
+        [Test]
+        public void CreateExportableAssessmentSection_AllFailureMechanismNotInAssembly_ReturnsExpectedValues()
+        {
+            // Setup
+            const string name = "assessmentSectionName";
+            const string id = "assessmentSectionId";
+
+            var random = new Random(21);
+            var assessmentSection = new AssessmentSection(random.NextEnumValue<AssessmentSectionComposition>())
+            {
+                Name = name,
+                Id = id
+            };
+            ReferenceLineTestFactory.SetReferenceLineGeometry(assessmentSection.ReferenceLine);
+
+            FailureMechanismTestHelper.AddSections(assessmentSection.Piping, random.Next(1, 10));
+            FailureMechanismTestHelper.AddSections(assessmentSection.MacroStabilityInwards, random.Next(1, 10));
+            FailureMechanismTestHelper.AddSections(assessmentSection.GrassCoverErosionInwards, random.Next(1, 10));
+            FailureMechanismTestHelper.AddSections(assessmentSection.HeightStructures, random.Next(1, 10));
+            FailureMechanismTestHelper.AddSections(assessmentSection.ClosingStructures, random.Next(1, 10));
+            FailureMechanismTestHelper.AddSections(assessmentSection.StabilityPointStructures, random.Next(1, 10));
+
+            FailureMechanismTestHelper.AddSections(assessmentSection.StabilityStoneCover, random.Next(1, 10));
+            FailureMechanismTestHelper.AddSections(assessmentSection.WaveImpactAsphaltCover, random.Next(1, 10));
+            FailureMechanismTestHelper.AddSections(assessmentSection.GrassCoverErosionOutwards, random.Next(1, 10));
+            FailureMechanismTestHelper.AddSections(assessmentSection.DuneErosion, random.Next(1, 10));
+
+            FailureMechanismTestHelper.AddSections(assessmentSection.Microstability, random.Next(1, 10));
+            FailureMechanismTestHelper.AddSections(assessmentSection.GrassCoverSlipOffOutwards, random.Next(1, 10));
+            FailureMechanismTestHelper.AddSections(assessmentSection.GrassCoverSlipOffInwards, random.Next(1, 10));
+            FailureMechanismTestHelper.AddSections(assessmentSection.PipingStructure, random.Next(1, 10));
+            FailureMechanismTestHelper.AddSections(assessmentSection.WaterPressureAsphaltCover, random.Next(1, 10));
+            
+            foreach (IFailureMechanism failureMechanism in assessmentSection.GetFailureMechanisms())
+            {
+                failureMechanism.InAssembly = false;
+            }
+
+            using (new AssemblyToolCalculatorFactoryConfig())
+            {
+                // Call
+                ExportableAssessmentSection exportableAssessmentSection = ExportableAssessmentSectionFactory.CreateExportableAssessmentSection(assessmentSection);
+
+                // Assert
+                Assert.AreEqual(name, exportableAssessmentSection.Name);
+                Assert.AreEqual(id, exportableAssessmentSection.Id);
+                CollectionAssert.AreEqual(assessmentSection.ReferenceLine.Points, exportableAssessmentSection.Geometry);
+
+                ExportableAssessmentSectionAssemblyResult exportableAssessmentSectionAssemblyResult = exportableAssessmentSection.AssessmentSectionAssembly;
+                Assert.AreEqual(ExportableAssemblyMethod.WBI2B1, exportableAssessmentSectionAssemblyResult.AssemblyMethod);
+                Assert.AreEqual(AssessmentSectionAssemblyGroup.APlus, exportableAssessmentSectionAssemblyResult.AssemblyGroup);
+                Assert.AreEqual(0.14, exportableAssessmentSectionAssemblyResult.Probability);
+
+                CollectionAssert.IsEmpty(exportableAssessmentSection.FailureMechanisms);
+                CollectionAssert.IsEmpty(exportableAssessmentSection.CombinedSectionAssemblies);
+            }
+        }
+
         private static void AssertExportableFailureMechanismsWithoutProbability(
             IEnumerable<ExportableFailureMechanism> exportableFailureMechanisms,
             AssessmentSection assessmentSection)