Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismSectionAssemblyCalculator.cs
===================================================================
diff -u -rc620a480d44f4099fcf02a2ef9cc1d15c586ab03 -r508157dfe8615caaf50d75a9dd5d5b8c86e3ee81
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismSectionAssemblyCalculator.cs (.../FailureMechanismSectionAssemblyCalculator.cs) (revision c620a480d44f4099fcf02a2ef9cc1d15c586ab03)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/FailureMechanismSectionAssemblyCalculator.cs (.../FailureMechanismSectionAssemblyCalculator.cs) (revision 508157dfe8615caaf50d75a9dd5d5b8c86e3ee81)
@@ -111,48 +111,15 @@
double probability,
AssemblyCategoriesInput assemblyCategoriesInput)
{
- try
- {
- IFailureMechanismSectionAssemblyCalculatorKernel kernel = factory.CreateFailureMechanismSectionAssemblyKernel();
- FmSectionAssemblyDirectResult output = kernel.TranslateAssessmentResultWbi0G3(
- new AssessmentSection(1, assemblyCategoriesInput.SignalingNorm, assemblyCategoriesInput.LowerLimitNorm),
- new FailureMechanism(assemblyCategoriesInput.N, assemblyCategoriesInput.FailureMechanismContribution),
- double.IsNaN(probability) && detailedAssessmentResult == DetailedAssessmentProbabilityOnlyResultType.Probability
- ? EAssessmentResultTypeG2.Gr
- : FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeG2(detailedAssessmentResult),
- probability);
-
- return FailureMechanismSectionAssemblyCreator.Create(output);
- }
- catch (Exception e)
- {
- throw new FailureMechanismSectionAssemblyCalculatorException(e.Message, e);
- }
+ return GetDetailedAssembly(detailedAssessmentResult, probability, assemblyCategoriesInput);
}
public FailureMechanismSectionAssembly AssembleDetailedAssessment(DetailedAssessmentProbabilityOnlyResultType detailedAssessmentResult,
double probability,
double n,
AssemblyCategoriesInput assemblyCategoriesInput)
{
- try
- {
- IFailureMechanismSectionAssemblyCalculatorKernel kernel = factory.CreateFailureMechanismSectionAssemblyKernel();
- FmSectionAssemblyDirectResult output = kernel.TranslateAssessmentResultWbi0G5(
- new AssessmentSection(1, assemblyCategoriesInput.SignalingNorm, assemblyCategoriesInput.LowerLimitNorm),
- new FailureMechanism(assemblyCategoriesInput.N, assemblyCategoriesInput.FailureMechanismContribution),
- n,
- double.IsNaN(probability) && detailedAssessmentResult == DetailedAssessmentProbabilityOnlyResultType.Probability
- ? EAssessmentResultTypeG2.Gr
- : FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeG2(detailedAssessmentResult),
- probability);
-
- return FailureMechanismSectionAssemblyCreator.Create(output);
- }
- catch (Exception e)
- {
- throw new FailureMechanismSectionAssemblyCalculatorException(e.Message, e);
- }
+ return GetDetailedAssembly(detailedAssessmentResult, probability, n, assemblyCategoriesInput);
}
public FailureMechanismSectionAssemblyCategoryGroup AssembleDetailedAssessment(
@@ -359,6 +326,59 @@
}
}
+ public FailureMechanismSectionAssembly AssembleManual(double probability, AssemblyCategoriesInput assemblyCategoriesInput)
+ {
+ return GetDetailedAssembly(DetailedAssessmentProbabilityOnlyResultType.Probability, probability, assemblyCategoriesInput);
+ }
+
+ public FailureMechanismSectionAssembly AssembleManual(double probability, double n, AssemblyCategoriesInput assemblyCategoriesInput)
+ {
+ return GetDetailedAssembly(DetailedAssessmentProbabilityOnlyResultType.Probability, probability, n, assemblyCategoriesInput);
+ }
+
+ private FailureMechanismSectionAssembly GetDetailedAssembly(DetailedAssessmentProbabilityOnlyResultType detailedAssessmentResult, double probability, AssemblyCategoriesInput assemblyCategoriesInput)
+ {
+ try
+ {
+ IFailureMechanismSectionAssemblyCalculatorKernel kernel = factory.CreateFailureMechanismSectionAssemblyKernel();
+ FmSectionAssemblyDirectResult output = kernel.TranslateAssessmentResultWbi0G3(
+ new AssessmentSection(1, assemblyCategoriesInput.SignalingNorm, assemblyCategoriesInput.LowerLimitNorm),
+ new FailureMechanism(assemblyCategoriesInput.N, assemblyCategoriesInput.FailureMechanismContribution),
+ double.IsNaN(probability) && detailedAssessmentResult == DetailedAssessmentProbabilityOnlyResultType.Probability
+ ? EAssessmentResultTypeG2.Gr
+ : FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeG2(detailedAssessmentResult),
+ probability);
+
+ return FailureMechanismSectionAssemblyCreator.Create(output);
+ }
+ catch (Exception e)
+ {
+ throw new FailureMechanismSectionAssemblyCalculatorException(e.Message, e);
+ }
+ }
+
+ private FailureMechanismSectionAssembly GetDetailedAssembly(DetailedAssessmentProbabilityOnlyResultType detailedAssessmentResult, double probability, double n, AssemblyCategoriesInput assemblyCategoriesInput)
+ {
+ try
+ {
+ IFailureMechanismSectionAssemblyCalculatorKernel kernel = factory.CreateFailureMechanismSectionAssemblyKernel();
+ FmSectionAssemblyDirectResult output = kernel.TranslateAssessmentResultWbi0G5(
+ new AssessmentSection(1, assemblyCategoriesInput.SignalingNorm, assemblyCategoriesInput.LowerLimitNorm),
+ new FailureMechanism(assemblyCategoriesInput.N, assemblyCategoriesInput.FailureMechanismContribution),
+ n,
+ double.IsNaN(probability) && detailedAssessmentResult == DetailedAssessmentProbabilityOnlyResultType.Probability
+ ? EAssessmentResultTypeG2.Gr
+ : FailureMechanismSectionAssemblyCalculatorInputCreator.CreateAssessmentResultTypeG2(detailedAssessmentResult),
+ probability);
+
+ return FailureMechanismSectionAssemblyCreator.Create(output);
+ }
+ catch (Exception e)
+ {
+ throw new FailureMechanismSectionAssemblyCalculatorException(e.Message, e);
+ }
+ }
+
#endregion
}
}
\ No newline at end of file
Index: Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/IFailureMechanismSectionAssemblyCalculator.cs
===================================================================
diff -u -rc0263fd00d9cc433209bbc0f4f68798bfd845bae -r508157dfe8615caaf50d75a9dd5d5b8c86e3ee81
--- Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/IFailureMechanismSectionAssemblyCalculator.cs (.../IFailureMechanismSectionAssemblyCalculator.cs) (revision c0263fd00d9cc433209bbc0f4f68798bfd845bae)
+++ Ringtoets/AssemblyTool/src/Ringtoets.AssemblyTool.KernelWrapper/Calculators/Assembly/IFailureMechanismSectionAssemblyCalculator.cs (.../IFailureMechanismSectionAssemblyCalculator.cs) (revision 508157dfe8615caaf50d75a9dd5d5b8c86e3ee81)
@@ -207,5 +207,31 @@
FailureMechanismSectionAssemblyCategoryGroup AssembleCombined(FailureMechanismSectionAssemblyCategoryGroup simpleAssembly,
FailureMechanismSectionAssemblyCategoryGroup detailedAssembly,
FailureMechanismSectionAssemblyCategoryGroup tailorMadeAssembly);
+
+ ///
+ /// Assembles the manual assembly based on the input parameters.
+ ///
+ /// The calculated probability.
+ /// The object containing the input parameters for
+ /// determining the assembly categories.
+ /// A .
+ /// Thrown when
+ /// an error occurs when performing the assembly.
+ FailureMechanismSectionAssembly AssembleManual(double probability,
+ AssemblyCategoriesInput assemblyCategoriesInput);
+
+ ///
+ /// Assembles the manual assembly based on the input parameters.
+ ///
+ /// The calculated probability.
+ /// The 'N' parameter of the failure mechanism section used to factor in the 'length effect'.
+ /// The object containing the input parameters for
+ /// determining the assembly categories.
+ /// A .
+ /// Thrown when
+ /// an error occurs when performing the assembly.
+ FailureMechanismSectionAssembly AssembleManual(double probability,
+ double n,
+ AssemblyCategoriesInput assemblyCategoriesInput);
}
}
\ No newline at end of file
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorTest.cs
===================================================================
diff -u -rea07b8a9037d23446252089f5a1034b01df65db4 -r508157dfe8615caaf50d75a9dd5d5b8c86e3ee81
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorTest.cs (.../FailureMechanismSectionAssemblyCalculatorTest.cs) (revision ea07b8a9037d23446252089f5a1034b01df65db4)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorTest.cs (.../FailureMechanismSectionAssemblyCalculatorTest.cs) (revision 508157dfe8615caaf50d75a9dd5d5b8c86e3ee81)
@@ -2061,5 +2061,266 @@
}
#endregion
+
+ #region Manual Assembly
+
+ [Test]
+ public void AssembleManualWithProbability_WithValidInput_InputCorrectlySetToKernel()
+ {
+ // Setup
+ var random = new Random(39);
+ double probability = random.NextDouble();
+ AssemblyCategoriesInput assemblyCategoriesInput = CreateAssemblyCategoriesInput();
+
+ using (new AssemblyToolKernelFactoryConfig())
+ {
+ var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+ FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
+ kernel.FailureMechanismSectionDirectResult = new FmSectionAssemblyDirectResult(random.NextEnumValue(),
+ random.NextDouble());
+
+ var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
+
+ // Call
+ calculator.AssembleManual(probability, assemblyCategoriesInput);
+
+ // Assert
+ Assert.AreEqual(probability, kernel.FailureProbabilityInput);
+ Assert.AreEqual(EAssessmentResultTypeG2.ResultSpecified, kernel.AssessmentResultTypeG2Input);
+
+ AssertAssemblyCategoriesInput(assemblyCategoriesInput, kernel);
+ }
+ }
+
+ [Test]
+ public void AssembleManualWithProbability_WithNaNValue_InputCorrectlySetToKernel()
+ {
+ // Setup
+ var random = new Random(39);
+ AssemblyCategoriesInput assemblyCategoriesInput = CreateAssemblyCategoriesInput();
+
+ using (new AssemblyToolKernelFactoryConfig())
+ {
+ var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+ FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
+ kernel.FailureMechanismSectionDirectResult = new FmSectionAssemblyDirectResult(random.NextEnumValue(),
+ random.NextDouble());
+
+ var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
+
+ // Call
+ calculator.AssembleManual(double.NaN, assemblyCategoriesInput);
+
+ // Assert
+ Assert.IsNaN(kernel.FailureProbabilityInput);
+ Assert.AreEqual(EAssessmentResultTypeG2.Gr, kernel.AssessmentResultTypeG2Input);
+
+ AssertAssemblyCategoriesInput(assemblyCategoriesInput, kernel);
+ }
+ }
+
+ [Test]
+ public void AssembleManualWithProbability_KernelWithCompleteOutput_OutputCorrectlyReturnedByCalculator()
+ {
+ // Setup
+ var random = new Random(39);
+ using (new AssemblyToolKernelFactoryConfig())
+ {
+ var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+ FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
+ kernel.FailureMechanismSectionDirectResult = new FmSectionAssemblyDirectResult(random.NextEnumValue(),
+ random.NextDouble());
+
+ var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
+
+ // Call
+ FailureMechanismSectionAssembly assembly = calculator.AssembleManual(random.NextDouble(), CreateAssemblyCategoriesInput());
+
+ // Assert
+ AssertCalculatorOutput(kernel.FailureMechanismSectionDirectResult, assembly);
+ }
+ }
+
+ [Test]
+ public void AssembleManualWithProbability_KernelWithInvalidOutput_ThrowFailureMechanismSectionAssemblyCalculatorException()
+ {
+ // Setup
+ var random = new Random(39);
+ using (new AssemblyToolKernelFactoryConfig())
+ {
+ var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+ FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
+ kernel.FailureMechanismSectionDirectResult = new FmSectionAssemblyDirectResult((EFmSectionCategory) 99,
+ random.NextDouble());
+
+ var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
+
+ // Call
+ TestDelegate test = () => calculator.AssembleManual(random.NextDouble(), CreateAssemblyCategoriesInput());
+
+ // Assert
+ var exception = Assert.Throws(test);
+ Exception innerException = exception.InnerException;
+ Assert.IsInstanceOf(innerException);
+ Assert.AreEqual(innerException.Message, exception.Message);
+ }
+ }
+
+ [Test]
+ public void AssembleManualWithProbability_KernelThrowsException_ThrowFailureMechanismSectionAssemblyCalculatorException()
+ {
+ // Setup
+ var random = new Random(39);
+ using (new AssemblyToolKernelFactoryConfig())
+ {
+ var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+ FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
+ kernel.ThrowExceptionOnCalculate = true;
+
+ var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
+
+ // Call
+ TestDelegate test = () => calculator.AssembleManual(random.NextDouble(), CreateAssemblyCategoriesInput());
+
+ // Assert
+ var exception = Assert.Throws(test);
+ Exception innerException = exception.InnerException;
+ Assert.IsNotNull(innerException);
+ Assert.AreEqual(innerException.Message, exception.Message);
+ }
+ }
+
+ [Test]
+ public void AssembleManualWithLengthEffect_WithValidInput_InputCorrectlySetToKernel()
+ {
+ // Setup
+ var random = new Random(39);
+ double probability = random.NextDouble();
+ double n = random.NextDouble();
+ AssemblyCategoriesInput assemblyCategoriesInput = CreateAssemblyCategoriesInput();
+
+ using (new AssemblyToolKernelFactoryConfig())
+ {
+ var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+ FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
+ kernel.FailureMechanismSectionDirectResult = new FmSectionAssemblyDirectResult(random.NextEnumValue(),
+ random.NextDouble());
+
+ var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
+
+ // Call
+ calculator.AssembleManual(
+ probability,
+ n,
+ assemblyCategoriesInput);
+
+ // Assert
+ Assert.AreEqual(probability, kernel.FailureProbabilityInput);
+ Assert.AreEqual(n, kernel.LengthEffectFactorInput);
+ Assert.AreEqual(EAssessmentResultTypeG2.ResultSpecified, kernel.AssessmentResultTypeG2Input);
+ AssertAssemblyCategoriesInput(assemblyCategoriesInput, kernel);
+ }
+ }
+
+ [Test]
+ public void AssembleManualWithLengthEffect_WithNaNValue_InputCorrectlySetToKernel()
+ {
+ // Setup
+ var random = new Random(39);
+ double n = random.NextDouble();
+ AssemblyCategoriesInput assemblyCategoriesInput = CreateAssemblyCategoriesInput();
+
+ using (new AssemblyToolKernelFactoryConfig())
+ {
+ var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+ FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
+ kernel.FailureMechanismSectionDirectResult = new FmSectionAssemblyDirectResult(random.NextEnumValue(),
+ random.NextDouble());
+
+ var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
+
+ // Call
+ calculator.AssembleManual(double.NaN, n, assemblyCategoriesInput);
+
+ // Assert
+ Assert.IsNaN(kernel.FailureProbabilityInput);
+ Assert.AreEqual(n, kernel.LengthEffectFactorInput);
+ Assert.AreEqual(EAssessmentResultTypeG2.Gr, kernel.AssessmentResultTypeG2Input);
+ AssertAssemblyCategoriesInput(assemblyCategoriesInput, kernel);
+ }
+ }
+
+ [Test]
+ public void AssembleManualWithLengthEffect_KernelWithCompleteOutput_OutputCorrectlyReturnedByCalculator()
+ {
+ // Setup
+ var random = new Random(39);
+ using (new AssemblyToolKernelFactoryConfig())
+ {
+ var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+ FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
+ kernel.FailureMechanismSectionDirectResult = new FmSectionAssemblyDirectResult(random.NextEnumValue(),
+ random.NextDouble());
+
+ var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
+
+ // Call
+ FailureMechanismSectionAssembly assembly = calculator.AssembleManual(random.NextDouble(), random.NextDouble(), CreateAssemblyCategoriesInput());
+
+ // Assert
+ AssertCalculatorOutput(kernel.FailureMechanismSectionDirectResult, assembly);
+ }
+ }
+
+ [Test]
+ public void AssembleManualWithLengthEffect_KernelWithInvalidOutput_ThrowFailureMechanismSectionAssemblyCalculatorException()
+ {
+ // Setup
+ var random = new Random(39);
+ using (new AssemblyToolKernelFactoryConfig())
+ {
+ var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+ FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
+ kernel.FailureMechanismSectionDirectResult = new FmSectionAssemblyDirectResult((EFmSectionCategory) 99,
+ random.NextDouble());
+
+ var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
+
+ // Call
+ TestDelegate test = () => calculator.AssembleManual(random.NextDouble(), random.NextDouble(), CreateAssemblyCategoriesInput());
+
+ // Assert
+ var exception = Assert.Throws(test);
+ Exception innerException = exception.InnerException;
+ Assert.IsInstanceOf(innerException);
+ Assert.AreEqual(innerException.Message, exception.Message);
+ }
+ }
+
+ [Test]
+ public void AssembleManualWithLengthEffect_KernelThrowsException_ThrowFailureMechanismSectionAssemblyCalculatorException()
+ {
+ // Setup
+ var random = new Random(39);
+ using (new AssemblyToolKernelFactoryConfig())
+ {
+ var factory = (TestAssemblyToolKernelFactory) AssemblyToolKernelFactory.Instance;
+ FailureMechanismSectionAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
+ kernel.ThrowExceptionOnCalculate = true;
+
+ var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
+
+ // Call
+ TestDelegate test = () => calculator.AssembleManual(random.NextDouble(), random.NextDouble(), CreateAssemblyCategoriesInput());
+
+ // Assert
+ var exception = Assert.Throws(test);
+ Exception innerException = exception.InnerException;
+ Assert.IsNotNull(innerException);
+ Assert.AreEqual(innerException.Message, exception.Message);
+ }
+ }
+
+ #endregion
}
}
\ No newline at end of file
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStubTest.cs
===================================================================
diff -u -rebf1043695f8e56bb1e0659af3565344f70cd33f -r508157dfe8615caaf50d75a9dd5d5b8c86e3ee81
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStubTest.cs (.../FailureMechanismSectionAssemblyCalculatorStubTest.cs) (revision ebf1043695f8e56bb1e0659af3565344f70cd33f)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil.Test/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStubTest.cs (.../FailureMechanismSectionAssemblyCalculatorStubTest.cs) (revision 508157dfe8615caaf50d75a9dd5d5b8c86e3ee81)
@@ -69,6 +69,10 @@
Assert.IsNull(calculator.CombinedTailorMadeAssemblyInput);
Assert.IsNull(calculator.CombinedAssemblyOutput);
+ Assert.AreEqual(0.0, calculator.ManualAssemblyNInput);
+ Assert.AreEqual(0.0, calculator.ManualAssemblyProbabilityInput);
+ Assert.IsNull(calculator.ManualAssemblyAssemblyOutput);
+
Assert.IsNull(calculator.AssemblyCategoriesInput);
}
@@ -376,7 +380,7 @@
FailureMechanismSectionAssembly assembly = calculator.AssembleDetailedAssessment(
random.NextEnumValue(),
random.NextDouble(),
- random.NextRoundedDouble(1.0, 10.0),
+ random.NextDouble(1.0, 10.0),
CreateAssemblyCategoriesInput());
// Assert
@@ -400,7 +404,7 @@
FailureMechanismSectionAssembly assembly = calculator.AssembleDetailedAssessment(
random.NextEnumValue(),
random.NextDouble(),
- random.NextRoundedDouble(1.0, 10.0),
+ random.NextDouble(1.0, 10.0),
CreateAssemblyCategoriesInput());
// Assert
@@ -413,7 +417,7 @@
// Setup
var random = new Random(39);
double probability = random.NextDouble();
- double n = random.NextRoundedDouble(1.0, 10.0);
+ double n = random.NextDouble(1.0, 10.0);
var detailedAssessmentResult = random.NextEnumValue();
AssemblyCategoriesInput assemblyCategoriesInput = CreateAssemblyCategoriesInput();
@@ -443,7 +447,7 @@
TestDelegate test = () => calculator.AssembleDetailedAssessment(
random.NextEnumValue(),
random.NextDouble(),
- random.NextRoundedDouble(1.0, 10.0),
+ random.NextDouble(1.0, 10.0),
CreateAssemblyCategoriesInput());
// Assert
@@ -1091,5 +1095,168 @@
}
#endregion
+
+ #region Manual Assessment
+
+ [Test]
+ public void AssembleManual_ThrowExceptionOnCalculateFalseAndOutputNotSet_ReturnOutput()
+ {
+ // Setup
+ var random = new Random(39);
+ var calculator = new FailureMechanismSectionAssemblyCalculatorStub();
+
+ // Call
+ FailureMechanismSectionAssembly assembly = calculator.AssembleManual(
+ random.NextDouble(),
+ CreateAssemblyCategoriesInput());
+
+ // Assert
+ Assert.AreEqual(1.0, assembly.Probability);
+ Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.VIv, assembly.Group);
+ }
+
+ [Test]
+ public void AssembleManual_ThrowExceptionOnCalculateFalseAndOutputSet_ReturnOutput()
+ {
+ // Setup
+ var random = new Random(39);
+ var calculator = new FailureMechanismSectionAssemblyCalculatorStub
+ {
+ ManualAssemblyAssemblyOutput = new FailureMechanismSectionAssembly(
+ random.NextDouble(),
+ random.NextEnumValue())
+ };
+
+ // Call
+ FailureMechanismSectionAssembly assembly = calculator.AssembleManual(
+ random.NextDouble(),
+ CreateAssemblyCategoriesInput());
+
+ // Assert
+ Assert.AreSame(calculator.ManualAssemblyAssemblyOutput, assembly);
+ }
+
+ [Test]
+ public void AssembleManual_ThrowExceptionOnCalculateFalse_SetsInput()
+ {
+ // Setup
+ var random = new Random(39);
+ double probability = random.NextDouble();
+ AssemblyCategoriesInput assemblyCategoriesInput = CreateAssemblyCategoriesInput();
+
+ var calculator = new FailureMechanismSectionAssemblyCalculatorStub();
+
+ // Call
+ calculator.AssembleManual(probability, assemblyCategoriesInput);
+
+ // Assert
+ Assert.AreEqual(probability, calculator.ManualAssemblyProbabilityInput);
+ Assert.AreSame(assemblyCategoriesInput, calculator.AssemblyCategoriesInput);
+ }
+
+ [Test]
+ public void AssembleManual_ThrowExceptionOnCalculateTrue_ThrowsFailureMechanismSectionAssemblyCalculatorException()
+ {
+ // Setup
+ var random = new Random(39);
+ var calculator = new FailureMechanismSectionAssemblyCalculatorStub
+ {
+ ThrowExceptionOnCalculate = true
+ };
+
+ // Call
+ TestDelegate test = () => calculator.AssembleManual(
+ random.NextDouble(),
+ CreateAssemblyCategoriesInput());
+
+ // Assert
+ var exception = Assert.Throws(test);
+ Assert.AreEqual("Message", exception.Message);
+ Assert.IsNotNull(exception.InnerException);
+ }
+
+ [Test]
+ public void AssembleManualWithLengthEffect_ThrowExceptionOnCalculateFalseAndOutputNotSet_ReturnOutput()
+ {
+ // Setup
+ var random = new Random(39);
+ var calculator = new FailureMechanismSectionAssemblyCalculatorStub();
+
+ // Call
+ FailureMechanismSectionAssembly assembly = calculator.AssembleManual(
+ random.NextDouble(),
+ random.NextDouble(1.0, 10.0),
+ CreateAssemblyCategoriesInput());
+
+ // Assert
+ Assert.AreEqual(0.0, assembly.Probability);
+ Assert.AreEqual(FailureMechanismSectionAssemblyCategoryGroup.VIv, assembly.Group);
+ }
+
+ [Test]
+ public void AssembleManualWithLengthEffect_ThrowExceptionOnCalculateFalseAndOutputSet_ReturnOutput()
+ {
+ // Setup
+ var random = new Random(39);
+ var calculator = new FailureMechanismSectionAssemblyCalculatorStub
+ {
+ ManualAssemblyAssemblyOutput = new FailureMechanismSectionAssembly(
+ random.NextDouble(),
+ random.NextEnumValue())
+ };
+
+ // Call
+ FailureMechanismSectionAssembly assembly = calculator.AssembleManual(
+ random.NextDouble(),
+ random.NextDouble(1.0, 10.0),
+ CreateAssemblyCategoriesInput());
+
+ // Assert
+ Assert.AreSame(calculator.ManualAssemblyAssemblyOutput, assembly);
+ }
+
+ [Test]
+ public void AssembleManualWithLengthEffect_ThrowExceptionOnCalculateFalse_SetsInput()
+ {
+ // Setup
+ var random = new Random(39);
+ double probability = random.NextDouble();
+ double n = random.NextDouble(1.0, 10.0);
+ AssemblyCategoriesInput assemblyCategoriesInput = CreateAssemblyCategoriesInput();
+
+ var calculator = new FailureMechanismSectionAssemblyCalculatorStub();
+
+ // Call
+ calculator.AssembleManual(probability, n, assemblyCategoriesInput);
+
+ // Assert
+ Assert.AreEqual(probability, calculator.ManualAssemblyProbabilityInput);
+ Assert.AreEqual(n, calculator.ManualAssemblyNInput);
+ Assert.AreSame(assemblyCategoriesInput, calculator.AssemblyCategoriesInput);
+ }
+
+ [Test]
+ public void AssembleManualWithLengthEffect_ThrowExceptionOnCalculateTrue_ThrowsFailureMechanismSectionAssemblyCalculatorException()
+ {
+ // Setup
+ var random = new Random(39);
+ var calculator = new FailureMechanismSectionAssemblyCalculatorStub
+ {
+ ThrowExceptionOnCalculate = true
+ };
+
+ // Call
+ TestDelegate test = () => calculator.AssembleManual(
+ random.NextDouble(),
+ random.NextDouble(1.0, 10.0),
+ CreateAssemblyCategoriesInput());
+
+ // Assert
+ var exception = Assert.Throws(test);
+ Assert.AreEqual("Message", exception.Message);
+ Assert.IsNotNull(exception.InnerException);
+ }
+
+ #endregion
}
}
\ No newline at end of file
Index: Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStub.cs
===================================================================
diff -u -rebf1043695f8e56bb1e0659af3565344f70cd33f -r508157dfe8615caaf50d75a9dd5d5b8c86e3ee81
--- Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStub.cs (.../FailureMechanismSectionAssemblyCalculatorStub.cs) (revision ebf1043695f8e56bb1e0659af3565344f70cd33f)
+++ Ringtoets/AssemblyTool/test/Ringtoets.AssemblyTool.KernelWrapper.TestUtil/Calculators/Assembly/FailureMechanismSectionAssemblyCalculatorStub.cs (.../FailureMechanismSectionAssemblyCalculatorStub.cs) (revision 508157dfe8615caaf50d75a9dd5d5b8c86e3ee81)
@@ -182,6 +182,21 @@
public FailureMechanismSectionAssemblyCategoryGroup CombinedTailorMadeAssemblyGroupInput { get; private set; }
///
+ /// Gets or sets the output of the manual assembly calculation.
+ ///
+ public FailureMechanismSectionAssembly ManualAssemblyAssemblyOutput { get; set; }
+
+ ///
+ /// Gets the probability input of the manual assembly calculation.
+ ///
+ public double ManualAssemblyProbabilityInput { get; private set; }
+
+ ///
+ /// Gets the 'N' parameter input of the manual assembly calculation.
+ ///
+ public double ManualAssemblyNInput { get; private set; }
+
+ ///
/// Gets the assembly categories input used in the assembly calculation methods.
///
public AssemblyCategoriesInput AssemblyCategoriesInput { get; private set; }
@@ -424,5 +439,34 @@
return CombinedAssemblyCategoryOutput.Value;
}
+
+ public FailureMechanismSectionAssembly AssembleManual(double probability, AssemblyCategoriesInput assemblyCategoriesInput)
+ {
+ if (ThrowExceptionOnCalculate)
+ {
+ throw new FailureMechanismSectionAssemblyCalculatorException("Message", new Exception());
+ }
+
+ DetailedAssessmentProbabilityInput = probability;
+ AssemblyCategoriesInput = assemblyCategoriesInput;
+
+ return DetailedAssessmentAssemblyOutput ??
+ (DetailedAssessmentAssemblyOutput = new FailureMechanismSectionAssembly(0, FailureMechanismSectionAssemblyCategoryGroup.VIv));
+ }
+
+ public FailureMechanismSectionAssembly AssembleManual(double probability, double n, AssemblyCategoriesInput assemblyCategoriesInput)
+ {
+ if (ThrowExceptionOnCalculate)
+ {
+ throw new FailureMechanismSectionAssemblyCalculatorException("Message", new Exception());
+ }
+
+ ManualAssemblyProbabilityInput = probability;
+ AssemblyCategoriesInput = assemblyCategoriesInput;
+ ManualAssemblyNInput = n;
+
+ return ManualAssemblyAssemblyOutput ??
+ (ManualAssemblyAssemblyOutput = new FailureMechanismSectionAssembly(1.0, FailureMechanismSectionAssemblyCategoryGroup.VIIv));
+ }
}
}
\ No newline at end of file