Index: Riskeer/Common/src/Riskeer.Common.Data/AssemblyTool/FailureMechanismSectionAssemblyResultFactory.cs =================================================================== diff -u --- Riskeer/Common/src/Riskeer.Common.Data/AssemblyTool/FailureMechanismSectionAssemblyResultFactory.cs (revision 0) +++ Riskeer/Common/src/Riskeer.Common.Data/AssemblyTool/FailureMechanismSectionAssemblyResultFactory.cs (revision ec2c838182ed237b3abd753347a861857129331b) @@ -0,0 +1,291 @@ +// Copyright (C) Stichting Deltares 2021. All rights reserved. +// +// This file is part of Riskeer. +// +// Riskeer is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using Riskeer.AssemblyTool.Data; +using Riskeer.AssemblyTool.KernelWrapper.Calculators; +using Riskeer.AssemblyTool.KernelWrapper.Calculators.Assembly; +using Riskeer.AssemblyTool.KernelWrapper.Kernels; +using Riskeer.Common.Data.AssessmentSection; +using Riskeer.Common.Data.Contribution; +using Riskeer.Common.Data.Exceptions; +using Riskeer.Common.Data.FailureMechanism; +using Riskeer.Common.Primitives; + +namespace Riskeer.Common.Data.AssemblyTool +{ + /// + /// Factory for creating assembly results for a failure mechanism section. + /// + public static class FailureMechanismSectionAssemblyResultFactory + { + /// + /// Assembles a failure mechanism section result based on the input arguments. + /// + /// The section result to assemble for. + /// The to assemble with. + /// The + /// to assemble with. + /// Indicator whether to use the length effect or not. + /// The N value for the section. + /// A . + /// Thrown when any , + /// or is null. + /// Thrown when the section could not be successfully assembled. + public static FailureMechanismSectionAssemblyResult AssembleSection( + AdoptableWithProfileProbabilityFailureMechanismSectionResult sectionResult, IAssessmentSection assessmentSection, + IFailureMechanismSectionResultCalculateProbabilityStrategy calculateProbabilityStrategy, + bool useLengthEffect, double sectionN) + { + if (sectionResult == null) + { + throw new ArgumentNullException(nameof(sectionResult)); + } + + if (assessmentSection == null) + { + throw new ArgumentNullException(nameof(assessmentSection)); + } + + if (calculateProbabilityStrategy == null) + { + throw new ArgumentNullException(nameof(calculateProbabilityStrategy)); + } + + bool adopt = sectionResult.InitialFailureMechanismResultType == AdoptableInitialFailureMechanismResultType.Adopt; + double initialFailureMechanismResultSectionProbability = + adopt + ? calculateProbabilityStrategy.CalculateSectionProbability() + : sectionResult.ManualInitialFailureMechanismResultSectionProbability; + + FailureMechanismSectionAssemblyInput input; + + if (useLengthEffect) + { + double initialFailureMechanismResultProfileProbability = + adopt + ? calculateProbabilityStrategy.CalculateProfileProbability() + : sectionResult.ManualInitialFailureMechanismResultProfileProbability; + + input = CreateInput( + assessmentSection, sectionResult.IsRelevant, sectionResult.InitialFailureMechanismResultType, + initialFailureMechanismResultProfileProbability, initialFailureMechanismResultSectionProbability, sectionResult.FurtherAnalysisType, + sectionResult.RefinedProfileProbability, sectionResult.RefinedSectionProbability, sectionResult.ProbabilityRefinementType, sectionN); + } + else + { + bool hasProbabilitySpecified = sectionResult.InitialFailureMechanismResultType != AdoptableInitialFailureMechanismResultType.NoFailureProbability; + + input = CreateInput( + assessmentSection, sectionResult.IsRelevant, initialFailureMechanismResultSectionProbability, + sectionResult.FurtherAnalysisType, sectionResult.RefinedSectionProbability, hasProbabilitySpecified); + } + + return PerformAssembly(input); + } + + /// + /// Assembles a failure mechanism section result based on the input arguments. + /// + /// The section result to assemble for. + /// The to assemble with. + /// The to calculate the probability with. + /// A . + /// Thrown when any argument is null. + /// Thrown when the section could not be successfully assembled. + public static FailureMechanismSectionAssemblyResult AssembleSection( + AdoptableFailureMechanismSectionResult sectionResult, IAssessmentSection assessmentSection, Func calculateProbabilityFunc) + { + if (sectionResult == null) + { + throw new ArgumentNullException(nameof(sectionResult)); + } + + if (assessmentSection == null) + { + throw new ArgumentNullException(nameof(assessmentSection)); + } + + if (calculateProbabilityFunc == null) + { + throw new ArgumentNullException(nameof(calculateProbabilityFunc)); + } + + double initialFailureMechanismResultSectionProbability = + sectionResult.InitialFailureMechanismResultType == AdoptableInitialFailureMechanismResultType.Adopt + ? calculateProbabilityFunc() + : sectionResult.ManualInitialFailureMechanismResultSectionProbability; + + bool hasProbabilitySpecified = sectionResult.InitialFailureMechanismResultType != AdoptableInitialFailureMechanismResultType.NoFailureProbability; + + FailureMechanismSectionAssemblyInput input = CreateInput( + assessmentSection, sectionResult.IsRelevant, initialFailureMechanismResultSectionProbability, + sectionResult.FurtherAnalysisType, sectionResult.RefinedSectionProbability, hasProbabilitySpecified); + + return PerformAssembly(input); + } + + /// + /// Assembles a failure mechanism section result based on the input arguments. + /// + /// The section result to assemble for. + /// The to assemble with. + /// Indicator whether to use the length effect or not. + /// A . + /// Thrown when any or + /// is null. + /// Thrown when the section could not be successfully assembled. + public static FailureMechanismSectionAssemblyResult AssembleSection( + NonAdoptableWithProfileProbabilityFailureMechanismSectionResult sectionResult, IAssessmentSection assessmentSection, + bool useLengthEffect) + { + if (sectionResult == null) + { + throw new ArgumentNullException(nameof(sectionResult)); + } + + if (assessmentSection == null) + { + throw new ArgumentNullException(nameof(assessmentSection)); + } + + bool hasProbabilitySpecified = sectionResult.InitialFailureMechanismResultType != NonAdoptableInitialFailureMechanismResultType.NoFailureProbability; + + FailureMechanismSectionAssemblyInput input = useLengthEffect + ? CreateInput( + assessmentSection, sectionResult.IsRelevant, hasProbabilitySpecified, + sectionResult.ManualInitialFailureMechanismResultProfileProbability, + sectionResult.ManualInitialFailureMechanismResultSectionProbability, + sectionResult.FurtherAnalysisType, sectionResult.RefinedProfileProbability, + sectionResult.RefinedSectionProbability) + : CreateInput( + assessmentSection, sectionResult.IsRelevant, + sectionResult.ManualInitialFailureMechanismResultSectionProbability, + sectionResult.FurtherAnalysisType, sectionResult.RefinedSectionProbability, + hasProbabilitySpecified); + + return PerformAssembly(input); + } + + /// + /// Assembles a failure mechanism section result based on the input arguments. + /// + /// The section result to assemble for. + /// The to assemble with. + /// A . + /// Thrown when any parameter is null. + /// Thrown when the section could not be successfully assembled. + public static FailureMechanismSectionAssemblyResult AssembleSection( + NonAdoptableFailureMechanismSectionResult sectionResult, IAssessmentSection assessmentSection) + { + if (sectionResult == null) + { + throw new ArgumentNullException(nameof(sectionResult)); + } + + if (assessmentSection == null) + { + throw new ArgumentNullException(nameof(assessmentSection)); + } + + bool hasProbabilitySpecified = sectionResult.InitialFailureMechanismResultType != NonAdoptableInitialFailureMechanismResultType.NoFailureProbability; + + FailureMechanismSectionAssemblyInput input = CreateInput( + assessmentSection, sectionResult.IsRelevant, sectionResult.ManualInitialFailureMechanismResultSectionProbability, + sectionResult.FurtherAnalysisType, sectionResult.RefinedSectionProbability, hasProbabilitySpecified); + + return PerformAssembly(input); + } + + private static FailureMechanismSectionAssemblyInput CreateInput( + IAssessmentSection assessmentSection, bool isRelevant, double initialSectionProbability, + FailureMechanismSectionResultFurtherAnalysisType furtherAnalysisType, + double refinedSectionProbability, bool hasProbabilitySpecified) + { + FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution; + return new FailureMechanismSectionAssemblyInput( + failureMechanismContribution.LowerLimitNorm, failureMechanismContribution.SignalingNorm, + isRelevant, hasProbabilitySpecified, initialSectionProbability, furtherAnalysisType, refinedSectionProbability); + } + + private static FailureMechanismSectionWithProfileProbabilityAssemblyInput CreateInput( + IAssessmentSection assessmentSection, + bool isRelevant, AdoptableInitialFailureMechanismResultType initialFailureMechanismResultType, + double initialProfileProbability, double initialSectionProbability, + FailureMechanismSectionResultFurtherAnalysisType furtherAnalysisType, + double refinedProfileProbability, double refinedSectionProbability, + ProbabilityRefinementType probabilityRefinementType, double sectionN) + { + if (probabilityRefinementType == ProbabilityRefinementType.Profile) + { + refinedSectionProbability = refinedProfileProbability * sectionN; + } + + if (probabilityRefinementType == ProbabilityRefinementType.Section) + { + refinedProfileProbability = refinedSectionProbability / sectionN; + } + + bool hasProbabilitySpecified = initialFailureMechanismResultType != AdoptableInitialFailureMechanismResultType.NoFailureProbability; + + return CreateInput(assessmentSection, isRelevant, hasProbabilitySpecified, + initialProfileProbability, initialSectionProbability, + furtherAnalysisType, refinedProfileProbability, refinedSectionProbability); + } + + private static FailureMechanismSectionWithProfileProbabilityAssemblyInput CreateInput( + IAssessmentSection assessmentSection, + bool isRelevant, bool hasProbabilitySpecified, + double initialProfileProbability, double initialSectionProbability, + FailureMechanismSectionResultFurtherAnalysisType furtherAnalysisType, + double refinedProfileProbability, double refinedSectionProbability) + { + FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution; + return new FailureMechanismSectionWithProfileProbabilityAssemblyInput( + failureMechanismContribution.LowerLimitNorm, failureMechanismContribution.SignalingNorm, + isRelevant, hasProbabilitySpecified, initialProfileProbability, initialSectionProbability, + furtherAnalysisType, refinedProfileProbability, refinedSectionProbability); + } + + /// + /// Performs the assembly based on the . + /// + /// The input to use in the assembly. + /// A . + /// Thrown when the section could not be successfully assembled. + private static FailureMechanismSectionAssemblyResult PerformAssembly(FailureMechanismSectionAssemblyInput input) + { + IFailureMechanismSectionAssemblyCalculator calculator = AssemblyToolCalculatorFactory.Instance.CreateFailureMechanismSectionAssemblyCalculator( + AssemblyToolKernelFactory.Instance); + + try + { + return input is FailureMechanismSectionWithProfileProbabilityAssemblyInput probabilityAssemblyInput + ? calculator.AssembleFailureMechanismSection(probabilityAssemblyInput) + : calculator.AssembleFailureMechanismSection(input); + } + catch (FailureMechanismSectionAssemblyCalculatorException e) + { + throw new AssemblyException(e.Message, e); + } + } + } +} \ No newline at end of file Fisheye: Tag ec2c838182ed237b3abd753347a861857129331b refers to a dead (removed) revision in file `Riskeer/Common/src/Riskeer.Common.Data/AssemblyTool/FailureMechanismSectionResultAssemblyFactory.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Riskeer/Common/src/Riskeer.Common.Data/Structures/StructuresFailureMechanismAssemblyFactory.cs =================================================================== diff -u -r24ca14cba20d34921dea3b900f7f2e895f85bfaa -rec2c838182ed237b3abd753347a861857129331b --- Riskeer/Common/src/Riskeer.Common.Data/Structures/StructuresFailureMechanismAssemblyFactory.cs (.../StructuresFailureMechanismAssemblyFactory.cs) (revision 24ca14cba20d34921dea3b900f7f2e895f85bfaa) +++ Riskeer/Common/src/Riskeer.Common.Data/Structures/StructuresFailureMechanismAssemblyFactory.cs (.../StructuresFailureMechanismAssemblyFactory.cs) (revision ec2c838182ed237b3abd753347a861857129331b) @@ -68,7 +68,7 @@ .OfType>() .ToArray(); - return FailureMechanismSectionResultAssemblyFactory.AssembleSection( + return FailureMechanismSectionAssemblyResultFactory.AssembleSection( sectionResult, assessmentSection, () => sectionResult.GetInitialFailureMechanismResultProbability(calculationScenarios)); } } Index: Riskeer/Common/src/Riskeer.Common.Forms/Views/NonAdoptableFailureMechanismSectionResultRow.cs =================================================================== diff -u -rb3fe0a0deb8b40bf6a21e456445cef3f2f554ca9 -rec2c838182ed237b3abd753347a861857129331b --- Riskeer/Common/src/Riskeer.Common.Forms/Views/NonAdoptableFailureMechanismSectionResultRow.cs (.../NonAdoptableFailureMechanismSectionResultRow.cs) (revision b3fe0a0deb8b40bf6a21e456445cef3f2f554ca9) +++ Riskeer/Common/src/Riskeer.Common.Forms/Views/NonAdoptableFailureMechanismSectionResultRow.cs (.../NonAdoptableFailureMechanismSectionResultRow.cs) (revision ec2c838182ed237b3abd753347a861857129331b) @@ -220,7 +220,7 @@ { try { - AssemblyResult = FailureMechanismSectionResultAssemblyFactory.AssembleSection(SectionResult, assessmentSection); + AssemblyResult = FailureMechanismSectionAssemblyResultFactory.AssembleSection(SectionResult, assessmentSection); } catch (AssemblyException e) { Index: Riskeer/Common/test/Riskeer.Common.Data.Test/AssemblyTool/FailureMechanismSectionAssemblyResultFactoryTest.cs =================================================================== diff -u --- Riskeer/Common/test/Riskeer.Common.Data.Test/AssemblyTool/FailureMechanismSectionAssemblyResultFactoryTest.cs (revision 0) +++ Riskeer/Common/test/Riskeer.Common.Data.Test/AssemblyTool/FailureMechanismSectionAssemblyResultFactoryTest.cs (revision ec2c838182ed237b3abd753347a861857129331b) @@ -0,0 +1,842 @@ +// Copyright (C) Stichting Deltares 2021. All rights reserved. +// +// This file is part of Riskeer. +// +// Riskeer is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using Core.Common.TestUtil; +using NUnit.Framework; +using Rhino.Mocks; +using Riskeer.AssemblyTool.Data; +using Riskeer.AssemblyTool.KernelWrapper.Calculators; +using Riskeer.AssemblyTool.KernelWrapper.Calculators.Assembly; +using Riskeer.AssemblyTool.KernelWrapper.TestUtil.Calculators; +using Riskeer.AssemblyTool.KernelWrapper.TestUtil.Calculators.Assembly; +using Riskeer.Common.Data.AssemblyTool; +using Riskeer.Common.Data.AssessmentSection; +using Riskeer.Common.Data.Contribution; +using Riskeer.Common.Data.Exceptions; +using Riskeer.Common.Data.FailureMechanism; +using Riskeer.Common.Data.TestUtil; +using Riskeer.Common.Primitives; + +namespace Riskeer.Common.Data.Test.AssemblyTool +{ + [TestFixture] + public class FailureMechanismSectionAssemblyResultFactoryTest + { + private static bool IsInitialFailureMechanismResultTypeAdopt(AdoptableInitialFailureMechanismResultType initialFailureMechanismResultType) + { + return initialFailureMechanismResultType == AdoptableInitialFailureMechanismResultType.Adopt; + } + + #region AdoptableWithProfileProbabilityFailureMechanismSectionResult + + [Test] + public void AssembleSectionAdoptableSectionWithProfileProbability_SectionResultNull_ThrowsArgumentNullException() + { + // Setup + var random = new Random(21); + + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + var calculateStrategy = mocks.Stub(); + mocks.ReplayAll(); + + // Call + void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection( + null, assessmentSection, calculateStrategy, random.NextBoolean(), random.NextDouble()); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("sectionResult", exception.ParamName); + + mocks.VerifyAll(); + } + + [Test] + public void AssembleSectionAdoptableSectionWithProfileProbability_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Setup + var random = new Random(21); + + var mocks = new MockRepository(); + var calculateStrategy = mocks.Stub(); + mocks.ReplayAll(); + + var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + // Call + void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection( + sectionResult, null, calculateStrategy, random.NextBoolean(), random.NextDouble()); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("assessmentSection", exception.ParamName); + + mocks.VerifyAll(); + } + + [Test] + public void AssembleSectionAdoptableSectionWithProfileProbability_CalculateProbabilityStrategyNull_ThrowsArgumentNullException() + { + // Setup + var random = new Random(21); + + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + // Call + void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection( + sectionResult, assessmentSection, null, random.NextBoolean(), random.NextDouble()); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("calculateProbabilityStrategy", exception.ParamName); + + mocks.VerifyAll(); + } + + [Test] + [TestCase(AdoptableInitialFailureMechanismResultType.Adopt, true)] + [TestCase(AdoptableInitialFailureMechanismResultType.Manual, true)] + [TestCase(AdoptableInitialFailureMechanismResultType.NoFailureProbability, false)] + public void AssembleSectionAdoptableWithProfileProbability_WithInputAndUseLengthEffectFalse_SetsInputOnCalculator( + AdoptableInitialFailureMechanismResultType initialFailureMechanismResultType, bool expectedHasProbabilitySpecified) + { + // Setup + var random = new Random(21); + bool isRelevant = random.NextBoolean(); + double manualInitialSectionProbability = random.NextDouble(); + double calculateStrategySectionProbability = random.NextDouble(); + var furtherAnalysisType = random.NextEnumValue(); + double refinedSectionProbability = random.NextDouble(); + + var mocks = new MockRepository(); + var calculateStrategy = mocks.StrictMock(); + bool isInitialFailureMechanismResultTypeAdopt = IsInitialFailureMechanismResultTypeAdopt(initialFailureMechanismResultType); + if (isInitialFailureMechanismResultTypeAdopt) + { + calculateStrategy.Expect(cs => cs.CalculateSectionProbability()) + .Return(calculateStrategySectionProbability); + } + + mocks.ReplayAll(); + + var assessmentSection = new AssessmentSectionStub(); + + var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + IsRelevant = isRelevant, + InitialFailureMechanismResultType = initialFailureMechanismResultType, + ManualInitialFailureMechanismResultSectionProbability = manualInitialSectionProbability, + FurtherAnalysisType = furtherAnalysisType, + RefinedSectionProbability = refinedSectionProbability + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyResultFactory.AssembleSection( + sectionResult, assessmentSection, calculateStrategy, false, random.NextDouble()); + + // Assert + FailureMechanismSectionAssemblyInput calculatorInput = calculator.FailureMechanismSectionAssemblyInput; + FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution; + Assert.AreEqual(failureMechanismContribution.SignalingNorm, calculatorInput.SignalingNorm); + Assert.AreEqual(failureMechanismContribution.LowerLimitNorm, calculatorInput.LowerLimitNorm); + + Assert.AreEqual(isRelevant, calculatorInput.IsRelevant); + Assert.AreEqual(expectedHasProbabilitySpecified, calculatorInput.HasProbabilitySpecified); + + double expectedInitialSectionProbability = isInitialFailureMechanismResultTypeAdopt + ? calculateStrategySectionProbability + : manualInitialSectionProbability; + Assert.AreEqual(expectedInitialSectionProbability, calculatorInput.InitialSectionProbability); + Assert.AreEqual(furtherAnalysisType, calculatorInput.FurtherAnalysisType); + Assert.AreEqual(refinedSectionProbability, calculatorInput.RefinedSectionProbability); + } + } + + [Test] + [TestCase(AdoptableInitialFailureMechanismResultType.Adopt, true)] + [TestCase(AdoptableInitialFailureMechanismResultType.Manual, true)] + [TestCase(AdoptableInitialFailureMechanismResultType.NoFailureProbability, false)] + public void AssembleSectionAdoptableWithProfileProbability_WithInputAndUseLengthEffectTrue_SetsInputOnCalculator( + AdoptableInitialFailureMechanismResultType initialFailureMechanismResultType, bool expectedHasProbabilitySpecified) + { + // Setup + var random = new Random(21); + bool isRelevant = random.NextBoolean(); + double manualInitialProfileProbability = random.NextDouble(); + double manualInitialSectionProbability = random.NextDouble(); + double calculatedStrategySectionProbability = random.NextDouble(); + double calculatedStrategyProfileSectionProbability = random.NextDouble(); + var furtherAnalysisType = random.NextEnumValue(); + double manualRefinedSectionProbability = random.NextDouble(); + double manualRefinedProfileProbability = random.NextDouble(); + + var mocks = new MockRepository(); + var calculateStrategy = mocks.StrictMock(); + bool isInitialFailureMechanismResultTypeAdopt = IsInitialFailureMechanismResultTypeAdopt(initialFailureMechanismResultType); + if (isInitialFailureMechanismResultTypeAdopt) + { + calculateStrategy.Expect(cs => cs.CalculateProfileProbability()) + .Return(calculatedStrategyProfileSectionProbability); + calculateStrategy.Expect(cs => cs.CalculateSectionProbability()) + .Return(calculatedStrategySectionProbability); + } + + mocks.ReplayAll(); + + var assessmentSection = new AssessmentSectionStub(); + + var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + IsRelevant = isRelevant, + InitialFailureMechanismResultType = initialFailureMechanismResultType, + ManualInitialFailureMechanismResultProfileProbability = manualInitialProfileProbability, + ManualInitialFailureMechanismResultSectionProbability = manualInitialSectionProbability, + FurtherAnalysisType = furtherAnalysisType, + ProbabilityRefinementType = ProbabilityRefinementType.Both, + RefinedProfileProbability = manualRefinedProfileProbability, + RefinedSectionProbability = manualRefinedSectionProbability + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyResultFactory.AssembleSection( + sectionResult, assessmentSection, calculateStrategy, true, random.NextDouble()); + + // Assert + FailureMechanismSectionWithProfileProbabilityAssemblyInput calculatorInput = calculator.FailureMechanismSectionWithProfileProbabilityAssemblyInput; + FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution; + Assert.AreEqual(failureMechanismContribution.SignalingNorm, calculatorInput.SignalingNorm); + Assert.AreEqual(failureMechanismContribution.LowerLimitNorm, calculatorInput.LowerLimitNorm); + + Assert.AreEqual(isRelevant, calculatorInput.IsRelevant); + Assert.AreEqual(expectedHasProbabilitySpecified, calculatorInput.HasProbabilitySpecified); + + double expectedInitialProfileProbability = isInitialFailureMechanismResultTypeAdopt + ? calculatedStrategyProfileSectionProbability + : manualInitialProfileProbability; + Assert.AreEqual(expectedInitialProfileProbability, calculatorInput.InitialProfileProbability); + double expectedInitialSectionProbability = isInitialFailureMechanismResultTypeAdopt + ? calculatedStrategySectionProbability + : manualInitialSectionProbability; + Assert.AreEqual(expectedInitialSectionProbability, calculatorInput.InitialSectionProbability); + Assert.AreEqual(furtherAnalysisType, calculatorInput.FurtherAnalysisType); + Assert.AreEqual(manualRefinedProfileProbability, calculatorInput.RefinedProfileProbability); + Assert.AreEqual(manualRefinedSectionProbability, calculatorInput.RefinedSectionProbability); + } + } + + [Test] + [TestCase(ProbabilityRefinementType.Profile)] + [TestCase(ProbabilityRefinementType.Section)] + [TestCase(ProbabilityRefinementType.Both)] + public void AssembleSectionAdoptableWithProfileProbability_WithInputAndUseLengthEffectTrueAndVariousProbabilityRefinementType_SetsInputOnCalculator( + ProbabilityRefinementType probabilityRefinementType) + { + // Setup + var random = new Random(21); + double refinedSectionProbability = random.NextDouble(); + double refinedProfileProbability = random.NextDouble(); + double sectionN = random.NextDouble(); + + var mocks = new MockRepository(); + var calculateStrategy = mocks.Stub(); + mocks.ReplayAll(); + + var assessmentSection = new AssessmentSectionStub(); + + var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + ProbabilityRefinementType = probabilityRefinementType, + RefinedProfileProbability = refinedProfileProbability, + RefinedSectionProbability = refinedSectionProbability + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyResultFactory.AssembleSection( + sectionResult, assessmentSection, calculateStrategy, true, sectionN); + + // Assert + FailureMechanismSectionWithProfileProbabilityAssemblyInput calculatorInput = calculator.FailureMechanismSectionWithProfileProbabilityAssemblyInput; + switch (probabilityRefinementType) + { + case ProbabilityRefinementType.Profile: + Assert.AreEqual(refinedProfileProbability, calculatorInput.RefinedProfileProbability); + Assert.AreEqual(refinedProfileProbability * sectionN, calculatorInput.RefinedSectionProbability); + break; + case ProbabilityRefinementType.Section: + Assert.AreEqual(refinedSectionProbability / sectionN, calculatorInput.RefinedProfileProbability); + Assert.AreEqual(refinedSectionProbability, calculatorInput.RefinedSectionProbability); + break; + case ProbabilityRefinementType.Both: + Assert.AreEqual(refinedProfileProbability, calculatorInput.RefinedProfileProbability); + Assert.AreEqual(refinedSectionProbability, calculatorInput.RefinedSectionProbability); + break; + } + } + } + + [Test] + public void AssembleSectionAdoptableSectionWithProfileProbability_CalculatorRan_ReturnsExpectedOutput() + { + // Setup + var random = new Random(21); + + var mocks = new MockRepository(); + var calculateStrategy = mocks.Stub(); + mocks.ReplayAll(); + + var assessmentSection = new AssessmentSectionStub(); + var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyResult result = FailureMechanismSectionAssemblyResultFactory.AssembleSection( + sectionResult, assessmentSection, calculateStrategy, random.NextBoolean(), random.NextDouble()); + + // Assert + Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput, result); + } + } + + [Test] + public void AssembleSectionAdoptableSectionWithProfileProbability_CalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + var random = new Random(21); + + var mocks = new MockRepository(); + var calculateStrategy = mocks.Stub(); + mocks.ReplayAll(); + + var assessmentSection = new AssessmentSectionStub(); + var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculate = true; + + // Call + void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection( + sectionResult, assessmentSection, calculateStrategy, random.NextBoolean(), random.NextDouble()); + + // Assert + var exception = Assert.Throws(Call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + #endregion + + #region AdoptableFailureMechanismSectionResult + + [Test] + public void AssembleSectionAdoptableSectionWithoutProfileProbability_SectionResultNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection(null, assessmentSection, () => double.NaN); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("sectionResult", exception.ParamName); + + mocks.VerifyAll(); + } + + [Test] + public void AssembleSectionAdoptableSectionWithoutProfileProbability_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Setup + var sectionResult = new AdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + // Call + void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, null, () => double.NaN); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + public void AssembleSectionAdoptableSectionWithoutProfileProbability_CalculateProbabilityFuncNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var sectionResult = new AdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + // Call + void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, assessmentSection, null); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("calculateProbabilityFunc", exception.ParamName); + + mocks.VerifyAll(); + } + + [Test] + [TestCase(AdoptableInitialFailureMechanismResultType.Adopt, true)] + [TestCase(AdoptableInitialFailureMechanismResultType.Manual, true)] + [TestCase(AdoptableInitialFailureMechanismResultType.NoFailureProbability, false)] + public void AssembleSectionAdoptableSectionWithoutProfileProbability_WithInput_ReturnsExpectedOutput( + AdoptableInitialFailureMechanismResultType initialFailureMechanismResultType, bool expectedHasProbabilitySpecified) + { + // Setup + var random = new Random(21); + bool isRelevant = random.NextBoolean(); + double manualSectionProbability = random.NextDouble(); + double calculatedSectionProbability = random.NextDouble(); + var furtherAnalysisType = random.NextEnumValue(); + double refinedSectionProbability = random.NextDouble(); + + var assessmentSection = new AssessmentSectionStub(); + + var sectionResult = new AdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + IsRelevant = isRelevant, + InitialFailureMechanismResultType = initialFailureMechanismResultType, + ManualInitialFailureMechanismResultSectionProbability = manualSectionProbability, + FurtherAnalysisType = furtherAnalysisType, + RefinedSectionProbability = refinedSectionProbability + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, assessmentSection, () => calculatedSectionProbability); + + // Assert + FailureMechanismSectionAssemblyInput calculatorInput = calculator.FailureMechanismSectionAssemblyInput; + FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution; + Assert.AreEqual(failureMechanismContribution.SignalingNorm, calculatorInput.SignalingNorm); + Assert.AreEqual(failureMechanismContribution.LowerLimitNorm, calculatorInput.LowerLimitNorm); + + Assert.AreEqual(isRelevant, calculatorInput.IsRelevant); + Assert.AreEqual(expectedHasProbabilitySpecified, calculatorInput.HasProbabilitySpecified); + + double expectedInitialSectionProbability = IsInitialFailureMechanismResultTypeAdopt(initialFailureMechanismResultType) + ? calculatedSectionProbability + : manualSectionProbability; + Assert.AreEqual(expectedInitialSectionProbability, calculatorInput.InitialSectionProbability); + Assert.AreEqual(furtherAnalysisType, calculatorInput.FurtherAnalysisType); + Assert.AreEqual(refinedSectionProbability, calculatorInput.RefinedSectionProbability); + } + } + + [Test] + public void AssembleSectionAdoptableSectionWithoutProfileProbability_CalculatorRan_ReturnsExpectedOutput() + { + // Setup + var assessmentSection = new AssessmentSectionStub(); + var sectionResult = new AdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyResult result = FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, assessmentSection, () => double.NaN); + + // Assert + Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput, result); + } + } + + [Test] + public void AssembleSectionAdoptableSectionWithoutProfileProbability_CalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + var assessmentSection = new AssessmentSectionStub(); + var sectionResult = new AdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculate = true; + + // Call + void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, assessmentSection, () => double.NaN); + + // Assert + var exception = Assert.Throws(Call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + #endregion + + #region NonAdoptableWithProfileProbability + + [Test] + public void AssembleSectionNonAdoptableSectionWithProfileProbability_SectionResultNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var random = new Random(21); + + // Call + void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection(null, assessmentSection, random.NextBoolean()); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("sectionResult", exception.ParamName); + + mocks.VerifyAll(); + } + + [Test] + public void AssembleSectionNonAdoptableSectionWithProfileProbability_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Setup + var random = new Random(21); + var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + // Call + void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, null, random.NextBoolean()); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + [TestCase(NonAdoptableInitialFailureMechanismResultType.Manual, true)] + [TestCase(NonAdoptableInitialFailureMechanismResultType.NoFailureProbability, false)] + public void AssembleSectionNonAdoptableWithProfileProbability_WithInputAndUseLengthEffectFalse_SetsInputOnCalculator( + NonAdoptableInitialFailureMechanismResultType initialFailureMechanismResultType, bool expectedHasProbabilitySpecified) + { + // Setup + var random = new Random(21); + bool isRelevant = random.NextBoolean(); + double manualInitialSectionProbability = random.NextDouble(); + var furtherAnalysisType = random.NextEnumValue(); + double refinedSectionProbability = random.NextDouble(); + + var assessmentSection = new AssessmentSectionStub(); + + var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + IsRelevant = isRelevant, + InitialFailureMechanismResultType = initialFailureMechanismResultType, + ManualInitialFailureMechanismResultSectionProbability = manualInitialSectionProbability, + FurtherAnalysisType = furtherAnalysisType, + RefinedSectionProbability = refinedSectionProbability + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, assessmentSection, false); + + // Assert + FailureMechanismSectionAssemblyInput calculatorInput = calculator.FailureMechanismSectionAssemblyInput; + FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution; + Assert.AreEqual(failureMechanismContribution.SignalingNorm, calculatorInput.SignalingNorm); + Assert.AreEqual(failureMechanismContribution.LowerLimitNorm, calculatorInput.LowerLimitNorm); + + Assert.AreEqual(isRelevant, calculatorInput.IsRelevant); + Assert.AreEqual(expectedHasProbabilitySpecified, calculatorInput.HasProbabilitySpecified); + + Assert.AreEqual(manualInitialSectionProbability, calculatorInput.InitialSectionProbability); + Assert.AreEqual(furtherAnalysisType, calculatorInput.FurtherAnalysisType); + Assert.AreEqual(refinedSectionProbability, calculatorInput.RefinedSectionProbability); + } + } + + [Test] + [TestCase(NonAdoptableInitialFailureMechanismResultType.Manual, true)] + [TestCase(NonAdoptableInitialFailureMechanismResultType.NoFailureProbability, false)] + public void AssembleSectionNonAdoptableWithProfileProbability_WithInputAndUseLengthEffectTrue_SetsInputOnCalculator( + NonAdoptableInitialFailureMechanismResultType initialFailureMechanismResultType, bool expectedHasProbabilitySpecified) + { + // Setup + var random = new Random(21); + bool isRelevant = random.NextBoolean(); + double manualInitialProfileProbability = random.NextDouble(); + double manualInitialSectionProbability = random.NextDouble(); + var furtherAnalysisType = random.NextEnumValue(); + double manualRefinedSectionProbability = random.NextDouble(); + double manualRefinedProfileProbability = random.NextDouble(); + + var assessmentSection = new AssessmentSectionStub(); + + var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + IsRelevant = isRelevant, + InitialFailureMechanismResultType = initialFailureMechanismResultType, + ManualInitialFailureMechanismResultProfileProbability = manualInitialProfileProbability, + ManualInitialFailureMechanismResultSectionProbability = manualInitialSectionProbability, + FurtherAnalysisType = furtherAnalysisType, + RefinedProfileProbability = manualRefinedProfileProbability, + RefinedSectionProbability = manualRefinedSectionProbability + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, assessmentSection, true); + + // Assert + FailureMechanismSectionWithProfileProbabilityAssemblyInput calculatorInput = calculator.FailureMechanismSectionWithProfileProbabilityAssemblyInput; + FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution; + Assert.AreEqual(failureMechanismContribution.SignalingNorm, calculatorInput.SignalingNorm); + Assert.AreEqual(failureMechanismContribution.LowerLimitNorm, calculatorInput.LowerLimitNorm); + + Assert.AreEqual(isRelevant, calculatorInput.IsRelevant); + Assert.AreEqual(expectedHasProbabilitySpecified, calculatorInput.HasProbabilitySpecified); + Assert.AreEqual(manualInitialProfileProbability, calculatorInput.InitialProfileProbability); + Assert.AreEqual(manualInitialSectionProbability, calculatorInput.InitialSectionProbability); + Assert.AreEqual(furtherAnalysisType, calculatorInput.FurtherAnalysisType); + Assert.AreEqual(manualRefinedProfileProbability, calculatorInput.RefinedProfileProbability); + Assert.AreEqual(manualRefinedSectionProbability, calculatorInput.RefinedSectionProbability); + } + } + + [Test] + public void AssembleSectionNonAdoptableSectionWithProfileProbability_CalculatorRan_ReturnsExpectedOutput() + { + // Setup + var random = new Random(21); + var assessmentSection = new AssessmentSectionStub(); + var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyResult result = FailureMechanismSectionAssemblyResultFactory.AssembleSection( + sectionResult, assessmentSection, random.NextBoolean()); + + // Assert + Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput, result); + } + } + + [Test] + public void AssembleSectionNonAdoptableSectionWithProfileProbability_CalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + var random = new Random(21); + var assessmentSection = new AssessmentSectionStub(); + var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculate = true; + + // Call + void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection( + sectionResult, assessmentSection, random.NextBoolean()); + + // Assert + var exception = Assert.Throws(Call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + #endregion + + #region NonAdoptableWithoutProfileProbability + + [Test] + public void AssembleSectionNonAdoptableSectionWithoutProfileProbability_SectionResultNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection(null, assessmentSection); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("sectionResult", exception.ParamName); + + mocks.VerifyAll(); + } + + [Test] + public void AssembleSectionNonAdoptableSectionWithoutProfileProbability_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Setup + var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + // Call + void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, null); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + [TestCase(NonAdoptableInitialFailureMechanismResultType.Manual, true)] + [TestCase(NonAdoptableInitialFailureMechanismResultType.NoFailureProbability, false)] + public void AssembleSectionNonAdoptableWithoutProfileProbability_WithInputAndUseLengthEffectFalse_SetsInputOnCalculator( + NonAdoptableInitialFailureMechanismResultType initialFailureMechanismResultType, bool expectedHasProbabilitySpecified) + { + // Setup + var random = new Random(21); + bool isRelevant = random.NextBoolean(); + double manualInitialSectionProbability = random.NextDouble(); + var furtherAnalysisType = random.NextEnumValue(); + double refinedSectionProbability = random.NextDouble(); + + var assessmentSection = new AssessmentSectionStub(); + + var sectionResult = new NonAdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + IsRelevant = isRelevant, + InitialFailureMechanismResultType = initialFailureMechanismResultType, + ManualInitialFailureMechanismResultSectionProbability = manualInitialSectionProbability, + FurtherAnalysisType = furtherAnalysisType, + RefinedSectionProbability = refinedSectionProbability + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, assessmentSection); + + // Assert + FailureMechanismSectionAssemblyInput calculatorInput = calculator.FailureMechanismSectionAssemblyInput; + FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution; + Assert.AreEqual(failureMechanismContribution.SignalingNorm, calculatorInput.SignalingNorm); + Assert.AreEqual(failureMechanismContribution.LowerLimitNorm, calculatorInput.LowerLimitNorm); + + Assert.AreEqual(isRelevant, calculatorInput.IsRelevant); + Assert.AreEqual(expectedHasProbabilitySpecified, calculatorInput.HasProbabilitySpecified); + + Assert.AreEqual(manualInitialSectionProbability, calculatorInput.InitialSectionProbability); + Assert.AreEqual(furtherAnalysisType, calculatorInput.FurtherAnalysisType); + Assert.AreEqual(refinedSectionProbability, calculatorInput.RefinedSectionProbability); + } + } + + [Test] + public void AssembleSectionNonAdoptableSectionWithoutProfileProbability_CalculatorRan_ReturnsExpectedOutput() + { + // Setup + var assessmentSection = new AssessmentSectionStub(); + var sectionResult = new NonAdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyResult result = FailureMechanismSectionAssemblyResultFactory.AssembleSection( + sectionResult, assessmentSection); + + // Assert + Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput, result); + } + } + + [Test] + public void AssembleSectionNonAdoptableSectionWithoutProfileProbability_CalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + var assessmentSection = new AssessmentSectionStub(); + var sectionResult = new NonAdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculate = true; + + // Call + void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection( + sectionResult, assessmentSection); + + // Assert + var exception = Assert.Throws(Call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + #endregion + } +} \ No newline at end of file Fisheye: Tag ec2c838182ed237b3abd753347a861857129331b refers to a dead (removed) revision in file `Riskeer/Common/test/Riskeer.Common.Data.Test/AssemblyTool/FailureMechanismSectionResultAssemblyFactoryTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Data/GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs =================================================================== diff -u -r562b41f8cf13ba3d6a29919c6841c3ad8c1c8df1 -rec2c838182ed237b3abd753347a861857129331b --- Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Data/GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs (.../GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs) (revision 562b41f8cf13ba3d6a29919c6841c3ad8c1c8df1) +++ Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Data/GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs (.../GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs) (revision ec2c838182ed237b3abd753347a861857129331b) @@ -66,7 +66,7 @@ .OfType() .ToArray(); - return FailureMechanismSectionResultAssemblyFactory.AssembleSection( + return FailureMechanismSectionAssemblyResultFactory.AssembleSection( sectionResult, assessmentSection, new GrassCoverErosionInwardsFailureMechanismSectionResultCalculateProbabilityStrategy(sectionResult, calculationScenarios), failureMechanism.GeneralInput.ApplyLengthEffectInSection, 1.0); Index: Riskeer/GrassCoverErosionOutwards/src/Riskeer.GrassCoverErosionOutwards.Data/GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.cs =================================================================== diff -u -rab91e93965a76b4b765204f935c8160533516c45 -rec2c838182ed237b3abd753347a861857129331b --- Riskeer/GrassCoverErosionOutwards/src/Riskeer.GrassCoverErosionOutwards.Data/GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.cs (.../GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.cs) (revision ab91e93965a76b4b765204f935c8160533516c45) +++ Riskeer/GrassCoverErosionOutwards/src/Riskeer.GrassCoverErosionOutwards.Data/GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.cs (.../GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.cs) (revision ec2c838182ed237b3abd753347a861857129331b) @@ -61,7 +61,7 @@ throw new ArgumentNullException(nameof(assessmentSection)); } - return FailureMechanismSectionResultAssemblyFactory.AssembleSection(sectionResult, assessmentSection, failureMechanism.GeneralInput.ApplyLengthEffectInSection); + return FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, assessmentSection, failureMechanism.GeneralInput.ApplyLengthEffectInSection); } } } \ No newline at end of file Index: Riskeer/Integration/src/Riskeer.Integration.Data/StandAlone/AssemblyFactories/StandAloneFailureMechanismAssemblyFactory.cs =================================================================== diff -u -r92ce27ee1854f01e9cc648b1ae4553a7ea0f3845 -rec2c838182ed237b3abd753347a861857129331b --- Riskeer/Integration/src/Riskeer.Integration.Data/StandAlone/AssemblyFactories/StandAloneFailureMechanismAssemblyFactory.cs (.../StandAloneFailureMechanismAssemblyFactory.cs) (revision 92ce27ee1854f01e9cc648b1ae4553a7ea0f3845) +++ Riskeer/Integration/src/Riskeer.Integration.Data/StandAlone/AssemblyFactories/StandAloneFailureMechanismAssemblyFactory.cs (.../StandAloneFailureMechanismAssemblyFactory.cs) (revision ec2c838182ed237b3abd753347a861857129331b) @@ -11,7 +11,7 @@ IHasGeneralInput failureMechanism, IAssessmentSection assessmentSection) { - return FailureMechanismSectionResultAssemblyFactory.AssembleSection(sectionResult, assessmentSection, failureMechanism.GeneralInput.ApplyLengthEffectInSection); + return FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, assessmentSection, failureMechanism.GeneralInput.ApplyLengthEffectInSection); } } } \ No newline at end of file Index: Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.Data/MacroStabilityInwardsFailureMechanismAssemblyFactory.cs =================================================================== diff -u -rc207cda58e0297e575104768f10805ed055071cf -rec2c838182ed237b3abd753347a861857129331b --- Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.Data/MacroStabilityInwardsFailureMechanismAssemblyFactory.cs (.../MacroStabilityInwardsFailureMechanismAssemblyFactory.cs) (revision c207cda58e0297e575104768f10805ed055071cf) +++ Riskeer/MacroStabilityInwards/src/Riskeer.MacroStabilityInwards.Data/MacroStabilityInwardsFailureMechanismAssemblyFactory.cs (.../MacroStabilityInwardsFailureMechanismAssemblyFactory.cs) (revision ec2c838182ed237b3abd753347a861857129331b) @@ -38,7 +38,7 @@ .OfType() .ToArray(); - return FailureMechanismSectionResultAssemblyFactory.AssembleSection( + return FailureMechanismSectionAssemblyResultFactory.AssembleSection( sectionResult, assessmentSection, new MacroStabilityInwardsFailureMechanismSectionResultCalculateProbabilityStrategy(sectionResult, calculationScenarios, failureMechanism), failureMechanism.GeneralInput.ApplyLengthEffectInSection, Index: Riskeer/Piping/src/Riskeer.Piping.Data/PipingFailureMechanismAssemblyFactory.cs =================================================================== diff -u -r1701ba2f2285c21eb6358de35af2a169b51f6b6e -rec2c838182ed237b3abd753347a861857129331b --- Riskeer/Piping/src/Riskeer.Piping.Data/PipingFailureMechanismAssemblyFactory.cs (.../PipingFailureMechanismAssemblyFactory.cs) (revision 1701ba2f2285c21eb6358de35af2a169b51f6b6e) +++ Riskeer/Piping/src/Riskeer.Piping.Data/PipingFailureMechanismAssemblyFactory.cs (.../PipingFailureMechanismAssemblyFactory.cs) (revision ec2c838182ed237b3abd753347a861857129331b) @@ -66,7 +66,7 @@ IFailureMechanismSectionResultCalculateProbabilityStrategy calculateProbabilityStrategy = PipingFailureMechanismSectionResultCalculateProbabilityStrategyFactory.CreateCalculateStrategy(sectionResult, failureMechanism, assessmentSection); - return FailureMechanismSectionResultAssemblyFactory.AssembleSection( + return FailureMechanismSectionAssemblyResultFactory.AssembleSection( sectionResult, assessmentSection, calculateProbabilityStrategy, failureMechanism.GeneralInput.ApplyLengthEffectInSection, failureMechanism.PipingProbabilityAssessmentInput.GetN(sectionResult.Section.Length)); Index: Riskeer/StabilityStoneCover/src/Riskeer.StabilityStoneCover.Data/StabilityStoneCoverFailureMechanismAssemblyFactory.cs =================================================================== diff -u -rab91e93965a76b4b765204f935c8160533516c45 -rec2c838182ed237b3abd753347a861857129331b --- Riskeer/StabilityStoneCover/src/Riskeer.StabilityStoneCover.Data/StabilityStoneCoverFailureMechanismAssemblyFactory.cs (.../StabilityStoneCoverFailureMechanismAssemblyFactory.cs) (revision ab91e93965a76b4b765204f935c8160533516c45) +++ Riskeer/StabilityStoneCover/src/Riskeer.StabilityStoneCover.Data/StabilityStoneCoverFailureMechanismAssemblyFactory.cs (.../StabilityStoneCoverFailureMechanismAssemblyFactory.cs) (revision ec2c838182ed237b3abd753347a861857129331b) @@ -61,7 +61,7 @@ throw new ArgumentNullException(nameof(assessmentSection)); } - return FailureMechanismSectionResultAssemblyFactory.AssembleSection(sectionResult, assessmentSection, failureMechanism.GeneralInput.ApplyLengthEffectInSection); + return FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, assessmentSection, failureMechanism.GeneralInput.ApplyLengthEffectInSection); } } } \ No newline at end of file Index: Riskeer/WaveImpactAsphaltCover/src/Riskeer.WaveImpactAsphaltCover.Data/WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.cs =================================================================== diff -u -rab91e93965a76b4b765204f935c8160533516c45 -rec2c838182ed237b3abd753347a861857129331b --- Riskeer/WaveImpactAsphaltCover/src/Riskeer.WaveImpactAsphaltCover.Data/WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.cs (.../WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.cs) (revision ab91e93965a76b4b765204f935c8160533516c45) +++ Riskeer/WaveImpactAsphaltCover/src/Riskeer.WaveImpactAsphaltCover.Data/WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.cs (.../WaveImpactAsphaltCoverFailureMechanismAssemblyFactory.cs) (revision ec2c838182ed237b3abd753347a861857129331b) @@ -40,7 +40,7 @@ throw new ArgumentNullException(nameof(assessmentSection)); } - return FailureMechanismSectionResultAssemblyFactory.AssembleSection(sectionResult, assessmentSection, failureMechanism.GeneralWaveImpactAsphaltCoverInput.ApplyLengthEffectInSection); + return FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, assessmentSection, failureMechanism.GeneralWaveImpactAsphaltCoverInput.ApplyLengthEffectInSection); } } } \ No newline at end of file