Index: Riskeer/Common/test/Riskeer.Common.Data.TestUtil/FailureMechanismTestHelper.cs
===================================================================
diff -u -r9d13fc4925bbab28ecc91ed7754a391749e53e1c -r74f6ee8b46fe57f0c79771536609cf638100de29
--- Riskeer/Common/test/Riskeer.Common.Data.TestUtil/FailureMechanismTestHelper.cs	(.../FailureMechanismTestHelper.cs)	(revision 9d13fc4925bbab28ecc91ed7754a391749e53e1c)
+++ Riskeer/Common/test/Riskeer.Common.Data.TestUtil/FailureMechanismTestHelper.cs	(.../FailureMechanismTestHelper.cs)	(revision 74f6ee8b46fe57f0c79771536609cf638100de29)
@@ -52,12 +52,12 @@
         /// </summary>
         /// <param name="failureMechanism">The failure mechanism to add sections to.</param>
         /// <param name="numberOfSections">The number of sections to add to the <paramref name="failureMechanism"/>.</param>
-        public static void AddSections(IFailureMechanism failureMechanism, int numberOfSections)
+        public static void AddSections(IFailurePath failureMechanism, int numberOfSections)
         {
             AddSections(failureMechanism, numberOfSections, new Point2D(-1, -1), new Point2D(15, 15));
         }
 
-        private static void AddSections(IFailureMechanism failureMechanism, int numberOfSections, Point2D startPoint, Point2D endPoint)
+        private static void AddSections(IFailurePath failureMechanism, int numberOfSections, Point2D startPoint, Point2D endPoint)
         {
             double endPointStepsX = (endPoint.X - startPoint.X) / numberOfSections;
             double endPointStepsY = (endPoint.Y - startPoint.Y) / numberOfSections;
Index: Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs
===================================================================
diff -u -r81a1ee36a074aaba2550106a26687e82c3e11109 -r74f6ee8b46fe57f0c79771536609cf638100de29
--- Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs	(.../ExportableAssessmentSectionFactory.cs)	(revision 81a1ee36a074aaba2550106a26687e82c3e11109)
+++ Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs	(.../ExportableAssessmentSectionFactory.cs)	(revision 74f6ee8b46fe57f0c79771536609cf638100de29)
@@ -165,6 +165,13 @@
                 exportableFailureMechanisms, assessmentSection.WaterPressureAsphaltCover, assessmentSection, FailureMechanismAssemblyFactory.AssembleFailureMechanism,
                 FailureMechanismAssemblyFactory.AssembleSection, ExportableFailureMechanismType.Generic);
 
+            foreach (SpecificFailurePath specificFailurePath in assessmentSection.SpecificFailurePaths)
+            {
+                AddFailureMechanismWhenInAssembly<SpecificFailurePath, NonAdoptableWithProfileProbabilityFailureMechanismSectionResult>(
+                    exportableFailureMechanisms, specificFailurePath, assessmentSection, FailureMechanismAssemblyFactory.AssembleFailureMechanism,
+                    FailureMechanismAssemblyFactory.AssembleSection, ExportableFailureMechanismType.Specific);
+            }
+
             return exportableFailureMechanisms;
         }
 
Index: Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs
===================================================================
diff -u -r2077c21eebd3514bbc3f49f2cf9039100760f966 -r74f6ee8b46fe57f0c79771536609cf638100de29
--- Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs	(.../ExportableAssessmentSectionFactoryTest.cs)	(revision 2077c21eebd3514bbc3f49f2cf9039100760f966)
+++ Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableAssessmentSectionFactoryTest.cs	(.../ExportableAssessmentSectionFactoryTest.cs)	(revision 74f6ee8b46fe57f0c79771536609cf638100de29)
@@ -65,6 +65,9 @@
             };
             ReferenceLineTestFactory.SetReferenceLineGeometry(assessmentSection.ReferenceLine);
 
