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