Index: Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismSectionAssemblyCalculator.cs =================================================================== diff -u -r6f8dc0c6b0b1018692002207d107695be438c2b1 -r99c226e8b1620ee7f11742df09bb892c96162bdd --- Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismSectionAssemblyCalculator.cs (.../FailureMechanismSectionAssemblyCalculator.cs) (revision 6f8dc0c6b0b1018692002207d107695be438c2b1) +++ Riskeer/AssemblyTool/src/Riskeer.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismSectionAssemblyCalculator.cs (.../FailureMechanismSectionAssemblyCalculator.cs) (revision 99c226e8b1620ee7f11742df09bb892c96162bdd) @@ -29,6 +29,7 @@ using Riskeer.AssemblyTool.Data; using Riskeer.AssemblyTool.KernelWrapper.Creators; using Riskeer.AssemblyTool.KernelWrapper.Kernels; +using Riskeer.Common.Primitives; using KernelFailureMechanismSectionAssemblyResult = Assembly.Kernel.Model.FailureMechanismSections.FailureMechanismSectionAssemblyResult; using RiskeerFailureMechanismSectionAssemblyResult = Riskeer.AssemblyTool.Data.FailureMechanismSectionAssemblyResult; @@ -65,20 +66,32 @@ try { - ICategoryLimitsCalculator assemblyGroupsKernel = factory.CreateAssemblyGroupsKernel(); - CategoriesList interpretationCategories = assemblyGroupsKernel.CalculateInterpretationCategoryLimitsBoi01( - new AssessmentSection(AssemblyCalculatorInputCreator.CreateProbability(input.SignalFloodingProbability), - AssemblyCalculatorInputCreator.CreateProbability(input.MaximumAllowableFloodingProbability))); - + Probability sectionProbability; + EInterpretationCategory interpretationCategory; IAssessmentResultsTranslator kernel = factory.CreateFailureMechanismSectionAssemblyKernel(); - KernelFailureMechanismSectionAssemblyResult output = kernel.TranslateAssessmentResultAggregatedMethod( - GetInitialMechanismProbabilitySpecification(input), - AssemblyCalculatorInputCreator.CreateProbability(input.InitialSectionProbability), - FailureMechanismSectionAssemblyCalculatorInputCreator.ConvertFailureMechanismSectionResultFurtherAnalysisType(input.FurtherAnalysisType), - AssemblyCalculatorInputCreator.CreateProbability(input.RefinedSectionProbability), - interpretationCategories); - - return FailureMechanismSectionAssemblyResultCreator.Create(output); + + if (IsProbabilityDefined(input)) + { + ICategoryLimitsCalculator assemblyGroupsKernel = factory.CreateAssemblyGroupsKernel(); + CategoriesList interpretationCategories = assemblyGroupsKernel.CalculateInterpretationCategoryLimitsBoi01( + new AssessmentSection(AssemblyCalculatorInputCreator.CreateProbability(input.SignalFloodingProbability), + AssemblyCalculatorInputCreator.CreateProbability(input.MaximumAllowableFloodingProbability))); + + sectionProbability = kernel.DetermineRepresentativeProbabilityBoi0A1( + input.FurtherAnalysisType != FailureMechanismSectionResultFurtherAnalysisType.NotNecessary, + AssemblyCalculatorInputCreator.CreateProbability(input.InitialSectionProbability), + AssemblyCalculatorInputCreator.CreateProbability(input.RefinedSectionProbability)); + interpretationCategory = kernel.DetermineInterpretationCategoryFromFailureMechanismSectionProbabilityBoi0B1( + sectionProbability, interpretationCategories); + } + else + { + interpretationCategory = kernel.DetermineInterpretationCategoryWithoutProbabilityEstimationBoi0C1(GetAnalysisStatus(input)); + sectionProbability = kernel.TranslateInterpretationCategoryToProbabilityBoi0C2(interpretationCategory); + } + + return new RiskeerFailureMechanismSectionAssemblyResult( + sectionProbability, sectionProbability, 1.0, FailureMechanismSectionAssemblyGroupConverter.ConvertTo(interpretationCategory)); } catch (AssemblyException e) { @@ -90,6 +103,37 @@ } } + private static EAnalysisState GetAnalysisStatus(FailureMechanismSectionAssemblyInput input) + { + if (!input.IsRelevant) + { + return EAnalysisState.NotRelevant; + } + + if (input.FurtherAnalysisType == FailureMechanismSectionResultFurtherAnalysisType.NotNecessary) + { + return !input.HasProbabilitySpecified + ? EAnalysisState.NoProbabilityEstimationNecessary + : EAnalysisState.ProbabilityEstimated; + } + + return input.FurtherAnalysisType == FailureMechanismSectionResultFurtherAnalysisType.Necessary + ? EAnalysisState.ProbabilityEstimationNecessary + : EAnalysisState.ProbabilityEstimated; + } + + private static bool IsProbabilityDefined(FailureMechanismSectionAssemblyInput input) + { + if (!input.IsRelevant) + { + return false; + } + + return input.FurtherAnalysisType == FailureMechanismSectionResultFurtherAnalysisType.NotNecessary + && !input.HasProbabilitySpecified + || input.FurtherAnalysisType == FailureMechanismSectionResultFurtherAnalysisType.Executed; + } + public RiskeerFailureMechanismSectionAssemblyResult AssembleFailureMechanismSection(FailureMechanismSectionWithProfileProbabilityAssemblyInput input) { if (input == null) Index: Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorTest.cs =================================================================== diff -u -r2d4b9f25d7f199a6335cb646634064aa35d10a8c -r99c226e8b1620ee7f11742df09bb892c96162bdd --- Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorTest.cs (.../FailureMechanismSectionAssemblyCalculatorTest.cs) (revision 2d4b9f25d7f199a6335cb646634064aa35d10a8c) +++ Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorTest.cs (.../FailureMechanismSectionAssemblyCalculatorTest.cs) (revision 99c226e8b1620ee7f11742df09bb892c96162bdd) @@ -20,6 +20,7 @@ // All rights reserved. using System; +using System.Collections.Generic; using System.ComponentModel; using Assembly.Kernel.Exceptions; using Assembly.Kernel.Model; @@ -92,52 +93,39 @@ } [Test] - public void AssembleFailureMechanismSection_InvalidInput_ThrowsFailureMechanismSectionAssemblyCalculatorException() + [TestCaseSource(nameof(GetInputWithUndefinedProbability))] + public void AssembleFailureMechanismSection_WithValidInputAndNoProbabilityDefined_InputCorrectlySentToKernel( + FailureMechanismSectionAssemblyInput input, EAnalysisState expectedAnalysisState) { // Setup - var random = new Random(21); - var input = new FailureMechanismSectionAssemblyInput( - 0.01, 0.001, random.NextBoolean(), random.NextBoolean(), random.NextDouble(), - (FailureMechanismSectionResultFurtherAnalysisType) 99, random.NextDouble()); - using (new AssemblyToolKernelFactoryConfig()) { var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; FailureMechanismSectionAssemblyKernelStub failureMechanismSectionAssemblyKernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel; + var random = new Random(21); + var categoryOutput = random.NextEnumValue(); + failureMechanismSectionAssemblyKernel.CategoryOutput = categoryOutput; + failureMechanismSectionAssemblyKernel.SectionProbability = new Probability(random.NextDouble()); + var calculator = new FailureMechanismSectionAssemblyCalculator(factory); // Call - void Call() => calculator.AssembleFailureMechanismSection(input); + calculator.AssembleFailureMechanismSection(input); // Assert - var exception = Assert.Throws(Call); - Assert.IsInstanceOf(exception.InnerException); - Assert.AreEqual(AssemblyErrorMessageCreator.CreateGenericErrorMessage(), exception.Message); - - Assert.IsFalse(failureMechanismSectionAssemblyKernel.Calculated); + Assert.AreEqual(expectedAnalysisState, failureMechanismSectionAssemblyKernel.AnalysisState); + Assert.AreEqual(categoryOutput, failureMechanismSectionAssemblyKernel.CategoryInput); } } [Test] - [TestCase(false, true, ESectionInitialMechanismProbabilitySpecification.NotRelevant)] - [TestCase(false, false, ESectionInitialMechanismProbabilitySpecification.NotRelevant)] - [TestCase(true, true, ESectionInitialMechanismProbabilitySpecification.RelevantWithProbabilitySpecification)] - [TestCase(true, false, ESectionInitialMechanismProbabilitySpecification.RelevantNoProbabilitySpecification)] - public void AssembleFailureMechanismSection_WithValidInput_InputCorrectlySentToKernel( - bool isRelevant, bool hasProbabilitySpecified, - ESectionInitialMechanismProbabilitySpecification expectedInitialMechanismProbabilitySpecification) + [TestCaseSource(nameof(GetInputWithDefinedProbability))] + public void AssembleFailureMechanismSection_WithValidInputAndProbabilityDefined_InputCorrectlySentToKernel( + FailureMechanismSectionAssemblyInput input) { // Setup - const double signalFloodingProbability = 0.0001; - const double maximumAllowableFloodingProbability = 0.001; - var random = new Random(21); - var input = new FailureMechanismSectionAssemblyInput(maximumAllowableFloodingProbability, signalFloodingProbability, - isRelevant, hasProbabilitySpecified, - random.NextDouble(), - random.NextEnumValue(), - random.NextDouble()); using (new AssemblyToolKernelFactoryConfig()) { var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; @@ -146,8 +134,9 @@ categoryLimitsKernel.InterpretationCategoryLimits = interpretationCategories; FailureMechanismSectionAssemblyKernelStub failureMechanismSectionAssemblyKernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel; - failureMechanismSectionAssemblyKernel.FailureMechanismSectionAssemblyResult = new KernelFailureMechanismSectionAssemblyResult( - new Probability(random.NextDouble(0.0, 0.01)), EInterpretationCategory.Zero); + var sectionProbability = new Probability(random.NextDouble(0.0, 0.01)); + failureMechanismSectionAssemblyKernel.SectionProbability = sectionProbability; + failureMechanismSectionAssemblyKernel.CategoryOutput = EInterpretationCategory.Zero; var calculator = new FailureMechanismSectionAssemblyCalculator(factory); @@ -156,43 +145,72 @@ // Assert AssessmentSection assessmentSection = categoryLimitsKernel.AssessmentSection; - ProbabilityAssert.AreEqual(maximumAllowableFloodingProbability, assessmentSection.MaximumAllowableFloodingProbability); - ProbabilityAssert.AreEqual(signalFloodingProbability, assessmentSection.SignalFloodingProbability); + ProbabilityAssert.AreEqual(input.MaximumAllowableFloodingProbability, assessmentSection.MaximumAllowableFloodingProbability); + ProbabilityAssert.AreEqual(input.SignalFloodingProbability, assessmentSection.SignalFloodingProbability); Assert.AreSame(interpretationCategories, failureMechanismSectionAssemblyKernel.Categories); - Assert.AreEqual(expectedInitialMechanismProbabilitySpecification, failureMechanismSectionAssemblyKernel.InitialMechanismProbabilitySpecification); + Assert.AreEqual(input.FurtherAnalysisType != FailureMechanismSectionResultFurtherAnalysisType.NotNecessary, failureMechanismSectionAssemblyKernel.RefinementNecessary); Assert.AreEqual(input.InitialSectionProbability, failureMechanismSectionAssemblyKernel.ProbabilityInitialMechanismSection); - Assert.AreEqual(FailureMechanismSectionAssemblyCalculatorInputCreator.ConvertFailureMechanismSectionResultFurtherAnalysisType(input.FurtherAnalysisType), - failureMechanismSectionAssemblyKernel.RefinementStatus); Assert.AreEqual(input.RefinedSectionProbability, failureMechanismSectionAssemblyKernel.RefinedProbabilitySection); + Assert.AreEqual(sectionProbability, failureMechanismSectionAssemblyKernel.SectionProbabilityInput); } } [Test] - public void AssembleFailureMechanismSection_KernelWithCompleteOutput_ReturnsExpectedFailureMechanismSectionAssembly() + public void AssembleFailureMechanismSection_InputWithProbabilityUndefinedAndKernelWithCompleteOutput_ReturnsExpectedFailureMechanismSectionAssembly() { // Setup var random = new Random(21); - FailureMechanismSectionAssemblyInput input = CreateFailureMechanismSectionAssemblyInput(); + var input = new FailureMechanismSectionAssemblyInput( + 0.001, 0.0001, false, random.NextBoolean(), double.NaN, + random.NextEnumValue(), double.NaN); + using (new AssemblyToolKernelFactoryConfig()) { var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; + + FailureMechanismSectionAssemblyKernelStub failureMechanismSectionAssemblyKernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel; + var categoryOutput = random.NextEnumValue(); + var sectionProbability = new Probability(random.NextDouble(0.0, 0.01)); + failureMechanismSectionAssemblyKernel.CategoryOutput = categoryOutput; + failureMechanismSectionAssemblyKernel.SectionProbability = sectionProbability; + + var calculator = new FailureMechanismSectionAssemblyCalculator(factory); + + // Call + RiskeerFailureMechanismSectionAssemblyResult result = calculator.AssembleFailureMechanismSection(input); + + // Assert + Assert.IsTrue(failureMechanismSectionAssemblyKernel.Calculated); + + Assert.AreEqual(sectionProbability, result.ProfileProbability); + Assert.AreEqual(sectionProbability, result.SectionProbability); + Assert.AreEqual(1.0, result.N); + Assert.AreEqual(FailureMechanismSectionAssemblyGroupConverter.ConvertTo(categoryOutput), + result.FailureMechanismSectionAssemblyGroup); + } + } + + [Test] + public void AssembleFailureMechanismSection_InputWithProbabilityDefinedKernelWithCompleteOutput_ReturnsExpectedFailureMechanismSectionAssembly() + { + // Setup + var random = new Random(21); + var input = new FailureMechanismSectionAssemblyInput( + 0.001, 0.0001, true, true, random.NextDouble(), + FailureMechanismSectionResultFurtherAnalysisType.Executed, random.NextDouble()); + + using (new AssemblyToolKernelFactoryConfig()) + { + var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; AssemblyCategoryLimitsKernelStub categoryLimitsKernel = factory.LastCreatedAssemblyCategoryLimitsKernel; categoryLimitsKernel.InterpretationCategoryLimits = CreateInterpretationCategories(); FailureMechanismSectionAssemblyKernelStub failureMechanismSectionAssemblyKernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel; - var kernelResult = new KernelFailureMechanismSectionAssemblyResult(new Probability(random.NextDouble()), - random.NextEnumValue(new[] - { - EInterpretationCategory.III, - EInterpretationCategory.II, - EInterpretationCategory.I, - EInterpretationCategory.Zero, - EInterpretationCategory.IMin, - EInterpretationCategory.IIMin, - EInterpretationCategory.IIIMin - })); - failureMechanismSectionAssemblyKernel.FailureMechanismSectionAssemblyResult = kernelResult; + var categoryOutput = random.NextEnumValue(); + var sectionProbability = new Probability(random.NextDouble(0.0, 0.01)); + failureMechanismSectionAssemblyKernel.CategoryOutput = categoryOutput; + failureMechanismSectionAssemblyKernel.SectionProbability = sectionProbability; var calculator = new FailureMechanismSectionAssemblyCalculator(factory); @@ -203,10 +221,10 @@ Assert.IsTrue(categoryLimitsKernel.Calculated); Assert.IsTrue(failureMechanismSectionAssemblyKernel.Calculated); - Assert.AreEqual(kernelResult.ProbabilitySection, result.ProfileProbability); - Assert.AreEqual(kernelResult.ProbabilitySection, result.SectionProbability); + Assert.AreEqual(sectionProbability, result.ProfileProbability); + Assert.AreEqual(sectionProbability, result.SectionProbability); Assert.AreEqual(1.0, result.N); - Assert.AreEqual(FailureMechanismSectionAssemblyGroupConverter.ConvertTo(kernelResult.InterpretationCategory), + Assert.AreEqual(FailureMechanismSectionAssemblyGroupConverter.ConvertTo(categoryOutput), result.FailureMechanismSectionAssemblyGroup); } } @@ -220,10 +238,8 @@ using (new AssemblyToolKernelFactoryConfig()) { var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; - AssemblyCategoryLimitsKernelStub categoryLimitsKernel = factory.LastCreatedAssemblyCategoryLimitsKernel; - categoryLimitsKernel.ThrowExceptionOnCalculate = true; - FailureMechanismSectionAssemblyKernelStub failureMechanismSectionAssemblyKernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel; + failureMechanismSectionAssemblyKernel.ThrowExceptionOnCalculate = true; var calculator = new FailureMechanismSectionAssemblyCalculator(factory); @@ -248,10 +264,8 @@ using (new AssemblyToolKernelFactoryConfig()) { var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance; - AssemblyCategoryLimitsKernelStub categoryLimitsKernel = factory.LastCreatedAssemblyCategoryLimitsKernel; - categoryLimitsKernel.ThrowAssemblyExceptionOnCalculate = true; - FailureMechanismSectionAssemblyKernelStub failureMechanismSectionAssemblyKernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel; + failureMechanismSectionAssemblyKernel.ThrowAssemblyExceptionOnCalculate = true; var calculator = new FailureMechanismSectionAssemblyCalculator(factory); @@ -456,6 +470,40 @@ } } + private static IEnumerable GetInputWithUndefinedProbability() + { + const double signalFloodingProbability = 0.0001; + const double maximumAllowableFloodingProbability = 0.001; + + var random = new Random(21); + yield return new TestCaseData(new FailureMechanismSectionAssemblyInput( + maximumAllowableFloodingProbability, signalFloodingProbability, false, random.NextBoolean(), + double.NaN, random.NextEnumValue(), double.NaN), + EAnalysisState.NotRelevant); + yield return new TestCaseData(new FailureMechanismSectionAssemblyInput( + maximumAllowableFloodingProbability, signalFloodingProbability, true, true, double.NaN, + FailureMechanismSectionResultFurtherAnalysisType.NotNecessary, double.NaN), + EAnalysisState.ProbabilityEstimated); + yield return new TestCaseData(new FailureMechanismSectionAssemblyInput( + maximumAllowableFloodingProbability, signalFloodingProbability, true, random.NextBoolean(), double.NaN, + FailureMechanismSectionResultFurtherAnalysisType.Necessary, double.NaN), + EAnalysisState.ProbabilityEstimationNecessary); + } + + private static IEnumerable GetInputWithDefinedProbability() + { + const double signalFloodingProbability = 0.0001; + const double maximumAllowableFloodingProbability = 0.001; + + var random = new Random(21); + yield return new TestCaseData(new FailureMechanismSectionAssemblyInput( + maximumAllowableFloodingProbability, signalFloodingProbability, true, false, random.NextDouble(), + FailureMechanismSectionResultFurtherAnalysisType.NotNecessary, random.NextDouble())); + yield return new TestCaseData(new FailureMechanismSectionAssemblyInput( + maximumAllowableFloodingProbability, signalFloodingProbability, true, random.NextBoolean(), random.NextDouble(), + FailureMechanismSectionResultFurtherAnalysisType.Executed, random.NextDouble())); + } + private static FailureMechanismSectionAssemblyInput CreateFailureMechanismSectionAssemblyInput() { const double maximumAllowableFloodingProbability = 0.001; Index: Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/AssessmentSectionAssemblyKernelStub.cs =================================================================== diff -u -r1a4e7b7e0118b7e113922647984ee686c53e11d8 -r99c226e8b1620ee7f11742df09bb892c96162bdd --- Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/AssessmentSectionAssemblyKernelStub.cs (.../AssessmentSectionAssemblyKernelStub.cs) (revision 1a4e7b7e0118b7e113922647984ee686c53e11d8) +++ Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/AssessmentSectionAssemblyKernelStub.cs (.../AssessmentSectionAssemblyKernelStub.cs) (revision 99c226e8b1620ee7f11742df09bb892c96162bdd) @@ -21,7 +21,6 @@ using System; using System.Collections.Generic; -using System.Reflection; using Assembly.Kernel.Exceptions; using Assembly.Kernel.Interfaces; using Assembly.Kernel.Model; @@ -108,21 +107,7 @@ private void ThrowException() { - if (ThrowExceptionOnCalculate) - { - throw new Exception("Message", new Exception()); - } - - if (ThrowAssemblyExceptionOnCalculate) - { - const BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Instance; - throw (AssemblyException) Activator.CreateInstance( - typeof(AssemblyException), flags, null, new object[] - { - "entity", - EAssemblyErrors.InvalidCategoryLimits - }, null); - } + AssemblyKernelStubHelper.ThrowException(ThrowExceptionOnCalculate, ThrowAssemblyExceptionOnCalculate, EAssemblyErrors.InvalidCategoryLimits); } } } \ No newline at end of file Index: Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/CombinedFailureMechanismSectionAssemblyKernelStub.cs =================================================================== diff -u -r1a4e7b7e0118b7e113922647984ee686c53e11d8 -r99c226e8b1620ee7f11742df09bb892c96162bdd --- Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/CombinedFailureMechanismSectionAssemblyKernelStub.cs (.../CombinedFailureMechanismSectionAssemblyKernelStub.cs) (revision 1a4e7b7e0118b7e113922647984ee686c53e11d8) +++ Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/CombinedFailureMechanismSectionAssemblyKernelStub.cs (.../CombinedFailureMechanismSectionAssemblyKernelStub.cs) (revision 99c226e8b1620ee7f11742df09bb892c96162bdd) @@ -21,7 +21,6 @@ using System; using System.Collections.Generic; -using System.Reflection; using Assembly.Kernel.Exceptions; using Assembly.Kernel.Interfaces; using Assembly.Kernel.Model.FailureMechanismSections; @@ -102,21 +101,7 @@ private void ThrowException() { - if (ThrowExceptionOnCalculate) - { - throw new Exception("Message", new Exception()); - } - - if (ThrowAssemblyExceptionOnCalculate) - { - const BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Instance; - throw (AssemblyException) Activator.CreateInstance( - typeof(AssemblyException), flags, null, new object[] - { - "entity", - EAssemblyErrors.EmptyResultsList - }, null); - } + AssemblyKernelStubHelper.ThrowException(ThrowExceptionOnCalculate, ThrowAssemblyExceptionOnCalculate, EAssemblyErrors.EmptyResultsList); } } } \ No newline at end of file Index: Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/FailureMechanismAssemblyKernelStub.cs =================================================================== diff -u -r1a4e7b7e0118b7e113922647984ee686c53e11d8 -r99c226e8b1620ee7f11742df09bb892c96162bdd --- Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/FailureMechanismAssemblyKernelStub.cs (.../FailureMechanismAssemblyKernelStub.cs) (revision 1a4e7b7e0118b7e113922647984ee686c53e11d8) +++ Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/FailureMechanismAssemblyKernelStub.cs (.../FailureMechanismAssemblyKernelStub.cs) (revision 99c226e8b1620ee7f11742df09bb892c96162bdd) @@ -21,7 +21,6 @@ using System; using System.Collections.Generic; -using System.Reflection; using Assembly.Kernel.Exceptions; using Assembly.Kernel.Interfaces; using Assembly.Kernel.Model; @@ -48,7 +47,7 @@ /// Gets the collection of . /// public IEnumerable FailureMechanismSectionAssemblyResults { get; private set; } - + /// /// Gets the collection of . /// @@ -106,21 +105,7 @@ private void ThrowException() { - if (ThrowExceptionOnCalculate) - { - throw new Exception("Message", new Exception()); - } - - if (ThrowAssemblyExceptionOnCalculate) - { - const BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Instance; - throw (AssemblyException) Activator.CreateInstance( - typeof(AssemblyException), flags, null, new object[] - { - "entity", - EAssemblyErrors.InvalidCategoryLimits - }, null); - } + AssemblyKernelStubHelper.ThrowException(ThrowExceptionOnCalculate, ThrowAssemblyExceptionOnCalculate, EAssemblyErrors.InvalidCategoryLimits); } } } \ No newline at end of file Index: Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/FailureMechanismSectionAssemblyKernelStub.cs =================================================================== diff -u -r199ffc94581665e31d00c698ed4c082931beed11 -r99c226e8b1620ee7f11742df09bb892c96162bdd --- Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/FailureMechanismSectionAssemblyKernelStub.cs (.../FailureMechanismSectionAssemblyKernelStub.cs) (revision 199ffc94581665e31d00c698ed4c082931beed11) +++ Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/Assembly/FailureMechanismSectionAssemblyKernelStub.cs (.../FailureMechanismSectionAssemblyKernelStub.cs) (revision 99c226e8b1620ee7f11742df09bb892c96162bdd) @@ -74,6 +74,16 @@ public CategoriesList Categories { get; private set; } /// + /// Gets the analysis state. + /// + public EAnalysisState AnalysisState { get; private set; } + + /// + /// Gets the category. + /// + public EInterpretationCategory CategoryInput { get; private set; } + + /// /// Sets an indicator whether an must be thrown while performing a calculation. /// public bool ThrowExceptionOnCalculate { private get; set; } @@ -87,12 +97,32 @@ /// Sets the assembly result of a failure mechanism section. /// public FailureMechanismSectionAssemblyResult FailureMechanismSectionAssemblyResult { private get; set; } - + /// /// Sets the assembly result with length effect of a failure mechanism section. /// public FailureMechanismSectionAssemblyResultWithLengthEffect FailureMechanismSectionAssemblyResultWithLengthEffect { private get; set; } + /// + /// Sets the section probability. + /// + public Probability SectionProbability { private get; set; } + + /// + /// Sets the category. + /// + public EInterpretationCategory CategoryOutput { private get; set; } + + /// + /// Gets whether the refinement is necessary. + /// + public bool RefinementNecessary { get; private set; } + + /// + /// Gets the section probability. + /// + public Probability SectionProbabilityInput { get; private set; } + public FailureMechanismSectionAssemblyResult TranslateAssessmentResultAggregatedMethod(ESectionInitialMechanismProbabilitySpecification relevance, Probability probabilityInitialMechanismSection, ERefinementStatus refinementStatus, @@ -113,7 +143,7 @@ return FailureMechanismSectionAssemblyResult; } - public FailureMechanismSectionAssemblyResultWithLengthEffect TranslateAssessmentResultWithLengthEffectAggregatedMethod(ESectionInitialMechanismProbabilitySpecification relevance, + public FailureMechanismSectionAssemblyResultWithLengthEffect TranslateAssessmentResultWithLengthEffectAggregatedMethod(ESectionInitialMechanismProbabilitySpecification relevance, Probability probabilityInitialMechanismProfile, Probability probabilityInitialMechanismSection, ERefinementStatus refinementStatus, @@ -139,7 +169,14 @@ public Probability DetermineRepresentativeProbabilityBoi0A1(bool refinementNecessary, Probability probabilityInitialMechanismSection, Probability refinedProbabilitySection) { - throw new NotImplementedException(); + ThrowException(); + Calculated = true; + + RefinementNecessary = refinementNecessary; + ProbabilityInitialMechanismSection = probabilityInitialMechanismSection; + RefinedProbabilitySection = refinedProbabilitySection; + + return SectionProbability; } public IProfileAndSectionProbabilities DetermineRepresentativeProbabilitiesBoi0A2(bool refinementNecessary, Probability probabilityInitialMechanismProfile, Probability probabilityInitialMechanismSection, Probability refinedProbabilityProfile, Probability refinedProbabilitySection) @@ -149,31 +186,38 @@ public EInterpretationCategory DetermineInterpretationCategoryFromFailureMechanismSectionProbabilityBoi0B1(Probability sectionProbability, CategoriesList categories) { - throw new NotImplementedException(); + ThrowException(); + Calculated = true; + + SectionProbabilityInput = sectionProbability; + Categories = categories; + + return CategoryOutput; } public EInterpretationCategory DetermineInterpretationCategoryWithoutProbabilityEstimationBoi0C1(EAnalysisState analysisState) { - throw new NotImplementedException(); + ThrowException(); + Calculated = true; + + AnalysisState = analysisState; + + return CategoryOutput; } public Probability TranslateInterpretationCategoryToProbabilityBoi0C2(EInterpretationCategory category) { - throw new NotImplementedException(); + ThrowException(); + Calculated = true; + + CategoryInput = category; + + return SectionProbability; } - + private void ThrowException() { - if (ThrowExceptionOnCalculate) - { - throw new Exception("Message", new Exception()); - } - - if (ThrowAssemblyExceptionOnCalculate) - { - - throw (AssemblyException) Activator.CreateInstance(typeof(AssemblyException), "entity", EAssemblyErrors.EmptyResultsList); - } + AssemblyKernelStubHelper.ThrowException(ThrowExceptionOnCalculate, ThrowAssemblyExceptionOnCalculate, EAssemblyErrors.EmptyResultsList); } } } \ No newline at end of file Index: Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/AssemblyKernelStubHelper.cs =================================================================== diff -u --- Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/AssemblyKernelStubHelper.cs (revision 0) +++ Riskeer/AssemblyTool/test/Riskeer.AssemblyTool.KernelWrapper.TestUtil/Kernels/AssemblyKernelStubHelper.cs (revision 99c226e8b1620ee7f11742df09bb892c96162bdd) @@ -0,0 +1,65 @@ +// 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.Reflection; +using Assembly.Kernel.Exceptions; + +namespace Riskeer.AssemblyTool.KernelWrapper.TestUtil.Kernels +{ + /// + /// Helper class that can be used in kernel stubs. + /// + public static class AssemblyKernelStubHelper + { + /// + /// Throws an exception when either + /// or is true. + /// + /// Indicator whether an + /// should be thrown. + /// Indicator whether an + /// should be thrown. + /// The error to use in the . + /// Thrown when is true. + /// Thrown when + /// is true. + public static void ThrowException(bool throwExceptionOnCalculate, bool throwAssemblyExceptionOnCalculate, + EAssemblyErrors assemblyError) + { + if (throwExceptionOnCalculate) + { + throw new Exception("Message", new Exception()); + } + + if (throwAssemblyExceptionOnCalculate) + { + const BindingFlags flags = BindingFlags.NonPublic | BindingFlags.Instance; + throw (AssemblyException) Activator.CreateInstance( + typeof(AssemblyException), flags, null, new object[] + { + "entity", + assemblyError + }, null); + } + } + } +} \ No newline at end of file