Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismSectionAssemblyCalculator.cs =================================================================== diff -u -r712c1aad8e5486980f259491130e4ae07ea48149 -r1a7e949a3a94f976dd41a7a568701a7674685427 --- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismSectionAssemblyCalculator.cs (.../FailureMechanismSectionAssemblyCalculator.cs) (revision 712c1aad8e5486980f259491130e4ae07ea48149) +++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismSectionAssemblyCalculator.cs (.../FailureMechanismSectionAssemblyCalculator.cs) (revision 1a7e949a3a94f976dd41a7a568701a7674685427) @@ -152,6 +152,26 @@ new Probability(probability))); } + public FailureMechanismSectionAssembly AssembleTailorMadeAssessment(TailorMadeAssessmentProbabilityCalculationResultType tailorMadeAssessmentResult, + double probability, + IEnumerable categories) + { + try + { + IFailureMechanismSectionAssemblyCalculatorKernel kernel = factory.CreateFailureMechanismSectionAssemblyKernel(); + CalculationOutput output = kernel.TailorMadeAssessmentDirectFailureMechanisms( + FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbability(tailorMadeAssessmentResult, + probability, + categories)); + + return FailureMechanismSectionAssemblyCreator.Create(output.Result); + } + catch (Exception e) + { + throw new FailureMechanismSectionAssemblyCalculatorException(e.Message, e); + } + } + public FailureMechanismSectionAssembly AssembleCombined(FailureMechanismSectionAssembly simpleAssembly, FailureMechanismSectionAssembly detailedAssembly, FailureMechanismSectionAssembly tailorMadeAssembly) Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/IFailureMechanismSectionAssemblyCalculator.cs =================================================================== diff -u -r712c1aad8e5486980f259491130e4ae07ea48149 -r1a7e949a3a94f976dd41a7a568701a7674685427 --- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/IFailureMechanismSectionAssemblyCalculator.cs (.../IFailureMechanismSectionAssemblyCalculator.cs) (revision 712c1aad8e5486980f259491130e4ae07ea48149) +++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/IFailureMechanismSectionAssemblyCalculator.cs (.../IFailureMechanismSectionAssemblyCalculator.cs) (revision 1a7e949a3a94f976dd41a7a568701a7674685427) @@ -94,6 +94,19 @@ IEnumerable categories); /// + /// Assembles the tailor made assessment based on the input parameters. + /// + /// The tailor made assessment result. + /// The calculated probability. + /// The collection of categories for this failure mechanism section. + /// A . + /// Thrown when + /// an error occurs when performing the assembly. + FailureMechanismSectionAssembly AssembleTailorMadeAssessment(TailorMadeAssessmentProbabilityCalculationResultType tailorMadeAssessmentResult, + double probability, + IEnumerable categories); + + /// /// Assembles the combined assembly based on the input parameters. /// /// The simple assembly. Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/FailureMechanismSectionAssemblyCalculatorInputCreator.cs =================================================================== diff -u -rcb946a26fea9d49d3aa3be7b32df6479b41fe244 -r1a7e949a3a94f976dd41a7a568701a7674685427 --- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/FailureMechanismSectionAssemblyCalculatorInputCreator.cs (.../FailureMechanismSectionAssemblyCalculatorInputCreator.cs) (revision cb946a26fea9d49d3aa3be7b32df6479b41fe244) +++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Creators/FailureMechanismSectionAssemblyCalculatorInputCreator.cs (.../FailureMechanismSectionAssemblyCalculatorInputCreator.cs) (revision 1a7e949a3a94f976dd41a7a568701a7674685427) @@ -195,6 +195,74 @@ } /// + /// Creates based on the given parameters. + /// + /// The tailor made assessment result to create + /// the input for. + /// The calculated probability to create the input for. + /// A collection of to + /// create the input for. + /// The created . + /// Thrown when + /// is null. + /// Thrown when: + /// + /// contains an invalid ; + /// is an invalid . + /// + /// + /// Thrown when: + /// + /// contains a valid but unsupported ; + /// a valid but unsupported . + /// + /// + /// Thrown when any input parameter has an + /// invalid value. + public static TailorMadeCalculationInputFromProbability CreateTailorMadeCalculationInputFromProbability( + TailorMadeAssessmentProbabilityCalculationResultType tailorMadeAssessmentResult, + double probability, + IEnumerable categories) + { + if (categories == null) + { + throw new ArgumentNullException(nameof(categories)); + } + + if (!Enum.IsDefined(typeof(TailorMadeAssessmentProbabilityCalculationResultType), tailorMadeAssessmentResult)) + { + throw new InvalidEnumArgumentException(nameof(tailorMadeAssessmentResult), + (int) tailorMadeAssessmentResult, + typeof(TailorMadeAssessmentProbabilityCalculationResultType)); + } + + TailorMadeProbabilityCalculationResult tailorMadeProbabilityCalculationResult; + switch (tailorMadeAssessmentResult) + { + case TailorMadeAssessmentProbabilityCalculationResultType.None: + tailorMadeProbabilityCalculationResult = new TailorMadeProbabilityCalculationResult(TailorMadeProbabilityCalculationResultGroup.None); + break; + case TailorMadeAssessmentProbabilityCalculationResultType.ProbabilityNegligible: + tailorMadeProbabilityCalculationResult = new TailorMadeProbabilityCalculationResult(TailorMadeProbabilityCalculationResultGroup.FV); + break; + case TailorMadeAssessmentProbabilityCalculationResultType.NotAssessed: + tailorMadeProbabilityCalculationResult = new TailorMadeProbabilityCalculationResult(TailorMadeProbabilityCalculationResultGroup.NGO); + break; + case TailorMadeAssessmentProbabilityCalculationResultType.Probability: + tailorMadeProbabilityCalculationResult = new TailorMadeProbabilityCalculationResult(new Probability(probability)); + break; + default: + throw new NotSupportedException(); + } + + return new TailorMadeCalculationInputFromProbability(tailorMadeProbabilityCalculationResult, + categories.Select(category => new FailureMechanismSectionCategory( + ConvertFailureMechanismSectionAssemblyCategoryGroup(category.Group), + new Probability(category.LowerBoundary), + new Probability(category.UpperBoundary))).ToArray()); + } + + /// /// Converts a into a . /// /// The to convert. Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorTest.cs =================================================================== diff -u -r712c1aad8e5486980f259491130e4ae07ea48149 -r1a7e949a3a94f976dd41a7a568701a7674685427 --- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorTest.cs (.../FailureMechanismSectionAssemblyCalculatorTest.cs) (revision 712c1aad8e5486980f259491130e4ae07ea48149) +++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorTest.cs (.../FailureMechanismSectionAssemblyCalculatorTest.cs) (revision 1a7e949a3a94f976dd41a7a568701a7674685427) @@ -68,10 +68,41 @@ Assert.AreEqual("factory", exception.ParamName); } + private static void AssertCalculatorOutput(CalculationOutput original, FailureMechanismSectionAssembly actual) + { + Assert.AreEqual(GetGroup(original.Result.CategoryGroup), actual.Group); + Assert.AreEqual(original.Result.EstimatedProbabilityOfFailure, actual.Probability); + } + + private static FailureMechanismSectionAssemblyCategoryGroup GetGroup(FailureMechanismSectionCategoryGroup originalGroup) + { + switch (originalGroup) + { + case FailureMechanismSectionCategoryGroup.Iv: + return FailureMechanismSectionAssemblyCategoryGroup.Iv; + case FailureMechanismSectionCategoryGroup.IIv: + return FailureMechanismSectionAssemblyCategoryGroup.IIv; + case FailureMechanismSectionCategoryGroup.IIIv: + return FailureMechanismSectionAssemblyCategoryGroup.IIIv; + case FailureMechanismSectionCategoryGroup.IVv: + return FailureMechanismSectionAssemblyCategoryGroup.IVv; + case FailureMechanismSectionCategoryGroup.Vv: + return FailureMechanismSectionAssemblyCategoryGroup.Vv; + case FailureMechanismSectionCategoryGroup.VIv: + return FailureMechanismSectionAssemblyCategoryGroup.VIv; + case FailureMechanismSectionCategoryGroup.VIIv: + return FailureMechanismSectionAssemblyCategoryGroup.VIIv; + case FailureMechanismSectionCategoryGroup.None: + return FailureMechanismSectionAssemblyCategoryGroup.None; + default: + throw new NotSupportedException(); + } + } + #region Tailor Made Assessment [Test] - public void AssembleTailorMadeAssessmentWithResult_Always_OutputCorrectlyReturnedByCalculator() + public void AssembleTailorMadeAssessmentWithProbabilityAndDetailedCalculationResult_Always_OutputCorrectlyReturnedByCalculator() { // Setup var random = new Random(39); @@ -100,39 +131,179 @@ } } - #endregion + [Test] + public void AssembleTailorMadeAssessment_WithInvalidCategoryEnumInput_ThrowFailureMechanismSectionAssemblyCalculatorException() + { + // Setup + var random = new Random(39); + double probability = random.NextDouble(); + var categories = new[] + { + new FailureMechanismSectionAssemblyCategory(random.NextDouble(), + random.NextDouble(), + (FailureMechanismSectionAssemblyCategoryGroup) 99) + }; - private static void AssertCalculatorOutput(CalculationOutput original, FailureMechanismSectionAssembly actual) + using (new AssemblyToolKernelFactoryConfig()) + { + var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; + FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel; + kernel.FailureMechanismSectionAssemblyCategoryResult = new CalculationOutput( + new FailureMechanismSectionAssemblyCategoryResult(FailureMechanismSectionCategoryGroup.Iv, Probability.NaN)); + + var calculator = new FailureMechanismSectionAssemblyCalculator(factory); + + // Call + TestDelegate test = () => calculator.AssembleTailorMadeAssessment(TailorMadeAssessmentProbabilityCalculationResultType.Probability, probability, categories); + + // Assert + var exception = Assert.Throws(test); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + [Test] + public void AssembleTailorMadeAssessment_WithValidInput_InputCorrectlySetToKernel() { - Assert.AreEqual(GetGroup(original.Result.CategoryGroup), actual.Group); - Assert.AreEqual(original.Result.EstimatedProbabilityOfFailure, actual.Probability); + // Setup + var random = new Random(39); + double probability = random.NextDouble(); + var categories = new[] + { + new FailureMechanismSectionAssemblyCategory(random.NextDouble(0.0, 0.5), + random.NextDouble(0.6, 1.0), + FailureMechanismSectionAssemblyCategoryGroup.IIv) + }; + + using (new AssemblyToolKernelFactoryConfig()) + { + var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; + FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel; + kernel.FailureMechanismSectionAssemblyCategoryResult = new CalculationOutput( + new FailureMechanismSectionAssemblyCategoryResult(FailureMechanismSectionCategoryGroup.Iv, Probability.NaN)); + + var calculator = new FailureMechanismSectionAssemblyCalculator(factory); + + // Call + calculator.AssembleTailorMadeAssessment(TailorMadeAssessmentProbabilityCalculationResultType.Probability, probability, categories); + + // Assert + Assert.AreEqual(probability, kernel.TailorMadeCalculationInputFromProbabilityInput.Result.Probability); + Assert.AreEqual(TailorMadeProbabilityCalculationResultGroup.Probability, kernel.TailorMadeCalculationInputFromProbabilityInput.Result.CalculationResultGroup); + + FailureMechanismSectionCategory actualCategory = kernel.TailorMadeCalculationInputFromProbabilityInput.Categories.Single(); + FailureMechanismSectionAssemblyCategory expectedCategory = categories.Single(); + Assert.AreEqual(expectedCategory.LowerBoundary, actualCategory.LowerBoundary); + Assert.AreEqual(expectedCategory.UpperBoundary, actualCategory.UpperBoundary); + Assert.AreEqual(FailureMechanismSectionCategoryGroup.IIv, actualCategory.CategoryGroup); + } } - private static FailureMechanismSectionAssemblyCategoryGroup GetGroup(FailureMechanismSectionCategoryGroup originalGroup) + [Test] + public void AssembleTailorMadeAssessment_KernelWithCompleteOutput_OutputCorrectlyReturnedByCalculator() { - switch (originalGroup) + // Setup + var random = new Random(39); + double probability = random.NextDouble(); + var categories = new[] { - case FailureMechanismSectionCategoryGroup.Iv: - return FailureMechanismSectionAssemblyCategoryGroup.Iv; - case FailureMechanismSectionCategoryGroup.IIv: - return FailureMechanismSectionAssemblyCategoryGroup.IIv; - case FailureMechanismSectionCategoryGroup.IIIv: - return FailureMechanismSectionAssemblyCategoryGroup.IIIv; - case FailureMechanismSectionCategoryGroup.IVv: - return FailureMechanismSectionAssemblyCategoryGroup.IVv; - case FailureMechanismSectionCategoryGroup.Vv: - return FailureMechanismSectionAssemblyCategoryGroup.Vv; - case FailureMechanismSectionCategoryGroup.VIv: - return FailureMechanismSectionAssemblyCategoryGroup.VIv; - case FailureMechanismSectionCategoryGroup.VIIv: - return FailureMechanismSectionAssemblyCategoryGroup.VIIv; - case FailureMechanismSectionCategoryGroup.None: - return FailureMechanismSectionAssemblyCategoryGroup.None; - default: - throw new NotSupportedException(); + new FailureMechanismSectionAssemblyCategory(random.NextDouble(0.0, 0.5), + random.NextDouble(0.6, 1.0), + FailureMechanismSectionAssemblyCategoryGroup.IIv) + }; + + using (new AssemblyToolKernelFactoryConfig()) + { + var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; + FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel; + kernel.FailureMechanismSectionAssemblyCategoryResult = new CalculationOutput( + new FailureMechanismSectionAssemblyCategoryResult(FailureMechanismSectionCategoryGroup.Iv, Probability.NaN)); + + var calculator = new FailureMechanismSectionAssemblyCalculator(factory); + + // Call + FailureMechanismSectionAssembly assembly = calculator.AssembleTailorMadeAssessment(TailorMadeAssessmentProbabilityCalculationResultType.Probability, + probability, + categories); + + // Assert + AssertCalculatorOutput(kernel.FailureMechanismSectionAssemblyCategoryResult, assembly); } } + [Test] + public void AssembleTailorMadeAssessment_KernelWithInvalidOutput_ThrowFailureMechanismSectionAssemblyCalculatorException() + { + // Setup + var random = new Random(39); + double probability = random.NextDouble(); + var categories = new[] + { + new FailureMechanismSectionAssemblyCategory(random.NextDouble(0.0, 0.5), + random.NextDouble(0.6, 1.0), + FailureMechanismSectionAssemblyCategoryGroup.IIv) + }; + + using (new AssemblyToolKernelFactoryConfig()) + { + var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; + FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel; + kernel.FailureMechanismSectionAssemblyCategoryResult = new CalculationOutput( + new FailureMechanismSectionAssemblyCategoryResult((FailureMechanismSectionCategoryGroup) 99, Probability.NaN)); + + var calculator = new FailureMechanismSectionAssemblyCalculator(factory); + + // Call + TestDelegate test = () => calculator.AssembleTailorMadeAssessment(TailorMadeAssessmentProbabilityCalculationResultType.Probability, + probability, + categories); + + // Assert + var exception = Assert.Throws(test); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + [Test] + public void AssembleTailorMadeAssessment_KernelThrowsException_ThrowFailureMechanismSectionAssemblyCalculatorException() + { + // Setup + var random = new Random(39); + double probability = random.NextDouble(); + var categories = new[] + { + new FailureMechanismSectionAssemblyCategory(random.NextDouble(0.0, 0.5), + random.NextDouble(0.6, 1.0), + FailureMechanismSectionAssemblyCategoryGroup.IIv) + }; + + using (new AssemblyToolKernelFactoryConfig()) + { + var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; + FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel; + kernel.ThrowExceptionOnCalculate = true; + + var calculator = new FailureMechanismSectionAssemblyCalculator(factory); + + // Call + TestDelegate test = () => calculator.AssembleTailorMadeAssessment(TailorMadeAssessmentProbabilityCalculationResultType.Probability, + probability, + categories); + + // Assert + var exception = Assert.Throws(test); + Exception innerException = exception.InnerException; + Assert.IsNotNull(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + #endregion + #region Simple Assessment [Test] Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs =================================================================== diff -u -rcb946a26fea9d49d3aa3be7b32df6479b41fe244 -r1a7e949a3a94f976dd41a7a568701a7674685427 --- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs (.../FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs) (revision cb946a26fea9d49d3aa3be7b32df6479b41fe244) +++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Creators/FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs (.../FailureMechanismSectionAssemblyCalculatorInputCreatorTest.cs) (revision 1a7e949a3a94f976dd41a7a568701a7674685427) @@ -36,6 +36,8 @@ [TestFixture] public class FailureMechanismSectionAssemblyCalculatorInputCreatorTest { + #region Simple Assessment + [Test] public void CreateSimpleCalculationResult_WithInvalidEnumInput_ThrowInvalidEnumArgumentException() { @@ -88,6 +90,10 @@ Assert.AreEqual(expectedResult, result); } + #endregion + + #region Detailed Assessment + [Test] public void CreateDetailedCalculationInputFromProbability_WithInvalidEnumInput_ThrowInvalidEnumArgumentException() { @@ -132,7 +138,7 @@ [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Vv, FailureMechanismSectionCategoryGroup.Vv)] [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIv, FailureMechanismSectionCategoryGroup.VIv)] [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIIv, FailureMechanismSectionCategoryGroup.VIIv)] - public void CreateDetailedCalculationInputFromProbability_ValidData_ReturnSimpleCalculationResult( + public void CreateDetailedCalculationInputFromProbability_ValidData_ReturnDetailedCalculationInputFromProbabilityWithLengthEffect( FailureMechanismSectionAssemblyCategoryGroup originalResult, FailureMechanismSectionCategoryGroup expectedResult) { @@ -211,7 +217,7 @@ [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Vv, FailureMechanismSectionCategoryGroup.Vv)] [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIv, FailureMechanismSectionCategoryGroup.VIv)] [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIIv, FailureMechanismSectionCategoryGroup.VIIv)] - public void CreateDetailedCalculationInputFromProbabilityWithLengthEffect_ValidData_ReturnSimpleCalculationResult( + public void CreateDetailedCalculationInputFromProbabilityWithLengthEffect_ValidData_ReturnDetailedCalculationInputFromProbabilityWithLengthEffect( FailureMechanismSectionAssemblyCategoryGroup originalResult, FailureMechanismSectionCategoryGroup expectedResult) { @@ -244,6 +250,10 @@ Assert.AreEqual(upperBoundary, actualCategory.UpperBoundary); } + #endregion + + #region Failure Mechanism Section Assembly + [Test] public void CreateFailureMechanismSectionAssemblyCategoryResult_AssemblyNull_ThrowsArgumentNullException() { @@ -327,5 +337,170 @@ const string expectedMessage = "The value of argument 'category' (99) is invalid for Enum type 'FailureMechanismSectionAssemblyCategoryGroup'."; TestHelper.AssertThrowsArgumentExceptionAndTestMessage(test, expectedMessage); } + + #endregion + + #region Tailor Made Assessment + + [Test] + public void CreateTailorMadeCalculationInputFromProbability_CategoriesNull_ThrowArgumentNullException() + { + // Setup + var random = new Random(39); + + // Call + TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbability( + random.NextEnumValue(), + random.NextDouble(), + null); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("categories", exception.ParamName); + } + + [Test] + public void CreateTailorMadeCalculationInputFromProbability_WithInvalidResultEnumInput_ThrowInvalidEnumArgumentException() + { + // Call + TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbability( + (TailorMadeAssessmentProbabilityCalculationResultType) 99, + new Random(39).NextDouble(), + Enumerable.Empty()); + + // Assert + const string expectedMessage = "The value of argument 'tailorMadeAssessmentResult' (99) is invalid for Enum type 'TailorMadeAssessmentProbabilityCalculationResultType'."; + TestHelper.AssertThrowsArgumentExceptionAndTestMessage(test, expectedMessage); + } + + [Test] + public void CreateTailorMadeCalculationInputFromProbability_WithInvalidCategoryEnumInput_ThrowInvalidEnumArgumentException() + { + // Setup + var random = new Random(39); + + // Call + TestDelegate test = () => FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbability( + random.NextEnumValue(), + random.NextDouble(), + new[] + { + new FailureMechanismSectionAssemblyCategory(random.NextDouble(), + random.NextDouble(), + (FailureMechanismSectionAssemblyCategoryGroup) 99) + }); + + // Assert + const string expectedMessage = "The value of argument 'category' (99) is invalid for Enum type 'FailureMechanismSectionAssemblyCategoryGroup'."; + TestHelper.AssertThrowsArgumentExceptionAndTestMessage(test, expectedMessage); + } + + [Test] + [TestCase(FailureMechanismSectionAssemblyCategoryGroup.NotApplicable, FailureMechanismCategoryGroup.NotApplicable)] + [TestCase(FailureMechanismSectionAssemblyCategoryGroup.None, FailureMechanismSectionCategoryGroup.None)] + [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Iv, FailureMechanismSectionCategoryGroup.Iv)] + [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IIv, FailureMechanismSectionCategoryGroup.IIv)] + [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IIIv, FailureMechanismSectionCategoryGroup.IIIv)] + [TestCase(FailureMechanismSectionAssemblyCategoryGroup.IVv, FailureMechanismSectionCategoryGroup.IVv)] + [TestCase(FailureMechanismSectionAssemblyCategoryGroup.Vv, FailureMechanismSectionCategoryGroup.Vv)] + [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIv, FailureMechanismSectionCategoryGroup.VIv)] + [TestCase(FailureMechanismSectionAssemblyCategoryGroup.VIIv, FailureMechanismSectionCategoryGroup.VIIv)] + public void CreateTailorMadeCalculationInputFromProbability_ValidData_ReturnTailorMadeCalculationInputFromProbabilityWithCorrectCategories( + FailureMechanismSectionAssemblyCategoryGroup originalResult, + FailureMechanismSectionCategoryGroup expectedResult) + { + // Setup + var random = new Random(39); + double probability = random.NextDouble(); + double lowerBoundary = random.NextDouble(0.0, 0.5); + double upperBoundary = random.NextDouble(0.6, 1.0); + + // Call + TailorMadeCalculationInputFromProbability result = + FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbability( + random.NextEnumValue(), + probability, + new[] + { + new FailureMechanismSectionAssemblyCategory(lowerBoundary, + upperBoundary, + originalResult) + }); + + // Assert + FailureMechanismSectionCategory actualCategory = result.Categories.Single(); + Assert.AreEqual(expectedResult, actualCategory.CategoryGroup); + Assert.AreEqual(lowerBoundary, actualCategory.LowerBoundary); + Assert.AreEqual(upperBoundary, actualCategory.UpperBoundary); + } + + [Test] + [TestCase(TailorMadeAssessmentProbabilityCalculationResultType.None, TailorMadeProbabilityCalculationResultGroup.None)] + [TestCase(TailorMadeAssessmentProbabilityCalculationResultType.ProbabilityNegligible, TailorMadeProbabilityCalculationResultGroup.FV)] + [TestCase(TailorMadeAssessmentProbabilityCalculationResultType.NotAssessed, TailorMadeProbabilityCalculationResultGroup.NGO)] + public void CreateTailorMadeCalculationInputFromProbability_ValidDataNotProbability_ReturnTailorMadeCalculationInputFromProbability( + TailorMadeAssessmentProbabilityCalculationResultType originalResult, + TailorMadeProbabilityCalculationResultGroup expectedResult) + { + // Setup + var random = new Random(39); + double probability = random.NextDouble(); + double lowerBoundary = random.NextDouble(0.0, 0.5); + double upperBoundary = random.NextDouble(0.6, 1.0); + const FailureMechanismSectionAssemblyCategoryGroup categoryGroup = FailureMechanismSectionAssemblyCategoryGroup.IIv; + + // Call + TailorMadeCalculationInputFromProbability input = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbability( + originalResult, + probability, + new[] + { + new FailureMechanismSectionAssemblyCategory(lowerBoundary, + upperBoundary, + categoryGroup) + }); + + // Assert + Assert.AreEqual(expectedResult, input.Result.CalculationResultGroup); + Assert.AreEqual(0.0, input.Result.Probability); + + FailureMechanismSectionCategory actualCategory = input.Categories.Single(); + Assert.AreEqual(FailureMechanismSectionCategoryGroup.IIv, actualCategory.CategoryGroup); + Assert.AreEqual(lowerBoundary, actualCategory.LowerBoundary); + Assert.AreEqual(upperBoundary, actualCategory.UpperBoundary); + } + + [Test] + public void CreateTailorMadeCalculationInputFromProbability_ValidDataProbability_ReturnTailorMadeCalculationInputFromProbability() + { + // Setup + var random = new Random(39); + double probability = random.NextDouble(); + double lowerBoundary = random.NextDouble(0.0, 0.5); + double upperBoundary = random.NextDouble(0.6, 1.0); + const FailureMechanismSectionAssemblyCategoryGroup categoryGroup = FailureMechanismSectionAssemblyCategoryGroup.IIv; + + // Call + TailorMadeCalculationInputFromProbability input = FailureMechanismSectionAssemblyCalculatorInputCreator.CreateTailorMadeCalculationInputFromProbability( + TailorMadeAssessmentProbabilityCalculationResultType.Probability, + probability, + new[] + { + new FailureMechanismSectionAssemblyCategory(lowerBoundary, + upperBoundary, + categoryGroup) + }); + + // Assert + Assert.AreEqual(TailorMadeProbabilityCalculationResultGroup.Probability, input.Result.CalculationResultGroup); + Assert.AreEqual(probability, input.Result.Probability); + + FailureMechanismSectionCategory actualCategory = input.Categories.Single(); + Assert.AreEqual(FailureMechanismSectionCategoryGroup.IIv, actualCategory.CategoryGroup); + Assert.AreEqual(lowerBoundary, actualCategory.LowerBoundary); + Assert.AreEqual(upperBoundary, actualCategory.UpperBoundary); + } + + #endregion } } \ No newline at end of file Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStubTest.cs =================================================================== diff -u -r712c1aad8e5486980f259491130e4ae07ea48149 -r1a7e949a3a94f976dd41a7a568701a7674685427 --- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStubTest.cs (.../FailureMechanismSectionAssemblyCalculatorStubTest.cs) (revision 712c1aad8e5486980f259491130e4ae07ea48149) +++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStubTest.cs (.../FailureMechanismSectionAssemblyCalculatorStubTest.cs) (revision 1a7e949a3a94f976dd41a7a568701a7674685427) @@ -54,7 +54,7 @@ Assert.IsNull(calculator.TailorMadeAssessmentCategoriesInput); Assert.AreEqual(0.0, calculator.TailorMadeAssessmentProbabilityInput); - Assert.AreEqual((TailorMadeAssessmentProbabilityAndDetailedCalculationResultType) 0, calculator.TailorMadeProbabilityAndDetailedCalculationResult); + Assert.AreEqual((TailorMadeAssessmentProbabilityAndDetailedCalculationResultType) 0, calculator.TailorMadeAssessmentProbabilityAndDetailedCalculationResult); Assert.IsNull(calculator.TailorMadeAssessmentAssemblyOutput); Assert.IsNull(calculator.CombinedSimpleAssemblyInput); @@ -307,7 +307,7 @@ #region Tailor Made Assessment [Test] - public void AssembleTailorMadeAssessment_ThrowExceptionOnCalculateFalse_ReturnOutput() + public void AssembleTailorMadeAssessmentWithProbabilityAndDetailedCalculationResult_ThrowExceptionOnCalculateFalse_ReturnOutput() { // Setup var random = new Random(39); @@ -330,7 +330,7 @@ } [Test] - public void AssembleTailorMadeAssessment_ThrowExceptionOnCalculateFalse_SetsInput() + public void AssembleTailorMadeAssessmentWithProbabilityAndDetailedCalculationResult_ThrowExceptionOnCalculateFalse_SetsInput() { // Setup var random = new Random(39); @@ -344,13 +344,13 @@ calculator.AssembleTailorMadeAssessment(tailorMadeAssessmentResult, probability, categoryInput); // Assert - Assert.AreEqual(tailorMadeAssessmentResult, calculator.TailorMadeProbabilityAndDetailedCalculationResult); + Assert.AreEqual(tailorMadeAssessmentResult, calculator.TailorMadeAssessmentProbabilityAndDetailedCalculationResult); Assert.AreEqual(probability, calculator.TailorMadeAssessmentProbabilityInput); Assert.AreSame(categoryInput, calculator.TailorMadeAssessmentCategoriesInput); } [Test] - public void AssembleTailorMadeAssessment_ThrowExceptionOnCalculateTrue_ThrowsFailureMechanismSectionAssemblyCalculatorException() + public void AssembleTailorMadeAssessmentWithProbabilityAndDetailedCalculationResult_ThrowExceptionOnCalculateTrue_ThrowsFailureMechanismSectionAssemblyCalculatorException() { // Setup var random = new Random(39); @@ -376,6 +376,76 @@ Assert.IsNotNull(exception.InnerException); } + [Test] + public void AssembleTailorMadeAssessmentWithProbabilityCalculationResult_ThrowExceptionOnCalculateFalse_ReturnOutput() + { + // Setup + var random = new Random(39); + var calculator = new FailureMechanismSectionAssemblyCalculatorStub(); + + // Call + FailureMechanismSectionAssembly assembly = calculator.AssembleTailorMadeAssessment( + random.NextEnumValue(), + random.NextDouble(), + new[] + { + new FailureMechanismSectionAssemblyCategory(random.NextRoundedDouble(0.0, 0.5), + random.NextRoundedDouble(0.6, 1.0), + random.NextEnumValue()) + }); + + // Assert + Assert.AreEqual(1.0, assembly.Probability); + Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.VIv, assembly.Group); + } + + [Test] + public void AssembleTailorMadeAssessmentWithProbabilityCalculationResult_ThrowExceptionOnCalculateFalse_SetsInput() + { + // Setup + var random = new Random(39); + double probability = random.NextDouble(); + var tailorMadeAssessmentResult = random.NextEnumValue(); + + IEnumerable categoryInput = Enumerable.Empty(); + var calculator = new FailureMechanismSectionAssemblyCalculatorStub(); + + // Call + calculator.AssembleTailorMadeAssessment(tailorMadeAssessmentResult, probability, categoryInput); + + // Assert + Assert.AreEqual(tailorMadeAssessmentResult, calculator.TailorMadeAssessmentProbabilityCalculationResultType); + Assert.AreEqual(probability, calculator.TailorMadeAssessmentProbabilityInput); + Assert.AreSame(categoryInput, calculator.TailorMadeAssessmentCategoriesInput); + } + + [Test] + public void AssembleTailorMadeAssessmentWithProbabilityCalculationResult_ThrowExceptionOnCalculateTrue_ThrowsFailureMechanismSectionAssemblyCalculatorException() + { + // Setup + var random = new Random(39); + var calculator = new FailureMechanismSectionAssemblyCalculatorStub + { + ThrowExceptionOnCalculate = true + }; + + // Call + TestDelegate test = () => calculator.AssembleTailorMadeAssessment( + random.NextEnumValue(), + random.NextDouble(), + new[] + { + new FailureMechanismSectionAssemblyCategory(random.NextRoundedDouble(0.0, 0.5), + random.NextRoundedDouble(0.6, 1.0), + random.NextEnumValue()) + }); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("Message", exception.Message); + Assert.IsNotNull(exception.InnerException); + } + #endregion #region Combined Assembly Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStub.cs =================================================================== diff -u -r712c1aad8e5486980f259491130e4ae07ea48149 -r1a7e949a3a94f976dd41a7a568701a7674685427 --- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStub.cs (.../FailureMechanismSectionAssemblyCalculatorStub.cs) (revision 712c1aad8e5486980f259491130e4ae07ea48149) +++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStub.cs (.../FailureMechanismSectionAssemblyCalculatorStub.cs) (revision 1a7e949a3a94f976dd41a7a568701a7674685427) @@ -80,9 +80,14 @@ /// /// Gets the result type of the tailor made assessment calculation with probability or detailed calculation result. /// - public TailorMadeAssessmentProbabilityAndDetailedCalculationResultType TailorMadeProbabilityAndDetailedCalculationResult { get; private set; } + public TailorMadeAssessmentProbabilityAndDetailedCalculationResultType TailorMadeAssessmentProbabilityAndDetailedCalculationResult { get; private set; } /// + /// Gets the result type of the tailor made assessment calculation with a probability calculation. + /// + public TailorMadeAssessmentProbabilityCalculationResultType TailorMadeAssessmentProbabilityCalculationResultType { get; private set; } + + /// /// Gets the probability input of the tailor made assessment calculation. /// public double TailorMadeAssessmentProbabilityInput { get; private set; } @@ -207,13 +212,27 @@ throw new FailureMechanismSectionAssemblyCalculatorException("Message", new Exception()); } - TailorMadeProbabilityAndDetailedCalculationResult = tailorMadeAssessmentResult; + TailorMadeAssessmentProbabilityAndDetailedCalculationResult = tailorMadeAssessmentResult; TailorMadeAssessmentProbabilityInput = probability; TailorMadeAssessmentCategoriesInput = categories; return TailorMadeAssessmentAssemblyOutput = new FailureMechanismSectionAssembly(1, FailureMechanismSectionAssemblyCategoryGroup.VIv); } + public FailureMechanismSectionAssembly AssembleTailorMadeAssessment(TailorMadeAssessmentProbabilityCalculationResultType tailorMadeAssessmentResult, double probability, IEnumerable categories) + { + if (ThrowExceptionOnCalculate) + { + throw new FailureMechanismSectionAssemblyCalculatorException("Message", new Exception()); + } + + TailorMadeAssessmentProbabilityCalculationResultType = tailorMadeAssessmentResult; + TailorMadeAssessmentProbabilityInput = probability; + TailorMadeAssessmentCategoriesInput = categories; + + return TailorMadeAssessmentAssemblyOutput = new FailureMechanismSectionAssembly(1, FailureMechanismSectionAssemblyCategoryGroup.VIv); + } + public FailureMechanismSectionAssembly AssembleCombined(FailureMechanismSectionAssembly simpleAssembly, FailureMechanismSectionAssembly detailedAssembly, FailureMechanismSectionAssembly tailorMadeAssembly) Index: Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/MacroStabilityOutwardsFailureMechanismSectionResultAssemblyFactoryTest.cs =================================================================== diff -u -r712c1aad8e5486980f259491130e4ae07ea48149 -r1a7e949a3a94f976dd41a7a568701a7674685427 --- Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/MacroStabilityOutwardsFailureMechanismSectionResultAssemblyFactoryTest.cs (.../MacroStabilityOutwardsFailureMechanismSectionResultAssemblyFactoryTest.cs) (revision 712c1aad8e5486980f259491130e4ae07ea48149) +++ Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/MacroStabilityOutwardsFailureMechanismSectionResultAssemblyFactoryTest.cs (.../MacroStabilityOutwardsFailureMechanismSectionResultAssemblyFactoryTest.cs) (revision 1a7e949a3a94f976dd41a7a568701a7674685427) @@ -370,7 +370,7 @@ // Assert Assert.AreEqual(sectionResult.TailorMadeAssessmentProbability, calculator.TailorMadeAssessmentProbabilityInput); - Assert.AreEqual(sectionResult.TailorMadeAssessmentResult, calculator.TailorMadeProbabilityAndDetailedCalculationResult); + Assert.AreEqual(sectionResult.TailorMadeAssessmentResult, calculator.TailorMadeAssessmentProbabilityAndDetailedCalculationResult); Assert.AreEqual(assessmentSection.FailureMechanismContribution.SignalingNorm, categoryCalculator.SignalingNorm); Assert.AreEqual(assessmentSection.FailureMechanismContribution.LowerLimitNorm, categoryCalculator.LowerLimitNorm);