Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/AssessmentSectionAssemblyCalculatorTest.cs
===================================================================
diff -u -rd300264590cc3df96f6968a54ff20578a83f6419 -r7c355e20c39e28c6837702bbbf7dcfea5cae6c7b
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/AssessmentSectionAssemblyCalculatorTest.cs	(.../AssessmentSectionAssemblyCalculatorTest.cs)	(revision d300264590cc3df96f6968a54ff20578a83f6419)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/AssessmentSectionAssemblyCalculatorTest.cs	(.../AssessmentSectionAssemblyCalculatorTest.cs)	(revision 7c355e20c39e28c6837702bbbf7dcfea5cae6c7b)
@@ -157,8 +157,9 @@
 
                 // Assert
                 AssessmentSectionAssemblyResult expectedResult = kernel.AssessmentSectionAssemblyResult;
+                AssessmentSectionAssemblyCategoryGroup expectedGroup = AssemblyCategoryCreator.CreateAssessmentSectionAssemblyCategory(expectedResult.Category);
                 Assert.AreEqual(expectedResult.FailureProbability, assembly.Probability);
-                Assert.AreEqual(AssemblyCategoryCreator.CreateAssessmentSectionAssemblyCategory(expectedResult.Category), assembly.Group);
+                Assert.AreEqual(expectedGroup, assembly.Group);
             }
         }
 
@@ -292,7 +293,8 @@
                 AssessmentSectionAssemblyCategoryGroup assembly = calculator.AssembleFailureMechanisms(Enumerable.Empty<FailureMechanismAssemblyCategoryGroup>());
 
                 // Assert
-                Assert.AreEqual(AssemblyCategoryCreator.CreateAssessmentSectionAssemblyCategory(kernel.AssessmentGradeResult), assembly);
+                AssessmentSectionAssemblyCategoryGroup expectedAssembly = AssemblyCategoryCreator.CreateAssessmentSectionAssemblyCategory(kernel.AssessmentGradeResult);
+                Assert.AreEqual(expectedAssembly, assembly);
             }
         }
 
@@ -429,7 +431,8 @@
                                                                                                        failureMechanismsWithProbability);
 
                 // Assert
-                Assert.AreEqual(AssemblyCategoryCreator.CreateAssessmentSectionAssemblyCategory(kernel.AssessmentGradeResult), assembly);
+                AssessmentSectionAssemblyCategoryGroup expectedAssembly = AssemblyCategoryCreator.CreateAssessmentSectionAssemblyCategory(kernel.AssessmentGradeResult);
+                Assert.AreEqual(expectedAssembly, assembly);
             }
         }
 
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismAssemblyCalculatorTest.cs
===================================================================
diff -u -recd4e132deb2683aadc0f83f0853dc1b79602033 -r7c355e20c39e28c6837702bbbf7dcfea5cae6c7b
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismAssemblyCalculatorTest.cs	(.../FailureMechanismAssemblyCalculatorTest.cs)	(revision ecd4e132deb2683aadc0f83f0853dc1b79602033)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismAssemblyCalculatorTest.cs	(.../FailureMechanismAssemblyCalculatorTest.cs)	(revision 7c355e20c39e28c6837702bbbf7dcfea5cae6c7b)
@@ -114,8 +114,7 @@
                 // Assert
                 FailureMechanismSectionAssemblyCategoryGroup actualCategoryGroup =
                     FailureMechanismSectionAssemblyCreator.CreateFailureMechanismSectionAssemblyCategoryGroup(kernel.FmSectionAssemblyResultsInput.Single().Result);
-                Assert.AreEqual(categoryGroups.Single(),
-                                actualCategoryGroup);
+                Assert.AreEqual(categoryGroups.Single(), actualCategoryGroup);
                 Assert.IsFalse(kernel.PartialAssembly);
             }
         }
@@ -137,8 +136,8 @@
                     new List<FailureMechanismSectionAssemblyCategoryGroup>());
 
                 // Assert
