Index: Ringtoets/Integration/src/Ringtoets.Integration.IO/Creators/AggregatedSerializableFailureMechanismSectionAssemblyCreator.cs
===================================================================
diff -u -r269a0fc57dea9891fa32f340098c3286395a5b08 -r10962f134fb2cef1f183d84dc99856c11531c181
--- Ringtoets/Integration/src/Ringtoets.Integration.IO/Creators/AggregatedSerializableFailureMechanismSectionAssemblyCreator.cs	(.../AggregatedSerializableFailureMechanismSectionAssemblyCreator.cs)	(revision 269a0fc57dea9891fa32f340098c3286395a5b08)
+++ Ringtoets/Integration/src/Ringtoets.Integration.IO/Creators/AggregatedSerializableFailureMechanismSectionAssemblyCreator.cs	(.../AggregatedSerializableFailureMechanismSectionAssemblyCreator.cs)	(revision 10962f134fb2cef1f183d84dc99856c11531c181)
@@ -192,6 +192,108 @@
         }
 
         /// <summary>
+        /// Creates an instance of <see cref="AggregatedSerializableFailureMechanismSectionAssembly"/>
+        /// based on its input parameters.
+        /// </summary>
+        /// <param name="idGenerator">The id generator to generate an id for <see cref="SerializableFailureMechanismSectionAssembly"/>.</param>
+        /// <param name="serializableCollection">The <see cref="SerializableFailureMechanismSectionCollection"/> the result belongs to.</param>
+        /// <param name="serializableFailureMechanism">The <see cref="SerializableFailureMechanism"/> the result belongs to.</param>
+        /// <param name="sectionResult">The <see cref="ExportableAggregatedFailureMechanismSectionAssemblyResultWithCombinedResultOnly"/> to create an
+        /// <see cref="AggregatedSerializableFailureMechanismSectionAssembly"/> for.</param>
+        /// <returns>An <see cref="AggregatedSerializableFailureMechanismSectionAssembly"/>.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
+        /// <exception cref="AssemblyCreatorException">Thrown when <paramref name="sectionResult"/> is invalid to create a serializable counterpart for.</exception>
+        public static AggregatedSerializableFailureMechanismSectionAssembly Create(IdentifierGenerator idGenerator,
+                                                                                   SerializableFailureMechanismSectionCollection serializableCollection,
+                                                                                   SerializableFailureMechanism serializableFailureMechanism,
+                                                                                   ExportableAggregatedFailureMechanismSectionAssemblyResultWithCombinedResultOnly sectionResult)
+        {
+            if (idGenerator == null)
+            {
+                throw new ArgumentNullException(nameof(idGenerator));
+            }
+
+            if (serializableCollection == null)
+            {
+                throw new ArgumentNullException(nameof(serializableCollection));
+            }
+
+            if (serializableFailureMechanism == null)
+            {
+                throw new ArgumentNullException(nameof(serializableFailureMechanism));
+            }
+
+            if (sectionResult == null)
+            {
+                throw new ArgumentNullException(nameof(sectionResult));
+            }
+
+            SerializableFailureMechanismSection failureMechanismSection = SerializableFailureMechanismSectionCreator.Create(idGenerator,
+                                                                                                                            serializableCollection,
+                                                                                                                            sectionResult.FailureMechanismSection);
+
+            var failureMechanismSectionAssembly = new SerializableFailureMechanismSectionAssembly(idGenerator.GetNewId(Resources.SerializableFailureMechanismSectionAssembly_IdPrefix),
+                                                                                                  serializableFailureMechanism,
+                                                                                                  failureMechanismSection,
+                                                                                                  new SerializableFailureMechanismSectionAssemblyResult[0],
+                                                                                                  SerializableFailureMechanismSectionAssemblyResultCreator.Create(SerializableAssessmentType.CombinedAssessment,
+                                                                                                                                                                  sectionResult.CombinedAssembly));
+            return new AggregatedSerializableFailureMechanismSectionAssembly(failureMechanismSection,
+                                                                             failureMechanismSectionAssembly);
+        }
+
+        /// <summary>
+        /// Creates an instance of <see cref="AggregatedSerializableFailureMechanismSectionAssembly"/>
+        /// based on its input parameters.
+        /// </summary>
+        /// <param name="idGenerator">The id generator to generate an id for <see cref="SerializableFailureMechanismSectionAssembly"/>.</param>
+        /// <param name="serializableCollection">The <see cref="SerializableFailureMechanismSectionCollection"/> the result belongs to.</param>
+        /// <param name="serializableFailureMechanism">The <see cref="SerializableFailureMechanism"/> the result belongs to.</param>
+        /// <param name="sectionResult">The <see cref="ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbabilityAndCombinedResultOnly"/> to create an
+        /// <see cref="AggregatedSerializableFailureMechanismSectionAssembly"/> for.</param>
+        /// <returns>An <see cref="AggregatedSerializableFailureMechanismSectionAssembly"/>.</returns>
+        /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
+        /// <exception cref="AssemblyCreatorException">Thrown when <paramref name="sectionResult"/> is invalid to create a serializable counterpart for.</exception>
+        public static AggregatedSerializableFailureMechanismSectionAssembly Create(IdentifierGenerator idGenerator,
+                                                                                   SerializableFailureMechanismSectionCollection serializableCollection,
+                                                                                   SerializableFailureMechanism serializableFailureMechanism,
+                                                                                   ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbabilityAndCombinedResultOnly sectionResult)
+        {
+            if (idGenerator == null)
+            {
+                throw new ArgumentNullException(nameof(idGenerator));
+            }
+
+            if (serializableCollection == null)
+            {
+                throw new ArgumentNullException(nameof(serializableCollection));
+            }
+
+            if (serializableFailureMechanism == null)
+            {
+                throw new ArgumentNullException(nameof(serializableFailureMechanism));
+            }
+
+            if (sectionResult == null)
+            {
+                throw new ArgumentNullException(nameof(sectionResult));
+            }
+
+            SerializableFailureMechanismSection failureMechanismSection = SerializableFailureMechanismSectionCreator.Create(idGenerator,
+                                                                                                                            serializableCollection,
+                                                                                                                            sectionResult.FailureMechanismSection);
+
+            var failureMechanismSectionAssembly = new SerializableFailureMechanismSectionAssembly(idGenerator.GetNewId(Resources.SerializableFailureMechanismSectionAssembly_IdPrefix),
+                                                                                                  serializableFailureMechanism,
+                                                                                                  failureMechanismSection,
+                                                                                                  new SerializableFailureMechanismSectionAssemblyResult[0],
+                                                                                                  SerializableFailureMechanismSectionAssemblyResultCreator.Create(SerializableAssessmentType.CombinedAssessment,
+                                                                                                                                                                  sectionResult.CombinedAssembly));
+            return new AggregatedSerializableFailureMechanismSectionAssembly(failureMechanismSection,
+                                                                             failureMechanismSectionAssembly);
+        }
+
+        /// <summary>
         /// Creates a collection of whether an <see cref="SerializableFailureMechanismSectionAssemblyResult"/> based on <paramref name="sectionResult"/>.
         /// </summary>
         /// <param name="sectionResult">The <see cref="ExportableAggregatedFailureMechanismSectionAssemblyResult"/> to create a collection of
