Fisheye: Tag ee815ae0e4b99e726400fe3f5d37d2c99b25a3a0 refers to a dead (removed) revision in file `Riskeer/HeightStructures/src/Riskeer.HeightStructures.Data/HeightStructuresFailureMechanismAssemblyFactory.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Riskeer/HeightStructures/src/Riskeer.HeightStructures.Data/HeightStructuresFailureMechanismAssemblyFactoryOld.cs =================================================================== diff -u --- Riskeer/HeightStructures/src/Riskeer.HeightStructures.Data/HeightStructuresFailureMechanismAssemblyFactoryOld.cs (revision 0) +++ Riskeer/HeightStructures/src/Riskeer.HeightStructures.Data/HeightStructuresFailureMechanismAssemblyFactoryOld.cs (revision ee815ae0e4b99e726400fe3f5d37d2c99b25a3a0) @@ -0,0 +1,394 @@ +// 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 System.Collections.Generic; +using System.Linq; +using Riskeer.AssemblyTool.Data; +using Riskeer.AssemblyTool.KernelWrapper.Calculators; +using Riskeer.AssemblyTool.KernelWrapper.Calculators.Assembly; +using Riskeer.AssemblyTool.KernelWrapper.Kernels; +using Riskeer.Common.Data.AssemblyTool; +using Riskeer.Common.Data.AssessmentSection; +using Riskeer.Common.Data.Exceptions; +using Riskeer.Common.Data.Structures; +using Riskeer.Common.Primitives; +using RiskeerCommonDataResources = Riskeer.Common.Data.Properties.Resources; + +namespace Riskeer.HeightStructures.Data +{ + /// + /// Factory for assembling assembly results for a height structures failure mechanism. + /// + public static class HeightStructuresFailureMechanismAssemblyFactoryOld + { + /// + /// Assembles the simple assessment results. + /// + /// The failure mechanism section result to assemble the + /// simple assembly results for. + /// A based on the . + /// Thrown when + /// is null. + /// Thrown when the + /// could not be created. + public static FailureMechanismSectionAssemblyOld AssembleSimpleAssessment( + HeightStructuresFailureMechanismSectionResultOld failureMechanismSectionResult) + { + if (failureMechanismSectionResult == null) + { + throw new ArgumentNullException(nameof(failureMechanismSectionResult)); + } + + IAssemblyToolCalculatorFactoryOld calculatorFactory = AssemblyToolCalculatorFactoryOld.Instance; + IFailureMechanismSectionAssemblyCalculatorOld calculator = + calculatorFactory.CreateFailureMechanismSectionAssemblyCalculator(AssemblyToolKernelFactoryOld.Instance); + + try + { + return calculator.AssembleSimpleAssessment(failureMechanismSectionResult.SimpleAssessmentResult); + } + catch (FailureMechanismSectionAssemblyCalculatorException e) + { + throw new AssemblyException(e.Message, e); + } + } + + /// + /// Assembles the detailed assessment result. + /// + /// The failure mechanism section result to + /// assemble the detailed assembly for. + /// All calculation scenarios in the failure mechanism. + /// The failure mechanism this section belongs to. + /// The this section belongs to. + /// A . + /// Thrown when any parameter is null. + /// Thrown when the + /// could not be created. + public static FailureMechanismSectionAssemblyOld AssembleDetailedAssessment( + HeightStructuresFailureMechanismSectionResultOld failureMechanismSectionResult, + IEnumerable> calculationScenarios, + HeightStructuresFailureMechanism failureMechanism, + IAssessmentSection assessmentSection) + { + if (failureMechanismSectionResult == null) + { + throw new ArgumentNullException(nameof(failureMechanismSectionResult)); + } + + if (calculationScenarios == null) + { + throw new ArgumentNullException(nameof(calculationScenarios)); + } + + if (failureMechanism == null) + { + throw new ArgumentNullException(nameof(failureMechanism)); + } + + if (assessmentSection == null) + { + throw new ArgumentNullException(nameof(assessmentSection)); + } + + IAssemblyToolCalculatorFactoryOld calculatorFactory = AssemblyToolCalculatorFactoryOld.Instance; + IFailureMechanismSectionAssemblyCalculatorOld calculator = + calculatorFactory.CreateFailureMechanismSectionAssemblyCalculator(AssemblyToolKernelFactoryOld.Instance); + + try + { + return calculator.AssembleDetailedAssessment( + failureMechanismSectionResult.DetailedAssessmentResult, + failureMechanismSectionResult.GetDetailedAssessmentProbability(calculationScenarios), + CreateAssemblyCategoriesInput(failureMechanism, assessmentSection)); + } + catch (FailureMechanismSectionAssemblyCalculatorException e) + { + throw new AssemblyException(e.Message, e); + } + } + + /// + /// Assembles the tailor made assessment result. + /// + /// The failure mechanism section result to + /// assemble the tailor made assembly for. + /// The failure mechanism this section belongs to. + /// The this section belongs to. + /// A . + /// Thrown when any parameter is null. + /// Thrown when the + /// could not be created. + public static FailureMechanismSectionAssemblyOld AssembleTailorMadeAssessment( + HeightStructuresFailureMechanismSectionResultOld failureMechanismSectionResult, + HeightStructuresFailureMechanism failureMechanism, + IAssessmentSection assessmentSection) + { + if (failureMechanismSectionResult == null) + { + throw new ArgumentNullException(nameof(failureMechanismSectionResult)); + } + + if (failureMechanism == null) + { + throw new ArgumentNullException(nameof(failureMechanism)); + } + + if (assessmentSection == null) + { + throw new ArgumentNullException(nameof(assessmentSection)); + } + + IAssemblyToolCalculatorFactoryOld calculatorFactory = AssemblyToolCalculatorFactoryOld.Instance; + IFailureMechanismSectionAssemblyCalculatorOld calculator = + calculatorFactory.CreateFailureMechanismSectionAssemblyCalculator(AssemblyToolKernelFactoryOld.Instance); + + try + { + return calculator.AssembleTailorMadeAssessment( + failureMechanismSectionResult.TailorMadeAssessmentResult, + failureMechanismSectionResult.TailorMadeAssessmentProbability, + CreateAssemblyCategoriesInput(failureMechanism, assessmentSection)); + } + catch (FailureMechanismSectionAssemblyCalculatorException e) + { + throw new AssemblyException(e.Message, e); + } + } + + /// + /// Assembles the combined assembly. + /// + /// The failure mechanism section result to + /// combine the assemblies for. + /// All calculation scenarios in the failure mechanism. + /// The failure mechanism this section belongs to. + /// The this section belongs to. + /// A . + /// Thrown when any parameter is null. + /// Thrown when the + /// could not be created. + public static FailureMechanismSectionAssemblyOld AssembleCombinedAssessment( + HeightStructuresFailureMechanismSectionResultOld failureMechanismSectionResult, + IEnumerable> calculationScenarios, + HeightStructuresFailureMechanism failureMechanism, + IAssessmentSection assessmentSection) + { + if (failureMechanismSectionResult == null) + { + throw new ArgumentNullException(nameof(failureMechanismSectionResult)); + } + + if (calculationScenarios == null) + { + throw new ArgumentNullException(nameof(calculationScenarios)); + } + + if (failureMechanism == null) + { + throw new ArgumentNullException(nameof(failureMechanism)); + } + + if (assessmentSection == null) + { + throw new ArgumentNullException(nameof(assessmentSection)); + } + + IAssemblyToolCalculatorFactoryOld calculatorFactory = AssemblyToolCalculatorFactoryOld.Instance; + IFailureMechanismSectionAssemblyCalculatorOld calculator = + calculatorFactory.CreateFailureMechanismSectionAssemblyCalculator(AssemblyToolKernelFactoryOld.Instance); + + try + { + FailureMechanismSectionAssemblyOld simpleAssembly = AssembleSimpleAssessment(failureMechanismSectionResult); + + if (failureMechanismSectionResult.SimpleAssessmentResult == SimpleAssessmentResultType.ProbabilityNegligible + || failureMechanismSectionResult.SimpleAssessmentResult == SimpleAssessmentResultType.NotApplicable) + { + return calculator.AssembleCombined(simpleAssembly); + } + + return calculator.AssembleCombined( + simpleAssembly, + AssembleDetailedAssessment(failureMechanismSectionResult, calculationScenarios, failureMechanism, assessmentSection), + AssembleTailorMadeAssessment(failureMechanismSectionResult, failureMechanism, assessmentSection)); + } + catch (FailureMechanismSectionAssemblyCalculatorException e) + { + throw new AssemblyException(e.Message, e); + } + } + + /// + /// Gets the assembly category group of the given . + /// + /// The failure mechanism section result to get the assembly category group for. + /// The failure mechanism this section belongs to. + /// The this section belongs to. + /// Indicator that determines whether the manual assembly should be considered when assembling the result. + /// A . + /// Thrown when any parameter is null. + /// Thrown when the + /// could not be created. + public static FailureMechanismSectionAssemblyCategoryGroup GetSectionAssemblyCategoryGroup(HeightStructuresFailureMechanismSectionResultOld failureMechanismSectionResult, + HeightStructuresFailureMechanism failureMechanism, + IAssessmentSection assessmentSection, + bool useManual) + { + if (failureMechanismSectionResult == null) + { + throw new ArgumentNullException(nameof(failureMechanismSectionResult)); + } + + if (failureMechanism == null) + { + throw new ArgumentNullException(nameof(failureMechanism)); + } + + if (assessmentSection == null) + { + throw new ArgumentNullException(nameof(assessmentSection)); + } + + return GetSectionAssembly(failureMechanismSectionResult, failureMechanism, assessmentSection, useManual).Group; + } + + /// + /// Assembles the failure mechanism assembly. + /// + /// The failure mechanism to assemble for. + /// The the failure mechanism belongs to. + /// Indicator that determines whether the manual assembly should be considered when assembling the result. + /// A . + /// Thrown when any parameter is null. + /// Thrown when the + /// could not be created. + public static FailureMechanismAssembly AssembleFailureMechanism( + HeightStructuresFailureMechanism failureMechanism, + IAssessmentSection assessmentSection, + bool useManual) + { + if (failureMechanism == null) + { + throw new ArgumentNullException(nameof(failureMechanism)); + } + + if (assessmentSection == null) + { + throw new ArgumentNullException(nameof(assessmentSection)); + } + + if (!failureMechanism.InAssembly) + { + return FailureMechanismAssemblyResultFactoryOld.CreateNotApplicableAssembly(); + } + + try + { + IAssemblyToolCalculatorFactoryOld calculatorFactory = AssemblyToolCalculatorFactoryOld.Instance; + AssemblyCategoriesInput assemblyCategoriesInput = CreateAssemblyCategoriesInput(failureMechanism, assessmentSection); + IEnumerable sectionAssemblies = failureMechanism.SectionResultsOld + .Select(sr => GetSectionAssembly(sr, failureMechanism, assessmentSection, useManual)) + .ToArray(); + + IFailureMechanismAssemblyCalculatorOld calculator = + calculatorFactory.CreateFailureMechanismAssemblyCalculator(AssemblyToolKernelFactoryOld.Instance); + + return calculator.Assemble(sectionAssemblies, assemblyCategoriesInput); + } + catch (FailureMechanismAssemblyCalculatorException e) + { + throw new AssemblyException(e.Message, e); + } + catch (AssemblyException e) + { + throw new AssemblyException(RiskeerCommonDataResources.FailureMechanismAssemblyFactory_Error_while_assembling_failureMechanism, e); + } + } + + /// + /// Gets the assembly of the given . + /// + /// The failure mechanism section result to get the assembly for. + /// The failure mechanism to assemble for. + /// The the failure mechanism belongs to. + /// Indicator that determines whether the manual assembly should be considered when assembling the result. + /// A . + /// Thrown when a + /// could not be created. + private static FailureMechanismSectionAssemblyOld GetSectionAssembly(HeightStructuresFailureMechanismSectionResultOld failureMechanismSectionResult, + HeightStructuresFailureMechanism failureMechanism, + IAssessmentSection assessmentSection, + bool useManual) + { + FailureMechanismSectionAssemblyOld sectionAssembly; + if (failureMechanismSectionResult.UseManualAssembly && useManual) + { + sectionAssembly = AssembleManualAssessment(failureMechanismSectionResult, + CreateAssemblyCategoriesInput(failureMechanism, assessmentSection)); + } + else + { + sectionAssembly = AssembleCombinedAssessment(failureMechanismSectionResult, + failureMechanism.Calculations.Cast>(), + failureMechanism, + assessmentSection); + } + + return sectionAssembly; + } + + /// + /// Assembles the manual assembly. + /// + /// The failure mechanism section result to assemble the + /// manual assembly for. + /// The input parameters used to determine the assembly categories. + /// A . + /// Thrown when the + /// could not be created. + private static FailureMechanismSectionAssemblyOld AssembleManualAssessment(HeightStructuresFailureMechanismSectionResultOld sectionResult, + AssemblyCategoriesInput assemblyCategoriesInput) + { + IAssemblyToolCalculatorFactoryOld calculatorFactory = AssemblyToolCalculatorFactoryOld.Instance; + IFailureMechanismSectionAssemblyCalculatorOld calculator = + calculatorFactory.CreateFailureMechanismSectionAssemblyCalculator(AssemblyToolKernelFactoryOld.Instance); + + try + { + return calculator.AssembleManual(sectionResult.ManualAssemblyProbability, assemblyCategoriesInput); + } + catch (FailureMechanismSectionAssemblyCalculatorException e) + { + throw new AssemblyException(e.Message, e); + } + } + + private static AssemblyCategoriesInput CreateAssemblyCategoriesInput(HeightStructuresFailureMechanism failureMechanism, + IAssessmentSection assessmentSection) + { + return AssemblyCategoriesInputFactory.CreateAssemblyCategoriesInput(failureMechanism.GeneralInput.N, + failureMechanism, + assessmentSection); + } + } +} \ No newline at end of file Index: Riskeer/HeightStructures/src/Riskeer.HeightStructures.Forms/Factories/HeightStructuresAssemblyMapDataFeaturesFactory.cs =================================================================== diff -u -rd07611d7e455e358e7255b2807447412ac56f9c6 -ree815ae0e4b99e726400fe3f5d37d2c99b25a3a0 --- Riskeer/HeightStructures/src/Riskeer.HeightStructures.Forms/Factories/HeightStructuresAssemblyMapDataFeaturesFactory.cs (.../HeightStructuresAssemblyMapDataFeaturesFactory.cs) (revision d07611d7e455e358e7255b2807447412ac56f9c6) +++ Riskeer/HeightStructures/src/Riskeer.HeightStructures.Forms/Factories/HeightStructuresAssemblyMapDataFeaturesFactory.cs (.../HeightStructuresAssemblyMapDataFeaturesFactory.cs) (revision ee815ae0e4b99e726400fe3f5d37d2c99b25a3a0) @@ -52,7 +52,7 @@ return AssemblyMapDataFeaturesFactory.CreateAssemblyFeatures( failureMechanism, - HeightStructuresFailureMechanismAssemblyFactory.AssembleSimpleAssessment); + HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleSimpleAssessment); } /// @@ -78,7 +78,7 @@ return AssemblyMapDataFeaturesFactory.CreateAssemblyFeatures( failureMechanism, - sectionResult => HeightStructuresFailureMechanismAssemblyFactory.AssembleDetailedAssessment( + sectionResult => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleDetailedAssessment( sectionResult, failureMechanism.Calculations.Cast>(), failureMechanism, @@ -107,9 +107,9 @@ return AssemblyMapDataFeaturesFactory.CreateAssemblyFeatures( failureMechanism, - sectionResult => HeightStructuresFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(sectionResult, - failureMechanism, - assessmentSection)); + sectionResult => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleTailorMadeAssessment(sectionResult, + failureMechanism, + assessmentSection)); } /// @@ -134,7 +134,7 @@ return AssemblyMapDataFeaturesFactory.CreateAssemblyFeatures( failureMechanism, - sectionResult => HeightStructuresFailureMechanismAssemblyFactory.AssembleCombinedAssessment( + sectionResult => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleCombinedAssessment( sectionResult, failureMechanism.Calculations.Cast>(), failureMechanism, Index: Riskeer/HeightStructures/test/Riskeer.HeightStructures.Data.Test/HeightStructuresFailureMechanismAssemblyFactoryOldTest.cs =================================================================== diff -u --- Riskeer/HeightStructures/test/Riskeer.HeightStructures.Data.Test/HeightStructuresFailureMechanismAssemblyFactoryOldTest.cs (revision 0) +++ Riskeer/HeightStructures/test/Riskeer.HeightStructures.Data.Test/HeightStructuresFailureMechanismAssemblyFactoryOldTest.cs (revision ee815ae0e4b99e726400fe3f5d37d2c99b25a3a0) @@ -0,0 +1,1217 @@ +// 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 System.Linq; +using Core.Common.TestUtil; +using NUnit.Framework; +using Rhino.Mocks; +using Riskeer.AssemblyTool.Data; +using Riskeer.AssemblyTool.Data.TestUtil; +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.Exceptions; +using Riskeer.Common.Data.FailureMechanism; +using Riskeer.Common.Data.Structures; +using Riskeer.Common.Data.TestUtil; +using Riskeer.Common.Primitives; + +namespace Riskeer.HeightStructures.Data.Test +{ + [TestFixture] + public class HeightStructuresFailureMechanismAssemblyFactoryOldTest + { + private static void AssertAssemblyCategoriesInput(IAssessmentSection assessmentSection, + HeightStructuresFailureMechanism failureMechanism, + AssemblyCategoriesInput assemblyCategoriesInput) + { + Assert.AreEqual(assessmentSection.FailureMechanismContribution.SignalingNorm, assemblyCategoriesInput.SignalingNorm); + Assert.AreEqual(assessmentSection.FailureMechanismContribution.LowerLimitNorm, assemblyCategoriesInput.LowerLimitNorm); + Assert.AreEqual(failureMechanism.Contribution, assemblyCategoriesInput.FailureMechanismContribution); + Assert.AreEqual(failureMechanism.GeneralInput.N, assemblyCategoriesInput.N); + } + + #region Simple Assembly + + [Test] + public void AssembleSimpleAssessment_FailureMechanismSectionResultNull_ThrowsArgumentNullException() + { + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleSimpleAssessment(null); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("failureMechanismSectionResult", exception.ParamName); + } + + [Test] + public void AssembleSimpleAssessment_WithSectionResult_SetsInputOnCalculator() + { + // Setup + var random = new Random(21); + FailureMechanismSection failureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var sectionResult = new HeightStructuresFailureMechanismSectionResultOld(failureMechanismSection) + { + SimpleAssessmentResult = random.NextEnumValue() + }; + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleSimpleAssessment(sectionResult); + + // Assert + Assert.AreEqual(sectionResult.SimpleAssessmentResult, calculator.SimpleAssessmentInput); + } + } + + [Test] + public void AssembleSimpleAssessment_AssemblyRan_ReturnsOutput() + { + // Setup + FailureMechanismSection failureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var sectionResult = new HeightStructuresFailureMechanismSectionResultOld(failureMechanismSection); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyOld actualOutput = + HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleSimpleAssessment(sectionResult); + + // Assert + FailureMechanismSectionAssemblyOld calculatorOutput = calculator.SimpleAssessmentAssemblyOutput; + Assert.AreSame(calculatorOutput, actualOutput); + } + } + + [Test] + public void AssembleSimpleAssessment_CalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + FailureMechanismSection failureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var sectionResult = new HeightStructuresFailureMechanismSectionResultOld(failureMechanismSection); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculate = true; + + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleSimpleAssessment(sectionResult); + + // Assert + var exception = Assert.Throws(Call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + #endregion + + #region Detailed Assembly + + [Test] + public void AssembleDetailedAssessment_FailureMechanismSectionResultNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleDetailedAssessment( + null, Enumerable.Empty>(), + new HeightStructuresFailureMechanism(), assessmentSection); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("failureMechanismSectionResult", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void AssembleDetailedAssessment_CalculationScenariosNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleDetailedAssessment( + new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()), + null, new HeightStructuresFailureMechanism(), assessmentSection); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("calculationScenarios", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void AssembleDetailedAssessment_FailureMechanismNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleDetailedAssessment( + new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()), + Enumerable.Empty>(), null, assessmentSection); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("failureMechanism", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void AssembleDetailedAssessment_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleDetailedAssessment( + new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()), + Enumerable.Empty>(), new HeightStructuresFailureMechanism(), null); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + public void AssembleDetailedAssessment_WithInput_SetsInputOnCalculator() + { + // Setup + var failureMechanism = new HeightStructuresFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + var sectionResult = new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + DetailedAssessmentResult = new Random(21).NextEnumValue() + }; + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleDetailedAssessment( + sectionResult, Enumerable.Empty>(), + failureMechanism, assessmentSection); + + // Assert + Assert.AreEqual(sectionResult.GetDetailedAssessmentProbability( + Enumerable.Empty>()), + calculator.DetailedAssessmentProbabilityInput); + Assert.AreEqual(sectionResult.DetailedAssessmentResult, calculator.DetailedAssessmentProbabilityOnlyResultInput); + AssertAssemblyCategoriesInput(assessmentSection, failureMechanism, calculator.DetailedAssessmentAssemblyCategoriesInput); + mocks.VerifyAll(); + } + } + + [Test] + public void AssembleDetailedAssessment_AssemblyRan_ReturnsOutput() + { + // Setup + var failureMechanism = new HeightStructuresFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + var sectionResult = new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyOld actualOutput = + HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleDetailedAssessment( + sectionResult, Enumerable.Empty>(), + failureMechanism, assessmentSection); + + // Assert + FailureMechanismSectionAssemblyOld calculatorOutput = calculator.DetailedAssessmentAssemblyOutput; + Assert.AreSame(calculatorOutput, actualOutput); + mocks.VerifyAll(); + } + } + + [Test] + public void AssembleDetailedAssessment_CalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + var failureMechanism = new HeightStructuresFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + var sectionResult = new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculate = true; + + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleDetailedAssessment( + sectionResult, Enumerable.Empty>(), + failureMechanism, assessmentSection); + + // Assert + var exception = Assert.Throws(Call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + mocks.VerifyAll(); + } + } + + #endregion + + #region Tailor Made Assembly + + [Test] + public void AssembleTailorMadeAssessment_FailureMechanismSectionResultNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleTailorMadeAssessment( + null, new HeightStructuresFailureMechanism(), assessmentSection); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("failureMechanismSectionResult", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void AssembleTailorMadeAssessment_FailureMechanismNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleTailorMadeAssessment( + new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()), + null, assessmentSection); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("failureMechanism", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void AssembleTailorMadeAssessment_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleTailorMadeAssessment( + new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()), + new HeightStructuresFailureMechanism(), null); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + public void AssembleTailorMadeAssessment_WithInput_SetsInputOnCalculator() + { + // Setup + var failureMechanism = new HeightStructuresFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + var sectionResult = new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleTailorMadeAssessment( + sectionResult, + failureMechanism, + assessmentSection); + + // Assert + Assert.AreEqual(sectionResult.TailorMadeAssessmentProbability, calculator.TailorMadeAssessmentProbabilityInput); + Assert.AreEqual(sectionResult.TailorMadeAssessmentResult, calculator.TailorMadeAssessmentProbabilityCalculationResultInput); + AssertAssemblyCategoriesInput(assessmentSection, failureMechanism, calculator.TailorMadeAssessmentAssemblyCategoriesInput); + mocks.VerifyAll(); + } + } + + [Test] + public void AssembleTailorMadeAssessment_AssemblyRan_ReturnsOutput() + { + // Setup + var failureMechanism = new HeightStructuresFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + var sectionResult = new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyOld actualOutput = + HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleTailorMadeAssessment( + sectionResult, + failureMechanism, + assessmentSection); + + // Assert + FailureMechanismSectionAssemblyOld calculatorOutput = calculator.TailorMadeAssessmentAssemblyOutput; + Assert.AreSame(calculatorOutput, actualOutput); + mocks.VerifyAll(); + } + } + + [Test] + public void AssembleTailorMadeAssessment_CalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + var failureMechanism = new HeightStructuresFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + var sectionResult = new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculate = true; + + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleTailorMadeAssessment( + sectionResult, failureMechanism, assessmentSection); + + // Assert + var exception = Assert.Throws(Call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + mocks.VerifyAll(); + } + } + + #endregion + + #region Combined Assembly + + [Test] + public void AssembleCombinedAssessment_FailureMechanismSectionResultNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleCombinedAssessment( + null, Enumerable.Empty>(), + new HeightStructuresFailureMechanism(), assessmentSection); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("failureMechanismSectionResult", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void AssembleCombinedAssessment_CalculationScenariosNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleCombinedAssessment( + new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()), + null, new HeightStructuresFailureMechanism(), assessmentSection); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("calculationScenarios", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void AssembleCombinedAssessment_FailureMechanismNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleCombinedAssessment( + new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()), + Enumerable.Empty>(), null, assessmentSection); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("failureMechanism", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void AssembleCombinedAssessment_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleCombinedAssessment( + new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()), + Enumerable.Empty>(), new HeightStructuresFailureMechanism(), null); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + [TestCase(SimpleAssessmentResultType.None)] + [TestCase(SimpleAssessmentResultType.AssessFurther)] + public void AssembleCombinedAssessment_WithVariousSimpleAssessmentInputAssemblesWithAllInformation_SetsInputOnCalculator(SimpleAssessmentResultType simpleAssessmentResult) + { + // Setup + var failureMechanism = new HeightStructuresFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + var sectionResult = new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + SimpleAssessmentResult = simpleAssessmentResult + }; + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleCombinedAssessment( + sectionResult, Enumerable.Empty>(), + failureMechanism, assessmentSection); + + // Assert + AssemblyToolTestHelper.AssertAreEqual(calculator.SimpleAssessmentAssemblyOutput, calculator.CombinedSimpleAssemblyInput); + AssemblyToolTestHelper.AssertAreEqual(calculator.DetailedAssessmentAssemblyOutput, calculator.CombinedDetailedAssemblyInput); + AssemblyToolTestHelper.AssertAreEqual(calculator.TailorMadeAssessmentAssemblyOutput, calculator.CombinedTailorMadeAssemblyInput); + mocks.VerifyAll(); + } + } + + [Test] + [TestCase(SimpleAssessmentResultType.NotApplicable)] + [TestCase(SimpleAssessmentResultType.ProbabilityNegligible)] + public void AssembleCombinedAssessment_WithVariousSimpleAssessmentInputAssemblesWithOnlySimpleAssessmentInput_SetsInputOnCalculator( + SimpleAssessmentResultType simpleAssessmentResult) + { + // Setup + var failureMechanism = new HeightStructuresFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + var sectionResult = new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + SimpleAssessmentResult = simpleAssessmentResult + }; + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleCombinedAssessment( + sectionResult, Enumerable.Empty>(), + failureMechanism, assessmentSection); + + // Assert + AssemblyToolTestHelper.AssertAreEqual(calculator.SimpleAssessmentAssemblyOutput, calculator.CombinedSimpleAssemblyInput); + Assert.IsNull(calculator.CombinedDetailedAssemblyInput); + Assert.IsNull(calculator.CombinedTailorMadeAssemblyInput); + mocks.VerifyAll(); + } + } + + [Test] + public void AssembleCombinedAssessment_AssemblyRan_ReturnsOutput() + { + // Setup + var failureMechanism = new HeightStructuresFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + var sectionResult = new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyOld actualOutput = + HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleCombinedAssessment( + sectionResult, Enumerable.Empty>(), + failureMechanism, assessmentSection); + + // Assert + Assert.AreSame(calculator.CombinedAssemblyOutput, actualOutput); + mocks.VerifyAll(); + } + } + + [Test] + public void AssembleCombinedAssessment_CalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + var failureMechanism = new HeightStructuresFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + var sectionResult = new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculateCombinedAssembly = true; + + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleCombinedAssessment( + sectionResult, Enumerable.Empty>(), + failureMechanism, assessmentSection); + + // Assert + var exception = Assert.Throws(Call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + mocks.VerifyAll(); + } + } + + #endregion + + #region GetSectionAssemblyCategoryGroup + + [Test] + public void GetSectionAssemblyCategoryGroup_FailureMechanismSectionResultNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.GetSectionAssemblyCategoryGroup( + null, new HeightStructuresFailureMechanism(), assessmentSection, new Random(39).NextBoolean()); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("failureMechanismSectionResult", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void GetSectionAssemblyCategoryGroup_FailureMechanismNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.GetSectionAssemblyCategoryGroup( + new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()), + null, assessmentSection, new Random(39).NextBoolean()); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("failureMechanism", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void GetSectionAssemblyCategoryGroup_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.GetSectionAssemblyCategoryGroup( + new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()), + new HeightStructuresFailureMechanism(), null, new Random(39).NextBoolean()); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + public void GetSectionAssemblyCategoryGroup_WithoutManualInput_SetsInputOnCalculator() + { + // Setup + var sectionResult = new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + var failureMechanism = new HeightStructuresFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + HeightStructuresFailureMechanismAssemblyFactoryOld.GetSectionAssemblyCategoryGroup( + sectionResult, + failureMechanism, + assessmentSection, + new Random(39).NextBoolean()); + + // Assert + AssemblyToolTestHelper.AssertAreEqual(calculator.SimpleAssessmentAssemblyOutput, calculator.CombinedSimpleAssemblyInput); + AssemblyToolTestHelper.AssertAreEqual(calculator.DetailedAssessmentAssemblyOutput, calculator.CombinedDetailedAssemblyInput); + AssemblyToolTestHelper.AssertAreEqual(calculator.TailorMadeAssessmentAssemblyOutput, calculator.CombinedTailorMadeAssemblyInput); + mocks.VerifyAll(); + } + } + + [Test] + public void GetSectionAssemblyCategoryGroup_WithManualInputAndUseManualTrue_SetsInputOnCalculator() + { + // Setup + var random = new Random(39); + var sectionResult = new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssembly = true, + ManualAssemblyProbability = random.NextDouble(), + TailorMadeAssessmentResult = random.NextEnumValue(), + TailorMadeAssessmentProbability = random.NextDouble() + }; + + var failureMechanism = new HeightStructuresFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + HeightStructuresFailureMechanismAssemblyFactoryOld.GetSectionAssemblyCategoryGroup( + sectionResult, + failureMechanism, + assessmentSection, + true); + + // Assert + Assert.AreEqual(sectionResult.ManualAssemblyProbability, calculator.ManualAssemblyProbabilityInput); + Assert.AreEqual(0.0, calculator.TailorMadeAssessmentProbabilityInput); + Assert.AreEqual((TailorMadeAssessmentProbabilityCalculationResultType) 0, calculator.TailorMadeAssessmentProbabilityCalculationResultInput); + mocks.VerifyAll(); + } + } + + [Test] + public void GetSectionAssemblyCategoryGroup_WithManualInputAndUseManualFalse_SetsInputOnCalculator() + { + // Setup + var random = new Random(39); + var sectionResult = new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssembly = true, + ManualAssemblyProbability = random.NextDouble(), + TailorMadeAssessmentResult = random.NextEnumValue(), + TailorMadeAssessmentProbability = random.NextDouble() + }; + + var failureMechanism = new HeightStructuresFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + HeightStructuresFailureMechanismAssemblyFactoryOld.GetSectionAssemblyCategoryGroup( + sectionResult, + failureMechanism, + assessmentSection, + false); + + // Assert + Assert.AreEqual(0.0, calculator.ManualAssemblyProbabilityInput); + Assert.AreEqual(sectionResult.TailorMadeAssessmentProbability, calculator.TailorMadeAssessmentProbabilityInput); + Assert.AreEqual(sectionResult.TailorMadeAssessmentResult, calculator.TailorMadeAssessmentProbabilityCalculationResultInput); + mocks.VerifyAll(); + } + } + + [Test] + public void GetSectionAssemblyCategoryGroup_WithoutManualInput_ReturnsOutput() + { + // Setup + var sectionResult = new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + var failureMechanism = new HeightStructuresFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyCategoryGroup categoryGroup = HeightStructuresFailureMechanismAssemblyFactoryOld.GetSectionAssemblyCategoryGroup( + sectionResult, + failureMechanism, + assessmentSection, + new Random(39).NextBoolean()); + + // Assert + Assert.AreEqual(calculator.CombinedAssemblyOutput.Group, categoryGroup); + mocks.VerifyAll(); + } + } + + [Test] + public void GetSectionAssemblyCategoryGroup_WithManualInputAndUseManualTrue_ReturnsOutput() + { + // Setup + var sectionResult = new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssembly = true, + ManualAssemblyProbability = new Random(39).NextDouble() + }; + + var failureMechanism = new HeightStructuresFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyCategoryGroup categoryGroup = HeightStructuresFailureMechanismAssemblyFactoryOld.GetSectionAssemblyCategoryGroup( + sectionResult, + failureMechanism, + assessmentSection, + true); + + // Assert + Assert.AreEqual(calculator.ManualAssemblyAssemblyOutput.Group, categoryGroup); + mocks.VerifyAll(); + } + } + + [Test] + public void GetSectionAssemblyCategoryGroup_WithManualInputAndUseManualFalse_ReturnsOutput() + { + // Setup + var sectionResult = new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssembly = true, + ManualAssemblyProbability = new Random(39).NextDouble() + }; + + var failureMechanism = new HeightStructuresFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyCategoryGroup categoryGroup = HeightStructuresFailureMechanismAssemblyFactoryOld.GetSectionAssemblyCategoryGroup( + sectionResult, + failureMechanism, + assessmentSection, + false); + + // Assert + Assert.AreEqual(calculator.CombinedAssemblyOutput.Group, categoryGroup); + mocks.VerifyAll(); + } + } + + [Test] + [TestCase(true)] + [TestCase(false)] + public void GetSectionAssemblyCategoryGroup_CalculatorThrowsException_ThrowsAssemblyException(bool useManualAssembly) + { + // Setup + var sectionResult = new HeightStructuresFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssembly = useManualAssembly + }; + var failureMechanism = new HeightStructuresFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + if (useManualAssembly) + { + calculator.ThrowExceptionOnCalculate = true; + } + else + { + calculator.ThrowExceptionOnCalculateCombinedAssembly = true; + } + + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.GetSectionAssemblyCategoryGroup( + sectionResult, failureMechanism, assessmentSection, useManualAssembly); + + // Assert + var exception = Assert.Throws(Call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + mocks.VerifyAll(); + } + } + + #endregion + + #region Failure Mechanism Assembly + + [Test] + public void AssembleFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleFailureMechanism( + null, assessmentSection, new Random(39).NextBoolean()); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("failureMechanism", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void AssembleFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleFailureMechanism( + new HeightStructuresFailureMechanism(), null, new Random(39).NextBoolean()); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + public void AssembleFailureMechanism_FailureMechanismNotInAssembly_ReturnsNotApplicableAssembly() + { + // Setup + var failureMechanism = new HeightStructuresFailureMechanism + { + InAssembly = false + }; + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + // Call + FailureMechanismAssembly assembly = HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleFailureMechanism( + failureMechanism, + assessmentSection, + new Random(39).NextBoolean()); + + // Assert + AssemblyToolTestHelper.AssertAreEqual(FailureMechanismAssemblyResultFactoryOld.CreateNotApplicableAssembly(), assembly); + mocks.VerifyAll(); + } + + [Test] + public void AssembleFailureMechanism_WithoutManualInput_SetsInputOnCalculator() + { + // Setup + var failureMechanism = new HeightStructuresFailureMechanism(); + FailureMechanismTestHelper.SetSections(failureMechanism, new[] + { + FailureMechanismSectionTestFactory.CreateFailureMechanismSection() + }); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + FailureMechanismSectionAssemblyCalculatorOldStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleFailureMechanism( + failureMechanism, + assessmentSection, + new Random(39).NextBoolean()); + + // Assert + AssemblyToolTestHelper.AssertAreEqual(sectionCalculator.CombinedAssemblyOutput, calculator.FailureMechanismSectionAssemblies.Single()); + mocks.VerifyAll(); + } + } + + [Test] + public void AssembleFailureMechanism_WithManualInputAndUseManualTrue_SetsInputOnCalculator() + { + // Setup + var failureMechanism = new HeightStructuresFailureMechanism(); + FailureMechanismTestHelper.SetSections(failureMechanism, new[] + { + FailureMechanismSectionTestFactory.CreateFailureMechanismSection() + }); + HeightStructuresFailureMechanismSectionResultOld sectionResult = failureMechanism.SectionResultsOld.Single(); + sectionResult.UseManualAssembly = true; + sectionResult.ManualAssemblyProbability = new Random(39).NextDouble(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + FailureMechanismSectionAssemblyCalculatorOldStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleFailureMechanism( + failureMechanism, + assessmentSection, + true); + + // Assert + AssemblyToolTestHelper.AssertAreEqual(sectionCalculator.ManualAssemblyAssemblyOutput, calculator.FailureMechanismSectionAssemblies.Single()); + mocks.VerifyAll(); + } + } + + [Test] + public void AssembleFailureMechanism_WithManualInputAndUseManualFalse_SetsInputOnCalculator() + { + // Setup + var failureMechanism = new HeightStructuresFailureMechanism(); + FailureMechanismTestHelper.SetSections(failureMechanism, new[] + { + FailureMechanismSectionTestFactory.CreateFailureMechanismSection() + }); + HeightStructuresFailureMechanismSectionResultOld sectionResult = failureMechanism.SectionResultsOld.Single(); + sectionResult.UseManualAssembly = true; + sectionResult.ManualAssemblyProbability = new Random(39).NextDouble(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + FailureMechanismSectionAssemblyCalculatorOldStub sectionCalculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleFailureMechanism( + failureMechanism, + assessmentSection, + false); + + // Assert + AssemblyToolTestHelper.AssertAreEqual(sectionCalculator.CombinedAssemblyOutput, calculator.FailureMechanismSectionAssemblies.Single()); + mocks.VerifyAll(); + } + } + + [Test] + public void AssembleFailureMechanism_AssemblyRan_ReturnsOutput() + { + // Setup + var failureMechanism = new HeightStructuresFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + FailureMechanismAssembly actualOutput = + HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleFailureMechanism( + failureMechanism, + assessmentSection, + new Random(39).NextBoolean()); + + // Assert + Assert.AreSame(calculator.FailureMechanismAssemblyOutput, actualOutput); + mocks.VerifyAll(); + } + } + + [Test] + public void AssembleFailureMechanism_FailureMechanismCalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + var failureMechanism = new HeightStructuresFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + calculator.ThrowExceptionOnCalculate = true; + + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleFailureMechanism( + failureMechanism, assessmentSection, new Random(39).NextBoolean()); + + // Assert + var exception = Assert.Throws(Call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + mocks.VerifyAll(); + } + } + + [Test] + public void AssembleFailureMechanism_FailureMechanismSectionCalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + var failureMechanism = new HeightStructuresFailureMechanism(); + FailureMechanismTestHelper.SetSections(failureMechanism, new[] + { + FailureMechanismSectionTestFactory.CreateFailureMechanismSection() + }); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculateCombinedAssembly = true; + + // Call + void Call() => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleFailureMechanism( + failureMechanism, assessmentSection, new Random(39).NextBoolean()); + + // Assert + var exception = Assert.Throws(Call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual("Voor een of meerdere vakken kan geen resultaat worden bepaald.", exception.Message); + mocks.VerifyAll(); + } + } + + #endregion + } +} \ No newline at end of file Fisheye: Tag ee815ae0e4b99e726400fe3f5d37d2c99b25a3a0 refers to a dead (removed) revision in file `Riskeer/HeightStructures/test/Riskeer.HeightStructures.Data.Test/HeightStructuresFailureMechanismAssemblyFactoryTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/AssessmentSectionAssemblyFactory.cs =================================================================== diff -u -reb0db539d74db9edf5a167a21807405812c6529b -ree815ae0e4b99e726400fe3f5d37d2c99b25a3a0 --- Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/AssessmentSectionAssemblyFactory.cs (.../AssessmentSectionAssemblyFactory.cs) (revision eb0db539d74db9edf5a167a21807405812c6529b) +++ Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/AssessmentSectionAssemblyFactory.cs (.../AssessmentSectionAssemblyFactory.cs) (revision ee815ae0e4b99e726400fe3f5d37d2c99b25a3a0) @@ -209,7 +209,7 @@ return new[] { GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleFailureMechanism(assessmentSection.GrassCoverErosionInwards, assessmentSection, useManual), - HeightStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.HeightStructures, assessmentSection, useManual), + HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleFailureMechanism(assessmentSection.HeightStructures, assessmentSection, useManual), ClosingStructuresFailureMechanismAssemblyFactoryOld.AssembleFailureMechanism(assessmentSection.ClosingStructures, assessmentSection, useManual), StabilityPointStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.StabilityPointStructures, assessmentSection, useManual), PipingFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.Piping, assessmentSection, useManual), Index: Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedAssemblyFailureMechanismSectionFactory.cs =================================================================== diff -u -reb0db539d74db9edf5a167a21807405812c6529b -ree815ae0e4b99e726400fe3f5d37d2c99b25a3a0 --- Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedAssemblyFailureMechanismSectionFactory.cs (.../CombinedAssemblyFailureMechanismSectionFactory.cs) (revision eb0db539d74db9edf5a167a21807405812c6529b) +++ Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedAssemblyFailureMechanismSectionFactory.cs (.../CombinedAssemblyFailureMechanismSectionFactory.cs) (revision ee815ae0e4b99e726400fe3f5d37d2c99b25a3a0) @@ -314,7 +314,7 @@ { get { - return (sectionResult, assessmentSection, useManual) => HeightStructuresFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( + return (sectionResult, assessmentSection, useManual) => HeightStructuresFailureMechanismAssemblyFactoryOld.GetSectionAssemblyCategoryGroup( sectionResult, assessmentSection.HeightStructures, assessmentSection, useManual); } } Index: Riskeer/Integration/src/Riskeer.Integration.Forms/Views/AssemblyResultTotalView.cs =================================================================== diff -u -reb0db539d74db9edf5a167a21807405812c6529b -ree815ae0e4b99e726400fe3f5d37d2c99b25a3a0 --- Riskeer/Integration/src/Riskeer.Integration.Forms/Views/AssemblyResultTotalView.cs (.../AssemblyResultTotalView.cs) (revision eb0db539d74db9edf5a167a21807405812c6529b) +++ Riskeer/Integration/src/Riskeer.Integration.Forms/Views/AssemblyResultTotalView.cs (.../AssemblyResultTotalView.cs) (revision ee815ae0e4b99e726400fe3f5d37d2c99b25a3a0) @@ -300,9 +300,9 @@ { HeightStructuresFailureMechanism heightStructures = AssessmentSection.HeightStructures; return new FailureMechanismAssemblyResultRow(heightStructures, - () => HeightStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(heightStructures, - AssessmentSection, - true)); + () => HeightStructuresFailureMechanismAssemblyFactoryOld.AssembleFailureMechanism(heightStructures, + AssessmentSection, + true)); } private FailureMechanismAssemblyResultRow CreateStabilityPointsStructuresFailureMechanismAssemblyResultRow()