public void DetailedAssessmentDirectFailureMechanismsFromProbabilityWithNValueReturnsCorrectResult(double probability, double nValue, FailureMechanismSectionCategoryGroup expectedCategoryGroup, double expectedProbabilityWithoutNMultiplication)
{
var categories = new[]
{
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.Iv, (Probability)0, (Probability)0.1),
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.IIv, (Probability)0.1, (Probability)0.2),
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.IIIv, (Probability)0.2, (Probability)0.3),
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.IVv, (Probability)0.3, (Probability)0.4),
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.Vv, (Probability)0.4, (Probability)0.5),
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.VIv, (Probability)0.5, (Probability)1),
};
var input = new DetailedCalculationInputFromProbabilityWithLengthEffect((Probability)probability, categories, nValue);
var calculationOutput = new FailureMechanismSectionAssemblyCalculator().DetailedAssessmentDirectFailureMechanisms(input);
Assert.IsNotNull(calculationOutput);
var expectedProbability = expectedProbabilityWithoutNMultiplication * nValue;
if (expectedProbability > 1)
{
Assert.AreEqual(1, calculationOutput.WarningMessages.Length);
Assert.AreEqual(WarningMessage.CorrectedProbability, calculationOutput.WarningMessages[0]);
}
else
{
Assert.IsEmpty(calculationOutput.WarningMessages);
}
Assert.IsNotNull(calculationOutput.Result);
Assert.AreEqual(expectedCategoryGroup, calculationOutput.Result.CategoryGroup);
Assert.AreEqual(Math.Min(1, expectedProbability), calculationOutput.Result.EstimatedProbabilityOfFailure);
}
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 TailorMadeAssessmentDirectFailureMechanismsFromProbabilityWithNValueReturnsCorrectCategoryFromProbability(double probabilityValue, FailureMechanismSectionCategoryGroup expectedCategoryGroup)
{
var categories = new[]
{
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.Iv, (Probability)0, (Probability)0.1),
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.IIv, (Probability)0.1, (Probability)0.2),
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.IIIv, (Probability)0.2, (Probability)0.3),
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.IVv, (Probability)0.3, (Probability)0.4),
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.Vv, (Probability)0.4, (Probability)0.5),
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.VIv, (Probability)0.5, (Probability)1),
};
var probability = (Probability)probabilityValue;
var result = new TailorMadeProbabilityCalculationResult(probability);
const double nValue = 1.234;
var input = new TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(result, categories, nValue);
var calculationOutput = new FailureMechanismSectionAssemblyCalculator().TailorMadeAssessmentDirectFailureMechanisms(input);
Assert.IsNotNull(calculationOutput);
var expectedProbability = probabilityValue * nValue;
if (expectedProbability > 1)
{
Assert.AreEqual(1, calculationOutput.WarningMessages.Length);
Assert.AreEqual(WarningMessage.CorrectedProbability, calculationOutput.WarningMessages[0]);
}
else
{
Assert.IsEmpty(calculationOutput.WarningMessages);
}
Assert.IsNotNull(calculationOutput.Result);
Assert.AreEqual(expectedCategoryGroup, calculationOutput.Result.CategoryGroup);
Assert.AreEqual(Math.Min(expectedProbability, 1.0), calculationOutput.Result.EstimatedProbabilityOfFailure);
}
public void AssembleFailureMechanismSection_WithValidInputAndProbabilityDefined_InputCorrectlySentToKernel(
FailureMechanismSectionAssemblyInput 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.SectionProbability = 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.InitialSectionProbability, failureMechanismSectionAssemblyKernel.ProbabilityInitialMechanismSection);
Assert.AreEqual(input.RefinedSectionProbability, failureMechanismSectionAssemblyKernel.RefinedProbabilitySection);
Assert.AreEqual(sectionProbability, failureMechanismSectionAssemblyKernel.SectionProbabilityInput);
}
}
public void TailorMadeAssessmentDirectFailureMechanismsFromCategoryResultReturnsCorrectCategory(TailorMadeCategoryCalculationResult result, FailureMechanismSectionCategoryGroup expectedCategoryGroup)
{
var calculationOutput = new FailureMechanismSectionAssemblyCalculator().TailorMadeAssessmentDirectFailureMechanisms(result);
Assert.IsNotNull(calculationOutput);
Assert.IsEmpty(calculationOutput.WarningMessages);
Assert.AreEqual(expectedCategoryGroup, calculationOutput.Result);
}
public void DetailedAssessmentDirectFailureMechanismsFromResultTranslatesResultCorrectly(DetailedCalculationResult result, FailureMechanismSectionCategoryGroup expectedCategoryGroup)
{
var calculationOutput = new FailureMechanismSectionAssemblyCalculator().DetailedAssessmentDirectFailureMechanisms(result);
Assert.IsNotNull(calculationOutput);
Assert.IsEmpty(calculationOutput.WarningMessages);
Assert.AreEqual(expectedCategoryGroup, calculationOutput.Result);
}
public void SimpleAssessmentDirectFailureMechanismsValidityOnlyResultsCorrectCategory(SimpleCalculationResultValidityOnly calculationResult, FailureMechanismSectionCategoryGroup expectedResult, double expectedProbability)
{
var calculationOutput = new FailureMechanismSectionAssemblyCalculator().SimpleAssessmentDirectFailureMechanisms(calculationResult);
Assert.IsNotNull(calculationOutput);
Assert.IsEmpty(calculationOutput.WarningMessages);
Assert.IsNotNull(calculationOutput.Result);
Assert.AreEqual(expectedResult, calculationOutput.Result.CategoryGroup);
Assert.AreEqual(expectedProbability, calculationOutput.Result.EstimatedProbabilityOfFailure);
}
public void DetailedAssessmentDirectFailureMechanismsGroupThreeReturnsCorrectCategory(DetailedCalculationResult iToII, DetailedCalculationResult iIToIII, DetailedCalculationResult iIIToIV, DetailedCalculationResult iVToV, DetailedCalculationResult vToVI, FailureMechanismSectionCategoryGroup expectedCategoryGroup)
{
var input = new DetailedCategoryBoundariesCalculationResult(iToII, iIToIII, iIIToIV, iVToV, vToVI);
var calculationOutput = new FailureMechanismSectionAssemblyCalculator().DetailedAssessmentDirectFailureMechanisms(input);
Assert.IsNotNull(calculationOutput);
Assert.IsEmpty(calculationOutput.WarningMessages);
Assert.IsNotNull(calculationOutput.Result);
Assert.AreEqual(expectedCategoryGroup, calculationOutput.Result);
}
public void CombinedAssessmentFromFailureMechanismSectionResultsSelectsCorrectResult(
FailureMechanismSectionCategoryGroup simpleAssessmentResult,
FailureMechanismSectionCategoryGroup detailedAssessmentResult,
FailureMechanismSectionCategoryGroup tailorMadeAssessmentResult,
FailureMechanismSectionCategoryGroup expectedCategoryGroup)
{
var calculationOutput = new FailureMechanismSectionAssemblyCalculator().CombinedAssessmentFromFailureMechanismSectionResults(simpleAssessmentResult, detailedAssessmentResult, tailorMadeAssessmentResult);
Assert.IsNotNull(calculationOutput);
Assert.IsEmpty(calculationOutput.WarningMessages);
Assert.AreEqual(expectedCategoryGroup, calculationOutput.Result);
}
public void Constructor_ExpectedValues()
{
// Setup
var mocks = new MockRepository();
var kernelFactory = mocks.Stub <IAssemblyToolKernelFactory>();
mocks.ReplayAll();
// Call
var calculator = new FailureMechanismSectionAssemblyCalculator(kernelFactory);
// Assert
Assert.IsInstanceOf <IFailureMechanismSectionAssemblyCalculator>(calculator);
mocks.VerifyAll();
}
public void TailorMadeAssessmentDirectFailureMechanismsFromProbabilityWithNValueReturnsCorrectCategoryNoProbability(TailorMadeProbabilityCalculationResultGroup resultGroup, FailureMechanismSectionCategoryGroup expectedCategoryGroup, double expectedProbability)
{
var input = new TailorMadeCalculationInputFromProbabilityWithLengthEffectFactor(
new TailorMadeProbabilityCalculationResult(resultGroup),
new[]
{
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.Iv, (Probability)0, (Probability)1)
}, 1.234);
var calculationOutput = new FailureMechanismSectionAssemblyCalculator().TailorMadeAssessmentDirectFailureMechanisms(input);
Assert.IsNotNull(calculationOutput);
Assert.IsEmpty(calculationOutput.WarningMessages);
Assert.IsNotNull(calculationOutput.Result);
Assert.AreEqual(expectedCategoryGroup, calculationOutput.Result.CategoryGroup);
Assert.AreEqual(expectedProbability, calculationOutput.Result.EstimatedProbabilityOfFailure);
}
public void AssembleFailureMechanismSection_InputNull_ThrowsArgumentNullException()
{
// Setup
var mocks = new MockRepository();
var kernelFactory = mocks.Stub <IAssemblyToolKernelFactory>();
mocks.ReplayAll();
var calculator = new FailureMechanismSectionAssemblyCalculator(kernelFactory);
// Call
void Call() => calculator.AssembleFailureMechanismSection((FailureMechanismSectionAssemblyInput)null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("input", exception.ParamName);
}
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 DetailedAssessmentDirectFailureMechanismsFromProbabilitySelectsCorrectCategory(double probability, FailureMechanismSectionCategoryGroup expectedCategoryGroup, double expectedProbability)
{
var categories = new[]
{
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.Iv, (Probability)0, (Probability)0.1),
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.IIv, (Probability)0.1, (Probability)0.2),
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.IIIv, (Probability)0.2, (Probability)0.3),
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.IVv, (Probability)0.3, (Probability)0.4),
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.Vv, (Probability)0.4, (Probability)0.5),
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.VIv, (Probability)0.5, (Probability)1),
};
var input = new DetailedCalculationInputFromProbability((Probability)probability, categories);
var calculationOutput = new FailureMechanismSectionAssemblyCalculator().DetailedAssessmentDirectFailureMechanisms(input);
Assert.IsNotNull(calculationOutput);
Assert.IsEmpty(calculationOutput.WarningMessages);
Assert.IsNotNull(calculationOutput.Result);
Assert.AreEqual(expectedCategoryGroup, calculationOutput.Result.CategoryGroup);
Assert.AreEqual(expectedProbability, calculationOutput.Result.EstimatedProbabilityOfFailure);
}
public void TailorMadeAssessmentDirectFailureMechanismsFromProbabilityReturnsCorrectCategoryFromProbability(double probabilityValue, FailureMechanismSectionCategoryGroup expectedCategoryGroup)
{
var categories = new[]
{
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.Iv, (Probability)0, (Probability)0.1),
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.IIv, (Probability)0.1, (Probability)0.2),
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.IIIv, (Probability)0.2, (Probability)0.3),
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.IVv, (Probability)0.3, (Probability)0.4),
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.Vv, (Probability)0.4, (Probability)0.5),
new FailureMechanismSectionCategory(FailureMechanismSectionCategoryGroup.VIv, (Probability)0.5, (Probability)1),
};
var probability = (Probability)probabilityValue;
var result = new TailorMadeProbabilityCalculationResult(probability);
var input = new TailorMadeCalculationInputFromProbability(result, categories);
var calculationOutput = new FailureMechanismSectionAssemblyCalculator().TailorMadeAssessmentDirectFailureMechanisms(input);
Assert.IsNotNull(calculationOutput);
Assert.IsEmpty(calculationOutput.WarningMessages);
Assert.IsNotNull(calculationOutput.Result);
Assert.AreEqual(expectedCategoryGroup, calculationOutput.Result.CategoryGroup);
Assert.AreEqual(probability, calculationOutput.Result.EstimatedProbabilityOfFailure);
}
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 CombinedAssessmentFromFailureMechanismSectionResultsWithProbabilitiesSelectsCorrectResult(
FailureMechanismSectionCategoryGroup simpleAssessmentResult,
double simpleAssessmentProbabilityValue,
FailureMechanismSectionCategoryGroup detailedAssessmentResult,
double detailedAssessmentProbabilityValue,
FailureMechanismSectionCategoryGroup tailorMadeAssessmentResult,
double tailorMadeAssessmentProbabilityValue,
FailureMechanismSectionCategoryGroup expectedCategoryGroup,
double expectedProbabilityValue)
{
var calculationOutput =
new FailureMechanismSectionAssemblyCalculator().CombinedAssessmentFromFailureMechanismSectionResults(
new FailureMechanismSectionAssemblyCategoryResult(simpleAssessmentResult,
(Probability)simpleAssessmentProbabilityValue),
new FailureMechanismSectionAssemblyCategoryResult(detailedAssessmentResult,
(Probability)detailedAssessmentProbabilityValue),
new FailureMechanismSectionAssemblyCategoryResult(tailorMadeAssessmentResult,
(Probability)tailorMadeAssessmentProbabilityValue));
Assert.IsNotNull(calculationOutput);
Assert.IsEmpty(calculationOutput.WarningMessages);
Assert.AreEqual(expectedCategoryGroup, calculationOutput.Result.CategoryGroup);
Assert.AreEqual(expectedProbabilityValue, calculationOutput.Result.EstimatedProbabilityOfFailure);
}
public void AssembleFailureMechanismSection_KernelThrowsException_ThrowsFailureMechanismSectionAssemblyCalculatorException()
{
// Setup
FailureMechanismSectionAssemblyInput input = CreateFailureMechanismSectionAssemblyInput();
using (new AssemblyToolKernelFactoryConfig())
{
var factory = (TestAssemblyToolKernelFactory)AssemblyToolKernelFactory.Instance;
FailureMechanismSectionAssemblyKernelStub failureMechanismSectionAssemblyKernel = factory.LastCreatedFailureMechanismSectionAssemblyKernel;
failureMechanismSectionAssemblyKernel.ThrowExceptionOnCalculate = true;
var calculator = new FailureMechanismSectionAssemblyCalculator(factory);
// Call
void Call() => calculator.AssembleFailureMechanismSection(input);
// Assert
var exception = Assert.Throws <FailureMechanismSectionAssemblyCalculatorException>(Call);
Assert.IsInstanceOf <Exception>(exception.InnerException);
Assert.AreEqual(AssemblyErrorMessageCreator.CreateGenericErrorMessage(), exception.Message);
Assert.IsFalse(failureMechanismSectionAssemblyKernel.Calculated);
}
}
public void AssembleFailureMechanismSection_WithValidInputAndNoProbabilityDefined_InputCorrectlySentToKernel(
FailureMechanismSectionAssemblyInput 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);
}
}
