Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Creators/AggregatedSerializableFailureMechanismCreator.cs
===================================================================
diff -u -r1fb8afd636f36c169e0e4ac3fa87472f372eb915 -ra4e95638762a7a1af29dd63dec477120c4faf249
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Creators/AggregatedSerializableFailureMechanismCreator.cs	(.../AggregatedSerializableFailureMechanismCreator.cs)	(revision 1fb8afd636f36c169e0e4ac3fa87472f372eb915)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Creators/AggregatedSerializableFailureMechanismCreator.cs	(.../AggregatedSerializableFailureMechanismCreator.cs)	(revision a4e95638762a7a1af29dd63dec477120c4faf249)
@@ -20,7 +20,6 @@
 // All rights reserved.
 
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using Ringtoets.AssemblyTool.IO.Model;
 using Ringtoets.Integration.IO.Assembly;
@@ -33,31 +32,67 @@
     /// </summary>
     public static class AggregatedSerializableFailureMechanismCreator
     {
+        /// <summary>
+        /// Creates an instance of an <see cref="AggregatedSerializableFailureMechanism"/> based on its input parameters.
+        /// </summary>
+        /// <param name="idGenerator">The id generator to generate an id for the serializable components.</param>
+        /// <param name="serializableTotalAssemblyResult">The <see cref="SerializableTotalAssemblyResult"/> the serializable components belong to.</param>
+        /// <param name="failureMechanism">The <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/> with a probability to
+        /// create a <see cref="AggregatedSerializableFailureMechanism"/> for.</param>
+        /// <returns>A <see cref="AggregatedSerializableFailureMechanism"/>.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
+        /// <exception cref="NotSupportedException">Thrown when the <see cref="ExportableFailureMechanism{TFailureMechanismAssemblyResult}"/>
+        /// contains unsupported items in the failure mechanism section assembly results.</exception>
         public static AggregatedSerializableFailureMechanism Create(UniqueIdentifierGenerator idGenerator,
-                                                                    SerializableTotalAssemblyResult serializableTotalAssembly,
+                                                                    SerializableTotalAssemblyResult serializableTotalAssemblyResult,
                                                                     ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability> failureMechanism)
         {
-            SerializableFailureMechanism serializableFailureMechanism = SerializableFailureMechanismCreator.Create(idGenerator, serializableTotalAssembly, failureMechanism);
-            var serializableCollection = new SerializableFailureMechanismSectionCollection(idGenerator.GetNewId("Vi"), serializableFailureMechanism);
+            if (idGenerator == null)
+            {
+                throw new ArgumentNullException(nameof(idGenerator));
+            }
 
-            var serializableFailureMechanismSectionAssemblyResults = new List<AggregatedSerializableFailureMechanismSectionAssembly>();
-            foreach (ExportableAggregatedFailureMechanismSectionAssemblyResultBase sectionAssemblyResult in failureMechanism.SectionAssemblyResults)
+            if (serializableTotalAssemblyResult == null)
             {
-                serializableFailureMechanismSectionAssemblyResults.Add(CreateFailureMechanismSectionAssembly(idGenerator, 
-                                                                                                             serializableFailureMechanism, 
-                                                                                                             serializableCollection,
-                                                                                                             sectionAssemblyResult));
+                throw new ArgumentNullException(nameof(serializableTotalAssemblyResult));
             }
 
+            if (failureMechanism == null)
+            {
+                throw new ArgumentNullException(nameof(failureMechanism));
+            }
+
+            SerializableFailureMechanism serializableFailureMechanism = SerializableFailureMechanismCreator.Create(idGenerator, serializableTotalAssemblyResult, failureMechanism);
+            var serializableCollection = new SerializableFailureMechanismSectionCollection(idGenerator.GetNewId("Vi"), serializableFailureMechanism);
+
+            AggregatedSerializableFailureMechanismSectionAssembly[] serializableFailureMechanismSectionAssemblyResults =
+                failureMechanism.SectionAssemblyResults
+                                .Select(sectionAssemblyResult => CreateFailureMechanismSectionAssembly(idGenerator,
+                                                                                                       serializableFailureMechanism,
+                                                                                                       serializableCollection,
+                                                                                                       sectionAssemblyResult))
+                                .ToArray();
+
             return new AggregatedSerializableFailureMechanism(serializableFailureMechanism,
                                                               serializableCollection,
                                                               serializableFailureMechanismSectionAssemblyResults.Select(fmr => fmr.FailureMechanismSection),
                                                               serializableFailureMechanismSectionAssemblyResults.Select(fmr => fmr.FailureMechanismSectionAssembly));
         }
 
+        /// <summary>
+        /// Creates an instance of <see cref="AggregatedSerializableFailureMechanismSectionAssembly"/> based on its input parameters.
+        /// </summary>
+        /// <param name="idGenerator">The id generator to generate the id for the serializable components.</param>
+        /// <param name="serializableFailureMechanism">The <see cref="SerializableFailureMechanism"/> the section assembly belongs to.</param>
+        /// <param name="serializableCollection">The <see cref="SerializableFailureMechanismSectionCollection"/> the section assembly belongs to.</param>
+        /// <param name="failureMechanismSectionAssemblyResult">An aggregated failure mechanism section assembly result to
+        /// create a <see cref="AggregatedSerializableFailureMechanismSectionAssembly"/> for.</param>
+        /// <returns>An <see cref="AggregatedSerializableFailureMechanismSectionAssembly"/>.</returns>
+        /// <exception cref="NotSupportedException">Thrown when an <see cref="AggregatedSerializableFailureMechanismSectionAssembly"/>
+        /// cannot be created for <paramref name="failureMechanismSectionAssemblyResult"/>.</exception>
         private static AggregatedSerializableFailureMechanismSectionAssembly CreateFailureMechanismSectionAssembly(
             UniqueIdentifierGenerator idGenerator,
-            SerializableFailureMechanism serializableFailureMechanism, 
+            SerializableFailureMechanism serializableFailureMechanism,
             SerializableFailureMechanismSectionCollection serializableCollection,
             ExportableAggregatedFailureMechanismSectionAssemblyResultBase failureMechanismSectionAssemblyResult)
         {
@@ -67,7 +102,19 @@
                 return AggregatedSerializableFailureMechanismSectionAssemblyCreator.Create(idGenerator, serializableCollection, serializableFailureMechanism, resultWithProbability);
             }
 
-            throw new NotSupportedException();
+            var resultWithoutProbability = failureMechanismSectionAssemblyResult as ExportableAggregatedFailureMechanismSectionAssemblyResult;
+            if (resultWithoutProbability != null)
+            {
+                return AggregatedSerializableFailureMechanismSectionAssemblyCreator.Create(idGenerator, serializableCollection, serializableFailureMechanism, resultWithoutProbability);
+            }
+
+            var resultWithoutDetailedAssembly = failureMechanismSectionAssemblyResult as ExportableAggregatedFailureMechanismSectionAssemblyResultWithoutDetailedAssembly;
+            if (resultWithoutDetailedAssembly != null)
+            {
+                return AggregatedSerializableFailureMechanismSectionAssemblyCreator.Create(idGenerator, serializableCollection, serializableFailureMechanism, resultWithoutDetailedAssembly);
+            }
+
+            throw new NotSupportedException($"{failureMechanismSectionAssemblyResult.GetType().Name} is not supported.");
         }
     }
 }