Index: Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Creators/AggregatedSerializableFailureMechanismSectionAssemblyCreatorTest.cs
===================================================================
diff -u -r269a0fc57dea9891fa32f340098c3286395a5b08 -r10962f134fb2cef1f183d84dc99856c11531c181
--- Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Creators/AggregatedSerializableFailureMechanismSectionAssemblyCreatorTest.cs	(.../AggregatedSerializableFailureMechanismSectionAssemblyCreatorTest.cs)	(revision 269a0fc57dea9891fa32f340098c3286395a5b08)
+++ Ringtoets/Integration/test/Ringtoets.Integration.IO.Test/Creators/AggregatedSerializableFailureMechanismSectionAssemblyCreatorTest.cs	(.../AggregatedSerializableFailureMechanismSectionAssemblyCreatorTest.cs)	(revision 10962f134fb2cef1f183d84dc99856c11531c181)
@@ -610,6 +610,205 @@
                                                                                         aggregatedSectionAssembly.FailureMechanismSection);
         }
 
+        [Test]
+        public void CreateWithCombinedResultOnly_IdGeneratorNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => AggregatedSerializableFailureMechanismSectionAssemblyCreator.Create(null,
+                                                                                                          new SerializableFailureMechanismSectionCollection(),
+                                                                                                          new SerializableFailureMechanism(),
+                                                                                                          new ExportableAggregatedFailureMechanismSectionAssemblyResultWithCombinedResultOnly(
+                                                                                                              ExportableFailureMechanismSectionTestFactory.CreateExportableFailureMechanismSection(),
+                                                                                                              CreateSectionAssemblyResult(10)));
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("idGenerator", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateWithCombinedResultOnly_SerializableFailureMechanismSectionCollectionNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => AggregatedSerializableFailureMechanismSectionAssemblyCreator.Create(new IdentifierGenerator(),
+                                                                                                          null,
+                                                                                                          new SerializableFailureMechanism(),
+                                                                                                          new ExportableAggregatedFailureMechanismSectionAssemblyResultWithCombinedResultOnly(
+                                                                                                              ExportableFailureMechanismSectionTestFactory.CreateExportableFailureMechanismSection(),
+                                                                                                              CreateSectionAssemblyResult(10)));
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("serializableCollection", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateWithCombinedResultOnly_SerializableFailureMechanismNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => AggregatedSerializableFailureMechanismSectionAssemblyCreator.Create(new IdentifierGenerator(),
+                                                                                                          new SerializableFailureMechanismSectionCollection(),
+                                                                                                          null,
+                                                                                                          new ExportableAggregatedFailureMechanismSectionAssemblyResultWithCombinedResultOnly(
+                                                                                                              ExportableFailureMechanismSectionTestFactory.CreateExportableFailureMechanismSection(),
+                                                                                                              CreateSectionAssemblyResult(10)));
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("serializableFailureMechanism", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateWithCombinedResultOnly_SectionResultNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => AggregatedSerializableFailureMechanismSectionAssemblyCreator.Create(new IdentifierGenerator(),
+                                                                                                          new SerializableFailureMechanismSectionCollection(),
+                                                                                                          new SerializableFailureMechanism(),
+                                                                                                          (ExportableAggregatedFailureMechanismSectionAssemblyResultWithCombinedResultOnly) null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("sectionResult", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateWithCombinedResultOnly_WithValidArgumentsAndAllAssemblyTypesHaveResults_ReturnsAggregatedSerializableFailureMechanismSectionAssembly()
+        {
+            // Setup
+            var idGenerator = new IdentifierGenerator();
+            var sectionResult = new ExportableAggregatedFailureMechanismSectionAssemblyResultWithCombinedResultOnly(
+                ExportableFailureMechanismSectionTestFactory.CreateExportableFailureMechanismSection(),
+                CreateSectionAssemblyResult(10));
+
+            var random = new Random(21);
+            const string serializableFailureMechanismId = "FailureMechanismId";
+            var serializableFailureMechanism = new SerializableFailureMechanism(serializableFailureMechanismId,
+                                                                                new SerializableTotalAssemblyResult(),
+                                                                                random.NextEnumValue<SerializableFailureMechanismType>(),
+                                                                                random.NextEnumValue<SerializableFailureMechanismGroup>(),
+                                                                                new SerializableFailureMechanismAssemblyResult());
+
+            const string serializableSectionCollectionId = "CollectionId";
+            var serializableCollection = new SerializableFailureMechanismSectionCollection(serializableSectionCollectionId);
+
+            // Call
+            AggregatedSerializableFailureMechanismSectionAssembly aggregatedSectionAssembly =
+                AggregatedSerializableFailureMechanismSectionAssemblyCreator.Create(idGenerator, serializableCollection, serializableFailureMechanism, sectionResult);
+
+            // Assert
+            SerializableFailureMechanismSectionAssembly failureMechanismSectionAssembly = aggregatedSectionAssembly.FailureMechanismSectionAssembly;
+            Assert.AreEqual("T.0", failureMechanismSectionAssembly.Id);
+            Assert.AreEqual(serializableFailureMechanism.Id, failureMechanismSectionAssembly.FailureMechanismId);
+
+            CollectionAssert.IsEmpty(failureMechanismSectionAssembly.SectionResults);
+            SerializableFailureMechanismSectionTestHelper.AssertFailureMechanismSection(sectionResult.FailureMechanismSection,
+                                                                                        serializableCollection,
+                                                                                        aggregatedSectionAssembly.FailureMechanismSection);
+        }
+
+        [Test]
+        public void CreateWithProbabilityAndCombinedResultOnly_IdGeneratorNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => AggregatedSerializableFailureMechanismSectionAssemblyCreator.Create(null,
+                                                                                                          new SerializableFailureMechanismSectionCollection(),
+                                                                                                          new SerializableFailureMechanism(),
+                                                                                                          new ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbabilityAndCombinedResultOnly(
+                                                                                                              ExportableFailureMechanismSectionTestFactory.CreateExportableFailureMechanismSection(),
+                                                                                                              CreateSectionAssemblyResultWithProbability(10)));
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("idGenerator", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateWithProbabilityAndCombinedResultOnly_SerializableFailureMechanismSectionCollectionNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => AggregatedSerializableFailureMechanismSectionAssemblyCreator.Create(new IdentifierGenerator(),
+                                                                                                          null,
+                                                                                                          new SerializableFailureMechanism(),
+                                                                                                          new ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbabilityAndCombinedResultOnly(
+                                                                                                              ExportableFailureMechanismSectionTestFactory.CreateExportableFailureMechanismSection(),
+                                                                                                              CreateSectionAssemblyResultWithProbability(10)));
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("serializableCollection", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateWithProbabilityAndCombinedResultOnly_SerializableFailureMechanismNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => AggregatedSerializableFailureMechanismSectionAssemblyCreator.Create(new IdentifierGenerator(),
+                                                                                                          new SerializableFailureMechanismSectionCollection(),
+                                                                                                          null,
+                                                                                                          new ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbabilityAndCombinedResultOnly(
+                                                                                                              ExportableFailureMechanismSectionTestFactory.CreateExportableFailureMechanismSection(),
+                                                                                                              CreateSectionAssemblyResultWithProbability(10)));
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("serializableFailureMechanism", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateWithProbabilityAndCombinedResultOnly_SectionResultNull_ThrowsArgumentNullException()
+        {
+            // Call
+            TestDelegate call = () => AggregatedSerializableFailureMechanismSectionAssemblyCreator.Create(new IdentifierGenerator(),
+                                                                                                          new SerializableFailureMechanismSectionCollection(),
+                                                                                                          new SerializableFailureMechanism(),
+                                                                                                          (ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbabilityAndCombinedResultOnly) null);
+
+            // Assert
+            var exception = Assert.Throws<ArgumentNullException>(call);
+            Assert.AreEqual("sectionResult", exception.ParamName);
+        }
+
+        [Test]
+        public void CreateWithProbabilityANdCombinedResultOnly_WithValidArgumentsAndAllAssemblyTypesHaveResults_ReturnsAggregatedSerializableFailureMechanismSectionAssembly()
+        {
+            // Setup
+            var idGenerator = new IdentifierGenerator();
+            var sectionResult = new ExportableAggregatedFailureMechanismSectionAssemblyResultWithProbabilityAndCombinedResultOnly(
+                ExportableFailureMechanismSectionTestFactory.CreateExportableFailureMechanismSection(),
+                CreateSectionAssemblyResultWithProbability(10));
+
+            var random = new Random(21);
+            const string serializableFailureMechanismId = "FailureMechanismId";
+            var serializableFailureMechanism = new SerializableFailureMechanism(serializableFailureMechanismId,
+                                                                                new SerializableTotalAssemblyResult(),
+                                                                                random.NextEnumValue<SerializableFailureMechanismType>(),
+                                                                                random.NextEnumValue<SerializableFailureMechanismGroup>(),
+                                                                                new SerializableFailureMechanismAssemblyResult());
+
+            const string serializableSectionCollectionId = "CollectionId";
+            var serializableCollection = new SerializableFailureMechanismSectionCollection(serializableSectionCollectionId);
+
+            // Call
+            AggregatedSerializableFailureMechanismSectionAssembly aggregatedSectionAssembly =
+                AggregatedSerializableFailureMechanismSectionAssemblyCreator.Create(idGenerator, serializableCollection, serializableFailureMechanism, sectionResult);
+
+            // Assert
+            SerializableFailureMechanismSectionAssembly failureMechanismSectionAssembly = aggregatedSectionAssembly.FailureMechanismSectionAssembly;
+            Assert.AreEqual("T.0", failureMechanismSectionAssembly.Id);
+            Assert.AreEqual(serializableFailureMechanism.Id, failureMechanismSectionAssembly.FailureMechanismId);
+
+            CollectionAssert.IsEmpty(failureMechanismSectionAssembly.SectionResults);
+
+            SerializableFailureMechanismSectionAssemblyResultTestHelper.AssertAssemblyResult(sectionResult.CombinedAssembly,
+                                                                                             SerializableAssessmentType.CombinedAssessment,
+                                                                                             failureMechanismSectionAssembly.CombinedSectionResult);
+
+            SerializableFailureMechanismSectionTestHelper.AssertFailureMechanismSection(sectionResult.FailureMechanismSection,
+                                                                                        serializableCollection,
+                                                                                        aggregatedSectionAssembly.FailureMechanismSection);
+        }
+
         private static ExportableSectionAssemblyResult CreateSectionAssemblyResult(int seed)
         {
             var random = new Random(seed);