Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Kernels/Assembly/FailureMechanismSectionAssemblyKernelStubTest.cs
===================================================================
diff -u -r7ed02cd32907187a42007f6f4fa7b35468b088ba -r63e7cce52acc9d82399af26319d4ac2d91a65511
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Kernels/Assembly/FailureMechanismSectionAssemblyKernelStubTest.cs	(.../FailureMechanismSectionAssemblyKernelStubTest.cs)	(revision 7ed02cd32907187a42007f6f4fa7b35468b088ba)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Kernels/Assembly/FailureMechanismSectionAssemblyKernelStubTest.cs	(.../FailureMechanismSectionAssemblyKernelStubTest.cs)	(revision 63e7cce52acc9d82399af26319d4ac2d91a65511)
@@ -678,157 +678,127 @@
         }
 
         [Test]
-        public void TailorMadeAssessmentDirectFailureMechanismsWithCategories_ThrowExceptionOnCalculateFalse_InputCorrectlySetToKernelAndCalculatedTrue()
+        public void TranslateAssessmentResultWbi0T4_ThrowExceptionOnCalculateFalse_InputCorrectlySetToKernelAndCalculatedTrue()
         {
             // Setup
             var random = new Random(39);
-            var result = random.NextEnumValue<TailorMadeCategoryCalculationResult>();
+            var assessment = random.NextEnumValue<EAssessmentResultTypeT3>();
+            var category = random.NextEnumValue<EFmSectionCategory>();
             var kernel = new FailureMechanismSectionAssemblyKernelStub();
 
             // Call
-            kernel.TailorMadeAssessmentDirectFailureMechanisms(result);
+            kernel.TranslateAssessmentResultWbi0T4(assessment, category);
 
             // Assert
-            Assert.AreEqual(result, kernel.TailorMadeCalculationInputFromCategoryResultInput);
+            Assert.AreEqual(assessment, kernel.AssessmentResultTypeT3Input);
+            Assert.AreEqual(category, kernel.SectionCategoryInput);
         }
 
         [Test]
-        public void TailorMadeAssessmentDirectFailureMechanismsWithCategories_ThrowExceptionOnCalculateFalse_ReturnFailureMechanismSectionAssemblyResult()
+        public void TranslateAssessmentResultWbi0T4_ThrowExceptionOnCalculateFalse_ThrowsException()
         {
             // Setup
             var random = new Random(39);
-            var kernel = new FailureMechanismSectionAssemblyKernelStub
-            {
-                ThrowExceptionOnCalculate = true
-            };
+            var assessment = random.NextEnumValue<EAssessmentResultTypeT3>();
+            var category = random.NextEnumValue<EFmSectionCategory>();
 
-            // Call
-            TestDelegate test = () => kernel.TailorMadeAssessmentDirectFailureMechanisms(random.NextEnumValue<TailorMadeCategoryCalculationResult>());
-
-            // Assert
-            var exception = Assert.Throws<Exception>(test);
-            Assert.AreEqual("Message", exception.Message);
-            Assert.IsNotNull(exception.InnerException);
-            Assert.IsNull(kernel.TailorMadeCalculationInputFromProbabilityInput);
-            Assert.IsFalse(kernel.Calculated);
-            Assert.IsNull(kernel.FailureMechanismSectionDirectResult);
-        }
-
-        [Test]
-        public void TailorMadeAssessmentDirectFailureMechanismsWithCategories_ThrowExceptionOnCalculateTrue_ThrowsException()
-        {
-            // Setup
-            var random = new Random(39);
-            var input = new TailorMadeCalculationInputFromProbability(
-                new TailorMadeProbabilityCalculationResult(new Probability(random.NextDouble())),
-                new[]
-                {
-                    new FailureMechanismSectionCategory(random.NextEnumValue<EFmSectionCategory>(),
-                                                        new Probability(random.NextRoundedDouble(0.0, 0.5)),
-                                                        new Probability(random.NextRoundedDouble(0.6, 1.0)))
-                });
-
             var kernel = new FailureMechanismSectionAssemblyKernelStub
             {
                 ThrowExceptionOnCalculate = true
             };
 
             // Call
-            TestDelegate test = () => kernel.TailorMadeAssessmentDirectFailureMechanisms(input);
+            TestDelegate test = () => kernel.TranslateAssessmentResultWbi0T4(assessment, category);
 
             // Assert
             var exception = Assert.Throws<Exception>(test);
             Assert.AreEqual("Message", exception.Message);
             Assert.IsNotNull(exception.InnerException);
-            Assert.IsNull(kernel.TailorMadeCalculationInputFromProbabilityInput);
+            Assert.IsNull(kernel.AssessmentResultTypeT3Input);
+            Assert.IsNull(kernel.SectionCategoryInput);
             Assert.IsFalse(kernel.Calculated);
             Assert.IsNull(kernel.FailureMechanismSectionDirectResult);
         }
 
         [Test]