+            assessmentSection.SpecificFailurePaths.Add(new SpecificFailurePath());
+            assessmentSection.SpecificFailurePaths.Add(new SpecificFailurePath());
+
             FailureMechanismTestHelper.AddSections(assessmentSection.Piping, random.Next(1, 10));
             FailureMechanismTestHelper.AddSections(assessmentSection.MacroStabilityInwards, random.Next(1, 10));
             FailureMechanismTestHelper.AddSections(assessmentSection.GrassCoverErosionInwards, random.Next(1, 10));
@@ -82,6 +85,8 @@
             FailureMechanismTestHelper.AddSections(assessmentSection.GrassCoverSlipOffInwards, random.Next(1, 10));
             FailureMechanismTestHelper.AddSections(assessmentSection.PipingStructure, random.Next(1, 10));
             FailureMechanismTestHelper.AddSections(assessmentSection.WaterPressureAsphaltCover, random.Next(1, 10));
+            FailureMechanismTestHelper.AddSections(assessmentSection.SpecificFailurePaths.First(), random.Next(1, 10));
+            FailureMechanismTestHelper.AddSections(assessmentSection.SpecificFailurePaths.Last(), random.Next(1, 10));
 
             using (new AssemblyToolCalculatorFactoryConfig())
             {
@@ -98,8 +103,8 @@
                 Assert.AreEqual(AssessmentSectionAssemblyGroup.APlus, exportableAssessmentSectionAssemblyResult.AssemblyGroup);
                 Assert.AreEqual(0.14, exportableAssessmentSectionAssemblyResult.Probability);
 
-                AssertExportableFailureMechanismsWithoutProbability(exportableAssessmentSection.FailureMechanisms,
-                                                                    assessmentSection);
+                AssertExportableFailureMechanisms(exportableAssessmentSection.FailureMechanisms,
+                                                  assessmentSection);
 
                 CollectionAssert.IsEmpty(exportableAssessmentSection.CombinedSectionAssemblies);
             }
@@ -120,6 +125,9 @@
             };
             ReferenceLineTestFactory.SetReferenceLineGeometry(assessmentSection.ReferenceLine);
 
+            assessmentSection.SpecificFailurePaths.Add(new SpecificFailurePath());
+            assessmentSection.SpecificFailurePaths.Add(new SpecificFailurePath());
+
             FailureMechanismTestHelper.AddSections(assessmentSection.Piping, random.Next(1, 10));
             FailureMechanismTestHelper.AddSections(assessmentSection.MacroStabilityInwards, random.Next(1, 10));
             FailureMechanismTestHelper.AddSections(assessmentSection.GrassCoverErosionInwards, random.Next(1, 10));
@@ -138,7 +146,11 @@
             FailureMechanismTestHelper.AddSections(assessmentSection.PipingStructure, random.Next(1, 10));
             FailureMechanismTestHelper.AddSections(assessmentSection.WaterPressureAsphaltCover, random.Next(1, 10));
 
-            foreach (IFailureMechanism failureMechanism in assessmentSection.GetFailureMechanisms())
+            FailureMechanismTestHelper.AddSections(assessmentSection.SpecificFailurePaths.First(), random.Next(1, 10));
+            FailureMechanismTestHelper.AddSections(assessmentSection.SpecificFailurePaths.Last(), random.Next(1, 10));
+
+            foreach (IFailurePath failureMechanism in assessmentSection.GetFailureMechanisms()
+                                                                       .Concat<IFailurePath>(assessmentSection.SpecificFailurePaths))
             {
                 failureMechanism.InAssembly = false;
             }
@@ -163,61 +175,86 @@
             }
         }
 
