Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Kernels/Assessments/FailureMechanismSectionAssessmentAssemblyKernelStubTest.cs
===================================================================
diff -u -rfc7fbe9882364e7caae2093c378d3cacd8858d00 -re7a4858c35baedd9d9dbd6254687945f3f04be7a
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Kernels/Assessments/FailureMechanismSectionAssessmentAssemblyKernelStubTest.cs	(.../FailureMechanismSectionAssessmentAssemblyKernelStubTest.cs)	(revision fc7fbe9882364e7caae2093c378d3cacd8858d00)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Kernels/Assessments/FailureMechanismSectionAssessmentAssemblyKernelStubTest.cs	(.../FailureMechanismSectionAssessmentAssemblyKernelStubTest.cs)	(revision e7a4858c35baedd9d9dbd6254687945f3f04be7a)
@@ -45,6 +45,7 @@
             Assert.IsInstanceOf<IFailureMechanismSectionAssemblyCalculator>(kernel);
             Assert.IsFalse(kernel.Calculated);
             Assert.IsNull(kernel.SimpleAssessmentFailureMechanismsInput);
+            Assert.IsNull(kernel.SimpleAssessmentFailureMechanismsValidityOnlyInput);
         }
 
         [Test]
@@ -118,16 +119,73 @@
         }
 
         [Test]
-        public void SimpleAssessmentDirectFailureMechanismsValidityOnly_Always_ThrowNotImplementedException()
+        public void SimpleAssessmentDirectFailureMechanismsValidityOnly_ThrowExceptionOnCalculateFalse_InputCorrectlySetToKernel()
         {
             // Setup
+            var random = new Random(39);
+            var input = random.NextEnumValue<SimpleCalculationResultValidityOnly>();
+
             var kernel = new FailureMechanismSectionAssessmentAssemblyKernelStub();
 
             // Call
+            kernel.SimpleAssessmentDirectFailureMechanisms(input);
+
+            // Assert
+            Assert.AreEqual(input, kernel.SimpleAssessmentFailureMechanismsValidityOnlyInput);
+        }
+
+        [Test]
+        public void SimpleAssessmentDirectFailureMechanismsValidityOnly_ThrowExceptionOnCalculateFalse_SetCalculatedTrue()
+        {
+            // Setup
+            var kernel = new FailureMechanismSectionAssessmentAssemblyKernelStub();
+
+            // Precondition
+            Assert.IsFalse(kernel.Calculated);
+
+            // Call
+            kernel.SimpleAssessmentDirectFailureMechanisms((SimpleCalculationResultValidityOnly) 0);
+
+            // Assert
+            Assert.IsTrue(kernel.Calculated);
+        }
+
+        [Test]
+        public void SimpleAssessmentDirectFailureMechanismsValidityOnly_ThrowExceptionOnCalculateFalse_ReturnFailureMechanismSectionAssemblyCategoryResult()
+        {
+            // Setup
+            var kernel = new FailureMechanismSectionAssessmentAssemblyKernelStub
+            {
+                FailureMechanismSectionAssemblyCategoryResult = new CalculationOutput<FailureMechanismSectionAssemblyCategoryResult>(
+                    new FailureMechanismSectionAssemblyCategoryResult(FailureMechanismSectionCategoryGroup.IIIv, Probability.NaN))
+            };
+
+            // Call
+            CalculationOutput<FailureMechanismSectionAssemblyCategoryResult> result = kernel.SimpleAssessmentDirectFailureMechanisms((SimpleCalculationResultValidityOnly) 0);
+
+            // Assert
+            Assert.AreSame(kernel.FailureMechanismSectionAssemblyCategoryResult, result);
+        }
+
+        [Test]
+        public void SimpleAssessmentDirectFailureMechanismsValidityOnly_ThrowExceptionOnCalculateTrue_ThrowsException()
+        {
+            // Setup
+            var kernel = new FailureMechanismSectionAssessmentAssemblyKernelStub
+            {
+                ThrowExceptionOnCalculate = true
+            };
+
+            // Call
             TestDelegate test = () => kernel.SimpleAssessmentDirectFailureMechanisms((SimpleCalculationResultValidityOnly) 0);
 
             // Assert
-            Assert.Throws<NotImplementedException>(test);
+            var exception = Assert.Throws<Exception>(test);
+            Assert.AreEqual("Message", exception.Message);
+            Assert.IsNotNull(exception.InnerException);
+            Assert.IsNull(kernel.SimpleAssessmentFailureMechanismsInput);
+            Assert.IsFalse(kernel.Calculated);
+            Assert.IsNull(kernel.FailureMechanismSectionAssemblyCategoryResult);
         }
 
         [Test]
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assessments/FailureMechanismSectionAssessmentAssemblyKernelStub.cs
===================================================================
diff -u -rfc7fbe9882364e7caae2093c378d3cacd8858d00 -re7a4858c35baedd9d9dbd6254687945f3f04be7a
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assessments/FailureMechanismSectionAssessmentAssemblyKernelStub.cs	(.../FailureMechanismSectionAssessmentAssemblyKernelStub.cs)	(revision fc7fbe9882364e7caae2093c378d3cacd8858d00)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assessments/FailureMechanismSectionAssessmentAssemblyKernelStub.cs	(.../FailureMechanismSectionAssessmentAssemblyKernelStub.cs)	(revision e7a4858c35baedd9d9dbd6254687945f3f04be7a)
@@ -39,6 +39,11 @@
         public SimpleCalculationResult? SimpleAssessmentFailureMechanismsInput { get; private set; }
 
         /// <summary>
+        /// Gets the input used in <see cref="SimpleAssessmentDirectFailureMechanisms(SimpleCalculationResultValidityOnly)"/>.
+        /// </summary>
+        public SimpleCalculationResultValidityOnly? SimpleAssessmentFailureMechanismsValidityOnlyInput { get; private set; }
+
+        /// <summary>
         /// Gets a value indicating whether a calculation was called or not.
         /// </summary>
         public bool Calculated { get; private set; }
@@ -72,7 +77,14 @@
 
         public CalculationOutput<FailureMechanismSectionAssemblyCategoryResult> SimpleAssessmentDirectFailureMechanisms(SimpleCalculationResultValidityOnly result)
         {
-            throw new NotImplementedException();
+            if (ThrowExceptionOnCalculate)
+            {
+                throw new Exception("Message", new Exception());
+            }
+
+            SimpleAssessmentFailureMechanismsValidityOnlyInput = result;
+            Calculated = true;
+            return FailureMechanismSectionAssemblyCategoryResult;
         }
 
         public CalculationOutput<FailureMechanismSectionCategoryGroup> DetailedAssessmentDirectFailureMechanisms(DetailedCalculationResult result)