/// <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); } }