public void DesignWaterLevelCalculationsView_CalculationUpdated_DataGridViewCorrectlyUpdated()
{
// Setup
IObservableEnumerable <HydraulicBoundaryLocationCalculation> hydraulicBoundaryLocationCalculations = GetTestHydraulicBoundaryLocationCalculations();
ShowFullyConfiguredDesignWaterLevelCalculationsView(hydraulicBoundaryLocationCalculations, testForm);
// Precondition
DataGridViewControl calculationsDataGridViewControl = GetCalculationsDataGridViewControl();
DataGridViewRowCollection rows = calculationsDataGridViewControl.Rows;
DataGridViewCellCollection cells = rows[0].Cells;
Assert.AreEqual(6, cells.Count);
Assert.AreEqual(false, cells[includeIllustrationPointsColumnIndex].FormattedValue);
HydraulicBoundaryLocationCalculation calculation = hydraulicBoundaryLocationCalculations.First();
// Call
calculation.InputParameters.ShouldIllustrationPointsBeCalculated = true;
calculation.NotifyObservers();
// Assert
Assert.AreEqual(true, cells[includeIllustrationPointsColumnIndex].FormattedValue);
}
/// <summary>
/// Performs a calculation for the wave height.
/// </summary>
/// <param name="hydraulicBoundaryLocationCalculation">The hydraulic boundary location calculation to perform.</param>
/// <param name="calculationSettings">The <see cref="HydraulicBoundaryCalculationSettings"/> with the
/// hydraulic boundary calculation settings.</param>
/// <param name="targetProbability">The target probability to use during the calculation.</param>
/// <param name="messageProvider">The object which is used to build log messages.</param>
/// <exception cref="CriticalFileReadException">Thrown when:
/// <list type="bullet">
/// <item>No settings database file could be found at the location of the hydraulic boundary database file path.
/// with the same name.</item>
/// <item>Unable to open settings database file.</item>
/// <item>Unable to read required data from database file.</item>
/// </list></exception>
/// <exception cref="HydraRingCalculationException">Thrown when an error occurs while performing the calculation.</exception>
private void PerformCalculation(HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation,
HydraulicBoundaryCalculationSettings calculationSettings,
double targetProbability,
ICalculationMessageProvider messageProvider)
{
HydraulicBoundaryLocation hydraulicBoundaryLocation = hydraulicBoundaryLocationCalculation.HydraulicBoundaryLocation;
WaveHeightCalculationInput calculationInput = CreateInput(hydraulicBoundaryLocation.Id, targetProbability, calculationSettings);
calculator.Calculate(calculationInput);
if (canceled || !string.IsNullOrEmpty(calculator.LastErrorFileContent))
{
return;
}
GeneralResult <TopLevelSubMechanismIllustrationPoint> generalResult = null;
try
{
generalResult = hydraulicBoundaryLocationCalculation.InputParameters.ShouldIllustrationPointsBeCalculated
? GetGeneralResult(calculator.IllustrationPointsResult)
: null;
}
catch (ArgumentException e)
{
log.Warn(string.Format(Resources.CalculationService_Error_in_reading_illustrationPoints_for_CalculationName_0_with_ErrorMessage_1,
hydraulicBoundaryLocation.Name,
e.Message));
}
HydraulicBoundaryLocationCalculationOutput hydraulicBoundaryLocationCalculationOutput = CreateOutput(
messageProvider, hydraulicBoundaryLocation.Name, calculationInput.Beta, targetProbability, calculator.Converged, generalResult);
hydraulicBoundaryLocationCalculation.Output = hydraulicBoundaryLocationCalculationOutput;
}
public void GivenMapLayerWithHydraulicBoundaryLocationsData_WhenHydraulicBoundaryLocationCalculationUpdatedAndNotified_ThenMapDataUpdated(
Func <IAssessmentSection, HydraulicBoundaryLocationCalculation> getCalculationFunc)
{
// Given
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
var hydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "test1", 1.0, 2.0);
var assessmentSection = new AssessmentSectionStub();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
using (var mapLayer = new HydraulicBoundaryLocationsMapLayer(assessmentSection))
{
mapLayer.MapData.Attach(observer);
// Precondition
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
// When
HydraulicBoundaryLocationCalculation calculation = getCalculationFunc(assessmentSection);
calculation.Output = new TestHydraulicBoundaryLocationCalculationOutput(new Random(21).NextDouble());
calculation.NotifyObservers();
// Then
MapDataTestHelper.AssertHydraulicBoundaryLocationsMapData(assessmentSection, mapLayer.MapData);
}
mocks.VerifyAll();
}
private static bool HasHydraulicBoundaryLocationCalculationOutput(HydraulicBoundaryLocationCalculation calculation)
{
return(calculation.HasOutput);
}
public void Run_InvalidCalculation_LogsErrorAndThrowException(bool endInFailure, string lastErrorFileContent)
{
// Setup
const string locationName = "locationName";
const string calculationFailedMessage = "calculationFailedMessage";
var calculator = new TestDesignWaterLevelCalculator
{
LastErrorFileContent = lastErrorFileContent,
EndInFailure = endInFailure
};
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(null))
.IgnoreArguments()
.Return(calculator);
var calculationMessageProvider = mockRepository.Stub <ICalculationMessageProvider>();
if (endInFailure && string.IsNullOrEmpty(lastErrorFileContent))
{
calculationMessageProvider.Expect(mp => mp.GetCalculationFailedMessage(locationName)).Return(calculationFailedMessage);
}
else
{
calculationMessageProvider.Expect(mp => mp.GetCalculationFailedWithErrorReportMessage(locationName,
endInFailure && string.IsNullOrEmpty(lastErrorFileContent)
? calculator.HydraRingCalculationException.Message
: lastErrorFileContent
)).Return(calculationFailedMessage);
}
mockRepository.ReplayAll();
var hydraulicBoundaryLocationCalculation = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation(locationName));
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
HydraRingCalculationException exception = null;
// Call
Action call = () =>
{
try
{
new DesignWaterLevelCalculationService().Calculate(hydraulicBoundaryLocationCalculation,
CreateCalculationSettings(),
1.0 / 30,
calculationMessageProvider);
}
catch (HydraRingCalculationException e)
{
exception = e;
}
};
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(4, msgs.Length);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
Assert.AreEqual(calculationFailedMessage, msgs[1]);
Assert.AreEqual($"Waterstand berekening is uitgevoerd op de tijdelijke locatie '{calculator.OutputDirectory}'. " +
"Gedetailleerde invoer en uitvoer kan in de bestanden op deze locatie worden gevonden.", msgs[2]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[3]);
});
Assert.IsInstanceOf <HydraRingCalculationException>(exception);
}
mockRepository.VerifyAll();
}
private static void MergeCalculationData(HydraulicBoundaryLocationCalculation targetCalculation, HydraulicBoundaryLocationCalculation sourceCalculation)
{
targetCalculation.InputParameters.ShouldIllustrationPointsBeCalculated = sourceCalculation.InputParameters.ShouldIllustrationPointsBeCalculated;
targetCalculation.Output = sourceCalculation.Output;
}
public void CreateInstance_WithContext_SetsExpectedCalculationData()
{
// Setup
var hydraulicBoundaryLocationCalculation = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation());
var calculationsForTargetProbability = new HydraulicBoundaryLocationCalculationsForTargetProbability(0.01)
{
HydraulicBoundaryLocationCalculations =
{
hydraulicBoundaryLocationCalculation
}
};
var assessmentSection = new AssessmentSectionStub();
assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities.Add(calculationsForTargetProbability);
var context = new WaterLevelCalculationsForUserDefinedTargetProbabilityContext(calculationsForTargetProbability, assessmentSection);
var mockRepository = new MockRepository();
var guiService = mockRepository.StrictMock <IHydraulicBoundaryLocationCalculationGuiService>();
double actualNormValue = double.NaN;
IEnumerable <HydraulicBoundaryLocationCalculation> performedCalculations = null;
guiService.Expect(ch => ch.CalculateDesignWaterLevels(null, null, int.MinValue, null)).IgnoreArguments().WhenCalled(
invocation =>
{
performedCalculations = (IEnumerable <HydraulicBoundaryLocationCalculation>)invocation.Arguments[0];
actualNormValue = (double)invocation.Arguments[2];
});
mockRepository.ReplayAll();
using (var plugin = new RiskeerPlugin())
{
ViewInfo info = GetViewInfo(plugin);
// Call
var view = (DesignWaterLevelCalculationsView)info.CreateInstance(context);
using (var testForm = new Form())
{
view.CalculationGuiService = guiService;
testForm.Controls.Add(view);
testForm.Show();
DataGridView calculationsDataGridView = ControlTestHelper.GetDataGridView(view, "DataGridView");
DataGridViewRowCollection rows = calculationsDataGridView.Rows;
rows[0].Cells[calculateColumnIndex].Value = true;
view.CalculationGuiService = guiService;
var button = new ButtonTester("CalculateForSelectedButton", testForm);
button.Click();
// Assert
Assert.AreEqual(calculationsForTargetProbability.TargetProbability, actualNormValue);
Assert.AreSame(hydraulicBoundaryLocationCalculation, performedCalculations.Single());
}
}
mockRepository.VerifyAll();
}
public void GetProperties_ValidData_ReturnsExpectedValues(bool withIllustrationPoints)
{
// Setup
var random = new Random();
double targetProbability = random.NextDouble();
double targetReliability = random.NextDouble();
double calculatedProbability = random.NextDouble();
double calculatedReliability = random.NextDouble();
double result = random.NextDouble();
var convergence = random.NextEnumValue <CalculationConvergence>();
var illustrationPoints = new[]
{
new TopLevelSubMechanismIllustrationPoint(new WindDirection("WEST", 4), "sluit", new TestSubMechanismIllustrationPoint())
};
var stochasts = new[]
{
new Stochast("a", 2, 3)
};
const string governingWindDirection = "EAST";
GeneralResult <TopLevelSubMechanismIllustrationPoint> generalResult =
withIllustrationPoints
? new GeneralResult <TopLevelSubMechanismIllustrationPoint>(new WindDirection(governingWindDirection, 2),
stochasts,
illustrationPoints)
: null;
var hydraulicBoundaryLocationCalculationOutput = new HydraulicBoundaryLocationCalculationOutput(result,
targetProbability,
targetReliability,
calculatedProbability,
calculatedReliability,
convergence,
generalResult);
var calculation = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
{
Output = hydraulicBoundaryLocationCalculationOutput
};
// Call
var properties = new TestHydraulicBoundaryLocationCalculationBaseProperties(calculation);
// Assert
Assert.AreEqual(targetProbability, properties.TargetProbability);
Assert.AreEqual(targetReliability, properties.TargetReliability, properties.TargetReliability.GetAccuracy());
Assert.AreEqual(calculatedProbability, properties.CalculatedProbability);
Assert.AreEqual(calculatedReliability, properties.CalculatedReliability, properties.CalculatedReliability.GetAccuracy());
Assert.AreEqual(convergence, properties.Convergence);
Assert.AreEqual(calculation.InputParameters.ShouldIllustrationPointsBeCalculated, properties.ShouldIllustrationPointsBeCalculated);
if (withIllustrationPoints)
{
GeneralResult <TopLevelSubMechanismIllustrationPoint> expectedGeneralResult = hydraulicBoundaryLocationCalculationOutput.GeneralResult;
CollectionAssert.AreEqual(expectedGeneralResult.Stochasts, properties.AlphaValues);
CollectionAssert.AreEqual(expectedGeneralResult.Stochasts, properties.Durations);
CollectionAssert.AreEqual(expectedGeneralResult.TopLevelIllustrationPoints, properties.IllustrationPoints.Select(ip => ip.Data));
Assert.AreEqual(expectedGeneralResult.GoverningWindDirection.Name, properties.GoverningWindDirection);
}
}
public void Constructor_WithoutGeneralIllustrationPointsResult_PropertiesHaveExpectedAttributesValues()
{
// Setup
var hydraulicBoundaryLocationCalculation = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation());
// Call
var properties = new TestHydraulicBoundaryLocationCalculationBaseProperties(hydraulicBoundaryLocationCalculation);
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(7, dynamicProperties.Count);
const string resultCategory = "Resultaat";
const string illustrationPointsCategory = "Illustratiepunten";
PropertyDescriptor resultProperty = dynamicProperties[resultPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(resultProperty,
resultCategory,
nameof(properties.Result),
"",
true);
PropertyDescriptor targetProbabilityProperty = dynamicProperties[targetProbabilityPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(targetProbabilityProperty,
resultCategory,
"Doelkans [1/jaar]",
"De ingevoerde kans waarvoor het resultaat moet worden berekend.",
true);
PropertyDescriptor targetReliabilityProperty = dynamicProperties[targetReliabilityPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(targetReliabilityProperty,
resultCategory,
"Betrouwbaarheidsindex doelkans [-]",
"Betrouwbaarheidsindex van de ingevoerde kans waarvoor het resultaat moet worden berekend.",
true);
PropertyDescriptor calculatedProbabilityProperty = dynamicProperties[calculatedProbabilityPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(calculatedProbabilityProperty,
resultCategory,
"Berekende kans [1/jaar]",
"De berekende kans van voorkomen van het berekende resultaat.",
true);
PropertyDescriptor calculatedReliabilityProperty = dynamicProperties[calculatedReliabilityPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(calculatedReliabilityProperty,
resultCategory,
"Betrouwbaarheidsindex berekende kans [-]",
"Betrouwbaarheidsindex van de berekende kans van voorkomen van het berekende resultaat.",
true);
PropertyDescriptor convergenceProperty = dynamicProperties[convergencePropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(convergenceProperty,
resultCategory,
"Convergentie",
string.Empty,
true);
PropertyDescriptor calculateIllustrationPointsProperty = dynamicProperties[shouldCalculateIllustrationPointsIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(calculateIllustrationPointsProperty,
illustrationPointsCategory,
"Illustratiepunten inlezen",
"Neem de informatie over de illustratiepunten op in het berekeningsresultaat.");
}
/// <summary>
/// Creates a new instance of <see cref="DesignWaterLevelCalculationProperties"/>.
/// </summary>
/// <param name="hydraulicBoundaryLocationCalculation">The hydraulic boundary location calculation.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="hydraulicBoundaryLocationCalculation"/> is <c>null</c>.</exception>
public DesignWaterLevelCalculationProperties(HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation)
: base(hydraulicBoundaryLocationCalculation)
{
}
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 GivenViewWithInputData_WhenHydraulicBoundaryLocationCalculationChangedAndCalculationNotified_ThenUpdatedDataIsShownInChart()
{
// Given
var random = new Random(39);
var profile = new TestForeshoreProfile(new[]
{
new Point2D(0.0, 0.0),
new Point2D(1.0, 1.0),
new Point2D(2.0, 2.0)
});
var calculation = new TestWaveConditionsCalculation <WaveConditionsInput>(new WaveConditionsInput())
{
InputParameters =
{
HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(),
ForeshoreProfile = profile,
LowerBoundaryRevetment = (RoundedDouble)5,
UpperBoundaryRevetment = (RoundedDouble)8,
LowerBoundaryWaterLevels = (RoundedDouble)3,
UpperBoundaryWaterLevels = (RoundedDouble)7
}
};
HydraulicBoundaryLocationCalculation newHydraulicBoundaryLocationCalculation = GetHydraulicBoundaryLocationCalculation(random.NextRoundedDouble());
HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation = GetHydraulicBoundaryLocationCalculation(random.NextRoundedDouble());
using (var view = new WaveConditionsInputView(calculation,
() => hydraulicBoundaryLocationCalculation,
new TestWaveConditionsInputViewStyle()))
{
var foreshoreChartData = (ChartLineData)view.Chart.Data.Collection.ElementAt(foreShoreChartDataIndex);
var lowerBoundaryRevetmentChartData = (ChartLineData)view.Chart.Data.Collection.ElementAt(lowerBoundaryRevetmentChartDataIndex);
var upperBoundaryRevetmentChartData = (ChartLineData)view.Chart.Data.Collection.ElementAt(upperBoundaryRevetmentChartDataIndex);
var lowerBoundaryWaterLevelsChartData = (ChartLineData)view.Chart.Data.Collection.ElementAt(lowerBoundaryWaterLevelsChartDataIndex);
var upperBoundaryWaterLevelsChartData = (ChartLineData)view.Chart.Data.Collection.ElementAt(upperBoundaryWaterLevelsChartDataIndex);
var assessmentLevelChartData = (ChartLineData)view.Chart.Data.Collection.ElementAt(assessmentLevelChartDataIndex);
var waterLevelsChartData = (ChartMultipleLineData)view.Chart.Data.Collection.ElementAt(waterLevelsChartDataIndex);
var revetmentBaseChartData = (ChartLineData)view.Chart.Data.Collection.ElementAt(revetmentBaseChartDataIndex);
var revetmentChartData = (ChartLineData)view.Chart.Data.Collection.ElementAt(revetmentChartDataIndex);
// When
hydraulicBoundaryLocationCalculation = newHydraulicBoundaryLocationCalculation;
calculation.InputParameters.NotifyObservers();
newHydraulicBoundaryLocationCalculation.Output = new TestHydraulicBoundaryLocationCalculationOutput(random.NextRoundedDouble());
newHydraulicBoundaryLocationCalculation.NotifyObservers();
// Then
Assert.AreSame(foreshoreChartData, (ChartLineData)view.Chart.Data.Collection.ElementAt(foreShoreChartDataIndex));
Assert.AreSame(lowerBoundaryRevetmentChartData, (ChartLineData)view.Chart.Data.Collection.ElementAt(lowerBoundaryRevetmentChartDataIndex));
Assert.AreSame(upperBoundaryRevetmentChartData, (ChartLineData)view.Chart.Data.Collection.ElementAt(upperBoundaryRevetmentChartDataIndex));
Assert.AreSame(lowerBoundaryWaterLevelsChartData, (ChartLineData)view.Chart.Data.Collection.ElementAt(lowerBoundaryWaterLevelsChartDataIndex));
Assert.AreSame(upperBoundaryWaterLevelsChartData, (ChartLineData)view.Chart.Data.Collection.ElementAt(upperBoundaryWaterLevelsChartDataIndex));
Assert.AreSame(assessmentLevelChartData, (ChartLineData)view.Chart.Data.Collection.ElementAt(assessmentLevelChartDataIndex));
Assert.AreSame(waterLevelsChartData, (ChartMultipleLineData)view.Chart.Data.Collection.ElementAt(waterLevelsChartDataIndex));
Assert.AreSame(revetmentBaseChartData, (ChartLineData)view.Chart.Data.Collection.ElementAt(revetmentBaseChartDataIndex));
Assert.AreSame(revetmentChartData, (ChartLineData)view.Chart.Data.Collection.ElementAt(revetmentChartDataIndex));
AssertForeshoreChartData(profile, foreshoreChartData);
AssertChartData(calculation.InputParameters.ForeshoreGeometry, calculation.InputParameters.LowerBoundaryRevetment,
lowerBoundaryRevetmentChartData, "Ondergrens bekleding");
AssertChartData(calculation.InputParameters.ForeshoreGeometry, calculation.InputParameters.UpperBoundaryRevetment,
upperBoundaryRevetmentChartData, "Bovengrens bekleding");
AssertChartData(calculation.InputParameters.ForeshoreGeometry, calculation.InputParameters.LowerBoundaryWaterLevels,
lowerBoundaryWaterLevelsChartData, "Ondergrens waterstanden");
AssertChartData(calculation.InputParameters.ForeshoreGeometry, calculation.InputParameters.UpperBoundaryWaterLevels,
upperBoundaryWaterLevelsChartData, "Bovengrens waterstanden");
RoundedDouble expectedAssessmentLevel = newHydraulicBoundaryLocationCalculation.Output.Result;
AssertChartData(calculation.InputParameters.ForeshoreGeometry, expectedAssessmentLevel,
assessmentLevelChartData, "Waterstand bij doelkans");
AssertWaterLevelsChartData(calculation.InputParameters.ForeshoreGeometry,
calculation.InputParameters.GetWaterLevels(expectedAssessmentLevel),
waterLevelsChartData);
AssertRevetmentBaseChartData(profile.Geometry.Last(),
calculation.InputParameters.LowerBoundaryRevetment,
calculation.InputParameters.LowerBoundaryWaterLevels,
revetmentBaseChartData);
AssertRevetmentChartData(profile.Geometry.Last(), calculation.InputParameters.LowerBoundaryRevetment,
calculation.InputParameters.UpperBoundaryRevetment, revetmentChartData);
}
}
public void Read_EntityWithValidValues_SetsCalculationsWithExpectedValues()
{
// Setup
var random = new Random(21);
HydraulicLocationEntity hydraulicLocationEntityOne = HydraulicLocationEntityTestFactory.CreateHydraulicLocationEntity();
var calculationEntityWithoutOutput = new HydraulicLocationCalculationEntity
{
HydraulicLocationEntity = hydraulicLocationEntityOne,
ShouldIllustrationPointsBeCalculated = Convert.ToByte(random.NextBoolean())
};
HydraulicLocationEntity hydraulicLocationEntityTwo = HydraulicLocationEntityTestFactory.CreateHydraulicLocationEntity();
var calculationEntityWithOutput = new HydraulicLocationCalculationEntity
{
HydraulicLocationEntity = hydraulicLocationEntityTwo,
ShouldIllustrationPointsBeCalculated = Convert.ToByte(random.NextBoolean()),
HydraulicLocationOutputEntities =
{
new HydraulicLocationOutputEntity()
}
};
var collectionEntity = new HydraulicLocationCalculationForTargetProbabilityCollectionEntity
{
TargetProbability = random.NextDouble(0, 0.1),
HydraulicLocationCalculationEntities =
{
calculationEntityWithoutOutput,
calculationEntityWithOutput
}
};
var hydraulicBoundaryLocationOne = new TestHydraulicBoundaryLocation("1");
var hydraulicBoundaryLocationTwo = new TestHydraulicBoundaryLocation("2");
var collector = new ReadConversionCollector();
collector.Read(hydraulicLocationEntityOne, hydraulicBoundaryLocationOne);
collector.Read(hydraulicLocationEntityTwo, hydraulicBoundaryLocationTwo);
// Call
HydraulicBoundaryLocationCalculationsForTargetProbability calculations = collectionEntity.Read(collector);
// Assert
Assert.AreEqual(collectionEntity.TargetProbability, calculations.TargetProbability);
IEnumerable <HydraulicBoundaryLocationCalculation> hydraulicBoundaryLocationCalculations = calculations.HydraulicBoundaryLocationCalculations;
Assert.AreEqual(collectionEntity.HydraulicLocationCalculationEntities.Count, hydraulicBoundaryLocationCalculations.Count());
HydraulicBoundaryLocationCalculation calculationOne = hydraulicBoundaryLocationCalculations.ElementAt(0);
Assert.AreEqual(Convert.ToBoolean(calculationEntityWithoutOutput.ShouldIllustrationPointsBeCalculated),
calculationOne.InputParameters.ShouldIllustrationPointsBeCalculated);
Assert.AreSame(hydraulicBoundaryLocationOne, calculationOne.HydraulicBoundaryLocation);
Assert.IsNull(calculationOne.Output);
HydraulicBoundaryLocationCalculation calculationTwo = hydraulicBoundaryLocationCalculations.ElementAt(1);
Assert.AreEqual(Convert.ToBoolean(calculationEntityWithOutput.ShouldIllustrationPointsBeCalculated),
calculationTwo.InputParameters.ShouldIllustrationPointsBeCalculated);
Assert.AreSame(hydraulicBoundaryLocationTwo, calculationTwo.HydraulicBoundaryLocation);
Assert.IsNotNull(calculationTwo.Output);
}
/// <summary>
/// Creates a new instance of <see cref="WaveHeightCalculationContext"/>.
/// </summary>
/// <param name="wrappedData">The <see cref="HydraulicBoundaryLocationCalculation"/> which the
/// <see cref="WaveHeightCalculationContext"/> belongs to.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="wrappedData"/> is <c>null</c>.</exception>
public WaveHeightCalculationContext(HydraulicBoundaryLocationCalculation wrappedData)
: base(wrappedData)
{
}
private static bool ShouldMerge(HydraulicBoundaryLocationCalculation targetCalculation, HydraulicBoundaryLocationCalculation sourceCalculation)
{
bool targetCalculationHasOutput = targetCalculation.HasOutput;
bool sourceCalculationHasOutput = sourceCalculation.HasOutput;
if (!targetCalculationHasOutput && !sourceCalculationHasOutput ||
targetCalculationHasOutput && !sourceCalculationHasOutput ||
targetCalculationHasOutput && !targetCalculation.Output.HasGeneralResult && !sourceCalculation.Output.HasGeneralResult ||
targetCalculationHasOutput && targetCalculation.Output.HasGeneralResult && sourceCalculation.Output.HasGeneralResult ||
targetCalculationHasOutput && targetCalculation.Output.HasGeneralResult && !sourceCalculation.Output.HasGeneralResult)
{
return(false);
}
return(true);
}
public TestHydraulicBoundaryCalculationContext(HydraulicBoundaryLocationCalculation calculation)
: base(calculation)
{
}
/// <summary>
/// Creates a new instance of <see cref="WaveHeightCalculationProperties"/>.
/// </summary>
/// <param name="hydraulicBoundaryLocationCalculation">The hydraulic boundary location calculation to create the properties for.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="hydraulicBoundaryLocationCalculation"/> is <c>null</c>.</exception>
public WaveHeightCalculationProperties(HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation)
: base(hydraulicBoundaryLocationCalculation)
{
}
public void GivenCalculationsWithIllustrationPoints_WhenClearIllustrationPointsClickedAndContinue_ThenInquiryAndIllustrationPointsCleared(
Func <IAssessmentSection, HydraulicBoundaryLocationCalculation> getHydraulicLocationCalculationFunc)
{
// Given
var random = new Random(21);
IAssessmentSection assessmentSection = GetConfiguredAssessmentSectionWithHydraulicBoundaryLocationCalculations();
HydraulicBoundaryLocationCalculation calculation = getHydraulicLocationCalculationFunc(assessmentSection);
calculation.Output = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble(), new TestGeneralResultSubMechanismIllustrationPoint());
HydraulicBoundaryLocationCalculation[] calculationsWithOutput = GetAllWaveHeightCalculationsWithOutput(assessmentSection).ToArray();
var messageBoxText = "";
DialogBoxHandler = (name, wnd) =>
{
var helper = new MessageBoxTester(wnd);
messageBoxText = helper.Text;
helper.ClickOk();
};
var context = new WaveHeightCalculationsForUserDefinedTargetProbabilitiesGroupContext(
assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities,
assessmentSection);
var mockRepository = new MockRepository();
using (var treeViewControl = new TreeViewControl())
{
var calculationObserver = mockRepository.StrictMock <IObserver>();
calculationObserver.Expect(o => o.UpdateObserver());
IGui gui = StubFactory.CreateGuiStub(mockRepository);
gui.Stub(cmp => cmp.MainWindow).Return(mockRepository.Stub <IMainWindow>());
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
mockRepository.ReplayAll();
calculation.Attach(calculationObserver);
using (var plugin = new RiskeerPlugin())
{
TreeNodeInfo info = GetInfo(plugin);
plugin.Gui = gui;
using (ContextMenuStrip contextMenuAdapter = info.ContextMenuStrip(context, null, treeViewControl))
{
// When
contextMenuAdapter.Items[contextMenuClearIllustrationPointsIndex].PerformClick();
// Then
const string expectedMessage = "Weet u zeker dat u alle berekende illustratiepunten bij 'Golfhoogten bij vrije doelkans' wilt wissen?";
Assert.AreEqual(expectedMessage, messageBoxText);
Assert.IsTrue(calculationsWithOutput.All(calc => calc.HasOutput));
Assert.IsFalse(calculation.Output.HasGeneralResult);
}
}
}
mockRepository.VerifyAll();
}
/// <summary>
/// Performs a calculation for the design water level.
/// </summary>
/// <param name="hydraulicBoundaryLocationCalculation">The hydraulic boundary location calculation to perform.</param>
/// <param name="calculationSettings">The <see cref="HydraulicBoundaryCalculationSettings"/> with the
/// hydraulic boundary calculation settings.</param>
/// <param name="targetProbability">The target probability to use during the calculation.</param>
/// <param name="messageProvider">The object which is used to build log messages.</param>
/// <remarks>Preprocessing is disabled when the preprocessor directory equals <see cref="string.Empty"/>.</remarks>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="hydraulicBoundaryLocationCalculation"/>,
/// <paramref name="calculationSettings"/> or <paramref name="messageProvider"/> is <c>null</c>.</exception>
/// <exception cref="ArgumentException">Thrown when
/// <list type="bullet">
/// <item>the hydraulic boundary database file path contains invalid characters.</item>
/// <item>The target probability or the calculated probability falls outside the [0.0, 1.0] range and is not <see cref="double.NaN"/>.</item>
/// </list></exception>
/// <exception cref="CriticalFileReadException">Thrown when:
/// <list type="bullet">
/// <item>No settings database file could be found at the location of hydraulic boundary database file path.
/// with the same name.</item>
/// <item>Unable to open settings database file.</item>
/// <item>Unable to read required data from database file.</item>
/// </list></exception>
/// <exception cref="HydraRingCalculationException">Thrown when an error occurs while performing the calculation.</exception>
public void Calculate(HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation,
HydraulicBoundaryCalculationSettings calculationSettings,
double targetProbability,
ICalculationMessageProvider messageProvider)
{
if (hydraulicBoundaryLocationCalculation == null)
{
throw new ArgumentNullException(nameof(hydraulicBoundaryLocationCalculation));
}
if (calculationSettings == null)
{
throw new ArgumentNullException(nameof(calculationSettings));
}
if (messageProvider == null)
{
throw new ArgumentNullException(nameof(messageProvider));
}
HydraulicBoundaryLocation hydraulicBoundaryLocation = hydraulicBoundaryLocationCalculation.HydraulicBoundaryLocation;
CalculationServiceHelper.LogCalculationBegin();
HydraRingCalculationSettings hydraRingCalculationSettings = HydraRingCalculationSettingsFactory.CreateSettings(calculationSettings);
calculator = HydraRingCalculatorFactory.Instance.CreateDesignWaterLevelCalculator(hydraRingCalculationSettings);
var exceptionThrown = false;
try
{
PerformCalculation(hydraulicBoundaryLocationCalculation,
calculationSettings,
targetProbability,
messageProvider);
}
catch (HydraRingCalculationException)
{
if (!canceled)
{
string lastErrorContent = calculator.LastErrorFileContent;
log.Error(string.IsNullOrEmpty(lastErrorContent)
? messageProvider.GetCalculationFailedMessage(hydraulicBoundaryLocation.Name)
: messageProvider.GetCalculationFailedWithErrorReportMessage(hydraulicBoundaryLocation.Name, lastErrorContent));
exceptionThrown = true;
throw;
}
}
finally
{
string lastErrorFileContent = calculator.LastErrorFileContent;
bool errorOccurred = CalculationServiceHelper.HasErrorOccurred(canceled, exceptionThrown, lastErrorFileContent);
if (errorOccurred)
{
log.Error(messageProvider.GetCalculationFailedWithErrorReportMessage(hydraulicBoundaryLocation.Name, lastErrorFileContent));
}
log.InfoFormat(Resources.DesignWaterLevelCalculationService_Calculate_Calculation_temporary_directory_can_be_found_on_location_0, calculator.OutputDirectory);
CalculationServiceHelper.LogCalculationEnd();
if (errorOccurred)
{
throw new HydraRingCalculationException(lastErrorFileContent);
}
}
}
public void Run_InvalidCalculation_LogsErrorOutputNotUpdatedAndActivityStateFailed(bool endInFailure, string lastErrorFileContent)
{
// Setup
const string locationName = "locationName";
const string calculationIdentifier = "1/100";
var calculator = new TestDesignWaterLevelCalculator
{
EndInFailure = endInFailure,
LastErrorFileContent = lastErrorFileContent
};
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(null))
.IgnoreArguments()
.Return(calculator);
mockRepository.ReplayAll();
var output = new TestHydraulicBoundaryLocationCalculationOutput(double.NaN, CalculationConvergence.CalculatedConverged);
var hydraulicBoundaryLocationCalculation = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation(locationName))
{
InputParameters =
{
ShouldIllustrationPointsBeCalculated = true
},
Output = output
};
var activity = new DesignWaterLevelCalculationActivity(hydraulicBoundaryLocationCalculation,
CreateCalculationSettings(),
0.01,
calculationIdentifier);
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
void Call() => activity.Run();
// Assert
TestHelper.AssertLogMessages(Call, m =>
{
string[] messages = m.ToArray();
Assert.AreEqual(7, messages.Length);
Assert.AreEqual($"{GetActivityDescription(locationName, calculationIdentifier)} is gestart.", messages[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(messages[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(messages[2]);
CalculationServiceTestHelper.AssertCalculationStartMessage(messages[3]);
string expectedFailureMessage = string.IsNullOrEmpty(lastErrorFileContent)
? $"Er is een fout opgetreden tijdens de waterstand berekening voor locatie '{locationName}' ({calculationIdentifier}). Er is geen foutrapport beschikbaar."
: $"Er is een fout opgetreden tijdens de waterstand berekening voor locatie '{locationName}' ({calculationIdentifier}). Bekijk het foutrapport door op details te klikken.{Environment.NewLine}{lastErrorFileContent}";
Assert.AreEqual(expectedFailureMessage, messages[4]);
StringAssert.StartsWith("Waterstand berekening is uitgevoerd op de tijdelijke locatie", messages[5]);
CalculationServiceTestHelper.AssertCalculationEndMessage(messages[6]);
});
Assert.AreSame(output, hydraulicBoundaryLocationCalculation.Output);
Assert.AreEqual(CalculationConvergence.CalculatedConverged, hydraulicBoundaryLocationCalculation.Output.CalculationConvergence);
Assert.AreEqual(ActivityState.Failed, activity.State);
}
mockRepository.VerifyAll();
}
public void Constructor_WithGeneralIllustrationPointsResult_PropertiesHaveExpectedAttributesValues()
{
// Setup
var hydraulicBoundaryLocationCalculation = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
{
Output = new TestHydraulicBoundaryLocationCalculationOutput(new TestGeneralResultSubMechanismIllustrationPoint())
};
// Call
var properties = new TestHydraulicBoundaryLocationCalculationBaseProperties(hydraulicBoundaryLocationCalculation);
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(11, dynamicProperties.Count);
const string resultCategory = "Resultaat";
const string illustrationPointsCategory = "Illustratiepunten";
PropertyDescriptor resultProperty = dynamicProperties[resultPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(resultProperty,
resultCategory,
nameof(properties.Result),
"",
true);
PropertyDescriptor targetProbabilityProperty = dynamicProperties[targetProbabilityPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(targetProbabilityProperty,
resultCategory,
"Doelkans [1/jaar]",
"De ingevoerde kans waarvoor het resultaat moet worden berekend.",
true);
PropertyDescriptor targetReliabilityProperty = dynamicProperties[targetReliabilityPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(targetReliabilityProperty,
resultCategory,
"Betrouwbaarheidsindex doelkans [-]",
"Betrouwbaarheidsindex van de ingevoerde kans waarvoor het resultaat moet worden berekend.",
true);
PropertyDescriptor calculatedProbabilityProperty = dynamicProperties[calculatedProbabilityPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(calculatedProbabilityProperty,
resultCategory,
"Berekende kans [1/jaar]",
"De berekende kans van voorkomen van het berekende resultaat.",
true);
PropertyDescriptor calculatedReliabilityProperty = dynamicProperties[calculatedReliabilityPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(calculatedReliabilityProperty,
resultCategory,
"Betrouwbaarheidsindex berekende kans [-]",
"Betrouwbaarheidsindex van de berekende kans van voorkomen van het berekende resultaat.",
true);
PropertyDescriptor convergenceProperty = dynamicProperties[convergencePropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(convergenceProperty,
resultCategory,
"Convergentie",
string.Empty,
true);
PropertyDescriptor calculateIllustrationPointsProperty = dynamicProperties[shouldCalculateIllustrationPointsIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(calculateIllustrationPointsProperty,
illustrationPointsCategory,
"Illustratiepunten inlezen",
"Neem de informatie over de illustratiepunten op in het berekeningsresultaat.");
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(dynamicProperties[governingWindDirectionIndex],
illustrationPointsCategory,
"Maatgevende windrichting",
"De windrichting waarvoor de berekende betrouwbaarheidsindex het laagst is.",
true);
PropertyDescriptor alphaValuesProperty = dynamicProperties[alphaValuesIndex];
Assert.NotNull(alphaValuesProperty.Attributes[typeof(KeyValueElementAttribute)]);
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(alphaValuesProperty,
illustrationPointsCategory,
"Invloedscoëfficiënten [-]",
"Berekende invloedscoëfficiënten voor alle beschouwde stochasten.",
true);
PropertyDescriptor durationsProperty = dynamicProperties[durationsIndex];
Assert.NotNull(durationsProperty.Attributes[typeof(KeyValueElementAttribute)]);
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(durationsProperty,
illustrationPointsCategory,
"Tijdsduren [uur]",
"Tijdsduren waarop de stochasten betrekking hebben.",
true);
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(dynamicProperties[illustrationPointsIndex],
illustrationPointsCategory,
"Illustratiepunten",
"De lijst van illustratiepunten voor de berekening.",
true);
}
/// <summary>
/// Creates a new instance of <see cref="HydraulicBoundaryLocationCalculationProperties"/>.
/// </summary>
/// <param name="hydraulicBoundaryLocationCalculation">The hydraulic boundary location calculation.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="hydraulicBoundaryLocationCalculation"/> is <c>null</c>.</exception>
protected HydraulicBoundaryLocationCalculationProperties(HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation)
: base(hydraulicBoundaryLocationCalculation)
{
}
public TestHydraulicBoundaryLocationCalculationBaseProperties(HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation)
: base(hydraulicBoundaryLocationCalculation)
{
}
public void Calculate_ValidDesignWaterLevelCalculationAndDoesNotConverge_SetsOutputAndLogs(bool readIllustrationPoints)
{
// Setup
const string locationName = "locationName";
const string failedConvergenceMessage = "failedConvergenceMessage";
var calculator = new TestDesignWaterLevelCalculator
{
IllustrationPointsResult = new TestGeneralResult(),
Converged = false
};
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(null))
.IgnoreArguments()
.Return(calculator);
var calculationMessageProvider = mockRepository.StrictMock <ICalculationMessageProvider>();
calculationMessageProvider.Expect(c => c.GetCalculatedNotConvergedMessage(locationName)).Return(failedConvergenceMessage);
mockRepository.ReplayAll();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(locationName);
var hydraulicBoundaryLocationCalculation = new HydraulicBoundaryLocationCalculation(hydraulicBoundaryLocation)
{
InputParameters =
{
ShouldIllustrationPointsBeCalculated = readIllustrationPoints
}
};
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
Action call = () => new DesignWaterLevelCalculationService().Calculate(hydraulicBoundaryLocationCalculation,
CreateCalculationSettings(),
1.0 / 30,
calculationMessageProvider);
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(4, msgs.Length);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
Assert.AreEqual(failedConvergenceMessage, msgs[1]);
Assert.AreEqual($"Waterstand berekening is uitgevoerd op de tijdelijke locatie '{calculator.OutputDirectory}'. " +
"Gedetailleerde invoer en uitvoer kan in de bestanden op deze locatie worden gevonden.", msgs[2]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[3]);
});
Assert.IsFalse(calculator.IsCanceled);
HydraulicBoundaryLocationCalculationOutput actualOutput = hydraulicBoundaryLocationCalculation.Output;
Assert.IsNotNull(actualOutput);
Assert.AreEqual(readIllustrationPoints, actualOutput.HasGeneralResult);
}
mockRepository.VerifyAll();
}
public void ClearHydraulicBoundaryLocationCalculationIllustrationPoints_CalculationsWithAndWithoutIllustrationPoints_ClearsIllustrationPointAndReturnsAffectedCalculations()
{
// Setup
var random = new Random(21);
var originalOutputWithIllustrationPoints1 = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble(),
new TestGeneralResultSubMechanismIllustrationPoint());
var calculationWithIllustrationPoints1 = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
{
Output = originalOutputWithIllustrationPoints1
};
var originalOutputWithIllustrationPoints2 = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble(),
new TestGeneralResultSubMechanismIllustrationPoint());
var calculationWithIllustrationPoints2 = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
{
Output = originalOutputWithIllustrationPoints2
};
var originalOutput1 = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble());
var calculationWithOutput1 = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
{
Output = originalOutput1
};
var originalOutput2 = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble());
var calculationWithOutput2 = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
{
Output = originalOutput2
};
HydraulicBoundaryLocationCalculation[] calculations =
{
new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation()),
calculationWithOutput1,
calculationWithIllustrationPoints1,
new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation()),
calculationWithOutput2,
calculationWithIllustrationPoints2,
new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
};
// Call
IEnumerable <IObservable> affectedCalculations = RiskeerCommonDataSynchronizationService.ClearHydraulicBoundaryLocationCalculationIllustrationPoints(calculations);
// Assert
CollectionAssert.AreEquivalent(new[]
{
calculationWithIllustrationPoints1,
calculationWithIllustrationPoints2
}, affectedCalculations);
HydraulicBoundaryLocationCalculation[] calculationWithOutputs =
{
calculationWithOutput1,
calculationWithIllustrationPoints1,
calculationWithOutput2,
calculationWithIllustrationPoints2
};
Assert.IsTrue(calculationWithOutputs.All(calc => calc.HasOutput));
Assert.IsTrue(calculationWithOutputs.All(calc => !calc.Output.HasGeneralResult));
AssertHydraulicBoundaryLocationOutput(originalOutput1, calculationWithOutput1.Output);
AssertHydraulicBoundaryLocationOutput(originalOutput2, calculationWithOutput2.Output);
AssertHydraulicBoundaryLocationOutput(originalOutputWithIllustrationPoints1, calculationWithIllustrationPoints1.Output);
AssertHydraulicBoundaryLocationOutput(originalOutputWithIllustrationPoints2, calculationWithIllustrationPoints2.Output);
}
/// <summary>
/// Creates a new instance of <see cref="DesignWaterLevelCalculationContext"/>.
/// </summary>
/// <param name="wrappedData">The <see cref="HydraulicBoundaryLocationCalculation"/> which the
/// <see cref="DesignWaterLevelCalculationContext"/> belongs to.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="wrappedData"/> is <c>null</c>.</exception>
public DesignWaterLevelCalculationContext(HydraulicBoundaryLocationCalculation wrappedData)
: base(wrappedData)
{
}
