/// <summary>
/// Asserts whether <paramref name="actual"/> is equal to
/// <paramref name="failureMechanismResults"/> and <paramref name="combinedResults"/>.
/// </summary>
/// <param name="failureMechanismResults">The original <see cref="IEnumerable{T}"/> of <see cref="FailureMechanismSectionList"/>.</param>
/// <param name="combinedResults">The original <see cref="IEnumerable{T}"/> of <see cref="FailureMechanismSectionWithCategory"/>.</param>
/// <param name="actual">The actual collection of <see cref="CombinedFailureMechanismSectionAssembly"/>.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="actual"/> is not equal to
/// <paramref name="failureMechanismResults"/> and <paramref name="combinedResults"/>.</exception>
public static void AssertAssembly(IEnumerable <FailureMechanismSectionList> failureMechanismResults,
IEnumerable <FailureMechanismSectionWithCategory> combinedResults,
IEnumerable <CombinedFailureMechanismSectionAssembly> actual)
{
Assert.AreEqual(combinedResults.Count(), actual.Count());
for (var i = 0; i < combinedResults.Count(); i++)
{
FailureMechanismSectionWithCategory combinedResult = combinedResults.ElementAt(i);
CombinedFailureMechanismSectionAssembly actualCombinedFailureMechanismSectionAssembly = actual.ElementAt(i);
Assert.AreEqual(combinedResult.Start, actualCombinedFailureMechanismSectionAssembly.Section.SectionStart);
Assert.AreEqual(combinedResult.End, actualCombinedFailureMechanismSectionAssembly.Section.SectionEnd);
Assert.AreEqual(FailureMechanismSectionAssemblyGroupConverter.ConvertTo(combinedResult.Category),
actualCombinedFailureMechanismSectionAssembly.Section.FailureMechanismSectionAssemblyGroup);
Assert.AreEqual(failureMechanismResults.Count(), actualCombinedFailureMechanismSectionAssembly.FailureMechanismSectionAssemblyGroupResults.Count());
for (var j = 0; j < failureMechanismResults.Count(); j++)
{
FailureMechanismSectionAssemblyGroup expectedGroup = FailureMechanismSectionAssemblyGroupConverter.ConvertTo(
((FailureMechanismSectionWithCategory)failureMechanismResults.ElementAt(j).Sections.ElementAt(i)).Category);
Assert.AreEqual(expectedGroup, actualCombinedFailureMechanismSectionAssembly.FailureMechanismSectionAssemblyGroupResults.ElementAt(j));
}
}
}
public void CreateForResultWithProfileAndSectionProbabilities_WithValidResult_ReturnsExpectedFailureMechanismSectionAssembly()
{
// Setup
var random = new Random(21);
double profileProbability = random.NextDouble(0.0001, 0.001);
double sectionProbability = random.NextDouble(0.0, 0.01);
EInterpretationCategory category = random.NextEnumValue(new[]
{
EInterpretationCategory.III,
EInterpretationCategory.II,
EInterpretationCategory.I,
EInterpretationCategory.Zero,
EInterpretationCategory.IMin,
EInterpretationCategory.IIMin,
EInterpretationCategory.IIIMin
});
var result = new ResultWithProfileAndSectionProbabilities(
new Probability(profileProbability), new Probability(sectionProbability));
// Call
FailureMechanismSectionAssemblyResult createdAssemblyResult = FailureMechanismSectionAssemblyResultCreator.Create(result, category);
// Assert
Assert.AreEqual(profileProbability, createdAssemblyResult.ProfileProbability);
Assert.AreEqual(sectionProbability, createdAssemblyResult.SectionProbability);
Assert.AreEqual(result.LengthEffectFactor, createdAssemblyResult.N);
Assert.AreEqual(FailureMechanismSectionAssemblyGroupConverter.ConvertTo(category),
createdAssemblyResult.FailureMechanismSectionAssemblyGroup);
}
public void ConvertFrom_ValidAssemblyGroup_ReturnsExpectedValue(FailureMechanismSectionAssemblyGroup assemblyGroup, EInterpretationCategory expectedInterpretationCategory)
{
// Call
EInterpretationCategory convertedInterpretationCategory = FailureMechanismSectionAssemblyGroupConverter.ConvertFrom(assemblyGroup);
// Assert
Assert.AreEqual(expectedInterpretationCategory, convertedInterpretationCategory);
}
public void ConvertTo_ValidInterpretationCategory_ReturnsExpectedValue(EInterpretationCategory interpretationCategory, FailureMechanismSectionAssemblyGroup expectedAssemblyGroup)
{
// Call
FailureMechanismSectionAssemblyGroup convertedAssemblyGroup = FailureMechanismSectionAssemblyGroupConverter.ConvertTo(interpretationCategory);
// Assert
Assert.AreEqual(expectedAssemblyGroup, convertedAssemblyGroup);
}
private static void AssertSections(IEnumerable <CombinedAssemblyFailureMechanismSection> originalSections, IEnumerable <FailureMechanismSection> failureMechanismSections)
{
Assert.AreEqual(originalSections.Count(), failureMechanismSections.Count());
Assert.IsTrue(failureMechanismSections.All(fms => fms.GetType() == typeof(FailureMechanismSectionWithCategory)));
CollectionAssert.AreEqual(originalSections.Select(s => s.SectionStart), failureMechanismSections.Select(r => r.Start));
CollectionAssert.AreEqual(originalSections.Select(s => s.SectionEnd), failureMechanismSections.Select(r => r.End));
CollectionAssert.AreEqual(originalSections.Select(s => FailureMechanismSectionAssemblyGroupConverter.ConvertFrom(s.FailureMechanismSectionAssemblyGroup)),
failureMechanismSections.Select(fms => fms)
.Cast <FailureMechanismSectionWithCategory>()
.Select(c => c.Category));
}
public void ConvertFrom_InvalidAssemblyGroup_ThrowsInvalidEnumArgumentException()
{
// Setup
const FailureMechanismSectionAssemblyGroup assemblyGroup = (FailureMechanismSectionAssemblyGroup)99;
// Call
void Call() => FailureMechanismSectionAssemblyGroupConverter.ConvertFrom(assemblyGroup);
// Assert
var expectedMessage = $"The value of argument 'assemblyGroup' ({assemblyGroup}) is invalid for Enum type '{nameof(FailureMechanismSectionAssemblyGroup)}'.";
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <InvalidEnumArgumentException>(Call, expectedMessage);
}
public void ConvertTo_InvalidInterpretationCategory_ThrowsInvalidEnumArgumentException()
{
// Setup
const EInterpretationCategory interpretationCategory = (EInterpretationCategory)99;
// Call
void Call() => FailureMechanismSectionAssemblyGroupConverter.ConvertTo(interpretationCategory);
// Assert
var expectedMessage = $"The value of argument 'interpretationCategory' ({interpretationCategory}) is invalid for Enum type '{nameof(EInterpretationCategory)}'.";
TestHelper.AssertThrowsArgumentExceptionAndTestMessage <InvalidEnumArgumentException>(Call, expectedMessage);
}
public void CreateForProbabilityAndCategory_WithValidData_ReturnsExpectedFailureMechanismSectionAssembly()
{
// Setup
var random = new Random(21);
double sectionProbability = random.NextDouble();
var category = random.NextEnumValue <EInterpretationCategory>();
// Call
FailureMechanismSectionAssemblyResult result = FailureMechanismSectionAssemblyResultCreator.Create(
new Probability(sectionProbability), category);
// Assert
Assert.AreEqual(sectionProbability, result.ProfileProbability);
Assert.AreEqual(sectionProbability, result.SectionProbability);
Assert.AreEqual(1.0, result.N);
Assert.AreEqual(FailureMechanismSectionAssemblyGroupConverter.ConvertTo(category),
result.FailureMechanismSectionAssemblyGroup);
}
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_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);
}
}
