Index: Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismAssemblyCalculator.cs =================================================================== diff -u -refffeffbef15761667281ffcf6b2cb48280e4a29 -r2f660e66788675684eccbdaeeaa7923d332e529e --- Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismAssemblyCalculator.cs (.../FailureMechanismAssemblyCalculator.cs) (revision efffeffbef15761667281ffcf6b2cb48280e4a29) +++ Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismAssemblyCalculator.cs (.../FailureMechanismAssemblyCalculator.cs) (revision 2f660e66788675684eccbdaeeaa7923d332e529e) @@ -22,29 +22,29 @@ using System; using System.Collections.Generic; using System.Linq; -using Assembly.Kernel.Old.Exceptions; -using Assembly.Kernel.Old.Interfaces; -using Assembly.Kernel.Old.Model; -using Assembly.Kernel.Old.Model.CategoryLimits; -using Riskeer.AssemblyTool.Data; +using Assembly.Kernel.Exceptions; +using Assembly.Kernel.Interfaces; +using Assembly.Kernel.Model; using Riskeer.AssemblyTool.KernelWrapper.Creators; using Riskeer.AssemblyTool.KernelWrapper.Kernels; +using AssemblyFailureMechanismSectionAssemblyResult = Assembly.Kernel.Model.FailureMechanismSections.FailureMechanismSectionAssemblyResult; +using RiskeerFailureMechanismSectionAssemblyResult = Riskeer.AssemblyTool.Data.FailureMechanismSectionAssemblyResult; namespace Riskeer.AssemblyTool.KernelWrapper.Calculators.Assembly { /// - /// Class representing a failure mechanism assembly calculator. + /// Class representing a failure path assembly calculator. /// - public class FailureMechanismAssemblyCalculator : IFailureMechanismAssemblyCalculator + public class FailureMechanismAssemblyCalculator : IFailurePathAssemblyCalculator { - private readonly IAssemblyToolKernelFactoryOld factory; + private readonly IAssemblyToolKernelFactory factory; /// /// Creates a new instance of . /// /// The factory responsible for creating the assembly kernel. - /// Thrown when any parameter is null. - public FailureMechanismAssemblyCalculator(IAssemblyToolKernelFactoryOld factory) + /// Thrown when any is null. + public FailureMechanismAssemblyCalculator(IAssemblyToolKernelFactory factory) { if (factory == null) { @@ -54,53 +54,32 @@ this.factory = factory; } - public FailureMechanismAssemblyCategoryGroup Assemble(IEnumerable sectionCategories) + public double Assemble(double failurePathN, IEnumerable sectionAssemblyResults) { - try + if (sectionAssemblyResults == null) { - IFailureMechanismResultAssembler kernel = factory.CreateFailureMechanismAssemblyKernel(); - EFailureMechanismCategory output = kernel.AssembleFailureMechanismWbi1A1( - sectionCategories.Select(FailureMechanismSectionAssemblyCalculatorInputCreator.CreateFailureMechanismSectionAssemblyDirectResult).ToArray(), - false); - - return FailureMechanismAssemblyCreator.CreateFailureMechanismAssemblyCategoryGroup(output); + throw new ArgumentNullException(nameof(sectionAssemblyResults)); } - catch (AssemblyException e) - { - throw new FailureMechanismAssemblyCalculatorException(AssemblyErrorMessageCreatorOld.CreateErrorMessage(e.Errors), e); - } - catch (Exception e) - { - throw new FailureMechanismAssemblyCalculatorException(AssemblyErrorMessageCreatorOld.CreateGenericErrorMessage(), e); - } - } - public FailureMechanismAssembly Assemble(IEnumerable sectionAssemblies, - AssemblyCategoriesInput assemblyCategoriesInput) - { try { - ICategoryLimitsCalculator categoriesKernel = factory.CreateAssemblyCategoriesKernel(); - CategoriesList categories = categoriesKernel.CalculateFailureMechanismCategoryLimitsWbi11( - new AssessmentSection(1, assemblyCategoriesInput.SignalingNorm, assemblyCategoriesInput.LowerLimitNorm), - new FailureMechanism(assemblyCategoriesInput.N, assemblyCategoriesInput.FailureMechanismContribution)); - IFailureMechanismResultAssembler kernel = factory.CreateFailureMechanismAssemblyKernel(); - FailureMechanismAssemblyResult output = kernel.AssembleFailureMechanismWbi1B1( - new FailureMechanism(assemblyCategoriesInput.N, assemblyCategoriesInput.FailureMechanismContribution), - sectionAssemblies.Select(FailureMechanismSectionAssemblyCalculatorInputCreator.CreateFailureMechanismSectionAssemblyDirectResult).ToArray(), - categories, - false); - return FailureMechanismAssemblyCreator.Create(output); + AssemblyFailureMechanismSectionAssemblyResult[] kernelInput = + sectionAssemblyResults.Select(FailureMechanismAssemblyCalculatorInputCreator.CreateFailureMechanismSectionAssemblyResult) + .ToArray(); + + FailureMechanismAssemblyResult result = kernel.AssembleFailureMechanismWbi1B1(failurePathN, kernelInput, false); + + return result.Probability.Value; } catch (AssemblyException e) { - throw new FailureMechanismAssemblyCalculatorException(AssemblyErrorMessageCreatorOld.CreateErrorMessage(e.Errors), e); + throw new FailurePathAssemblyCalculatorException(AssemblyErrorMessageCreator.CreateErrorMessage(e.Errors), e); } catch (Exception e) { - throw new FailureMechanismAssemblyCalculatorException(AssemblyErrorMessageCreatorOld.CreateGenericErrorMessage(), e); + throw new FailurePathAssemblyCalculatorException(AssemblyErrorMessageCreator.CreateGenericErrorMessage(), e); } } } Index: Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismAssemblyCalculatorOld.cs =================================================================== diff -u --- Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismAssemblyCalculatorOld.cs (revision 0) +++ Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismAssemblyCalculatorOld.cs (revision 2f660e66788675684eccbdaeeaa7923d332e529e) @@ -0,0 +1,107 @@ +// 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 Assembly.Kernel.Old.Exceptions; +using Assembly.Kernel.Old.Interfaces; +using Assembly.Kernel.Old.Model; +using Assembly.Kernel.Old.Model.CategoryLimits; +using Riskeer.AssemblyTool.Data; +using Riskeer.AssemblyTool.KernelWrapper.Creators; +using Riskeer.AssemblyTool.KernelWrapper.Kernels; + +namespace Riskeer.AssemblyTool.KernelWrapper.Calculators.Assembly +{ + /// + /// Class representing a failure mechanism assembly calculator. + /// + public class FailureMechanismAssemblyCalculatorOld : IFailureMechanismAssemblyCalculator + { + private readonly IAssemblyToolKernelFactoryOld factory; + + /// + /// Creates a new instance of . + /// + /// The factory responsible for creating the assembly kernel. + /// Thrown when any parameter is null. + public FailureMechanismAssemblyCalculatorOld(IAssemblyToolKernelFactoryOld factory) + { + if (factory == null) + { + throw new ArgumentNullException(nameof(factory)); + } + + this.factory = factory; + } + + public FailureMechanismAssemblyCategoryGroup Assemble(IEnumerable sectionCategories) + { + try + { + IFailureMechanismResultAssembler kernel = factory.CreateFailureMechanismAssemblyKernel(); + EFailureMechanismCategory output = kernel.AssembleFailureMechanismWbi1A1( + sectionCategories.Select(FailureMechanismSectionAssemblyCalculatorInputCreator.CreateFailureMechanismSectionAssemblyDirectResult).ToArray(), + false); + + return FailureMechanismAssemblyCreator.CreateFailureMechanismAssemblyCategoryGroup(output); + } + catch (AssemblyException e) + { + throw new FailureMechanismAssemblyCalculatorException(AssemblyErrorMessageCreatorOld.CreateErrorMessage(e.Errors), e); + } + catch (Exception e) + { + throw new FailureMechanismAssemblyCalculatorException(AssemblyErrorMessageCreatorOld.CreateGenericErrorMessage(), e); + } + } + + public FailureMechanismAssembly Assemble(IEnumerable sectionAssemblies, + AssemblyCategoriesInput assemblyCategoriesInput) + { + try + { + ICategoryLimitsCalculator categoriesKernel = factory.CreateAssemblyCategoriesKernel(); + CategoriesList categories = categoriesKernel.CalculateFailureMechanismCategoryLimitsWbi11( + new AssessmentSection(1, assemblyCategoriesInput.SignalingNorm, assemblyCategoriesInput.LowerLimitNorm), + new FailureMechanism(assemblyCategoriesInput.N, assemblyCategoriesInput.FailureMechanismContribution)); + + IFailureMechanismResultAssembler kernel = factory.CreateFailureMechanismAssemblyKernel(); + FailureMechanismAssemblyResult output = kernel.AssembleFailureMechanismWbi1B1( + new FailureMechanism(assemblyCategoriesInput.N, assemblyCategoriesInput.FailureMechanismContribution), + sectionAssemblies.Select(FailureMechanismSectionAssemblyCalculatorInputCreator.CreateFailureMechanismSectionAssemblyDirectResult).ToArray(), + categories, + false); + + return FailureMechanismAssemblyCreator.Create(output); + } + catch (AssemblyException e) + { + throw new FailureMechanismAssemblyCalculatorException(AssemblyErrorMessageCreatorOld.CreateErrorMessage(e.Errors), e); + } + catch (Exception e) + { + throw new FailureMechanismAssemblyCalculatorException(AssemblyErrorMessageCreatorOld.CreateGenericErrorMessage(), e); + } + } + } +} \ No newline at end of file Fisheye: Tag 2f660e66788675684eccbdaeeaa7923d332e529e refers to a dead (removed) revision in file `Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/Assembly/FailurePathAssemblyCalculator.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/AssemblyToolCalculatorFactory.cs =================================================================== diff -u -r7547caf55a454c8aa66b1cf88885f520123e4ea9 -r2f660e66788675684eccbdaeeaa7923d332e529e --- Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/AssemblyToolCalculatorFactory.cs (.../AssemblyToolCalculatorFactory.cs) (revision 7547caf55a454c8aa66b1cf88885f520123e4ea9) +++ Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/AssemblyToolCalculatorFactory.cs (.../AssemblyToolCalculatorFactory.cs) (revision 2f660e66788675684eccbdaeeaa7923d332e529e) @@ -55,7 +55,7 @@ public IFailurePathAssemblyCalculator CreateFailurePathAssemblyCalculator(IAssemblyToolKernelFactory factory) { - return new FailurePathAssemblyCalculator(factory); + return new FailureMechanismAssemblyCalculator(factory); } } } \ No newline at end of file Index: Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/AssemblyToolCalculatorFactoryOld.cs =================================================================== diff -u -rfa6b41745f75625989787406e5bb0001e6a71a2e -r2f660e66788675684eccbdaeeaa7923d332e529e --- Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/AssemblyToolCalculatorFactoryOld.cs (.../AssemblyToolCalculatorFactoryOld.cs) (revision fa6b41745f75625989787406e5bb0001e6a71a2e) +++ Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/AssemblyToolCalculatorFactoryOld.cs (.../AssemblyToolCalculatorFactoryOld.cs) (revision 2f660e66788675684eccbdaeeaa7923d332e529e) @@ -61,7 +61,7 @@ public IFailureMechanismAssemblyCalculator CreateFailureMechanismAssemblyCalculator(IAssemblyToolKernelFactoryOld factory) { - return new FailureMechanismAssemblyCalculator(factory); + return new FailureMechanismAssemblyCalculatorOld(factory); } public IAssessmentSectionAssemblyCalculator CreateAssessmentSectionAssemblyCalculator(IAssemblyToolKernelFactoryOld factory) Index: Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismAssemblyCalculatorOldTest.cs =================================================================== diff -u --- Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismAssemblyCalculatorOldTest.cs (revision 0) +++ Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismAssemblyCalculatorOldTest.cs (revision 2f660e66788675684eccbdaeeaa7923d332e529e) @@ -0,0 +1,395 @@ +// 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.ComponentModel; +using System.Linq; +using Assembly.Kernel.Old.Exceptions; +using Assembly.Kernel.Old.Model; +using Assembly.Kernel.Old.Model.FmSectionTypes; +using Core.Common.TestUtil; +using NUnit.Framework; +using Rhino.Mocks; +using Riskeer.AssemblyTool.Data; +using Riskeer.AssemblyTool.KernelWrapper.Calculators.Assembly; +using Riskeer.AssemblyTool.KernelWrapper.Creators; +using Riskeer.AssemblyTool.KernelWrapper.Kernels; +using Riskeer.AssemblyTool.KernelWrapper.TestUtil; +using Riskeer.AssemblyTool.KernelWrapper.TestUtil.Kernels; +using Riskeer.AssemblyTool.KernelWrapper.TestUtil.Kernels.Assembly; +using Riskeer.AssemblyTool.KernelWrapper.TestUtil.Kernels.Categories; + +namespace Riskeer.AssemblyTool.KernelWrapper.Test.Calculators.Assembly +{ + [TestFixture] + public class FailureMechanismAssemblyCalculatorOldTest + { + [Test] + public void Constructor_WithKernelFactory_ExpectedValues() + { + // Setup + var mocks = new MockRepository(); + var kernelFactory = mocks.Stub(); + mocks.ReplayAll(); + + // Call + var calculator = new FailureMechanismAssemblyCalculatorOld(kernelFactory); + + // Assert + Assert.IsInstanceOf(calculator); + mocks.VerifyAll(); + } + + [Test] + public void Constructor_FactoryNull_ThrowsArgumentNullException() + { + // Call + TestDelegate call = () => new FailureMechanismAssemblyCalculatorOld(null); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("factory", exception.ParamName); + } + + [Test] + public void Assemble_WithInvalidEnumInput_ThrowFailureMechanismAssemblyCalculatorException() + { + // Setup + using (new AssemblyToolKernelFactoryConfigOld()) + { + var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; + var calculator = new FailureMechanismAssemblyCalculatorOld(factory); + + // Call + TestDelegate test = () => calculator.Assemble(new[] + { + (FailureMechanismSectionAssemblyCategoryGroup) 99 + }); + + // Assert + var exception = Assert.Throws(test); + Assert.IsInstanceOf(exception.InnerException); + Assert.AreEqual(AssemblyErrorMessageCreatorOld.CreateGenericErrorMessage(), exception.Message); + } + } + + [Test] + public void Assemble_WithValidInput_InputCorrectlySetToKernel() + { + // Setup + var random = new Random(39); + var categoryGroups = new[] + { + random.NextEnumValue() + }; + + using (new AssemblyToolKernelFactoryConfigOld()) + { + var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; + FailureMechanismAssemblyKernelStubOld kernel = factory.LastCreatedFailureMechanismAssemblyKernel; + kernel.FailureMechanismCategoryResult = new Random(39).NextEnumValue(); + + var calculator = new FailureMechanismAssemblyCalculatorOld(factory); + + // Call + calculator.Assemble(categoryGroups); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup actualCategoryGroup = + FailureMechanismSectionAssemblyCreatorOld.CreateFailureMechanismSectionAssemblyCategoryGroup(kernel.FmSectionAssemblyResultsInput.Single().Result); + Assert.AreEqual(categoryGroups.Single(), actualCategoryGroup); + Assert.IsFalse(kernel.PartialAssembly); + } + } + + [Test] + public void Assemble_KernelWithCompleteOutput_OutputCorrectlyReturnedByCalculator() + { + // Setup + using (new AssemblyToolKernelFactoryConfigOld()) + { + var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; + FailureMechanismAssemblyKernelStubOld kernel = factory.LastCreatedFailureMechanismAssemblyKernel; + kernel.FailureMechanismCategoryResult = new Random(39).NextEnumValue(); + + var calculator = new FailureMechanismAssemblyCalculatorOld(factory); + + // Call + FailureMechanismAssemblyCategoryGroup category = calculator.Assemble( + new List()); + + // Assert + FailureMechanismAssemblyCategoryGroup expectedCategory = FailureMechanismAssemblyCreator.CreateFailureMechanismAssemblyCategoryGroup(kernel.FailureMechanismCategoryResult); + Assert.AreEqual(expectedCategory, category); + } + } + + [Test] + public void Assemble_KernelWithInvalidOutput_ThrowFailureMechanismAssemblyCalculatorException() + { + // Setup + using (new AssemblyToolKernelFactoryConfigOld()) + { + var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; + FailureMechanismAssemblyKernelStubOld kernel = factory.LastCreatedFailureMechanismAssemblyKernel; + kernel.FailureMechanismCategoryResult = (EFailureMechanismCategory) 99; + + var calculator = new FailureMechanismAssemblyCalculatorOld(factory); + + // Call + TestDelegate test = () => calculator.Assemble(new List()); + + // Assert + var exception = Assert.Throws(test); + Assert.IsInstanceOf(exception.InnerException); + Assert.AreEqual(AssemblyErrorMessageCreatorOld.CreateGenericErrorMessage(), exception.Message); + } + } + + [Test] + public void Assemble_KernelThrowsException_ThrowFailureMechanismAssemblyCalculatorException() + { + // Setup + using (new AssemblyToolKernelFactoryConfigOld()) + { + var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; + FailureMechanismAssemblyKernelStubOld kernel = factory.LastCreatedFailureMechanismAssemblyKernel; + kernel.ThrowExceptionOnCalculate = true; + + var calculator = new FailureMechanismAssemblyCalculatorOld(factory); + + // Call + TestDelegate test = () => calculator.Assemble(new List()); + + // Assert + var exception = Assert.Throws(test); + Assert.IsNotNull(exception.InnerException); + Assert.AreEqual(AssemblyErrorMessageCreatorOld.CreateGenericErrorMessage(), exception.Message); + } + } + + [Test] + public void Assemble_KernelThrowsAssemblyException_ThrowFailureMechanismAssemblyCalculatorException() + { + // Setup + using (new AssemblyToolKernelFactoryConfigOld()) + { + var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; + FailureMechanismAssemblyKernelStubOld kernel = factory.LastCreatedFailureMechanismAssemblyKernel; + kernel.ThrowAssemblyExceptionOnCalculate = true; + + var calculator = new FailureMechanismAssemblyCalculatorOld(factory); + + // Call + TestDelegate test = () => calculator.Assemble(new List()); + + // Assert + var exception = Assert.Throws(test); + Assert.IsInstanceOf(exception.InnerException); + Assert.AreEqual(AssemblyErrorMessageCreatorOld.CreateErrorMessage(new[] + { + new AssemblyErrorMessage(string.Empty, EAssemblyErrors.CategoryLowerLimitOutOfRange) + }), exception.Message); + } + } + + [Test] + public void AssembleWithProbabilities_WithInvalidEnumInput_ThrowFailureMechanismAssemblyCalculatorException() + { + // Setup + using (new AssemblyToolKernelFactoryConfigOld()) + { + var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; + var calculator = new FailureMechanismAssemblyCalculatorOld(factory); + + // Call + TestDelegate test = () => calculator.Assemble(new[] + { + new FailureMechanismSectionAssemblyOld(new Random(39).NextDouble(), (FailureMechanismSectionAssemblyCategoryGroup) 99) + }, CreateAssemblyCategoriesInput()); + + // Assert + var exception = Assert.Throws(test); + Assert.IsInstanceOf(exception.InnerException); + Assert.AreEqual(AssemblyErrorMessageCreatorOld.CreateGenericErrorMessage(), exception.Message); + } + } + + [Test] + public void AssembleWithProbabilities_WithValidInput_InputCorrectlySetToKernel() + { + // Setup + var random = new Random(39); + var expectedResults = new[] + { + new FailureMechanismSectionAssemblyOld(random.NextDouble(), random.NextEnumValue()) + }; + AssemblyCategoriesInput assemblyCategoriesInput = CreateAssemblyCategoriesInput(); + + using (new AssemblyToolKernelFactoryConfigOld()) + { + var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; + AssemblyCategoriesKernelStubOld categoriesKernel = factory.LastCreatedAssemblyCategoriesKernel; + categoriesKernel.FailureMechanismCategoriesOutput = CategoriesListTestFactory.CreateFailureMechanismCategories(); + + FailureMechanismAssemblyKernelStubOld kernel = factory.LastCreatedFailureMechanismAssemblyKernel; + kernel.FailureMechanismAssemblyResult = new FailureMechanismAssemblyResult(random.NextEnumValue(), + random.NextDouble()); + var calculator = new FailureMechanismAssemblyCalculatorOld(factory); + + // Call + calculator.Assemble(expectedResults, assemblyCategoriesInput); + + // Assert + AssertFailureMechanismSectionAssembly(expectedResults.Single(), kernel.FmSectionAssemblyResultsWithProbabilityInput.Single()); + + Assert.IsFalse(kernel.PartialAssembly); + + double expectedN = assemblyCategoriesInput.N; + double expectedFailureMechanismContribution = assemblyCategoriesInput.FailureMechanismContribution; + Assert.AreEqual(expectedN, kernel.FailureMechanismInput.LengthEffectFactor); + Assert.AreEqual(expectedFailureMechanismContribution, kernel.FailureMechanismInput.FailureProbabilityMarginFactor); + + Assert.AreSame(categoriesKernel.FailureMechanismCategoriesOutput, kernel.Categories); + Assert.AreEqual(assemblyCategoriesInput.LowerLimitNorm, categoriesKernel.LowerLimitNorm); + Assert.AreEqual(assemblyCategoriesInput.SignalingNorm, categoriesKernel.SignalingNorm); + Assert.AreEqual(expectedN, categoriesKernel.N); + Assert.AreEqual(expectedFailureMechanismContribution, categoriesKernel.FailureMechanismContribution); + } + } + + [Test] + public void AssembleWithProbabilities_KernelWithCompleteOutput_OutputCorrectlyReturnedByCalculator() + { + // Setup + var random = new Random(39); + using (new AssemblyToolKernelFactoryConfigOld()) + { + var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; + FailureMechanismAssemblyKernelStubOld kernel = factory.LastCreatedFailureMechanismAssemblyKernel; + kernel.FailureMechanismAssemblyResult = new FailureMechanismAssemblyResult(random.NextEnumValue(), + random.NextDouble()); + + var calculator = new FailureMechanismAssemblyCalculatorOld(factory); + + // Call + FailureMechanismAssembly assembly = calculator.Assemble(Enumerable.Empty(), + CreateAssemblyCategoriesInput()); + + // Assert + FailureMechanismAssemblyCategoryGroup expectedGroup = FailureMechanismAssemblyCreator.CreateFailureMechanismAssemblyCategoryGroup(kernel.FailureMechanismAssemblyResult.Category); + Assert.AreEqual(expectedGroup, assembly.Group); + Assert.AreEqual(kernel.FailureMechanismAssemblyResult.FailureProbability, assembly.Probability); + } + } + + [Test] + public void AssembleWithProbabilities_KernelWithInvalidOutput_ThrowFailureMechanismAssemblyCalculatorException() + { + // Setup + using (new AssemblyToolKernelFactoryConfigOld()) + { + var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; + FailureMechanismAssemblyKernelStubOld kernel = factory.LastCreatedFailureMechanismAssemblyKernel; + kernel.FailureMechanismAssemblyResult = new FailureMechanismAssemblyResult((EFailureMechanismCategory) 99, + new Random(39).NextDouble()); + var calculator = new FailureMechanismAssemblyCalculatorOld(factory); + + // Call + TestDelegate test = () => calculator.Assemble(Enumerable.Empty(), + CreateAssemblyCategoriesInput()); + + // Assert + var exception = Assert.Throws(test); + Assert.IsInstanceOf(exception.InnerException); + Assert.AreEqual(AssemblyErrorMessageCreatorOld.CreateGenericErrorMessage(), exception.Message); + } + } + + [Test] + public void AssembleWithProbabilities_KernelThrowsException_ThrowFailureMechanismAssemblyCalculatorException() + { + // Setup + using (new AssemblyToolKernelFactoryConfigOld()) + { + var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; + FailureMechanismAssemblyKernelStubOld kernel = factory.LastCreatedFailureMechanismAssemblyKernel; + kernel.ThrowExceptionOnCalculate = true; + + var calculator = new FailureMechanismAssemblyCalculatorOld(factory); + + // Call + TestDelegate test = () => calculator.Assemble(Enumerable.Empty(), + CreateAssemblyCategoriesInput()); + + // Assert + var exception = Assert.Throws(test); + Assert.IsNotNull(exception.InnerException); + Assert.AreEqual(AssemblyErrorMessageCreatorOld.CreateGenericErrorMessage(), exception.Message); + } + } + + [Test] + public void AssembleWithProbabilities_KernelThrowsAssemblyException_ThrowFailureMechanismAssemblyCalculatorException() + { + // Setup + using (new AssemblyToolKernelFactoryConfigOld()) + { + var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; + FailureMechanismAssemblyKernelStubOld kernel = factory.LastCreatedFailureMechanismAssemblyKernel; + kernel.ThrowAssemblyExceptionOnCalculate = true; + + var calculator = new FailureMechanismAssemblyCalculatorOld(factory); + + // Call + TestDelegate test = () => calculator.Assemble(Enumerable.Empty(), + CreateAssemblyCategoriesInput()); + + // Assert + var exception = Assert.Throws(test); + Assert.IsInstanceOf(exception.InnerException); + Assert.AreEqual(AssemblyErrorMessageCreatorOld.CreateErrorMessage(new[] + { + new AssemblyErrorMessage(string.Empty, EAssemblyErrors.CategoryLowerLimitOutOfRange) + }), exception.Message); + } + } + + private static void AssertFailureMechanismSectionAssembly(FailureMechanismSectionAssemblyOld expectedSectionAssembly, + FmSectionAssemblyDirectResultWithProbability actualResult) + { + FailureMechanismSectionAssemblyCategoryGroup actualGroup = + FailureMechanismSectionAssemblyCreatorOld.CreateFailureMechanismSectionAssemblyCategoryGroup(actualResult.Result); + Assert.AreEqual(expectedSectionAssembly.Group, actualGroup); + Assert.AreEqual(expectedSectionAssembly.Probability, actualResult.FailureProbability); + } + + private static AssemblyCategoriesInput CreateAssemblyCategoriesInput() + { + var random = new Random(39); + return new AssemblyCategoriesInput(random.NextDouble(1.0, 5.0), + random.NextDouble(), + random.NextDouble(0.0, 0.5), + random.NextDouble(0.5, 1.0)); + } + } +} \ No newline at end of file Index: Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismAssemblyCalculatorTest.cs =================================================================== diff -u -refffeffbef15761667281ffcf6b2cb48280e4a29 -r2f660e66788675684eccbdaeeaa7923d332e529e --- Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismAssemblyCalculatorTest.cs (.../FailureMechanismAssemblyCalculatorTest.cs) (revision efffeffbef15761667281ffcf6b2cb48280e4a29) +++ Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismAssemblyCalculatorTest.cs (.../FailureMechanismAssemblyCalculatorTest.cs) (revision 2f660e66788675684eccbdaeeaa7923d332e529e) @@ -21,11 +21,10 @@ using System; using System.Collections.Generic; -using System.ComponentModel; using System.Linq; -using Assembly.Kernel.Old.Exceptions; -using Assembly.Kernel.Old.Model; -using Assembly.Kernel.Old.Model.FmSectionTypes; +using Assembly.Kernel.Exceptions; +using Assembly.Kernel.Model; +using Assembly.Kernel.Model.Categories; using Core.Common.TestUtil; using NUnit.Framework; using Rhino.Mocks; @@ -36,360 +35,256 @@ using Riskeer.AssemblyTool.KernelWrapper.TestUtil; using Riskeer.AssemblyTool.KernelWrapper.TestUtil.Kernels; using Riskeer.AssemblyTool.KernelWrapper.TestUtil.Kernels.Assembly; -using Riskeer.AssemblyTool.KernelWrapper.TestUtil.Kernels.Categories; +using AssemblyFailureMechanismSectionAssemblyResult = Assembly.Kernel.Model.FailureMechanismSections.FailureMechanismSectionAssemblyResult; +using RiskeerFailureMechanismSectionAssemblyResult = Riskeer.AssemblyTool.Data.FailureMechanismSectionAssemblyResult; namespace Riskeer.AssemblyTool.KernelWrapper.Test.Calculators.Assembly { [TestFixture] public class FailureMechanismAssemblyCalculatorTest { [Test] - public void Constructor_WithKernelFactory_ExpectedValues() + public void Constructor_FactoryNull_ThrowsArgumentNullException() { - // Setup - var mocks = new MockRepository(); - var kernelFactory = mocks.Stub(); - mocks.ReplayAll(); - // Call - var calculator = new FailureMechanismAssemblyCalculator(kernelFactory); + void Call() => new FailureMechanismAssemblyCalculator(null); // Assert - Assert.IsInstanceOf(calculator); - mocks.VerifyAll(); + var exception = Assert.Throws(Call); + Assert.AreEqual("factory", exception.ParamName); } [Test] - public void Constructor_FactoryNull_ThrowsArgumentNullException() + public void Constructor_ExpectedValues() { + // Setup + var mocks = new MockRepository(); + var kernelFactory = mocks.Stub(); + mocks.ReplayAll(); + // Call - TestDelegate call = () => new FailureMechanismAssemblyCalculator(null); + var calculator = new FailureMechanismAssemblyCalculator(kernelFactory); // Assert - var exception = Assert.Throws(call); - Assert.AreEqual("factory", exception.ParamName); + Assert.IsInstanceOf(calculator); + mocks.VerifyAll(); } [Test] - public void Assemble_WithInvalidEnumInput_ThrowFailureMechanismAssemblyCalculatorException() + public void Assemble_SectionAssemblyResultsNull_ThrowsArgumentNullException() { // Setup - using (new AssemblyToolKernelFactoryConfigOld()) - { - var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; - var calculator = new FailureMechanismAssemblyCalculator(factory); + var random = new Random(21); - // Call - TestDelegate test = () => calculator.Assemble(new[] - { - (FailureMechanismSectionAssemblyCategoryGroup) 99 - }); + var mocks = new MockRepository(); + var kernelFactory = mocks.Stub(); + mocks.ReplayAll(); - // Assert - var exception = Assert.Throws(test); - Assert.IsInstanceOf(exception.InnerException); - Assert.AreEqual(AssemblyErrorMessageCreatorOld.CreateGenericErrorMessage(), exception.Message); - } + var calculator = new FailureMechanismAssemblyCalculator(kernelFactory); + + // Call + void Call() => calculator.Assemble(random.NextDouble(), null); + + // Assert + Assert.That(Call, Throws.TypeOf() + .With.Property(nameof(ArgumentNullException.ParamName)) + .EqualTo("sectionAssemblyResults")); + mocks.VerifyAll(); } [Test] - public void Assemble_WithValidInput_InputCorrectlySetToKernel() + public void Assemble_WithValidInput_SendsCorrectInputToKernel() { // Setup - var random = new Random(39); - var categoryGroups = new[] + var random = new Random(21); + double failurePathN = random.NextDouble(); + RiskeerFailureMechanismSectionAssemblyResult[] sectionAssemblyResults = { - random.NextEnumValue() + CreateSectionAssemblyResult(random.Next()), + CreateSectionAssemblyResult(random.Next()) }; - using (new AssemblyToolKernelFactoryConfigOld()) + using (new AssemblyToolKernelFactoryConfig()) { - var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; + var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; FailureMechanismAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismAssemblyKernel; - kernel.FailureMechanismCategoryResult = new Random(39).NextEnumValue(); + kernel.ProbabilityResult = new FailureMechanismAssemblyResult(new Probability(random.NextDouble()), EFailureMechanismAssemblyMethod.Correlated); var calculator = new FailureMechanismAssemblyCalculator(factory); // Call - calculator.Assemble(categoryGroups); + calculator.Assemble(failurePathN, sectionAssemblyResults); // Assert - FailureMechanismSectionAssemblyCategoryGroup actualCategoryGroup = - FailureMechanismSectionAssemblyCreatorOld.CreateFailureMechanismSectionAssemblyCategoryGroup(kernel.FmSectionAssemblyResultsInput.Single().Result); - Assert.AreEqual(categoryGroups.Single(), actualCategoryGroup); + Assert.AreEqual(failurePathN, kernel.LenghtEffectFactor); Assert.IsFalse(kernel.PartialAssembly); + AssertFailurePathSectionAssemblyResults(sectionAssemblyResults, kernel.FailureMechanismSectionAssemblyResults); } } [Test] - public void Assemble_KernelWithCompleteOutput_OutputCorrectlyReturnedByCalculator() + public void Assemble_WithValidOutput_ReturnsExpectedOutput() { // Setup - using (new AssemblyToolKernelFactoryConfigOld()) + var random = new Random(21); + + using (new AssemblyToolKernelFactoryConfig()) { - var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; + var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; FailureMechanismAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismAssemblyKernel; - kernel.FailureMechanismCategoryResult = new Random(39).NextEnumValue(); + var output = new FailureMechanismAssemblyResult(new Probability(random.NextDouble()), EFailureMechanismAssemblyMethod.Correlated); + kernel.ProbabilityResult = output; var calculator = new FailureMechanismAssemblyCalculator(factory); // Call - FailureMechanismAssemblyCategoryGroup category = calculator.Assemble( - new List()); + double assemblyResult = calculator.Assemble(random.NextDouble(), Enumerable.Empty()); // Assert - FailureMechanismAssemblyCategoryGroup expectedCategory = FailureMechanismAssemblyCreator.CreateFailureMechanismAssemblyCategoryGroup(kernel.FailureMechanismCategoryResult); - Assert.AreEqual(expectedCategory, category); + Assert.IsTrue(kernel.Calculated); + ProbabilityAssert.AreEqual(assemblyResult, output.Probability); } } [Test] - public void Assemble_KernelWithInvalidOutput_ThrowFailureMechanismAssemblyCalculatorException() + public void Assemble_WithInvalidInput_ThrowsFailurePathAssemblyCalculatorException() { // Setup - using (new AssemblyToolKernelFactoryConfigOld()) + var random = new Random(21); + double probability = random.NextDouble(); + var invalidInput = new RiskeerFailureMechanismSectionAssemblyResult(probability, probability, random.NextDouble(), + (FailureMechanismSectionAssemblyGroup) 99); + + using (new AssemblyToolKernelFactoryConfig()) { - var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; + var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; FailureMechanismAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismAssemblyKernel; - kernel.FailureMechanismCategoryResult = (EFailureMechanismCategory) 99; var calculator = new FailureMechanismAssemblyCalculator(factory); // Call - TestDelegate test = () => calculator.Assemble(new List()); + void Call() => calculator.Assemble(random.NextDouble(), new[] + { + invalidInput + }); // Assert - var exception = Assert.Throws(test); - Assert.IsInstanceOf(exception.InnerException); + Assert.IsFalse(kernel.Calculated); + + var exception = Assert.Throws(Call); + Assert.IsInstanceOf(exception.InnerException); Assert.AreEqual(AssemblyErrorMessageCreatorOld.CreateGenericErrorMessage(), exception.Message); } } [Test] - public void Assemble_KernelThrowsException_ThrowFailureMechanismAssemblyCalculatorException() + public void Assemble_KernelThrowsException_ThrowsFailurePathAssemblyCalculatorException() { // Setup - using (new AssemblyToolKernelFactoryConfigOld()) + var random = new Random(21); + + using (new AssemblyToolKernelFactoryConfig()) { - var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; + var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; FailureMechanismAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismAssemblyKernel; kernel.ThrowExceptionOnCalculate = true; var calculator = new FailureMechanismAssemblyCalculator(factory); // Call - TestDelegate test = () => calculator.Assemble(new List()); + void Call() => calculator.Assemble(random.NextDouble(), Enumerable.Empty()); // Assert - var exception = Assert.Throws(test); - Assert.IsNotNull(exception.InnerException); + Assert.IsFalse(kernel.Calculated); + + var exception = Assert.Throws(Call); + Assert.IsInstanceOf(exception.InnerException); Assert.AreEqual(AssemblyErrorMessageCreatorOld.CreateGenericErrorMessage(), exception.Message); } } [Test] - public void Assemble_KernelThrowsAssemblyException_ThrowFailureMechanismAssemblyCalculatorException() + public void Assemble_KernelThrowsAssemblyException_ThrowsFailurePathAssemblyCalculatorException() { // Setup - using (new AssemblyToolKernelFactoryConfigOld()) + var random = new Random(21); + + using (new AssemblyToolKernelFactoryConfig()) { - var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; + var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; FailureMechanismAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismAssemblyKernel; kernel.ThrowAssemblyExceptionOnCalculate = true; var calculator = new FailureMechanismAssemblyCalculator(factory); // Call - TestDelegate test = () => calculator.Assemble(new List()); + void Call() => calculator.Assemble(random.NextDouble(), Enumerable.Empty()); // Assert - var exception = Assert.Throws(test); - Assert.IsInstanceOf(exception.InnerException); - Assert.AreEqual(AssemblyErrorMessageCreatorOld.CreateErrorMessage(new[] - { - new AssemblyErrorMessage(string.Empty, EAssemblyErrors.CategoryLowerLimitOutOfRange) - }), exception.Message); - } - } + Assert.IsFalse(kernel.Calculated); - [Test] - public void AssembleWithProbabilities_WithInvalidEnumInput_ThrowFailureMechanismAssemblyCalculatorException() - { - // Setup - using (new AssemblyToolKernelFactoryConfigOld()) - { - var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; - var calculator = new FailureMechanismAssemblyCalculator(factory); - - // Call - TestDelegate test = () => calculator.Assemble(new[] - { - new FailureMechanismSectionAssemblyOld(new Random(39).NextDouble(), (FailureMechanismSectionAssemblyCategoryGroup) 99) - }, CreateAssemblyCategoriesInput()); - - // Assert - var exception = Assert.Throws(test); - Assert.IsInstanceOf(exception.InnerException); - Assert.AreEqual(AssemblyErrorMessageCreatorOld.CreateGenericErrorMessage(), exception.Message); + var exception = Assert.Throws(Call); + var innerException = exception.InnerException as AssemblyException; + Assert.IsNotNull(innerException); + Assert.AreEqual(AssemblyErrorMessageCreator.CreateErrorMessage(innerException.Errors), exception.Message); } } - [Test] - public void AssembleWithProbabilities_WithValidInput_InputCorrectlySetToKernel() + private static RiskeerFailureMechanismSectionAssemblyResult CreateSectionAssemblyResult(int seed) { - // Setup - var random = new Random(39); - var expectedResults = new[] - { - new FailureMechanismSectionAssemblyOld(random.NextDouble(), random.NextEnumValue()) - }; - AssemblyCategoriesInput assemblyCategoriesInput = CreateAssemblyCategoriesInput(); - - using (new AssemblyToolKernelFactoryConfigOld()) - { - var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; - AssemblyCategoriesKernelStubOld categoriesKernel = factory.LastCreatedAssemblyCategoriesKernel; - categoriesKernel.FailureMechanismCategoriesOutput = CategoriesListTestFactory.CreateFailureMechanismCategories(); - - FailureMechanismAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismAssemblyKernel; - kernel.FailureMechanismAssemblyResult = new FailureMechanismAssemblyResult(random.NextEnumValue(), - random.NextDouble()); - var calculator = new FailureMechanismAssemblyCalculator(factory); - - // Call - calculator.Assemble(expectedResults, assemblyCategoriesInput); - - // Assert - AssertFailureMechanismSectionAssembly(expectedResults.Single(), kernel.FmSectionAssemblyResultsWithProbabilityInput.Single()); - - Assert.IsFalse(kernel.PartialAssembly); - - double expectedN = assemblyCategoriesInput.N; - double expectedFailureMechanismContribution = assemblyCategoriesInput.FailureMechanismContribution; - Assert.AreEqual(expectedN, kernel.FailureMechanismInput.LengthEffectFactor); - Assert.AreEqual(expectedFailureMechanismContribution, kernel.FailureMechanismInput.FailureProbabilityMarginFactor); - - Assert.AreSame(categoriesKernel.FailureMechanismCategoriesOutput, kernel.Categories); - Assert.AreEqual(assemblyCategoriesInput.LowerLimitNorm, categoriesKernel.LowerLimitNorm); - Assert.AreEqual(assemblyCategoriesInput.SignalingNorm, categoriesKernel.SignalingNorm); - Assert.AreEqual(expectedN, categoriesKernel.N); - Assert.AreEqual(expectedFailureMechanismContribution, categoriesKernel.FailureMechanismContribution); - } + var random = new Random(seed); + double probability = random.NextDouble(); + return new RiskeerFailureMechanismSectionAssemblyResult(probability, probability + 0.001, random.NextDouble(), + random.NextEnumValue()); } - [Test] - public void AssembleWithProbabilities_KernelWithCompleteOutput_OutputCorrectlyReturnedByCalculator() + private static void AssertFailurePathSectionAssemblyResults(IEnumerable expected, + IEnumerable actual) { - // Setup - var random = new Random(39); - using (new AssemblyToolKernelFactoryConfigOld()) - { - var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; - FailureMechanismAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismAssemblyKernel; - kernel.FailureMechanismAssemblyResult = new FailureMechanismAssemblyResult(random.NextEnumValue(), - random.NextDouble()); + int nrOfExpectedResults = expected.Count(); + Assert.AreEqual(nrOfExpectedResults, actual.Count()); - var calculator = new FailureMechanismAssemblyCalculator(factory); - - // Call - FailureMechanismAssembly assembly = calculator.Assemble(Enumerable.Empty(), - CreateAssemblyCategoriesInput()); - - // Assert - FailureMechanismAssemblyCategoryGroup expectedGroup = FailureMechanismAssemblyCreator.CreateFailureMechanismAssemblyCategoryGroup(kernel.FailureMechanismAssemblyResult.Category); - Assert.AreEqual(expectedGroup, assembly.Group); - Assert.AreEqual(kernel.FailureMechanismAssemblyResult.FailureProbability, assembly.Probability); - } - } - - [Test] - public void AssembleWithProbabilities_KernelWithInvalidOutput_ThrowFailureMechanismAssemblyCalculatorException() - { - // Setup - using (new AssemblyToolKernelFactoryConfigOld()) + for (int i = 0; i < nrOfExpectedResults; i++) { - var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; - FailureMechanismAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismAssemblyKernel; - kernel.FailureMechanismAssemblyResult = new FailureMechanismAssemblyResult((EFailureMechanismCategory) 99, - new Random(39).NextDouble()); - var calculator = new FailureMechanismAssemblyCalculator(factory); - - // Call - TestDelegate test = () => calculator.Assemble(Enumerable.Empty(), - CreateAssemblyCategoriesInput()); - - // Assert - var exception = Assert.Throws(test); - Assert.IsInstanceOf(exception.InnerException); - Assert.AreEqual(AssemblyErrorMessageCreatorOld.CreateGenericErrorMessage(), exception.Message); + AssertFailurePathSectionAssemblyResult(expected.ElementAt(i), actual.ElementAt(i)); } } - [Test] - public void AssembleWithProbabilities_KernelThrowsException_ThrowFailureMechanismAssemblyCalculatorException() + private static void AssertFailurePathSectionAssemblyResult(RiskeerFailureMechanismSectionAssemblyResult expected, + AssemblyFailureMechanismSectionAssemblyResult actual) { - // Setup - using (new AssemblyToolKernelFactoryConfigOld()) - { - var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; - FailureMechanismAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismAssemblyKernel; - kernel.ThrowExceptionOnCalculate = true; - - var calculator = new FailureMechanismAssemblyCalculator(factory); - - // Call - TestDelegate test = () => calculator.Assemble(Enumerable.Empty(), - CreateAssemblyCategoriesInput()); - - // Assert - var exception = Assert.Throws(test); - Assert.IsNotNull(exception.InnerException); - Assert.AreEqual(AssemblyErrorMessageCreatorOld.CreateGenericErrorMessage(), exception.Message); - } + ProbabilityAssert.AreEqual(expected.ProfileProbability, actual.ProbabilityProfile); + ProbabilityAssert.AreEqual(expected.SectionProbability, actual.ProbabilitySection); + Assert.AreEqual(GetInterpretationCategory(expected.AssemblyGroup), actual.InterpretationCategory); } - [Test] - public void AssembleWithProbabilities_KernelThrowsAssemblyException_ThrowFailureMechanismAssemblyCalculatorException() + private static EInterpretationCategory GetInterpretationCategory(FailureMechanismSectionAssemblyGroup assemblyGroup) { - // Setup - using (new AssemblyToolKernelFactoryConfigOld()) + switch (assemblyGroup) { - var factory = (TestAssemblyToolKernelFactoryOld) AssemblyToolKernelFactoryOld.Instance; - FailureMechanismAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismAssemblyKernel; - kernel.ThrowAssemblyExceptionOnCalculate = true; - - var calculator = new FailureMechanismAssemblyCalculator(factory); - - // Call - TestDelegate test = () => calculator.Assemble(Enumerable.Empty(), - CreateAssemblyCategoriesInput()); - - // Assert - var exception = Assert.Throws(test); - Assert.IsInstanceOf(exception.InnerException); - Assert.AreEqual(AssemblyErrorMessageCreatorOld.CreateErrorMessage(new[] - { - new AssemblyErrorMessage(string.Empty, EAssemblyErrors.CategoryLowerLimitOutOfRange) - }), exception.Message); + case FailureMechanismSectionAssemblyGroup.NotDominant: + return EInterpretationCategory.NotDominant; + case FailureMechanismSectionAssemblyGroup.III: + return EInterpretationCategory.III; + case FailureMechanismSectionAssemblyGroup.II: + return EInterpretationCategory.II; + case FailureMechanismSectionAssemblyGroup.I: + return EInterpretationCategory.I; + case FailureMechanismSectionAssemblyGroup.Zero: + return EInterpretationCategory.Zero; + case FailureMechanismSectionAssemblyGroup.IMin: + return EInterpretationCategory.IMin; + case FailureMechanismSectionAssemblyGroup.IIMin: + return EInterpretationCategory.IIMin; + case FailureMechanismSectionAssemblyGroup.IIIMin: + return EInterpretationCategory.IIIMin; + case FailureMechanismSectionAssemblyGroup.Dominant: + return EInterpretationCategory.Dominant; + case FailureMechanismSectionAssemblyGroup.Gr: + return EInterpretationCategory.Gr; + default: + throw new NotSupportedException(); } } - - private static void AssertFailureMechanismSectionAssembly(FailureMechanismSectionAssemblyOld expectedSectionAssembly, - FmSectionAssemblyDirectResultWithProbability actualResult) - { - FailureMechanismSectionAssemblyCategoryGroup actualGroup = - FailureMechanismSectionAssemblyCreatorOld.CreateFailureMechanismSectionAssemblyCategoryGroup(actualResult.Result); - Assert.AreEqual(expectedSectionAssembly.Group, actualGroup); - Assert.AreEqual(expectedSectionAssembly.Probability, actualResult.FailureProbability); - } - - private static AssemblyCategoriesInput CreateAssemblyCategoriesInput() - { - var random = new Random(39); - return new AssemblyCategoriesInput(random.NextDouble(1.0, 5.0), - random.NextDouble(), - random.NextDouble(0.0, 0.5), - random.NextDouble(0.5, 1.0)); - } } } \ No newline at end of file Fisheye: Tag 2f660e66788675684eccbdaeeaa7923d332e529e refers to a dead (removed) revision in file `Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailurePathAssemblyCalculatorTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/AssemblyToolCalculatorFactoryOldTest.cs =================================================================== diff -u -rfa6b41745f75625989787406e5bb0001e6a71a2e -r2f660e66788675684eccbdaeeaa7923d332e529e --- Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/AssemblyToolCalculatorFactoryOldTest.cs (.../AssemblyToolCalculatorFactoryOldTest.cs) (revision fa6b41745f75625989787406e5bb0001e6a71a2e) +++ Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/AssemblyToolCalculatorFactoryOldTest.cs (.../AssemblyToolCalculatorFactoryOldTest.cs) (revision 2f660e66788675684eccbdaeeaa7923d332e529e) @@ -117,7 +117,7 @@ factory.CreateFailureMechanismAssemblyCalculator(AssemblyToolKernelFactoryOld.Instance); // Assert - Assert.IsInstanceOf(calculator); + Assert.IsInstanceOf(calculator); } } Index: Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/AssemblyToolCalculatorFactoryTest.cs =================================================================== diff -u -r7547caf55a454c8aa66b1cf88885f520123e4ea9 -r2f660e66788675684eccbdaeeaa7923d332e529e --- Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/AssemblyToolCalculatorFactoryTest.cs (.../AssemblyToolCalculatorFactoryTest.cs) (revision 7547caf55a454c8aa66b1cf88885f520123e4ea9) +++ Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/AssemblyToolCalculatorFactoryTest.cs (.../AssemblyToolCalculatorFactoryTest.cs) (revision 2f660e66788675684eccbdaeeaa7923d332e529e) @@ -121,7 +121,7 @@ factory.CreateFailurePathAssemblyCalculator(AssemblyToolKernelFactory.Instance); // Assert - Assert.IsInstanceOf(calculator); + Assert.IsInstanceOf(calculator); } } } Fisheye: Tag 2f660e66788675684eccbdaeeaa7923d332e529e refers to a dead (removed) revision in file `Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/FailureMechanismAssemblyKernelStub.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/FailureMechanismAssemblyKernelStubOld.cs =================================================================== diff -u --- Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/FailureMechanismAssemblyKernelStubOld.cs (revision 0) +++ Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/FailureMechanismAssemblyKernelStubOld.cs (revision 2f660e66788675684eccbdaeeaa7923d332e529e) @@ -0,0 +1,135 @@ +// 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 Assembly.Kernel.Old.Exceptions; +using Assembly.Kernel.Old.Interfaces; +using Assembly.Kernel.Old.Model; +using Assembly.Kernel.Old.Model.CategoryLimits; +using Assembly.Kernel.Old.Model.FmSectionTypes; + +namespace Riskeer.AssemblyTool.KernelWrapper.TestUtil.Kernels.Assembly +{ + /// + /// Failure mechanism assembly kernel stub for testing purposes. + /// + public class FailureMechanismAssemblyKernelStubOld : IFailureMechanismResultAssembler + { + /// + /// Gets the collection of used as input parameter for assembly methods. + /// + public IEnumerable FmSectionAssemblyResultsInput { get; private set; } + + /// + /// Gets the collection of used as input parameter for assembly methods. + /// + public IEnumerable FmSectionAssemblyResultsWithProbabilityInput { get; private set; } + + /// + /// Gets a value indicating whether an assembly is partial. + /// + public bool? PartialAssembly { get; private set; } + + /// + /// Gets the used as input parameter for assembly methods. + /// + public FailureMechanism FailureMechanismInput { get; private set; } + + /// + /// Gets the with + /// used as input parameter for assembly methods. + /// + public CategoriesList Categories { get; private set; } + + /// + /// Gets or sets the failure mechanism category result. + /// + public EFailureMechanismCategory FailureMechanismCategoryResult { get; set; } + + /// + /// Gets or sets the failure mechanism assembly result. + /// + public FailureMechanismAssemblyResult FailureMechanismAssemblyResult { get; set; } + + /// + /// Gets a value indicating whether a calculation was called or not. + /// + public bool Calculated { get; private set; } + + /// + /// Sets an indicator whether an must be thrown while performing a calculation. + /// + public bool ThrowExceptionOnCalculate { private get; set; } + + /// + /// Sets an indicator whether an must be thrown while performing a calculation. + /// + public bool ThrowAssemblyExceptionOnCalculate { private get; set; } + + public EFailureMechanismCategory AssembleFailureMechanismWbi1A1(IEnumerable fmSectionAssemblyResults, + bool partialAssembly) + { + ThrowException(); + + FmSectionAssemblyResultsInput = fmSectionAssemblyResults; + PartialAssembly = partialAssembly; + + Calculated = true; + return FailureMechanismCategoryResult; + } + + public EIndirectAssessmentResult AssembleFailureMechanismWbi1A2(IEnumerable fmSectionAssemblyResults, + bool partialAssembly) + { + throw new NotImplementedException(); + } + + public FailureMechanismAssemblyResult AssembleFailureMechanismWbi1B1(FailureMechanism failureMechanism, + IEnumerable fmSectionAssemblyResults, + CategoriesList categoryLimits, + bool partialAssembly) + { + ThrowException(); + + Categories = categoryLimits; + FailureMechanismInput = failureMechanism; + FmSectionAssemblyResultsWithProbabilityInput = fmSectionAssemblyResults; + PartialAssembly = partialAssembly; + + Calculated = true; + return FailureMechanismAssemblyResult; + } + + private void ThrowException() + { + if (ThrowExceptionOnCalculate) + { + throw new Exception("Message", new Exception()); + } + + if (ThrowAssemblyExceptionOnCalculate) + { + throw new AssemblyException("entity", EAssemblyErrors.CategoryLowerLimitOutOfRange); + } + } + } +} \ No newline at end of file Index: Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/FailurePathAssemblyKernelStub.cs =================================================================== diff -u -r16361dc9bef717d46f647fc311632fd0743d0621 -r2f660e66788675684eccbdaeeaa7923d332e529e --- Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/FailurePathAssemblyKernelStub.cs (.../FailurePathAssemblyKernelStub.cs) (revision 16361dc9bef717d46f647fc311632fd0743d0621) +++ Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/FailurePathAssemblyKernelStub.cs (.../FailurePathAssemblyKernelStub.cs) (revision 2f660e66788675684eccbdaeeaa7923d332e529e) @@ -29,9 +29,9 @@ namespace Riskeer.AssemblyTool.KernelWrapper.TestUtil.Kernels.Assembly { /// - /// Failure path assembly kernel stub for testing purposes. + /// Failure mechanism assembly kernel stub for testing purposes. /// - public class FailurePathAssemblyKernelStub : IFailureMechanismResultAssembler + public class FailureMechanismAssemblyKernelStub : IFailureMechanismResultAssembler { /// /// Gets a value indicating whether a calculation was called or not. @@ -44,9 +44,9 @@ public double LenghtEffectFactor { get; private set; } /// - /// Gets the collection of . + /// Gets the collection of . /// - public IEnumerable FailurePathSectionAssemblyResults { get; private set; } + public IEnumerable FailureMechanismSectionAssemblyResults { get; private set; } /// /// Gets a value indicating whether an assembly is partial. @@ -69,14 +69,14 @@ public bool ThrowAssemblyExceptionOnCalculate { private get; set; } public FailureMechanismAssemblyResult AssembleFailureMechanismWbi1B1(double lengthEffectFactor, - IEnumerable failurePathSectionAssemblyResults, + IEnumerable failureMechanismSectionAssemblyResults, bool partialAssembly) { ThrowException(); Calculated = true; LenghtEffectFactor = lengthEffectFactor; - FailurePathSectionAssemblyResults = failurePathSectionAssemblyResults; + FailureMechanismSectionAssemblyResults = failureMechanismSectionAssemblyResults; PartialAssembly = partialAssembly; return ProbabilityResult; Index: Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/TestAssemblyToolKernelFactory.cs =================================================================== diff -u -r526598baa804f18e3bc6525405084f8254e6befb -r2f660e66788675684eccbdaeeaa7923d332e529e --- Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/TestAssemblyToolKernelFactory.cs (.../TestAssemblyToolKernelFactory.cs) (revision 526598baa804f18e3bc6525405084f8254e6befb) +++ Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/TestAssemblyToolKernelFactory.cs (.../TestAssemblyToolKernelFactory.cs) (revision 2f660e66788675684eccbdaeeaa7923d332e529e) @@ -38,7 +38,7 @@ { LastCreatedAssemblyCategoryLimitsKernel = new AssemblyCategoryLimitsKernelStub(); LastCreatedFailureMechanismSectionAssemblyKernel = new FailureMechanismSectionAssemblyKernelStub(); - LastCreatedFailurePathAssemblyKernel = new FailurePathAssemblyKernelStub(); + LastCreatedFailureMechanismAssemblyKernel = new FailureMechanismAssemblyKernelStub(); } /// @@ -52,9 +52,9 @@ public FailureMechanismSectionAssemblyKernelStub LastCreatedFailureMechanismSectionAssemblyKernel { get; } /// - /// Gets the last created failure path assembly kernel. + /// Gets the last created failure mechanism assembly kernel. /// - public FailurePathAssemblyKernelStub LastCreatedFailurePathAssemblyKernel { get; } + public FailureMechanismAssemblyKernelStub LastCreatedFailureMechanismAssemblyKernel { get; } public ICategoryLimitsCalculator CreateAssemblyCategoriesKernel() { @@ -68,7 +68,7 @@ public IFailureMechanismResultAssembler CreateFailureMechanismAssemblyKernel() { - return LastCreatedFailurePathAssemblyKernel; + return LastCreatedFailureMechanismAssemblyKernel; } } } \ No newline at end of file Index: Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/TestAssemblyToolKernelFactoryOld.cs =================================================================== diff -u -r68ace91ca821b02b1fdeee5aa09391a43b516e7b -r2f660e66788675684eccbdaeeaa7923d332e529e --- Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/TestAssemblyToolKernelFactoryOld.cs (.../TestAssemblyToolKernelFactoryOld.cs) (revision 68ace91ca821b02b1fdeee5aa09391a43b516e7b) +++ Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/TestAssemblyToolKernelFactoryOld.cs (.../TestAssemblyToolKernelFactoryOld.cs) (revision 2f660e66788675684eccbdaeeaa7923d332e529e) @@ -38,7 +38,7 @@ { LastCreatedAssemblyCategoriesKernel = new AssemblyCategoriesKernelStubOld(); LastCreatedFailureMechanismSectionAssemblyKernel = new FailureMechanismSectionAssemblyKernelStubOld(); - LastCreatedFailureMechanismAssemblyKernel = new FailureMechanismAssemblyKernelStub(); + LastCreatedFailureMechanismAssemblyKernel = new FailureMechanismAssemblyKernelStubOld(); LastCreatedAssessmentSectionAssemblyKernel = new AssessmentSectionAssemblyKernelStub(); LastCreatedCombinedFailureMechanismSectionAssemblyKernel = new CombinedFailureMechanismSectionAssemblyKernelStub(); } @@ -56,7 +56,7 @@ /// /// Gets the last created failure mechanism assembly kernel. /// - public FailureMechanismAssemblyKernelStub LastCreatedFailureMechanismAssemblyKernel { get; } + public FailureMechanismAssemblyKernelStubOld LastCreatedFailureMechanismAssemblyKernel { get; } /// /// Gets the last created assessment section assembly kernel.