public void Constructor_PerformAssemblyFuncReturnsResult_ReturnsAssemblyResult()
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
FailureMechanismSectionAssemblyResultWrapper assemblyResultWrapper = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create();
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = () => assemblyResultWrapper;
// Call
var row = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResultRow(result, errorProvider, performAssemblyFunc, ConstructionProperties);
// Assert
FailureMechanismSectionAssemblyResult assemblyResult = assemblyResultWrapper.AssemblyResult;
Assert.AreEqual(assemblyResult.ProfileProbability, row.ProfileProbability);
Assert.AreEqual(assemblyResult.SectionProbability, row.SectionProbability);
Assert.AreEqual(assemblyResult.N, row.SectionN, row.SectionN.GetAccuracy());
Assert.AreEqual(2, row.SectionN.NumberOfDecimalPlaces);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(assemblyResult.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
mocks.VerifyAll();
}
/// <summary>
/// Creates a collection of <see cref="ExportableFailureMechanismSectionAssemblyWithProbabilityResult"/>
/// with assembly results based on <paramref name="failureMechanism"/>.
/// </summary>
/// <param name="failureMechanism">The failure mechanism to create a collection of
/// <see cref="ExportableFailureMechanismSectionAssemblyWithProbabilityResult"/> for.</param>
/// <param name="assessmentSection">The <see cref="IAssessmentSection"/> to use in the assembly.</param>
/// <param name="assembleFailureMechanismSectionFunc">The <see cref="Func{T1,T2,T3,TResult}"/>
/// to perform the failure mechanism section assembly.</param>
/// <typeparam name="TFailureMechanism">The type of the failure mechanism.</typeparam>
/// <typeparam name="TSectionResult">The type of the section result.</typeparam>
/// <returns>A collection of <see cref="ExportableFailureMechanismSectionAssemblyWithProbabilityResult"/>.</returns>
/// <exception cref="AssemblyException">Thrown when assembly results cannot be created.</exception>
private static IEnumerable <ExportableFailureMechanismSectionAssemblyWithProbabilityResult> CreateExportableFailureMechanismSectionResults
<TFailureMechanism, TSectionResult>(
TFailureMechanism failureMechanism, IAssessmentSection assessmentSection,
Func <TSectionResult, TFailureMechanism, IAssessmentSection, FailureMechanismSectionAssemblyResultWrapper> assembleFailureMechanismSectionFunc)
where TFailureMechanism : IFailureMechanism <TSectionResult>
where TSectionResult : FailureMechanismSectionResult
{
IDictionary <TSectionResult, ExportableFailureMechanismSection> failureMechanismSectionsLookup =
ExportableFailureMechanismSectionHelper.CreateFailureMechanismSectionResultLookup(failureMechanism.SectionResults);
var exportableResults = new List <ExportableFailureMechanismSectionAssemblyWithProbabilityResult>();
foreach (KeyValuePair <TSectionResult, ExportableFailureMechanismSection> failureMechanismSectionPair in failureMechanismSectionsLookup)
{
FailureMechanismSectionAssemblyResultWrapper assemblyResultWrapper = assembleFailureMechanismSectionFunc(
failureMechanismSectionPair.Key, failureMechanism, assessmentSection);
FailureMechanismSectionAssemblyResult assemblyResult = assemblyResultWrapper.AssemblyResult;
exportableResults.Add(
new ExportableFailureMechanismSectionAssemblyWithProbabilityResult(
failureMechanismSectionPair.Value, assemblyResult.FailureMechanismSectionAssemblyGroup, assemblyResult.SectionProbability,
ExportableAssemblyMethodFactory.Create(assemblyResultWrapper.AssemblyGroupMethod),
ExportableAssemblyMethodFactory.Create(assemblyResultWrapper.ProbabilityMethod)));
}
return(exportableResults);
}
public void Constructor_AssemblyRan_ReturnsAssemblyResult()
{
// Setup
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new AdoptableFailureMechanismSectionResult(section);
FailureMechanismSectionAssemblyResultWrapper assemblyResultWrapper = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create();
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = () => assemblyResultWrapper;
// Call
var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
performAssemblyFunc, ConstructionProperties);
// Assert
var assemblyResult = assemblyResultWrapper.AssemblyResult;
Assert.AreEqual(assemblyResult.SectionProbability, row.SectionProbability);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(assemblyResult.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
mocks.VerifyAll();
}
public void AssembleSectionAdoptableSectionWithProfileProbability_CalculatorRan_ReturnsExpectedOutput()
{
// Setup
var random = new Random(21);
var mocks = new MockRepository();
var calculateStrategy = mocks.Stub <IFailureMechanismSectionResultCalculateProbabilityStrategy>();
mocks.ReplayAll();
var assessmentSection = new AssessmentSectionStub();
var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection());
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
FailureMechanismSectionAssemblyResultWrapper result = FailureMechanismSectionAssemblyResultFactory.AssembleSection(
sectionResult, assessmentSection, calculateStrategy, random.NextBoolean(), random.NextDouble());
// Assert
Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput, result);
}
}
public void GivenRowWithoutAssemblyErrors_WhenUpdatingAndPerformAssemblyThrowsException_ThenShowError()
{
// Given
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
var nrOfCalls = 0;
FailureMechanismSectionAssemblyResultWrapper assemblyResultWrapper = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create();
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = () =>
{
if (nrOfCalls == 1)
{
throw new AssemblyException();
}
nrOfCalls++;
return(assemblyResultWrapper);
};
var row = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResultRow(result, errorProvider, performAssemblyFunc, ConstructionProperties);
// Precondition
FailureMechanismSectionAssemblyResult assemblyResult = assemblyResultWrapper.AssemblyResult;
Assert.AreEqual(assemblyResult.ProfileProbability, row.ProfileProbability);
Assert.AreEqual(assemblyResult.SectionProbability, row.SectionProbability);
Assert.AreEqual(assemblyResult.N, row.SectionN, row.SectionN.GetAccuracy());
Assert.AreEqual(2, row.SectionN.NumberOfDecimalPlaces);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(assemblyResult.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
// When
row.InitialFailureMechanismResultType = NonAdoptableInitialFailureMechanismResultType.NoFailureProbability;
// Then
var expectedAssemblyResult = new DefaultFailureMechanismSectionAssemblyResult();
Assert.AreEqual(expectedAssemblyResult.ProfileProbability, row.ProfileProbability);
Assert.AreEqual(expectedAssemblyResult.SectionProbability, row.SectionProbability);
Assert.AreEqual(expectedAssemblyResult.N, row.SectionN, row.SectionN.GetAccuracy());
Assert.AreEqual(2, row.SectionN.NumberOfDecimalPlaces);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(expectedAssemblyResult.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
mocks.VerifyAll();
}
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 GivenRowWithoutAssemblyErrors_WhenUpdatingAndAssemblyThrowsException_ThenAssemblyPropertiesSetToDefault()
{
// Given
var mocks = new MockRepository();
var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>();
mocks.ReplayAll();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var result = new AdoptableFailureMechanismSectionResult(section);
var nrOfCalls = 0;
FailureMechanismSectionAssemblyResultWrapper assemblyResultWrapper = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create();
Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = () =>
{
if (nrOfCalls == 1)
{
throw new AssemblyException();
}
nrOfCalls++;
return(assemblyResultWrapper);
};
var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider,
performAssemblyFunc, ConstructionProperties);
// Precondition
FailureMechanismSectionAssemblyResult assemblyResult = assemblyResultWrapper.AssemblyResult;
Assert.AreEqual(assemblyResult.SectionProbability, row.SectionProbability);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(assemblyResult.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
// When
row.InitialFailureMechanismResultType = AdoptableInitialFailureMechanismResultType.Manual;
// Then
var expectedAssemblyResult = new DefaultFailureMechanismSectionAssemblyResult();
Assert.AreEqual(expectedAssemblyResult.SectionProbability, row.SectionProbability);
Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(expectedAssemblyResult.FailureMechanismSectionAssemblyGroup),
row.AssemblyGroup);
mocks.VerifyAll();
}
public void Constructor_ExpectedValues()
{
// Setup
var random = new Random(21);
var assemblyResult = new FailureMechanismSectionAssemblyResult(
random.NextDouble(), random.NextDouble(), random.NextDouble(),
random.NextEnumValue <FailureMechanismSectionAssemblyGroup>());
var probabilityMethod = random.NextEnumValue <AssemblyMethod>();
var assemblyGroupMethod = random.NextEnumValue <AssemblyMethod>();
// Call
var wrapper = new FailureMechanismSectionAssemblyResultWrapper(assemblyResult, probabilityMethod, assemblyGroupMethod);
// Assert
Assert.AreSame(assemblyResult, wrapper.AssemblyResult);
Assert.AreEqual(probabilityMethod, wrapper.ProbabilityMethod);
Assert.AreEqual(assemblyGroupMethod, wrapper.AssemblyGroupMethod);
}
public void AssembleSectionAdoptableSectionWithoutProfileProbability_CalculatorRan_ReturnsExpectedOutput()
{
// Setup
var assessmentSection = new AssessmentSectionStub();
var sectionResult = new AdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection());
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
FailureMechanismSectionAssemblyResultWrapper result = FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, assessmentSection, () => double.NaN);
// Assert
Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput, result);
}
}
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 FailureMechanismResultsView_AllDataSet_DataGridViewCorrectlyInitialized()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection("Section 1");
var failureMechanism = new TestNonAdoptableWithProfileProbabilityFailureMechanism();
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
section
});
var sectionAssemblyResult = new FailureMechanismSectionAssemblyResultWrapper(
new FailureMechanismSectionAssemblyResult(0.01, 0.1, 10, FailureMechanismSectionAssemblyGroup.I),
AssemblyMethod.BOI0A1, AssemblyMethod.BOI0B1);
// Call
using (new AssemblyToolCalculatorFactoryConfig())
using (ShowFailureMechanismResultsView(failureMechanism, sr => sectionAssemblyResult))
{
DataGridView dataGridView = GetDataGridView();
// Assert
DataGridViewRowCollection rows = dataGridView.Rows;
Assert.AreEqual(1, rows.Count);
DataGridViewCellCollection cells = rows[0].Cells;
Assert.AreEqual(columnCount, cells.Count);
Assert.AreEqual("Section 1", cells[nameColumnIndex].FormattedValue);
Assert.AreEqual(true, cells[isRelevantIndex].Value);
Assert.AreEqual(NonAdoptableInitialFailureMechanismResultType.Manual, cells[initialFailureMechanismResultTypeIndex].Value);
Assert.AreEqual("-", cells[initialFailureMechanismResultProfileProbabilityIndex].FormattedValue);
Assert.AreEqual("-", cells[initialFailureMechanismResultSectionProbabilityIndex].FormattedValue);
Assert.AreEqual(FailureMechanismSectionResultFurtherAnalysisType.NotNecessary, cells[furtherAnalysisTypeIndex].Value);
Assert.AreEqual("-", cells[refinedProfileProbabilityIndex].FormattedValue);
Assert.AreEqual("-", cells[refinedSectionProbabilityIndex].FormattedValue);
Assert.AreEqual("1/100", cells[profileProbabilityIndex].FormattedValue);
Assert.AreEqual("1/10", cells[sectionProbabilityIndex].FormattedValue);
Assert.AreEqual("10,00", cells[sectionNIndex].FormattedValue);
Assert.AreEqual("+I", cells[assemblyGroupIndex].FormattedValue);
}
}
public void AssembleSection_CalculatorRan_ReturnsExpectedOutput()
{
// Setup
var failureMechanism = new TestCalculatableFailureMechanism();
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var sectionResult = new AdoptableFailureMechanismSectionResult(section);
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
FailureMechanismSectionAssemblyResultWrapper result = StructuresFailureMechanismAssemblyFactory.AssembleSection <TestStructuresInput>(
sectionResult, failureMechanism, assessmentSection);
// Assert
Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput, result);
}
}
public void AssembleSection_CalculatorRan_ReturnsExpectedOutput()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section);
var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
// Call
FailureMechanismSectionAssemblyResultWrapper result = GrassCoverErosionOutwardsFailureMechanismAssemblyFactory.AssembleSection(
sectionResult, failureMechanism, assessmentSection);
// Assert
Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput, result);
}
}
public void CreateExportableFailureMechanism_WithValidData_ReturnsExportableFailureMechanism()
{
// Setup
var random = new Random(21);
var failureMechanism = new TestFailureMechanism();
FailureMechanismTestHelper.AddSections(failureMechanism, random.Next(2, 10));
var assessmentSection = new AssessmentSectionStub();
double probability = random.NextDouble();
var assemblyMethod = random.NextEnumValue <AssemblyMethod>();
FailureMechanismSectionAssemblyResultWrapper expectedSectionOutput = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create();
var failureMechanismType = random.NextEnumValue <ExportableFailureMechanismType>();
// Call
ExportableFailureMechanism exportableFailureMechanism =
ExportableFailureMechanismFactory.CreateExportableFailureMechanism <TestFailureMechanism, TestFailureMechanismSectionResult>(
failureMechanism, assessmentSection, (fm, section) => new FailureMechanismAssemblyResultWrapper(probability, assemblyMethod),
(sr, fm, section) => expectedSectionOutput, failureMechanismType);
// Assert
Assert.AreEqual(failureMechanismType, exportableFailureMechanism.FailureMechanismType);
Assert.AreEqual(failureMechanism.Code, exportableFailureMechanism.Code);
ExportableFailureMechanismAssemblyResult exportableFailureMechanismAssembly = exportableFailureMechanism.FailureMechanismAssembly;
Assert.AreEqual(probability, exportableFailureMechanismAssembly.Probability);
Assert.AreEqual(ExportableAssemblyMethodFactory.Create(assemblyMethod), exportableFailureMechanismAssembly.AssemblyMethod);
IEnumerable <ExportableFailureMechanismSection> exportableFailureMechanismSections = exportableFailureMechanism.SectionAssemblyResults
.Select(sar => sar.FailureMechanismSection);
ExportableFailureMechanismSectionTestHelper.AssertExportableFailureMechanismSections(failureMechanism.Sections, exportableFailureMechanismSections);
ExportableFailureMechanismSectionAssemblyResultTestHelper.AssertExportableFailureMechanismSectionResults(
expectedSectionOutput, exportableFailureMechanismSections, exportableFailureMechanism.SectionAssemblyResults);
}
/// <summary>
/// Asserts a collection of <see cref="ExportableFailureMechanismSectionAssemblyWithProbabilityResult"/>
/// against the assembly result.
/// </summary>
/// <param name="expectedAssemblyResultWrapper">The expected <see cref="FailureMechanismSectionAssemblyResultWrapper"/>.</param>
/// <param name="sections">The actual exportable sections.</param>
/// <param name="results">The actual exportable assembly results.</param>
/// <exception cref="AssertionException">Thrown when:
/// <list type="bullet">
/// <item>The number of <paramref name="sections"/> and number of <paramref name="results"/> do not match.</item>
/// <item>The values between <paramref name="expectedAssemblyResultWrapper"/> and <paramref name="results"/>
/// do not match.</item>
/// </list></exception>
public static void AssertExportableFailureMechanismSectionResults(FailureMechanismSectionAssemblyResultWrapper expectedAssemblyResultWrapper,
IEnumerable <ExportableFailureMechanismSection> sections,
IEnumerable <ExportableFailureMechanismSectionAssemblyWithProbabilityResult> results)
{
int expectedNrOfResults = sections.Count();
Assert.AreEqual(expectedNrOfResults, results.Count());
for (var i = 0; i < expectedNrOfResults; i++)
{
ExportableFailureMechanismSection section = sections.ElementAt(i);
ExportableFailureMechanismSectionAssemblyWithProbabilityResult actualExportableAssemblyResult = results.ElementAt(i);
Assert.AreSame(section, actualExportableAssemblyResult.FailureMechanismSection);
FailureMechanismSectionAssemblyResult expectedAssemblyResult = expectedAssemblyResultWrapper.AssemblyResult;
Assert.AreEqual(expectedAssemblyResult.FailureMechanismSectionAssemblyGroup, actualExportableAssemblyResult.AssemblyGroup);
Assert.AreEqual(expectedAssemblyResult.SectionProbability, actualExportableAssemblyResult.Probability);
Assert.AreEqual(ExportableAssemblyMethodFactory.Create(expectedAssemblyResultWrapper.AssemblyGroupMethod),
actualExportableAssemblyResult.AssemblyGroupAssemblyMethod);
Assert.AreEqual(ExportableAssemblyMethodFactory.Create(expectedAssemblyResultWrapper.ProbabilityMethod),
actualExportableAssemblyResult.ProbabilityAssemblyMethod);
}
}
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);
}
}