-                Assert.AreEqual(FailureMechanismAssemblyCreator.CreateFailureMechanismAssemblyCategoryGroup(kernel.FailureMechanismCategoryResult),
-                                category);
+                FailureMechanismAssemblyCategoryGroup expectedCategory = FailureMechanismAssemblyCreator.CreateFailureMechanismAssemblyCategoryGroup(kernel.FailureMechanismCategoryResult);
+                Assert.AreEqual(expectedCategory, category);
             }
         }
 
@@ -262,8 +261,8 @@
                                                                         CreateAssemblyCategoriesInput());
 
                 // Assert
-                Assert.AreEqual(FailureMechanismAssemblyCreator.CreateFailureMechanismAssemblyCategoryGroup(kernel.FailureMechanismAssemblyResult.Category),
-                                assembly.Group);
+                FailureMechanismAssemblyCategoryGroup expectedGroup = FailureMechanismAssemblyCreator.CreateFailureMechanismAssemblyCategoryGroup(kernel.FailureMechanismAssemblyResult.Category);
+                Assert.AreEqual(expectedGroup, assembly.Group);
                 Assert.AreEqual(kernel.FailureMechanismAssemblyResult.FailureProbability, assembly.Probability);
             }
         }
@@ -319,8 +318,8 @@
         private static void AssertCalculatorOutput(FailureMechanismSectionAssembly expectedSectionAssembly,
                                                    FmSectionAssemblyDirectResult actualResult)
         {
-            Assert.AreEqual(expectedSectionAssembly.Group,
-                            FailureMechanismSectionAssemblyCreator.CreateFailureMechanismSectionAssemblyCategoryGroup(actualResult.Result));
+            FailureMechanismSectionAssemblyCategoryGroup actualGroup = FailureMechanismSectionAssemblyCreator.CreateFailureMechanismSectionAssemblyCategoryGroup(actualResult.Result);
+            Assert.AreEqual(expectedSectionAssembly.Group, actualGroup);
             Assert.AreEqual(expectedSectionAssembly.Probability, actualResult.FailureProbability);
         }
 
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorTest.cs
===================================================================
diff -u -r5054dd8dca09c2c282b4c7aaccd4214c18413cd1 -r7c355e20c39e28c6837702bbbf7dcfea5cae6c7b
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorTest.cs	(.../FailureMechanismSectionAssemblyCalculatorTest.cs)	(revision 5054dd8dca09c2c282b4c7aaccd4214c18413cd1)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorTest.cs	(.../FailureMechanismSectionAssemblyCalculatorTest.cs)	(revision 7c355e20c39e28c6837702bbbf7dcfea5cae6c7b)
@@ -109,7 +109,7 @@
             Assert.AreEqual(assemblyCategoriesInput.SignalingNorm, kernel.AssessmentSectionInput.FailureProbabilitySignallingLimit);
         }
 
-        private AssemblyCategoriesInput CreateAssemblyCategoriesInput()
+        private static AssemblyCategoriesInput CreateAssemblyCategoriesInput()
         {
             var random = new Random(39);
             return new AssemblyCategoriesInput(random.NextDouble(1.0, 5.0),
@@ -160,8 +160,8 @@
                 calculator.AssembleSimpleAssessment(assessmentResult);
 
                 // Assert
-                Assert.AreEqual(FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeE1(assessmentResult),
-                                kernel.AssessmentResultTypeE1Input);
+                EAssessmentResultTypeE1 expectedResultType = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeE1(assessmentResult);
+                Assert.AreEqual(expectedResultType, kernel.AssessmentResultTypeE1Input);
             }
         }
 
@@ -275,8 +275,8 @@
                 calculator.AssembleSimpleAssessment(assessmentResult);
 
                 // Assert
-                Assert.AreEqual(FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeE2(assessmentResult),
-                                kernel.AssessmentResultTypeE2Input);
+                EAssessmentResultTypeE2 expectedResultType = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeE2(assessmentResult);
+                Assert.AreEqual(expectedResultType, kernel.AssessmentResultTypeE2Input);
             }
         }
 
@@ -393,8 +393,8 @@
                 calculator.AssembleDetailedAssessment(detailedAssessmentResult);
 
                 // Assert
-                Assert.AreEqual(FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeG1(detailedAssessmentResult),
-                                kernel.AssessmentResultTypeG1Input);
+                EAssessmentResultTypeG1 expectedResultType = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeG1(detailedAssessmentResult);
+                Assert.AreEqual(expectedResultType, kernel.AssessmentResultTypeG1Input);
             }
         }
 