-        private static void AssertExportableFailureMechanismsWithoutProbability(
+        private static void AssertExportableFailureMechanisms(
             IEnumerable<ExportableFailureMechanism> exportableFailureMechanisms,
             AssessmentSection assessmentSection)
         {
-            Assert.AreEqual(15, exportableFailureMechanisms.Count());
+            Assert.AreEqual(17, exportableFailureMechanisms.Count());
 
             AssertExportableFailureMechanism(assessmentSection.Piping,
+                                             ExportableFailureMechanismType.Generic,
                                              exportableFailureMechanisms.ElementAt(0));
 
             AssertExportableFailureMechanism(assessmentSection.MacroStabilityInwards,
+                                             ExportableFailureMechanismType.Generic,
                                              exportableFailureMechanisms.ElementAt(1));
 
             AssertExportableFailureMechanism(assessmentSection.GrassCoverErosionInwards,
+                                             ExportableFailureMechanismType.Generic,
                                              exportableFailureMechanisms.ElementAt(2));
 
             AssertExportableFailureMechanism(assessmentSection.HeightStructures,
+                                             ExportableFailureMechanismType.Generic,
                                              exportableFailureMechanisms.ElementAt(3));
 
             AssertExportableFailureMechanism(assessmentSection.ClosingStructures,
+                                             ExportableFailureMechanismType.Generic,
                                              exportableFailureMechanisms.ElementAt(4));
 
             AssertExportableFailureMechanism(assessmentSection.StabilityPointStructures,
+                                             ExportableFailureMechanismType.Generic,
                                              exportableFailureMechanisms.ElementAt(5));
 
             AssertExportableFailureMechanism(assessmentSection.StabilityStoneCover,
+                                             ExportableFailureMechanismType.Generic,
                                              exportableFailureMechanisms.ElementAt(6));
 
             AssertExportableFailureMechanism(assessmentSection.WaveImpactAsphaltCover,
+                                             ExportableFailureMechanismType.Generic,
                                              exportableFailureMechanisms.ElementAt(7));
 
             AssertExportableFailureMechanism(assessmentSection.GrassCoverErosionOutwards,
+                                             ExportableFailureMechanismType.Generic,
                                              exportableFailureMechanisms.ElementAt(8));
 
             AssertExportableFailureMechanism(assessmentSection.DuneErosion,
+                                             ExportableFailureMechanismType.Generic,
                                              exportableFailureMechanisms.ElementAt(9));
 
             AssertExportableFailureMechanism(assessmentSection.Microstability,
+                                             ExportableFailureMechanismType.Generic,
                                              exportableFailureMechanisms.ElementAt(10));
 
             AssertExportableFailureMechanism(assessmentSection.GrassCoverSlipOffOutwards,
+                                             ExportableFailureMechanismType.Generic,
                                              exportableFailureMechanisms.ElementAt(11));
 
             AssertExportableFailureMechanism(assessmentSection.GrassCoverSlipOffInwards,
+                                             ExportableFailureMechanismType.Generic,
                                              exportableFailureMechanisms.ElementAt(12));
 
             AssertExportableFailureMechanism(assessmentSection.PipingStructure,
+                                             ExportableFailureMechanismType.Generic,
                                              exportableFailureMechanisms.ElementAt(13));
 
             AssertExportableFailureMechanism(assessmentSection.WaterPressureAsphaltCover,
+                                             ExportableFailureMechanismType.Generic,
                                              exportableFailureMechanisms.ElementAt(14));
+
+            AssertExportableFailureMechanism(assessmentSection.SpecificFailurePaths.First(),
+                                             ExportableFailureMechanismType.Specific,
+                                             exportableFailureMechanisms.ElementAt(15));
+
+            AssertExportableFailureMechanism(assessmentSection.SpecificFailurePaths.Last(),
+                                             ExportableFailureMechanismType.Specific,
+                                             exportableFailureMechanisms.ElementAt(16));
         }
 
         private static void AssertExportableFailureMechanism(IFailurePath<FailureMechanismSectionResult> failureMechanism,
+                                                             ExportableFailureMechanismType expectedFailureMechanismType,
                                                              ExportableFailureMechanism actualExportableFailureMechanism)
         {
+            Assert.AreEqual(expectedFailureMechanismType, actualExportableFailureMechanism.FailureMechanismType);
             Assert.AreEqual(failureMechanism.Code, actualExportableFailureMechanism.Code);
 
             ExportableFailureMechanismAssemblyResult exportableFailureMechanismAssemblyResult = actualExportableFailureMechanism.FailureMechanismAssembly;