Index: Ringtoets/Integration/src/Ringtoets.Integration.Data/Assembly/AssessmentSectionAssemblyFactory.cs =================================================================== diff -u -r4e3025c88acd58d4f9e63b3e0cf0c87a81db6166 -r0e747c4f97f5b778258b5406289a4942ec56f34d --- Ringtoets/Integration/src/Ringtoets.Integration.Data/Assembly/AssessmentSectionAssemblyFactory.cs (.../AssessmentSectionAssemblyFactory.cs) (revision 4e3025c88acd58d4f9e63b3e0cf0c87a81db6166) +++ Ringtoets/Integration/src/Ringtoets.Integration.Data/Assembly/AssessmentSectionAssemblyFactory.cs (.../AssessmentSectionAssemblyFactory.cs) (revision 0e747c4f97f5b778258b5406289a4942ec56f34d) @@ -53,10 +53,12 @@ /// Assembles the results of the failure mechanisms with probability within the assessment sections. /// /// The assessment section which contains the failure mechanisms to assemble for. + /// Indicator that determines whether the manual assembly should be considered when assembling the result. /// A . /// Thrown when is null. /// Thrown when cannot be created. - public static FailureMechanismAssembly AssembleFailureMechanismsWithProbability(AssessmentSection assessmentSection) + public static FailureMechanismAssembly AssembleFailureMechanismsWithProbability(AssessmentSection assessmentSection, + bool useManual) { if (assessmentSection == null) { @@ -70,7 +72,7 @@ calculatorFactory.CreateAssessmentSectionAssemblyCalculator(AssemblyToolKernelFactory.Instance); FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution; - return calculator.AssembleFailureMechanisms(GetFailureMechanismWithProbabilityAssemblyResults(assessmentSection), + return calculator.AssembleFailureMechanisms(GetFailureMechanismWithProbabilityAssemblyResults(assessmentSection, useManual), failureMechanismContribution.SignalingNorm, failureMechanismContribution.LowerLimitNorm); } @@ -88,10 +90,12 @@ /// Assembles the results of failure mechanisms without probability within the assessment section. /// /// The assessment section which contains the failure mechanisms to assemble for. + /// Indicator that determines whether the manual assembly should be considered when assembling the result. /// A . /// Thrown when is null. /// Thrown when cannot be created. - public static FailureMechanismAssemblyCategoryGroup AssembleFailureMechanismsWithoutProbability(AssessmentSection assessmentSection) + public static FailureMechanismAssemblyCategoryGroup AssembleFailureMechanismsWithoutProbability(AssessmentSection assessmentSection, + bool useManual) { if (assessmentSection == null) { @@ -104,7 +108,8 @@ IAssessmentSectionAssemblyCalculator calculator = calculatorFactory.CreateAssessmentSectionAssemblyCalculator(AssemblyToolKernelFactory.Instance); - return calculator.AssembleFailureMechanisms(GetFailureMechanismsWithoutProbabilityAssemblyResults(assessmentSection)); + return calculator.AssembleFailureMechanisms(GetFailureMechanismsWithoutProbabilityAssemblyResults(assessmentSection, + useManual)); } catch (AssessmentSectionAssemblyCalculatorException e) { @@ -120,10 +125,12 @@ /// Assembles the assessment section. /// /// The assessment section which contains the failure mechanisms to assemble for. + /// Indicator that determines whether the manual assembly should be considered when assembling the result. /// A . /// Thrown when is null. /// Thrown when cannot be created. - public static AssessmentSectionAssemblyCategoryGroup AssembleAssessmentSection(AssessmentSection assessmentSection) + public static AssessmentSectionAssemblyCategoryGroup AssembleAssessmentSection(AssessmentSection assessmentSection, + bool useManual) { if (assessmentSection == null) { @@ -136,8 +143,8 @@ IAssessmentSectionAssemblyCalculator calculator = calculatorFactory.CreateAssessmentSectionAssemblyCalculator(AssemblyToolKernelFactory.Instance); - return calculator.AssembleAssessmentSection(AssembleFailureMechanismsWithoutProbability(assessmentSection), - AssembleFailureMechanismsWithProbability(assessmentSection)); + return calculator.AssembleAssessmentSection(AssembleFailureMechanismsWithoutProbability(assessmentSection, useManual), + AssembleFailureMechanismsWithProbability(assessmentSection, useManual)); } catch (AssessmentSectionAssemblyCalculatorException e) { @@ -150,12 +157,14 @@ /// /// The assessment section that contains all /// the failure mechanism sections to assemble. + /// Indicator that determines whether the manual assembly should be considered when assembling the result. /// A collection of . /// Thrown when /// is null. /// Thrown when a /// cannot be created. - public static IEnumerable AssembleCombinedPerFailureMechanismSection(AssessmentSection assessmentSection) + public static IEnumerable AssembleCombinedPerFailureMechanismSection(AssessmentSection assessmentSection, + bool useManual) { if (assessmentSection == null) { @@ -178,7 +187,7 @@ .ToDictionary(x => x.FailureMechanism, x => x.Index); IEnumerable output = calculator.AssembleCombinedFailureMechanismSections( - CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, relevantFailureMechanisms.Keys), + CombinedAssemblyFailureMechanismSectionFactory.CreateInput(assessmentSection, relevantFailureMechanisms.Keys, useManual), assessmentSection.ReferenceLine.Length); return CombinedFailureMechanismSectionAssemblyResultFactory.Create(output, relevantFailureMechanisms, assessmentSection); @@ -193,35 +202,37 @@ } } - private static IEnumerable GetFailureMechanismWithProbabilityAssemblyResults(AssessmentSection assessmentSection) + private static IEnumerable GetFailureMechanismWithProbabilityAssemblyResults(AssessmentSection assessmentSection, + bool useManual) { return new[] { - GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.GrassCoverErosionInwards, assessmentSection), - HeightStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.HeightStructures, assessmentSection), - ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.ClosingStructures, assessmentSection), - StabilityPointStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.StabilityPointStructures, assessmentSection), - PipingFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.Piping, assessmentSection), - MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.MacroStabilityInwards, assessmentSection) + GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.GrassCoverErosionInwards, assessmentSection, useManual), + HeightStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.HeightStructures, assessmentSection, useManual), + ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.ClosingStructures, assessmentSection, useManual), + StabilityPointStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.StabilityPointStructures, assessmentSection, useManual), + PipingFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.Piping, assessmentSection, useManual), + MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.MacroStabilityInwards, assessmentSection, useManual) }; } - private static IEnumerable GetFailureMechanismsWithoutProbabilityAssemblyResults(AssessmentSection assessmentSection) + private static IEnumerable GetFailureMechanismsWithoutProbabilityAssemblyResults(AssessmentSection assessmentSection, + bool useManual) { return new[] { - StabilityStoneCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.StabilityStoneCover), - WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.WaveImpactAsphaltCover), - GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.GrassCoverErosionOutwards), - DuneErosionFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.DuneErosion), - MacroStabilityOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.MacroStabilityOutwards, assessmentSection), - MicrostabilityFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.Microstability), - WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.WaterPressureAsphaltCover), - GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.GrassCoverSlipOffOutwards), - GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.GrassCoverSlipOffInwards), - PipingStructureFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.PipingStructure), - StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.StrengthStabilityLengthwiseConstruction), - TechnicalInnovationFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.TechnicalInnovation) + StabilityStoneCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.StabilityStoneCover, useManual), + WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.WaveImpactAsphaltCover, useManual), + GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.GrassCoverErosionOutwards, useManual), + DuneErosionFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.DuneErosion, useManual), + MacroStabilityOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.MacroStabilityOutwards, assessmentSection, useManual), + MicrostabilityFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.Microstability, useManual), + WaterPressureAsphaltCoverFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.WaterPressureAsphaltCover, useManual), + GrassCoverSlipOffOutwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.GrassCoverSlipOffOutwards, useManual), + GrassCoverSlipOffInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.GrassCoverSlipOffInwards, useManual), + PipingStructureFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.PipingStructure, useManual), + StrengthStabilityLengthwiseConstructionFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.StrengthStabilityLengthwiseConstruction, useManual), + TechnicalInnovationFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.TechnicalInnovation, useManual) }; } } Index: Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/Assembly/AssessmentSectionAssemblyFactoryTest.cs =================================================================== diff -u -r77f6f342957303bd16538c7c4060ab502720045d -r0e747c4f97f5b778258b5406289a4942ec56f34d --- Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/Assembly/AssessmentSectionAssemblyFactoryTest.cs (.../AssessmentSectionAssemblyFactoryTest.cs) (revision 77f6f342957303bd16538c7c4060ab502720045d) +++ Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/Assembly/AssessmentSectionAssemblyFactoryTest.cs (.../AssessmentSectionAssemblyFactoryTest.cs) (revision 0e747c4f97f5b778258b5406289a4942ec56f34d) @@ -23,29 +23,47 @@ using System.Collections.Generic; using System.Linq; using Core.Common.TestUtil; +using Core.Common.Util.Extensions; using NUnit.Framework; using Ringtoets.AssemblyTool.Data; using Ringtoets.AssemblyTool.KernelWrapper.Calculators; using Ringtoets.AssemblyTool.KernelWrapper.Calculators.Assembly; using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators; using Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Calculators.Assembly; +using Ringtoets.ClosingStructures.Data; +using Ringtoets.Common.Data.AssemblyTool; using Ringtoets.Common.Data.AssessmentSection; using Ringtoets.Common.Data.Contribution; using Ringtoets.Common.Data.Exceptions; using Ringtoets.Common.Data.FailureMechanism; +using Ringtoets.Common.Data.TestUtil; +using Ringtoets.Common.Primitives; +using Ringtoets.DuneErosion.Data; +using Ringtoets.GrassCoverErosionInwards.Data; +using Ringtoets.GrassCoverErosionOutwards.Data; +using Ringtoets.HeightStructures.Data; using Ringtoets.Integration.Data.Assembly; +using Ringtoets.Integration.Data.StandAlone; +using Ringtoets.Integration.Data.StandAlone.SectionResults; using Ringtoets.Integration.TestUtil; +using Ringtoets.MacroStabilityInwards.Data; +using Ringtoets.Piping.Data; +using Ringtoets.StabilityPointStructures.Data; +using Ringtoets.StabilityStoneCover.Data; +using Ringtoets.WaveImpactAsphaltCover.Data; namespace Ringtoets.Integration.Data.Test.Assembly { [TestFixture] public class AssessmentSectionAssemblyFactoryTest { + #region Assemble Failure Mechanisms With Probability + [Test] public void AssembleFailureMechanismsWithProbability_AssessmentSectionNull_ThrowsArgumentNullException() { // Call - TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(null); + TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(null, new Random(39).NextBoolean()); // Assert var exception = Assert.Throws(call); @@ -61,15 +79,16 @@ using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; - FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorfactory.LastCreatedFailureMechanismAssemblyCalculator; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; failureMechanismAssemblyCalculator.FailureMechanismAssemblyOutput = new FailureMechanismAssembly( random.NextDouble(), random.NextEnumValue()); - AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator; + AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; // Call - AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(assessmentSection); + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(assessmentSection, + false); // Assert FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution; @@ -91,13 +110,14 @@ using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; - AssessmentSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; calculator.AssembleFailureMechanismsAssemblyOutput = new FailureMechanismAssembly( random.NextDouble(), random.NextEnumValue()); // Call - FailureMechanismAssembly output = AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(assessmentSection); + FailureMechanismAssembly output = AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(assessmentSection, + new Random(39).NextBoolean()); // Assert Assert.AreSame(calculator.AssembleFailureMechanismsAssemblyOutput, output); @@ -110,12 +130,13 @@ // Setup using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; - AssessmentSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call - TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(CreateAssessmentSection()); + TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(CreateAssessmentSection(), + new Random(39).NextBoolean()); // Assert var exception = Assert.Throws(call); @@ -131,12 +152,13 @@ // Setup using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; - FailureMechanismAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismAssemblyCalculator; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call - TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(CreateAssessmentSection()); + TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(CreateAssessmentSection(), + new Random(39).NextBoolean()); // Assert var exception = Assert.Throws(call); @@ -146,11 +168,344 @@ } } + #region Manual Assembly Used + + #region Piping + [Test] - public void AssemblyFailureMechanismsWithoutProbability_AssessmentSectionNull_ThrowsArgumentNullException() + public void GivenAssessmentSectionWithPipingConfigured_WhenAssemblingFailureMechanismsWithProbabilityAndUseManualTrue_ThenInputSetOnCalculator() { + // Given + AssessmentSection assessmentSection = CreateAssessmentSection(); + PipingFailureMechanism failureMechanism = assessmentSection.Piping; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + PipingFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyProbability = true; + double probability = new Random(39).NextDouble(); + sectionResult.ManualAssemblyProbability = probability; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(assessmentSection, true); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + Assert.AreEqual(probability, failureMechanismSectionAssemblyCalculator.ManualAssemblyProbabilityInput); + } + } + + [Test] + public void GivenAssessmentSectionWithPipingConfigured_WhenAssemblingFailureMechanismsWithProbabilityAndUseManualFalse_ThenNoInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateAssessmentSection(); + PipingFailureMechanism failureMechanism = assessmentSection.Piping; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + PipingFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyProbability = true; + double probability = new Random(39).NextDouble(); + sectionResult.ManualAssemblyProbability = probability; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(assessmentSection, false); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + Assert.IsNull(failureMechanismSectionAssemblyCalculator.ManualAssemblyAssemblyOutput); + } + } + + #endregion + + #region MacroStabilityInwards + + [Test] + public void GivenAssessmentSectionWithMacroStabilityInwardsConfigured_WhenAssemblingFailureMechanismsWithProbabilityAndUseManualTrue_ThenInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateAssessmentSection(); + MacroStabilityInwardsFailureMechanism failureMechanism = assessmentSection.MacroStabilityInwards; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + MacroStabilityInwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyProbability = true; + double probability = new Random(39).NextDouble(); + sectionResult.ManualAssemblyProbability = probability; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(assessmentSection, true); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + Assert.AreEqual(probability, failureMechanismSectionAssemblyCalculator.ManualAssemblyProbabilityInput); + } + } + + [Test] + public void GivenAssessmentSectionWithMacroStabilityInwardsConfigured_WhenAssemblingFailureMechanismsWithProbabilityAndUseManualFalse_ThenNoInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateAssessmentSection(); + MacroStabilityInwardsFailureMechanism failureMechanism = assessmentSection.MacroStabilityInwards; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + MacroStabilityInwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyProbability = true; + double probability = new Random(39).NextDouble(); + sectionResult.ManualAssemblyProbability = probability; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(assessmentSection, false); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + Assert.IsNull(failureMechanismSectionAssemblyCalculator.ManualAssemblyAssemblyOutput); + } + } + + #endregion + + #region GrassCoverErosionInwards + + [Test] + public void GivenAssessmentSectionWithGrassCoverErosionInwardsConfigured_WhenAssemblingFailureMechanismsWithProbabilityAndUseManualTrue_ThenInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateAssessmentSection(); + GrassCoverErosionInwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverErosionInwards; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + GrassCoverErosionInwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyProbability = true; + double probability = new Random(39).NextDouble(); + sectionResult.ManualAssemblyProbability = probability; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(assessmentSection, true); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + Assert.AreEqual(probability, failureMechanismSectionAssemblyCalculator.ManualAssemblyProbabilityInput); + } + } + + [Test] + public void GivenAssessmentSectionWithGrassCoverErosionInwardsConfigured_WhenAssemblingFailureMechanismsWithProbabilityAndUseManualFalse_ThenNoInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateAssessmentSection(); + GrassCoverErosionInwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverErosionInwards; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + GrassCoverErosionInwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyProbability = true; + double probability = new Random(39).NextDouble(); + sectionResult.ManualAssemblyProbability = probability; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(assessmentSection, false); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + Assert.IsNull(failureMechanismSectionAssemblyCalculator.ManualAssemblyAssemblyOutput); + } + } + + #endregion + + #region ClosingStructures + + [Test] + public void GivenAssessmentSectionWithClosingStructuresConfigured_WhenAssemblingFailureMechanismsWithProbabilityAndUseManualTrue_ThenInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateAssessmentSection(); + ClosingStructuresFailureMechanism failureMechanism = assessmentSection.ClosingStructures; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + ClosingStructuresFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyProbability = true; + double probability = new Random(39).NextDouble(); + sectionResult.ManualAssemblyProbability = probability; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(assessmentSection, true); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + Assert.AreEqual(probability, failureMechanismSectionAssemblyCalculator.ManualAssemblyProbabilityInput); + } + } + + [Test] + public void GivenAssessmentSectionWithClosingStructuresConfigured_WhenAssemblingFailureMechanismsWithProbabilityAndUseManualFalse_ThenNoInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateAssessmentSection(); + ClosingStructuresFailureMechanism failureMechanism = assessmentSection.ClosingStructures; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + ClosingStructuresFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyProbability = true; + double probability = new Random(39).NextDouble(); + sectionResult.ManualAssemblyProbability = probability; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(assessmentSection, false); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + Assert.IsNull(failureMechanismSectionAssemblyCalculator.ManualAssemblyAssemblyOutput); + } + } + + #endregion + + #region HeightStructures + + [Test] + public void GivenAssessmentSectionWithHeightStructuresConfigured_WhenAssemblingFailureMechanismsWithProbabilityAndUseManualTrue_ThenInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateAssessmentSection(); + HeightStructuresFailureMechanism failureMechanism = assessmentSection.HeightStructures; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + HeightStructuresFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyProbability = true; + double probability = new Random(39).NextDouble(); + sectionResult.ManualAssemblyProbability = probability; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(assessmentSection, true); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + Assert.AreEqual(probability, failureMechanismSectionAssemblyCalculator.ManualAssemblyProbabilityInput); + } + } + + [Test] + public void GivenAssessmentSectionWithHeightStructuresConfigured_WhenAssemblingFailureMechanismsWithProbabilityAndUseManualFalse_ThenNoInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateAssessmentSection(); + HeightStructuresFailureMechanism failureMechanism = assessmentSection.HeightStructures; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + HeightStructuresFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyProbability = true; + double probability = new Random(39).NextDouble(); + sectionResult.ManualAssemblyProbability = probability; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(assessmentSection, false); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + Assert.IsNull(failureMechanismSectionAssemblyCalculator.ManualAssemblyAssemblyOutput); + } + } + + #endregion + + #region StabilityPointStructures + + [Test] + public void GivenAssessmentSectionWithStabilityPointStructuresConfigured_WhenAssemblingFailureMechanismsWithProbabilityAndUseManualTrue_ThenInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateAssessmentSection(); + StabilityPointStructuresFailureMechanism failureMechanism = assessmentSection.StabilityPointStructures; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + StabilityPointStructuresFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyProbability = true; + double probability = new Random(39).NextDouble(); + sectionResult.ManualAssemblyProbability = probability; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(assessmentSection, true); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + Assert.AreEqual(probability, failureMechanismSectionAssemblyCalculator.ManualAssemblyProbabilityInput); + } + } + + [Test] + public void GivenAssessmentSectionWithStabilityPointStructuresConfigured_WhenAssemblingFailureMechanismsWithProbabilityAndUseManualFalse_ThenNoInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateAssessmentSection(); + StabilityPointStructuresFailureMechanism failureMechanism = assessmentSection.StabilityPointStructures; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + StabilityPointStructuresFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyProbability = true; + double probability = new Random(39).NextDouble(); + sectionResult.ManualAssemblyProbability = probability; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithProbability(assessmentSection, false); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub failureMechanismSectionAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + Assert.IsNull(failureMechanismSectionAssemblyCalculator.ManualAssemblyAssemblyOutput); + } + } + + #endregion + + #endregion + + #endregion + + #region Assemble Failure Mechanisms Without Probability + + [Test] + public void AssembleFailureMechanismsWithoutProbability_AssessmentSectionNull_ThrowsArgumentNullException() + { // Call - TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(null); + TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(null, + new Random(39).NextBoolean()); // Assert var exception = Assert.Throws(call); @@ -166,14 +521,14 @@ using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; - FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorfactory.LastCreatedFailureMechanismAssemblyCalculator; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; failureMechanismAssemblyCalculator.FailureMechanismAssemblyCategoryGroupOutput = random.NextEnumValue(); - AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator; + AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; // Call - AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection); + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, false); // Assert AssertGroup3And4FailureMechanismInputs(assessmentSection, @@ -191,12 +546,12 @@ using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; - AssessmentSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; calculator.AssembleFailureMechanismsAssemblyCategoryGroupOutput = random.NextEnumValue(); // Call - FailureMechanismAssemblyCategoryGroup output = AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection); + FailureMechanismAssemblyCategoryGroup output = AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, false); // Assert Assert.AreEqual(calculator.AssembleFailureMechanismsAssemblyCategoryGroupOutput, output); @@ -209,12 +564,13 @@ // Setup using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; - AssessmentSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call - TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(CreateAssessmentSection()); + TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(CreateAssessmentSection(), + new Random(39).NextBoolean()); // Assert var exception = Assert.Throws(call); @@ -230,12 +586,13 @@ // Setup using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; - FailureMechanismAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismAssemblyCalculator; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call - TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(CreateAssessmentSection()); + TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(CreateAssessmentSection(), + new Random(39).NextBoolean()); // Assert var exception = Assert.Throws(call); @@ -245,11 +602,682 @@ } } + #region Manual Assembly Used + + #region DuneErosion + [Test] + public void GivenAssessmentSectionWithDuneErosionConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualTrue_ThenInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + DuneErosionFailureMechanism failureMechanism = assessmentSection.DuneErosion; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + DuneErosionFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = FailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, true); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(sectionResult.ManualAssemblyCategoryGroup, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void GivenAssessmentSectionWithDuneErosionConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualFalse_ThenNoInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + DuneErosionFailureMechanism failureMechanism = assessmentSection.DuneErosion; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + DuneErosionFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = FailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, false); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.Iv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + #endregion + + #region GrassCoverErosionOutwards + + [Test] + public void GivenAssessmentSectionWithGrassCoverErosionOutwardsConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualTrue_ThenInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + GrassCoverErosionOutwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverErosionOutwards; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + GrassCoverErosionOutwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = FailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, true); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(sectionResult.ManualAssemblyCategoryGroup, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void GivenAssessmentSectionWithGrassCoverErosionOutwardsConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualFalse_ThenNoInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + GrassCoverErosionOutwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverErosionOutwards; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + GrassCoverErosionOutwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = FailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, false); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.Iv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + #endregion + + #region StabilityStoneCover + + [Test] + public void GivenAssessmentSectionWithStabilityStoneCoverConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualTrue_ThenInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + StabilityStoneCoverFailureMechanism failureMechanism = assessmentSection.StabilityStoneCover; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + StabilityStoneCoverFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = FailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, true); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(sectionResult.ManualAssemblyCategoryGroup, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void GivenAssessmentSectionWithStabilityStoneCoverConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualFalse_ThenNoInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + StabilityStoneCoverFailureMechanism failureMechanism = assessmentSection.StabilityStoneCover; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + StabilityStoneCoverFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = FailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, false); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.Iv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + #endregion + + #region WaveImpactAsphaltCover + + [Test] + public void GivenAssessmentSectionWithWaveImpactAsphaltCoverConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualTrue_ThenInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + WaveImpactAsphaltCoverFailureMechanism failureMechanism = assessmentSection.WaveImpactAsphaltCover; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + WaveImpactAsphaltCoverFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = FailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, true); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(sectionResult.ManualAssemblyCategoryGroup, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void GivenAssessmentSectionWithWaveImpactAsphaltCoverConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualFalse_ThenNoInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + WaveImpactAsphaltCoverFailureMechanism failureMechanism = assessmentSection.WaveImpactAsphaltCover; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + WaveImpactAsphaltCoverFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = FailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, false); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.Iv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + #endregion + + #region GrassCoverSlipOffInwards + + [Test] + public void GivenAssessmentSectionWithGrassCoverSlipOffInwardsConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualTrue_ThenInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + GrassCoverSlipOffInwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverSlipOffInwards; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + GrassCoverSlipOffInwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, true); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), + failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void GivenAssessmentSectionWithGrassCoverSlipOffInwardsConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualFalse_ThenNoInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + GrassCoverSlipOffInwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverSlipOffInwards; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + GrassCoverSlipOffInwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, false); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + #endregion + + #region GrassCoverSlipOffOutwards + + [Test] + public void GivenAssessmentSectionWithGrassCoverSlipOffOutwardsConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualTrue_ThenInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + GrassCoverSlipOffOutwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverSlipOffOutwards; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + GrassCoverSlipOffOutwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, true); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), + failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void GivenAssessmentSectionWithGrassCoverSlipOffOutwardsConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualFalse_ThenNoInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + GrassCoverSlipOffOutwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverSlipOffOutwards; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + GrassCoverSlipOffOutwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, false); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + #endregion + + #region MacroStabilityOutwards + + [Test] + public void GivenAssessmentSectionWithMacroStabilityOutwardsConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualTrue_ThenInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + MacroStabilityOutwardsFailureMechanism failureMechanism = assessmentSection.MacroStabilityOutwards; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + MacroStabilityOutwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, true); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), + failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void GivenAssessmentSectionWithMacroStabilityOutwardsConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualFalse_ThenNoInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + MacroStabilityOutwardsFailureMechanism failureMechanism = assessmentSection.MacroStabilityOutwards; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + MacroStabilityOutwardsFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, false); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.VIv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + #endregion + + #region Microstability + + [Test] + public void GivenAssessmentSectionWithMicrostabilityConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualTrue_ThenInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + MicrostabilityFailureMechanism failureMechanism = assessmentSection.Microstability; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + MicrostabilityFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, true); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), + failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void GivenAssessmentSectionWithMicrostabilityConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualFalse_ThenNoInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + MicrostabilityFailureMechanism failureMechanism = assessmentSection.Microstability; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + MicrostabilityFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, false); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + #endregion + + #region PipingStructure + + [Test] + public void GivenAssessmentSectionWithPipingStructureConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualTrue_ThenInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + PipingStructureFailureMechanism failureMechanism = assessmentSection.PipingStructure; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + PipingStructureFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, true); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), + failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void GivenAssessmentSectionWithPipingStructureConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualFalse_ThenNoInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + PipingStructureFailureMechanism failureMechanism = assessmentSection.PipingStructure; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + PipingStructureFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, false); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + #endregion + + #region StrengthStabilityLengthwiseConstruction + + [Test] + public void GivenAssessmentSectionWithStrengthStabilityLengthwiseConstructionConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualTrue_ThenInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + StrengthStabilityLengthwiseConstructionFailureMechanism failureMechanism = assessmentSection.StrengthStabilityLengthwiseConstruction; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + StrengthStabilityLengthwiseConstructionFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, true); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), + failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void GivenAssessmentSectionWithStrengthStabilityLengthwiseConstructionConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualFalse_ThenNoInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + StrengthStabilityLengthwiseConstructionFailureMechanism failureMechanism = assessmentSection.StrengthStabilityLengthwiseConstruction; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + StrengthStabilityLengthwiseConstructionFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, false); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + #endregion + + #region TechnicalInnovation + + [Test] + public void GivenAssessmentSectionWithTechnicalInnovationConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualTrue_ThenInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + TechnicalInnovationFailureMechanism failureMechanism = assessmentSection.TechnicalInnovation; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + TechnicalInnovationFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, true); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), + failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void GivenAssessmentSectionWithTechnicalInnovationConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualFalse_ThenNoInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + TechnicalInnovationFailureMechanism failureMechanism = assessmentSection.TechnicalInnovation; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + TechnicalInnovationFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, false); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + #endregion + + #region WaterPressureAsphaltCover + + [Test] + public void GivenAssessmentSectionWithWaterPressureAsphaltCoverConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualTrue_ThenInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + WaterPressureAsphaltCoverFailureMechanism failureMechanism = assessmentSection.WaterPressureAsphaltCover; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + WaterPressureAsphaltCoverFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, true); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(ManualFailureMechanismSectionAssemblyCategoryGroupConverter.Convert(sectionResult.ManualAssemblyCategoryGroup), + failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void GivenAssessmentSectionWithWaterPressureAsphaltCoverConfigured_WhenAssemblingFailureMechanismsWithoutProbabilityAndUseManualFalse_ThenNoInputSetOnCalculator() + { + // Given + AssessmentSection assessmentSection = CreateIrrelevantAssessmentSection(); + WaterPressureAsphaltCoverFailureMechanism failureMechanism = assessmentSection.WaterPressureAsphaltCover; + failureMechanism.IsRelevant = true; + FailureMechanismTestHelper.AddSections(failureMechanism, 1); + + WaterPressureAsphaltCoverFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single(); + sectionResult.UseManualAssemblyCategoryGroup = true; + sectionResult.ManualAssemblyCategoryGroup = ManualFailureMechanismSectionAssemblyCategoryGroup.Vv; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + // When + AssessmentSectionAssemblyFactory.AssembleFailureMechanismsWithoutProbability(assessmentSection, false); + + // Then + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.IIv, failureMechanismAssemblyCalculator.FailureMechanismSectionCategories.Single()); + } + } + + #endregion + + private static AssessmentSection CreateIrrelevantAssessmentSection() + { + AssessmentSection assessmentSection = CreateAssessmentSection(); + assessmentSection.GetFailureMechanisms().ForEachElementDo(fm => fm.IsRelevant = false); + return assessmentSection; + } + + #endregion + + #endregion + + #region Assemble Assessment Section + + [Test] public void AssembleAssessmentSection_AssessmentSectionNull_ThrowsArgumentNullException() { // Call - TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleAssessmentSection(null); + TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleAssessmentSection(null, new Random(39).NextBoolean()); // Assert var exception = Assert.Throws(call); @@ -265,16 +1293,16 @@ using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; - FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorfactory.LastCreatedFailureMechanismAssemblyCalculator; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; - AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator; + AssessmentSectionAssemblyCalculatorStub assessmentSectionAssemblyCalculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; assessmentSectionAssemblyCalculator.AssembleFailureMechanismsAssemblyOutput = new FailureMechanismAssembly( random.NextDouble(), random.NextEnumValue()); assessmentSectionAssemblyCalculator.AssembleFailureMechanismsAssemblyCategoryGroupOutput = random.NextEnumValue(); // Call - AssessmentSectionAssemblyFactory.AssembleAssessmentSection(assessmentSection); + AssessmentSectionAssemblyFactory.AssembleAssessmentSection(assessmentSection, false); // Assert AssertGroup1And2FailureMechanismInputs(assessmentSection, @@ -301,14 +1329,14 @@ using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; - AssessmentSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; calculator.AssembleFailureMechanismsAssemblyOutput = new FailureMechanismAssembly( random.NextDouble(), random.NextEnumValue()); calculator.AssembleAssessmentSectionCategoryGroupOutput = random.NextEnumValue(); // Call - AssessmentSectionAssemblyCategoryGroup output = AssessmentSectionAssemblyFactory.AssembleAssessmentSection(assessmentSection); + AssessmentSectionAssemblyCategoryGroup output = AssessmentSectionAssemblyFactory.AssembleAssessmentSection(assessmentSection, false); // Assert Assert.AreEqual(calculator.AssembleAssessmentSectionCategoryGroupOutput, output); @@ -321,12 +1349,13 @@ // Setup using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; - AssessmentSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call - TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleAssessmentSection(CreateAssessmentSection()); + TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleAssessmentSection(CreateAssessmentSection(), + new Random(39).NextBoolean()); // Assert var exception = Assert.Throws(call); @@ -342,12 +1371,13 @@ // Setup using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; - FailureMechanismAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismAssemblyCalculator; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call - TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleAssessmentSection(CreateAssessmentSection()); + TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleAssessmentSection(CreateAssessmentSection(), + new Random(39).NextBoolean()); // Assert var exception = Assert.Throws(call); @@ -357,11 +1387,16 @@ } } + #endregion + + #region Assemble Combined Per Failure Mechanism Section + [Test] public void AssembleCombinedPerFailureMechanismSection_AssessmentSectionNull_ThrowsArgumentNullException() { // Call - TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(null); + TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(null, + new Random(39).NextBoolean()); // Assert var exception = Assert.Throws(call); @@ -377,17 +1412,17 @@ using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; - AssessmentSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; calculator.CombinedFailureMechanismSectionAssemblyOutput = new CombinedFailureMechanismSectionAssembly[0]; // Call - AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection); + AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection, false); // Assert IEnumerable[] actualInput = calculator.CombinedFailureMechanismSectionsInput.ToArray(); IEnumerable[] expectedInput = CombinedAssemblyFailureMechanismSectionFactory.CreateInput( - assessmentSection, assessmentSection.GetFailureMechanisms()).ToArray(); + assessmentSection, assessmentSection.GetFailureMechanisms(), false).ToArray(); Assert.AreEqual(expectedInput.Length, actualInput.Length); for (var i = 0; i < expectedInput.Length; i++) @@ -415,16 +1450,17 @@ using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; - AssessmentSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; calculator.CombinedFailureMechanismSectionAssemblyOutput = new[] { CreateCombinedFailureMechanismSectionAssembly(assessmentSection, 20), CreateCombinedFailureMechanismSectionAssembly(assessmentSection, 21) }; // Call - CombinedFailureMechanismSectionAssemblyResult[] output = AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection) + CombinedFailureMechanismSectionAssemblyResult[] output = AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection, + false) .ToArray(); // Assert @@ -477,12 +1513,13 @@ using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; - AssessmentSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedAssessmentSectionAssemblyCalculator; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + AssessmentSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedAssessmentSectionAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call - TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection); + TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection, + new Random(39).NextBoolean()); // Assert var exception = Assert.Throws(call); @@ -502,12 +1539,13 @@ using (new AssemblyToolCalculatorFactoryConfig()) { - var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; - FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call - TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection); + TestDelegate call = () => AssessmentSectionAssemblyFactory.AssembleCombinedPerFailureMechanismSection(assessmentSection, + new Random(39).NextBoolean()); // Assert var exception = Assert.Throws(call); @@ -517,6 +1555,10 @@ } } + #endregion + + #region Helpers + private static CombinedFailureMechanismSectionAssembly CreateCombinedFailureMechanismSectionAssembly(AssessmentSection assessmentSection, int seed) { var random = new Random(seed); @@ -590,5 +1632,7 @@ assessmentSection.TechnicalInnovation }; } + + #endregion } } \ No newline at end of file