Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Creators/AggregatedSerializableCombinedFailureMechanismSectionAssembliesCreator.cs
===================================================================
diff -u -r7d9a50c849077865822160e024ee7b5ed66905a0 -r3143f826f08381a246a2d7936ece12241b8b1903
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Creators/AggregatedSerializableCombinedFailureMechanismSectionAssembliesCreator.cs	(.../AggregatedSerializableCombinedFailureMechanismSectionAssembliesCreator.cs)	(revision 7d9a50c849077865822160e024ee7b5ed66905a0)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Creators/AggregatedSerializableCombinedFailureMechanismSectionAssembliesCreator.cs	(.../AggregatedSerializableCombinedFailureMechanismSectionAssembliesCreator.cs)	(revision 3143f826f08381a246a2d7936ece12241b8b1903)
@@ -41,13 +41,13 @@
         /// </summary>
         /// <param name="idGenerator">The id generator to generate ids for the serializable components.</param>
         /// <param name="totalAssemblyResult">The <see cref="SerializableTotalAssemblyResult"/> the serializable components belong to.</param>
-        /// <param name="combinedSectionAssemblyCollection">The collection of <see cref="ExportableCombinedSectionAssembly"/>
-        /// to create am <see cref="AggregatedSerializableCombinedFailureMechanismSectionAssemblies"/> for.</param>
+        /// <param name="combinedSectionAssemblies">The collection of <see cref="ExportableCombinedSectionAssembly"/>
+        /// to create an <see cref="AggregatedSerializableCombinedFailureMechanismSectionAssemblies"/> for.</param>
         /// <returns>An <see cref="AggregatedSerializableCombinedFailureMechanismSectionAssemblies"/>.</returns>
         /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
         public static AggregatedSerializableCombinedFailureMechanismSectionAssemblies Create(UniqueIdentifierGenerator idGenerator,
                                                                                              SerializableTotalAssemblyResult totalAssemblyResult,
-                                                                                             IEnumerable<ExportableCombinedSectionAssembly> combinedSectionAssemblyCollection)
+                                                                                             IEnumerable<ExportableCombinedSectionAssembly> combinedSectionAssemblies)
         {
             if (idGenerator == null)
             {
@@ -59,24 +59,24 @@
                 throw new ArgumentNullException(nameof(totalAssemblyResult));
             }
 
-            if (combinedSectionAssemblyCollection == null)
+            if (combinedSectionAssemblies == null)
             {
-                throw new ArgumentNullException(nameof(combinedSectionAssemblyCollection));
+                throw new ArgumentNullException(nameof(combinedSectionAssemblies));
             }
 
             var collection = new SerializableFailureMechanismSectionCollection(idGenerator.GetNewId(Resources.SerializableFailureMechanismSectionCollection_IdPrefix),
                                                                                totalAssemblyResult);
 
-            AggregatedSerializableCombinedFailureMechanismSectionAssembly[] aggregates =
-                combinedSectionAssemblyCollection.Select(csar => AggregatedSerializableCombinedFailureMechanismSectionAssemblyCreator.Create(idGenerator,
-                                                                                                                                             totalAssemblyResult,
-                                                                                                                                             collection,
-                                                                                                                                             csar))
-                                                 .ToArray();
+            AggregatedSerializableCombinedFailureMechanismSectionAssembly[] aggregatedAssemblies =
+                combinedSectionAssemblies.Select(assembly => AggregatedSerializableCombinedFailureMechanismSectionAssemblyCreator.Create(idGenerator,
+                                                                                                                                         totalAssemblyResult,
+                                                                                                                                         collection,
+                                                                                                                                         assembly))
+                                         .ToArray();
 
             return new AggregatedSerializableCombinedFailureMechanismSectionAssemblies(collection,
-                                                                                       aggregates.Select(ag => ag.FailureMechanismSection),
-                                                                                       aggregates.Select(ag => ag.CombinedFailureMechanismSectionAssembly));
+                                                                                       aggregatedAssemblies.Select(ag => ag.FailureMechanismSection),
+                                                                                       aggregatedAssemblies.Select(ag => ag.CombinedFailureMechanismSectionAssembly));
         }
     }
 }
