public void Constructor_CalculationWithOutput_ExpectedValues(double sectionLength) { // Setup var failureMechanism = new PipingFailureMechanism(); var mocks = new MockRepository(); IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); mocks.ReplayAll(); var calculation = new SemiProbabilisticPipingCalculationScenario { Output = PipingTestDataGenerator.GetRandomSemiProbabilisticPipingOutput() }; var failureMechanismSection = new FailureMechanismSection("test", new[] { new Point2D(0, 0), new Point2D(sectionLength, 0) }); // Call var row = new SemiProbabilisticPipingScenarioRow(calculation, failureMechanism, failureMechanismSection, assessmentSection); // Assert 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(Math.Min(1.0, expectedDerivedOutput.PipingProbability * failureMechanism.PipingProbabilityAssessmentInput.GetN( failureMechanismSection.Length)), row.SectionFailureProbability); mocks.VerifyAll(); }
public void Constructor_ExpectedValues() { // Setup var failureMechanism = new PipingFailureMechanism(); var mocks = new MockRepository(); IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks); mocks.ReplayAll(); var calculation = new SemiProbabilisticPipingCalculationScenario(); FailureMechanismSection failureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection(); // Call var row = new SemiProbabilisticPipingScenarioRow(calculation, failureMechanism, failureMechanismSection, assessmentSection); // Assert Assert.IsInstanceOf <PipingScenarioRow <SemiProbabilisticPipingCalculationScenario> >(row); Assert.AreSame(calculation, row.CalculationScenario); TestHelper.AssertTypeConverter <SemiProbabilisticPipingScenarioRow, NoProbabilityValueDoubleConverter>( nameof(SemiProbabilisticPipingScenarioRow.FailureProbabilityUplift)); TestHelper.AssertTypeConverter <SemiProbabilisticPipingScenarioRow, NoProbabilityValueDoubleConverter>( nameof(SemiProbabilisticPipingScenarioRow.FailureProbabilityHeave)); TestHelper.AssertTypeConverter <SemiProbabilisticPipingScenarioRow, NoProbabilityValueDoubleConverter>( nameof(SemiProbabilisticPipingScenarioRow.FailureProbabilitySellmeijer)); }
public void Create_StochasticSoilProfileSet_EntityHasStochasticSoilProfileEntity() { // Setup PipingSoilProfile soilProfile = PipingSoilProfileTestFactory.CreatePipingSoilProfile(); var stochasticSoilProfile = new PipingStochasticSoilProfile(0.6, soilProfile); PipingStochasticSoilModel soilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel("A", new[] { stochasticSoilProfile }); var registry = new PersistenceRegistry(); StochasticSoilModelEntity soilModelEntity = soilModel.Create(registry, 0); var calculation = new SemiProbabilisticPipingCalculationScenario { InputParameters = { StochasticSoilModel = soilModel, StochasticSoilProfile = stochasticSoilProfile } }; // Call SemiProbabilisticPipingCalculationEntity entity = calculation.Create(registry, 0); // Assert PipingStochasticSoilProfileEntity expectedStochasticSoilProfileEntity = soilModelEntity.PipingStochasticSoilProfileEntities.First(); Assert.AreSame(expectedStochasticSoilProfileEntity, entity.PipingStochasticSoilProfileEntity); Assert.IsTrue(registry.Contains(soilModel)); }
public void Create_HasCalculationOutput_EntityHasPipingCalculationOutputEntity() { // Setup var registry = new PersistenceRegistry(); SemiProbabilisticPipingOutput newOutput = PipingTestDataGenerator.GetRandomSemiProbabilisticPipingOutput(); var calculation = new SemiProbabilisticPipingCalculationScenario { Output = newOutput }; // Call SemiProbabilisticPipingCalculationEntity entity = calculation.Create(registry, 0); // Assert SemiProbabilisticPipingCalculationOutputEntity outputEntity = entity.SemiProbabilisticPipingCalculationOutputEntities.SingleOrDefault(); Assert.IsNotNull(outputEntity); Assert.AreEqual(newOutput.HeaveFactorOfSafety, outputEntity.HeaveFactorOfSafety); Assert.AreEqual(newOutput.SellmeijerFactorOfSafety, outputEntity.SellmeijerFactorOfSafety); Assert.AreEqual(newOutput.UpliftFactorOfSafety, outputEntity.UpliftFactorOfSafety); Assert.AreEqual(newOutput.UpliftEffectiveStress, outputEntity.UpliftEffectiveStress, newOutput.UpliftEffectiveStress.GetAccuracy()); Assert.AreEqual(newOutput.HeaveGradient, outputEntity.HeaveGradient, newOutput.HeaveGradient.GetAccuracy()); Assert.AreEqual(newOutput.SellmeijerCreepCoefficient, outputEntity.SellmeijerCreepCoefficient, newOutput.SellmeijerCreepCoefficient.GetAccuracy()); Assert.AreEqual(newOutput.SellmeijerCriticalFall, outputEntity.SellmeijerCriticalFall, newOutput.SellmeijerCriticalFall.GetAccuracy()); Assert.AreEqual(newOutput.SellmeijerReducedFall, outputEntity.SellmeijerReducedFall, newOutput.SellmeijerReducedFall.GetAccuracy()); }
public void Create_HasSurfaceLineSet_EntityHasSurfaceLineEntity() { // Setup var surfaceLine = new PipingSurfaceLine(string.Empty) { ReferenceLineIntersectionWorldPoint = new Point2D(1.1, 2.2) }; surfaceLine.SetGeometry(new[] { new Point3D(0.0, 0.0, 1.0), new Point3D(3.3, 6.6, 1.0) }); var registry = new PersistenceRegistry(); SurfaceLineEntity surfaceLineEntity = surfaceLine.Create(registry, 0); var calculation = new SemiProbabilisticPipingCalculationScenario { InputParameters = { SurfaceLine = surfaceLine } }; // Call SemiProbabilisticPipingCalculationEntity entity = calculation.Create(registry, 0); // Assert Assert.AreSame(surfaceLineEntity, entity.SurfaceLineEntity); }
public void CloseForData_NestedViewNotCorrespondingToRemovedAssessmentSection_ReturnsFalse() { // Setup var calculation = new SemiProbabilisticPipingCalculationScenario(); var calculationGroup = new CalculationGroup(); calculationGroup.Children.Add(calculation); var failureMechanism = new PipingFailureMechanism(); failureMechanism.CalculationsGroup.Children.Add(calculationGroup); var assessmentSection = mocks.Stub <IAssessmentSection>(); assessmentSection.Stub(section => section.GetFailureMechanisms()).Return(new[] { failureMechanism }); mocks.ReplayAll(); using (var view = new PipingInputView { Data = new SemiProbabilisticPipingCalculationScenario() }) { // Call bool closeForData = info.CloseForData(view, assessmentSection); // Assert Assert.IsFalse(closeForData); mocks.VerifyAll(); } }
public void CloseForData_NestedViewCorrespondingToRemovedFailureMechanismContext_ReturnsTrue() { // Setup var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var calculation = new SemiProbabilisticPipingCalculationScenario(); var calculationGroup = new CalculationGroup(); calculationGroup.Children.Add(calculation); var failureMechanism = new PipingFailureMechanism(); failureMechanism.CalculationsGroup.Children.Add(calculationGroup); var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection); using (var view = new PipingInputView { Data = calculation }) { // Call bool closeForData = info.CloseForData(view, context); // Assert Assert.IsTrue(closeForData); mocks.VerifyAll(); } }
public void Read_EntityWithSurfaceLineNotYetInCollector_CalculationWithCreatedSurfaceLineAndRegisteredNewEntities() { // Setup var points = new[] { new Point3D(1, 3, 4), new Point3D(7, 10, 11) }; var surfaceLineEntity = new SurfaceLineEntity { Name = "surface line", PointsXml = new Point3DCollectionXmlSerializer().ToXml(points) }; var entity = new SemiProbabilisticPipingCalculationEntity { SurfaceLineEntity = surfaceLineEntity, EntryPointL = 1, ExitPointL = 2, DampingFactorExitMean = 1, ScenarioContribution = 0 }; var collector = new ReadConversionCollector(); // Call SemiProbabilisticPipingCalculationScenario calculation = entity.Read(collector); // Assert Assert.IsTrue(collector.ContainsPipingSurfaceLine(surfaceLineEntity)); CollectionAssert.AreEqual(points, calculation.InputParameters.SurfaceLine.Points); }
public void ParameteredConstructor_ParentNull_ThrowsArgumentNullException() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var surfaceLines = new[] { new PipingSurfaceLine(string.Empty) }; PipingStochasticSoilModel[] soilModels = { PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel() }; var calculation = new SemiProbabilisticPipingCalculationScenario(); var failureMechanism = new PipingFailureMechanism(); // Call TestDelegate call = () => new SemiProbabilisticPipingCalculationScenarioContext(calculation, null, surfaceLines, soilModels, failureMechanism, assessmentSection); // Assert var exception = Assert.Throws <ArgumentNullException>(call); Assert.AreEqual("parent", exception.ParamName); mocks.VerifyAll(); }
public void Read_EntityWithSurfaceLineInCollector_CalculationHasAlreadyReadSurfaceLine() { // Setup var surfaceLine = new PipingSurfaceLine(string.Empty); surfaceLine.SetGeometry(new[] { new Point3D(1, 2, 3), new Point3D(4, 5, 6) }); var surfaceLineEntity = new SurfaceLineEntity(); var entity = new SemiProbabilisticPipingCalculationEntity { SurfaceLineEntity = surfaceLineEntity, EntryPointL = 1, ExitPointL = 2, DampingFactorExitMean = 1, ScenarioContribution = 0 }; var collector = new ReadConversionCollector(); collector.Read(surfaceLineEntity, surfaceLine); // Call SemiProbabilisticPipingCalculationScenario calculation = entity.Read(collector); // Assert Assert.AreSame(surfaceLine, calculation.InputParameters.SurfaceLine); Assert.AreEqual(1, calculation.InputParameters.EntryPointL, 1e-6); Assert.AreEqual(2, calculation.InputParameters.ExitPointL, 1e-6); }
/// <summary> /// Assigns the hydraulic boundary location or the assessment level that is set manually. /// </summary> /// <param name="calculationConfiguration">The calculation read from the imported file.</param> /// <param name="pipingCalculation">The semi-probabilistic calculation to configure.</param> /// <returns><c>false</c> when the <paramref name="calculationConfiguration"/> has a <see cref="HydraulicBoundaryLocation"/> /// set which is not available in <see cref="availableHydraulicBoundaryLocations"/>, <c>true</c> otherwise.</returns> private bool TrySetSemiProbabilisticHydraulicBoundaryData(PipingCalculationConfiguration calculationConfiguration, SemiProbabilisticPipingCalculationScenario pipingCalculation) { bool locationRead = TryReadHydraulicBoundaryLocation(calculationConfiguration.HydraulicBoundaryLocationName, calculationConfiguration.Name, availableHydraulicBoundaryLocations, out HydraulicBoundaryLocation location); if (!locationRead) { return(false); } if (calculationConfiguration.AssessmentLevel.HasValue) { pipingCalculation.InputParameters.UseAssessmentLevelManualInput = true; pipingCalculation.InputParameters.AssessmentLevel = (RoundedDouble)calculationConfiguration.AssessmentLevel.Value; } else { SetLocation(pipingCalculation, location); } return(true); }
public void CloseForData_ViewCorrespondingToRemovedPipingCalculationScenarioContext_ReturnsTrue() { // Setup var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var pipingCalculation = new SemiProbabilisticPipingCalculationScenario(); var pipingCalculationScenarioContext = new SemiProbabilisticPipingCalculationScenarioContext(pipingCalculation, new CalculationGroup(), Enumerable.Empty <PipingSurfaceLine>(), Enumerable.Empty <PipingStochasticSoilModel>(), new PipingFailureMechanism(), assessmentSection); using (var view = new PipingInputView { Data = pipingCalculation }) { // Call bool closeForData = info.CloseForData(view, pipingCalculationScenarioContext); // Assert Assert.IsTrue(closeForData); mocks.VerifyAll(); } }
public void CloseForData_NestedViewNotCorrespondingWithRemovedParentPipingCalculationGroupContext_ReturnsFalse() { // Setup var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var calculation = new SemiProbabilisticPipingCalculationScenario(); var nestedGroup = new CalculationGroup(); nestedGroup.Children.Add(calculation); var calculationGroup = new CalculationGroup(); calculationGroup.Children.Add(nestedGroup); var calculationGroupContext = new PipingCalculationGroupContext(new CalculationGroup(), null, Enumerable.Empty <PipingSurfaceLine>(), Enumerable.Empty <PipingStochasticSoilModel>(), new PipingFailureMechanism(), assessmentSection); using (var view = new PipingInputView { Data = calculation }) { // Call bool closeForData = info.CloseForData(view, calculationGroupContext); // Assert Assert.IsFalse(closeForData); mocks.VerifyAll(); } }
public void Read_EntityWithHydraulicBoundaryLocationInCollector_CalculationHasAlreadyReadHydraulicBoundaryLocation() { // Setup var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(); var hydraulicLocationEntity = new HydraulicLocationEntity(); var entity = new SemiProbabilisticPipingCalculationEntity { HydraulicLocationEntity = hydraulicLocationEntity, EntryPointL = 1, ExitPointL = 2, DampingFactorExitMean = 1, AssessmentLevel = 5.81, UseAssessmentLevelManualInput = Convert.ToByte(false), ScenarioContribution = 0 }; var collector = new ReadConversionCollector(); collector.Read(hydraulicLocationEntity, hydraulicBoundaryLocation); // Call SemiProbabilisticPipingCalculationScenario calculation = entity.Read(collector); // Assert Assert.AreSame(hydraulicBoundaryLocation, calculation.InputParameters.HydraulicBoundaryLocation); }
/// <summary> /// Gets a <see cref="SemiProbabilisticPipingCalculationScenario"/> with <c>double.NegativeInfinity</c> /// and <c>double.PositiveInfinity</c> values set. /// </summary> /// <returns>A <see cref="SemiProbabilisticPipingCalculationScenario"/> with <c>double.NegativeInfinity</c> /// and <c>double.PositiveInfinity</c> values.</returns> public static SemiProbabilisticPipingCalculationScenario GetSemiProbabilisticPipingCalculationScenarioWithInfinities() { SemiProbabilisticPipingCalculationScenario calculation = GetPipingCalculationScenarioWithAssessmentLevel(); calculation.InputParameters.SurfaceLine.SetGeometry(new[] { new Point3D(0, double.NegativeInfinity, 0), new Point3D(0, double.PositiveInfinity, 0) }); calculation.InputParameters.AssessmentLevel = (RoundedDouble)double.NegativeInfinity; calculation.InputParameters.EntryPointL = (RoundedDouble)double.NegativeInfinity; calculation.InputParameters.ExitPointL = (RoundedDouble)double.PositiveInfinity; calculation.InputParameters.PhreaticLevelExit = new NormalDistribution { Mean = (RoundedDouble)double.NegativeInfinity, StandardDeviation = (RoundedDouble)double.PositiveInfinity }; calculation.InputParameters.DampingFactorExit = new LogNormalDistribution { Mean = (RoundedDouble)double.PositiveInfinity, StandardDeviation = (RoundedDouble)double.PositiveInfinity }; return(calculation); }
public void Read_EntityWithStochasticSoilModelEntityInCollector_CalculationHasAlreadyReadStochasticSoilModel() { // Setup PipingStochasticSoilModel stochasticSoilModel = PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel(); var stochasticSoilModelEntity = new StochasticSoilModelEntity(); var stochasticSoilProfile = new PipingStochasticSoilProfile(1, PipingSoilProfileTestFactory.CreatePipingSoilProfile()); var stochasticSoilProfileEntity = new PipingStochasticSoilProfileEntity { StochasticSoilModelEntity = stochasticSoilModelEntity }; var entity = new SemiProbabilisticPipingCalculationEntity { PipingStochasticSoilProfileEntity = stochasticSoilProfileEntity, EntryPointL = 1, ExitPointL = 2, DampingFactorExitMean = 1, ScenarioContribution = 0 }; var collector = new ReadConversionCollector(); collector.Read(stochasticSoilProfileEntity, stochasticSoilProfile); collector.Read(stochasticSoilModelEntity, stochasticSoilModel); // Call SemiProbabilisticPipingCalculationScenario calculation = entity.Read(collector); // Assert Assert.AreSame(stochasticSoilProfile, calculation.InputParameters.StochasticSoilProfile); Assert.AreSame(stochasticSoilModel, calculation.InputParameters.StochasticSoilModel); }
public void ParameteredConstructor_ExpectedValues() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var calculation = new SemiProbabilisticPipingCalculationScenario(); var surfaceLines = new[] { new PipingSurfaceLine(string.Empty) }; PipingStochasticSoilModel[] stochasticSoilModels = { PipingStochasticSoilModelTestFactory.CreatePipingStochasticSoilModel() }; var failureMechanism = new PipingFailureMechanism(); // Call var context = new SemiProbabilisticPipingInputContext(calculation.InputParameters, calculation, surfaceLines, stochasticSoilModels, failureMechanism, assessmentSection); // Assert Assert.IsInstanceOf <PipingContext <SemiProbabilisticPipingInput> >(context); Assert.AreSame(calculation.InputParameters, context.WrappedData); Assert.AreSame(calculation, context.PipingCalculation); Assert.AreSame(failureMechanism, context.FailureMechanism); Assert.AreSame(assessmentSection, context.AssessmentSection); CollectionAssert.AreEqual(surfaceLines, context.AvailablePipingSurfaceLines); CollectionAssert.AreEqual(stochasticSoilModels, context.AvailableStochasticSoilModels); mocks.VerifyAll(); }
public void Read_EntityWithSemiProbabilisticPipingCalculationOutputEntity_CalculationWithSemiProbabilisticPipingOutput() { // Setup var entity = new SemiProbabilisticPipingCalculationEntity { SemiProbabilisticPipingCalculationOutputEntities = { new SemiProbabilisticPipingCalculationOutputEntity() }, ScenarioContribution = 0 }; var collector = new ReadConversionCollector(); // Call SemiProbabilisticPipingCalculationScenario calculation = entity.Read(collector); // Assert SemiProbabilisticPipingOutput output = calculation.Output; Assert.IsNotNull(output); Assert.IsNaN(output.HeaveFactorOfSafety); Assert.IsNaN(output.SellmeijerFactorOfSafety); Assert.IsNaN(output.UpliftFactorOfSafety); Assert.IsNaN(output.UpliftEffectiveStress); Assert.IsNaN(output.HeaveGradient); Assert.IsNaN(output.SellmeijerCreepCoefficient); Assert.IsNaN(output.SellmeijerCriticalFall); Assert.IsNaN(output.SellmeijerReducedFall); }
public DerivedSemiProbabilisticPipingCalculationScenarioContext(SemiProbabilisticPipingCalculationScenario calculation, CalculationGroup parent, IEnumerable <PipingSurfaceLine> surfaceLines, IEnumerable <PipingStochasticSoilModel> stochasticSoilModels, PipingFailureMechanism pipingFailureMechanism, IAssessmentSection assessmentSection) : base(calculation, parent, surfaceLines, stochasticSoilModels, pipingFailureMechanism, assessmentSection) { }
private static void ReadCalculationOutputs(SemiProbabilisticPipingCalculationScenario calculation, SemiProbabilisticPipingCalculationEntity entity) { SemiProbabilisticPipingCalculationOutputEntity calculationOutputEntity = entity.SemiProbabilisticPipingCalculationOutputEntities.SingleOrDefault(); if (calculationOutputEntity != null) { calculation.Output = calculationOutputEntity.Read(); } }
public void UpdateModelWithImportedData_ProfilesAssignedToCalculationsWithOneImportedModelProfileRemoved_OneProfileRemovedCalculationUpdatedAccordingly() { // Setup const string modelsName = "same model"; PipingStochasticSoilModel existingModel = CreateSimpleModel(modelsName, "Unaffected Profile", "Removed Profile"); var failureMechanism = new PipingFailureMechanism(); PipingStochasticSoilModelCollection targetCollection = failureMechanism.StochasticSoilModels; targetCollection.AddRange(new[] { existingModel }, sourceFilePath); PipingStochasticSoilProfile firstExistingProfile = existingModel.StochasticSoilProfiles.First(); PipingStochasticSoilModel readModel = CreateSimpleModel(modelsName, firstExistingProfile.SoilProfile.Name); var calculationWithNotUpdatedProfile = new SemiProbabilisticPipingCalculationScenario(); calculationWithNotUpdatedProfile.InputParameters.StochasticSoilModel = existingModel; calculationWithNotUpdatedProfile.InputParameters.StochasticSoilProfile = existingModel.StochasticSoilProfiles.ElementAt(0); calculationWithNotUpdatedProfile.Output = new SemiProbabilisticPipingOutput(new SemiProbabilisticPipingOutput.ConstructionProperties()); var calculationWithDeletedProfile = new SemiProbabilisticPipingCalculationScenario(); calculationWithDeletedProfile.InputParameters.StochasticSoilModel = existingModel; calculationWithDeletedProfile.InputParameters.StochasticSoilProfile = existingModel.StochasticSoilProfiles.ElementAt(1); calculationWithDeletedProfile.Output = new SemiProbabilisticPipingOutput(new SemiProbabilisticPipingOutput.ConstructionProperties()); failureMechanism.CalculationsGroup.Children.Add(calculationWithDeletedProfile); failureMechanism.CalculationsGroup.Children.Add(calculationWithNotUpdatedProfile); var strategy = new PipingStochasticSoilModelUpdateDataStrategy(failureMechanism); // Call IEnumerable <IObservable> affectedObjects = strategy.UpdateModelWithImportedData(new[] { readModel }, sourceFilePath).ToArray(); // Assert PipingStochasticSoilModel firstSoilModel = targetCollection[0]; Assert.AreSame(existingModel, firstSoilModel); Assert.AreSame(firstExistingProfile, firstSoilModel.StochasticSoilProfiles.ElementAt(0)); Assert.IsTrue(calculationWithNotUpdatedProfile.HasOutput); CollectionAssert.DoesNotContain(affectedObjects, calculationWithNotUpdatedProfile); CollectionAssert.DoesNotContain(affectedObjects, calculationWithNotUpdatedProfile.InputParameters); Assert.IsFalse(calculationWithDeletedProfile.HasOutput); Assert.IsNull(calculationWithDeletedProfile.InputParameters.StochasticSoilProfile); CollectionAssert.Contains(affectedObjects, calculationWithDeletedProfile); CollectionAssert.Contains(affectedObjects, calculationWithDeletedProfile.InputParameters); }
public void VerifyUpdates_CalculationWithOutputs_AlwaysReturnsExpectedInquiryMessage(bool isActionConfirmed) { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); var mainWindow = mocks.Stub <IMainWindow>(); var gui = mocks.Stub <IGui>(); gui.Stub(g => g.MainWindow).Return(mainWindow); mocks.ReplayAll(); plugin.Gui = gui; var failureMechanism = new PipingFailureMechanism(); var calculationWithOutput = new SemiProbabilisticPipingCalculationScenario { Output = PipingTestDataGenerator.GetRandomSemiProbabilisticPipingOutput() }; failureMechanism.CalculationsGroup.Children.Add(calculationWithOutput); var surfaceLines = new PipingSurfaceLineCollection(); var context = new PipingSurfaceLinesContext(surfaceLines, failureMechanism, assessmentSection); string textBoxMessage = null; DialogBoxHandler = (name, wnd) => { var helper = new MessageBoxTester(wnd); textBoxMessage = helper.Text; if (isActionConfirmed) { helper.ClickOk(); } else { helper.ClickCancel(); } }; // Call bool updatesVerified = importInfo.VerifyUpdates(context); // Assert string expectedInquiryMessage = "Als u profielschematisaties importeert, " + "dan worden alle rekenresultaten van dit faalmechanisme verwijderd." + $"{Environment.NewLine}{Environment.NewLine}Weet u zeker dat u wilt doorgaan?"; Assert.AreEqual(expectedInquiryMessage, textBoxMessage); Assert.AreEqual(isActionConfirmed, updatesVerified); mocks.VerifyAll(); }
public void Clone_NotAllPropertiesSet_ReturnNewInstanceWithCopiedValues() { // Setup SemiProbabilisticPipingCalculationScenario original = CreateRandomCalculationScenarioWithoutOutput(); // Call object clone = original.Clone(); // Assert CoreCloneAssert.AreObjectClones(original, clone, PipingCloneAssert.AreClones); }
public void Contribution_SetValidValue_ValueSet(double newValue) { // Setup var calculationScenario = new SemiProbabilisticPipingCalculationScenario(); // Call calculationScenario.Contribution = (RoundedDouble)newValue; // Assert Assert.AreEqual(4, calculationScenario.Contribution.NumberOfDecimalPlaces); Assert.AreEqual(newValue, calculationScenario.Contribution, calculationScenario.Contribution.GetAccuracy()); }
public void Create_PersistenceRegistryIsNull_ThrowArgumentNullException() { // Setup var calculation = new SemiProbabilisticPipingCalculationScenario(); // Call void Call() => calculation.Create(null, 0); // Assert var exception = Assert.Throws <ArgumentNullException>(Call); Assert.AreEqual("registry", exception.ParamName); }
public void Constructor_ExpectedValues() { // Call var scenario = new SemiProbabilisticPipingCalculationScenario(); // Assert Assert.IsInstanceOf <SemiProbabilisticPipingCalculation>(scenario); Assert.IsInstanceOf <IPipingCalculationScenario <SemiProbabilisticPipingInput> >(scenario); Assert.IsTrue(scenario.IsRelevant); Assert.AreEqual(4, scenario.Contribution.NumberOfDecimalPlaces); Assert.AreEqual(1.0, scenario.Contribution, scenario.Contribution.GetAccuracy()); }
public void Contribution_SetInvalidValue_ThrowArgumentException(double newValue) { // Setup var calculationScenario = new SemiProbabilisticPipingCalculationScenario(); // Call void Call() => calculationScenario.Contribution = (RoundedDouble)newValue; // Assert const string expectedMessage = "De waarde voor de bijdrage moet binnen het bereik [0, 100] liggen."; TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentOutOfRangeException>(Call, expectedMessage); }
public void Read_ValidEntity_ReturnSemiProbabilisticPipingCalculationScenario( bool isRelevant, bool useAssessmentLevelManualInput, double contribution, string name, string comments, double entryPoint, double exitPoint, double assessmentLevel, int seed) { // Setup var random = new Random(seed); var entity = new SemiProbabilisticPipingCalculationEntity { RelevantForScenario = Convert.ToByte(isRelevant), ScenarioContribution = contribution, Name = name, Comments = comments, EntryPointL = entryPoint.ToNaNAsNull(), ExitPointL = exitPoint.ToNaNAsNull(), PhreaticLevelExitMean = random.NextDouble(-9999.99, 9999.99), PhreaticLevelExitStandardDeviation = random.NextDouble(0, 9999.99), DampingFactorExitMean = random.NextDouble(1e-6, 9999.99), DampingFactorExitStandardDeviation = random.NextDouble(0, 9999.99), AssessmentLevel = assessmentLevel.ToNaNAsNull(), UseAssessmentLevelManualInput = Convert.ToByte(useAssessmentLevelManualInput) }; var collector = new ReadConversionCollector(); // Call SemiProbabilisticPipingCalculationScenario calculation = entity.Read(collector); // Assert Assert.AreEqual(isRelevant, calculation.IsRelevant); RoundedDoubleTestHelper.AssertRoundedDouble(contribution, calculation.Contribution); Assert.AreEqual(name, calculation.Name); Assert.AreEqual(comments, calculation.Comments.Body); RoundedDoubleTestHelper.AssertRoundedDouble(entryPoint, calculation.InputParameters.EntryPointL); RoundedDoubleTestHelper.AssertRoundedDouble(exitPoint, calculation.InputParameters.ExitPointL); RoundedDoubleTestHelper.AssertRoundedDouble(entity.PhreaticLevelExitMean, calculation.InputParameters.PhreaticLevelExit.Mean); RoundedDoubleTestHelper.AssertRoundedDouble(entity.PhreaticLevelExitStandardDeviation, calculation.InputParameters.PhreaticLevelExit.StandardDeviation); RoundedDoubleTestHelper.AssertRoundedDouble(entity.DampingFactorExitMean, calculation.InputParameters.DampingFactorExit.Mean); RoundedDoubleTestHelper.AssertRoundedDouble(entity.DampingFactorExitStandardDeviation, calculation.InputParameters.DampingFactorExit.StandardDeviation); Assert.AreEqual(useAssessmentLevelManualInput, calculation.InputParameters.UseAssessmentLevelManualInput); Assert.AreEqual(entity.AssessmentLevel.ToNullAsNaN(), calculation.InputParameters.AssessmentLevel.Value); Assert.IsNull(calculation.InputParameters.SurfaceLine); Assert.IsNull(calculation.InputParameters.HydraulicBoundaryLocation); Assert.IsNull(calculation.InputParameters.StochasticSoilModel); Assert.IsNull(calculation.InputParameters.StochasticSoilProfile); Assert.IsNull(calculation.Output); }
public void Create_WithCalculationGroup_ReturnFailureMechanismEntityWithCalculationGroupEntities() { // Setup var calculationGroup = new CalculationGroup(); var semiProbabilisticPipingCalculationScenario = new SemiProbabilisticPipingCalculationScenario(); var probabilisticPipingCalculationScenario = new ProbabilisticPipingCalculationScenario(); var failureMechanism = new PipingFailureMechanism(); failureMechanism.CalculationsGroup.Children.Add(calculationGroup); failureMechanism.CalculationsGroup.Children.Add(semiProbabilisticPipingCalculationScenario); failureMechanism.CalculationsGroup.Children.Add(probabilisticPipingCalculationScenario); // Call FailureMechanismEntity entity = failureMechanism.Create(new PersistenceRegistry()); // Assert Assert.IsNotNull(entity); Assert.AreEqual(failureMechanism.CalculationsGroup.Name, entity.CalculationGroupEntity.Name); Assert.AreEqual(0, entity.CalculationGroupEntity.Order); CalculationGroupEntity[] childGroupEntities = entity.CalculationGroupEntity.CalculationGroupEntity1 .OrderBy(cge => cge.Order) .ToArray(); Assert.AreEqual(1, childGroupEntities.Length); CalculationGroupEntity childGroupEntity = childGroupEntities[0]; Assert.AreEqual(calculationGroup.Name, childGroupEntity.Name); Assert.AreEqual(0, childGroupEntity.Order); SemiProbabilisticPipingCalculationEntity[] semiProbabilisticPipingCalculationEntities = entity.CalculationGroupEntity .SemiProbabilisticPipingCalculationEntities .OrderBy(ce => ce.Order) .ToArray(); Assert.AreEqual(1, semiProbabilisticPipingCalculationEntities.Length); SemiProbabilisticPipingCalculationEntity semiProbabilisticPipingCalculationEntity = semiProbabilisticPipingCalculationEntities[0]; Assert.AreEqual(semiProbabilisticPipingCalculationScenario.Name, semiProbabilisticPipingCalculationEntity.Name); Assert.AreEqual(1, semiProbabilisticPipingCalculationEntity.Order); ProbabilisticPipingCalculationEntity[] probabilisticPipingCalculationEntities = entity.CalculationGroupEntity .ProbabilisticPipingCalculationEntities .OrderBy(ce => ce.Order) .ToArray(); Assert.AreEqual(1, probabilisticPipingCalculationEntities.Length); ProbabilisticPipingCalculationEntity probabilisticPipingCalculationEntity = probabilisticPipingCalculationEntities[0]; Assert.AreEqual(probabilisticPipingCalculationScenario.Name, probabilisticPipingCalculationEntity.Name); Assert.AreEqual(2, probabilisticPipingCalculationEntity.Order); }
/// <summary> /// Parses a semi-probabilistic calculation from the provided <paramref name="readCalculation"/>. /// </summary> /// <param name="readCalculation">The calculation read from XML.</param> /// <returns>The parsed <see cref="SemiProbabilisticPipingCalculationScenario"/>, /// or <c>null</c> when parsing failed.</returns> private ICalculation ParseReadCalculationAsSemiProbabilistic(PipingCalculationConfiguration readCalculation) { var pipingCalculation = new SemiProbabilisticPipingCalculationScenario { Name = readCalculation.Name }; if (TrySetSemiProbabilisticHydraulicBoundaryData(readCalculation, pipingCalculation) && TrySetGenericData(readCalculation, pipingCalculation)) { return(pipingCalculation); } return(null); }