Index: Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableFailureMechanismFactory.cs
===================================================================
diff -u -r838241db2e78d6f4dc62648bca2fc58aec061365 -r7b3aff14823c770cf5801b80f00f19892e40cfbe
--- Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableFailureMechanismFactory.cs	(.../ExportableFailureMechanismFactory.cs)	(revision 838241db2e78d6f4dc62648bca2fc58aec061365)
+++ Riskeer/Integration/src/Riskeer.Integration.IO/Factories/ExportableFailureMechanismFactory.cs	(.../ExportableFailureMechanismFactory.cs)	(revision 7b3aff14823c770cf5801b80f00f19892e40cfbe)
@@ -26,6 +26,7 @@
 using Riskeer.Common.Data.AssessmentSection;
 using Riskeer.Common.Data.Exceptions;
 using Riskeer.Common.Data.FailureMechanism;
+using Riskeer.Integration.IO.Exceptions;
 using Riskeer.Integration.IO.Helpers;
 using Riskeer.Integration.IO.Properties;
 
@@ -54,6 +55,8 @@
         /// <returns>An <see cref="ExportableFailureMechanism"/> with assembly results.</returns>
         /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
         /// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
+        /// <exception cref="AssemblyFactoryException">Thrown when <paramref name="assembleFailureMechanismSectionFunc"/>
+        /// returns an invalid result that cannot be exported.</exception>
         public static ExportableGenericFailureMechanism CreateExportableGenericFailureMechanism<TFailureMechanism, TSectionResult>(
             IdentifierGenerator idGenerator, ExportableFailureMechanismSectionRegistry registry, TFailureMechanism failureMechanism, IAssessmentSection assessmentSection,
             Func<TFailureMechanism, IAssessmentSection, FailureMechanismAssemblyResultWrapper> assembleFailureMechanismFunc,
@@ -96,8 +99,8 @@
                                                          new ExportableFailureMechanismAssemblyResult(
                                                              assemblyResultWrapper.AssemblyResult,
                                                              ExportableAssemblyMethodFactory.Create(assemblyResultWrapper.AssemblyMethod)),
-                                                         CreateExportableFailureMechanismSectionResults(idGenerator, registry,
-                                                                                                        failureMechanism, assessmentSection, assembleFailureMechanismSectionFunc),
+                                                         CreateExportableFailureMechanismSectionResults(
+                                                             idGenerator, registry, failureMechanism, assessmentSection, assembleFailureMechanismSectionFunc),
                                                          failureMechanism.Code);
         }
 
@@ -116,6 +119,8 @@
         /// <returns>An <see cref="ExportableFailureMechanism"/> with assembly results.</returns>
         /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
         /// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
+        /// <exception cref="AssemblyFactoryException">Thrown when <paramref name="assembleFailureMechanismSectionFunc"/>
+        /// returns an invalid result that cannot be exported.</exception>
         public static ExportableSpecificFailureMechanism CreateExportableSpecificFailureMechanism(
             IdentifierGenerator idGenerator, ExportableFailureMechanismSectionRegistry registry, SpecificFailureMechanism failureMechanism, IAssessmentSection assessmentSection,
             Func<SpecificFailureMechanism, IAssessmentSection, FailureMechanismAssemblyResultWrapper> assembleFailureMechanismFunc,
@@ -156,8 +161,8 @@
                                                           new ExportableFailureMechanismAssemblyResult(
                                                               assemblyResultWrapper.AssemblyResult,
                                                               ExportableAssemblyMethodFactory.Create(assemblyResultWrapper.AssemblyMethod)),
-                                                          CreateExportableFailureMechanismSectionResults(idGenerator, registry, failureMechanism,
-                                                                                                         assessmentSection, assembleFailureMechanismSectionFunc),
+                                                          CreateExportableFailureMechanismSectionResults(
+                                                              idGenerator, registry, failureMechanism, assessmentSection, assembleFailureMechanismSectionFunc),
                                                           failureMechanism.Name);
         }
 
