public void ScenarioConfigurationTypeIsSemiProbabilistic_VariousConfigurations_ReturnsExpectedResult( PipingFailureMechanism failureMechanism, PipingScenarioConfigurationPerFailureMechanismSectionType configurationType, bool expectedResult) { // Setup FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); failureMechanism.SetSections(new[] { section }, "APath"); PipingScenarioConfigurationPerFailureMechanismSection scenarioConfigurationPerFailureMechanismSection = failureMechanism.ScenarioConfigurationsPerFailureMechanismSection.Single(); scenarioConfigurationPerFailureMechanismSection.ScenarioConfigurationType = configurationType; // Call bool isSemiProbabilistic = failureMechanism.ScenarioConfigurationTypeIsSemiProbabilistic(scenarioConfigurationPerFailureMechanismSection); // Assert Assert.AreEqual(expectedResult, isSemiProbabilistic); }
public void Constructor_ConstructionPropertiesNull_ThrowsArgumentNullException() { // Setup var mocks = new MockRepository(); var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>(); mocks.ReplayAll(); Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create; FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var result = new AdoptableFailureMechanismSectionResult(section); // Call void Call() => new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider, performAssemblyFunc, null); // Assert var exception = Assert.Throws <ArgumentNullException>(Call); Assert.AreEqual("constructionProperties", exception.ParamName); mocks.VerifyAll(); }
public void Constructor_ExpectedValues() { // Setup var random = new Random(21); var failureMechanism = new TestCalculatableFailureMechanism(); failureMechanism.SetSections(new[] { FailureMechanismSectionTestFactory.CreateFailureMechanismSection() }, string.Empty); var assemblyResult = new FailureMechanismSectionAssemblyResult( random.NextDouble(), random.NextDouble(), random.NextDouble(), random.NextEnumValue <FailureMechanismSectionAssemblyGroup>()); // Call using (var mapLayer = new CalculatableFailureMechanismSectionResultsMapLayer <TestCalculatableFailureMechanism, TestFailureMechanismSectionResult, TestCalculationInput>( failureMechanism, result => assemblyResult)) { // Assert Assert.IsInstanceOf <NonCalculatableFailureMechanismSectionResultsMapLayer <TestFailureMechanismSectionResult> >(mapLayer); } }
public void GivenRowWithFurtherAnalysisNotExecuted_WhenErrorProviderReturnsError_ThenShowsNoError(FailureMechanismSectionResultFurtherAnalysisType furtherAnalysisType) { // Given var random = new Random(21); double profileProbability = random.NextDouble(); double sectionProbability = profileProbability + 0.1; var mocks = new MockRepository(); var errorProvider = mocks.StrictMock <IFailureMechanismSectionResultRowErrorProvider>(); errorProvider.Stub(ep => ep.GetManualProbabilityValidationError(double.NaN)) .IgnoreArguments() .Return("error"); mocks.ReplayAll(); FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var result = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(section) { InitialFailureMechanismResultType = NonAdoptableInitialFailureMechanismResultType.NoFailureProbability, FurtherAnalysisType = furtherAnalysisType, RefinedProfileProbability = profileProbability, RefinedSectionProbability = sectionProbability }; Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create; // When var row = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResultRow(result, errorProvider, performAssemblyFunc, ConstructionProperties); // Then IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions; Assert.IsEmpty(columnStateDefinitions[ConstructionProperties.RefinedProfileProbabilityIndex].ErrorText); Assert.IsEmpty(columnStateDefinitions[ConstructionProperties.RefinedSectionProbabilityIndex].ErrorText); mocks.VerifyAll(); }
public void UpdateSectionsWithImportedData_WithEmptyData_ClearsSectionsAndUpdatesPathAndReturnsAffectedObjects() { // Setup const string oldSourcePath = "old/path"; string sourcePath = TestHelper.GetScratchPadPath(); var failureMechanism = new TestFailureMechanism(); failureMechanism.SetSections(new[] { FailureMechanismSectionTestFactory.CreateFailureMechanismSection() }, oldSourcePath); var sectionResultUpdateStrategy = new TestUpdateFailureMechanismSectionResultUpdateStrategy(); var failureMechanismSectionUpdateStrategy = new FailureMechanismSectionUpdateStrategy <FailureMechanismSectionResult>( failureMechanism, sectionResultUpdateStrategy); // Precondition IEnumerable <FailureMechanismSection> failureMechanismSections = failureMechanism.Sections; Assert.AreEqual(1, failureMechanismSections.Count()); Assert.AreEqual(oldSourcePath, failureMechanism.FailureMechanismSectionSourcePath); // Call IEnumerable <IObservable> affectedObjects = failureMechanismSectionUpdateStrategy.UpdateSectionsWithImportedData( Enumerable.Empty <FailureMechanismSection>(), sourcePath); // Assert Assert.AreEqual(sourcePath, failureMechanism.FailureMechanismSectionSourcePath); Assert.IsEmpty(failureMechanismSections); Assert.IsFalse(sectionResultUpdateStrategy.Update); CollectionAssert.AreEqual(new IObservable[] { failureMechanism, failureMechanism.SectionResults }, affectedObjects); }
public void GivenScenarioRow_WhenOutputChangedAndUpdate_ThenDerivedOutputUpdated() { // Given var calculation = new MacroStabilityInwardsCalculationScenario { Output = MacroStabilityInwardsOutputTestFactory.CreateRandomOutput() }; var failureMechanism = new MacroStabilityInwardsFailureMechanism(); FailureMechanismSection failureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var row = new MacroStabilityInwardsScenarioRow(calculation, failureMechanism, failureMechanismSection); // Precondition DerivedMacroStabilityInwardsOutput expectedDerivedOutput = DerivedMacroStabilityInwardsOutputFactory.Create(calculation.Output, failureMechanism.GeneralInput.ModelFactor); Assert.AreEqual(expectedDerivedOutput.MacroStabilityInwardsProbability, row.FailureProbability); Assert.AreEqual(expectedDerivedOutput.MacroStabilityInwardsProbability * failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.GetN( failureMechanismSection.Length), row.SectionFailureProbability); var random = new Random(11); // When calculation.Output = MacroStabilityInwardsOutputTestFactory.CreateOutput(new MacroStabilityInwardsOutput.ConstructionProperties { FactorOfStability = random.NextDouble() }); row.Update(); // Then DerivedMacroStabilityInwardsOutput newExpectedDerivedOutput = DerivedMacroStabilityInwardsOutputFactory.Create(calculation.Output, failureMechanism.GeneralInput.ModelFactor); Assert.AreEqual(newExpectedDerivedOutput.MacroStabilityInwardsProbability, row.FailureProbability); Assert.AreEqual(newExpectedDerivedOutput.MacroStabilityInwardsProbability * failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.GetN( failureMechanismSection.Length), row.SectionFailureProbability); }
public void GetRelevantCalculationScenarios_WithoutScenarioIntersectingSection_ReturnsNoCalculationScenarios() { // Setup var mocks = new MockRepository(); var calculationScenarioStub1 = mocks.Stub <ICalculationScenario>(); var calculationScenarioStub2 = mocks.Stub <ICalculationScenario>(); mocks.ReplayAll(); calculationScenarioStub1.IsRelevant = true; calculationScenarioStub2.IsRelevant = false; var calculationScenario1 = new TestCalculationScenario(); var calculationScenario2 = new TestCalculationScenario { IsRelevant = false }; ICalculationScenario[] calculationScenarios = { calculationScenarioStub1, calculationScenarioStub2, calculationScenario1, calculationScenario2 }; FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var sectionResult = new TestFailureMechanismSectionResult(section); // Call IEnumerable <ICalculationScenario> relevantScenarios = sectionResult.GetRelevantCalculationScenarios <TestCalculationScenario>( calculationScenarios, (scenario, segments) => false); // Assert CollectionAssert.IsEmpty(relevantScenarios); mocks.VerifyAll(); }
public void GetRelevantCalculationScenarios_WithRelevantAndIrrelevantScenariosOfDifferentTypes_ReturnsRelevantCalculationScenarios() { // Setup var mocks = new MockRepository(); var calculationScenarioStub1 = mocks.Stub <ICalculationScenario>(); var calculationScenarioStub2 = mocks.Stub <ICalculationScenario>(); mocks.ReplayAll(); calculationScenarioStub1.IsRelevant = true; calculationScenarioStub2.IsRelevant = false; var calculationScenario1 = new TestCalculationScenario(); var calculationScenario2 = new TestCalculationScenario { IsRelevant = false }; ICalculationScenario[] calculationScenarios = { calculationScenarioStub1, calculationScenarioStub2, calculationScenario1, calculationScenario2 }; FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var sectionResult = new TestFailureMechanismSectionResult(section); // Call IEnumerable <ICalculationScenario> relevantScenarios = sectionResult.GetRelevantCalculationScenarios <TestCalculationScenario>( calculationScenarios, (scenario, segments) => true); // Assert Assert.AreEqual(calculationScenario1, relevantScenarios.Single()); mocks.VerifyAll(); }
public void GivenRowWithFurtherAnalysisTypeExecuted_WhenErrorProviderReturnsError_ThenShowsError() { // Given var random = new Random(21); double sectionProbability = random.NextDouble(); const string errorText = "error"; var mocks = new MockRepository(); var errorProvider = mocks.StrictMock <IFailureMechanismSectionResultRowWithCalculatedProbabilityErrorProvider>(); errorProvider.Stub(ep => ep.GetCalculatedProbabilityValidationError(null)) .IgnoreArguments() .Return(string.Empty); errorProvider.Expect(ep => ep.GetManualProbabilityValidationError(sectionProbability)) .Return(errorText); mocks.ReplayAll(); FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var result = new AdoptableFailureMechanismSectionResult(section) { FurtherAnalysisType = FailureMechanismSectionResultFurtherAnalysisType.Executed, RefinedSectionProbability = sectionProbability }; Func <FailureMechanismSectionAssemblyResultWrapper> performAssemblyFunc = FailureMechanismSectionAssemblyResultWrapperTestFactory.Create; // When var row = new AdoptableFailureMechanismSectionResultRow(result, () => double.NaN, errorProvider, performAssemblyFunc, ConstructionProperties); // Then IDictionary <int, DataGridViewColumnStateDefinition> columnStateDefinitions = row.ColumnStateDefinitions; Assert.AreEqual(errorText, columnStateDefinitions[ConstructionProperties.RefinedSectionProbabilityIndex].ErrorText); mocks.VerifyAll(); }
public void GivenFailureMechanismWithSections_WhenUpdateSectionsWithImportedData_ThenDataUpdatedAndReturnsAffectedObjects() { // Given var failureMechanism = new PipingFailureMechanism(); var failureMechanismSectionUpdateStrategy = new PipingFailureMechanismSectionUpdateStrategy( failureMechanism, new AdoptableWithProfileProbabilityFailureMechanismSectionResultUpdateStrategy()); FailureMechanismSection[] sections = { FailureMechanismSectionTestFactory.CreateFailureMechanismSection(), FailureMechanismSectionTestFactory.CreateFailureMechanismSection(new[] { new Point2D(1, 0), new Point2D(3, 0) }) }; string sourcePath = TestHelper.GetScratchPadPath(); failureMechanism.SetSections(sections, sourcePath); failureMechanism.ScenarioConfigurationsPerFailureMechanismSection.First().ScenarioConfigurationType = PipingScenarioConfigurationPerFailureMechanismSectionType.Probabilistic; // When IEnumerable <IObservable> affectedObjects = failureMechanismSectionUpdateStrategy.UpdateSectionsWithImportedData(sections, sourcePath); // Then CollectionAssert.AreEqual(new[] { PipingScenarioConfigurationPerFailureMechanismSectionType.Probabilistic, PipingScenarioConfigurationPerFailureMechanismSectionType.SemiProbabilistic }, failureMechanism.ScenarioConfigurationsPerFailureMechanismSection.Select(sc => sc.ScenarioConfigurationType)); CollectionAssert.AreEqual(new IObservable[] { failureMechanism, failureMechanism.SectionResults, failureMechanism.ScenarioConfigurationsPerFailureMechanismSection }, affectedObjects); }
public void GivenRowWithoutAssemblyErrors_WhenUpdatingAndAssemblyThrowsException_ThenAssemblyPropertiesSetToDefault() { // Given var mocks = new MockRepository(); var errorProvider = mocks.Stub <IFailureMechanismSectionResultRowErrorProvider>(); mocks.ReplayAll(); FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var result = new NonAdoptableFailureMechanismSectionResult(section); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; var row = new NonAdoptableFailureMechanismSectionResultRow(result, errorProvider, new AssessmentSectionStub(), ConstructionProperties); // Precondition FailureMechanismSectionAssemblyResult calculatorOutput = calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult; Assert.AreEqual(calculatorOutput.SectionProbability, row.SectionProbability); Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(calculatorOutput.FailureMechanismSectionAssemblyGroup), row.AssemblyGroup); // When calculator.ThrowExceptionOnCalculate = true; row.InitialFailureMechanismResultType = NonAdoptableInitialFailureMechanismResultType.NoFailureProbability; // Then var expectedAssemblyResult = new DefaultFailureMechanismSectionAssemblyResult(); Assert.AreEqual(expectedAssemblyResult.SectionProbability, row.SectionProbability); Assert.AreEqual(EnumDisplayNameHelper.GetDisplayName(expectedAssemblyResult.FailureMechanismSectionAssemblyGroup), row.AssemblyGroup); } mocks.VerifyAll(); }
public void SemiProbabilisticGetInitialFailureMechanismResultProbability_RelevantScenarioContributionsDoNotAddUpTo1_ReturnNaN(double contributionA, double contributionB) { // Setup FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var pipingCalculationScenarioA = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section); var pipingCalculationScenarioB = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section); pipingCalculationScenarioA.Contribution = (RoundedDouble)contributionA; pipingCalculationScenarioB.Contribution = (RoundedDouble)contributionB; var result = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section); // Call double initialFailureMechanismResultProbability = result.GetInitialFailureMechanismResultProbability(new[] { pipingCalculationScenarioA, pipingCalculationScenarioB }, 0.1); // Assert Assert.IsNaN(initialFailureMechanismResultProbability); }
public void CalculateProfileProbability_MultipleScenarios_ReturnsValueBasedOnRelevantScenarios() { // Setup FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section); var calculationScenario1 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section); var calculationScenario2 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section); var calculationScenario3 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section); calculationScenario1.IsRelevant = true; calculationScenario1.Contribution = (RoundedDouble)0.2111; calculationScenario1.Output = PipingTestDataGenerator.GetSemiProbabilisticPipingOutput(1.1, 2.2, 3.3); calculationScenario2.IsRelevant = true; calculationScenario2.Contribution = (RoundedDouble)0.7889; calculationScenario2.Output = PipingTestDataGenerator.GetSemiProbabilisticPipingOutput(4.4, 5.5, 6.6); calculationScenario3.IsRelevant = false; SemiProbabilisticPipingCalculationScenario[] calculations = { calculationScenario1, calculationScenario2, calculationScenario3 }; var strategy = new SemiProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy( sectionResult, calculations, new PipingFailureMechanism(), new AssessmentSectionStub()); // Call double profileProbability = strategy.CalculateProfileProbability(); // Assert Assert.AreEqual(9.2969543564512289E-16, profileProbability); }
public void GetInitialFailureMechanismResultProbability_RelevantScenarioContributionsDoNotAddUpTo1_ReturnNaN(double contributionA, double contributionB) { // Setup FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenarioA = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenario(section); MacroStabilityInwardsCalculationScenario macroStabilityInwardsCalculationScenarioB = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenario(section); macroStabilityInwardsCalculationScenarioA.Contribution = (RoundedDouble)contributionA; macroStabilityInwardsCalculationScenarioB.Contribution = (RoundedDouble)contributionB; var result = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section); // Call double initialFailureMechanismResultProbability = result.GetInitialFailureMechanismResultProbability(new[] { macroStabilityInwardsCalculationScenarioA, macroStabilityInwardsCalculationScenarioB }, 0.1); // Assert Assert.IsNaN(initialFailureMechanismResultProbability); }
public void Constructor_ExpectedValues() { // Setup var random = new Random(21); double sectionStart = random.NextDouble(); double sectionEnd = random.NextDouble(); var probabilityAssessmentInput = new TestProbabilityAssessmentInput(0.5, 100); FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); // Call var properties = new FailureMechanismSectionProbabilityAssessmentProperties(section, sectionStart, sectionEnd, probabilityAssessmentInput); // Assert Assert.IsInstanceOf <FailureMechanismSectionProperties>(properties); Assert.AreSame(section, properties.Data); TestHelper.AssertTypeConverter <FailureMechanismSectionProbabilityAssessmentProperties, ExpandableObjectConverter>(); Assert.AreEqual(2, properties.N.NumberOfDecimalPlaces); Assert.AreEqual(1.0, properties.N, properties.N.GetAccuracy()); Assert.AreEqual(sectionStart, properties.SectionStart, properties.SectionStart.GetAccuracy()); Assert.AreEqual(sectionEnd, properties.SectionEnd, properties.SectionEnd.GetAccuracy()); }
public void UpdateSectionsWithImportedData_WithValidData_SetsSectionsToFailureMechanismAndReturnsAffectedObjects() { // Setup var failureMechanism = new TestFailureMechanism(); var failureMechanismSectionReplaceStrategy = new FailureMechanismSectionReplaceStrategy(failureMechanism); string sourcePath = TestHelper.GetScratchPadPath(); FailureMechanismSection[] sections = { FailureMechanismSectionTestFactory.CreateFailureMechanismSection() }; // Call IEnumerable <IObservable> affectedObjects = failureMechanismSectionReplaceStrategy.UpdateSectionsWithImportedData(sections, sourcePath); // Assert Assert.AreEqual(sourcePath, failureMechanism.FailureMechanismSectionSourcePath); Assert.AreEqual(sections.Single(), failureMechanism.Sections.Single()); CollectionAssert.AreEqual(new IObservable[] { failureMechanism, failureMechanism.SectionResults }, affectedObjects); }
public void CalculateProfileProbability_MultipleScenarios_ReturnsValueBasedOnRelevantScenarios() { // Setup FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section); GrassCoverErosionInwardsCalculationScenario calculationScenario1 = GrassCoverErosionInwardsCalculationScenarioTestFactory.CreateGrassCoverErosionInwardsCalculationScenario(section); GrassCoverErosionInwardsCalculationScenario calculationScenario2 = GrassCoverErosionInwardsCalculationScenarioTestFactory.CreateGrassCoverErosionInwardsCalculationScenario(section); GrassCoverErosionInwardsCalculationScenario calculationScenario3 = GrassCoverErosionInwardsCalculationScenarioTestFactory.CreateGrassCoverErosionInwardsCalculationScenario(section); calculationScenario1.IsRelevant = true; calculationScenario1.Contribution = (RoundedDouble)0.2111; calculationScenario1.Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(1.1), null, null); calculationScenario2.IsRelevant = true; calculationScenario2.Contribution = (RoundedDouble)0.7889; calculationScenario1.Output = new GrassCoverErosionInwardsOutput(new TestOvertoppingOutput(2.2), null, null); calculationScenario3.IsRelevant = false; GrassCoverErosionInwardsCalculationScenario[] calculationScenarios = { calculationScenario1, calculationScenario2, calculationScenario3 }; var strategy = new GrassCoverErosionInwardsFailureMechanismSectionResultCalculateProbabilityStrategy( sectionResult, calculationScenarios); // Call double profileProbability = strategy.CalculateProfileProbability(); // Assert Assert.AreEqual(0.3973850177700996, profileProbability); }
public void UpdateSectionsWithImportedData_WithInvalidSections_ThrowsUpdateDataException() { // Setup string sourcePath = TestHelper.GetScratchPadPath(); var failureMechanism = new TestFailureMechanism(); FailureMechanismSection failureMechanismSection1 = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(new[] { new Point2D(0.0, 0.0), new Point2D(5.0, 5.0) }); FailureMechanismSection failureMechanismSection2 = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(new[] { new Point2D(10.0, 10.0), new Point2D(15.0, 15.0) }); var sectionResultUpdateStrategy = new TestUpdateFailureMechanismSectionResultUpdateStrategy(); var failureMechanismSectionUpdateStrategy = new FailureMechanismSectionUpdateStrategy <FailureMechanismSectionResult>(failureMechanism, sectionResultUpdateStrategy); FailureMechanismSection[] sections = { failureMechanismSection1, failureMechanismSection2 }; // Call void Call() => failureMechanismSectionUpdateStrategy.UpdateSectionsWithImportedData(sections, sourcePath); // Assert var exception = Assert.Throws <UpdateDataException>(Call); Assert.IsInstanceOf <ArgumentException>(exception.InnerException); Assert.AreEqual(exception.InnerException.Message, exception.Message); Assert.IsFalse(sectionResultUpdateStrategy.Update); }
public void SemiProbabilisticGetInitialFailureMechanismResultProbability_MultipleScenarios_ReturnsValueBasedOnRelevantScenarios() { // Setup FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var failureMechanismSectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section); var pipingCalculationScenario1 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section); var pipingCalculationScenario2 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section); var pipingCalculationScenario3 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section); pipingCalculationScenario1.IsRelevant = true; pipingCalculationScenario1.Contribution = (RoundedDouble)0.2111; pipingCalculationScenario1.Output = PipingTestDataGenerator.GetSemiProbabilisticPipingOutput(1.1, 2.2, 3.3); pipingCalculationScenario2.IsRelevant = true; pipingCalculationScenario2.Contribution = (RoundedDouble)0.7889; pipingCalculationScenario2.Output = PipingTestDataGenerator.GetSemiProbabilisticPipingOutput(4.4, 5.5, 6.6); pipingCalculationScenario3.IsRelevant = false; SemiProbabilisticPipingCalculationScenario[] calculations = { pipingCalculationScenario1, pipingCalculationScenario2, pipingCalculationScenario3 }; // Call double initialFailureMechanismResultProbability = failureMechanismSectionResult.GetInitialFailureMechanismResultProbability(calculations, 0.1); // Assert Assert.AreEqual(4.2467174336864661e-7, initialFailureMechanismResultProbability); }
public void CreateNonAdoptableWithProfileProbabilityFailureMechanismSectionResult_SectionResultWithNaNValues_ReturnsEntityWithExpectedResults() { // Setup var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) { ManualInitialFailureMechanismResultProfileProbability = double.NaN, ManualInitialFailureMechanismResultSectionProbability = double.NaN, RefinedProfileProbability = double.NaN, RefinedSectionProbability = double.NaN }; // Call NonAdoptableWithProfileProbabilityFailureMechanismSectionResultEntity entity = sectionResult.Create(); // Assert Assert.IsNull(entity.ManualInitialFailureMechanismResultProfileProbability); Assert.IsNull(entity.ManualInitialFailureMechanismResultSectionProbability); Assert.IsNull(entity.RefinedProfileProbability); Assert.IsNull(entity.RefinedSectionProbability); }
public void CreateNonAdoptableWithProfileProbabilityFailureMechanismSectionResult_WithDifferentResults_ReturnsEntityWithExpectedResults() { // Setup var random = new Random(21); bool isRelevant = random.NextBoolean(); var initialFailureMechanismResultType = random.NextEnumValue <NonAdoptableInitialFailureMechanismResultType>(); double manualProfileProbability = random.NextDouble(); double manualSectionProbability = random.NextDouble(); var furtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>(); double refinedProfileProbability = random.NextDouble(); double refinedSectionProbability = random.NextDouble(); var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) { IsRelevant = isRelevant, InitialFailureMechanismResultType = initialFailureMechanismResultType, ManualInitialFailureMechanismResultProfileProbability = manualProfileProbability, ManualInitialFailureMechanismResultSectionProbability = manualSectionProbability, FurtherAnalysisType = furtherAnalysisType, RefinedProfileProbability = refinedProfileProbability, RefinedSectionProbability = refinedSectionProbability }; // Call NonAdoptableWithProfileProbabilityFailureMechanismSectionResultEntity entity = sectionResult.Create(); // Assert Assert.AreEqual(Convert.ToByte(isRelevant), entity.IsRelevant); Assert.AreEqual(Convert.ToByte(initialFailureMechanismResultType), entity.InitialFailureMechanismResultType); Assert.AreEqual(manualProfileProbability, entity.ManualInitialFailureMechanismResultProfileProbability); Assert.AreEqual(manualSectionProbability, entity.ManualInitialFailureMechanismResultSectionProbability); Assert.AreEqual(Convert.ToByte(furtherAnalysisType), entity.FurtherAnalysisType); Assert.AreEqual(refinedProfileProbability, entity.RefinedProfileProbability); Assert.AreEqual(refinedSectionProbability, entity.RefinedSectionProbability); }
public void AssembleSectionNonAdoptableWithProfileProbability_WithInputAndUseLengthEffectTrue_SetsInputOnCalculator( NonAdoptableInitialFailureMechanismResultType initialFailureMechanismResultType, bool expectedHasProbabilitySpecified) { // Setup var random = new Random(21); bool isRelevant = random.NextBoolean(); double manualInitialProfileProbability = random.NextDouble(); double manualInitialSectionProbability = random.NextDouble(); var furtherAnalysisType = random.NextEnumValue <FailureMechanismSectionResultFurtherAnalysisType>(); double manualRefinedSectionProbability = random.NextDouble(); double manualRefinedProfileProbability = random.NextDouble(); var assessmentSection = new AssessmentSectionStub(); var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) { IsRelevant = isRelevant, InitialFailureMechanismResultType = initialFailureMechanismResultType, ManualInitialFailureMechanismResultProfileProbability = manualInitialProfileProbability, ManualInitialFailureMechanismResultSectionProbability = manualInitialSectionProbability, FurtherAnalysisType = furtherAnalysisType, RefinedProfileProbability = manualRefinedProfileProbability, RefinedSectionProbability = manualRefinedSectionProbability }; using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, assessmentSection, true); // Assert FailureMechanismSectionWithProfileProbabilityAssemblyInput calculatorInput = calculator.FailureMechanismSectionWithProfileProbabilityAssemblyInput; FailureMechanismContribution failureMechanismContribution = assessmentSection.FailureMechanismContribution; Assert.AreEqual(failureMechanismContribution.SignalFloodingProbability, calculatorInput.SignalFloodingProbability); Assert.AreEqual(failureMechanismContribution.MaximumAllowableFloodingProbability, calculatorInput.MaximumAllowableFloodingProbability); Assert.AreEqual(isRelevant, calculatorInput.IsRelevant); Assert.AreEqual(expectedHasProbabilitySpecified, calculatorInput.HasProbabilitySpecified); Assert.AreEqual(manualInitialProfileProbability, calculatorInput.InitialProfileProbability); Assert.AreEqual(manualInitialSectionProbability, calculatorInput.InitialSectionProbability); Assert.AreEqual(furtherAnalysisType, calculatorInput.FurtherAnalysisType); Assert.AreEqual(manualRefinedProfileProbability, calculatorInput.RefinedProfileProbability); Assert.AreEqual(manualRefinedSectionProbability, calculatorInput.RefinedSectionProbability); } }
public void AssembleSectionNonAdoptableSectionWithProfileProbability_CalculatorRan_ReturnsExpectedOutput() { // Setup var random = new Random(21); var assessmentSection = new AssessmentSectionStub(); var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; // Call FailureMechanismSectionAssemblyResultWrapper result = FailureMechanismSectionAssemblyResultFactory.AssembleSection( sectionResult, assessmentSection, random.NextBoolean()); // Assert Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput, result); } }
public void AssembleSectionNonAdoptableSectionWithProfileProbability_CalculatorThrowsException_ThrowsAssemblyException() { // Setup var random = new Random(21); var assessmentSection = new AssessmentSectionStub(); var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); using (new AssemblyToolCalculatorFactoryConfig()) { var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; calculator.ThrowExceptionOnCalculate = true; // Call void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection( sectionResult, assessmentSection, random.NextBoolean()); // Assert var exception = Assert.Throws <AssemblyException>(Call); Exception innerException = exception.InnerException; Assert.IsInstanceOf <FailureMechanismSectionAssemblyCalculatorException>(innerException); Assert.AreEqual(innerException.Message, exception.Message); } }
public void AssembleSectionAdoptableSectionWithProfileProbability_AssessmentSectionNull_ThrowsArgumentNullException() { // Setup var random = new Random(21); var mocks = new MockRepository(); var calculateStrategy = mocks.Stub <IFailureMechanismSectionResultCalculateProbabilityStrategy>(); mocks.ReplayAll(); var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); // Call void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection( sectionResult, null, calculateStrategy, random.NextBoolean(), random.NextDouble()); // Assert var exception = Assert.Throws <ArgumentNullException>(Call); Assert.AreEqual("assessmentSection", exception.ParamName); mocks.VerifyAll(); }
public void UpdateSectionsWithImportedData_WithValidData_SetsSectionsToFailureMechanismAndCopiesPropertiesOfEqualSectionsAndReturnsAffectedObjects() { // Setup string sourcePath = TestHelper.GetScratchPadPath(); var failureMechanism = new TestFailureMechanism(); FailureMechanismSection failureMechanismSection1 = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(new[] { new Point2D(0.0, 0.0), new Point2D(5.0, 5.0) }); FailureMechanismSection failureMechanismSection2 = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(new[] { new Point2D(5.0, 5.0), new Point2D(10.0, 10.0) }); failureMechanism.SetSections(new[] { failureMechanismSection1, failureMechanismSection2 }, sourcePath); IObservableEnumerable <FailureMechanismSectionResult> failureMechanismSectionResults = failureMechanism.SectionResults; FailureMechanismSectionResult oldSectionResult = failureMechanismSectionResults.First(); var sectionResultUpdateStrategy = new TestUpdateFailureMechanismSectionResultUpdateStrategy(); var failureMechanismSectionUpdateStrategy = new FailureMechanismSectionUpdateStrategy <FailureMechanismSectionResult>(failureMechanism, sectionResultUpdateStrategy); FailureMechanismSection[] sections = { FailureMechanismSectionTestFactory.CreateFailureMechanismSection(new[] { new Point2D(0.0, 0.0), new Point2D(5.0, 5.0) }), FailureMechanismSectionTestFactory.CreateFailureMechanismSection(new[] { new Point2D(5.0, 5.0), new Point2D(15.0, 15.0) }) }; // Call IEnumerable <IObservable> affectedObjects = failureMechanismSectionUpdateStrategy.UpdateSectionsWithImportedData(sections, sourcePath); // Assert Assert.AreEqual(sourcePath, failureMechanism.FailureMechanismSectionSourcePath); IEnumerable <FailureMechanismSection> failureMechanismSections = failureMechanism.Sections; Assert.AreEqual(2, failureMechanismSections.Count()); CollectionAssert.AreEqual(sections, failureMechanismSections); Assert.AreSame(oldSectionResult, sectionResultUpdateStrategy.Origin); Assert.AreSame(failureMechanismSectionResults.First(), sectionResultUpdateStrategy.Target); CollectionAssert.AreEqual(new IObservable[] { failureMechanism, failureMechanism.SectionResults }, affectedObjects); }
protected override NonAdoptableFailureMechanismSectionResult CreateEmptySectionResult() { return(new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())); }
public void AssembleSectionNonAdoptableSectionWithoutProfileProbability_AssessmentSectionNull_ThrowsArgumentNullException() { // Setup var sectionResult = new NonAdoptableWithProfileProbabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); // Call void Call() => FailureMechanismSectionAssemblyResultFactory.AssembleSection(sectionResult, null); // Assert var exception = Assert.Throws <ArgumentNullException>(Call); Assert.AreEqual("assessmentSection", exception.ParamName); }
protected override FailureMechanismSection CreateDataModel() { return(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()); }
protected override AdoptableFailureMechanismSectionResult CreateEmptySectionResult() { return(new AdoptableFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection())); }