Fisheye: Tag df3c3ac4860db8af1cbf61c7bc8661ed1db22bd0 refers to a dead (removed) revision in file `Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Data/GrassCoverErosionInwardsFailureMechanismAssemblyFactory.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Data/GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.cs =================================================================== diff -u --- Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Data/GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.cs (revision 0) +++ Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Data/GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.cs (revision df3c3ac4860db8af1cbf61c7bc8661ed1db22bd0) @@ -0,0 +1,392 @@ +// 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.Primitives; +using RiskeerCommonDataResources = Riskeer.Common.Data.Properties.Resources; + +namespace Riskeer.GrassCoverErosionInwards.Data +{ + /// + /// Factory for assembling assembly results for a grass cover erosion inwards failure mechanism. + /// + public static class GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld + { + /// + /// 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( + GrassCoverErosionInwardsFailureMechanismSectionResultOld 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. + /// The calculation scenarios belonging to this section. + /// 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( + GrassCoverErosionInwardsFailureMechanismSectionResultOld failureMechanismSectionResult, + IEnumerable calculationScenarios, + GrassCoverErosionInwardsFailureMechanism 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( + GrassCoverErosionInwardsFailureMechanismSectionResultOld failureMechanismSectionResult, + GrassCoverErosionInwardsFailureMechanism 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. + /// The calculation scenarios belonging to this section. + /// 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( + GrassCoverErosionInwardsFailureMechanismSectionResultOld failureMechanismSectionResult, + IEnumerable calculationScenarios, + GrassCoverErosionInwardsFailureMechanism 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 == SimpleAssessmentValidityOnlyResultType.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(GrassCoverErosionInwardsFailureMechanismSectionResultOld failureMechanismSectionResult, + GrassCoverErosionInwardsFailureMechanism 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( + GrassCoverErosionInwardsFailureMechanism 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(GrassCoverErosionInwardsFailureMechanismSectionResultOld failureMechanismSectionResult, + GrassCoverErosionInwardsFailureMechanism 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(GrassCoverErosionInwardsFailureMechanismSectionResultOld 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(GrassCoverErosionInwardsFailureMechanism failureMechanism, + IAssessmentSection assessmentSection) + { + return AssemblyCategoriesInputFactory.CreateAssemblyCategoriesInput(failureMechanism.GeneralInput.N, + failureMechanism, + assessmentSection); + } + } +} \ No newline at end of file Index: Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Forms/Factories/GrassCoverErosionInwardsAssemblyMapDataFeaturesFactory.cs =================================================================== diff -u -rd07611d7e455e358e7255b2807447412ac56f9c6 -rdf3c3ac4860db8af1cbf61c7bc8661ed1db22bd0 --- Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Forms/Factories/GrassCoverErosionInwardsAssemblyMapDataFeaturesFactory.cs (.../GrassCoverErosionInwardsAssemblyMapDataFeaturesFactory.cs) (revision d07611d7e455e358e7255b2807447412ac56f9c6) +++ Riskeer/GrassCoverErosionInwards/src/Riskeer.GrassCoverErosionInwards.Forms/Factories/GrassCoverErosionInwardsAssemblyMapDataFeaturesFactory.cs (.../GrassCoverErosionInwardsAssemblyMapDataFeaturesFactory.cs) (revision df3c3ac4860db8af1cbf61c7bc8661ed1db22bd0) @@ -51,7 +51,7 @@ return AssemblyMapDataFeaturesFactory.CreateAssemblyFeatures( failureMechanism, - GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleSimpleAssessment); + GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleSimpleAssessment); } /// @@ -77,7 +77,7 @@ return AssemblyMapDataFeaturesFactory.CreateAssemblyFeatures( failureMechanism, - sectionResult => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleDetailedAssessment( + sectionResult => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleDetailedAssessment( sectionResult, failureMechanism.Calculations.Cast(), failureMechanism, @@ -106,9 +106,9 @@ return AssemblyMapDataFeaturesFactory.CreateAssemblyFeatures( failureMechanism, - sectionResult => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleTailorMadeAssessment(sectionResult, - failureMechanism, - assessmentSection)); + sectionResult => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleTailorMadeAssessment(sectionResult, + failureMechanism, + assessmentSection)); } /// @@ -133,7 +133,7 @@ return AssemblyMapDataFeaturesFactory.CreateAssemblyFeatures( failureMechanism, - sectionResult => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleCombinedAssessment( + sectionResult => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleCombinedAssessment( sectionResult, failureMechanism.Calculations.Cast(), failureMechanism, Index: Riskeer/GrassCoverErosionInwards/test/Riskeer.GrassCoverErosionInwards.Data.Test/GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOldTest.cs =================================================================== diff -u --- Riskeer/GrassCoverErosionInwards/test/Riskeer.GrassCoverErosionInwards.Data.Test/GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOldTest.cs (revision 0) +++ Riskeer/GrassCoverErosionInwards/test/Riskeer.GrassCoverErosionInwards.Data.Test/GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOldTest.cs (revision df3c3ac4860db8af1cbf61c7bc8661ed1db22bd0) @@ -0,0 +1,1157 @@ +// 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.TestUtil; +using Riskeer.Common.Primitives; + +namespace Riskeer.GrassCoverErosionInwards.Data.Test +{ + [TestFixture] + public class GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOldTest + { + private static void AssertAssemblyCategoriesInput(IAssessmentSection assessmentSection, + GrassCoverErosionInwardsFailureMechanism 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() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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 GrassCoverErosionInwardsFailureMechanismSectionResultOld(failureMechanismSection) + { + SimpleAssessmentResult = random.NextEnumValue() + }; + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleSimpleAssessment(sectionResult); + + // Assert + Assert.AreEqual(sectionResult.SimpleAssessmentResult, calculator.SimpleAssessmentValidityOnlyInput); + } + } + + [Test] + public void AssembleSimpleAssessment_AssemblyRan_ReturnsOutput() + { + // Setup + FailureMechanismSection failureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); + var sectionResult = new GrassCoverErosionInwardsFailureMechanismSectionResultOld(failureMechanismSection); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyOld actualOutput = + GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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 GrassCoverErosionInwardsFailureMechanismSectionResultOld(failureMechanismSection); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculate = true; + + // Call + void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleDetailedAssessment( + null, Enumerable.Empty(), + new GrassCoverErosionInwardsFailureMechanism(), assessmentSection); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("failureMechanismSectionResult", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void AssembleDetailedAssessment_FailureMechanismNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + var sectionResult = new GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + // Call + void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleDetailedAssessment( + sectionResult, Enumerable.Empty(), null, assessmentSection); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("failureMechanism", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void AssembleDetailedAssessment_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Setup + var sectionResult = new GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + // Call + void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleDetailedAssessment( + sectionResult, Enumerable.Empty(), + new GrassCoverErosionInwardsFailureMechanism(), null); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + public void AssembleDetailedAssessment_WithInput_SetsInputOnCalculator() + { + // Setup + var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + var sectionResult = new GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + DetailedAssessmentResult = new Random(21).NextEnumValue() + }; + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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 GrassCoverErosionInwardsFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + var sectionResult = new GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyOld actualOutput = + GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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 GrassCoverErosionInwardsFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + var sectionResult = new GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculate = true; + + // Call + void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleTailorMadeAssessment( + null, new GrassCoverErosionInwardsFailureMechanism(), 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() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleTailorMadeAssessment( + new GrassCoverErosionInwardsFailureMechanismSectionResultOld(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() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleTailorMadeAssessment( + new GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()), + new GrassCoverErosionInwardsFailureMechanism(), null); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + public void AssembleTailorMadeAssessment_WithInput_SetsInputOnCalculator() + { + // Setup + var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + var sectionResult = new GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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 GrassCoverErosionInwardsFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + var sectionResult = new GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyOld actualOutput = + GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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 GrassCoverErosionInwardsFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + var sectionResult = new GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculate = true; + + // Call + void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleCombinedAssessment( + null, Enumerable.Empty(), + new GrassCoverErosionInwardsFailureMechanism(), assessmentSection); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("failureMechanismSectionResult", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void AssembleCombinedAssessment_FailureMechanismNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleCombinedAssessment( + new GrassCoverErosionInwardsFailureMechanismSectionResultOld(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() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleCombinedAssessment( + new GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()), + Enumerable.Empty(), new GrassCoverErosionInwardsFailureMechanism(), null); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + [TestCase(SimpleAssessmentValidityOnlyResultType.None)] + [TestCase(SimpleAssessmentValidityOnlyResultType.Applicable)] + public void AssembleCombinedAssessment_WithVariousSimpleAssessmentInputAssemblesWithAllInformation_SetsInputOnCalculator( + SimpleAssessmentValidityOnlyResultType simpleAssessmentResult) + { + // Setup + var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + var sectionResult = new GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + SimpleAssessmentResult = simpleAssessmentResult + }; + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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] + public void AssembleCombinedAssessment_WithInputSimpleAssessmentNotApplicable_SetsInputOnCalculator() + { + // Setup + var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + var sectionResult = new GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + SimpleAssessmentResult = SimpleAssessmentValidityOnlyResultType.NotApplicable + }; + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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 GrassCoverErosionInwardsFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + var sectionResult = new GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + + // Call + FailureMechanismSectionAssemblyOld actualOutput = + GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleCombinedAssessment( + sectionResult, Enumerable.Empty(), + failureMechanism, assessmentSection); + + // Assert + Assert.AreSame(calculator.CombinedAssemblyOutput, actualOutput); + mocks.VerifyAll(); + } + } + + [Test] + public void AssembleCombinedAssessment_CalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + var sectionResult = new GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + + using (new AssemblyToolCalculatorFactoryConfigOld()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactoryOld) AssemblyToolCalculatorFactoryOld.Instance; + FailureMechanismSectionAssemblyCalculatorOldStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculateCombinedAssembly = true; + + // Call + void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.GetSectionAssemblyCategoryGroup( + null, new GrassCoverErosionInwardsFailureMechanism(), 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() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.GetSectionAssemblyCategoryGroup( + new GrassCoverErosionInwardsFailureMechanismSectionResultOld(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() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.GetSectionAssemblyCategoryGroup( + new GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()), + new GrassCoverErosionInwardsFailureMechanism(), 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 GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); + + 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 + GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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 GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssembly = true, + ManualAssemblyProbability = random.NextDouble(), + TailorMadeAssessmentResult = random.NextEnumValue(), + TailorMadeAssessmentProbability = random.NextDouble() + }; + + var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); + + 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 + GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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 GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssembly = true, + ManualAssemblyProbability = random.NextDouble(), + TailorMadeAssessmentResult = random.NextEnumValue(), + TailorMadeAssessmentProbability = random.NextDouble() + }; + + var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); + + 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 + GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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 GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); + var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); + + 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 = GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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 GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssembly = true, + ManualAssemblyProbability = new Random(39).NextDouble() + }; + + var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); + + 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 = GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.GetSectionAssemblyCategoryGroup( + sectionResult, failureMechanism, assessmentSection, true); + + // Assert + Assert.AreEqual(calculator.ManualAssemblyAssemblyOutput.Group, categoryGroup); + mocks.VerifyAll(); + } + } + + [Test] + public void GetSectionAssemblyCategoryGroup_WithManualInputAndUseManualFalse_ReturnsOutput() + { + // Setup + var sectionResult = new GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssembly = true, + ManualAssemblyProbability = new Random(39).NextDouble() + }; + + var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); + + 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 = GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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 GrassCoverErosionInwardsFailureMechanismSectionResultOld(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssembly = useManualAssembly + }; + var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); + + 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() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleFailureMechanism( + new GrassCoverErosionInwardsFailureMechanism(), 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 GrassCoverErosionInwardsFailureMechanism + { + InAssembly = false + }; + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); + mocks.ReplayAll(); + + // Call + FailureMechanismAssembly assembly = GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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 GrassCoverErosionInwardsFailureMechanism(); + 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 + GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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 GrassCoverErosionInwardsFailureMechanism(); + FailureMechanismTestHelper.SetSections(failureMechanism, new[] + { + FailureMechanismSectionTestFactory.CreateFailureMechanismSection() + }); + GrassCoverErosionInwardsFailureMechanismSectionResultOld 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 + GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleFailureMechanism( + failureMechanism, + assessmentSection, + true); + + // Assert + AssemblyToolTestHelper.AssertAreEqual(sectionCalculator.ManualAssemblyAssemblyOutput, calculator.FailureMechanismSectionAssemblies.Single()); + mocks.VerifyAll(); + } + } + + [Test] + public void AssembleFailureMechanism_WithManualInputAndUseManualFalse_SetsInputOnCalculator() + { + // Setup + var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); + FailureMechanismTestHelper.SetSections(failureMechanism, new[] + { + FailureMechanismSectionTestFactory.CreateFailureMechanismSection() + }); + GrassCoverErosionInwardsFailureMechanismSectionResultOld 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 + GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleFailureMechanism( + failureMechanism, + assessmentSection, + false); + + // Assert + AssemblyToolTestHelper.AssertAreEqual(sectionCalculator.CombinedAssemblyOutput, calculator.FailureMechanismSectionAssemblies.Single()); + mocks.VerifyAll(); + } + } + + [Test] + public void AssembleFailureMechanism_AssemblyRan_ReturnsOutput() + { + // Setup + var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); + + 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 = + GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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 GrassCoverErosionInwardsFailureMechanism(); + + 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() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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 GrassCoverErosionInwardsFailureMechanism(); + 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() => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.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 df3c3ac4860db8af1cbf61c7bc8661ed1db22bd0 refers to a dead (removed) revision in file `Riskeer/GrassCoverErosionInwards/test/Riskeer.GrassCoverErosionInwards.Data.Test/GrassCoverErosionInwardsFailureMechanismAssemblyFactoryTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/AssessmentSectionAssemblyFactory.cs =================================================================== diff -u -r2cce2a85a414587a79f94abc0e9961b6340057e3 -rdf3c3ac4860db8af1cbf61c7bc8661ed1db22bd0 --- Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/AssessmentSectionAssemblyFactory.cs (.../AssessmentSectionAssemblyFactory.cs) (revision 2cce2a85a414587a79f94abc0e9961b6340057e3) +++ Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/AssessmentSectionAssemblyFactory.cs (.../AssessmentSectionAssemblyFactory.cs) (revision df3c3ac4860db8af1cbf61c7bc8661ed1db22bd0) @@ -208,7 +208,7 @@ { return new[] { - GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.GrassCoverErosionInwards, assessmentSection, useManual), + GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleFailureMechanism(assessmentSection.GrassCoverErosionInwards, assessmentSection, useManual), HeightStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.HeightStructures, assessmentSection, useManual), ClosingStructuresFailureMechanismAssemblyFactoryOld.AssembleFailureMechanism(assessmentSection.ClosingStructures, assessmentSection, useManual), StabilityPointStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(assessmentSection.StabilityPointStructures, assessmentSection, useManual), Index: Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedAssemblyFailureMechanismSectionFactory.cs =================================================================== diff -u -r2cce2a85a414587a79f94abc0e9961b6340057e3 -rdf3c3ac4860db8af1cbf61c7bc8661ed1db22bd0 --- Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedAssemblyFailureMechanismSectionFactory.cs (.../CombinedAssemblyFailureMechanismSectionFactory.cs) (revision 2cce2a85a414587a79f94abc0e9961b6340057e3) +++ Riskeer/Integration/src/Riskeer.Integration.Data/Assembly/CombinedAssemblyFailureMechanismSectionFactory.cs (.../CombinedAssemblyFailureMechanismSectionFactory.cs) (revision df3c3ac4860db8af1cbf61c7bc8661ed1db22bd0) @@ -240,7 +240,7 @@ { get { - return (sectionResult, assessmentSection, useManual) => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.GetSectionAssemblyCategoryGroup( + return (sectionResult, assessmentSection, useManual) => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.GetSectionAssemblyCategoryGroup( sectionResult, assessmentSection.GrassCoverErosionInwards, assessmentSection, useManual); } } Index: Riskeer/Integration/src/Riskeer.Integration.Forms/Views/AssemblyResultTotalView.cs =================================================================== diff -u -r2cce2a85a414587a79f94abc0e9961b6340057e3 -rdf3c3ac4860db8af1cbf61c7bc8661ed1db22bd0 --- Riskeer/Integration/src/Riskeer.Integration.Forms/Views/AssemblyResultTotalView.cs (.../AssemblyResultTotalView.cs) (revision 2cce2a85a414587a79f94abc0e9961b6340057e3) +++ Riskeer/Integration/src/Riskeer.Integration.Forms/Views/AssemblyResultTotalView.cs (.../AssemblyResultTotalView.cs) (revision df3c3ac4860db8af1cbf61c7bc8661ed1db22bd0) @@ -318,9 +318,9 @@ { GrassCoverErosionInwardsFailureMechanism grassCoverErosionInwards = AssessmentSection.GrassCoverErosionInwards; return new FailureMechanismAssemblyResultRow(grassCoverErosionInwards, - () => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(grassCoverErosionInwards, - AssessmentSection, - true)); + () => GrassCoverErosionInwardsFailureMechanismAssemblyFactoryOld.AssembleFailureMechanism(grassCoverErosionInwards, + AssessmentSection, + true)); } #endregion