\ No newline at end of file
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Creators/AggregatedSerializableFailureMechanismCreatorTest.cs
===================================================================
diff -u -r1fb8afd636f36c169e0e4ac3fa87472f372eb915 -ra4e95638762a7a1af29dd63dec477120c4faf249
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Creators/AggregatedSerializableFailureMechanismCreatorTest.cs	(.../AggregatedSerializableFailureMechanismCreatorTest.cs)	(revision 1fb8afd636f36c169e0e4ac3fa87472f372eb915)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Creators/AggregatedSerializableFailureMechanismCreatorTest.cs	(.../AggregatedSerializableFailureMechanismCreatorTest.cs)	(revision a4e95638762a7a1af29dd63dec477120c4faf249)
@@ -40,25 +40,101 @@
     public class AggregatedSerializableFailureMechanismCreatorTest
     {
         [Test]
-        public void CreateFailureMechanismWithProbabilityAndSectionAssemblyResultsWithProbability_WithValidArguments_ReturnsAggregatedSerializableFailureMechanism()
+        public void CreateFailureMechanismWithProbability_IdGeneratorNull_ThrowsArgumentNullException()
         {
             // Setup
             var random = new Random(21);
-            ExportableFailureMechanismSection[] failureMechanismSections =
-            {
-                CreateSection(21),
-                CreateSection(22)
-            };
-            ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability[] failureMechanismSectionResults =
-            {
-                CreateSectionResultWithProbability(failureMechanismSections[0]),
-                CreateSectionResultWithProbability(failureMechanismSections[1])
-            };
 
+            // Call
+            TestDelegate call = () => AggregatedSerializableFailureMechanismCreator.Create(null,
+                                                                                           new SerializableTotalAssemblyResult(),
+                                                                                           new ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>(
+                                                                                               ExportableFailureMechanismAssemblyResultTestFactory.CreateResultWithProbability(),
+                                                                                               Enumerable.Empty<ExportableFailureMechanismSection>(),
+                                                                                               Enumerable.Empty<ExportableAggregatedFailureMechanismSectionAssemblyResultBase>(),
+                                                                                               random.NextEnumValue<ExportableFailureMechanismType>(),
+                                                                                               random.NextEnumValue<ExportableFailureMechanismGroup>()));
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("idGenerator", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateFailureMechanismWithProbability_TotalAssemblyResultNull_ThrowsArgumentNullException()
+        {
+            // Setup
+            var random = new Random(21);
+
+            // Call
+            TestDelegate call = () => AggregatedSerializableFailureMechanismCreator.Create(new UniqueIdentifierGenerator(),
+                                                                                           null,
+                                                                                           new ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>(
+                                                                                               ExportableFailureMechanismAssemblyResultTestFactory.CreateResultWithProbability(),
+                                                                                               Enumerable.Empty<ExportableFailureMechanismSection>(),
+                                                                                               Enumerable.Empty<ExportableAggregatedFailureMechanismSectionAssemblyResultBase>(),
+                                                                                               random.NextEnumValue<ExportableFailureMechanismType>(),
+                                                                                               random.NextEnumValue<ExportableFailureMechanismGroup>()));
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("serializableTotalAssemblyResult", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateFailureMechanismWithProbability_FailureMechanismNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => AggregatedSerializableFailureMechanismCreator.Create(new UniqueIdentifierGenerator(),
+                                                                                           new SerializableTotalAssemblyResult(),
+                                                                                           null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("failureMechanism", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateFailureMechanismWithProbability_WithUnsupportedAggregatedSectionResult_ThrowsNotSupportedException()
+        {
+            // Setup
+            var random = new Random(21);
+            ExportableFailureMechanismSection section = ExportableFailureMechanismSectionTestFactory.CreateExportableFailureMechanismSection();
+
             var failureMechanism = new ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>(
                 ExportableFailureMechanismAssemblyResultTestFactory.CreateResultWithProbability(),
+                Enumerable.Empty<ExportableFailureMechanismSection>(),
+                new[]
+                {
+                    new UnsupportedExportableAggregatedFailureMechanismSectionAssemblyResult(section)
+                },
+                random.NextEnumValue<ExportableFailureMechanismType>(),
+                random.NextEnumValue<ExportableFailureMechanismGroup>());
+
+            // Call
+            TestDelegate call = () => AggregatedSerializableFailureMechanismCreator.Create(new UniqueIdentifierGenerator(),
+                                                                                           new SerializableTotalAssemblyResult(),
+                                                                                           failureMechanism);
+
+            // Assert
+            var exception = Assert.Throws<NotSupportedException>(call);
+            Assert.AreEqual($"{nameof(UnsupportedExportableAggregatedFailureMechanismSectionAssemblyResult)} is not supported.",
+                            exception.Message);
+        }
+
+        [Test]
+        [TestCaseSource(nameof(GetSectionAssemblyConfigurations))]
+        public void CreateFailureMechanismWithProbabilityAndSectionAssemblyResultsWithProbability_WithValidArguments_ReturnsAggregatedSerializableFailureMechanism(
+            IEnumerable<ExportableFailureMechanismSection> failureMechanismSections,
+            IEnumerable<ExportableAggregatedFailureMechanismSectionAssemblyResultBase> failureMechanismSectionAssemblyResults,
+            Action<ExportableAggregatedFailureMechanismSectionAssemblyResultBase, SerializableFailureMechanismSectionAssembly> assertSectionAssemblyResultsAction)
+        {
+            // Setup
+            var random = new Random(21);
+            var failureMechanism = new ExportableFailureMechanism<ExportableFailureMechanismAssemblyResultWithProbability>(
+                ExportableFailureMechanismAssemblyResultTestFactory.CreateResultWithProbability(),
                 failureMechanismSections,
-                failureMechanismSectionResults,
+                failureMechanismSectionAssemblyResults,
                 random.NextEnumValue<ExportableFailureMechanismType>(),
                 random.NextEnumValue<ExportableFailureMechanismGroup>());
 
@@ -88,22 +164,23 @@
             Assert.AreEqual("Vi.1", serializableFailureMechanismSectionCollection.Id);
             Assert.AreEqual(serializableFailureMechanism.Id, serializableFailureMechanismSectionCollection.FailureMechanismId);
 
-            AssertFailureMechanismSections(2,
-                                           failureMechanism,
-                                           serializableFailureMechanismSectionCollection,
-                                           serializableFailureMechanism,
-                                           aggregatedFailureMechanism.FailureMechanismSections,
-                                           aggregatedFailureMechanism.FailureMechanismSectionAssemblyResults,
-                                           AssertSectionAssemblyResultsWithProbability);
+            AssertFailureMechanismSectionAssemblies(2,
+                                                    failureMechanism,
+                                                    serializableFailureMechanismSectionCollection,
+                                                    serializableFailureMechanism,
+                                                    aggregatedFailureMechanism.FailureMechanismSections,
+                                                    aggregatedFailureMechanism.FailureMechanismSectionAssemblyResults,
+                                                    assertSectionAssemblyResultsAction);
         }
 
-        private static void AssertFailureMechanismSections<T>(int idStartIndex,
-                                                              ExportableFailureMechanism<T> expectedFailureMechanism,
-                                                              SerializableFailureMechanismSectionCollection expectedSerializableFailureMechanismSectionCollection,
-                                                              SerializableFailureMechanism expectedSerializableFailureMechanism,
-                                                              IEnumerable<SerializableFailureMechanismSection> serializableFailureMechanismSections,
-                                                              IEnumerable<SerializableFailureMechanismSectionAssembly> serializableFailureMechanismSectionAssemblies,
-                                                              Action<ExportableAggregatedFailureMechanismSectionAssemblyResultBase, SerializableFailureMechanismSectionAssembly> assertSectionAssemblyResultAction)
+        private static void AssertFailureMechanismSectionAssemblies<T>(
+            int idStartIndex,
+            ExportableFailureMechanism<T> expectedFailureMechanism,
+            SerializableFailureMechanismSectionCollection expectedSerializableFailureMechanismSectionCollection,
+            SerializableFailureMechanism expectedSerializableFailureMechanism,
+            IEnumerable<SerializableFailureMechanismSection> serializableFailureMechanismSections,
+            IEnumerable<SerializableFailureMechanismSectionAssembly> serializableFailureMechanismSectionAssemblies,
+            Action<ExportableAggregatedFailureMechanismSectionAssemblyResultBase, SerializableFailureMechanismSectionAssembly> assertSectionAssemblyResultAction)
             where T : ExportableFailureMechanismAssemblyResult
         {
             IEnumerable<ExportableFailureMechanismSection> expectedSections = expectedFailureMechanism.Sections;
@@ -154,6 +231,120 @@
                                  actualSectionAssemblyResult.CombinedSectionResult);
         }
 
+        private static void AssertSectionAssemblyResultsWithoutProbability(ExportableAggregatedFailureMechanismSectionAssemblyResultBase expectedSectionAssemblyResult,
+                                                                           SerializableFailureMechanismSectionAssembly actualSectionAssemblyResult)
+        {
+            var expectedSectionAssemblyResultWithoutProbability = (ExportableAggregatedFailureMechanismSectionAssemblyResult) expectedSectionAssemblyResult;
+
+            SerializableFailureMechanismSectionAssemblyResult[] serializedSectionResults = actualSectionAssemblyResult.SectionResults;
+            Assert.AreEqual(3, serializedSectionResults.Length);
+            AssertAssemblyResult(expectedSectionAssemblyResultWithoutProbability.SimpleAssembly,
+                                 SerializableAssessmentType.SimpleAssessment,
+                                 serializedSectionResults[0]);
+            AssertAssemblyResult(expectedSectionAssemblyResultWithoutProbability.DetailedAssembly,
+                                 SerializableAssessmentType.DetailedAssessment,
+                                 serializedSectionResults[1]);
+            AssertAssemblyResult(expectedSectionAssemblyResultWithoutProbability.TailorMadeAssembly,
+                                 SerializableAssessmentType.TailorMadeAssessment,
+                                 serializedSectionResults[2]);
+            AssertAssemblyResult(expectedSectionAssemblyResultWithoutProbability.CombinedAssembly,
+                                 SerializableAssessmentType.CombinedAssessment,
+                                 actualSectionAssemblyResult.CombinedSectionResult);
+        }
+
+        private static void AssertSectionAssemblyResultsWithoutDetailedAssembly(ExportableAggregatedFailureMechanismSectionAssemblyResultBase expectedSectionAssemblyResult,
+                                                                                SerializableFailureMechanismSectionAssembly actualSectionAssemblyResult)
+        {
+            var expectedSectionAssemblyResultWithoutProbability = (ExportableAggregatedFailureMechanismSectionAssemblyResultWithoutDetailedAssembly) expectedSectionAssemblyResult;
+
+            SerializableFailureMechanismSectionAssemblyResult[] serializedSectionResults = actualSectionAssemblyResult.SectionResults;
+            Assert.AreEqual(2, serializedSectionResults.Length);
+            AssertAssemblyResult(expectedSectionAssemblyResultWithoutProbability.SimpleAssembly,
+                                 SerializableAssessmentType.SimpleAssessment,
+                                 serializedSectionResults[0]);
+            AssertAssemblyResult(expectedSectionAssemblyResultWithoutProbability.TailorMadeAssembly,
+                                 SerializableAssessmentType.TailorMadeAssessment,
+                                 serializedSectionResults[1]);
+            AssertAssemblyResult(expectedSectionAssemblyResultWithoutProbability.CombinedAssembly,
+                                 SerializableAssessmentType.CombinedAssessment,
+                                 actualSectionAssemblyResult.CombinedSectionResult);
+        }
+
+        private static void AssertAssemblyResult(ExportableSectionAssemblyResult expectedResult,
+                                                 SerializableAssessmentType expectedAssessmentType,
+                                                 SerializableFailureMechanismSectionAssemblyResult actualResult)
+        {
+            Assert.AreEqual(SerializableFailureMechanismSectionCategoryGroupCreator.Create(expectedResult.AssemblyCategory),
+                            actualResult.CategoryGroup);
+            Assert.AreEqual(SerializableAssemblyMethodCreator.Create(expectedResult.AssemblyMethod),
+                            actualResult.AssemblyMethod);
+            Assert.AreEqual(expectedAssessmentType, actualResult.AssessmentType);
+            Assert.IsNull(actualResult.Probability);
+        }
+
+        private static void AssertAssemblyResult(ExportableSectionAssemblyResultWithProbability expectedResult,
+                                                 SerializableAssessmentType expectedAssessmentType,
+                                                 SerializableFailureMechanismSectionAssemblyResult actualResult)
+        {
+            Assert.AreEqual(SerializableFailureMechanismSectionCategoryGroupCreator.Create(expectedResult.AssemblyCategory),
+                            actualResult.CategoryGroup);
+            Assert.AreEqual(SerializableAssemblyMethodCreator.Create(expectedResult.AssemblyMethod),
+                            actualResult.AssemblyMethod);
+            Assert.AreEqual(expectedAssessmentType, actualResult.AssessmentType);
+            Assert.AreEqual(expectedResult.Probability, actualResult.Probability);
+        }
+
+        private static SerializableTotalAssemblyResult CreateSerializableTotalAssembly(string totalAssemblyId)
+        {
+            return new SerializableTotalAssemblyResult(totalAssemblyId,
+                                                       new SerializableAssessmentProcess(),
+                                                       new SerializableFailureMechanismAssemblyResult(),
+                                                       new SerializableFailureMechanismAssemblyResult(),
+                                                       new SerializableAssessmentSectionAssemblyResult());
+        }
+
+        private static IEnumerable<TestCaseData> GetSectionAssemblyConfigurations()
+        {
+            ExportableFailureMechanismSection[] failureMechanismSections =
+            {
+                CreateSection(21),
+                CreateSection(22)
+            };
+
+            ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbability[] failureMechanismSectionResultsWithProbability =
+            {
+                CreateSectionResultWithProbability(failureMechanismSections[0]),
+                CreateSectionResultWithProbability(failureMechanismSections[1])
+            };
+            yield return new TestCaseData(failureMechanismSections,
+                                          failureMechanismSectionResultsWithProbability,
+                                          new Action<ExportableAggregatedFailureMechanismSectionAssemblyResultBase,
+                                              SerializableFailureMechanismSectionAssembly>(AssertSectionAssemblyResultsWithProbability))
+                .SetName("SectionAssemblyResults with probability");
+
+            ExportableAggregatedFailureMechanismSectionAssemblyResult[] failureMechanismSectionResultsWithoutProbability =
+            {
+                CreateSectionResultWithoutProbability(failureMechanismSections[0]),
+                CreateSectionResultWithoutProbability(failureMechanismSections[1])
+            };
+            yield return new TestCaseData(failureMechanismSections,
+                                          failureMechanismSectionResultsWithoutProbability,
+                                          new Action<ExportableAggregatedFailureMechanismSectionAssemblyResultBase,
+                                              SerializableFailureMechanismSectionAssembly>(AssertSectionAssemblyResultsWithoutProbability))
+                .SetName("SectionAssemblyResults without probability");
+
+            ExportableAggregatedFailureMechanismSectionAssemblyResultWithoutDetailedAssembly[] failureMechanismSectionResultsWithoutDetailedAssembly =
+            {
+                CreateSectionResultWithoutDetailedAssembly(failureMechanismSections[0]),
+                CreateSectionResultWithoutDetailedAssembly(failureMechanismSections[1])
+            };
+            yield return new TestCaseData(failureMechanismSections,
+                                          failureMechanismSectionResultsWithoutDetailedAssembly,
+                                          new Action<ExportableAggregatedFailureMechanismSectionAssemblyResultBase,
+                                              SerializableFailureMechanismSectionAssembly>(AssertSectionAssemblyResultsWithoutDetailedAssembly))
+                .SetName("SectionAssemblyResults without detailed assessment");
+        }
+
         private static ExportableFailureMechanismSection CreateSection(int seed)
         {
             var random = new Random(seed);
@@ -173,6 +364,23 @@
                                                                                                 CreateSectionAssemblyResultWithProbability(13));
         }
 
+        private static ExportableAggregatedFailureMechanismSectionAssemblyResult CreateSectionResultWithoutProbability(ExportableFailureMechanismSection section)
+        {
+            return new ExportableAggregatedFailureMechanismSectionAssemblyResult(section,
+                                                                                 CreateSectionAssemblyResult(10),
+                                                                                 CreateSectionAssemblyResult(11),
+                                                                                 CreateSectionAssemblyResult(12),
+                                                                                 CreateSectionAssemblyResult(13));
+        }
+
+        private static ExportableAggregatedFailureMechanismSectionAssemblyResultWithoutDetailedAssembly CreateSectionResultWithoutDetailedAssembly(ExportableFailureMechanismSection section)
+        {
+            return new ExportableAggregatedFailureMechanismSectionAssemblyResultWithoutDetailedAssembly(section,
+                                                                                                        CreateSectionAssemblyResult(10),
+                                                                                                        CreateSectionAssemblyResult(11),
+                                                                                                        CreateSectionAssemblyResult(12));
+        }
+
         private static ExportableSectionAssemblyResult CreateSectionAssemblyResult(int seed)
         {
             var random = new Random(seed);
@@ -200,37 +408,9 @@
                                                                       random.NextDouble());
         }
 
-        private static SerializableTotalAssemblyResult CreateSerializableTotalAssembly(string totalAssemblyId)
+        private class UnsupportedExportableAggregatedFailureMechanismSectionAssemblyResult : ExportableAggregatedFailureMechanismSectionAssemblyResultBase
         {
-            return new SerializableTotalAssemblyResult(totalAssemblyId,
-                                                       new SerializableAssessmentProcess(),
-                                                       new SerializableFailureMechanismAssemblyResult(),
-                                                       new SerializableFailureMechanismAssemblyResult(),
-                                                       new SerializableAssessmentSectionAssemblyResult());
+            public UnsupportedExportableAggregatedFailureMechanismSectionAssemblyResult(ExportableFailureMechanismSection failureMechanismSection) : base(failureMechanismSection) {}
         }
-
-        private static void AssertAssemblyResult(ExportableSectionAssemblyResult expectedResult,
-                                                 SerializableAssessmentType expectedAssessmentType,
-                                                 SerializableFailureMechanismSectionAssemblyResult actualResult)
-        {
-            Assert.AreEqual(SerializableFailureMechanismSectionCategoryGroupCreator.Create(expectedResult.AssemblyCategory),
-                            actualResult.CategoryGroup);
-            Assert.AreEqual(SerializableAssemblyMethodCreator.Create(expectedResult.AssemblyMethod),
-                            actualResult.AssemblyMethod);
-            Assert.AreEqual(expectedAssessmentType, actualResult.AssessmentType);
-            Assert.IsNull(actualResult.Probability);
-        }
-
-        private static void AssertAssemblyResult(ExportableSectionAssemblyResultWithProbability expectedResult,
-                                                 SerializableAssessmentType expectedAssessmentType,
-                                                 SerializableFailureMechanismSectionAssemblyResult actualResult)
-        {
-            Assert.AreEqual(SerializableFailureMechanismSectionCategoryGroupCreator.Create(expectedResult.AssemblyCategory),
-                            actualResult.CategoryGroup);
-            Assert.AreEqual(SerializableAssemblyMethodCreator.Create(expectedResult.AssemblyMethod),
-                            actualResult.AssemblyMethod);
-            Assert.AreEqual(expectedAssessmentType, actualResult.AssessmentType);
-            Assert.AreEqual(expectedResult.Probability, actualResult.Probability);
-        }
     }
 }
\ No newline at end of file