@@ -176,8 +181,9 @@
         /// <typeparam name="TSectionResult">The type of the section result.</typeparam>
         /// <returns>A collection of <see cref="ExportableFailureMechanismSectionAssemblyResult"/>.</returns>
         /// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
-        private static IEnumerable<ExportableFailureMechanismSectionAssemblyResult> CreateExportableFailureMechanismSectionResults
-            <TFailureMechanism, TSectionResult>(
+        /// <exception cref="AssemblyFactoryException">Thrown when <paramref name="assembleFailureMechanismSectionFunc"/>
+        /// returns an invalid result that cannot be exported.</exception>
+        private static IEnumerable<ExportableFailureMechanismSectionAssemblyResult> CreateExportableFailureMechanismSectionResults<TFailureMechanism, TSectionResult>(
                 IdentifierGenerator idGenerator, ExportableFailureMechanismSectionRegistry registry, TFailureMechanism failureMechanism, IAssessmentSection assessmentSection,
                 Func<TSectionResult, TFailureMechanism, IAssessmentSection, FailureMechanismSectionAssemblyResultWrapper> assembleFailureMechanismSectionFunc)
             where TFailureMechanism : IFailureMechanism<TSectionResult>
@@ -190,9 +196,16 @@
                     sectionResult, failureMechanism, assessmentSection);
                 FailureMechanismSectionAssemblyResult assemblyResult = assemblyResultWrapper.AssemblyResult;
 
+                if (assemblyResult.FailureMechanismSectionAssemblyGroup == FailureMechanismSectionAssemblyGroup.NoResult
+                    || assemblyResult.FailureMechanismSectionAssemblyGroup == FailureMechanismSectionAssemblyGroup.Dominant)
+                {
+                    throw new AssemblyFactoryException("The assembly result is invalid and cannot be created.");
+                }
+
                 exportableResults.Add(
                     new ExportableFailureMechanismSectionAssemblyResult(
-                        idGenerator.GetNewId(Resources.ExportableFailureMechanismSectionAssemblyResult_IdPrefix), registry.Get(sectionResult.Section),
+                        idGenerator.GetNewId(Resources.ExportableFailureMechanismSectionAssemblyResult_IdPrefix),
+                        registry.Get(sectionResult.Section),
                         assemblyResult.SectionProbability, assemblyResult.FailureMechanismSectionAssemblyGroup,
                         ExportableAssemblyMethodFactory.Create(assemblyResultWrapper.AssemblyGroupMethod),
                         ExportableAssemblyMethodFactory.Create(assemblyResultWrapper.ProbabilityMethod)));
Index: Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableFailureMechanismFactoryTest.cs
===================================================================
diff -u -r838241db2e78d6f4dc62648bca2fc58aec061365 -r7b3aff14823c770cf5801b80f00f19892e40cfbe
--- Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableFailureMechanismFactoryTest.cs	(.../ExportableFailureMechanismFactoryTest.cs)	(revision 838241db2e78d6f4dc62648bca2fc58aec061365)
+++ Riskeer/Integration/test/Riskeer.Integration.IO.Test/Factories/ExportableFailureMechanismFactoryTest.cs	(.../ExportableFailureMechanismFactoryTest.cs)	(revision 7b3aff14823c770cf5801b80f00f19892e40cfbe)
@@ -32,6 +32,7 @@
 using Riskeer.Common.Data.AssessmentSection;
 using Riskeer.Common.Data.FailureMechanism;
 using Riskeer.Common.Data.TestUtil;
+using Riskeer.Integration.IO.Exceptions;
 using Riskeer.Integration.IO.Factories;
 using Riskeer.Integration.IO.Helpers;
 
@@ -143,14 +144,45 @@
         }
 
         [Test]