-        public void TailorMadeAssessmentDirectFailureMechanismsWithProbabilityAndLengthEffect_ThrowExceptionOnCalculateFalse_InputCorrectlySetToKernelAndCalculatedTrue()
+        public void TranslateAssessmentResultWbi0T5_ThrowExceptionOnCalculateFalse_InputCorrectlySetToKernelAndCalculatedTrue()
         {
             // Setup
             var random = new Random(39);
-            var input = new TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
-                new TailorMadeProbabilityCalculationResult(new Probability(random.NextDouble())),
-                new[]
-                {
-                    new FailureMechanismSectionCategory(random.NextEnumValue<EFmSectionCategory>(),
-                                                        new Probability(random.NextRoundedDouble(0.0, 0.5)),
-                                                        new Probability(random.NextRoundedDouble(0.6, 1.0)))
-                },
-                random.NextDouble(1.0, 10.0));
+            var section = new AssessmentSection(random.NextDouble(), random.NextDouble(0.5, 0.9), random.NextDouble(0.0, 0.4));
+            var failureMechanism = new FailureMechanism(random.NextDouble(), random.NextDouble());
+            var assessment = random.NextEnumValue<EAssessmentResultTypeT3>();
+            double failureProbability = random.NextDouble();
+            double lengthEffect = random.NextDouble();
 
             var kernel = new FailureMechanismSectionAssemblyKernelStub();
 
             // Precondition
             Assert.IsFalse(kernel.Calculated);
 
             // Call
-            kernel.TailorMadeAssessmentDirectFailureMechanisms(input);
+            kernel.TranslateAssessmentResultWbi0T5(section, failureMechanism, lengthEffect, assessment, failureProbability);
 
             // Assert
-            Assert.AreSame(input, kernel.TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor);
+            Assert.AreSame(section, kernel.AssessmentSectionInput);
+            Assert.AreSame(failureMechanism, kernel.FailureMechanismInput);
+            Assert.AreEqual(assessment, kernel.AssessmentResultTypeT3Input);
+            Assert.AreEqual(failureProbability, kernel.FailureProbabilityInput);
+            Assert.AreEqual(lengthEffect, kernel.LengthEffectFactorInput);
             Assert.IsTrue(kernel.Calculated);
         }
 
         [Test]
