Index: Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/GrassCoverSlipOffInwardsFailureMechanismAssemblyFactoryTest.cs =================================================================== diff -u -r396e95150a2e0ec58015956fc562b9a00e0b56a2 -r4159e6dc4ed1c6bc44773254a1b77777658f12e1 --- Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/GrassCoverSlipOffInwardsFailureMechanismAssemblyFactoryTest.cs (.../GrassCoverSlipOffInwardsFailureMechanismAssemblyFactoryTest.cs) (revision 396e95150a2e0ec58015956fc562b9a00e0b56a2) +++ Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/GrassCoverSlipOffInwardsFailureMechanismAssemblyFactoryTest.cs (.../GrassCoverSlipOffInwardsFailureMechanismAssemblyFactoryTest.cs) (revision 4159e6dc4ed1c6bc44773254a1b77777658f12e1) @@ -97,8 +97,7 @@ GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleSimpleAssessment(sectionResult); // Assert - FailureMechanismSectionAssembly calculatorOutput = calculator.SimpleAssessmentAssemblyOutput; - Assert.AreEqual(calculatorOutput.Group, actualOutput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, actualOutput); } } @@ -176,8 +175,7 @@ GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment(sectionResult); // Assert - FailureMechanismSectionAssemblyCategoryGroup? calculatorOutput = calculator.DetailedAssessmentAssemblyGroupOutput; - Assert.AreEqual(calculatorOutput, actualOutput); + Assert.AreEqual(calculator.DetailedAssessmentAssemblyGroupOutput, actualOutput); } } @@ -223,7 +221,12 @@ public void AssembleTailorMadeAssessment_WithInput_SetsInputOnCalculator() { // Setup - var sectionResult = new GrassCoverSlipOffInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + var random = new Random(21); + FailureMechanismSection failureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var sectionResult = new GrassCoverSlipOffInwardsFailureMechanismSectionResult(failureMechanismSection) + { + TailorMadeAssessmentResult = random.NextEnumValue() + }; using (new AssemblyToolCalculatorFactoryConfig()) { @@ -254,8 +257,7 @@ GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(sectionResult); // Assert - FailureMechanismSectionAssemblyCategoryGroup? calculatorOutput = calculator.TailorMadeAssemblyCategoryOutput; - Assert.AreEqual(calculatorOutput, actualOutput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, actualOutput); } } @@ -318,16 +320,9 @@ GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(sectionResult); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly = - GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleSimpleAssessment(sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedDetailedAssembly = - GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment(sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedTailorMadeAssembly = - GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(sectionResult); - - Assert.AreEqual(expectedSimpleAssembly, calculator.CombinedSimpleAssemblyGroupInput); - Assert.AreEqual(expectedDetailedAssembly, calculator.CombinedDetailedAssemblyGroupInput); - Assert.AreEqual(expectedTailorMadeAssembly, calculator.CombinedTailorMadeAssemblyGroupInput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, calculator.CombinedSimpleAssemblyGroupInput); + Assert.AreEqual(calculator.DetailedAssessmentAssemblyGroupOutput, calculator.CombinedDetailedAssemblyGroupInput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, calculator.CombinedTailorMadeAssemblyGroupInput); } } @@ -439,16 +434,9 @@ new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly = GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleSimpleAssessment( - sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedDetailedAssembly = GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment( - sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedTailorMadeAssembly = GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment( - sectionResult); - - Assert.AreEqual(expectedSimpleAssembly, calculator.CombinedSimpleAssemblyGroupInput); - Assert.AreEqual(expectedDetailedAssembly, calculator.CombinedDetailedAssemblyGroupInput); - Assert.AreEqual(expectedTailorMadeAssembly, calculator.CombinedTailorMadeAssemblyGroupInput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, calculator.CombinedSimpleAssemblyGroupInput); + Assert.AreEqual(calculator.DetailedAssessmentAssemblyGroupOutput, calculator.CombinedDetailedAssemblyGroupInput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, calculator.CombinedTailorMadeAssemblyGroupInput); } } @@ -460,15 +448,16 @@ using (new AssemblyToolCalculatorFactoryConfig()) { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + // Call FailureMechanismSectionAssemblyCategoryGroup categoryGroup = GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( sectionResult, new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - sectionResult); - Assert.AreEqual(expectedAssembly, categoryGroup); + Assert.AreEqual(calculator.CombinedAssemblyCategoryOutput, categoryGroup); } } @@ -488,7 +477,8 @@ true); // Assert - Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), categoryGroup); + Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), + categoryGroup); } [Test] @@ -499,19 +489,22 @@ var sectionResult = new GrassCoverSlipOffInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) { UseManualAssembly = true, - ManualAssemblyCategoryGroup = random.NextEnumValue(), - TailorMadeAssessmentResult = random.NextEnumValue() + ManualAssemblyCategoryGroup = random.NextEnumValue() }; - // Call - FailureMechanismSectionAssemblyCategoryGroup categoryGroup = GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( - sectionResult, - false); + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; - // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - sectionResult); - Assert.AreEqual(expectedAssembly, categoryGroup); + // Call + FailureMechanismSectionAssemblyCategoryGroup categoryGroup = GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( + sectionResult, + false); + + // Assert + Assert.AreEqual(calculator.CombinedAssemblyCategoryOutput, categoryGroup); + } } [Test] @@ -529,7 +522,7 @@ // Call TestDelegate call = () => GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( sectionResult, - new Random(39).NextBoolean()); + false); // Assert var exception = Assert.Throws(call); @@ -576,6 +569,22 @@ } [Test] + public void AssembleFailureMechanism_FailureMechanismIsNotRelevant_ReturnsNotApplicableCategory() + { + // Setup + var failureMechanism = new GrassCoverSlipOffInwardsFailureMechanism + { + IsRelevant = false + }; + + // Call + FailureMechanismAssemblyCategoryGroup category = GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); + + // Assert + Assert.AreEqual(FailureMechanismAssemblyResultFactory.CreateNotApplicableCategory(), category); + } + + [Test] public void AssembleFailureMechanism_WithoutManualInput_SetsInputOnCalculator() { // Setup @@ -589,34 +598,17 @@ { var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = - GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(failureMechanism.SectionResults.Single()); - Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + Assert.AreEqual(sectionCalculator.CombinedAssemblyCategoryOutput, calculator.FailureMechanismSectionCategories.Single()); } } [Test] - public void AssembleFailureMechanism_FailureMechanismIsNotRelevant_ReturnsNotApplicableCategory() - { - // Setup - var failureMechanism = new GrassCoverSlipOffInwardsFailureMechanism - { - IsRelevant = false - }; - - // Call - FailureMechanismAssemblyCategoryGroup category = GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); - - // Assert - Assert.AreEqual(FailureMechanismAssemblyResultFactory.CreateNotApplicableCategory(), category); - } - - [Test] public void AssembleFailureMechanism_WithManualInputAndUseManualTrue_SetsInputOnCalculator() { // Setup @@ -638,13 +630,13 @@ GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, true); // Assert - Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), + Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), calculator.FailureMechanismSectionCategories.Single()); } } [Test] - public void AssembleFailureMechanism_WithManualInputAndUseManualFalse_SetsNoInputOnCalculator() + public void AssembleFailureMechanism_WithManualInputAndUseManualFalse_SetsCombinedInputOnCalculator() { // Setup var failureMechanism = new GrassCoverSlipOffInwardsFailureMechanism(); @@ -660,14 +652,13 @@ { var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, false); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - failureMechanism.SectionResults.Single()); - Assert.AreEqual(expectedAssembly, calculator.FailureMechanismSectionCategories.Single()); + Assert.AreEqual(sectionCalculator.CombinedAssemblyCategoryOutput, calculator.FailureMechanismSectionCategories.Single()); } } Index: Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactoryTest.cs =================================================================== diff -u -r396e95150a2e0ec58015956fc562b9a00e0b56a2 -r4159e6dc4ed1c6bc44773254a1b77777658f12e1 --- Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactoryTest.cs (.../GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactoryTest.cs) (revision 396e95150a2e0ec58015956fc562b9a00e0b56a2) +++ Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactoryTest.cs (.../GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactoryTest.cs) (revision 4159e6dc4ed1c6bc44773254a1b77777658f12e1) @@ -97,8 +97,7 @@ GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleSimpleAssessment(sectionResult); // Assert - FailureMechanismSectionAssembly calculatorOutput = calculator.SimpleAssessmentAssemblyOutput; - Assert.AreEqual(calculatorOutput.Group, actualOutput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, actualOutput); } } @@ -176,8 +175,7 @@ GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment(sectionResult); // Assert - FailureMechanismSectionAssemblyCategoryGroup? calculatorOutput = calculator.DetailedAssessmentAssemblyGroupOutput; - Assert.AreEqual(calculatorOutput, actualOutput); + Assert.AreEqual(calculator.DetailedAssessmentAssemblyGroupOutput, actualOutput); } } @@ -223,7 +221,12 @@ public void AssembleTailorMadeAssessment_WithInput_SetsInputOnCalculator() { // Setup - var sectionResult = new GrassCoverSlipOffOutwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + var random = new Random(21); + FailureMechanismSection failureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var sectionResult = new GrassCoverSlipOffOutwardsFailureMechanismSectionResult(failureMechanismSection) + { + TailorMadeAssessmentResult = random.NextEnumValue() + }; using (new AssemblyToolCalculatorFactoryConfig()) { @@ -254,8 +257,7 @@ GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(sectionResult); // Assert - FailureMechanismSectionAssemblyCategoryGroup? calculatorOutput = calculator.TailorMadeAssemblyCategoryOutput; - Assert.AreEqual(calculatorOutput, actualOutput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, actualOutput); } } @@ -318,16 +320,9 @@ GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(sectionResult); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly = - GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleSimpleAssessment(sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedDetailedAssembly = - GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment(sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedTailorMadeAssembly = - GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(sectionResult); - - Assert.AreEqual(expectedSimpleAssembly, calculator.CombinedSimpleAssemblyGroupInput); - Assert.AreEqual(expectedDetailedAssembly, calculator.CombinedDetailedAssemblyGroupInput); - Assert.AreEqual(expectedTailorMadeAssembly, calculator.CombinedTailorMadeAssemblyGroupInput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, calculator.CombinedSimpleAssemblyGroupInput); + Assert.AreEqual(calculator.DetailedAssessmentAssemblyGroupOutput, calculator.CombinedDetailedAssemblyGroupInput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, calculator.CombinedTailorMadeAssemblyGroupInput); } } @@ -439,16 +434,9 @@ new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly = GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleSimpleAssessment( - sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedDetailedAssembly = GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment( - sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedTailorMadeAssembly = GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment( - sectionResult); - - Assert.AreEqual(expectedSimpleAssembly, calculator.CombinedSimpleAssemblyGroupInput); - Assert.AreEqual(expectedDetailedAssembly, calculator.CombinedDetailedAssemblyGroupInput); - Assert.AreEqual(expectedTailorMadeAssembly, calculator.CombinedTailorMadeAssemblyGroupInput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, calculator.CombinedSimpleAssemblyGroupInput); + Assert.AreEqual(calculator.DetailedAssessmentAssemblyGroupOutput, calculator.CombinedDetailedAssemblyGroupInput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, calculator.CombinedTailorMadeAssemblyGroupInput); } } @@ -460,15 +448,16 @@ using (new AssemblyToolCalculatorFactoryConfig()) { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + // Call FailureMechanismSectionAssemblyCategoryGroup categoryGroup = GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( sectionResult, new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - sectionResult); - Assert.AreEqual(expectedAssembly, categoryGroup); + Assert.AreEqual(calculator.CombinedAssemblyCategoryOutput, categoryGroup); } } @@ -488,7 +477,8 @@ true); // Assert - Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), categoryGroup); + Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), + categoryGroup); } [Test] @@ -499,19 +489,22 @@ var sectionResult = new GrassCoverSlipOffOutwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) { UseManualAssembly = true, - ManualAssemblyCategoryGroup = random.NextEnumValue(), - TailorMadeAssessmentResult = random.NextEnumValue() + ManualAssemblyCategoryGroup = random.NextEnumValue() }; - // Call - FailureMechanismSectionAssemblyCategoryGroup categoryGroup = GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( - sectionResult, - false); + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; - // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - sectionResult); - Assert.AreEqual(expectedAssembly, categoryGroup); + // Call + FailureMechanismSectionAssemblyCategoryGroup categoryGroup = GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( + sectionResult, + false); + + // Assert + Assert.AreEqual(calculator.CombinedAssemblyCategoryOutput, categoryGroup); + } } [Test] @@ -529,7 +522,7 @@ // Call TestDelegate call = () => GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( sectionResult, - new Random(39).NextBoolean()); + false); // Assert var exception = Assert.Throws(call); @@ -576,6 +569,22 @@ } [Test] + public void AssembleFailureMechanism_FailureMechanismIsNotRelevant_ReturnsNotApplicableCategory() + { + // Setup + var failureMechanism = new GrassCoverSlipOffOutwardsFailureMechanism + { + IsRelevant = false + }; + + // Call + FailureMechanismAssemblyCategoryGroup category = GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); + + // Assert + Assert.AreEqual(FailureMechanismAssemblyResultFactory.CreateNotApplicableCategory(), category); + } + + [Test] public void AssembleFailureMechanism_WithoutManualInput_SetsInputOnCalculator() { // Setup @@ -589,34 +598,17 @@ { var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = - GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(failureMechanism.SectionResults.Single()); - Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + Assert.AreEqual(sectionCalculator.CombinedAssemblyCategoryOutput, calculator.FailureMechanismSectionCategories.Single()); } } [Test] - public void AssembleFailureMechanism_FailureMechanismIsNotRelevant_ReturnsNotApplicableCategory() - { - // Setup - var failureMechanism = new GrassCoverSlipOffOutwardsFailureMechanism - { - IsRelevant = false - }; - - // Call - FailureMechanismAssemblyCategoryGroup category = GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); - - // Assert - Assert.AreEqual(FailureMechanismAssemblyResultFactory.CreateNotApplicableCategory(), category); - } - - [Test] public void AssembleFailureMechanism_WithManualInputAndUseManualTrue_SetsInputOnCalculator() { // Setup @@ -638,13 +630,13 @@ GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, true); // Assert - Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), + Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), calculator.FailureMechanismSectionCategories.Single()); } } [Test] - public void AssembleFailureMechanism_WithManualInputAndUseManualFalse_SetsNoInputOnCalculator() + public void AssembleFailureMechanism_WithManualInputAndUseManualFalse_SetsCombinedInputOnCalculator() { // Setup var failureMechanism = new GrassCoverSlipOffOutwardsFailureMechanism(); @@ -660,14 +652,13 @@ { var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, false); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - failureMechanism.SectionResults.Single()); - Assert.AreEqual(expectedAssembly, calculator.FailureMechanismSectionCategories.Single()); + Assert.AreEqual(sectionCalculator.CombinedAssemblyCategoryOutput, calculator.FailureMechanismSectionCategories.Single()); } } Index: Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/MacroStabilityOutwardsFailureMechanismAssemblyFactoryTest.cs =================================================================== diff -u -r396e95150a2e0ec58015956fc562b9a00e0b56a2 -r4159e6dc4ed1c6bc44773254a1b77777658f12e1 --- Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/MacroStabilityOutwardsFailureMechanismAssemblyFactoryTest.cs (.../MacroStabilityOutwardsFailureMechanismAssemblyFactoryTest.cs) (revision 396e95150a2e0ec58015956fc562b9a00e0b56a2) +++ Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/MacroStabilityOutwardsFailureMechanismAssemblyFactoryTest.cs (.../MacroStabilityOutwardsFailureMechanismAssemblyFactoryTest.cs) (revision 4159e6dc4ed1c6bc44773254a1b77777658f12e1) @@ -100,8 +100,7 @@ MacroStabilityOutwardsFailureMechanismAssemblyFactory.AssembleSimpleAssessment(sectionResult); // Assert - FailureMechanismSectionAssembly calculatorOutput = calculator.SimpleAssessmentAssemblyOutput; - Assert.AreEqual(calculatorOutput.Group, actualOutput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, actualOutput); } } @@ -223,8 +222,9 @@ failureMechanism.MacroStabilityOutwardsProbabilityAssessmentInput.SectionLength); Assert.AreEqual(expectedN, calculator.DetailedAssessmentFailureMechanismNInput); Assert.AreEqual(failureMechanism.Contribution / 100, calculator.DetailedAssessmentFailureMechanismContribution); - mocks.VerifyAll(); } + + mocks.VerifyAll(); } [Test] @@ -252,10 +252,10 @@ assessmentSection); // Assert - FailureMechanismSectionAssembly calculatorOutput = calculator.DetailedAssessmentAssemblyOutput; - Assert.AreEqual(calculatorOutput.Group, actualOutput); - mocks.VerifyAll(); + Assert.AreEqual(calculator.DetailedAssessmentAssemblyOutput.Group, actualOutput); } + + mocks.VerifyAll(); } [Test] @@ -287,8 +287,9 @@ Exception innerException = exception.InnerException; Assert.IsInstanceOf(innerException); Assert.AreEqual(innerException.Message, exception.Message); - mocks.VerifyAll(); } + + mocks.VerifyAll(); } #endregion @@ -354,6 +355,12 @@ { // Setup var random = new Random(21); + FailureMechanismSection failureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var sectionResult = new MacroStabilityOutwardsFailureMechanismSectionResult(failureMechanismSection) + { + TailorMadeAssessmentResult = random.NextEnumValue() + }; + var failureMechanism = new MacroStabilityOutwardsFailureMechanism { Contribution = random.NextDouble(0, 100) @@ -363,8 +370,6 @@ IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); mocks.ReplayAll(); - var sectionResult = new MacroStabilityOutwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); - using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; @@ -384,8 +389,9 @@ failureMechanism.MacroStabilityOutwardsProbabilityAssessmentInput.SectionLength); Assert.AreEqual(expectedN, calculator.TailorMadeAssessmentFailureMechanismNInput); Assert.AreEqual(failureMechanism.Contribution / 100, calculator.TailorMadeAssessmentFailureMechanismContributionInput); - mocks.VerifyAll(); } + + mocks.VerifyAll(); } [Test] @@ -413,10 +419,10 @@ assessmentSection); // Assert - FailureMechanismSectionAssembly calculatorOutput = calculator.TailorMadeAssessmentAssemblyOutput; - Assert.AreEqual(calculatorOutput.Group, actualOutput); - mocks.VerifyAll(); + Assert.AreEqual(calculator.TailorMadeAssessmentAssemblyOutput.Group, actualOutput); } + + mocks.VerifyAll(); } [Test] @@ -448,8 +454,9 @@ Exception innerException = exception.InnerException; Assert.IsInstanceOf(innerException); Assert.AreEqual(innerException.Message, exception.Message); - mocks.VerifyAll(); } + + mocks.VerifyAll(); } #endregion @@ -537,18 +544,12 @@ MacroStabilityOutwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(sectionResult, failureMechanism, assessmentSection); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly = - MacroStabilityOutwardsFailureMechanismAssemblyFactory.AssembleSimpleAssessment(sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedDetailedAssembly = - MacroStabilityOutwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment(sectionResult, failureMechanism, assessmentSection); - FailureMechanismSectionAssemblyCategoryGroup expectedTailorMadeAssembly = - MacroStabilityOutwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(sectionResult, failureMechanism, assessmentSection); - - Assert.AreEqual(expectedSimpleAssembly, calculator.CombinedSimpleAssemblyGroupInput); - Assert.AreEqual(expectedDetailedAssembly, calculator.CombinedDetailedAssemblyGroupInput); - Assert.AreEqual(expectedTailorMadeAssembly, calculator.CombinedTailorMadeAssemblyGroupInput); - mocks.VerifyAll(); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, calculator.CombinedSimpleAssemblyGroupInput); + Assert.AreEqual(calculator.DetailedAssessmentAssemblyOutput.Group, calculator.CombinedDetailedAssemblyGroupInput); + Assert.AreEqual(calculator.TailorMadeAssessmentAssemblyOutput.Group, calculator.CombinedTailorMadeAssemblyGroupInput); } + + mocks.VerifyAll(); } [Test] @@ -584,8 +585,9 @@ Assert.AreEqual(expectedSimpleAssembly, calculator.CombinedSimpleAssemblyGroupInput); Assert.AreEqual((FailureMechanismSectionAssemblyCategoryGroup) 0, calculator.CombinedDetailedAssemblyGroupInput); Assert.AreEqual((FailureMechanismSectionAssemblyCategoryGroup) 0, calculator.CombinedTailorMadeAssemblyGroupInput); - mocks.VerifyAll(); } + + mocks.VerifyAll(); } [Test] @@ -615,8 +617,9 @@ // Assert FailureMechanismSectionAssemblyCategoryGroup? calculatorOutput = calculator.CombinedAssemblyCategoryOutput; Assert.AreEqual(calculatorOutput, actualOutput); - mocks.VerifyAll(); } + + mocks.VerifyAll(); } [Test] @@ -648,8 +651,9 @@ Exception innerException = exception.InnerException; Assert.IsInstanceOf(innerException); Assert.AreEqual(innerException.Message, exception.Message); - mocks.VerifyAll(); } + + mocks.VerifyAll(); } #endregion @@ -737,22 +741,12 @@ new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly = MacroStabilityOutwardsFailureMechanismAssemblyFactory.AssembleSimpleAssessment( - sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedDetailedAssembly = MacroStabilityOutwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment( - sectionResult, - failureMechanism, - assessmentSection); - FailureMechanismSectionAssemblyCategoryGroup expectedTailorMadeAssembly = MacroStabilityOutwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment( - sectionResult, - failureMechanism, - assessmentSection); - - Assert.AreEqual(expectedSimpleAssembly, calculator.CombinedSimpleAssemblyGroupInput); - Assert.AreEqual(expectedDetailedAssembly, calculator.CombinedDetailedAssemblyGroupInput); - Assert.AreEqual(expectedTailorMadeAssembly, calculator.CombinedTailorMadeAssemblyGroupInput); - mocks.VerifyAll(); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, calculator.CombinedSimpleAssemblyGroupInput); + Assert.AreEqual(calculator.DetailedAssessmentAssemblyOutput.Group, calculator.CombinedDetailedAssemblyGroupInput); + Assert.AreEqual(calculator.TailorMadeAssessmentAssemblyOutput.Group, calculator.CombinedTailorMadeAssemblyGroupInput); } + + mocks.VerifyAll(); } [Test] @@ -768,6 +762,9 @@ using (new AssemblyToolCalculatorFactoryConfig()) { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + // Call FailureMechanismSectionAssemblyCategoryGroup categoryGroup = MacroStabilityOutwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( sectionResult, @@ -776,12 +773,7 @@ new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = MacroStabilityOutwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - sectionResult, - failureMechanism, - assessmentSection); - Assert.AreEqual(expectedAssembly, categoryGroup); - mocks.VerifyAll(); + Assert.AreEqual(calculator.CombinedAssemblyCategoryOutput, categoryGroup); } } @@ -809,7 +801,8 @@ true); // Assert - Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), categoryGroup); + Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), + categoryGroup); mocks.VerifyAll(); } @@ -821,8 +814,7 @@ var sectionResult = new MacroStabilityOutwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) { UseManualAssembly = true, - ManualAssemblyCategoryGroup = random.NextEnumValue(), - TailorMadeAssessmentResult = random.NextEnumValue() + ManualAssemblyCategoryGroup = random.NextEnumValue() }; var failureMechanism = new MacroStabilityOutwardsFailureMechanism(); @@ -831,19 +823,22 @@ IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); mocks.ReplayAll(); - // Call - FailureMechanismSectionAssemblyCategoryGroup categoryGroup = MacroStabilityOutwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( - sectionResult, - failureMechanism, - assessmentSection, - false); + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; - // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = MacroStabilityOutwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - sectionResult, - failureMechanism, - assessmentSection); - Assert.AreEqual(expectedAssembly, categoryGroup); + // Call + FailureMechanismSectionAssemblyCategoryGroup categoryGroup = MacroStabilityOutwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( + sectionResult, + failureMechanism, + assessmentSection, + false); + + // Assert + Assert.AreEqual(calculator.CombinedAssemblyCategoryOutput, categoryGroup); + } + mocks.VerifyAll(); } @@ -877,8 +872,9 @@ Exception innerException = exception.InnerException; Assert.IsInstanceOf(innerException); Assert.AreEqual(innerException.Message, exception.Message); - mocks.VerifyAll(); } + + mocks.VerifyAll(); } [Test] @@ -908,6 +904,7 @@ Exception innerException = exception.InnerException; Assert.IsInstanceOf(innerException); Assert.AreEqual(innerException.Message, exception.Message); + mocks.VerifyAll(); } #endregion @@ -949,6 +946,30 @@ } [Test] + public void AssembleFailureMechanism_FailureMechanismIsNotRelevant_ReturnsNotApplicableCategory() + { + // Setup + var failureMechanism = new MacroStabilityOutwardsFailureMechanism + { + IsRelevant = false + }; + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + // Call + FailureMechanismAssemblyCategoryGroup category = MacroStabilityOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism( + failureMechanism, + assessmentSection, + new Random(39).NextBoolean()); + + // Assert + Assert.AreEqual(FailureMechanismAssemblyResultFactory.CreateNotApplicableCategory(), category); + mocks.VerifyAll(); + } + + [Test] public void AssembleFailureMechanism_WithoutManualInput_SetsInputOnCalculator() { // Setup @@ -966,48 +987,21 @@ { var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call MacroStabilityOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection, new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = - MacroStabilityOutwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment(failureMechanism.SectionResults.Single(), - failureMechanism, - assessmentSection); - Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + Assert.AreEqual(sectionCalculator.CombinedAssemblyCategoryOutput, calculator.FailureMechanismSectionCategories.Single()); } mocks.VerifyAll(); } [Test] - public void AssembleFailureMechanism_FailureMechanismIsNotRelevant_ReturnsNotApplicableCategory() - { - // Setup - var failureMechanism = new MacroStabilityOutwardsFailureMechanism - { - IsRelevant = false - }; - - var mocks = new MockRepository(); - IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); - mocks.ReplayAll(); - - // Call - FailureMechanismAssemblyCategoryGroup category = MacroStabilityOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism( - failureMechanism, - assessmentSection, - new Random(39).NextBoolean()); - - // Assert - Assert.AreEqual(FailureMechanismAssemblyResultFactory.CreateNotApplicableCategory(), category); - mocks.VerifyAll(); - } - - [Test] public void AssembleFailureMechanism_WithManualInputAndUseManualTrue_SetsInputOnCalculator() { // Setup @@ -1035,15 +1029,15 @@ true); // Assert - Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), + Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), calculator.FailureMechanismSectionCategories.Single()); } mocks.VerifyAll(); } [Test] - public void AssembleFailureMechanism_WithManualInputAndUseManualFalse_SetsNoInputOnCalculator() + public void AssembleFailureMechanism_WithManualInputAndUseManualFalse_SetsCombinedInputOnCalculator() { // Setup var failureMechanism = new MacroStabilityOutwardsFailureMechanism(); @@ -1063,16 +1057,15 @@ { var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call MacroStabilityOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection, false); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = MacroStabilityOutwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - failureMechanism.SectionResults.Single(), failureMechanism, assessmentSection); - Assert.AreEqual(expectedAssembly, calculator.FailureMechanismSectionCategories.Single()); + Assert.AreEqual(sectionCalculator.CombinedAssemblyCategoryOutput, calculator.FailureMechanismSectionCategories.Single()); } mocks.VerifyAll(); @@ -1101,8 +1094,9 @@ // Assert Assert.AreEqual(calculator.FailureMechanismAssemblyCategoryGroupOutput, actualOutput); - mocks.VerifyAll(); } + + mocks.VerifyAll(); } [Test] Index: Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/MicrostabilityFailureMechanismAssemblyFactoryTest.cs =================================================================== diff -u -r396e95150a2e0ec58015956fc562b9a00e0b56a2 -r4159e6dc4ed1c6bc44773254a1b77777658f12e1 --- Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/MicrostabilityFailureMechanismAssemblyFactoryTest.cs (.../MicrostabilityFailureMechanismAssemblyFactoryTest.cs) (revision 396e95150a2e0ec58015956fc562b9a00e0b56a2) +++ Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/MicrostabilityFailureMechanismAssemblyFactoryTest.cs (.../MicrostabilityFailureMechanismAssemblyFactoryTest.cs) (revision 4159e6dc4ed1c6bc44773254a1b77777658f12e1) @@ -97,8 +97,7 @@ MicrostabilityFailureMechanismAssemblyFactory.AssembleSimpleAssessment(sectionResult); // Assert - FailureMechanismSectionAssembly calculatorOutput = calculator.SimpleAssessmentAssemblyOutput; - Assert.AreEqual(calculatorOutput.Group, actualOutput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, actualOutput); } } @@ -176,8 +175,7 @@ MicrostabilityFailureMechanismAssemblyFactory.AssembleDetailedAssessment(sectionResult); // Assert - FailureMechanismSectionAssemblyCategoryGroup? calculatorOutput = calculator.DetailedAssessmentAssemblyGroupOutput; - Assert.AreEqual(calculatorOutput, actualOutput); + Assert.AreEqual(calculator.DetailedAssessmentAssemblyGroupOutput, actualOutput); } } @@ -223,7 +221,12 @@ public void AssembleTailorMadeAssessment_WithInput_SetsInputOnCalculator() { // Setup - var sectionResult = new MicrostabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + var random = new Random(21); + FailureMechanismSection failureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var sectionResult = new MicrostabilityFailureMechanismSectionResult(failureMechanismSection) + { + TailorMadeAssessmentResult = random.NextEnumValue() + }; using (new AssemblyToolCalculatorFactoryConfig()) { @@ -254,8 +257,7 @@ MicrostabilityFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(sectionResult); // Assert - FailureMechanismSectionAssemblyCategoryGroup? calculatorOutput = calculator.TailorMadeAssemblyCategoryOutput; - Assert.AreEqual(calculatorOutput, actualOutput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, actualOutput); } } @@ -318,16 +320,9 @@ MicrostabilityFailureMechanismAssemblyFactory.AssembleCombinedAssessment(sectionResult); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly = - MicrostabilityFailureMechanismAssemblyFactory.AssembleSimpleAssessment(sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedDetailedAssembly = - MicrostabilityFailureMechanismAssemblyFactory.AssembleDetailedAssessment(sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedTailorMadeAssembly = - MicrostabilityFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(sectionResult); - - Assert.AreEqual(expectedSimpleAssembly, calculator.CombinedSimpleAssemblyGroupInput); - Assert.AreEqual(expectedDetailedAssembly, calculator.CombinedDetailedAssemblyGroupInput); - Assert.AreEqual(expectedTailorMadeAssembly, calculator.CombinedTailorMadeAssemblyGroupInput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, calculator.CombinedSimpleAssemblyGroupInput); + Assert.AreEqual(calculator.DetailedAssessmentAssemblyGroupOutput, calculator.CombinedDetailedAssemblyGroupInput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, calculator.CombinedTailorMadeAssemblyGroupInput); } } @@ -439,16 +434,9 @@ new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly = MicrostabilityFailureMechanismAssemblyFactory.AssembleSimpleAssessment( - sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedDetailedAssembly = MicrostabilityFailureMechanismAssemblyFactory.AssembleDetailedAssessment( - sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedTailorMadeAssembly = MicrostabilityFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment( - sectionResult); - - Assert.AreEqual(expectedSimpleAssembly, calculator.CombinedSimpleAssemblyGroupInput); - Assert.AreEqual(expectedDetailedAssembly, calculator.CombinedDetailedAssemblyGroupInput); - Assert.AreEqual(expectedTailorMadeAssembly, calculator.CombinedTailorMadeAssemblyGroupInput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, calculator.CombinedSimpleAssemblyGroupInput); + Assert.AreEqual(calculator.DetailedAssessmentAssemblyGroupOutput, calculator.CombinedDetailedAssemblyGroupInput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, calculator.CombinedTailorMadeAssemblyGroupInput); } } @@ -460,15 +448,16 @@ using (new AssemblyToolCalculatorFactoryConfig()) { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + // Call FailureMechanismSectionAssemblyCategoryGroup categoryGroup = MicrostabilityFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( sectionResult, new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = MicrostabilityFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - sectionResult); - Assert.AreEqual(expectedAssembly, categoryGroup); + Assert.AreEqual(calculator.CombinedAssemblyCategoryOutput, categoryGroup); } } @@ -488,7 +477,8 @@ true); // Assert - Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), categoryGroup); + Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), + categoryGroup); } [Test] @@ -499,19 +489,22 @@ var sectionResult = new MicrostabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) { UseManualAssembly = true, - ManualAssemblyCategoryGroup = random.NextEnumValue(), - TailorMadeAssessmentResult = random.NextEnumValue() + ManualAssemblyCategoryGroup = random.NextEnumValue() }; - // Call - FailureMechanismSectionAssemblyCategoryGroup categoryGroup = MicrostabilityFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( - sectionResult, - false); + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; - // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = MicrostabilityFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - sectionResult); - Assert.AreEqual(expectedAssembly, categoryGroup); + // Call + FailureMechanismSectionAssemblyCategoryGroup categoryGroup = MicrostabilityFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( + sectionResult, + false); + + // Assert + Assert.AreEqual(calculator.CombinedAssemblyCategoryOutput, categoryGroup); + } } [Test] @@ -529,7 +522,7 @@ // Call TestDelegate call = () => MicrostabilityFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( sectionResult, - new Random(39).NextBoolean()); + false); // Assert var exception = Assert.Throws(call); @@ -576,6 +569,22 @@ } [Test] + public void AssembleFailureMechanism_FailureMechanismIsNotRelevant_ReturnsNotApplicableCategory() + { + // Setup + var failureMechanism = new MicrostabilityFailureMechanism + { + IsRelevant = false + }; + + // Call + FailureMechanismAssemblyCategoryGroup category = MicrostabilityFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); + + // Assert + Assert.AreEqual(FailureMechanismAssemblyResultFactory.CreateNotApplicableCategory(), category); + } + + [Test] public void AssembleFailureMechanism_WithoutManualInput_SetsInputOnCalculator() { // Setup @@ -589,34 +598,17 @@ { var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call MicrostabilityFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = - MicrostabilityFailureMechanismAssemblyFactory.AssembleCombinedAssessment(failureMechanism.SectionResults.Single()); - Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + Assert.AreEqual(sectionCalculator.CombinedAssemblyCategoryOutput, calculator.FailureMechanismSectionCategories.Single()); } } [Test] - public void AssembleFailureMechanism_FailureMechanismIsNotRelevant_ReturnsNotApplicableCategory() - { - // Setup - var failureMechanism = new MicrostabilityFailureMechanism - { - IsRelevant = false - }; - - // Call - FailureMechanismAssemblyCategoryGroup category = MicrostabilityFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); - - // Assert - Assert.AreEqual(FailureMechanismAssemblyResultFactory.CreateNotApplicableCategory(), category); - } - - [Test] public void AssembleFailureMechanism_WithManualInputAndUseManualTrue_SetsInputOnCalculator() { // Setup @@ -638,13 +630,13 @@ MicrostabilityFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, true); // Assert - Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), + Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), calculator.FailureMechanismSectionCategories.Single()); } } [Test] - public void AssembleFailureMechanism_WithManualInputAndUseManualFalse_SetsNoInputOnCalculator() + public void AssembleFailureMechanism_WithManualInputAndUseManualFalse_SetsCombinedInputOnCalculator() { // Setup var failureMechanism = new MicrostabilityFailureMechanism(); @@ -660,14 +652,13 @@ { var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call MicrostabilityFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, false); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = MicrostabilityFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - failureMechanism.SectionResults.Single()); - Assert.AreEqual(expectedAssembly, calculator.FailureMechanismSectionCategories.Single()); + Assert.AreEqual(sectionCalculator.CombinedAssemblyCategoryOutput, calculator.FailureMechanismSectionCategories.Single()); } } Index: Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/PipingStructureFailureMechanismAssemblyFactoryTest.cs =================================================================== diff -u -r396e95150a2e0ec58015956fc562b9a00e0b56a2 -r4159e6dc4ed1c6bc44773254a1b77777658f12e1 --- Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/PipingStructureFailureMechanismAssemblyFactoryTest.cs (.../PipingStructureFailureMechanismAssemblyFactoryTest.cs) (revision 396e95150a2e0ec58015956fc562b9a00e0b56a2) +++ Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/PipingStructureFailureMechanismAssemblyFactoryTest.cs (.../PipingStructureFailureMechanismAssemblyFactoryTest.cs) (revision 4159e6dc4ed1c6bc44773254a1b77777658f12e1) @@ -97,8 +97,7 @@ PipingStructureFailureMechanismAssemblyFactory.AssembleSimpleAssessment(sectionResult); // Assert - FailureMechanismSectionAssembly calculatorOutput = calculator.SimpleAssessmentAssemblyOutput; - Assert.AreEqual(calculatorOutput.Group, actualOutput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, actualOutput); } } @@ -176,8 +175,7 @@ PipingStructureFailureMechanismAssemblyFactory.AssembleDetailedAssessment(sectionResult); // Assert - FailureMechanismSectionAssemblyCategoryGroup? calculatorOutput = calculator.DetailedAssessmentAssemblyGroupOutput; - Assert.AreEqual(calculatorOutput, actualOutput); + Assert.AreEqual(calculator.DetailedAssessmentAssemblyGroupOutput, actualOutput); } } @@ -223,7 +221,12 @@ public void AssembleTailorMadeAssessment_WithInput_SetsInputOnCalculator() { // Setup - var sectionResult = new PipingStructureFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + var random = new Random(21); + FailureMechanismSection failureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var sectionResult = new PipingStructureFailureMechanismSectionResult(failureMechanismSection) + { + TailorMadeAssessmentResult = random.NextEnumValue() + }; using (new AssemblyToolCalculatorFactoryConfig()) { @@ -254,8 +257,7 @@ PipingStructureFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(sectionResult); // Assert - FailureMechanismSectionAssemblyCategoryGroup? calculatorOutput = calculator.TailorMadeAssemblyCategoryOutput; - Assert.AreEqual(calculatorOutput, actualOutput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, actualOutput); } } @@ -318,16 +320,9 @@ PipingStructureFailureMechanismAssemblyFactory.AssembleCombinedAssessment(sectionResult); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly = - PipingStructureFailureMechanismAssemblyFactory.AssembleSimpleAssessment(sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedDetailedAssembly = - PipingStructureFailureMechanismAssemblyFactory.AssembleDetailedAssessment(sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedTailorMadeAssembly = - PipingStructureFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(sectionResult); - - Assert.AreEqual(expectedSimpleAssembly, calculator.CombinedSimpleAssemblyGroupInput); - Assert.AreEqual(expectedDetailedAssembly, calculator.CombinedDetailedAssemblyGroupInput); - Assert.AreEqual(expectedTailorMadeAssembly, calculator.CombinedTailorMadeAssemblyGroupInput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, calculator.CombinedSimpleAssemblyGroupInput); + Assert.AreEqual(calculator.DetailedAssessmentAssemblyGroupOutput, calculator.CombinedDetailedAssemblyGroupInput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, calculator.CombinedTailorMadeAssemblyGroupInput); } } @@ -439,16 +434,9 @@ new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly = PipingStructureFailureMechanismAssemblyFactory.AssembleSimpleAssessment( - sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedDetailedAssembly = PipingStructureFailureMechanismAssemblyFactory.AssembleDetailedAssessment( - sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedTailorMadeAssembly = PipingStructureFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment( - sectionResult); - - Assert.AreEqual(expectedSimpleAssembly, calculator.CombinedSimpleAssemblyGroupInput); - Assert.AreEqual(expectedDetailedAssembly, calculator.CombinedDetailedAssemblyGroupInput); - Assert.AreEqual(expectedTailorMadeAssembly, calculator.CombinedTailorMadeAssemblyGroupInput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, calculator.CombinedSimpleAssemblyGroupInput); + Assert.AreEqual(calculator.DetailedAssessmentAssemblyGroupOutput, calculator.CombinedDetailedAssemblyGroupInput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, calculator.CombinedTailorMadeAssemblyGroupInput); } } @@ -460,15 +448,16 @@ using (new AssemblyToolCalculatorFactoryConfig()) { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + // Call FailureMechanismSectionAssemblyCategoryGroup categoryGroup = PipingStructureFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( sectionResult, new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = PipingStructureFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - sectionResult); - Assert.AreEqual(expectedAssembly, categoryGroup); + Assert.AreEqual(calculator.CombinedAssemblyCategoryOutput, categoryGroup); } } @@ -488,7 +477,8 @@ true); // Assert - Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), categoryGroup); + Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), + categoryGroup); } [Test] @@ -499,19 +489,22 @@ var sectionResult = new PipingStructureFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) { UseManualAssembly = true, - ManualAssemblyCategoryGroup = random.NextEnumValue(), - TailorMadeAssessmentResult = random.NextEnumValue() + ManualAssemblyCategoryGroup = random.NextEnumValue() }; - // Call - FailureMechanismSectionAssemblyCategoryGroup categoryGroup = PipingStructureFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( - sectionResult, - false); + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; - // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = PipingStructureFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - sectionResult); - Assert.AreEqual(expectedAssembly, categoryGroup); + // Call + FailureMechanismSectionAssemblyCategoryGroup categoryGroup = PipingStructureFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( + sectionResult, + false); + + // Assert + Assert.AreEqual(calculator.CombinedAssemblyCategoryOutput, categoryGroup); + } } [Test] @@ -529,7 +522,7 @@ // Call TestDelegate call = () => PipingStructureFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( sectionResult, - new Random(39).NextBoolean()); + false); // Assert var exception = Assert.Throws(call); @@ -576,6 +569,22 @@ } [Test] + public void AssembleFailureMechanism_FailureMechanismIsNotRelevant_ReturnsNotApplicableCategory() + { + // Setup + var failureMechanism = new PipingStructureFailureMechanism + { + IsRelevant = false + }; + + // Call + FailureMechanismAssemblyCategoryGroup category = PipingStructureFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); + + // Assert + Assert.AreEqual(FailureMechanismAssemblyResultFactory.CreateNotApplicableCategory(), category); + } + + [Test] public void AssembleFailureMechanism_WithoutManualInput_SetsInputOnCalculator() { // Setup @@ -589,34 +598,17 @@ { var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call PipingStructureFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = - PipingStructureFailureMechanismAssemblyFactory.AssembleCombinedAssessment(failureMechanism.SectionResults.Single()); - Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + Assert.AreEqual(sectionCalculator.CombinedAssemblyCategoryOutput, calculator.FailureMechanismSectionCategories.Single()); } } [Test] - public void AssembleFailureMechanism_FailureMechanismIsNotRelevant_ReturnsNotApplicableCategory() - { - // Setup - var failureMechanism = new PipingStructureFailureMechanism - { - IsRelevant = false - }; - - // Call - FailureMechanismAssemblyCategoryGroup category = PipingStructureFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); - - // Assert - Assert.AreEqual(FailureMechanismAssemblyResultFactory.CreateNotApplicableCategory(), category); - } - - [Test] public void AssembleFailureMechanism_WithManualInputAndUseManualTrue_SetsInputOnCalculator() { // Setup @@ -644,7 +636,7 @@ } [Test] - public void AssembleFailureMechanism_WithManualInputAndUseManualFalse_SetsNoInputOnCalculator() + public void AssembleFailureMechanism_WithManualInputAndUseManualFalse_SetsCombinedInputOnCalculator() { // Setup var failureMechanism = new PipingStructureFailureMechanism(); @@ -660,14 +652,13 @@ { var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call PipingStructureFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, false); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = PipingStructureFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - failureMechanism.SectionResults.Single()); - Assert.AreEqual(expectedAssembly, calculator.FailureMechanismSectionCategories.Single()); + Assert.AreEqual(sectionCalculator.CombinedAssemblyCategoryOutput, calculator.FailureMechanismSectionCategories.Single()); } } Index: Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactoryTest.cs =================================================================== diff -u -r396e95150a2e0ec58015956fc562b9a00e0b56a2 -r4159e6dc4ed1c6bc44773254a1b77777658f12e1 --- Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactoryTest.cs (.../StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactoryTest.cs) (revision 396e95150a2e0ec58015956fc562b9a00e0b56a2) +++ Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactoryTest.cs (.../StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactoryTest.cs) (revision 4159e6dc4ed1c6bc44773254a1b77777658f12e1) @@ -97,8 +97,7 @@ StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.AssembleSimpleAssessment(sectionResult); // Assert - FailureMechanismSectionAssembly calculatorOutput = calculator.SimpleAssessmentAssemblyOutput; - Assert.AreEqual(calculatorOutput.Group, actualOutput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, actualOutput); } } @@ -145,7 +144,12 @@ public void AssembleTailorMadeAssessment_WithInput_SetsInputOnCalculator() { // Setup - var sectionResult = new StrengthStabilityLengthwiseConstructionFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + var random = new Random(21); + FailureMechanismSection failureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var sectionResult = new StrengthStabilityLengthwiseConstructionFailureMechanismSectionResult(failureMechanismSection) + { + TailorMadeAssessmentResult = random.NextEnumValue() + }; using (new AssemblyToolCalculatorFactoryConfig()) { @@ -176,8 +180,7 @@ StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(sectionResult); // Assert - FailureMechanismSectionAssemblyCategoryGroup? calculatorOutput = calculator.TailorMadeAssemblyCategoryOutput; - Assert.AreEqual(calculatorOutput, actualOutput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, actualOutput); } } @@ -226,8 +229,7 @@ SimpleAssessmentResultType simpleAssessmentResult) { // Setup - var sectionResult = new StrengthStabilityLengthwiseConstructionFailureMechanismSectionResult( - FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + var sectionResult = new StrengthStabilityLengthwiseConstructionFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) { SimpleAssessmentResult = simpleAssessmentResult }; @@ -241,14 +243,9 @@ StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.AssembleCombinedAssessment(sectionResult); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly = - StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.AssembleSimpleAssessment(sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedTailorMadeAssembly = - StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(sectionResult); - - Assert.AreEqual(expectedSimpleAssembly, calculator.CombinedSimpleAssemblyGroupInput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, calculator.CombinedSimpleAssemblyGroupInput); Assert.AreEqual((FailureMechanismSectionAssemblyCategoryGroup) 0, calculator.CombinedDetailedAssemblyGroupInput); - Assert.AreEqual(expectedTailorMadeAssembly, calculator.CombinedTailorMadeAssemblyGroupInput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, calculator.CombinedTailorMadeAssemblyGroupInput); } } @@ -360,13 +357,9 @@ new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly = StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.AssembleSimpleAssessment( - sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedTailorMadeAssembly = StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment( - sectionResult); - - Assert.AreEqual(expectedSimpleAssembly, calculator.CombinedSimpleAssemblyGroupInput); - Assert.AreEqual(expectedTailorMadeAssembly, calculator.CombinedTailorMadeAssemblyGroupInput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, calculator.CombinedSimpleAssemblyGroupInput); + Assert.AreEqual((FailureMechanismSectionAssemblyCategoryGroup) 0, calculator.CombinedDetailedAssemblyGroupInput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, calculator.CombinedTailorMadeAssemblyGroupInput); } } @@ -378,15 +371,16 @@ using (new AssemblyToolCalculatorFactoryConfig()) { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + // Call FailureMechanismSectionAssemblyCategoryGroup categoryGroup = StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( sectionResult, new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - sectionResult); - Assert.AreEqual(expectedAssembly, categoryGroup); + Assert.AreEqual(calculator.CombinedAssemblyCategoryOutput, categoryGroup); } } @@ -406,7 +400,8 @@ true); // Assert - Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), categoryGroup); + Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), + categoryGroup); } [Test] @@ -417,19 +412,22 @@ var sectionResult = new StrengthStabilityLengthwiseConstructionFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) { UseManualAssembly = true, - ManualAssemblyCategoryGroup = random.NextEnumValue(), - TailorMadeAssessmentResult = random.NextEnumValue() + ManualAssemblyCategoryGroup = random.NextEnumValue() }; - // Call - FailureMechanismSectionAssemblyCategoryGroup categoryGroup = StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( - sectionResult, - false); + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; - // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - sectionResult); - Assert.AreEqual(expectedAssembly, categoryGroup); + // Call + FailureMechanismSectionAssemblyCategoryGroup categoryGroup = StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( + sectionResult, + false); + + // Assert + Assert.AreEqual(calculator.CombinedAssemblyCategoryOutput, categoryGroup); + } } [Test] @@ -447,7 +445,7 @@ // Call TestDelegate call = () => StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( sectionResult, - new Random(39).NextBoolean()); + false); // Assert var exception = Assert.Throws(call); @@ -468,9 +466,8 @@ }; // Call - TestDelegate call = () => StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( - sectionResult, - true); + TestDelegate call = () => StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup(sectionResult, + true); // Assert var exception = Assert.Throws(call); @@ -495,6 +492,22 @@ } [Test] + public void AssembleFailureMechanism_FailureMechanismIsNotRelevant_ReturnsNotApplicableCategory() + { + // Setup + var failureMechanism = new StrengthStabilityLengthwiseConstructionFailureMechanism + { + IsRelevant = false + }; + + // Call + FailureMechanismAssemblyCategoryGroup category = StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); + + // Assert + Assert.AreEqual(FailureMechanismAssemblyResultFactory.CreateNotApplicableCategory(), category); + } + + [Test] public void AssembleFailureMechanism_WithoutManualInput_SetsInputOnCalculator() { // Setup @@ -508,34 +521,17 @@ { var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = - StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.AssembleCombinedAssessment(failureMechanism.SectionResults.Single()); - Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + Assert.AreEqual(sectionCalculator.CombinedAssemblyCategoryOutput, calculator.FailureMechanismSectionCategories.Single()); } } [Test] - public void AssembleFailureMechanism_FailureMechanismIsNotRelevant_ReturnsNotApplicableCategory() - { - // Setup - var failureMechanism = new StrengthStabilityLengthwiseConstructionFailureMechanism - { - IsRelevant = false - }; - - // Call - FailureMechanismAssemblyCategoryGroup category = StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); - - // Assert - Assert.AreEqual(FailureMechanismAssemblyResultFactory.CreateNotApplicableCategory(), category); - } - - [Test] public void AssembleFailureMechanism_WithManualInputAndUseManualTrue_SetsInputOnCalculator() { // Setup @@ -563,7 +559,7 @@ } [Test] - public void AssembleFailureMechanism_WithManualInputAndUseManualFalse_SetsNoInputOnCalculator() + public void AssembleFailureMechanism_WithManualInputAndUseManualFalse_SetsCombinedInputOnCalculator() { // Setup var failureMechanism = new StrengthStabilityLengthwiseConstructionFailureMechanism(); @@ -579,14 +575,13 @@ { var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, false); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - failureMechanism.SectionResults.Single()); - Assert.AreEqual(expectedAssembly, calculator.FailureMechanismSectionCategories.Single()); + Assert.AreEqual(sectionCalculator.CombinedAssemblyCategoryOutput, calculator.FailureMechanismSectionCategories.Single()); } } Index: Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/TechnicalInnovationFailureMechanismAssemblyFactoryTest.cs =================================================================== diff -u -r396e95150a2e0ec58015956fc562b9a00e0b56a2 -r4159e6dc4ed1c6bc44773254a1b77777658f12e1 --- Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/TechnicalInnovationFailureMechanismAssemblyFactoryTest.cs (.../TechnicalInnovationFailureMechanismAssemblyFactoryTest.cs) (revision 396e95150a2e0ec58015956fc562b9a00e0b56a2) +++ Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/TechnicalInnovationFailureMechanismAssemblyFactoryTest.cs (.../TechnicalInnovationFailureMechanismAssemblyFactoryTest.cs) (revision 4159e6dc4ed1c6bc44773254a1b77777658f12e1) @@ -97,8 +97,7 @@ TechnicalInnovationFailureMechanismAssemblyFactory.AssembleSimpleAssessment(sectionResult); // Assert - FailureMechanismSectionAssembly calculatorOutput = calculator.SimpleAssessmentAssemblyOutput; - Assert.AreEqual(calculatorOutput.Group, actualOutput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, actualOutput); } } @@ -145,7 +144,12 @@ public void AssembleTailorMadeAssessment_WithInput_SetsInputOnCalculator() { // Setup - var sectionResult = new TechnicalInnovationFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + var random = new Random(21); + FailureMechanismSection failureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var sectionResult = new TechnicalInnovationFailureMechanismSectionResult(failureMechanismSection) + { + TailorMadeAssessmentResult = random.NextEnumValue() + }; using (new AssemblyToolCalculatorFactoryConfig()) { @@ -176,8 +180,7 @@ TechnicalInnovationFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(sectionResult); // Assert - FailureMechanismSectionAssemblyCategoryGroup? calculatorOutput = calculator.TailorMadeAssemblyCategoryOutput; - Assert.AreEqual(calculatorOutput, actualOutput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, actualOutput); } } @@ -226,8 +229,7 @@ SimpleAssessmentResultType simpleAssessmentResult) { // Setup - var sectionResult = new TechnicalInnovationFailureMechanismSectionResult( - FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + var sectionResult = new TechnicalInnovationFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) { SimpleAssessmentResult = simpleAssessmentResult }; @@ -241,14 +243,9 @@ TechnicalInnovationFailureMechanismAssemblyFactory.AssembleCombinedAssessment(sectionResult); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly = - TechnicalInnovationFailureMechanismAssemblyFactory.AssembleSimpleAssessment(sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedTailorMadeAssembly = - TechnicalInnovationFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(sectionResult); - - Assert.AreEqual(expectedSimpleAssembly, calculator.CombinedSimpleAssemblyGroupInput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, calculator.CombinedSimpleAssemblyGroupInput); Assert.AreEqual((FailureMechanismSectionAssemblyCategoryGroup) 0, calculator.CombinedDetailedAssemblyGroupInput); - Assert.AreEqual(expectedTailorMadeAssembly, calculator.CombinedTailorMadeAssemblyGroupInput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, calculator.CombinedTailorMadeAssemblyGroupInput); } } @@ -360,13 +357,9 @@ new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly = TechnicalInnovationFailureMechanismAssemblyFactory.AssembleSimpleAssessment( - sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedTailorMadeAssembly = TechnicalInnovationFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment( - sectionResult); - - Assert.AreEqual(expectedSimpleAssembly, calculator.CombinedSimpleAssemblyGroupInput); - Assert.AreEqual(expectedTailorMadeAssembly, calculator.CombinedTailorMadeAssemblyGroupInput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, calculator.CombinedSimpleAssemblyGroupInput); + Assert.AreEqual((FailureMechanismSectionAssemblyCategoryGroup) 0, calculator.CombinedDetailedAssemblyGroupInput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, calculator.CombinedTailorMadeAssemblyGroupInput); } } @@ -378,15 +371,16 @@ using (new AssemblyToolCalculatorFactoryConfig()) { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + // Call FailureMechanismSectionAssemblyCategoryGroup categoryGroup = TechnicalInnovationFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( sectionResult, new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = TechnicalInnovationFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - sectionResult); - Assert.AreEqual(expectedAssembly, categoryGroup); + Assert.AreEqual(calculator.CombinedAssemblyCategoryOutput, categoryGroup); } } @@ -406,7 +400,8 @@ true); // Assert - Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), categoryGroup); + Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), + categoryGroup); } [Test] @@ -417,19 +412,22 @@ var sectionResult = new TechnicalInnovationFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) { UseManualAssembly = true, - ManualAssemblyCategoryGroup = random.NextEnumValue(), - TailorMadeAssessmentResult = random.NextEnumValue() + ManualAssemblyCategoryGroup = random.NextEnumValue() }; - // Call - FailureMechanismSectionAssemblyCategoryGroup categoryGroup = TechnicalInnovationFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( - sectionResult, - false); + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; - // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = TechnicalInnovationFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - sectionResult); - Assert.AreEqual(expectedAssembly, categoryGroup); + // Call + FailureMechanismSectionAssemblyCategoryGroup categoryGroup = TechnicalInnovationFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( + sectionResult, + false); + + // Assert + Assert.AreEqual(calculator.CombinedAssemblyCategoryOutput, categoryGroup); + } } [Test] @@ -447,7 +445,7 @@ // Call TestDelegate call = () => TechnicalInnovationFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( sectionResult, - new Random(39).NextBoolean()); + false); // Assert var exception = Assert.Throws(call); @@ -494,6 +492,22 @@ } [Test] + public void AssembleFailureMechanism_FailureMechanismIsNotRelevant_ReturnsNotApplicableCategory() + { + // Setup + var failureMechanism = new TechnicalInnovationFailureMechanism + { + IsRelevant = false + }; + + // Call + FailureMechanismAssemblyCategoryGroup category = TechnicalInnovationFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); + + // Assert + Assert.AreEqual(FailureMechanismAssemblyResultFactory.CreateNotApplicableCategory(), category); + } + + [Test] public void AssembleFailureMechanism_WithoutManualInput_SetsInputOnCalculator() { // Setup @@ -507,34 +521,17 @@ { var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call TechnicalInnovationFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = - TechnicalInnovationFailureMechanismAssemblyFactory.AssembleCombinedAssessment(failureMechanism.SectionResults.Single()); - Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + Assert.AreEqual(sectionCalculator.CombinedAssemblyCategoryOutput, calculator.FailureMechanismSectionCategories.Single()); } } [Test] - public void AssembleFailureMechanism_FailureMechanismIsNotRelevant_ReturnsNotApplicableCategory() - { - // Setup - var failureMechanism = new TechnicalInnovationFailureMechanism - { - IsRelevant = false - }; - - // Call - FailureMechanismAssemblyCategoryGroup category = TechnicalInnovationFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); - - // Assert - Assert.AreEqual(FailureMechanismAssemblyResultFactory.CreateNotApplicableCategory(), category); - } - - [Test] public void AssembleFailureMechanism_WithManualInputAndUseManualTrue_SetsInputOnCalculator() { // Setup @@ -562,7 +559,7 @@ } [Test] - public void AssembleFailureMechanism_WithManualInputAndUseManualFalse_SetsNoInputOnCalculator() + public void AssembleFailureMechanism_WithManualInputAndUseManualFalse_SetsCombinedInputOnCalculator() { // Setup var failureMechanism = new TechnicalInnovationFailureMechanism(); @@ -578,14 +575,13 @@ { var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call TechnicalInnovationFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, false); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = TechnicalInnovationFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - failureMechanism.SectionResults.Single()); - Assert.AreEqual(expectedAssembly, calculator.FailureMechanismSectionCategories.Single()); + Assert.AreEqual(sectionCalculator.CombinedAssemblyCategoryOutput, calculator.FailureMechanismSectionCategories.Single()); } } Index: Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/WaterPressureAsphaltCoverFailureMechanismAssemblyFactoryTest.cs =================================================================== diff -u -r396e95150a2e0ec58015956fc562b9a00e0b56a2 -r4159e6dc4ed1c6bc44773254a1b77777658f12e1 --- Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/WaterPressureAsphaltCoverFailureMechanismAssemblyFactoryTest.cs (.../WaterPressureAsphaltCoverFailureMechanismAssemblyFactoryTest.cs) (revision 396e95150a2e0ec58015956fc562b9a00e0b56a2) +++ Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/WaterPressureAsphaltCoverFailureMechanismAssemblyFactoryTest.cs (.../WaterPressureAsphaltCoverFailureMechanismAssemblyFactoryTest.cs) (revision 4159e6dc4ed1c6bc44773254a1b77777658f12e1) @@ -97,8 +97,7 @@ WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.AssembleSimpleAssessment(sectionResult); // Assert - FailureMechanismSectionAssembly calculatorOutput = calculator.SimpleAssessmentAssemblyOutput; - Assert.AreEqual(calculatorOutput.Group, actualOutput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, actualOutput); } } @@ -145,7 +144,12 @@ public void AssembleTailorMadeAssessment_WithInput_SetsInputOnCalculator() { // Setup - var sectionResult = new WaterPressureAsphaltCoverFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + var random = new Random(21); + FailureMechanismSection failureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var sectionResult = new WaterPressureAsphaltCoverFailureMechanismSectionResult(failureMechanismSection) + { + TailorMadeAssessmentResult = random.NextEnumValue() + }; using (new AssemblyToolCalculatorFactoryConfig()) { @@ -176,8 +180,7 @@ WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(sectionResult); // Assert - FailureMechanismSectionAssemblyCategoryGroup? calculatorOutput = calculator.TailorMadeAssemblyCategoryOutput; - Assert.AreEqual(calculatorOutput, actualOutput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, actualOutput); } } @@ -226,8 +229,7 @@ SimpleAssessmentResultType simpleAssessmentResult) { // Setup - var sectionResult = new WaterPressureAsphaltCoverFailureMechanismSectionResult( - FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + var sectionResult = new WaterPressureAsphaltCoverFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) { SimpleAssessmentResult = simpleAssessmentResult }; @@ -241,14 +243,9 @@ WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.AssembleCombinedAssessment(sectionResult); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly = - WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.AssembleSimpleAssessment(sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedTailorMadeAssembly = - WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(sectionResult); - - Assert.AreEqual(expectedSimpleAssembly, calculator.CombinedSimpleAssemblyGroupInput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, calculator.CombinedSimpleAssemblyGroupInput); Assert.AreEqual((FailureMechanismSectionAssemblyCategoryGroup) 0, calculator.CombinedDetailedAssemblyGroupInput); - Assert.AreEqual(expectedTailorMadeAssembly, calculator.CombinedTailorMadeAssemblyGroupInput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, calculator.CombinedTailorMadeAssemblyGroupInput); } } @@ -360,13 +357,9 @@ new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedSimpleAssembly = WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.AssembleSimpleAssessment( - sectionResult); - FailureMechanismSectionAssemblyCategoryGroup expectedTailorMadeAssembly = WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment( - sectionResult); - - Assert.AreEqual(expectedSimpleAssembly, calculator.CombinedSimpleAssemblyGroupInput); - Assert.AreEqual(expectedTailorMadeAssembly, calculator.CombinedTailorMadeAssemblyGroupInput); + Assert.AreEqual(calculator.SimpleAssessmentAssemblyOutput.Group, calculator.CombinedSimpleAssemblyGroupInput); + Assert.AreEqual((FailureMechanismSectionAssemblyCategoryGroup) 0, calculator.CombinedDetailedAssemblyGroupInput); + Assert.AreEqual(calculator.TailorMadeAssemblyCategoryOutput, calculator.CombinedTailorMadeAssemblyGroupInput); } } @@ -378,15 +371,16 @@ using (new AssemblyToolCalculatorFactoryConfig()) { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + // Call FailureMechanismSectionAssemblyCategoryGroup categoryGroup = WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( sectionResult, new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - sectionResult); - Assert.AreEqual(expectedAssembly, categoryGroup); + Assert.AreEqual(calculator.CombinedAssemblyCategoryOutput, categoryGroup); } } @@ -406,7 +400,8 @@ true); // Assert - Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), categoryGroup); + Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), + categoryGroup); } [Test] @@ -417,19 +412,22 @@ var sectionResult = new WaterPressureAsphaltCoverFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) { UseManualAssembly = true, - ManualAssemblyCategoryGroup = random.NextEnumValue(), - TailorMadeAssessmentResult = random.NextEnumValue() + ManualAssemblyCategoryGroup = random.NextEnumValue() }; - // Call - FailureMechanismSectionAssemblyCategoryGroup categoryGroup = WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( - sectionResult, - false); + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; - // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - sectionResult); - Assert.AreEqual(expectedAssembly, categoryGroup); + // Call + FailureMechanismSectionAssemblyCategoryGroup categoryGroup = WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( + sectionResult, + false); + + // Assert + Assert.AreEqual(calculator.CombinedAssemblyCategoryOutput, categoryGroup); + } } [Test] @@ -447,7 +445,7 @@ // Call TestDelegate call = () => WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( sectionResult, - new Random(39).NextBoolean()); + false); // Assert var exception = Assert.Throws(call); @@ -494,6 +492,22 @@ } [Test] + public void AssembleFailureMechanism_FailureMechanismIsNotRelevant_ReturnsNotApplicableCategory() + { + // Setup + var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism + { + IsRelevant = false + }; + + // Call + FailureMechanismAssemblyCategoryGroup category = WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); + + // Assert + Assert.AreEqual(FailureMechanismAssemblyResultFactory.CreateNotApplicableCategory(), category); + } + + [Test] public void AssembleFailureMechanism_WithoutManualInput_SetsInputOnCalculator() { // Setup @@ -507,34 +521,17 @@ { var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); // Assert - FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = - WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.AssembleCombinedAssessment(failureMechanism.SectionResults.Single()); - Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + Assert.AreEqual(sectionCalculator.CombinedAssemblyCategoryOutput, calculator.FailureMechanismSectionCategories.Single()); } } [Test] - public void AssembleFailureMechanism_FailureMechanismIsNotRelevant_ReturnsNotApplicableCategory() - { - // Setup - var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism - { - IsRelevant = false - }; - - // Call - FailureMechanismAssemblyCategoryGroup category = WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, new Random(39).NextBoolean()); - - // Assert - Assert.AreEqual(FailureMechanismAssemblyResultFactory.CreateNotApplicableCategory(), category); - } - - [Test] public void AssembleFailureMechanism_WithManualInputAndUseManualTrue_SetsInputOnCalculator() { // Setup @@ -562,7 +559,7 @@ } [Test] - public void AssembleFailureMechanism_WithManualInputAndUseManualFalse_SetsNoInputOnCalculator() + public void AssembleFailureMechanism_WithManualInputAndUseManualFalse_SetsCombinedInputOnCalculator() { // Setup var failureMechanism = new WaterPressureAsphaltCoverFailureMechanism(); @@ -578,14 +575,13 @@ { var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + FailureMechanismSectionAssemblyCalculatorStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, false); // Assert - FailureMechanismSectionAssemblyCategoryGroup expectedAssembly = WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.AssembleCombinedAssessment( - failureMechanism.SectionResults.Single()); - Assert.AreEqual(expectedAssembly, calculator.FailureMechanismSectionCategories.Single()); + Assert.AreEqual(sectionCalculator.CombinedAssemblyCategoryOutput, calculator.FailureMechanismSectionCategories.Single()); } }