public void RemoveAllStochasticSoilModel_FullyConfiguredPipingFailureMechanism_RemovesAllSoilModelAndClearDependentData() { // Setup PipingFailureMechanism failureMechanism = PipingTestDataGenerator.GetPipingFailureMechanismWithAllCalculationConfigurations(); IPipingCalculationScenario <PipingInput>[] calculationsWithStochasticSoilModel = failureMechanism.Calculations .Cast <IPipingCalculationScenario <PipingInput> >() .Where(calc => calc.InputParameters.StochasticSoilModel != null) .ToArray(); IPipingCalculationScenario <PipingInput>[] calculationsWithOutput = calculationsWithStochasticSoilModel.Where(c => c.HasOutput) .ToArray(); // Precondition CollectionAssert.IsNotEmpty(calculationsWithStochasticSoilModel); // Call IEnumerable <IObservable> observables = PipingDataSynchronizationService.RemoveAllStochasticSoilModels(failureMechanism); // Assert // Note: To make sure the clear is performed regardless of what is done with // the return result, no ToArray() should be called before these assertions: CollectionAssert.IsEmpty(failureMechanism.StochasticSoilModels); foreach (IPipingCalculationScenario <PipingInput> calculation in calculationsWithStochasticSoilModel) { Assert.IsNull(calculation.InputParameters.StochasticSoilModel); } IObservable[] affectedObjectsArray = observables.ToArray(); int expectedAffectedObjectCount = 1 + calculationsWithOutput.Length + calculationsWithStochasticSoilModel.Length; Assert.AreEqual(expectedAffectedObjectCount, affectedObjectsArray.Length); foreach (IPipingCalculationScenario <PipingInput> calculation in calculationsWithOutput) { Assert.IsFalse(calculation.HasOutput); } IEnumerable <IObservable> expectedAffectedObjects = calculationsWithStochasticSoilModel.Select(calc => calc.InputParameters) .Cast <IObservable>() .Concat(calculationsWithOutput) .Concat(new IObservable[] { failureMechanism.StochasticSoilModels }); CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjectsArray); }
public void ForeColor_HasOutput_ReturnControlText() { // Setup var calculation = new ProbabilisticPipingCalculationScenario { Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints() }; var context = new ProbabilisticPipingOutputContext(calculation); // Call Color color = info.ForeColor(context); // Assert Assert.AreEqual(Color.FromKnownColor(KnownColor.ControlText), color); }
public void AdditionalDataCheck_CalculationWithoutSubMechanismOutput_ReturnsFalse() { // Setup var calculation = new ProbabilisticPipingCalculationScenario { Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints() }; var context = new ProbabilisticPipingSectionSpecificOutputContext(calculation); // Call bool additionalDataCheck = info.AdditionalDataCheck(context); // Assert Assert.IsFalse(additionalDataCheck); }
public void GivenScenarioRow_WhenOutputChangedAndUpdate_ThenDerivedOutputUpdated() { // Given var failureMechanism = new PipingFailureMechanism(); var mocks = new MockRepository(); IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); mocks.ReplayAll(); var calculation = new SemiProbabilisticPipingCalculationScenario { Output = PipingTestDataGenerator.GetRandomSemiProbabilisticPipingOutput() }; FailureMechanismSection failureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var row = new SemiProbabilisticPipingScenarioRow(calculation, failureMechanism, failureMechanismSection, assessmentSection); // Precondition DerivedSemiProbabilisticPipingOutput expectedDerivedOutput = DerivedSemiProbabilisticPipingOutputFactory.Create(calculation.Output, assessmentSection.FailureMechanismContribution.NormativeProbability); Assert.AreEqual(expectedDerivedOutput.PipingProbability, row.FailureProbability); Assert.AreEqual(expectedDerivedOutput.UpliftProbability, row.FailureProbabilityUplift); Assert.AreEqual(expectedDerivedOutput.HeaveProbability, row.FailureProbabilityHeave); Assert.AreEqual(expectedDerivedOutput.SellmeijerProbability, row.FailureProbabilitySellmeijer); Assert.AreEqual(expectedDerivedOutput.PipingProbability * failureMechanism.PipingProbabilityAssessmentInput.GetN( failureMechanismSection.Length), row.SectionFailureProbability); var random = new Random(11); // When calculation.Output = PipingTestDataGenerator.GetSemiProbabilisticPipingOutput(random.NextDouble(), random.NextDouble(), random.NextDouble()); row.Update(); // Then DerivedSemiProbabilisticPipingOutput newExpectedDerivedOutput = DerivedSemiProbabilisticPipingOutputFactory.Create(calculation.Output, assessmentSection.FailureMechanismContribution.NormativeProbability); Assert.AreEqual(newExpectedDerivedOutput.PipingProbability, row.FailureProbability); Assert.AreEqual(newExpectedDerivedOutput.UpliftProbability, row.FailureProbabilityUplift); Assert.AreEqual(newExpectedDerivedOutput.HeaveProbability, row.FailureProbabilityHeave); Assert.AreEqual(newExpectedDerivedOutput.SellmeijerProbability, row.FailureProbabilitySellmeijer); Assert.AreEqual(newExpectedDerivedOutput.PipingProbability * failureMechanism.PipingProbabilityAssessmentInput.GetN( failureMechanismSection.Length), row.SectionFailureProbability); mocks.VerifyAll(); }
public void GivenScenarioRow_WhenOutputSetAndUpdate_ThenDerivedOutputUpdated() { // Given var calculation = new ProbabilisticPipingCalculationScenario(); var row = new ProbabilisticPipingScenarioRow(calculation); // Precondition Assert.IsNaN(row.FailureProbability); Assert.IsNaN(row.SectionFailureProbability); // When calculation.Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithoutIllustrationPoints(); // Then Assert.AreEqual(StatisticsConverter.ReliabilityToProbability(calculation.Output.ProfileSpecificOutput.Reliability), row.FailureProbability); Assert.AreEqual(StatisticsConverter.ReliabilityToProbability(calculation.Output.SectionSpecificOutput.Reliability), row.SectionFailureProbability); }
public void Create_CalculationWithOutput_ReturnEntityWithOutput() { // Setup var output = new ProbabilisticPipingOutput(PipingTestDataGenerator.GetRandomPartialProbabilisticFaultTreePipingOutput(null), PipingTestDataGenerator.GetRandomPartialProbabilisticFaultTreePipingOutput(null)); // Call ProbabilisticPipingCalculationOutputEntity entity = output.Create(); // Assert Assert.AreEqual(output.ProfileSpecificOutput.Reliability, entity.ProfileSpecificReliability); Assert.AreEqual(output.SectionSpecificOutput.Reliability, entity.SectionSpecificReliability); Assert.IsNull(entity.GeneralResultFaultTreeIllustrationPointEntity); Assert.IsNull(entity.GeneralResultFaultTreeIllustrationPointEntity1); Assert.IsNull(entity.GeneralResultSubMechanismIllustrationPointEntity); Assert.IsNull(entity.GeneralResultSubMechanismIllustrationPointEntity1); }
public void Constructor_FailureMechanismNull_ThrowsArgumentNullException() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); // Call void Call() => new SemiProbabilisticPipingOutputContext(PipingTestDataGenerator.GetRandomSemiProbabilisticPipingOutput(), null, assessmentSection); // Assert var exception = Assert.Throws <ArgumentNullException>(Call); Assert.AreEqual("failureMechanism", exception.ParamName); mocks.VerifyAll(); }
public void CreateInstance_WithContextWithOtherPartialOutput_Null() { // Setup var calculation = new ProbabilisticPipingCalculationScenario { Output = new ProbabilisticPipingOutput(PipingTestDataGenerator.GetRandomPartialProbabilisticPipingOutput(), PipingTestDataGenerator.GetRandomPartialProbabilisticPipingOutput()) }; var context = new ProbabilisticPipingSectionSpecificOutputContext(calculation); // Call IObjectProperties objectProperties = info.CreateInstance(context); // Assert Assert.IsNull(objectProperties); }
private static IEnumerable <TestCaseData> GetCalculationConfigurations() { var calculationWithIllustrationPoints = new ProbabilisticPipingCalculationScenario { Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints() }; var calculationWithNoIllustrationPoints = new ProbabilisticPipingCalculationScenario { Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithoutIllustrationPoints() }; yield return(new TestCaseData(calculationWithIllustrationPoints, true)); yield return(new TestCaseData(calculationWithNoIllustrationPoints, false)); yield return(new TestCaseData(new ProbabilisticPipingCalculationScenario(), false)); }
public void AdditionalDataCheck_CalculationWithSubMechanismOutput_ReturnsTrue() { // Setup var calculation = new ProbabilisticPipingCalculationScenario { Output = new ProbabilisticPipingOutput( PipingTestDataGenerator.GetRandomPartialProbabilisticSubMechanismPipingOutput(), PipingTestDataGenerator.GetRandomPartialProbabilisticSubMechanismPipingOutput()) }; var context = new ProbabilisticPipingSectionSpecificOutputContext(calculation); // Call bool additionalDataCheck = info.AdditionalDataCheck(context); // Assert Assert.IsTrue(additionalDataCheck); }
public void CreateInstance_WithContextWithPartialSubMechanismOutput_ExpectedProperties() { // Setup var calculation = new ProbabilisticPipingCalculationScenario { Output = new ProbabilisticPipingOutput(PipingTestDataGenerator.GetRandomPartialProbabilisticSubMechanismPipingOutput(), PipingTestDataGenerator.GetRandomPartialProbabilisticSubMechanismPipingOutput()) }; var context = new ProbabilisticPipingSectionSpecificOutputContext(calculation); // Call IObjectProperties objectProperties = info.CreateInstance(context); // Assert Assert.IsInstanceOf <ProbabilisticSubMechanismPipingOutputProperties>(objectProperties); Assert.AreSame(context.WrappedData.Output.SectionSpecificOutput, objectProperties.Data); }
public void Clone_NotAllPropertiesSet_ReturnNewInstanceWithCopiedValues() { // Setup var original = new TestPipingInput(); PipingTestDataGenerator.SetRandomDataToPipingInput(original); original.SurfaceLine = null; original.StochasticSoilModel = null; original.StochasticSoilProfile = null; original.HydraulicBoundaryLocation = null; // Call object clone = original.Clone(); // Assert CoreCloneAssert.AreObjectClones(original, clone, PipingCloneAssert.AreClones); }
private static ProbabilisticPipingCalculationScenario CreateRandomCalculationScenarioWithoutOutput() { var random = new Random(21); var calculation = new ProbabilisticPipingCalculationScenario { Comments = { Body = "Random body" }, Name = "Random name", IsRelevant = random.NextBoolean(), Contribution = random.NextRoundedDouble() }; PipingTestDataGenerator.SetRandomDataToPipingInput(calculation.InputParameters); return(calculation); }
public void GetProperties_WithData_ReturnExpectedValues() { // Setup PartialProbabilisticSubMechanismPipingOutput output = PipingTestDataGenerator.GetRandomPartialProbabilisticSubMechanismPipingOutput(); // Call var properties = new ProbabilisticSubMechanismPipingOutputProperties(output); // Assert Assert.AreEqual(ProbabilityFormattingHelper.Format(StatisticsConverter.ReliabilityToProbability(output.Reliability)), properties.Probability); Assert.AreEqual(output.Reliability, properties.Reliability, properties.Reliability.GetAccuracy()); GeneralResult <TopLevelSubMechanismIllustrationPoint> generalResult = output.GeneralResult; CollectionAssert.AreEqual(generalResult.Stochasts, properties.AlphaValues); CollectionAssert.AreEqual(generalResult.Stochasts, properties.Durations); CollectionAssert.AreEqual(generalResult.TopLevelIllustrationPoints, properties.IllustrationPoints.Select(ip => ip.Data)); Assert.AreEqual(generalResult.GoverningWindDirection.Name, properties.WindDirection); }
public void DoPostUpdateActions_Always_ClearsAllProbabilisticOutputAndReturnsAffectedObjects() { // Setup var calculation1 = new ProbabilisticPipingCalculationScenario { Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints() }; var calculation2 = new ProbabilisticPipingCalculationScenario { Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithoutIllustrationPoints() }; var calculation3 = new SemiProbabilisticPipingCalculationScenario { Output = PipingTestDataGenerator.GetSemiProbabilisticPipingOutput(double.NaN, double.NaN, double.NaN) }; var failureMechanism = new PipingFailureMechanism(); failureMechanism.CalculationsGroup.Children.AddRange(new ICalculation[] { calculation1, calculation2, calculation3, new ProbabilisticPipingCalculationScenario() }); var replaceStrategy = new PipingFailureMechanismSectionReplaceStrategy(failureMechanism); // Call IEnumerable <IObservable> affectedObjects = replaceStrategy.DoPostUpdateActions(); // Assert Assert.IsFalse(calculation1.HasOutput); Assert.IsFalse(calculation2.HasOutput); Assert.IsTrue(calculation3.HasOutput); CollectionAssert.AreEqual(new[] { calculation1, calculation2 }, affectedObjects); }
public void Constructor_ExpectedValues() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); SemiProbabilisticPipingOutput output = PipingTestDataGenerator.GetRandomSemiProbabilisticPipingOutput(); var failureMechanism = new PipingFailureMechanism(); // Call var context = new SemiProbabilisticPipingOutputContext(output, failureMechanism, assessmentSection); // Assert Assert.IsInstanceOf <WrappedObjectContextBase <SemiProbabilisticPipingOutput> >(context); Assert.AreSame(output, context.WrappedData); Assert.AreSame(failureMechanism, context.FailureMechanism); Assert.AreSame(assessmentSection, context.AssessmentSection); mocks.VerifyAll(); }
public void CreateInstance_ValidData_NewPropertiesWithPipingOutputAsData() { // Setup var failureMechanism = new PipingFailureMechanism(); var mocks = new MockRepository(); IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); mocks.ReplayAll(); SemiProbabilisticPipingOutput output = PipingTestDataGenerator.GetRandomSemiProbabilisticPipingOutput(); var context = new SemiProbabilisticPipingOutputContext(output, failureMechanism, assessmentSection); // Call IObjectProperties objectProperties = info.CreateInstance(context); // Assert Assert.IsInstanceOf <SemiProbabilisticPipingOutputProperties>(objectProperties); Assert.AreSame(output, objectProperties.Data); mocks.VerifyAll(); }
public void Create_CalculationWithOutputWithFaultTreeIllustrationPoints_ReturnEntityWithOutputAndGeneralResult() { // Setup PartialProbabilisticFaultTreePipingOutput profileSpecificOutput = PipingTestDataGenerator.GetRandomPartialProbabilisticFaultTreePipingOutput(); PartialProbabilisticFaultTreePipingOutput sectionSpecificOutput = PipingTestDataGenerator.GetRandomPartialProbabilisticFaultTreePipingOutput(); var output = new ProbabilisticPipingOutput(profileSpecificOutput, sectionSpecificOutput); // Call ProbabilisticPipingCalculationOutputEntity entity = output.Create(); // Assert Assert.AreEqual(output.ProfileSpecificOutput.Reliability, entity.ProfileSpecificReliability); Assert.AreEqual(output.SectionSpecificOutput.Reliability, entity.SectionSpecificReliability); GeneralResultEntityTestHelper.AssertGeneralResultPropertyValues( profileSpecificOutput.GeneralResult, entity.GeneralResultFaultTreeIllustrationPointEntity); GeneralResultEntityTestHelper.AssertGeneralResultPropertyValues( sectionSpecificOutput.GeneralResult, entity.GeneralResultFaultTreeIllustrationPointEntity1); Assert.IsNull(entity.GeneralResultSubMechanismIllustrationPointEntity); Assert.IsNull(entity.GeneralResultSubMechanismIllustrationPointEntity1); }
public void ClearIllustrationPoints_CalculationWithOutputWithoutIllustrationPoints_ReturnsFalse() { // Setup var mocks = new MockRepository(); var inquiryHelper = mocks.StrictMock <IInquiryHelper>(); mocks.ReplayAll(); var calculation = new ProbabilisticPipingCalculationScenario { Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithoutIllustrationPoints() }; var handler = new ClearIllustrationPointsOfProbabilisticPipingCalculationChangeHandler(inquiryHelper, calculation); // Call bool result = handler.ClearIllustrationPoints(); // Assert Assert.IsFalse(result); mocks.VerifyAll(); }
public void ClearStochasticSoilProfileDependentData_CalculationWithOutputWithProfile_ReturnInputAndCalculation() { // Setup PipingFailureMechanism failureMechanism = PipingTestDataGenerator.GetPipingFailureMechanismWithAllCalculationConfigurations(); IEnumerable <IPipingCalculationScenario <PipingInput> > calculations = failureMechanism.Calculations .Cast <IPipingCalculationScenario <PipingInput> >(); var expectedAffectedObjects = new List <IObservable>(); PipingStochasticSoilProfile profileToDelete = null; foreach (IPipingCalculationScenario <PipingInput> calculation in calculations) { PipingInput input = calculation.InputParameters; PipingStochasticSoilProfile currentProfile = input.StochasticSoilProfile; if (profileToDelete == null) { profileToDelete = currentProfile; } if (profileToDelete != null && ReferenceEquals(profileToDelete, currentProfile)) { if (calculation.HasOutput) { expectedAffectedObjects.Add(calculation); } expectedAffectedObjects.Add(input); } } // Call IEnumerable <IObservable> affected = PipingDataSynchronizationService.ClearStochasticSoilProfileDependentData(failureMechanism, profileToDelete); // Assert CollectionAssert.AreEquivalent(expectedAffectedObjects, affected); CollectionAssert.IsEmpty(affected.OfType <PipingInput>().Where(a => a.StochasticSoilProfile == null)); CollectionAssert.IsEmpty(affected.OfType <IPipingCalculationScenario <PipingInput> >().Where(a => a.HasOutput)); }
public void ChildNodeObjects_Always_ReturnsCollectionWithOutputObjects(bool hasOutput) { // Setup var calculation = new ProbabilisticPipingCalculationScenario { Output = hasOutput ? PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints() : null }; var context = new ProbabilisticPipingOutputContext(calculation); // Call object[] children = info.ChildNodeObjects(context).ToArray(); // Assert Assert.AreEqual(2, children.Length); var profileSpecificOutputContext = children[0] as ProbabilisticPipingProfileSpecificOutputContext; Assert.AreSame(calculation, profileSpecificOutputContext.WrappedData); var sectionSpecificOutputContext = children[1] as ProbabilisticPipingSectionSpecificOutputContext; Assert.AreSame(calculation, sectionSpecificOutputContext.WrappedData); }
public void ContextMenuStrip_FailureMechanismHasCalculationsWithoutIllustrationPoints_ContextMenuItemClearAllIllustrationPointsDisabledAndToolTipSet() { // Setup using (var treeViewControl = new TreeViewControl()) { var pipingCalculation = new ProbabilisticPipingCalculationScenario { Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithoutIllustrationPoints() }; var failureMechanism = new PipingFailureMechanism(); failureMechanism.CalculationsGroup.Children.Add(pipingCalculation); var assessmentSection = mocks.Stub <IAssessmentSection>(); var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection); var menuBuilder = new CustomItemsOnlyContextMenuBuilder(); var gui = mocks.Stub <IGui>(); gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(menuBuilder); gui.Stub(cmp => cmp.MainWindow).Return(mocks.Stub <IMainWindow>()); mocks.ReplayAll(); plugin.Gui = gui; failureMechanism.CalculationsGroup.Children.Add(pipingCalculation); // Call using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl)) { // Assert ToolStripItem clearOutputItem = contextMenu.Items[contextMenuClearIllustrationPointsIndex]; Assert.IsFalse(clearOutputItem.Enabled); Assert.AreEqual("Er zijn geen berekeningen met illustratiepunten om te wissen.", clearOutputItem.ToolTipText); } } }
public void ClearReferenceLineDependentData_FullyConfiguredFailureMechanism_RemoveReferenceLineDependentDataAndReturnAffectedObjects() { // Setup PipingFailureMechanism failureMechanism = PipingTestDataGenerator.GetPipingFailureMechanismWithAllCalculationConfigurations(); object[] expectedRemovedObjects = failureMechanism.Sections.OfType <object>() .Concat(failureMechanism.SectionResults) .Concat(failureMechanism.ScenarioConfigurationsPerFailureMechanismSection) .Concat(failureMechanism.CalculationsGroup.GetAllChildrenRecursive()) .Concat(failureMechanism.StochasticSoilModels) .Concat(failureMechanism.SurfaceLines) .ToArray(); // Call ClearResults results = PipingDataSynchronizationService.ClearReferenceLineDependentData(failureMechanism); // Assert // Note: To make sure the clear is performed regardless of what is done with // the return result, no ToArray() should be called before these assertions: CollectionAssert.IsEmpty(failureMechanism.Sections); CollectionAssert.IsEmpty(failureMechanism.SectionResults); CollectionAssert.IsEmpty(failureMechanism.ScenarioConfigurationsPerFailureMechanismSection); CollectionAssert.IsEmpty(failureMechanism.CalculationsGroup.Children); CollectionAssert.IsEmpty(failureMechanism.StochasticSoilModels); CollectionAssert.IsEmpty(failureMechanism.SurfaceLines); IObservable[] array = results.ChangedObjects.ToArray(); Assert.AreEqual(6, array.Length); CollectionAssert.Contains(array, failureMechanism); CollectionAssert.Contains(array, failureMechanism.SectionResults); CollectionAssert.Contains(array, failureMechanism.ScenarioConfigurationsPerFailureMechanismSection); CollectionAssert.Contains(array, failureMechanism.CalculationsGroup); CollectionAssert.Contains(array, failureMechanism.StochasticSoilModels); CollectionAssert.Contains(array, failureMechanism.SurfaceLines); CollectionAssert.AreEquivalent(expectedRemovedObjects, results.RemovedObjects); }
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 RequireConfirmation_ProbabilisticCalculationsWithOutput_ReturnsTrue() { // Setup var mocks = new MockRepository(); var inquiryHelper = mocks.Stub <IInquiryHelper>(); mocks.ReplayAll(); var failureMechanism = new PipingFailureMechanism(); failureMechanism.CalculationsGroup.Children.Add(new ProbabilisticPipingCalculationScenario { Output = PipingTestDataGenerator.GetRandomProbabilisticPipingOutputWithIllustrationPoints() }); var changeHandler = new PipingFailureMechanismCalculationChangeHandler(failureMechanism, string.Empty, inquiryHelper); // Call bool requireConfirmation = changeHandler.RequireConfirmation(); // Assert Assert.IsTrue(requireConfirmation); mocks.VerifyAll(); }
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 GetProperties_WithData_ReturnExpectedValues() { // Setup PartialProbabilisticPipingOutput <TestTopLevelIllustrationPoint> output = PipingTestDataGenerator.GetRandomPartialProbabilisticPipingOutput(); // Call var properties = new TestProbabilisticPipingOutputProperties(output); // Assert Assert.AreEqual(ProbabilityFormattingHelper.Format(StatisticsConverter.ReliabilityToProbability(output.Reliability)), properties.Probability); Assert.AreEqual(output.Reliability, properties.Reliability, properties.Reliability.GetAccuracy()); }
public void Constructor_WithData_ExpectedValues() { // Setup PartialProbabilisticPipingOutput <TestTopLevelIllustrationPoint> output = PipingTestDataGenerator.GetRandomPartialProbabilisticPipingOutput(); // Call var properties = new TestProbabilisticPipingOutputProperties(output); // Assert Assert.IsInstanceOf <ObjectProperties <IPartialProbabilisticPipingOutput> >(properties); Assert.AreSame(output, properties.Data); }
public void Constructor_WithData_PropertiesHaveExpectedAttributesValues() { // Setup PartialProbabilisticPipingOutput <TestTopLevelIllustrationPoint> output = PipingTestDataGenerator.GetRandomPartialProbabilisticPipingOutput(null); // Call var properties = new TestProbabilisticPipingOutputProperties(output); // Assert PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties); Assert.AreEqual(2, dynamicProperties.Count); PropertyDescriptor probabilityProperty = dynamicProperties[probabilityPropertyIndex]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(probabilityProperty, resultCategoryName, "Faalkans [1/jaar]", "De kans dat het faalmechanisme optreedt voor deze berekening.", true); PropertyDescriptor reliabilityProperty = dynamicProperties[reliabilityPropertyIndex]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(reliabilityProperty, resultCategoryName, "Betrouwbaarheidsindex faalkans [-]", "De betrouwbaarheidsindex van de faalkans voor deze berekening.", true); }
public void Constructor_ExpectedValues() { // Setup PartialProbabilisticPipingOutput <TestTopLevelIllustrationPoint> sectionSpecificOutput = PipingTestDataGenerator.GetRandomPartialProbabilisticPipingOutput(); PartialProbabilisticPipingOutput <TestTopLevelIllustrationPoint> profileSpecificOutput = PipingTestDataGenerator.GetRandomPartialProbabilisticPipingOutput(); // Call var output = new ProbabilisticPipingOutput(sectionSpecificOutput, profileSpecificOutput); // Assert Assert.IsInstanceOf <CloneableObservable>(output); Assert.IsInstanceOf <ICalculationOutput>(output); Assert.AreSame(sectionSpecificOutput, output.SectionSpecificOutput); Assert.AreSame(profileSpecificOutput, output.ProfileSpecificOutput); }