public void ProbabilisticGetInitialFailureMechanismResultProbability_MultipleScenarios_ReturnsValueBasedOnRelevantScenarios() { // Setup FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var failureMechanismSectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section); var pipingCalculationScenario1 = ProbabilisticPipingCalculationTestFactory.CreateCalculation <ProbabilisticPipingCalculationScenario>(section); var pipingCalculationScenario2 = ProbabilisticPipingCalculationTestFactory.CreateCalculation <ProbabilisticPipingCalculationScenario>(section); var pipingCalculationScenario3 = ProbabilisticPipingCalculationTestFactory.CreateCalculation <ProbabilisticPipingCalculationScenario>(section); pipingCalculationScenario1.IsRelevant = true; pipingCalculationScenario1.Contribution = (RoundedDouble)0.2111; pipingCalculationScenario2.IsRelevant = true; pipingCalculationScenario2.Contribution = (RoundedDouble)0.7889; pipingCalculationScenario3.IsRelevant = false; ProbabilisticPipingCalculationScenario[] calculations = { pipingCalculationScenario1, pipingCalculationScenario2, pipingCalculationScenario3 }; // Call double initialFailureMechanismResultProbability = failureMechanismSectionResult.GetInitialFailureMechanismResultProbability( calculations, scenario => scenario.Output.ProfileSpecificOutput); // Assert Assert.AreEqual(0.24284668249632746, initialFailureMechanismResultProbability); }
public void CalculateProfileProbability_MultipleScenarios_ReturnsValueBasedOnRelevantScenarios() { // Setup FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var sectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section); var calculationScenario1 = ProbabilisticPipingCalculationTestFactory.CreateCalculation <ProbabilisticPipingCalculationScenario>(section); var calculationScenario2 = ProbabilisticPipingCalculationTestFactory.CreateCalculation <ProbabilisticPipingCalculationScenario>(section); var calculationScenario3 = ProbabilisticPipingCalculationTestFactory.CreateCalculation <ProbabilisticPipingCalculationScenario>(section); calculationScenario1.IsRelevant = true; calculationScenario1.Contribution = (RoundedDouble)0.2111; calculationScenario2.IsRelevant = true; calculationScenario2.Contribution = (RoundedDouble)0.7889; calculationScenario3.IsRelevant = false; ProbabilisticPipingCalculationScenario[] calculations = { calculationScenario1, calculationScenario2, calculationScenario3 }; var strategy = new ProbabilisticPipingFailureMechanismSectionResultCalculateProbabilityStrategy(sectionResult, calculations); // Call double profileProbability = strategy.CalculateProfileProbability(); // Assert Assert.AreEqual(0.24284668249632746, profileProbability); }
public void ProbabilisticGetInitialFailureMechanismResultProbability_ScenarioWithNaNResults_ReturnsNaN() { // Setup FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var failureMechanismSectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section); const double contribution1 = 0.2; const double contribution2 = 0.8; var pipingCalculationScenario1 = ProbabilisticPipingCalculationTestFactory.CreateCalculation <ProbabilisticPipingCalculationScenario>(section); var pipingCalculationScenario2 = ProbabilisticPipingCalculationTestFactory.CreateNotCalculatedCalculation <ProbabilisticPipingCalculationScenario>(section); pipingCalculationScenario1.IsRelevant = true; pipingCalculationScenario1.Contribution = (RoundedDouble)contribution1; pipingCalculationScenario2.IsRelevant = true; pipingCalculationScenario2.Contribution = (RoundedDouble)contribution2; pipingCalculationScenario2.Output = new ProbabilisticPipingOutput(new TestPartialProbabilisticPipingOutput(double.NaN, null), new TestPartialProbabilisticPipingOutput(double.NaN, null)); ProbabilisticPipingCalculationScenario[] calculations = { pipingCalculationScenario1, pipingCalculationScenario2 }; // Call double initialFailureMechanismResultProbability = failureMechanismSectionResult.GetInitialFailureMechanismResultProbability( calculations, scenario => scenario.Output.ProfileSpecificOutput); // Assert Assert.IsNaN(initialFailureMechanismResultProbability); }
public void GivenViewWithCalculationGroupData_WhenCalculationGroupUpdatedAndNotified_ThenMapDataUpdated() { // Given var failureMechanism = new PipingFailureMechanism(); PipingFailureMechanismView view = CreateView(failureMechanism, new AssessmentSectionStub()); IMapControl map = ((RiskeerMapControl)view.Controls[0]).MapControl; var surfaceLineA = new PipingSurfaceLine(string.Empty); surfaceLineA.SetGeometry(new[] { new Point3D(0.0, 0.0, 1.0), new Point3D(3.0, 0.0, 1.7) }); var surfaceLineB = new PipingSurfaceLine(string.Empty); surfaceLineB.SetGeometry(new[] { new Point3D(0.0, 0.0, 1.5), new Point3D(3.0, 0.0, 1.8) }); surfaceLineA.ReferenceLineIntersectionWorldPoint = new Point2D(1.3, 1.3); surfaceLineB.ReferenceLineIntersectionWorldPoint = new Point2D(1.5, 1.5); var calculationA = SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <SemiProbabilisticPipingCalculationScenario>( new TestHydraulicBoundaryLocation()); var calculationB = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <ProbabilisticPipingCalculationScenario>( new TestHydraulicBoundaryLocation()); calculationA.InputParameters.SurfaceLine = surfaceLineA; calculationB.InputParameters.SurfaceLine = surfaceLineB; failureMechanism.CalculationsGroup.Children.Add(calculationA); failureMechanism.CalculationsGroup.Children.Add(calculationB); var probabilisticCalculationMapData = (MapLineData)map.Data.Collection.ElementAt(probabilisticCalculationsIndex); var semiProbabilisticCalculationMapData = (MapLineData)map.Data.Collection.ElementAt(semiProbabilisticCalculationsIndex); var mocks = new MockRepository(); IObserver[] observers = AttachMapDataObservers(mocks, map.Data.Collection); observers[semiProbabilisticCalculationObserverIndex].Expect(obs => obs.UpdateObserver()); observers[probabilisticCalculationObserverIndex].Expect(obs => obs.UpdateObserver()); mocks.ReplayAll(); // When failureMechanism.CalculationsGroup.Children.Add(calculationB); failureMechanism.CalculationsGroup.NotifyObservers(); // Then AssertSemiProbabilisticCalculationsMapData(failureMechanism.Calculations.OfType <SemiProbabilisticPipingCalculationScenario>(), semiProbabilisticCalculationMapData); AssertProbabilisticCalculationsMapData(failureMechanism.Calculations.OfType <ProbabilisticPipingCalculationScenario>(), probabilisticCalculationMapData); mocks.VerifyAll(); }
public void Run_ValidCalculation_InputPropertiesCorrectlySentToService() { // Setup var mocks = new MockRepository(); var profileSpecificCalculator = new TestPipingCalculator(); var sectionSpecificCalculator = new TestPipingCalculator(); var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreatePipingCalculator(null)) .IgnoreArguments() .Return(profileSpecificCalculator) .Repeat.Once(); calculatorFactory.Expect(cf => cf.CreatePipingCalculator(null)) .IgnoreArguments() .Return(sectionSpecificCalculator) .Repeat.Once(); mocks.ReplayAll(); var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike); DataImportHelper.ImportHydraulicBoundaryDatabase(assessmentSection, validFilePath); TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels(); var calculation = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestProbabilisticPipingCalculation>( assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001)); calculation.InputParameters.HydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001); CalculatableActivity activity = PipingCalculationActivityFactory.CreateProbabilisticPipingCalculationActivity( calculation, failureMechanism, assessmentSection); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call activity.Run(); // Assert PipingCalculationInput[] profileSpecificInputs = profileSpecificCalculator.ReceivedInputs.ToArray(); PipingCalculationInput[] sectionSpecificInputs = sectionSpecificCalculator.ReceivedInputs.ToArray(); Assert.AreEqual(1, profileSpecificInputs.Length); Assert.AreEqual(1, sectionSpecificInputs.Length); double sectionLength = failureMechanism.Sections.Single( s => calculation.IsSurfaceLineIntersectionWithReferenceLineInSection( Math2D.ConvertPointsToLineSegments(s.Points))).Length; AssertCalculatorInput(failureMechanism.GeneralInput, calculation.InputParameters, 0, profileSpecificInputs[0]); AssertCalculatorInput(failureMechanism.GeneralInput, calculation.InputParameters, sectionLength, sectionSpecificInputs[0]); } mocks.VerifyAll(); }
public void FailureMechanismResultsView_AllDataSet_DataGridViewCorrectlyInitialized( PipingScenarioConfigurationType scenarioConfigurationType, PipingScenarioConfigurationPerFailureMechanismSectionType scenarioConfigurationPerFailureMechanismSectionType, string probability) { // Setup FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection("Section 1"); var failureMechanism = new PipingFailureMechanism { ScenarioConfigurationType = scenarioConfigurationType }; FailureMechanismTestHelper.SetSections(failureMechanism, new[] { section }); failureMechanism.ScenarioConfigurationsPerFailureMechanismSection.First().ScenarioConfigurationType = scenarioConfigurationPerFailureMechanismSectionType; failureMechanism.CalculationsGroup.Children.Add( SemiProbabilisticPipingCalculationTestFactory.CreateCalculation <SemiProbabilisticPipingCalculationScenario>(section)); failureMechanism.CalculationsGroup.Children.Add( ProbabilisticPipingCalculationTestFactory.CreateCalculation <ProbabilisticPipingCalculationScenario>(section)); // Call using (new AssemblyToolCalculatorFactoryConfig()) using (ShowFailureMechanismResultsView(failureMechanism)) { 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(AdoptableInitialFailureMechanismResultType.Adopt, cells[initialFailureMechanismResultTypeIndex].Value); Assert.AreEqual(probability, cells[initialFailureMechanismResultProfileProbabilityIndex].FormattedValue); Assert.AreEqual(probability, cells[initialFailureMechanismResultSectionProbabilityIndex].FormattedValue); Assert.AreEqual(FailureMechanismSectionResultFurtherAnalysisType.NotNecessary, cells[furtherAnalysisTypeIndex].Value); Assert.AreEqual(ProbabilityRefinementType.Section, cells[probabilityRefinementTypeIndex].Value); Assert.AreEqual("<afgeleid>", 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 Run_ValidCalculation_PerformValidationAndCalculationAndLogStartAndEnd() { // Setup var mocks = new MockRepository(); var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreatePipingCalculator(null)) .IgnoreArguments() .Return(new TestPipingCalculator()) .Repeat.Twice(); mocks.ReplayAll(); var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike); DataImportHelper.ImportHydraulicBoundaryDatabase(assessmentSection, validFilePath); TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels(); var calculation = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestProbabilisticPipingCalculation>( assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001)); CalculatableActivity activity = PipingCalculationActivityFactory.CreateProbabilisticPipingCalculationActivity( calculation, failureMechanism, assessmentSection); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call void Call() => activity.Run(); // Assert TestHelper.AssertLogMessages(Call, messages => { string[] msgs = messages.ToArray(); Assert.AreEqual(7, msgs.Length); Assert.AreEqual($"Uitvoeren van berekening '{calculation.Name}' is gestart.", msgs[0]); CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]); CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]); CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[3]); StringAssert.StartsWith("De piping sterkte berekening voor doorsnede is uitgevoerd op de tijdelijke locatie", msgs[4]); StringAssert.StartsWith("De piping sterkte berekening voor vak is uitgevoerd op de tijdelijke locatie", msgs[5]); CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[6]); }); Assert.AreEqual(ActivityState.Executed, activity.State); } mocks.VerifyAll(); }
private static void AddProbabilisticPipingCalculationScenario(AssessmentSection assessmentSection, HydraulicBoundaryLocation hydraulicBoundaryLocation) { var pipingCalculationScenario = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <ProbabilisticPipingCalculationScenario>( hydraulicBoundaryLocation); assessmentSection.Piping.CalculationsGroup.Children.Add(pipingCalculationScenario); assessmentSection.Piping.SetSections(new[] { new FailureMechanismSection("test", new[] { new Point2D(0, 0), new Point2D(1, 1) }) }, string.Empty); }
public void ProbabilisticGetInitialFailureMechanismResultProbability_ScenarioNotCalculated_ReturnsNaN() { // Setup FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var failureMechanismSectionResult = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section); var pipingCalculationScenario = ProbabilisticPipingCalculationTestFactory.CreateNotCalculatedCalculation <ProbabilisticPipingCalculationScenario>(section); // Call double initialFailureMechanismResultProbability = failureMechanismSectionResult.GetInitialFailureMechanismResultProbability(new[] { pipingCalculationScenario }, scenario => scenario.Output.ProfileSpecificOutput); // Assert Assert.IsNaN(initialFailureMechanismResultProbability); }
public void Run_ValidCalculation_ProgressTextSetAccordingly() { // Setup var mocks = new MockRepository(); var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreatePipingCalculator(null)) .IgnoreArguments() .Return(new TestPipingCalculator()) .Repeat.Twice(); mocks.ReplayAll(); var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike); DataImportHelper.ImportHydraulicBoundaryDatabase(assessmentSection, validFilePath); TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels(); var calculation = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestProbabilisticPipingCalculation>( assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001)); CalculatableActivity activity = PipingCalculationActivityFactory.CreateProbabilisticPipingCalculationActivity( calculation, failureMechanism, assessmentSection); var progressTexts = ""; activity.ProgressChanged += (s, e) => progressTexts += activity.ProgressText + Environment.NewLine; using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call activity.Run(); // Assert string expectedProgressTexts = "Stap 1 van 2 | Uitvoeren sterkte berekening voor doorsnede" + Environment.NewLine + "Stap 2 van 2 | Uitvoeren sterkte berekening voor vak" + Environment.NewLine; Assert.AreEqual(expectedProgressTexts, progressTexts); } mocks.VerifyAll(); }
public void GivenProbabilisticPipingCalculationActivity_WhenRunAndFinished_ThenOutputSetAndObserversNotified() { // Given var mocks = new MockRepository(); var observer = mocks.StrictMock <IObserver>(); observer.Expect(o => o.UpdateObserver()); var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreatePipingCalculator(null)) .IgnoreArguments() .Return(new TestPipingCalculator()) .Repeat.Twice(); mocks.ReplayAll(); var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike); DataImportHelper.ImportHydraulicBoundaryDatabase(assessmentSection, validFilePath); TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels(); var calculation = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestProbabilisticPipingCalculation>( assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001)); calculation.Attach(observer); CalculatableActivity activity = PipingCalculationActivityFactory.CreateProbabilisticPipingCalculationActivity( calculation, failureMechanism, assessmentSection); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // When activity.Run(); activity.Finish(); // Then Assert.IsNotNull(calculation.Output); } mocks.VerifyAll(); }
public void CreateProbabilisticPipingCalculationActivity_WithValidCalculation_ReturnsActivityWithParametersSet() { // Setup var assessmentSection = new AssessmentSectionStub(); var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(); TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels(); assessmentSection.HydraulicBoundaryDatabase.FilePath = validHydraulicBoundaryDatabaseFilePath; HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase); var calculation = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestProbabilisticPipingCalculation>( hydraulicBoundaryLocation); // Call CalculatableActivity activity = PipingCalculationActivityFactory.CreateProbabilisticPipingCalculationActivity(calculation, failureMechanism, assessmentSection); // Assert Assert.IsInstanceOf <ProbabilisticPipingCalculationActivity>(activity); AssertProbabilisticPipingCalculationActivity(activity, calculation, hydraulicBoundaryLocation); }
public void ProbabilisticGetInitialFailureMechanismResultProbability_RelevantScenarioContributionsDoNotAddUpTo1_ReturnNaN(double contributionA, double contributionB) { // Setup FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); var pipingCalculationScenarioA = ProbabilisticPipingCalculationTestFactory.CreateCalculation <ProbabilisticPipingCalculationScenario>(section); var pipingCalculationScenarioB = ProbabilisticPipingCalculationTestFactory.CreateCalculation <ProbabilisticPipingCalculationScenario>(section); pipingCalculationScenarioA.Contribution = (RoundedDouble)contributionA; pipingCalculationScenarioB.Contribution = (RoundedDouble)contributionB; var result = new AdoptableWithProfileProbabilityFailureMechanismSectionResult(section); // Call double initialFailureMechanismResultProbability = result.GetInitialFailureMechanismResultProbability(new[] { pipingCalculationScenarioA, pipingCalculationScenarioB }, scenario => null); // Assert Assert.IsNaN(initialFailureMechanismResultProbability); }
public void Run_InvalidSectionSpecificCalculation_LogErrorAndActivityStateFailedAndOutputNotSet(bool endInFailure, string lastErrorFileContent) { // Setup var sectionSpecificCalculator = new TestPipingCalculator { LastErrorFileContent = lastErrorFileContent, EndInFailure = true }; var mocks = new MockRepository(); var observer = mocks.StrictMock <IObserver>(); var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreatePipingCalculator(null)) .IgnoreArguments() .Return(new TestPipingCalculator()) .Repeat.Once(); calculatorFactory.Expect(cf => cf.CreatePipingCalculator(null)) .IgnoreArguments() .Return(sectionSpecificCalculator) .Repeat.Once(); mocks.ReplayAll(); var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike); DataImportHelper.ImportHydraulicBoundaryDatabase(assessmentSection, validFilePath); TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels(); var calculation = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestProbabilisticPipingCalculation>( assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001)); calculation.Attach(observer); CalculatableActivity activity = PipingCalculationActivityFactory.CreateProbabilisticPipingCalculationActivity( calculation, failureMechanism, assessmentSection); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call void Call() => activity.Run(); // Assert TestHelper.AssertLogMessages(Call, messages => { string[] msgs = messages.ToArray(); Assert.AreEqual(8, msgs.Length); Assert.AreEqual($"Uitvoeren van berekening '{calculation.Name}' is gestart.", msgs[0]); CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]); CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]); CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[3]); StringAssert.StartsWith("De piping sterkte berekening voor doorsnede is uitgevoerd op de tijdelijke locatie", msgs[4]); string errorReportText = lastErrorFileContent != null ? $"Bekijk het foutrapport door op details te klikken.{Environment.NewLine}{lastErrorFileContent}" : "Er is geen foutrapport beschikbaar."; Assert.AreEqual($"De piping sterkte berekening voor vak '{calculation.Name}' is mislukt. {errorReportText}", msgs[5]); StringAssert.StartsWith("De piping sterkte berekening voor vak is uitgevoerd op de tijdelijke locatie", msgs[6]); CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]); }); Assert.AreEqual(ActivityState.Failed, activity.State); Assert.IsNull(calculation.Output); } mocks.VerifyAll(); // No observers notified }
public void CreateCalculationActivitiesForFailureMechanism_WithValidCalculations_ReturnsPipingCalculationActivitiesWithParametersSet() { // Setup var assessmentSection = new AssessmentSectionStub { FailureMechanismContribution = { NormativeProbabilityType = NormativeProbabilityType.MaximumAllowableFloodingProbability } }; var hydraulicBoundaryLocation1 = new TestHydraulicBoundaryLocation(); var hydraulicBoundaryLocation2 = new TestHydraulicBoundaryLocation(); TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels(); assessmentSection.SetHydraulicBoundaryLocationCalculations(new[] { hydraulicBoundaryLocation1, hydraulicBoundaryLocation2 }); assessmentSection.HydraulicBoundaryDatabase.FilePath = validHydraulicBoundaryDatabaseFilePath; HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase); var random = new Random(39); HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation1 = assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability.First(); hydraulicBoundaryLocationCalculation1.Output = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble()); HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation2 = assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability.ElementAt(1); hydraulicBoundaryLocationCalculation2.Output = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble()); var calculation1 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestSemiProbabilisticPipingCalculation>( hydraulicBoundaryLocation1); var calculation2 = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestProbabilisticPipingCalculation>( hydraulicBoundaryLocation1); var calculation3 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestSemiProbabilisticPipingCalculation>( hydraulicBoundaryLocation2); var calculation4 = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestProbabilisticPipingCalculation>( hydraulicBoundaryLocation2); failureMechanism.CalculationsGroup.Children.AddRange(new IPipingCalculation <PipingInput>[] { calculation1, calculation2, calculation3, calculation4 }); // Call IEnumerable <CalculatableActivity> activities = PipingCalculationActivityFactory.CreateCalculationActivities( failureMechanism, assessmentSection); // Assert Assert.AreEqual(4, activities.Count()); CalculatableActivity activity1 = activities.ElementAt(0); Assert.IsInstanceOf <SemiProbabilisticPipingCalculationActivity>(activity1); AssertSemiProbabilisticPipingCalculationActivity(activity1, calculation1, hydraulicBoundaryLocationCalculation1); CalculatableActivity activity2 = activities.ElementAt(1); Assert.IsInstanceOf <ProbabilisticPipingCalculationActivity>(activity2); AssertProbabilisticPipingCalculationActivity(activity2, calculation2, hydraulicBoundaryLocation1); CalculatableActivity activity3 = activities.ElementAt(2); Assert.IsInstanceOf <SemiProbabilisticPipingCalculationActivity>(activity3); AssertSemiProbabilisticPipingCalculationActivity(activity3, calculation3, hydraulicBoundaryLocationCalculation2); CalculatableActivity activity4 = activities.ElementAt(3); Assert.IsInstanceOf <ProbabilisticPipingCalculationActivity>(activity4); AssertProbabilisticPipingCalculationActivity(activity4, calculation4, hydraulicBoundaryLocation2); }
public void ContextMenuStrip_ClickOnCalculateAllItem_ScheduleAllChildCalculations() { // Setup using (var treeViewControl = new TreeViewControl()) { var assessmentSection = new AssessmentSectionStub(); var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(); TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels(); assessmentSection.HydraulicBoundaryDatabase.FilePath = validHydraulicBoundaryDatabaseFilePath; HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase); assessmentSection.SetHydraulicBoundaryLocationCalculations(new[] { hydraulicBoundaryLocation }, true); var calculationA = SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <SemiProbabilisticPipingCalculationScenario>( hydraulicBoundaryLocation); var calculationB = SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <SemiProbabilisticPipingCalculationScenario>( hydraulicBoundaryLocation); var calculationC = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <ProbabilisticPipingCalculationScenario>( hydraulicBoundaryLocation); var calculationD = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <ProbabilisticPipingCalculationScenario>( hydraulicBoundaryLocation); calculationA.Name = "A"; calculationB.Name = "B"; calculationC.Name = "C"; calculationD.Name = "D"; failureMechanism.CalculationsGroup.Children.Add(calculationA); failureMechanism.CalculationsGroup.Children.Add(calculationC); failureMechanism.CalculationsGroup.Children.Add(calculationB); failureMechanism.CalculationsGroup.Children.Add(calculationD); var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection); var menuBuilder = new CustomItemsOnlyContextMenuBuilder(); IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocks); var gui = mocks.Stub <IGui>(); gui.Stub(g => g.MainWindow).Return(mainWindow); gui.Stub(g => g.Get(context, treeViewControl)).Return(menuBuilder); var calculatorFactory = mocks.Stub <IHydraRingCalculatorFactory>(); calculatorFactory.Stub(cf => cf.CreatePipingCalculator(null)) .IgnoreArguments() .Return(new TestPipingCalculator()); mocks.ReplayAll(); plugin.Gui = gui; DialogBoxHandler = (name, wnd) => { // Expect an activity dialog which is automatically closed }; using (new PipingSubCalculatorFactoryConfig()) using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl)) { // Call void Call() => contextMenu.Items[contextMenuCalculateAllIndex].PerformClick(); // Assert TestHelper.AssertLogMessages(Call, messages => { string[] msgs = messages.ToArray(); Assert.AreEqual(28, msgs.Length); Assert.AreEqual("Uitvoeren van berekening 'A' is gestart.", msgs[0]); CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]); CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]); CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[3]); CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[4]); Assert.AreEqual("Uitvoeren van berekening 'A' is gelukt.", msgs[5]); Assert.AreEqual("Uitvoeren van berekening 'C' is gestart.", msgs[6]); CalculationServiceTestHelper.AssertValidationStartMessage(msgs[7]); CalculationServiceTestHelper.AssertValidationEndMessage(msgs[8]); CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[9]); CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[12]); Assert.AreEqual("Uitvoeren van berekening 'C' is gelukt.", msgs[13]); Assert.AreEqual("Uitvoeren van berekening 'B' is gestart.", msgs[14]); CalculationServiceTestHelper.AssertValidationStartMessage(msgs[15]); CalculationServiceTestHelper.AssertValidationEndMessage(msgs[16]); CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[17]); CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[18]); Assert.AreEqual("Uitvoeren van berekening 'B' is gelukt.", msgs[19]); Assert.AreEqual("Uitvoeren van berekening 'D' is gestart.", msgs[20]); CalculationServiceTestHelper.AssertValidationStartMessage(msgs[21]); CalculationServiceTestHelper.AssertValidationEndMessage(msgs[22]); CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[23]); CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[26]); Assert.AreEqual("Uitvoeren van berekening 'D' is gelukt.", msgs[27]); }); } } }
public void Constructor_WithAllData_DataUpdatedToCollectionOfFilledMapData() { // Setup PipingStochasticSoilModel stochasticSoilModel1 = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("name1", new[] { new Point2D(1.0, 2.0), new Point2D(1.1, 2.2) }); PipingStochasticSoilModel stochasticSoilModel2 = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("name2", new[] { new Point2D(3.0, 4.0), new Point2D(3.3, 4.4) }); var surfaceLineA = new PipingSurfaceLine("Line A"); surfaceLineA.SetGeometry(new[] { new Point3D(0.0, 0.0, 1.0), new Point3D(3.0, 0.0, 1.7) }); var surfaceLineB = new PipingSurfaceLine("Name B"); surfaceLineB.SetGeometry(new[] { new Point3D(0.0, 0.0, 1.5), new Point3D(3.0, 0.0, 1.8) }); surfaceLineA.ReferenceLineIntersectionWorldPoint = new Point2D(1.3, 1.3); surfaceLineB.ReferenceLineIntersectionWorldPoint = new Point2D(1.5, 1.5); var failureMechanism = new PipingFailureMechanism(); const string arbitraryFilePath = "path"; var geometryPoints = new[] { new Point2D(0.0, 0.0), new Point2D(2.0, 0.0), new Point2D(4.0, 4.0), new Point2D(6.0, 4.0) }; failureMechanism.SurfaceLines.AddRange(new[] { surfaceLineA, surfaceLineB }, arbitraryFilePath); FailureMechanismTestHelper.SetSections(failureMechanism, new[] { new FailureMechanismSection("A", geometryPoints.Take(2)), new FailureMechanismSection("B", geometryPoints.Skip(1).Take(2)), new FailureMechanismSection("C", geometryPoints.Skip(2).Take(2)) }); failureMechanism.StochasticSoilModels.AddRange(new[] { stochasticSoilModel1, stochasticSoilModel2 }, arbitraryFilePath); var hydraulicBoundaryLocation1 = new HydraulicBoundaryLocation(1, "test", 1.0, 2.0); var hydraulicBoundaryLocation2 = new HydraulicBoundaryLocation(2, "test", 3.0, 4.0); var calculationA = SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <SemiProbabilisticPipingCalculationScenario>( hydraulicBoundaryLocation1); var calculationB = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <ProbabilisticPipingCalculationScenario>( hydraulicBoundaryLocation2); calculationA.InputParameters.SurfaceLine = surfaceLineA; calculationB.InputParameters.SurfaceLine = surfaceLineB; failureMechanism.CalculationsGroup.Children.Add(calculationA); failureMechanism.CalculationsGroup.Children.Add(calculationB); var referenceLine = new ReferenceLine(); referenceLine.SetGeometry(new[] { new Point2D(0.0, 3.0), new Point2D(3.0, 0.0) }); var assessmentSection = new AssessmentSectionStub { ReferenceLine = referenceLine }; assessmentSection.SetHydraulicBoundaryLocationCalculations(new[] { hydraulicBoundaryLocation1, hydraulicBoundaryLocation2 }); using (new AssemblyToolCalculatorFactoryConfig()) { // Call PipingFailureMechanismView view = CreateView(failureMechanism, assessmentSection); IMapControl map = ((RiskeerMapControl)view.Controls[0]).MapControl; // Assert MapDataCollection mapData = map.Data; Assert.IsInstanceOf <MapDataCollection>(mapData); List <MapData> mapDataList = mapData.Collection.ToList(); Assert.AreEqual(8, mapDataList.Count); MapDataTestHelper.AssertReferenceLineMapData(assessmentSection.ReferenceLine, mapDataList[referenceLineIndex]); AssertSurfaceLinesMapData(failureMechanism.SurfaceLines, mapDataList[surfaceLinesIndex]); IEnumerable <MapData> sectionsCollection = ((MapDataCollection)mapDataList[sectionsCollectionIndex]).Collection; MapDataTestHelper.AssertFailureMechanismSectionsMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsIndex)); MapDataTestHelper.AssertFailureMechanismSectionsStartPointMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsStartPointIndex)); MapDataTestHelper.AssertFailureMechanismSectionsEndPointMapData(failureMechanism.Sections, sectionsCollection.ElementAt(sectionsEndPointIndex)); MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapDataList[hydraulicBoundaryLocationsIndex]); AssertStochasticSoilModelsMapData(failureMechanism.StochasticSoilModels, mapDataList[stochasticSoilModelsIndex]); AssertProbabilisticCalculationsMapData(failureMechanism.Calculations.OfType <ProbabilisticPipingCalculationScenario>(), mapDataList[probabilisticCalculationsIndex]); AssertSemiProbabilisticCalculationsMapData(failureMechanism.Calculations.OfType <SemiProbabilisticPipingCalculationScenario>(), mapDataList[semiProbabilisticCalculationsIndex]); var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance; FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator; MapDataTestHelper.AssertAssemblyMapData(failureMechanism, calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult, mapDataList[assemblyResultsIndex]); } }
public void ContextMenuStrip_ClickOnValidateAllItem_ValidateAllChildCalculations() { // Setup using (var treeViewControl = new TreeViewControl()) { var assessmentSection = new AssessmentSectionStub(); var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(); TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels(); assessmentSection.HydraulicBoundaryDatabase.FilePath = validHydraulicBoundaryDatabaseFilePath; HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase); assessmentSection.SetHydraulicBoundaryLocationCalculations(new[] { hydraulicBoundaryLocation }, true); var validSemiProbabilisticCalculation = SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <SemiProbabilisticPipingCalculationScenario>( hydraulicBoundaryLocation); var invalidSemiProbabilisticCalculation = SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithInvalidInput <SemiProbabilisticPipingCalculationScenario>(); var validProbabilisticCalculation = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <ProbabilisticPipingCalculationScenario>( hydraulicBoundaryLocation); var invalidProbabilisticCalculation = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithInvalidInput <ProbabilisticPipingCalculationScenario>(); failureMechanism.CalculationsGroup.Children.Add(validSemiProbabilisticCalculation); failureMechanism.CalculationsGroup.Children.Add(invalidProbabilisticCalculation); failureMechanism.CalculationsGroup.Children.Add(validProbabilisticCalculation); failureMechanism.CalculationsGroup.Children.Add(invalidSemiProbabilisticCalculation); var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection); var menuBuilder = new CustomItemsOnlyContextMenuBuilder(); var gui = mocks.Stub <IGui>(); gui.Stub(g => g.Get(context, treeViewControl)).Return(menuBuilder); gui.Stub(cmp => cmp.MainWindow).Return(mocks.Stub <IMainWindow>()); mocks.ReplayAll(); plugin.Gui = gui; using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl)) { // Call void Call() => contextMenu.Items[contextMenuValidateAllIndex].PerformClick(); // Assert TestHelper.AssertLogMessages(Call, messages => { string[] msgs = messages.ToArray(); Assert.AreEqual(18, msgs.Length); CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]); CalculationServiceTestHelper.AssertValidationEndMessage(msgs[1]); CalculationServiceTestHelper.AssertValidationStartMessage(msgs[2]); CalculationServiceTestHelper.AssertValidationEndMessage(msgs[8]); CalculationServiceTestHelper.AssertValidationStartMessage(msgs[9]); CalculationServiceTestHelper.AssertValidationEndMessage(msgs[10]); CalculationServiceTestHelper.AssertValidationStartMessage(msgs[11]); CalculationServiceTestHelper.AssertValidationEndMessage(msgs[17]); }); } } }