-        public void CreateExportableGenericFailureMechanismCreateExportableFailureMechanism_WithValidData_ReturnsExportableFailureMechanism()
+        [TestCase(FailureMechanismSectionAssemblyGroup.NoResult)]
+        [TestCase(FailureMechanismSectionAssemblyGroup.Dominant)]
+        public void CreateExportableGenericFailureMechanism_InvalidFailureMechanismSectionAssemblyResult_ThrowsAssemblyFactoryException(
+            FailureMechanismSectionAssemblyGroup assemblyGroup)
         {
             // Setup
             var random = new Random(21);
             var failureMechanism = new TestFailureMechanism();
             FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
             var assessmentSection = new AssessmentSectionStub();
 
+            var idGenerator = new IdentifierGenerator();
+
+            var registry = new ExportableFailureMechanismSectionRegistry();
+            RegisterFailureMechanismSections(registry, failureMechanism.Sections);
+
+            // Call
+            void Call() => ExportableFailureMechanismFactory.CreateExportableGenericFailureMechanism<TestFailureMechanism, TestFailureMechanismSectionResult>(
+                idGenerator, registry, failureMechanism, assessmentSection, (fm, section) => new FailureMechanismAssemblyResultWrapper(
+                    random.NextDouble(), random.NextEnumValue<AssemblyMethod>()),
+                (sr, fm, section) => new FailureMechanismSectionAssemblyResultWrapper(
+                    new FailureMechanismSectionAssemblyResult(
+                        random.NextDouble(), random.NextDouble(), random.NextDouble(), assemblyGroup),
+                    random.NextEnumValue<AssemblyMethod>(), random.NextEnumValue<AssemblyMethod>()));
+
+            // Assert
+            var exception = Assert.Throws<AssemblyFactoryException>(Call);
+            Assert.AreEqual("The assembly result is invalid and cannot be created.", exception.Message);
+        }
+
+        [Test]
+        public void CreateExportableGenericFailureMechanism_WithValidData_ReturnsExportableFailureMechanism()
+        {
+            // Setup
+            var random = new Random(21);
+            var failureMechanism = new TestFailureMechanism();
+            FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
+            var assessmentSection = new AssessmentSectionStub();
+
             double probability = random.NextDouble();
             var assemblyMethod = random.NextEnumValue<AssemblyMethod>();
             FailureMechanismSectionAssemblyResultWrapper expectedSectionOutput = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create();
@@ -285,6 +317,37 @@
         }
 
         [Test]
+        [TestCase(FailureMechanismSectionAssemblyGroup.NoResult)]
+        [TestCase(FailureMechanismSectionAssemblyGroup.Dominant)]
+        public void CreateExportableSpecificFailureMechanism_InvalidFailureMechanismSectionAssemblyResult_ThrowsAssemblyFactoryException(
+            FailureMechanismSectionAssemblyGroup assemblyGroup)
+        {
+            // Setup
+            var random = new Random(21);
+            var failureMechanism = new SpecificFailureMechanism();
+            FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
+            var assessmentSection = new AssessmentSectionStub();
+
+            var idGenerator = new IdentifierGenerator();
+
+            var registry = new ExportableFailureMechanismSectionRegistry();
+            RegisterFailureMechanismSections(registry, failureMechanism.Sections);
+
+            // Call
+            void Call() => ExportableFailureMechanismFactory.CreateExportableSpecificFailureMechanism(
+                idGenerator, registry, failureMechanism, assessmentSection, (fm, section) => new FailureMechanismAssemblyResultWrapper(
+                    random.NextDouble(), random.NextEnumValue<AssemblyMethod>()),
+                (sr, fm, section) => new FailureMechanismSectionAssemblyResultWrapper(
+                    new FailureMechanismSectionAssemblyResult(
+                        random.NextDouble(), random.NextDouble(), random.NextDouble(), assemblyGroup),
+                    random.NextEnumValue<AssemblyMethod>(), random.NextEnumValue<AssemblyMethod>()));
+
+            // Assert
+            var exception = Assert.Throws<AssemblyFactoryException>(Call);
+            Assert.AreEqual("The assembly result is invalid and cannot be created.", exception.Message);
+        }
+
+        [Test]
         public void CreateExportableSpecificFailureMechanism_WithValidData_ReturnsExportableFailureMechanism()
         {
             // Setup