public void AssembleFailureMechanismSectionWithLengthEffect_KernelThrowsAssemblyException_ThrowsFailureMechanismSectionAssemblyCalculatorException()
{
// Setup
FailureMechanismSectionWithProfileProbabilityAssemblyInput input = CreateFailureMechanismSectionWithProfileProbabilityAssemblyInput();
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
FailureMechanismSectionAssemblyKernelStub failureMechanismSectionAssemblyKernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
failureMechanismSectionAssemblyKernel.ThrowAssemblyExceptionOnCalculate = true;
var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
// Call
void Call() => calculator.AssembleFailureMechanismSection(input);
// Assert
var exception = Assert.Throws <FailureMechanismSectionAssemblyCalculatorException>(Call);
var innerException = exception.InnerException as AssemblyException;
Assert.IsNotNull(innerException);
Assert.AreEqual(AssemblyErrorMessageCreator.CreateErrorMessage(innerException.Errors), exception.Message);
Assert.IsFalse(failureMechanismSectionAssemblyKernel.Calculated);
}
}
public void Constructor_ExpectedValues()
{
// Setup
var random = new Random(21);
double maximumAllowableFloodingProbability = random.NextDouble();
double signalFloodingProbability = random.NextDouble();
bool isRelevant = random.NextBoolean();
bool hasProbabilitySpecified = random.NextBoolean();
double profileProbability = random.NextDouble();
double sectionProbability = random.NextDouble();
var furtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>();
double refinedProfileProbability = random.NextDouble();
double refinedSectionProbability = random.NextDouble();
// Call
var input = new FailureMechanismSectionWithProfileProbabilityAssemblyInput(
maximumAllowableFloodingProbability, signalFloodingProbability, isRelevant, hasProbabilitySpecified, profileProbability, sectionProbability,
furtherAnalysisType, refinedProfileProbability, refinedSectionProbability);
// Assert
Assert.IsInstanceOf <FailureMechanismSectionAssemblyInput>(input);
Assert.AreEqual(signalFloodingProbability, input.SignalFloodingProbability);
Assert.AreEqual(maximumAllowableFloodingProbability, input.MaximumAllowableFloodingProbability);
Assert.AreEqual(isRelevant, input.IsRelevant);
Assert.AreEqual(hasProbabilitySpecified, input.HasProbabilitySpecified);
Assert.AreEqual(profileProbability, input.InitialProfileProbability);
Assert.AreEqual(sectionProbability, input.InitialSectionProbability);
Assert.AreEqual(furtherAnalysisType, input.FurtherAnalysisType);
Assert.AreEqual(refinedProfileProbability, input.RefinedProfileProbability);
Assert.AreEqual(refinedSectionProbability, input.RefinedSectionProbability);
}
public void AssembleSectionAdoptableWithProfileProbability_WithInputAndUseLengthEffectTrueAndVariousProbabilityRefinementType_SetsInputOnCalculator(
ProbabilityRefinementType probabilityRefinementType,
double sectionN)
{
// Setup
var random = new Random(21);
double refinedSectionProbability = random.NextDouble();
double refinedProfileProbability = random.NextDouble();
var mocks = new MockRepository();
var calculateStrategy = mocks.Stub <IFailureMechanismSectionResultCalculateProbabilityStrategy>();
mocks.ReplayAll();
var assessmentSection = new AssessmentSectionStub();
var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
{
ProbabilityRefinementType = probabilityRefinementType,
RefinedProfileProbability = refinedProfileProbability,
RefinedSectionProbability = refinedSectionProbability
};
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
FailureMechanismSectionAssemblyResultFactory.AssembleSection(
sectionResult, assessmentSection, calculateStrategy, true, sectionN);
// Assert
FailureMechanismSectionWithProfileProbabilityAssemblyInput calculatorInput = calculator.FailureMechanismSectionWithProfileProbabilityAssemblyInput;
switch (probabilityRefinementType)
{
case ProbabilityRefinementType.Profile:
Assert.AreEqual(refinedProfileProbability, calculatorInput.RefinedProfileProbability);
Assert.AreEqual(Math.Min(1.0, refinedProfileProbability * sectionN), calculatorInput.RefinedSectionProbability);
break;
case ProbabilityRefinementType.Section:
Assert.AreEqual(refinedSectionProbability / sectionN, calculatorInput.RefinedProfileProbability);
Assert.AreEqual(refinedSectionProbability, calculatorInput.RefinedSectionProbability);
break;
case ProbabilityRefinementType.Both:
Assert.AreEqual(refinedProfileProbability, calculatorInput.RefinedProfileProbability);
Assert.AreEqual(refinedSectionProbability, calculatorInput.RefinedSectionProbability);
break;
}
}
}
public FailureMechanismSectionAssemblyResultWrapper AssembleFailureMechanismSection(FailureMechanismSectionWithProfileProbabilityAssemblyInput input)
{
if (ThrowExceptionOnCalculate)
{
throw new FailureMechanismSectionAssemblyCalculatorException("Message", new Exception());
}
FailureMechanismSectionWithProfileProbabilityAssemblyInput = input;
return(FailureMechanismSectionAssemblyResultOutput ??
(FailureMechanismSectionAssemblyResultOutput =
new FailureMechanismSectionAssemblyResultWrapper(
new FailureMechanismSectionAssemblyResult(0.01, 0.1, 10, FailureMechanismSectionAssemblyGroup.I),
AssemblyMethod.BOI0A1, AssemblyMethod.BOI0B1)));
}
public void AssembleSectionNonAdoptableWithProfileProbability_WithInputAndUseLengthEffectTrue_SetsInputOnCalculator(
NonAdoptableInitialFailureMechanismResultType initialFailureMechanismResultType, bool expectedHasProbabilitySpecified)
{
// Setup
var random = new Random(21);
bool isRelevant = random.NextBoolean();
double manualInitialProfileProbability = random.NextDouble();
double manualInitialSectionProbability = random.NextDouble();
var furtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>();
double manualRefinedSectionProbability = random.NextDouble();
double manualRefinedProfileProbability = random.NextDouble();
var assessmentSection = new AssessmentSectionStub();
var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
{
IsRelevant = isRelevant,
InitialFailureMechanismResultType = initialFailureMechanismResultType,
ManualInitialFailureMechanismResultProfileProbability = manualInitialProfileProbability,
ManualInitialFailureMechanismResultSectionProbability = manualInitialSectionProbability,
FurtherAnalysisType = furtherAnalysisType,
RefinedProfileProbability = manualRefinedProfileProbability,
RefinedSectionProbability = manualRefinedSectionProbability
};
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, assessmentSection, true);
// Assert
FailureMechanismSectionWithProfileProbabilityAssemblyInput calculatorInput = calculator.FailureMechanismSectionWithProfileProbabilityAssemblyInput;
FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution;
Assert.AreEqual(failureMechanismContribution.SignalFloodingProbability, calculatorInput.SignalFloodingProbability);
Assert.AreEqual(failureMechanismContribution.MaximumAllowableFloodingProbability, calculatorInput.MaximumAllowableFloodingProbability);
Assert.AreEqual(isRelevant, calculatorInput.IsRelevant);
Assert.AreEqual(expectedHasProbabilitySpecified, calculatorInput.HasProbabilitySpecified);
Assert.AreEqual(manualInitialProfileProbability, calculatorInput.InitialProfileProbability);
Assert.AreEqual(manualInitialSectionProbability, calculatorInput.InitialSectionProbability);
Assert.AreEqual(furtherAnalysisType, calculatorInput.FurtherAnalysisType);
Assert.AreEqual(manualRefinedProfileProbability, calculatorInput.RefinedProfileProbability);
Assert.AreEqual(manualRefinedSectionProbability, calculatorInput.RefinedSectionProbability);
}
}
public void AssembleSection_WithInput_SetsInputOnCalculator()
{
// Setup
var random = new Random(21);
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section)
{
IsRelevant = random.NextBoolean(),
InitialFailureMechanismResultType = AdoptableInitialFailureMechanismResultType.Manual,
ManualInitialFailureMechanismResultProfileProbability = random.NextDouble(),
ManualInitialFailureMechanismResultSectionProbability = random.NextDouble(),
FurtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>(),
ProbabilityRefinementType = ProbabilityRefinementType.Both,
RefinedProfileProbability = random.NextDouble(),
RefinedSectionProbability = random.NextDouble()
};
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
MacroStabilityInwardsFailureMechanismAssemblyFactory.AssembleSection(sectionResult, failureMechanism, assessmentSection);
// Assert
FailureMechanismSectionWithProfileProbabilityAssemblyInput calculatorInput = calculator.FailureMechanismSectionWithProfileProbabilityAssemblyInput;
FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution;
Assert.AreEqual(failureMechanismContribution.SignalFloodingProbability, calculatorInput.SignalFloodingProbability);
Assert.AreEqual(failureMechanismContribution.MaximumAllowableFloodingProbability, calculatorInput.MaximumAllowableFloodingProbability);
Assert.AreEqual(sectionResult.IsRelevant, calculatorInput.IsRelevant);
Assert.IsTrue(calculatorInput.HasProbabilitySpecified);
Assert.AreEqual(sectionResult.ManualInitialFailureMechanismResultProfileProbability, calculatorInput.InitialProfileProbability);
Assert.AreEqual(sectionResult.ManualInitialFailureMechanismResultSectionProbability, calculatorInput.InitialSectionProbability);
Assert.AreEqual(sectionResult.FurtherAnalysisType, calculatorInput.FurtherAnalysisType);
Assert.AreEqual(sectionResult.RefinedProfileProbability, calculatorInput.RefinedProfileProbability);
Assert.AreEqual(sectionResult.RefinedSectionProbability, calculatorInput.RefinedSectionProbability);
}
}
public void AssembleFailureMechanismSectionWithLengthEffect_InputWithProbabilityDefinedKernelWithCompleteOutput_ReturnsExpectedFailureMechanismSectionAssembly()
{
// Setup
var random = new Random(21);
var input = new FailureMechanismSectionWithProfileProbabilityAssemblyInput(
0.001, 0.0001, true, true, random.NextDouble(), random.NextDouble(),
FailureMechanismSectionResultFurtherAnalysisType.Executed,
random.NextDouble(), random.NextDouble());
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
AssemblyCategoryLimitsKernelStub categoryLimitsKernel = factory.LastCreatedAssemblyCategoryLimitsKernel;
categoryLimitsKernel.InterpretationCategoryLimits = CreateInterpretationCategories();
FailureMechanismSectionAssemblyKernelStub failureMechanismSectionAssemblyKernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
var categoryOutput = random.NextEnumValue <EInterpretationCategory>();
var kernelResult = new ResultWithProfileAndSectionProbabilities(
new Probability(random.NextDouble(0.0001, 0.001)),
new Probability(random.NextDouble(0.001, 0.01)));
failureMechanismSectionAssemblyKernel.ProfileAndSectionProbabilities = kernelResult;
failureMechanismSectionAssemblyKernel.CategoryOutput = categoryOutput;
var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
// Call
FailureMechanismSectionAssemblyResultWrapper resultWrapper = calculator.AssembleFailureMechanismSection(input);
// Assert
Assert.IsTrue(categoryLimitsKernel.Calculated);
Assert.IsTrue(failureMechanismSectionAssemblyKernel.Calculated);
FailureMechanismSectionAssemblyResult result = resultWrapper.AssemblyResult;
Assert.AreEqual((double)kernelResult.ProbabilityProfile, result.ProfileProbability);
Assert.AreEqual((double)kernelResult.ProbabilitySection, result.SectionProbability);
Assert.AreEqual(kernelResult.LengthEffectFactor, result.N);
Assert.AreEqual(FailureMechanismSectionAssemblyGroupConverter.ConvertTo(categoryOutput),
result.FailureMechanismSectionAssemblyGroup);
Assert.AreEqual(AssemblyMethod.BOI0A2, resultWrapper.ProbabilityMethod);
Assert.AreEqual(AssemblyMethod.BOI0B1, resultWrapper.AssemblyGroupMethod);
}
}
public void AssembleFailureMechanismSectionWithLengthEffect_WithValidInputAndProbabilityDefined_InputCorrectlySentToKernel(
FailureMechanismSectionWithProfileProbabilityAssemblyInput input)
{
// Setup
var random = new Random(21);
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
AssemblyCategoryLimitsKernelStub categoryLimitsKernel = factory.LastCreatedAssemblyCategoryLimitsKernel;
CategoriesList <InterpretationCategory> interpretationCategories = CreateInterpretationCategories();
categoryLimitsKernel.InterpretationCategoryLimits = interpretationCategories;
FailureMechanismSectionAssemblyKernelStub failureMechanismSectionAssemblyKernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
var sectionProbability = new Probability(random.NextDouble(0.0, 0.01));
failureMechanismSectionAssemblyKernel.ProfileAndSectionProbabilities = new ResultWithProfileAndSectionProbabilities(
new Probability(random.NextDouble(0.0001, 0.001)), sectionProbability);
failureMechanismSectionAssemblyKernel.CategoryOutput = EInterpretationCategory.Zero;
var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
// Call
calculator.AssembleFailureMechanismSection(input);
// Assert
AssessmentSection assessmentSection = categoryLimitsKernel.AssessmentSection;
ProbabilityAssert.AreEqual(input.MaximumAllowableFloodingProbability, assessmentSection.MaximumAllowableFloodingProbability);
ProbabilityAssert.AreEqual(input.SignalFloodingProbability, assessmentSection.SignalFloodingProbability);
Assert.AreSame(interpretationCategories, failureMechanismSectionAssemblyKernel.Categories);
Assert.AreEqual(input.FurtherAnalysisType != FailureMechanismSectionResultFurtherAnalysisType.NotNecessary, failureMechanismSectionAssemblyKernel.RefinementNecessary);
Assert.AreEqual(input.InitialProfileProbability, failureMechanismSectionAssemblyKernel.ProbabilityInitialMechanismProfile);
Assert.AreEqual(input.InitialSectionProbability, failureMechanismSectionAssemblyKernel.ProbabilityInitialMechanismSection);
Assert.AreEqual(input.RefinedProfileProbability, failureMechanismSectionAssemblyKernel.RefinedProbabilityProfile);
Assert.AreEqual(input.RefinedSectionProbability, failureMechanismSectionAssemblyKernel.RefinedProbabilitySection);
Assert.AreEqual(sectionProbability, failureMechanismSectionAssemblyKernel.SectionProbabilityInput);
}
}
public void AssembleFailureMechanismSectionWithLengthEffect_InputWithProbabilityUndefinedAndKernelWithCompleteOutput_ReturnsExpectedFailureMechanismSectionAssembly()
{
// Setup
var random = new Random(21);
var input = new FailureMechanismSectionWithProfileProbabilityAssemblyInput(
0.001, 0.0001, false, random.NextBoolean(), double.NaN, double.NaN,
random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>(),
double.NaN, double.NaN);
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
FailureMechanismSectionAssemblyKernelStub failureMechanismSectionAssemblyKernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
var categoryOutput = random.NextEnumValue <EInterpretationCategory>();
var sectionProbability = new Probability(random.NextDouble(0.0, 0.01));
failureMechanismSectionAssemblyKernel.CategoryOutput = categoryOutput;
failureMechanismSectionAssemblyKernel.SectionProbability = sectionProbability;
var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
// Call
FailureMechanismSectionAssemblyResultWrapper resultWrapper = calculator.AssembleFailureMechanismSection(input);
// Assert
Assert.IsTrue(failureMechanismSectionAssemblyKernel.Calculated);
FailureMechanismSectionAssemblyResult result = resultWrapper.AssemblyResult;
Assert.AreEqual(sectionProbability, result.ProfileProbability);
Assert.AreEqual(sectionProbability, result.SectionProbability);
Assert.AreEqual(1.0, result.N);
Assert.AreEqual(FailureMechanismSectionAssemblyGroupConverter.ConvertTo(categoryOutput),
result.FailureMechanismSectionAssemblyGroup);
Assert.AreEqual(AssemblyMethod.BOI0C2, resultWrapper.ProbabilityMethod);
Assert.AreEqual(AssemblyMethod.BOI0C1, resultWrapper.AssemblyGroupMethod);
}
}
public void AssembleFailureMechanismSectionWithLengthEffect_WithValidInputAndNoProbabilityDefined_InputCorrectlySentToKernel(
FailureMechanismSectionWithProfileProbabilityAssemblyInput input, EAnalysisState expectedAnalysisState)
{
// Setup
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
FailureMechanismSectionAssemblyKernelStub failureMechanismSectionAssemblyKernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
var random = new Random(21);
var categoryOutput = random.NextEnumValue <EInterpretationCategory>();
failureMechanismSectionAssemblyKernel.CategoryOutput = categoryOutput;
failureMechanismSectionAssemblyKernel.SectionProbability = new Probability(random.NextDouble());
var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
// Call
calculator.AssembleFailureMechanismSection(input);
// Assert
Assert.AreEqual(expectedAnalysisState, failureMechanismSectionAssemblyKernel.AnalysisState);
Assert.AreEqual(categoryOutput, failureMechanismSectionAssemblyKernel.CategoryInput);
}
}
public FailureMechanismSectionAssemblyResultWrapper AssembleFailureMechanismSection(FailureMechanismSectionWithProfileProbabilityAssemblyInput input)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
try
{
IAssessmentResultsTranslator kernel = factory.CreateFailureMechanismSectionAssemblyKernel();
if (!IsProbabilityDefined(input))
{
return(AssembleWithUndefinedProbabilities(input, kernel));
}
ResultWithProfileAndSectionProbabilities output = kernel.DetermineRepresentativeProbabilitiesBoi0A2(
input.FurtherAnalysisType != FailureMechanismSectionResultFurtherAnalysisType.NotNecessary,
AssemblyCalculatorInputCreator.CreateProbability(input.InitialProfileProbability),
AssemblyCalculatorInputCreator.CreateProbability(input.InitialSectionProbability),
AssemblyCalculatorInputCreator.CreateProbability(input.RefinedProfileProbability),
AssemblyCalculatorInputCreator.CreateProbability(input.RefinedSectionProbability));
EInterpretationCategory interpretationCategory = AssembleInterpretationCategory(input, kernel, output.ProbabilitySection);
return(new FailureMechanismSectionAssemblyResultWrapper(
FailureMechanismSectionAssemblyResultCreator.Create(output, interpretationCategory),
AssemblyMethod.BOI0A2, AssemblyMethod.BOI0B1));
}
catch (AssemblyException e)
{
throw new FailureMechanismSectionAssemblyCalculatorException(AssemblyErrorMessageCreator.CreateErrorMessage(e.Errors), e);
}
catch (Exception e)
{
throw new FailureMechanismSectionAssemblyCalculatorException(AssemblyErrorMessageCreator.CreateGenericErrorMessage(), e);
}
}
public void AssembleSectionAdoptableWithProfileProbability_WithInputAndUseLengthEffectTrue_SetsInputOnCalculator(
AdoptableInitialFailureMechanismResultType initialFailureMechanismResultType, bool expectedHasProbabilitySpecified)
{
// Setup
var random = new Random(21);
bool isRelevant = random.NextBoolean();
double manualInitialProfileProbability = random.NextDouble();
double manualInitialSectionProbability = random.NextDouble();
double calculatedStrategySectionProbability = random.NextDouble();
double calculatedStrategyProfileSectionProbability = random.NextDouble();
var furtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>();
double manualRefinedSectionProbability = random.NextDouble();
double manualRefinedProfileProbability = random.NextDouble();
var mocks = new MockRepository();
var calculateStrategy = mocks.StrictMock <IFailureMechanismSectionResultCalculateProbabilityStrategy>();
bool isInitialFailureMechanismResultTypeAdopt = IsInitialFailureMechanismResultTypeAdopt(initialFailureMechanismResultType);
if (isInitialFailureMechanismResultTypeAdopt)
{
calculateStrategy.Expect(cs => cs.CalculateProfileProbability())
.Return(calculatedStrategyProfileSectionProbability);
calculateStrategy.Expect(cs => cs.CalculateSectionProbability())
.Return(calculatedStrategySectionProbability);
}
mocks.ReplayAll();
var assessmentSection = new AssessmentSectionStub();
var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())
{
IsRelevant = isRelevant,
InitialFailureMechanismResultType = initialFailureMechanismResultType,
ManualInitialFailureMechanismResultProfileProbability = manualInitialProfileProbability,
ManualInitialFailureMechanismResultSectionProbability = manualInitialSectionProbability,
FurtherAnalysisType = furtherAnalysisType,
ProbabilityRefinementType = ProbabilityRefinementType.Both,
RefinedProfileProbability = manualRefinedProfileProbability,
RefinedSectionProbability = manualRefinedSectionProbability
};
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
FailureMechanismSectionAssemblyResultFactory.AssembleSection(
sectionResult, assessmentSection, calculateStrategy, true, random.NextDouble());
// Assert
FailureMechanismSectionWithProfileProbabilityAssemblyInput calculatorInput = calculator.FailureMechanismSectionWithProfileProbabilityAssemblyInput;
FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution;
Assert.AreEqual(failureMechanismContribution.SignalFloodingProbability, calculatorInput.SignalFloodingProbability);
Assert.AreEqual(failureMechanismContribution.MaximumAllowableFloodingProbability, calculatorInput.MaximumAllowableFloodingProbability);
Assert.AreEqual(isRelevant, calculatorInput.IsRelevant);
Assert.AreEqual(expectedHasProbabilitySpecified, calculatorInput.HasProbabilitySpecified);
double expectedInitialProfileProbability = isInitialFailureMechanismResultTypeAdopt
? calculatedStrategyProfileSectionProbability
: manualInitialProfileProbability;
Assert.AreEqual(expectedInitialProfileProbability, calculatorInput.InitialProfileProbability);
double expectedInitialSectionProbability = isInitialFailureMechanismResultTypeAdopt
? calculatedStrategySectionProbability
: manualInitialSectionProbability;
Assert.AreEqual(expectedInitialSectionProbability, calculatorInput.InitialSectionProbability);
Assert.AreEqual(furtherAnalysisType, calculatorInput.FurtherAnalysisType);
Assert.AreEqual(manualRefinedProfileProbability, calculatorInput.RefinedProfileProbability);
Assert.AreEqual(manualRefinedSectionProbability, calculatorInput.RefinedSectionProbability);
}
}