-        public void TailorMadeAssessmentDirectFailureMechanismsWithProbabilityAndLengthEffect_ThrowExceptionOnCalculateFalse_ReturnFailureMechanismSectionAssemblyResult()
+        public void TranslateAssessmentResultWbi0T5_ThrowExceptionOnCalculateFalse_ReturnFailureMechanismSectionAssemblyResult()
         {
             // Setup
             var random = new Random(39);
-            var input = new TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
-                new TailorMadeProbabilityCalculationResult(new Probability(random.NextDouble())),
-                new[]
-                {
-                    new FailureMechanismSectionCategory(random.NextEnumValue<EFmSectionCategory>(),
-                                                        new Probability(random.NextRoundedDouble(0.0, 0.5)),
-                                                        new Probability(random.NextRoundedDouble(0.6, 1.0)))
-                },
-                random.NextDouble(1.0, 10.0));
+            var section = new AssessmentSection(random.NextDouble(), random.NextDouble(0.5, 0.9), random.NextDouble(0.0, 0.4));
+            var failureMechanism = new FailureMechanism(random.NextDouble(), random.NextDouble());
+            var assessment = random.NextEnumValue<EAssessmentResultTypeT3>();
+            double failureProbability = random.NextDouble();
+            double lengthEffect = random.NextDouble();
 
             var kernel = new FailureMechanismSectionAssemblyKernelStub
             {
-                FailureMechanismSectionDirectResult = new FmSectionAssemblyDirectResult(
-                    new FailureMechanismSectionAssemblyResult(EFmSectionCategory.IIIv, double.NaN))
+                FailureMechanismSectionDirectResult = new FmSectionAssemblyDirectResult(random.NextEnumValue<EFmSectionCategory>())
             };
 
             // Call
-            FmSectionAssemblyDirectResult result = kernel.TailorMadeAssessmentDirectFailureMechanisms(input);
+            FmSectionAssemblyDirectResult result = kernel.TranslateAssessmentResultWbi0T5(section, failureMechanism, lengthEffect, assessment, failureProbability);
 
             // Assert
             Assert.AreSame(kernel.FailureMechanismSectionDirectResult, result);
         }
 
         [Test]
-        public void TailorMadeAssessmentDirectFailureMechanismsWithProbabilityAndLengthEffect_ThrowExceptionOnCalculateTrue_ThrowsException()
+        public void TranslateAssessmentResultWbi0T5_ThrowExceptionOnCalculateTrue_ThrowsException()
         {
             // Setup
             var random = new Random(39);
-            var input = new TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
-                new TailorMadeProbabilityCalculationResult(new Probability(random.NextDouble())),
-                new[]
-                {
-                    new FailureMechanismSectionCategory(random.NextEnumValue<EFmSectionCategory>(),
-                                                        new Probability(random.NextRoundedDouble(0.0, 0.5)),
-                                                        new Probability(random.NextRoundedDouble(0.6, 1.0)))
-                },
-                random.NextDouble(1.0, 10.0));
+            var section = new AssessmentSection(random.NextDouble(), random.NextDouble(0.5, 0.9), random.NextDouble(0.0, 0.4));
+            var failureMechanism = new FailureMechanism(random.NextDouble(), random.NextDouble());
+            var assessment = random.NextEnumValue<EAssessmentResultTypeT3>();
+            double failureProbability = random.NextDouble();
+            double lengthEffect = random.NextDouble();
 
             var kernel = new FailureMechanismSectionAssemblyKernelStub
             {
                 ThrowExceptionOnCalculate = true
             };
 
             // Call
-            TestDelegate test = () => kernel.TailorMadeAssessmentDirectFailureMechanisms(input);
+            TestDelegate test = () => kernel.TranslateAssessmentResultWbi0T5(section, failureMechanism, lengthEffect, assessment, failureProbability);
 
             // Assert
             var exception = Assert.Throws<Exception>(test);
             Assert.AreEqual("Message", exception.Message);
             Assert.IsNotNull(exception.InnerException);
-            Assert.IsNull(kernel.TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor);
+            Assert.IsNull(kernel.AssessmentSectionInput);
+            Assert.IsNull(kernel.FailureMechanismInput);
+            Assert.IsNull(kernel.AssessmentResultTypeT3Input);
+            Assert.IsNull(kernel.FailureProbabilityInput);
+            Assert.IsNull(kernel.LengthEffectFactorInput);
             Assert.IsFalse(kernel.Calculated);
             Assert.IsNull(kernel.FailureMechanismSectionDirectResult);
         }