Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Categories/AssemblyCategoriesCalculator.cs =================================================================== diff -u -rbaf9e7a385fd374010f076868ddccc77b4da17ce -r2f05c299a43f2b890e0276cf74078c616a3ca27d --- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Categories/AssemblyCategoriesCalculator.cs (.../AssemblyCategoriesCalculator.cs) (revision baf9e7a385fd374010f076868ddccc77b4da17ce) +++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Categories/AssemblyCategoriesCalculator.cs (.../AssemblyCategoriesCalculator.cs) (revision 2f05c299a43f2b890e0276cf74078c616a3ca27d) @@ -68,6 +68,23 @@ } } + public IEnumerable CalculateFailureMechanismCategories(AssemblyCategoriesInput assemblyCategoriesInput) + { + try + { + ICategoryLimitsCalculator kernel = factory.CreateAssemblyCategoriesKernel(); + IEnumerable output = kernel.CalculateFailureMechanismCategoryLimitsWbi11( + new AssessmentSection(1, assemblyCategoriesInput.SignalingNorm, assemblyCategoriesInput.LowerLimitNorm), + new FailureMechanism(assemblyCategoriesInput.N, assemblyCategoriesInput.FailureMechanismContribution)); + + return AssemblyCategoryCreator.CreateFailureMechanismAssemblyCategories(output); + } + catch (Exception e) + { + throw new AssemblyCategoriesCalculatorException(e.Message, e); + } + } + public IEnumerable CalculateFailureMechanismSectionCategories( AssemblyCategoriesInput assemblyCategoriesInput) { Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Categories/IAssemblyCategoriesCalculator.cs =================================================================== diff -u -rbaf9e7a385fd374010f076868ddccc77b4da17ce -r2f05c299a43f2b890e0276cf74078c616a3ca27d --- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Categories/IAssemblyCategoriesCalculator.cs (.../IAssemblyCategoriesCalculator.cs) (revision baf9e7a385fd374010f076868ddccc77b4da17ce) +++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Categories/IAssemblyCategoriesCalculator.cs (.../IAssemblyCategoriesCalculator.cs) (revision 2f05c299a43f2b890e0276cf74078c616a3ca27d) @@ -42,6 +42,17 @@ double signalingNorm, double lowerLimitNorm); /// + /// Performs the calculation for getting the failure mechanism categories. + /// + /// The object containing the input parameters for + /// determining the assembly categories. + /// An with categories of + /// . + /// Thrown when an error occurs + /// when performing the calculation. + IEnumerable CalculateFailureMechanismCategories(AssemblyCategoriesInput assemblyCategoriesInput); + + /// /// Performs the calculation for getting the failure mechanism section categories. /// /// The object containing the input parameters for Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/AssemblyCategoryCreator.cs =================================================================== diff -u -r3beb793b4db2bc773a4ae68783902c359db1e6bb -r2f05c299a43f2b890e0276cf74078c616a3ca27d --- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/AssemblyCategoryCreator.cs (.../AssemblyCategoryCreator.cs) (revision 3beb793b4db2bc773a4ae68783902c359db1e6bb) +++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/AssemblyCategoryCreator.cs (.../AssemblyCategoryCreator.cs) (revision 2f05c299a43f2b890e0276cf74078c616a3ca27d) @@ -25,7 +25,6 @@ using System.Linq; using Assembly.Kernel.Model; using Assembly.Kernel.Model.CategoryLimits; -using Assembly.Kernel.Model.FmSectionTypes; using Ringtoets.AssemblyTool.Data; namespace Ringtoets.AssemblyTool.KernelWrapper.Creators @@ -39,9 +38,9 @@ /// Creates a collection of /// based on the information given in the . /// - /// The collection of to + /// The collection of to /// create the result for. - /// A collection of + /// A collection of /// with information taken from the . /// Thrown when is null. /// Thrown when @@ -64,6 +63,34 @@ } /// + /// Creates a collection of + /// based on the information given in the . + /// + /// The collection of to + /// create the result for. + /// A collection of + /// with information taken from the . + /// Thrown when is null. + /// Thrown when + /// contains an invalid value. + /// Thrown when + /// contains a valid value, but unsupported. + public static IEnumerable CreateFailureMechanismAssemblyCategories( + IEnumerable categoryLimits) + { + if (categoryLimits == null) + { + throw new ArgumentNullException(nameof(categoryLimits)); + } + + return categoryLimits.Select( + categoriesOutput => new FailureMechanismAssemblyCategory( + categoriesOutput.LowerLimit, + categoriesOutput.UpperLimit, + FailureMechanismAssemblyCreator.CreateFailureMechanismAssemblyCategoryGroup(categoriesOutput.Category))).ToArray(); + } + + /// /// Creates a collection of /// based on the information given in the . /// @@ -88,7 +115,7 @@ categoriesOutput => new FailureMechanismSectionAssemblyCategory( categoriesOutput.LowerLimit, categoriesOutput.UpperLimit, - ConvertFailureMechanismSectionCategoryGroup(categoriesOutput.Category))).ToArray(); + FailureMechanismSectionAssemblyCreator.CreateFailureMechanismSectionAssemblyCategoryGroup(categoriesOutput.Category))).ToArray(); } /// @@ -131,48 +158,5 @@ throw new NotSupportedException(); } } - - /// - /// Converts a into a . - /// - /// The to convert. - /// A based on . - /// Thrown when - /// is an invalid value. - /// Thrown when - /// is a valid value, but unsupported. - private static FailureMechanismSectionAssemblyCategoryGroup ConvertFailureMechanismSectionCategoryGroup(EFmSectionCategory category) - { - if (!Enum.IsDefined(typeof(EFmSectionCategory), category)) - { - throw new InvalidEnumArgumentException(nameof(category), - (int) category, - typeof(EFmSectionCategory)); - } - - switch (category) - { - case EFmSectionCategory.Iv: - return FailureMechanismSectionAssemblyCategoryGroup.Iv; - case EFmSectionCategory.IIv: - return FailureMechanismSectionAssemblyCategoryGroup.IIv; - case EFmSectionCategory.IIIv: - return FailureMechanismSectionAssemblyCategoryGroup.IIIv; - case EFmSectionCategory.IVv: - return FailureMechanismSectionAssemblyCategoryGroup.IVv; - case EFmSectionCategory.Vv: - return FailureMechanismSectionAssemblyCategoryGroup.Vv; - case EFmSectionCategory.VIv: - return FailureMechanismSectionAssemblyCategoryGroup.VIv; - case EFmSectionCategory.VIIv: - return FailureMechanismSectionAssemblyCategoryGroup.VIIv; - case EFmSectionCategory.NotApplicable: - return FailureMechanismSectionAssemblyCategoryGroup.NotApplicable; - case EFmSectionCategory.Gr: - return FailureMechanismSectionAssemblyCategoryGroup.None; - default: - throw new NotSupportedException(); - } - } } } \ No newline at end of file Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Categories/AssemblyCategoriesCalculatorTest.cs =================================================================== diff -u -r9a64bbb28b8179b5894b4bbaf418330a974bf36b -r2f05c299a43f2b890e0276cf74078c616a3ca27d --- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Categories/AssemblyCategoriesCalculatorTest.cs (.../AssemblyCategoriesCalculatorTest.cs) (revision 9a64bbb28b8179b5894b4bbaf418330a974bf36b) +++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Categories/AssemblyCategoriesCalculatorTest.cs (.../AssemblyCategoriesCalculatorTest.cs) (revision 2f05c299a43f2b890e0276cf74078c616a3ca27d) @@ -143,6 +143,77 @@ } [Test] + public void CalculateFailureMechanismCategories_WithInput_InputCorrectlySetToKernel() + { + // Setup + AssemblyCategoriesInput assemblyCategoriesInput = CreateRandomAssemblyCategoriesInput(); + + using (new AssemblyToolKernelFactoryConfig()) + { + var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; + AssemblyCategoriesKernelStub kernel = factory.LastCreatedAssemblyCategoriesKernel; + kernel.FailureMechanismCategoriesOutput = CreateFailureMechanismCategoryKernelOutput(); + + var calculator = new AssemblyCategoriesCalculator(factory); + + // Call + calculator.CalculateFailureMechanismCategories(assemblyCategoriesInput); + + // Assert + Assert.AreEqual(assemblyCategoriesInput.LowerLimitNorm, kernel.LowerLimitNorm); + Assert.AreEqual(assemblyCategoriesInput.SignalingNorm, kernel.SignalingNorm); + Assert.AreEqual(assemblyCategoriesInput.FailureMechanismContribution, kernel.FailureMechanismContribution); + Assert.AreEqual(assemblyCategoriesInput.N, kernel.N); + } + } + + [Test] + public void CalculateFailureMechanismCategories_KernelWithCompleteOutput_OutputCorrectlyReturnedByCalculator() + { + // Setup + IEnumerable output = CreateFailureMechanismCategoryKernelOutput(); + + using (new AssemblyToolKernelFactoryConfig()) + { + var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; + AssemblyCategoriesKernelStub kernel = factory.LastCreatedAssemblyCategoriesKernel; + kernel.FailureMechanismCategoriesOutput = output; + + var calculator = new AssemblyCategoriesCalculator(factory); + + // Call + IEnumerable result = calculator.CalculateFailureMechanismCategories( + CreateRandomAssemblyCategoriesInput()); + + // Assert + AssemblyCategoryAssert.AssertFailureMechanismAssemblyCategories(output, result); + } + } + + [Test] + public void CalculateFailureMechanismCategories_KernelThrowsException_ThrowAssemblyCategoriesCalculatorException() + { + // Setup + using (new AssemblyToolKernelFactoryConfig()) + { + var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; + AssemblyCategoriesKernelStub kernel = factory.LastCreatedAssemblyCategoriesKernel; + kernel.ThrowExceptionOnCalculate = true; + + var calculator = new AssemblyCategoriesCalculator(factory); + + // Call + TestDelegate test = () => calculator.CalculateFailureMechanismCategories( + CreateRandomAssemblyCategoriesInput()); + + // Assert + var exception = Assert.Throws(test); + Assert.IsNotNull(exception.InnerException); + Assert.AreEqual(exception.InnerException.Message, exception.Message); + } + } + + [Test] public void CalculateFailureMechanismSectionCategories_WithInput_InputCorrectlySetToKernel() { // Setup @@ -312,5 +383,15 @@ yield return new FmSectionCategoryLimits(random.NextEnumValue(), random.NextDouble(0, 0.5), random.NextDouble(0.5, 1)); yield return new FmSectionCategoryLimits(random.NextEnumValue(), random.NextDouble(0, 0.5), random.NextDouble(0.5, 1)); } + + private static IEnumerable CreateFailureMechanismCategoryKernelOutput() + { + var random = new Random(11); + + yield return new FailureMechanismCategoryLimits(random.NextEnumValue(), random.NextDouble(0, 0.5), random.NextDouble(0.5, 1)); + yield return new FailureMechanismCategoryLimits(random.NextEnumValue(), random.NextDouble(0, 0.5), random.NextDouble(0.5, 1)); + yield return new FailureMechanismCategoryLimits(random.NextEnumValue(), random.NextDouble(0, 0.5), random.NextDouble(0.5, 1)); + yield return new FailureMechanismCategoryLimits(random.NextEnumValue(), random.NextDouble(0, 0.5), random.NextDouble(0.5, 1)); + } } } \ No newline at end of file Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/AssemblyCategoryCreatorTest.cs =================================================================== diff -u -r4b5d80639ec5b56ed227ef2b467e42edc191ca91 -r2f05c299a43f2b890e0276cf74078c616a3ca27d --- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/AssemblyCategoryCreatorTest.cs (.../AssemblyCategoryCreatorTest.cs) (revision 4b5d80639ec5b56ed227ef2b467e42edc191ca91) +++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/AssemblyCategoryCreatorTest.cs (.../AssemblyCategoryCreatorTest.cs) (revision 2f05c299a43f2b890e0276cf74078c616a3ca27d) @@ -117,7 +117,7 @@ }; // Call - TestDelegate test = () => AssemblyCategoryCreator.CreateAssessmentSectionAssemblyCategory((EAssessmentGrade)99); + TestDelegate test = () => AssemblyCategoryCreator.CreateAssessmentSectionAssemblyCategory((EAssessmentGrade) 99); // Assert const string exceptionMessage = "The value of argument 'category' (99) is invalid for Enum type 'EAssessmentGrade'."; @@ -138,6 +138,84 @@ } [Test] + public void CreateFailureMechanismAssemblyCategories_CategoryLimitsNull_ThrowsArgumentNullException() + { + // Call + TestDelegate call = () => AssemblyCategoryCreator.CreateFailureMechanismAssemblyCategories(null); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("categoryLimits", exception.ParamName); + } + + [Test] + public void CreateFailureMechanismAssemblyCategories_WithCategoryLimits_ReturnFailureMechanismAssemblyCategoryResult() + { + // Setup + var random = new Random(11); + + var categoryLimits = new[] + { + new FailureMechanismCategoryLimits(random.NextEnumValue(), random.NextDouble(0, 0.5), random.NextDouble(0.5, 1)), + new FailureMechanismCategoryLimits(random.NextEnumValue(), random.NextDouble(0, 0.5), random.NextDouble(0.5, 1)), + new FailureMechanismCategoryLimits(random.NextEnumValue(), random.NextDouble(0, 0.5), random.NextDouble(0.5, 1)), + new FailureMechanismCategoryLimits(random.NextEnumValue(), random.NextDouble(0, 0.5), random.NextDouble(0.5, 1)) + }; + + // Call + IEnumerable result = AssemblyCategoryCreator.CreateFailureMechanismAssemblyCategories(categoryLimits); + + // Assert + AssemblyCategoryAssert.AssertFailureMechanismAssemblyCategories(categoryLimits, result); + } + + [Test] + public void CreateFailureMechanismAssemblyCategories_CategoryWithInvalidFailureMechanismCategory_ThrowsInvalidEnumArgumentException() + { + // Setup + var categoryLimit = new[] + { + new FailureMechanismCategoryLimits((EFailureMechanismCategory) 99, 0, 0) + }; + + // Call + TestDelegate test = () => AssemblyCategoryCreator.CreateFailureMechanismAssemblyCategories(categoryLimit); + + // Assert + const string exceptionMessage = "The value of argument 'category' (99) is invalid for Enum type 'EFailureMechanismCategory'."; + TestHelper.AssertThrowsArgumentExceptionAndTestMessage(test, exceptionMessage); + } + + [Test] + [TestCase(EFailureMechanismCategory.It, FailureMechanismAssemblyCategoryGroup.It)] + [TestCase(EFailureMechanismCategory.IIt, FailureMechanismAssemblyCategoryGroup.IIt)] + [TestCase(EFailureMechanismCategory.IIIt, FailureMechanismAssemblyCategoryGroup.IIIt)] + [TestCase(EFailureMechanismCategory.IVt, FailureMechanismAssemblyCategoryGroup.IVt)] + [TestCase(EFailureMechanismCategory.Vt, FailureMechanismAssemblyCategoryGroup.Vt)] + [TestCase(EFailureMechanismCategory.VIt, FailureMechanismAssemblyCategoryGroup.VIt)] + [TestCase(EFailureMechanismCategory.VIIt, FailureMechanismAssemblyCategoryGroup.VIIt)] + [TestCase(EFailureMechanismCategory.Nvt, FailureMechanismAssemblyCategoryGroup.NotApplicable)] + [TestCase(EFailureMechanismCategory.Gr, FailureMechanismAssemblyCategoryGroup.None)] + public void CreateFailureMechanismAssemblyCategories_CategoryWithValidFailureMechanismCategory_ExpectedFailureMechanismAssemblyCategoryResultType( + EFailureMechanismCategory categoryGroup, + FailureMechanismAssemblyCategoryGroup expectedCategoryGroup) + { + // Setup + var categoryLimits = new[] + { + new FailureMechanismCategoryLimits(categoryGroup, 0, 0) + }; + + // Call + IEnumerable result = AssemblyCategoryCreator.CreateFailureMechanismAssemblyCategories(categoryLimits); + + // Assert + FailureMechanismAssemblyCategory categoryResult = result.Single(); + + Assert.AreEqual(expectedCategoryGroup, categoryResult.Group); + } + + [Test] public void CreateFailureMechanismSectionAssemblyCategories_CategoryLimitsNull_ThrowsArgumentNullException() { // Call Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Calculators/Categories/AssemblyCategoriesCalculatorStubTest.cs =================================================================== diff -u -reddfb02cea511355211eaeb85050a5e12cb09a3f -r2f05c299a43f2b890e0276cf74078c616a3ca27d --- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Calculators/Categories/AssemblyCategoriesCalculatorStubTest.cs (.../AssemblyCategoriesCalculatorStubTest.cs) (revision eddfb02cea511355211eaeb85050a5e12cb09a3f) +++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Calculators/Categories/AssemblyCategoriesCalculatorStubTest.cs (.../AssemblyCategoriesCalculatorStubTest.cs) (revision 2f05c299a43f2b890e0276cf74078c616a3ca27d) @@ -82,11 +82,13 @@ public void CalculateAssessmentSectionCategories_ThrowExceptionOnCalculateFalseAndOutputSet_ReturnsCategories() { // Setup - var calculator = new AssemblyCategoriesCalculatorStub(); - calculator.AssessmentSectionCategoriesOutput = new[] + var calculator = new AssemblyCategoriesCalculatorStub { - new AssessmentSectionAssemblyCategory(1, 2, AssessmentSectionAssemblyCategoryGroup.A), - new AssessmentSectionAssemblyCategory(4.01, 5, AssessmentSectionAssemblyCategoryGroup.D) + AssessmentSectionCategoriesOutput = new[] + { + new AssessmentSectionAssemblyCategory(1, 2, AssessmentSectionAssemblyCategoryGroup.A), + new AssessmentSectionAssemblyCategory(4.01, 5, AssessmentSectionAssemblyCategoryGroup.D) + } }; // Call @@ -133,12 +135,97 @@ } [Test] - public void CalculateFailureMechanismSectionCategories_ThrowExceptionOnCalculateFalse_ReturnsCategories() + public void CalculateFailureMechanismCategories_ThrowExceptionOnCalculateFalseAndOutputNotSet_ReturnsCategories() { // Setup var calculator = new AssemblyCategoriesCalculatorStub(); // Call + FailureMechanismAssemblyCategory[] result = calculator.CalculateFailureMechanismCategories(CreateAssemblyCategoriesInput()).ToArray(); + + // Assert + Assert.AreEqual(3, result.Length); + CollectionAssert.AreEqual(new[] + { + 1, + 2.01, + 3.01 + }, result.Select(r => r.LowerBoundary)); + CollectionAssert.AreEqual(new[] + { + 2, + 3, + 4 + }, result.Select(r => r.UpperBoundary)); + CollectionAssert.AreEqual(new[] + { + FailureMechanismAssemblyCategoryGroup.It, + FailureMechanismAssemblyCategoryGroup.IIt, + FailureMechanismAssemblyCategoryGroup.IIIt + }, result.Select(r => r.Group)); + } + + [Test] + public void CalculateFailureMechanismCategories_ThrowExceptionOnCalculateFalseAndOutputSet_ReturnsCategories() + { + // Setup + var calculator = new AssemblyCategoriesCalculatorStub + { + FailureMechanismCategoriesOutput = new[] + { + new FailureMechanismAssemblyCategory(1, 2, FailureMechanismAssemblyCategoryGroup.IIIt), + new FailureMechanismAssemblyCategory(4.01, 5, FailureMechanismAssemblyCategoryGroup.VIt) + } + }; + + // Call + IEnumerable result = calculator.CalculateFailureMechanismCategories(CreateAssemblyCategoriesInput()); + + // Assert + Assert.AreSame(calculator.FailureMechanismCategoriesOutput, result); + } + + [Test] + public void CalculateFailureMechanismCategories_ThrowExceptionOnCalculateFalse_SetsInput() + { + // Setup + AssemblyCategoriesInput assemblyCategoriesInput = CreateAssemblyCategoriesInput(); + + var calculator = new AssemblyCategoriesCalculatorStub(); + + // Call + calculator.CalculateFailureMechanismCategories( + assemblyCategoriesInput); + + // Assert + Assert.AreSame(assemblyCategoriesInput, calculator.AssemblyCategoriesInput); + } + + [Test] + public void CalculateFailureMechanismCategories_ThrowExceptionOnCalculateTrue_ThrowsAssemblyCategoriesCalculatorException() + { + // Setup + var calculator = new AssemblyCategoriesCalculatorStub + { + ThrowExceptionOnCalculate = true + }; + + // Call + TestDelegate test = () => calculator.CalculateFailureMechanismCategories(CreateAssemblyCategoriesInput()); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("Message", exception.Message); + Assert.IsNotNull(exception.InnerException); + } + + [Test] + public void CalculateFailureMechanismSectionCategories_ThrowExceptionOnCalculateFalseAndOutputNotSet_ReturnsCategories() + { + // Setup + var calculator = new AssemblyCategoriesCalculatorStub(); + + // Call FailureMechanismSectionAssemblyCategory[] result = calculator.CalculateFailureMechanismSectionCategories(CreateAssemblyCategoriesInput()).ToArray(); // Assert @@ -164,6 +251,26 @@ } [Test] + public void CalculateFailureMechanismSectionCategories_ThrowExceptionOnCalculateFalseAndOutputSet_ReturnsCategories() + { + // Setup + var calculator = new AssemblyCategoriesCalculatorStub + { + FailureMechanismSectionCategoriesOutput = new[] + { + new FailureMechanismSectionAssemblyCategory(1, 2, FailureMechanismSectionAssemblyCategoryGroup.IIIv), + new FailureMechanismSectionAssemblyCategory(4.01, 5, FailureMechanismSectionAssemblyCategoryGroup.VIv) + } + }; + + // Call + IEnumerable result = calculator.CalculateFailureMechanismSectionCategories(CreateAssemblyCategoriesInput()); + + // Assert + Assert.AreSame(calculator.FailureMechanismSectionCategoriesOutput, result); + } + + [Test] public void CalculateFailureMechanismSectionCategories_ThrowExceptionOnCalculateFalse_SetsInput() { // Setup Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Kernels/Categories/AssemblyCategoriesKernelStubTest.cs =================================================================== diff -u -r7d2d3b08afed372bd36d3ab1386274bbaf351237 -r2f05c299a43f2b890e0276cf74078c616a3ca27d --- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Kernels/Categories/AssemblyCategoriesKernelStubTest.cs (.../AssemblyCategoriesKernelStubTest.cs) (revision 7d2d3b08afed372bd36d3ab1386274bbaf351237) +++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Kernels/Categories/AssemblyCategoriesKernelStubTest.cs (.../AssemblyCategoriesKernelStubTest.cs) (revision 2f05c299a43f2b890e0276cf74078c616a3ca27d) @@ -115,6 +115,79 @@ } [Test] + public void CalculateFailureMechanismCategoryLimitsWbi11_ThrowExceptionOnCalculateFalse_InputCorrectlySetToKernelAndCalculatedTrue() + { + // Setup + var random = new Random(11); + double lowerLimitNorm = random.NextDouble(0.5, 0.9); + double signalingNorm = random.NextDouble(0.0, 0.4); + double failureMechanismContribution = random.NextDouble(); + double n = random.NextDouble(1, 5); + + var kernel = new AssemblyCategoriesKernelStub(); + + // Precondition + Assert.IsFalse(kernel.Calculated); + + // Call + kernel.CalculateFailureMechanismCategoryLimitsWbi11(new AssessmentSection(random.NextDouble(), signalingNorm, lowerLimitNorm), + new FailureMechanism(n, failureMechanismContribution)); + + // Assert + Assert.IsTrue(kernel.Calculated); + + Assert.AreEqual(signalingNorm, kernel.SignalingNorm); + Assert.AreEqual(lowerLimitNorm, kernel.LowerLimitNorm); + Assert.AreEqual(failureMechanismContribution, kernel.FailureMechanismContribution); + Assert.AreEqual(n, kernel.N); + } + + [Test] + public void CalculateFailureMechanismCategoryLimitsWbi11_ThrowExceptionOnCalculateFalse_ReturnAssessmentSectionCategories() + { + // Setup + var random = new Random(11); + var kernel = new AssemblyCategoriesKernelStub + { + FailureMechanismCategoriesOutput = Enumerable.Empty() + }; + + // Call + IEnumerable output = kernel.CalculateFailureMechanismCategoryLimitsWbi11( + new AssessmentSection(random.NextDouble(), random.NextDouble(0.0, 0.4), random.NextDouble(0.5, 0.9)), + new FailureMechanism(random.NextDouble(1, 5), random.NextDouble())); + + // Assert + Assert.AreSame(kernel.FailureMechanismCategoriesOutput, output); + } + + [Test] + public void CalculateFailureMechanismCategoryLimitsWbi11_ThrowExceptionOnCalculateTrue_ThrowsException() + { + // Setup + var random = new Random(11); + var kernel = new AssemblyCategoriesKernelStub + { + ThrowExceptionOnCalculate = true + }; + + // Precondition + Assert.IsFalse(kernel.Calculated); + + // Call + TestDelegate test = () => kernel.CalculateFailureMechanismCategoryLimitsWbi11( + new AssessmentSection(random.NextDouble(), random.NextDouble(0.0, 0.4), random.NextDouble(0.5, 0.9)), + new FailureMechanism(random.NextDouble(1, 5), random.NextDouble())); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("Message", exception.Message); + Assert.IsNotNull(exception.InnerException); + Assert.IsFalse(kernel.Calculated); + Assert.IsNull(kernel.FailureMechanismCategoriesOutput); + } + + [Test] public void CalculateFmSectionCategoryLimitsWbi01_ThrowExceptionOnCalculateFalse_InputCorrectlySetToKernelAndCalculatedTrue() { // Setup @@ -259,21 +332,5 @@ Assert.IsFalse(kernel.Calculated); Assert.IsNull(kernel.FailureMechanismSectionCategoriesOutput); } - - [Test] - public void CalculateFailureMechanismCategoryLimitsWbi11_Always_ThrowsNotImplementedException() - { - // Setup - var random = new Random(11); - var kernel = new AssemblyCategoriesKernelStub(); - - // Call - TestDelegate test = () => kernel.CalculateFailureMechanismCategoryLimitsWbi11( - new AssessmentSection(random.NextDouble(), random.NextDouble(0.0, 0.4), random.NextDouble(0.5, 0.9)), - new FailureMechanism(random.NextDouble(1, 5), random.NextDouble())); - - // Assert - Assert.Throws(test); - } } } \ No newline at end of file Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/AssemblyCategoryAssert.cs =================================================================== diff -u -r87391c51bc397ae140d3aca7940b4f5ac80cad35 -r2f05c299a43f2b890e0276cf74078c616a3ca27d --- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/AssemblyCategoryAssert.cs (.../AssemblyCategoryAssert.cs) (revision 87391c51bc397ae140d3aca7940b4f5ac80cad35) +++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/AssemblyCategoryAssert.cs (.../AssemblyCategoryAssert.cs) (revision 2f05c299a43f2b890e0276cf74078c616a3ca27d) @@ -55,6 +55,23 @@ /// /// Asserts whether is equal to . /// + /// The original collection of . + /// The actual collection of . + /// Thrown when + /// is not equal to . + public static void AssertFailureMechanismAssemblyCategories(IEnumerable original, + IEnumerable actual) + { + Assert.AreEqual(original.Count(), actual.Count()); + + CollectionAssert.AreEqual(original.Select(o => GetFailureMechanismCategoryGroup(o.Category)), actual.Select(r => r.Group)); + CollectionAssert.AreEqual(original.Select(o => o.LowerLimit), actual.Select(r => r.LowerBoundary)); + CollectionAssert.AreEqual(original.Select(o => o.UpperLimit), actual.Select(r => r.UpperBoundary)); + } + + /// + /// Asserts whether is equal to . + /// /// The original collection of . /// The actual collection of . /// Thrown when @@ -94,6 +111,33 @@ } } + private static FailureMechanismAssemblyCategoryGroup GetFailureMechanismCategoryGroup(EFailureMechanismCategory category) + { + switch (category) + { + case EFailureMechanismCategory.It: + return FailureMechanismAssemblyCategoryGroup.It; + case EFailureMechanismCategory.IIt: + return FailureMechanismAssemblyCategoryGroup.IIt; + case EFailureMechanismCategory.IIIt: + return FailureMechanismAssemblyCategoryGroup.IIIt; + case EFailureMechanismCategory.IVt: + return FailureMechanismAssemblyCategoryGroup.IVt; + case EFailureMechanismCategory.Vt: + return FailureMechanismAssemblyCategoryGroup.Vt; + case EFailureMechanismCategory.VIt: + return FailureMechanismAssemblyCategoryGroup.VIt; + case EFailureMechanismCategory.VIIt: + return FailureMechanismAssemblyCategoryGroup.VIIt; + case EFailureMechanismCategory.Nvt: + return FailureMechanismAssemblyCategoryGroup.NotApplicable; + case EFailureMechanismCategory.Gr: + return FailureMechanismAssemblyCategoryGroup.None; + default: + throw new NotSupportedException(); + } + } + private static FailureMechanismSectionAssemblyCategoryGroup GetFailureMechanismSectionCategoryGroup(EFmSectionCategory category) { switch (category) Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Calculators/Categories/AssemblyCategoriesCalculatorStub.cs =================================================================== diff -u -rbaf9e7a385fd374010f076868ddccc77b4da17ce -r2f05c299a43f2b890e0276cf74078c616a3ca27d --- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Calculators/Categories/AssemblyCategoriesCalculatorStub.cs (.../AssemblyCategoriesCalculatorStub.cs) (revision baf9e7a385fd374010f076868ddccc77b4da17ce) +++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Calculators/Categories/AssemblyCategoriesCalculatorStub.cs (.../AssemblyCategoriesCalculatorStub.cs) (revision 2f05c299a43f2b890e0276cf74078c616a3ca27d) @@ -52,9 +52,14 @@ public IEnumerable AssessmentSectionCategoriesOutput { get; set; } /// + /// Gets or sets the output of the calculation. + /// + public IEnumerable FailureMechanismCategoriesOutput { get; set; } + + /// /// Gets the output of the calculation. /// - public IEnumerable FailureMechanismSectionCategoriesOutput { get; private set; } + public IEnumerable FailureMechanismSectionCategoriesOutput { get; set; } /// /// Indicator whether an exception must be thrown when performing the calculation. @@ -80,6 +85,24 @@ }); } + public IEnumerable CalculateFailureMechanismCategories(AssemblyCategoriesInput assemblyCategoriesInput) + { + if (ThrowExceptionOnCalculate) + { + throw new AssemblyCategoriesCalculatorException("Message", new Exception()); + } + + AssemblyCategoriesInput = assemblyCategoriesInput; + + return FailureMechanismCategoriesOutput + ?? (FailureMechanismCategoriesOutput = new[] + { + new FailureMechanismAssemblyCategory(1, 2, FailureMechanismAssemblyCategoryGroup.It), + new FailureMechanismAssemblyCategory(2.01, 3, FailureMechanismAssemblyCategoryGroup.IIt), + new FailureMechanismAssemblyCategory(3.01, 4, FailureMechanismAssemblyCategoryGroup.IIIt) + }); + } + public IEnumerable CalculateFailureMechanismSectionCategories( AssemblyCategoriesInput assemblyCategoriesInput) { Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Kernels/Categories/AssemblyCategoriesKernelStub.cs =================================================================== diff -u -r051211cc2f021db7921e679f6734cb247ea5021a -r2f05c299a43f2b890e0276cf74078c616a3ca27d --- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Kernels/Categories/AssemblyCategoriesKernelStub.cs (.../AssemblyCategoriesKernelStub.cs) (revision 051211cc2f021db7921e679f6734cb247ea5021a) +++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Kernels/Categories/AssemblyCategoriesKernelStub.cs (.../AssemblyCategoriesKernelStub.cs) (revision 2f05c299a43f2b890e0276cf74078c616a3ca27d) @@ -68,6 +68,11 @@ public IEnumerable AssessmentSectionCategoriesOutput { get; set; } /// + /// Gets or sets the failure mechanism categories output. + /// + public IEnumerable FailureMechanismCategoriesOutput { get; set; } + + /// /// Gets or sets the failure mechanism section categories output. /// public IEnumerable FailureMechanismSectionCategoriesOutput { get; set; } @@ -89,7 +94,19 @@ public IEnumerable CalculateFailureMechanismCategoryLimitsWbi11(AssessmentSection section, FailureMechanism failureMechanism) { - throw new NotImplementedException(); + if (ThrowExceptionOnCalculate) + { + throw new Exception("Message", new Exception()); + } + + SignalingNorm = section.FailureProbabilitySignallingLimit; + LowerLimitNorm = section.FailureProbabilityLowerLimit; + FailureMechanismContribution = failureMechanism.FailureProbabilityMarginFactor; + N = failureMechanism.LengthEffectFactor; + + Calculated = true; + + return FailureMechanismCategoriesOutput; } public IEnumerable CalculateFmSectionCategoryLimitsWbi01(AssessmentSection section, FailureMechanism failureMechanism)