@@ -522,10 +522,10 @@
                     assemblyCategoriesInput);
 
                 // Assert
+                EAssessmentResultTypeG2 expectedResultType = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeG2(detailedAssessment);
+                Assert.AreEqual(expectedResultType, kernel.AssessmentResultTypeG2Input);
                 Assert.AreEqual(probability, kernel.FailureProbabilityInput);
-                Assert.AreEqual(FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeG2(detailedAssessment),
-                                kernel.AssessmentResultTypeG2Input);
-
+                
                 AssertAssemblyCategoriesInput(assemblyCategoriesInput, kernel);
             }
         }
@@ -694,8 +694,8 @@
                 // Assert
                 Assert.AreEqual(probability, kernel.FailureProbabilityInput);
                 Assert.AreEqual(n, kernel.LengthEffectFactorInput);
-                Assert.AreEqual(FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeG2(detailedAssessment),
-                                kernel.AssessmentResultTypeG2Input);
+                EAssessmentResultTypeG2 expectedResultType = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeG2(detailedAssessment);
+                Assert.AreEqual(expectedResultType, kernel.AssessmentResultTypeG2Input);
                 AssertAssemblyCategoriesInput(assemblyCategoriesInput, kernel);
             }
         }
@@ -1029,8 +1029,8 @@
                 calculator.AssembleTailorMadeAssessment(tailorMadeAssessmentResult);
 
                 // Assert
-                Assert.AreEqual(FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeT1(tailorMadeAssessmentResult),
-                                kernel.AssessmentResultTypeT1Input);
+                EAssessmentResultTypeT1 expectedResultType = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeT1(tailorMadeAssessmentResult);
+                Assert.AreEqual(expectedResultType, kernel.AssessmentResultTypeT1Input);
             }
         }
 
@@ -1155,8 +1155,8 @@
                 calculator.AssembleTailorMadeAssessment(tailorMadeAssessmentResult, probability, assemblyCategoriesInput);
 
                 // Assert
-                Assert.AreEqual(FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeT4(tailorMadeAssessmentResult),
-                                kernel.AssessmentResultTypeT4Input);
+                EAssessmentResultTypeT4 expectedResultType = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeT4(tailorMadeAssessmentResult);
+                Assert.AreEqual(expectedResultType, kernel.AssessmentResultTypeT4Input);
                 Assert.AreEqual(probability, kernel.FailureProbabilityInput);
                 AssertAssemblyCategoriesInput(assemblyCategoriesInput, kernel);
             }
@@ -1316,8 +1316,8 @@
                 calculator.AssembleTailorMadeAssessment(tailorMadeAssessmentResult, probability, assemblyCategoriesInput);
 
                 // Assert
-                Assert.AreEqual(FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeT3(tailorMadeAssessmentResult),
-                                kernel.AssessmentResultTypeT3Input);
+                EAssessmentResultTypeT3 expectedResultType = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeT3(tailorMadeAssessmentResult);
+                Assert.AreEqual(expectedResultType, kernel.AssessmentResultTypeT3Input);
                 Assert.AreEqual(probability, kernel.FailureProbabilityInput);
                 AssertAssemblyCategoriesInput(assemblyCategoriesInput, kernel);
             }
@@ -1479,8 +1479,8 @@
                 calculator.AssembleTailorMadeAssessment(tailorMadeAssessmentResult, probability, n, assemblyCategoriesInput);
 
                 // Assert
-                Assert.AreEqual(FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeT3(tailorMadeAssessmentResult),
-                                kernel.AssessmentResultTypeT3Input);
+                EAssessmentResultTypeT3 expectedResultType = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeT3(tailorMadeAssessmentResult);
+                Assert.AreEqual(expectedResultType, kernel.AssessmentResultTypeT3Input);
                 Assert.AreEqual(probability, kernel.FailureProbabilityInput);
                 Assert.AreEqual(n, kernel.LengthEffectFactorInput);
                 AssertAssemblyCategoriesInput(assemblyCategoriesInput, kernel);