public void AssembleFailureMechanism_WithInputWithProbabilityResultTypeManual_NoInputOnCalculatorAndReturnsOutput()
{
// Setup
var random = new Random(21);
var failureMechanismResult = new FailureMechanismAssemblyResult
{
ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Manual,
ManualFailureMechanismAssemblyProbability = random.NextDouble()
};
using (new AssemblyToolCalculatorFactoryConfig())
{
// Call
FailureMechanismAssemblyResultWrapper assemblyResult = FailureMechanismAssemblyResultFactory.AssembleFailureMechanism(
random.NextDouble(), Enumerable.Empty <FailureMechanismSectionAssemblyResult>(),
random.NextBoolean(), failureMechanismResult);
// Assert
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
Assert.AreEqual(0, calculator.FailureMechanismN);
Assert.IsNull(calculator.SectionAssemblyResultsInput);
Assert.IsFalse(calculator.ApplyLengthEffect);
Assert.AreEqual(failureMechanismResult.ManualFailureMechanismAssemblyProbability, assemblyResult.AssemblyResult);
Assert.AreEqual(AssemblyMethod.Manual, assemblyResult.AssemblyMethod);
}
}
public void AssembleFailureMechanism_CalculatorRan_ReturnsExpectedOutput()
{
// Setup
var failureMechanism = new ClosingStructuresFailureMechanism
{
AssemblyResult =
{
ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic
}
};
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
// Call
FailureMechanismAssemblyResultWrapper result = ClosingStructuresFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
// Assert
Assert.AreSame(calculator.AssemblyResultOutput, result);
}
}
public FailureMechanismAssemblyResultWrapper Assemble(double failureMechanismN, IEnumerable <FailureMechanismSectionAssemblyResult> sectionAssemblyResults,
bool applySectionLengthEffect)
{
if (ThrowExceptionOnCalculate)
{
throw new FailureMechanismAssemblyCalculatorException("Message", new Exception());
}
FailureMechanismN = failureMechanismN;
SectionAssemblyResultsInput = sectionAssemblyResults;
ApplyLengthEffect = applySectionLengthEffect;
return(AssemblyResultOutput ?? (AssemblyResultOutput = new FailureMechanismAssemblyResultWrapper(0.1, AssemblyMethod.BOI1A1)));
}
public void Constructor_ExpectedValues()
{
// Setup
var random = new Random(21);
double assemblyResult = random.NextDouble();
var assemblyMethod = random.NextEnumValue <AssemblyMethod>();
// Call
var wrapper = new FailureMechanismAssemblyResultWrapper(assemblyResult, assemblyMethod);
// Assert
Assert.AreEqual(assemblyResult, wrapper.AssemblyResult);
Assert.AreEqual(assemblyMethod, wrapper.AssemblyMethod);
}
public void AssembleFailureMechanism_CalculatorRan_ReturnsOutput()
{
// Setup
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
// Call
FailureMechanismAssemblyResultWrapper assemblyResult = FailureMechanismAssemblyResultFactory.AssembleFailureMechanism(
0, Enumerable.Empty <FailureMechanismSectionAssemblyResult>(), false, new FailureMechanismAssemblyResult());
// Assert
Assert.AreSame(calculator.AssemblyResultOutput, assemblyResult);
}
}
/// <summary>
/// Creates an <see cref="ExportableFailureMechanism"/>
/// with assembly results based on the input parameters.
/// </summary>
/// <param name="failureMechanism">The failure mechanism to create an <see cref="ExportableFailureMechanism"/> for.</param>
/// <param name="assessmentSection">The assessment section the failure mechanism belongs to.</param>
/// <param name="assembleFailureMechanismFunc">The <see cref="Func{T1,T2,TResult}"/> to perform
/// the failure mechanism assembly.</param>
/// <param name="assembleFailureMechanismSectionFunc">The <see cref="Func{T1,T2,T3,TResult}"/>
/// to perform the failure mechanism section assembly.</param>
/// <param name="failureMechanismType">The type of the failure mechanism.</param>
/// <typeparam name="TFailureMechanism">The type of the failure mechanism.</typeparam>
/// <typeparam name="TSectionResult">The type of the section result.</typeparam>
/// <returns>An <see cref="ExportableFailureMechanism"/> with assembly results.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="failureMechanism"/>,
/// <paramref name="assessmentSection"/>, <paramref name="assembleFailureMechanismFunc"/> or
/// <paramref name="assembleFailureMechanismSectionFunc"/> is <c>null</c>.</exception>
/// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
public static ExportableFailureMechanism CreateExportableFailureMechanism <TFailureMechanism, TSectionResult>(
TFailureMechanism failureMechanism, IAssessmentSection assessmentSection,
Func <TFailureMechanism, IAssessmentSection, FailureMechanismAssemblyResultWrapper> assembleFailureMechanismFunc,
Func <TSectionResult, TFailureMechanism, IAssessmentSection, FailureMechanismSectionAssemblyResultWrapper> assembleFailureMechanismSectionFunc,
ExportableFailureMechanismType failureMechanismType)
where TFailureMechanism : IFailureMechanism <TSectionResult>
where TSectionResult : FailureMechanismSectionResult
{
if (failureMechanism == null)
{
throw new ArgumentNullException(nameof(failureMechanism));
}
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
if (assembleFailureMechanismFunc == null)
{
throw new ArgumentNullException(nameof(assembleFailureMechanismFunc));
}
if (assembleFailureMechanismSectionFunc == null)
{
throw new ArgumentNullException(nameof(assembleFailureMechanismSectionFunc));
}
FailureMechanismAssemblyResultWrapper assemblyResultWrapper = assembleFailureMechanismFunc(failureMechanism, assessmentSection);
return(new ExportableFailureMechanism(
new ExportableFailureMechanismAssemblyResult(
assemblyResultWrapper.AssemblyResult,
ExportableAssemblyMethodFactory.Create(assemblyResultWrapper.AssemblyMethod)),
CreateExportableFailureMechanismSectionResults(
failureMechanism, assessmentSection, assembleFailureMechanismSectionFunc),
failureMechanismType, failureMechanism.Code, failureMechanism.Name));
}
public void Assemble_WithValidOutput_ReturnsExpectedOutput(bool applyLengthEffect, AssemblyMethod expectedAssemblyMethod)
{
// Setup
var random = new Random(21);
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
FailureMechanismAssemblyKernelStub kernel = factory.LastCreatedFailureMechanismAssemblyKernel;
var output = new FailureMechanismAssemblyResult(new Probability(random.NextDouble()), EFailureMechanismAssemblyMethod.Correlated);
kernel.ProbabilityResult = output;
var calculator = new FailureMechanismAssemblyCalculator(factory);
// Call
FailureMechanismAssemblyResultWrapper assemblyResultWrapper = calculator.Assemble(random.NextDouble(), Enumerable.Empty <RiskeerFailureMechanismSectionAssemblyResult>(),
applyLengthEffect);
// Assert
Assert.IsTrue(kernel.Calculated);
ProbabilityAssert.AreEqual(assemblyResultWrapper.AssemblyResult, output.Probability);
Assert.AreEqual(assemblyResultWrapper.AssemblyMethod, expectedAssemblyMethod);
}
}
