private static void SetPropertyToInvalidValueAndVerifyException( Action <PipingCalculationRow> setProperty, IPipingCalculationScenario <PipingInput> calculation, string expectedMessage) { // Setup var mocks = new MockRepository(); var observable = mocks.StrictMock <IObservable>(); mocks.ReplayAll(); var handler = new SetPropertyValueAfterConfirmationParameterTester( new[] { observable }); var row = new PipingCalculationRow(calculation, string.Empty, handler); // Call void Call() => setProperty(row); // Assert TestHelper.AssertThrowsArgumentExceptionAndTestMessage <ArgumentOutOfRangeException>(Call, expectedMessage); Assert.IsTrue(handler.Called); mocks.VerifyAll(); }
/// <summary> /// Assigns the stochastic soil model. /// </summary> /// <param name="calculationConfiguration">The calculation read from the imported file.</param> /// <param name="pipingCalculation">The calculation to configure.</param> /// <returns><c>false</c> when /// <list type="bullet"> /// <item>the <paramref name="calculationConfiguration"/> has a <see cref="PipingStochasticSoilModel"/> set /// which is not available in the failure mechanism.</item> /// <item>The <see cref="PipingStochasticSoilModel"/> does not intersect with the <see cref="PipingSurfaceLine"/> /// when this is set.</item> /// </list> /// <c>true</c> otherwise.</returns> private bool TrySetStochasticSoilModel(PipingCalculationConfiguration calculationConfiguration, IPipingCalculationScenario <PipingInput> pipingCalculation) { if (calculationConfiguration.StochasticSoilModelName != null) { PipingStochasticSoilModel soilModel = failureMechanism.StochasticSoilModels .FirstOrDefault(ssm => ssm.Name == calculationConfiguration.StochasticSoilModelName); if (soilModel == null) { Log.LogCalculationConversionError(string.Format( Resources.PipingCalculationConfigurationImporter_ReadStochasticSoilModel_Stochastische_soil_model_0_does_not_exist, calculationConfiguration.StochasticSoilModelName), pipingCalculation.Name); return(false); } if (pipingCalculation.InputParameters.SurfaceLine != null && !soilModel.IntersectsWithSurfaceLineGeometry(pipingCalculation.InputParameters.SurfaceLine)) { Log.LogCalculationConversionError(string.Format( Resources.PipingCalculationConfigurationImporter_ReadStochasticSoilModel_Stochastische_soil_model_0_does_not_intersect_with_surfaceLine_1, calculationConfiguration.StochasticSoilModelName, calculationConfiguration.SurfaceLineName), pipingCalculation.Name); return(false); } pipingCalculation.InputParameters.StochasticSoilModel = soilModel; } return(true); }
private static void SetPropertyAndVerifyNotificationsAndOutputForCalculation( Action <PipingCalculationRow> setProperty, IPipingCalculationScenario <PipingInput> calculation) { // Setup var mocks = new MockRepository(); var observable = mocks.StrictMock <IObservable>(); observable.Expect(o => o.NotifyObservers()); mocks.ReplayAll(); var handler = new SetPropertyValueAfterConfirmationParameterTester( new[] { observable }); var row = new PipingCalculationRow(calculation, string.Empty, handler); // Call setProperty(row); // Assert Assert.IsTrue(handler.Called); mocks.VerifyAll(); }
public void CreateCalculationFeatures_GivenCalculations_ReturnsCalculationFeaturesCollection() { // Setup IPipingCalculationScenario <PipingInput> calculationA = PipingCalculationScenarioTestFactory.CreateCalculationWithValidInput( new HydraulicBoundaryLocation(1, string.Empty, 5.0, 4.0)); IPipingCalculationScenario <PipingInput> calculationB = PipingCalculationScenarioTestFactory.CreateCalculationWithValidInput( new HydraulicBoundaryLocation(1, string.Empty, 2.2, 3.8)); calculationA.InputParameters.SurfaceLine.ReferenceLineIntersectionWorldPoint = new Point2D(1.0, 3.0); calculationB.InputParameters.SurfaceLine.ReferenceLineIntersectionWorldPoint = new Point2D(1.0, 4.0); // Call IEnumerable <MapFeature> features = PipingMapDataFeaturesFactory.CreateCalculationFeatures(new[] { calculationA, calculationB }); // Assert Assert.AreEqual(2, features.Count()); Assert.AreEqual(1, features.ElementAt(0).MapGeometries.Count()); Assert.AreEqual(1, features.ElementAt(1).MapGeometries.Count()); AssertEqualPointCollections(new[] { new Point2D(1.0, 3.0), new Point2D(5.0, 4.0) }, features.ElementAt(0).MapGeometries.ElementAt(0)); AssertEqualPointCollections(new[] { new Point2D(1.0, 4.0), new Point2D(2.2, 3.8) }, features.ElementAt(1).MapGeometries.ElementAt(0)); }
/// <summary> /// Assigns the hydraulic boundary location. /// </summary> /// <param name="pipingCalculation">The calculation to configure.</param> /// <param name="location">The <see cref="HydraulicBoundaryLocation"/> to assign.</param> private static void SetLocation(IPipingCalculationScenario <PipingInput> pipingCalculation, HydraulicBoundaryLocation location) { if (location != null) { pipingCalculation.InputParameters.HydraulicBoundaryLocation = location; } }
/// <summary> /// Assigns the stochastic soil profile. /// </summary> /// <param name="calculationConfiguration">The calculation read from the imported file.</param> /// <param name="pipingCalculation">The calculation to configure.</param> /// <returns><c>false</c> when the <paramref name="calculationConfiguration"/> has: /// <list type="bullet"> /// <item>a <see cref="PipingStochasticSoilProfile"/> set but no <see cref="PipingStochasticSoilModel"/> is specified;</item> /// <item>a <see cref="PipingStochasticSoilProfile"/> set which is not available in the <see cref="PipingStochasticSoilModel"/>.</item> /// </list> /// <c>true</c> otherwise.</returns> private bool TrySetStochasticSoilProfile(PipingCalculationConfiguration calculationConfiguration, IPipingCalculationScenario <PipingInput> pipingCalculation) { if (calculationConfiguration.StochasticSoilProfileName != null) { if (pipingCalculation.InputParameters.StochasticSoilModel == null) { Log.LogCalculationConversionError(string.Format( Resources.PipingCalculationConfigurationImporter_ReadStochasticSoilProfile_No_soil_model_provided_for_soil_profile_with_name_0, calculationConfiguration.StochasticSoilProfileName), pipingCalculation.Name); return(false); } PipingStochasticSoilProfile soilProfile = pipingCalculation.InputParameters .StochasticSoilModel .StochasticSoilProfiles .FirstOrDefault(ssp => ssp.SoilProfile.Name == calculationConfiguration.StochasticSoilProfileName); if (soilProfile == null) { Log.LogCalculationConversionError(string.Format( Resources.PipingCalculationConfigurationImporter_ReadStochasticSoilProfile_Stochastic_soil_profile_0_does_not_exist_within_soil_model_1, calculationConfiguration.StochasticSoilProfileName, calculationConfiguration.StochasticSoilModelName), pipingCalculation.Name); return(false); } pipingCalculation.InputParameters.StochasticSoilProfile = soilProfile; } return(true); }
/// <summary> /// Creates a new instance of <see cref="PipingCalculationRow"/>. /// </summary> /// <param name="calculationScenario">The <see cref="IPipingCalculationScenario{TPipingInput}"/> this row contains.</param> /// <param name="calculationType">The description of the type of calculation scenario that is presented in the row.</param> /// <param name="handler">The handler responsible for handling effects of a property change.</param> /// <exception cref="ArgumentNullException">Thrown when <paramref name="calculationScenario"/> or /// <paramref name="handler"/> is <c>null</c>.</exception> internal PipingCalculationRow(IPipingCalculationScenario <PipingInput> calculationScenario, string calculationType, IObservablePropertyChangeHandler handler) : base(calculationScenario, handler) { CalculationType = calculationType; }
private static void AssertCalculationScenario(IPipingCalculationScenario <PipingInput> calculationScenario, PipingStochasticSoilProfile stochasticSoilProfile, PipingSurfaceLine surfaceLine) { PipingInput input = calculationScenario.InputParameters; Assert.AreSame(stochasticSoilProfile, input.StochasticSoilProfile); Assert.AreSame(surfaceLine, input.SurfaceLine); Assert.AreEqual((RoundedDouble)stochasticSoilProfile.Probability, calculationScenario.Contribution); }
public void ExitPointL_OnValidChange_NotifyObserverAndCalculationPropertyChanged() { // Setup IPipingCalculationScenario <PipingInput> calculation = PipingCalculationScenarioTestFactory.CreateCalculationWithValidInput(new TestHydraulicBoundaryLocation()); var exitPointL = (RoundedDouble)0.3; // Call & Assert SetPropertyAndVerifyNotificationsAndOutputForCalculation(row => row.ExitPointL = exitPointL, calculation); }
private bool TrySetGenericData(PipingCalculationConfiguration readCalculation, IPipingCalculationScenario <PipingInput> pipingCalculation) { return(TrySetSurfaceLine(readCalculation, pipingCalculation) && TrySetEntryExitPoint(readCalculation, pipingCalculation) && TrySetStochasticSoilModel(readCalculation, pipingCalculation) && TrySetStochasticSoilProfile(readCalculation, pipingCalculation) && TrySetStochasts(readCalculation, pipingCalculation) && TrySetScenarioParameters(readCalculation.Scenario, pipingCalculation)); }
private bool TrySetPhreaticLevelExit(PipingCalculationConfiguration calculationConfiguration, IPipingCalculationScenario <PipingInput> pipingCalculation) { return(ConfigurationImportHelper.TrySetStandardDeviationStochast( PipingCalculationConfigurationSchemaIdentifiers.PhreaticLevelExitStochastName, pipingCalculation.Name, pipingCalculation.InputParameters, calculationConfiguration.PhreaticLevelExit, i => i.PhreaticLevelExit, (i, s) => i.PhreaticLevelExit = s, Log)); }
public void ExitPointL_NotOnSurfaceLine_ThrowsArgumentOutOfRangeExceptionAndDoesNotNotifyObservers() { // Setup IPipingCalculationScenario <PipingInput> calculation = PipingCalculationScenarioTestFactory.CreateCalculationWithValidInput(new TestHydraulicBoundaryLocation()); var exitPointL = (RoundedDouble)3.0; // Call & Assert const string expectedMessage = "Het gespecificeerde punt moet op het profiel liggen (bereik [0,0, 1,0])."; SetPropertyToInvalidValueAndVerifyException(row => row.ExitPointL = exitPointL, calculation, expectedMessage); }
public void ExitPointL_ExitPointNotBeyondEntryPoint_ThrowsArgumentOutOfRangeExceptionDoesNotNotifyObservers(double newValue) { // Setup IPipingCalculationScenario <PipingInput> calculation = PipingCalculationScenarioTestFactory.CreateCalculationWithValidInput(new TestHydraulicBoundaryLocation()); var exitPointL = (RoundedDouble)newValue; // Call & Assert const string expectedMessage = "Het uittredepunt moet landwaarts van het intredepunt liggen."; SetPropertyToInvalidValueAndVerifyException(row => row.ExitPointL = exitPointL, calculation, expectedMessage); }
private static void AssertPropertyChangeWithOrWithoutCalculationOutput( Action <PipingCalculationRow> setProperty, Action <IPipingCalculationScenario <PipingInput> > assertions, bool hasOutput, bool expectUpdates) { // Setup var mockRepository = new MockRepository(); var inputObserver = mockRepository.StrictMock <IObserver>(); if (expectUpdates) { inputObserver.Expect(o => o.UpdateObserver()); } var calculationObserver = mockRepository.StrictMock <IObserver>(); if (expectUpdates && hasOutput) { calculationObserver.Expect(o => o.UpdateObserver()); } var handler = mockRepository.Stub <IObservablePropertyChangeHandler>(); mockRepository.ReplayAll(); IPipingCalculationScenario <PipingInput> calculation = PipingCalculationScenarioTestFactory.CreateCalculationWithValidInput(new TestHydraulicBoundaryLocation(), hasOutput); var row = new PipingCalculationRow(calculation, string.Empty, handler); calculation.Attach(calculationObserver); calculation.InputParameters.Attach(inputObserver); // Call setProperty(row); // Assert assertions(calculation); if (expectUpdates) { Assert.IsFalse(calculation.HasOutput); } else { Assert.AreEqual(hasOutput, calculation.HasOutput); } mockRepository.VerifyAll(); }
/// <summary> /// Assigns the entry point and exit point. /// </summary> /// <param name="calculationConfiguration">The calculation read from the imported file.</param> /// <param name="pipingCalculation">The calculation to configure.</param> /// <returns><c>false</c> when entry or exit point is set without <see cref="PipingSurfaceLine"/>, /// or when entry or exit point is invalid, <c>true</c> otherwise.</returns> private bool TrySetEntryExitPoint(PipingCalculationConfiguration calculationConfiguration, IPipingCalculationScenario <PipingInput> pipingCalculation) { bool hasEntryPoint = calculationConfiguration.EntryPointL.HasValue; bool hasExitPoint = calculationConfiguration.ExitPointL.HasValue; if (calculationConfiguration.SurfaceLineName == null && (hasEntryPoint || hasExitPoint)) { Log.LogCalculationConversionError(Resources.PipingCalculationConfigurationImporter_ReadSurfaceLine_EntryPointL_or_ExitPointL_defined_without_SurfaceLine, pipingCalculation.Name); return(false); } if (hasEntryPoint) { double entryPoint = calculationConfiguration.EntryPointL.Value; try { pipingCalculation.InputParameters.EntryPointL = (RoundedDouble)entryPoint; } catch (ArgumentOutOfRangeException e) { Log.LogOutOfRangeException(string.Format(Resources.PipingCalculationConfigurationImporter_ReadEntryExitPoint_Entry_point_invalid, entryPoint), pipingCalculation.Name, e); return(false); } } if (hasExitPoint) { double exitPoint = calculationConfiguration.ExitPointL.Value; try { pipingCalculation.InputParameters.ExitPointL = (RoundedDouble)exitPoint; } catch (ArgumentOutOfRangeException e) { Log.LogOutOfRangeException(string.Format(Resources.PipingCalculationConfigurationImporter_ReadEntryExitPoint_Exit_point_invalid, exitPoint), pipingCalculation.Name, e); return(false); } } return(true); }
/// <inheritdoc/> /// <exception cref="NotSupportedException">Thrown when <paramref name="calculation"/> is of a type that is not supported.</exception> protected override PipingCalculationRow CreateRow(IPipingCalculationScenario <PipingInput> calculation) { string calculationType; switch (calculation) { case SemiProbabilisticPipingCalculationScenario _: calculationType = RiskeerPipingDataResources.SemiProbabilistic_DisplayName; break; case ProbabilisticPipingCalculationScenario _: calculationType = RiskeerPipingDataResources.Probabilistic_DisplayName; break; default: throw new NotSupportedException(); } return(new PipingCalculationRow(calculation, calculationType, new ObservablePropertyChangeHandler(calculation, calculation.InputParameters))); }
/// <summary> /// Assigns the surface line. /// </summary> /// <param name="calculationConfiguration">The calculation read from the imported file.</param> /// <param name="pipingCalculation">The calculation to configure.</param> /// <returns><c>false</c> when the <paramref name="calculationConfiguration"/> has a <see cref="PipingSurfaceLine"/> /// set which is not available in <see cref="PipingFailureMechanism.SurfaceLines"/>, <c>true</c> otherwise.</returns> private bool TrySetSurfaceLine(PipingCalculationConfiguration calculationConfiguration, IPipingCalculationScenario <PipingInput> pipingCalculation) { if (calculationConfiguration.SurfaceLineName != null) { PipingSurfaceLine surfaceLine = failureMechanism.SurfaceLines .FirstOrDefault(sl => sl.Name == calculationConfiguration.SurfaceLineName); if (surfaceLine == null) { Log.LogCalculationConversionError(string.Format( Resources.PipingCalculationConfigurationImporter_ReadSurfaceLine_SurfaceLine_0_does_not_exist, calculationConfiguration.SurfaceLineName), pipingCalculation.Name); return(false); } pipingCalculation.InputParameters.SurfaceLine = surfaceLine; } return(true); }
/// <inheritdoc/> /// <exception cref="NotSupportedException">Thrown when <paramref name="calculation"/> /// is of an unsupported type.</exception> protected override PipingCalculationConfiguration ToConfiguration(IPipingCalculationScenario <PipingInput> calculation) { PipingInput input = calculation.InputParameters; PipingCalculationConfigurationType calculationConfigurationType = GetCalculationConfigurationType(calculation); var calculationConfiguration = new PipingCalculationConfiguration(calculation.Name, calculationConfigurationType) { DampingFactorExit = input.DampingFactorExit.ToStochastConfiguration(), PhreaticLevelExit = input.PhreaticLevelExit.ToStochastConfiguration(), Scenario = calculation.ToScenarioConfiguration() }; if (input.SurfaceLine != null) { calculationConfiguration.SurfaceLineName = input.SurfaceLine.Name; calculationConfiguration.EntryPointL = input.EntryPointL; calculationConfiguration.ExitPointL = input.ExitPointL; } if (input.StochasticSoilModel != null) { calculationConfiguration.StochasticSoilModelName = input.StochasticSoilModel.Name; calculationConfiguration.StochasticSoilProfileName = input.StochasticSoilProfile?.SoilProfile.Name; } if (calculationConfigurationType == PipingCalculationConfigurationType.SemiProbabilistic) { ToSemiProbabilisticConfiguration(calculationConfiguration, (SemiProbabilisticPipingInput)calculation.InputParameters); } if (calculationConfigurationType == PipingCalculationConfigurationType.Probabilistic) { ToProbabilisticConfiguration(calculationConfiguration, (ProbabilisticPipingInput)calculation.InputParameters); } return(calculationConfiguration); }
/// <summary> /// Gets the <see cref="PipingCalculationConfigurationType"/> based on the type of <paramref name="calculation"/>. /// </summary> /// <param name="calculation">The calculation scenario to get the type for.</param> /// <returns>The <see cref="PipingCalculationConfigurationType"/>.</returns> /// <exception cref="NotSupportedException">Thrown when <paramref name="calculation"/> /// is of an unsupported type.</exception> private static PipingCalculationConfigurationType GetCalculationConfigurationType(IPipingCalculationScenario <PipingInput> calculation) { switch (calculation) { case SemiProbabilisticPipingCalculationScenario _: return(PipingCalculationConfigurationType.SemiProbabilistic); case ProbabilisticPipingCalculationScenario _: return(PipingCalculationConfigurationType.Probabilistic); default: throw new NotSupportedException(); } }
/// <summary> /// Assigns the stochasts. /// </summary> /// <param name="calculationConfiguration">The calculation read from the imported file.</param> /// <param name="pipingCalculation">The calculation to configure.</param> /// <returns><c>false</c> when a stochast value (mean or standard deviation) is invalid, <c>true</c> otherwise.</returns> private bool TrySetStochasts(PipingCalculationConfiguration calculationConfiguration, IPipingCalculationScenario <PipingInput> pipingCalculation) { return(TrySetPhreaticLevelExit(calculationConfiguration, pipingCalculation) && TrySetDampingFactorExit(calculationConfiguration, pipingCalculation)); }