\ No newline at end of file
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs
===================================================================
diff -u -r86fc37386ed3cc9925009a4ecde8f4a48c3ab44a -r3143f826f08381a246a2d7936ece12241b8b1903
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs	(.../ExportableAssessmentSectionFactory.cs)	(revision 86fc37386ed3cc9925009a4ecde8f4a48c3ab44a)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableAssessmentSectionFactory.cs	(.../ExportableAssessmentSectionFactory.cs)	(revision 3143f826f08381a246a2d7936ece12241b8b1903)
@@ -169,7 +169,7 @@
         private static IEnumerable<ExportableCombinedSectionAssembly> CreateExportableCombinedSectionAssemblyCollection(AssessmentSection assessmentSection)
         {
             IEnumerable<CombinedFailureMechanismSectionAssemblyResult> assemblyResults = AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection);
-            return ExportableCombinedSectionAssemblyCollectionFactory.CreateExportableCombinedSectionAssemblyCollection(assemblyResults, assessmentSection.ReferenceLine);
+            return ExportableCombinedSectionAssemblyFactory.CreateExportableCombinedSectionAssemblyCollection(assemblyResults, assessmentSection.ReferenceLine);
         }
     }
 }
\ No newline at end of file
Fisheye: Tag 3143f826f08381a246a2d7936ece12241b8b1903 refers to a dead (removed) revision in file `Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableCombinedSectionAssemblyCollectionFactory.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableCombinedSectionAssemblyFactory.cs
===================================================================
diff -u
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableCombinedSectionAssemblyFactory.cs	(revision 0)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Factories/ExportableCombinedSectionAssemblyFactory.cs	(revision 3143f826f08381a246a2d7936ece12241b8b1903)
@@ -0,0 +1,116 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using Ringtoets.AssemblyTool.Data;
+using Ringtoets.Common.Data.AssessmentSection;
+using Ringtoets.Integration.Data.Assembly;
+using Ringtoets.Integration.IO.Assembly;
+using Ringtoets.Integration.IO.Helpers;
+
+namespace Ringtoets.Integration.IO.Factories
+{
+    /// <summary>
+    /// Factory to create a collection of <see cref="ExportableCombinedSectionAssembly"/>
+    /// </summary>
+    public static class ExportableCombinedSectionAssemblyFactory
+    {
+        /// <summary>
+        /// Creates a collection of <see cref="ExportableCombinedSectionAssembly"/>
+        /// based on <paramref name="combinedSectionAssemblyResults"/>.
+        /// </summary>
+        /// <param name="combinedSectionAssemblyResults">A collection of combined section results to
+        /// create a collection of <see cref="ExportableCombinedSectionAssembly"/> for.</param>
+        /// <param name="referenceLine">The reference line to map the sections to.</param>
+        /// <returns>A collection of <see cref="ExportableCombinedSectionAssembly"/>.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
+        public static IEnumerable<ExportableCombinedSectionAssembly> CreateExportableCombinedSectionAssemblyCollection(
+            IEnumerable<CombinedFailureMechanismSectionAssemblyResult> combinedSectionAssemblyResults,
+            ReferenceLine referenceLine)
+        {
+            if (combinedSectionAssemblyResults == null)
+            {
+                throw new ArgumentNullException(nameof(combinedSectionAssemblyResults));
+            }
+
+            if (referenceLine == null)
+            {
+                throw new ArgumentNullException(nameof(referenceLine));
+            }
+
+            var sectionResults = new List<ExportableCombinedSectionAssembly>();
+            foreach (CombinedFailureMechanismSectionAssemblyResult assemblyResult in combinedSectionAssemblyResults)
+            {
+                var exportableSection = new ExportableCombinedFailureMechanismSection(
+                    ExportableFailureMechanismSectionHelper.GetFailureMechanismSectionGeometry(
+                        referenceLine, assemblyResult.SectionStart, assemblyResult.SectionEnd),
+                    assemblyResult.SectionStart,
+                    assemblyResult.SectionEnd,
+                    ExportableAssemblyMethod.WBI3A1);
+
+                var exportableSectionResult = new ExportableCombinedSectionAssembly(exportableSection,
+                                                                                    new ExportableSectionAssemblyResult(ExportableAssemblyMethod.WBI3C1,
+                                                                                                                        assemblyResult.TotalResult),
+                                                                                    CreateFailureMechanismCombinedSectionAssemblyResults(assemblyResult));
+
+                sectionResults.Add(exportableSectionResult);
+            }
+
+            return sectionResults;
+        }
+
+        private static IEnumerable<ExportableFailureMechanismCombinedSectionAssemblyResult> CreateFailureMechanismCombinedSectionAssemblyResults(
+            CombinedFailureMechanismSectionAssemblyResult assemblyResult)
+        {
+            return new[]
+            {
+                CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.Piping, ExportableFailureMechanismType.STPH),
+                CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.GrassCoverErosionInwards, ExportableFailureMechanismType.GEKB),
+                CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.MacroStabilityInwards, ExportableFailureMechanismType.STBI),
+                CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.MacroStabilityOutwards, ExportableFailureMechanismType.STBU),
+                CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.Microstability, ExportableFailureMechanismType.STMI),
+                CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.StabilityStoneCover, ExportableFailureMechanismType.ZST),
+                CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.WaveImpactAsphaltCover, ExportableFailureMechanismType.AGK),
+                CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.WaterPressureAsphaltCover, ExportableFailureMechanismType.AWO),
+                CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.GrassCoverErosionOutwards, ExportableFailureMechanismType.GEBU),
+                CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.GrassCoverSlipOffOutwards, ExportableFailureMechanismType.GABU),
+                CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.GrassCoverSlipOffInwards, ExportableFailureMechanismType.GABI),
+                CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.HeightStructures, ExportableFailureMechanismType.HTKW),
+                CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.ClosingStructures, ExportableFailureMechanismType.BSKW),
+                CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.PipingStructure, ExportableFailureMechanismType.PKW),
+                CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.StabilityPointStructures, ExportableFailureMechanismType.STKWp),
+                CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.StrengthStabilityLengthwiseConstruction, ExportableFailureMechanismType.STKWl),
+                CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.DuneErosion, ExportableFailureMechanismType.DA),
+                CreateExportableFailureMechanismCombinedSectionAssemblyResult(assemblyResult.TechnicalInnovation, ExportableFailureMechanismType.INN)
+            };
+        }
+
+        private static ExportableFailureMechanismCombinedSectionAssemblyResult CreateExportableFailureMechanismCombinedSectionAssemblyResult(
+            FailureMechanismSectionAssemblyCategoryGroup sectionAssemblyResult,
+            ExportableFailureMechanismType failureMechanismCode)
+        {
+            return new ExportableFailureMechanismCombinedSectionAssemblyResult(new ExportableSectionAssemblyResult(ExportableAssemblyMethod.WBI3B1,
+                                                                                                                   sectionAssemblyResult),
+                                                                               failureMechanismCode);
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Ringtoets.Integration.IO.csproj
===================================================================
diff -u -r86fc37386ed3cc9925009a4ecde8f4a48c3ab44a -r3143f826f08381a246a2d7936ece12241b8b1903
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Ringtoets.Integration.IO.csproj	(.../Ringtoets.Integration.IO.csproj)	(revision 86fc37386ed3cc9925009a4ecde8f4a48c3ab44a)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Ringtoets.Integration.IO.csproj	(.../Ringtoets.Integration.IO.csproj)	(revision 3143f826f08381a246a2d7936ece12241b8b1903)
@@ -61,7 +61,7 @@
     <Compile Include="Exporters\HydraulicBoundaryLocationsWriter.cs" />
     <Compile Include="Factories\ExportableAssessmentSectionFactory.cs" />
     <Compile Include="Factories\ExportableClosingStructuresFailureMechanismFactory.cs" />
-    <Compile Include="Factories\ExportableCombinedSectionAssemblyCollectionFactory.cs" />
+    <Compile Include="Factories\ExportableCombinedSectionAssemblyFactory.cs" />
     <Compile Include="Factories\ExportableDuneErosionFailureMechanismFactory.cs" />
     <Compile Include="Factories\ExportableFailureMechanismFactory.cs" />
     <Compile Include="Factories\ExportableGrassCoverErosionInwardsFailureMechanismFactory.cs" />
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Creators/AggregatedSerializableCombinedFailureMechanismSectionAssembliesCreatorTest.cs
===================================================================
diff -u -r7d9a50c849077865822160e024ee7b5ed66905a0 -r3143f826f08381a246a2d7936ece12241b8b1903
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Creators/AggregatedSerializableCombinedFailureMechanismSectionAssembliesCreatorTest.cs	(.../AggregatedSerializableCombinedFailureMechanismSectionAssembliesCreatorTest.cs)	(revision 7d9a50c849077865822160e024ee7b5ed66905a0)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Creators/AggregatedSerializableCombinedFailureMechanismSectionAssembliesCreatorTest.cs	(.../AggregatedSerializableCombinedFailureMechanismSectionAssembliesCreatorTest.cs)	(revision 3143f826f08381a246a2d7936ece12241b8b1903)
@@ -70,7 +70,7 @@
         }
 
         [Test]
-        public void Create_CombinedSectionAssemblyCollectionNull_ThrowsArgumentNullException()
+        public void Create_CombinedSectionAssembliesNull_ThrowsArgumentNullException()
         {
             // Call
             TestDelegate call = () =>
@@ -81,7 +81,7 @@
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
-            Assert.AreEqual("combinedSectionAssemblyCollection", exception.ParamName);
+            Assert.AreEqual("combinedSectionAssemblies", exception.ParamName);
         }
 
         [Test]
Fisheye: Tag 3143f826f08381a246a2d7936ece12241b8b1903 refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableCombinedSectionAssemblyCollectionFactoryTest.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableCombinedSectionAssemblyFactoryTest.cs
===================================================================
diff -u
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableCombinedSectionAssemblyFactoryTest.cs	(revision 0)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Factories/ExportableCombinedSectionAssemblyFactoryTest.cs	(revision 3143f826f08381a246a2d7936ece12241b8b1903)
@@ -0,0 +1,217 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Core.Common.Base.Geometry;
+using Core.Common.TestUtil;
+using NUnit.Framework;
+using Ringtoets.AssemblyTool.Data;
+using Ringtoets.Common.Data.AssessmentSection;
+using Ringtoets.Integration.Data.Assembly;
+using Ringtoets.Integration.IO.Assembly;
+using Ringtoets.Integration.IO.Factories;
+using Ringtoets.Integration.IO.Helpers;
+
+namespace Ringtoets.Integration.IO.Test.Factories
+{
+    [TestFixture]
+    public class ExportableCombinedSectionAssemblyFactoryTest
+    {
+        [Test]
+        public void CreateExportableCombinedSectionAssemblyCollection_CombinedSectionAssemblyResultsNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => ExportableCombinedSectionAssemblyFactory.CreateExportableCombinedSectionAssemblyCollection(null, new ReferenceLine());
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("combinedSectionAssemblyResults", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateExportableCombinedSectionAssemblyCollection_ReferenceLineNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => ExportableCombinedSectionAssemblyFactory.CreateExportableCombinedSectionAssemblyCollection(
+                Enumerable.Empty<CombinedFailureMechanismSectionAssemblyResult>(), null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("referenceLine", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateExportableCombinedSectionAssemblyCollection_WithAssemblyResults_ReturnsExportableCombinedSectionAssemblyCollection()
+        {
+            // Setup
+            var referenceLine = new ReferenceLine();
+            referenceLine.SetGeometry(new[]
+            {
+                new Point2D(0, 0),
+                new Point2D(2, 2)
+            });
+            CombinedFailureMechanismSectionAssemblyResult[] assemblyResults =
+            {
+                CreateCombinedFailureMechanismSectionAssemblyResult(21),
+                CreateCombinedFailureMechanismSectionAssemblyResult(22)
+            };
+
+            // Call
+            IEnumerable<ExportableCombinedSectionAssembly> exportableCombinedSectionAssembly =
+                ExportableCombinedSectionAssemblyFactory.CreateExportableCombinedSectionAssemblyCollection(assemblyResults, referenceLine);
+
+            // Assert
+            AssertCombinedFailureMechanismSectionAssemblyResults(assemblyResults, exportableCombinedSectionAssembly, referenceLine);
+        }
+
+        private static CombinedFailureMechanismSectionAssemblyResult CreateCombinedFailureMechanismSectionAssemblyResult(int seed)
+        {
+            var random = new Random(seed);
+
+            return new CombinedFailureMechanismSectionAssemblyResult(random.NextDouble(),
+                                                                     random.NextDouble(),
+                                                                     random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>(),
+                                                                     new CombinedFailureMechanismSectionAssemblyResult.ConstructionProperties
+                                                                     {
+                                                                         Piping = random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>(),
+                                                                         GrassCoverErosionInwards = random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>(),
+                                                                         MacroStabilityInwards = random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>(),
+                                                                         MacroStabilityOutwards = random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>(),
+                                                                         Microstability = random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>(),
+                                                                         StabilityStoneCover = random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>(),
+                                                                         WaveImpactAsphaltCover = random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>(),
+                                                                         WaterPressureAsphaltCover = random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>(),
+                                                                         GrassCoverErosionOutwards = random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>(),
+                                                                         GrassCoverSlipOffOutwards = random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>(),
+                                                                         GrassCoverSlipOffInwards = random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>(),
+                                                                         HeightStructures = random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>(),
+                                                                         ClosingStructures = random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>(),
+                                                                         PipingStructure = random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>(),
+                                                                         StabilityPointStructures = random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>(),
+                                                                         StrengthStabilityLengthwiseConstruction = random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>(),
+                                                                         DuneErosion = random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>(),
+                                                                         TechnicalInnovation = random.NextEnumValue<FailureMechanismSectionAssemblyCategoryGroup>()
+                                                                     });
+        }
+
+        private static void AssertCombinedFailureMechanismSectionAssemblyResults(IEnumerable<CombinedFailureMechanismSectionAssemblyResult> expectedSectionResults,
+                                                                                 IEnumerable<ExportableCombinedSectionAssembly> combinedSectionAssemblies,
+                                                                                 ReferenceLine referenceLine)
+        {
+            int expectedNrOfSections = expectedSectionResults.Count();
+            Assert.AreEqual(expectedNrOfSections, combinedSectionAssemblies.Count());
+
+            for (var i = 0; i < expectedNrOfSections; i++)
+            {
+                CombinedFailureMechanismSectionAssemblyResult expectedSection = expectedSectionResults.ElementAt(i);
+                ExportableCombinedSectionAssembly actualSectionResult = combinedSectionAssemblies.ElementAt(i);
+
+                AssertExportableCombinedFailureMechanismSection(expectedSection, actualSectionResult.Section, referenceLine);
+                AssertExportableCombinedFailureMechanismSectionResult(actualSectionResult, actualSectionResult.Section, expectedSection);
+            }
+        }
+
+        private static void AssertExportableCombinedFailureMechanismSection(CombinedFailureMechanismSectionAssemblyResult expectedSection,
+                                                                            ExportableCombinedFailureMechanismSection actualSection,
+                                                                            ReferenceLine referenceLine)
+        {
+            IEnumerable<Point2D> expectedGeometry = ExportableFailureMechanismSectionHelper.GetFailureMechanismSectionGeometry(
+                referenceLine,
+                actualSection.StartDistance,
+                actualSection.EndDistance).ToArray();
+            CollectionAssert.IsNotEmpty(expectedGeometry);
+
+            Assert.AreEqual(expectedSection.SectionStart, actualSection.StartDistance);
+            Assert.AreEqual(expectedSection.SectionEnd, actualSection.EndDistance);
+            CollectionAssert.AreEqual(expectedGeometry, actualSection.Geometry);
+            Assert.AreEqual(ExportableAssemblyMethod.WBI3A1, actualSection.AssemblyMethod);
+        }
+
+        private static void AssertExportableCombinedFailureMechanismSectionResult(ExportableCombinedSectionAssembly expectedSectionResult,
+                                                                                  ExportableCombinedFailureMechanismSection expectedSection,
+                                                                                  CombinedFailureMechanismSectionAssemblyResult actualCombinedSectionAssemblyResult)
+        {
+            Assert.AreSame(expectedSection, expectedSectionResult.Section);
+            Assert.AreEqual(actualCombinedSectionAssemblyResult.TotalResult, expectedSectionResult.CombinedSectionAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(ExportableAssemblyMethod.WBI3C1, expectedSectionResult.CombinedSectionAssemblyResult.AssemblyMethod);
+
+            IEnumerable<ExportableFailureMechanismCombinedSectionAssemblyResult> failureMechanismCombinedSectionResults = expectedSectionResult.FailureMechanismResults;
+            Assert.AreEqual(18, failureMechanismCombinedSectionResults.Count());
+            Assert.IsTrue(failureMechanismCombinedSectionResults.All(result => result.SectionAssemblyResult.AssemblyMethod == ExportableAssemblyMethod.WBI3B1));
+
+            Assert.AreEqual(actualCombinedSectionAssemblyResult.Piping, failureMechanismCombinedSectionResults.ElementAt(0).SectionAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(ExportableFailureMechanismType.STPH, failureMechanismCombinedSectionResults.ElementAt(0).Code);
+
+            Assert.AreEqual(actualCombinedSectionAssemblyResult.GrassCoverErosionInwards, failureMechanismCombinedSectionResults.ElementAt(1).SectionAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(ExportableFailureMechanismType.GEKB, failureMechanismCombinedSectionResults.ElementAt(1).Code);
+
+            Assert.AreEqual(actualCombinedSectionAssemblyResult.MacroStabilityInwards, failureMechanismCombinedSectionResults.ElementAt(2).SectionAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(ExportableFailureMechanismType.STBI, failureMechanismCombinedSectionResults.ElementAt(2).Code);
+
+            Assert.AreEqual(actualCombinedSectionAssemblyResult.MacroStabilityOutwards, failureMechanismCombinedSectionResults.ElementAt(3).SectionAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(ExportableFailureMechanismType.STBU, failureMechanismCombinedSectionResults.ElementAt(3).Code);
+
+            Assert.AreEqual(actualCombinedSectionAssemblyResult.Microstability, failureMechanismCombinedSectionResults.ElementAt(4).SectionAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(ExportableFailureMechanismType.STMI, failureMechanismCombinedSectionResults.ElementAt(4).Code);
+
+            Assert.AreEqual(actualCombinedSectionAssemblyResult.StabilityStoneCover, failureMechanismCombinedSectionResults.ElementAt(5).SectionAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(ExportableFailureMechanismType.ZST, failureMechanismCombinedSectionResults.ElementAt(5).Code);
+
+            Assert.AreEqual(actualCombinedSectionAssemblyResult.WaveImpactAsphaltCover, failureMechanismCombinedSectionResults.ElementAt(6).SectionAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(ExportableFailureMechanismType.AGK, failureMechanismCombinedSectionResults.ElementAt(6).Code);
+
+            Assert.AreEqual(actualCombinedSectionAssemblyResult.WaterPressureAsphaltCover, failureMechanismCombinedSectionResults.ElementAt(7).SectionAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(ExportableFailureMechanismType.AWO, failureMechanismCombinedSectionResults.ElementAt(7).Code);
+
+            Assert.AreEqual(actualCombinedSectionAssemblyResult.GrassCoverErosionOutwards, failureMechanismCombinedSectionResults.ElementAt(8).SectionAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(ExportableFailureMechanismType.GEBU, failureMechanismCombinedSectionResults.ElementAt(8).Code);
+
+            Assert.AreEqual(actualCombinedSectionAssemblyResult.GrassCoverSlipOffOutwards, failureMechanismCombinedSectionResults.ElementAt(9).SectionAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(ExportableFailureMechanismType.GABU, failureMechanismCombinedSectionResults.ElementAt(9).Code);
+
+            Assert.AreEqual(actualCombinedSectionAssemblyResult.GrassCoverSlipOffInwards, failureMechanismCombinedSectionResults.ElementAt(10).SectionAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(ExportableFailureMechanismType.GABI, failureMechanismCombinedSectionResults.ElementAt(10).Code);
+
+            Assert.AreEqual(actualCombinedSectionAssemblyResult.HeightStructures, failureMechanismCombinedSectionResults.ElementAt(11).SectionAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(ExportableFailureMechanismType.HTKW, failureMechanismCombinedSectionResults.ElementAt(11).Code);
+
+            Assert.AreEqual(actualCombinedSectionAssemblyResult.ClosingStructures, failureMechanismCombinedSectionResults.ElementAt(12).SectionAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(ExportableFailureMechanismType.BSKW, failureMechanismCombinedSectionResults.ElementAt(12).Code);
+
+            Assert.AreEqual(actualCombinedSectionAssemblyResult.PipingStructure, failureMechanismCombinedSectionResults.ElementAt(13).SectionAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(ExportableFailureMechanismType.PKW, failureMechanismCombinedSectionResults.ElementAt(13).Code);
+
+            Assert.AreEqual(actualCombinedSectionAssemblyResult.StabilityPointStructures, failureMechanismCombinedSectionResults.ElementAt(14).SectionAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(ExportableFailureMechanismType.STKWp, failureMechanismCombinedSectionResults.ElementAt(14).Code);
+
+            Assert.AreEqual(actualCombinedSectionAssemblyResult.StrengthStabilityLengthwiseConstruction, failureMechanismCombinedSectionResults.ElementAt(15).SectionAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(ExportableFailureMechanismType.STKWl, failureMechanismCombinedSectionResults.ElementAt(15).Code);
+
+            Assert.AreEqual(actualCombinedSectionAssemblyResult.DuneErosion, failureMechanismCombinedSectionResults.ElementAt(16).SectionAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(ExportableFailureMechanismType.DA, failureMechanismCombinedSectionResults.ElementAt(16).Code);
+
+            Assert.AreEqual(actualCombinedSectionAssemblyResult.TechnicalInnovation, failureMechanismCombinedSectionResults.ElementAt(17).SectionAssemblyResult.AssemblyCategory);
+            Assert.AreEqual(ExportableFailureMechanismType.INN, failureMechanismCombinedSectionResults.ElementAt(17).Code);
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Ringtoets.Integration.IO.Test.csproj
===================================================================
diff -u -r86fc37386ed3cc9925009a4ecde8f4a48c3ab44a -r3143f826f08381a246a2d7936ece12241b8b1903
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Ringtoets.Integration.IO.Test.csproj	(.../Ringtoets.Integration.IO.Test.csproj)	(revision 86fc37386ed3cc9925009a4ecde8f4a48c3ab44a)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Ringtoets.Integration.IO.Test.csproj	(.../Ringtoets.Integration.IO.Test.csproj)	(revision 3143f826f08381a246a2d7936ece12241b8b1903)
@@ -63,7 +63,7 @@
     <Compile Include="Exporters\HydraulicBoundaryLocationsExporterTest.cs" />
     <Compile Include="Exporters\HydraulicBoundaryLocationsWriterTest.cs" />
     <Compile Include="Factories\ExportableClosingStructuresFailureMechanismFactoryTest.cs" />
-    <Compile Include="Factories\ExportableCombinedSectionAssemblyCollectionFactoryTest.cs" />
+    <Compile Include="Factories\ExportableCombinedSectionAssemblyFactoryTest.cs" />
     <Compile Include="Factories\ExportableDuneErosionFailureMechanismFactoryTest.cs" />
     <Compile Include="Factories\ExportableFailureMechanismFactoryTest.cs" />
     <Compile Include="Factories\ExportableGrassCoverErosionInwardsFailureMechanismFactoryTest.cs" />