public void Constructor_ValidData_PropertiesHaveExpectedAttributeValues()
{
// Setup
var waternet = new MacroStabilityInwardsWaternet(Enumerable.Empty <MacroStabilityInwardsPhreaticLine>(),
Enumerable.Empty <MacroStabilityInwardsWaternetLine>());
// Call
var properties = new MacroStabilityInwardsWaternetProperties(waternet);
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(2, dynamicProperties.Count);
const string waterStressesCategoryName = "Waterspanningen";
PropertyDescriptor phreaticLinesProperty = dynamicProperties[0];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(phreaticLinesProperty,
waterStressesCategoryName,
"Stijghoogtelijnen",
"Eigenschappen van de stijghoogtelijnen.",
true);
PropertyDescriptor waternetLinesProperty = dynamicProperties[1];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(waternetLinesProperty,
waterStressesCategoryName,
"Zones",
"Eigenschappen van de zones.",
true);
}
/// <summary>
/// Asserts whether <paramref name="actual"/> corresponds to <paramref name="original"/>.
/// </summary>
/// <param name="original">The original <see cref="MacroStabilityInwardsWaternet"/>.</param>
/// <param name="expectedVisibility">The expected visibility of the chart data.</param>
/// <param name="actual">The actual <see cref="ChartDataCollection"/>.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="actual"/>
/// does not correspond to <paramref name="original"/>.</exception>
public static void AssertWaternetChartData(MacroStabilityInwardsWaternet original, bool expectedVisibility, ChartDataCollection actual)
{
ChartData[] waternetChartData = actual.Collection.ToArray();
MacroStabilityInwardsWaternetLine[] waternetLines = original.WaternetLines.ToArray();
MacroStabilityInwardsPhreaticLine[] phreaticLines = original.PhreaticLines.ToArray();
CollectionAssert.IsNotEmpty(waternetLines);
CollectionAssert.IsNotEmpty(phreaticLines);
Assert.AreEqual(waternetLines.Length + phreaticLines.Length, waternetChartData.Length);
for (var i = 0; i < waternetChartData.Length; i++)
{
if (i < phreaticLines.Length)
{
var phreaticLineChartData = (ChartLineData)waternetChartData[i];
Assert.AreEqual(phreaticLines[i].Name, phreaticLineChartData.Name);
Assert.AreEqual(phreaticLines[i].Geometry, phreaticLineChartData.Points);
Assert.AreEqual(expectedVisibility, phreaticLineChartData.IsVisible);
}
else
{
var waternetLineChartData = (ChartMultipleAreaData)waternetChartData[i];
MacroStabilityInwardsWaternetLine waternetLine = waternetLines[i - waternetLines.Length];
Assert.AreEqual(waternetLine.Name, waternetLineChartData.Name);
Assert.IsTrue(waternetLineChartData.HasData);
Assert.AreEqual(expectedVisibility, waternetLineChartData.IsVisible);
}
}
}
public void Create_WithWaternetsWithoutLines_ReturnsPersistableWaternetCollection()
{
// Setup
var dailyWaternet = new MacroStabilityInwardsWaternet(new MacroStabilityInwardsPhreaticLine[0], new MacroStabilityInwardsWaternetLine[0]);
var extremeWaternet = new MacroStabilityInwardsWaternet(new MacroStabilityInwardsPhreaticLine[0], new MacroStabilityInwardsWaternetLine[0]);
var idFactory = new IdFactory();
var registry = new MacroStabilityInwardsExportRegistry();
// Call
IEnumerable <PersistableWaternet> persistableWaternets = PersistableWaternetFactory.Create(dailyWaternet, extremeWaternet, new GeneralMacroStabilityInwardsInput(), idFactory, registry);
// Assert
PersistableDataModelTestHelper.AssertWaternets(new[]
{
dailyWaternet,
extremeWaternet
}, persistableWaternets);
var stages = new[]
{
MacroStabilityInwardsExportStageType.Daily,
MacroStabilityInwardsExportStageType.Extreme
};
Assert.AreEqual(2, registry.Waternets.Count);
for (var i = 0; i < stages.Length; i++)
{
Assert.AreEqual(registry.Waternets[stages[i]], persistableWaternets.ElementAt(i).Id);
}
}
private void SetWaternetDailyChartData(MacroStabilityInwardsWaternet waternet, MacroStabilityInwardsSurfaceLine surfaceLine)
{
if (!waternet.Equals(currentWaternetDaily) || !SurfaceLineEqual(surfaceLine))
{
currentWaternetDaily = waternet;
SetWaternetZonesChartData(waternet, surfaceLine, waternetZonesDailyChartData);
}
}
private void SetWaternetDailyChartData(MacroStabilityInwardsWaternet waternet)
{
if (!waternet.Equals(currentWaternetDaily))
{
currentWaternetDaily = waternet;
SetWaternetZonesChartData(waternet, waternetZonesDailyChartData,
phreaticLineDailyLookup, waternetLineDailyLookup);
}
}
private void SetWaternetExtremeChartData(MacroStabilityInwardsWaternet waternet)
{
if (!waternet.Equals(currentWaternetExtreme))
{
currentWaternetExtreme = waternet;
SetWaternetZonesChartData(waternet, waternetZonesExtremeChartData,
phreaticLineExtremeLookup, waternetLineExtremeLookup);
}
}
public void Convert_WithResult_ReturnMacroStabilityInwardsWaternet()
{
// Setup
WaternetCalculatorResult result = WaternetCalculatorResultTestFactory.Create();
// Call
MacroStabilityInwardsWaternet converted = MacroStabilityInwardsWaternetConverter.Convert(result);
// Assert
CalculatorOutputAssert.AssertWaternet(result, converted);
}
public void ToString_Always_ReturnEmpty()
{
// Setup
var waternet = new MacroStabilityInwardsWaternet(Enumerable.Empty <MacroStabilityInwardsPhreaticLine>(),
Enumerable.Empty <MacroStabilityInwardsWaternetLine>());
var properties = new MacroStabilityInwardsWaternetProperties(waternet);
// Call
var name = properties.ToString();
// Assert
Assert.IsEmpty(name);
}
public void Create_GeneralInputNull_ThrowsArgumentNullException()
{
// Setup
var waternet = new MacroStabilityInwardsWaternet(new MacroStabilityInwardsPhreaticLine[0], new MacroStabilityInwardsWaternetLine[0]);
// Call
void Call() => PersistableWaternetFactory.Create(waternet, waternet, null, new IdFactory(), new MacroStabilityInwardsExportRegistry());
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("generalInput", exception.ParamName);
}
public void CalculateDaily_CalculationRan_ReturnMacroStabilityInwardsWaternet()
{
// Setup
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
var calculatorFactory = (TestMacroStabilityInwardsCalculatorFactory)MacroStabilityInwardsCalculatorFactory.Instance;
// Call
MacroStabilityInwardsWaternet output = WaternetCalculationService.CalculateDaily(testCalculation.InputParameters, new GeneralMacroStabilityInwardsInput());
// Assert
CalculatorOutputAssert.AssertWaternet(calculatorFactory.LastCreatedWaternetDailyCalculator.Output, output);
}
}
public void GetWaternetDaily_ValidInput_ReturnsMacroStabilityInwardsWaternet()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
MacroStabilityInwardsWaternet waternet = DerivedMacroStabilityInwardsInput.GetWaternetDaily(calculation.InputParameters, new GeneralMacroStabilityInwardsInput());
// Assert
var calculatorFactory = (TestMacroStabilityInwardsCalculatorFactory)MacroStabilityInwardsCalculatorFactory.Instance;
CalculatorOutputAssert.AssertWaternet(calculatorFactory.LastCreatedWaternetDailyCalculator.Output, waternet);
}
}
public void CalculateDaily_ErrorInCalculation_ReturnMacroStabilityInwardsWaternet()
{
// Setup
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
var calculatorFactory = (TestMacroStabilityInwardsCalculatorFactory)MacroStabilityInwardsCalculatorFactory.Instance;
calculatorFactory.LastCreatedWaternetDailyCalculator.ThrowExceptionOnCalculate = true;
// Call
MacroStabilityInwardsWaternet output = WaternetCalculationService.CalculateDaily(testCalculation.InputParameters, new GeneralMacroStabilityInwardsInput());
// Assert
Assert.IsNotNull(output);
CollectionAssert.IsEmpty(output.PhreaticLines);
CollectionAssert.IsEmpty(output.WaternetLines);
}
}
private static PersistableWaternet Create(MacroStabilityInwardsWaternet waternet, GeneralMacroStabilityInwardsInput generalInput, MacroStabilityInwardsExportStageType stageType,
IdFactory idFactory, MacroStabilityInwardsExportRegistry registry)
{
var persistableWaternet = new PersistableWaternet
{
Id = idFactory.Create(),
UnitWeightWater = generalInput.WaterVolumetricWeight,
HeadLines = waternet.PhreaticLines.Select(pl => Create(pl, idFactory)).ToArray(),
ReferenceLines = waternet.WaternetLines.Select(wl => Create(wl, idFactory)).ToArray(),
PhreaticLineId = waternet.PhreaticLines.Any()
? createdHeadLines[waternet.PhreaticLines.First()].Id
: null
};
registry.AddWaternet(stageType, persistableWaternet.Id);
return(persistableWaternet);
}
public void GetProperties_WithData_ReturnExpectedValues()
{
// Setup
var waternet = new MacroStabilityInwardsWaternet(new[]
{
MacroStabilityInwardsTestDataFactory.CreateMacroStabilityInwardsPhreaticLine()
}, new[]
{
MacroStabilityInwardsTestDataFactory.CreateMacroStabilityInwardsWaternetLine()
});
// Call
var properties = new MacroStabilityInwardsWaternetProperties(waternet);
// Assert
Assert.AreSame(waternet.PhreaticLines.Single(), properties.PhreaticLines.Single().Data);
Assert.AreSame(waternet.WaternetLines.Single(), properties.WaternetLines.Single().Data);
}
public void GetWaternetExtreme_SurfaceLineNull_ReturnsMacroStabilityInwardsWaternet()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
calculation.InputParameters.SurfaceLine = null;
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
MacroStabilityInwardsWaternet waternet = DerivedMacroStabilityInwardsInput.GetWaternetExtreme(calculation.InputParameters, new GeneralMacroStabilityInwardsInput(), RoundedDouble.NaN);
// Assert
Assert.IsNotNull(waternet);
CollectionAssert.IsEmpty(waternet.PhreaticLines);
CollectionAssert.IsEmpty(waternet.WaternetLines);
}
}
/// <summary>
/// Asserts whether the <see cref="MacroStabilityInwardsWaternet"/> contains the data
/// that is representative for the <paramref name="originalWaternets"/>.
/// </summary>
/// <param name="originalWaternets">The Waternets that contain the original data.</param>
/// <param name="actualWaternets">The <see cref="PersistableWaternet"/>
/// that needs to be asserted.</param>
/// <exception cref="AssertionException">Thrown when the data in <paramref name="actualWaternets"/>
/// is not correct.</exception>
public static void AssertWaternets(IEnumerable <MacroStabilityInwardsWaternet> originalWaternets, IEnumerable <PersistableWaternet> actualWaternets)
{
Assert.AreEqual(originalWaternets.Count(), actualWaternets.Count());
for (var i = 0; i < originalWaternets.Count(); i++)
{
MacroStabilityInwardsWaternet originalWaternet = originalWaternets.ElementAt(i);
PersistableWaternet actualWaternet = actualWaternets.ElementAt(i);
Assert.IsNotNull(actualWaternet.Id);
Assert.AreEqual(9.81, actualWaternet.UnitWeightWater);
PersistableHeadLine firstHeadLine = actualWaternet.HeadLines.FirstOrDefault();
Assert.AreEqual(actualWaternet.PhreaticLineId, firstHeadLine?.Id);
Assert.AreEqual(originalWaternet.PhreaticLines.Count(), actualWaternet.HeadLines.Count());
for (var j = 0; j < originalWaternet.PhreaticLines.Count(); j++)
{
MacroStabilityInwardsPhreaticLine phreaticLine = originalWaternet.PhreaticLines.ElementAt(j);
PersistableHeadLine headLine = actualWaternet.HeadLines.ElementAt(j);
Assert.IsNotNull(headLine.Id);
Assert.AreEqual(phreaticLine.Name, headLine.Label);
CollectionAssert.AreEqual(phreaticLine.Geometry.Select(p => new PersistablePoint(p.X, p.Y)), headLine.Points);
}
Assert.AreEqual(originalWaternet.WaternetLines.Count(), actualWaternet.ReferenceLines.Count());
for (var j = 0; j < originalWaternet.WaternetLines.Count(); j++)
{
MacroStabilityInwardsWaternetLine waternetLine = originalWaternet.WaternetLines.ElementAt(j);
PersistableReferenceLine referenceLine = actualWaternet.ReferenceLines.ElementAt(j);
Assert.IsNotNull(referenceLine.Id);
Assert.AreEqual(waternetLine.Name, referenceLine.Label);
CollectionAssert.AreEqual(waternetLine.Geometry.Select(p => new PersistablePoint(p.X, p.Y)), referenceLine.Points);
Assert.AreEqual(firstHeadLine.Id, referenceLine.TopHeadLineId);
Assert.AreEqual(firstHeadLine.Id, referenceLine.BottomHeadLineId);
}
}
}
private static void SetWaternetZonesChartData(MacroStabilityInwardsWaternet waternet, MacroStabilityInwardsSurfaceLine surfaceLine,
ChartDataCollection chartData)
{
chartData.Clear();
foreach (MacroStabilityInwardsPhreaticLine phreaticLine in waternet.PhreaticLines)
{
ChartLineData phreaticLineChartData = MacroStabilityInwardsChartDataFactory.CreatePhreaticLineChartData(phreaticLine.Name, true);
phreaticLineChartData.Points = MacroStabilityInwardsChartDataPointsFactory.CreatePhreaticLinePoints(phreaticLine);
chartData.Add(phreaticLineChartData);
}
foreach (MacroStabilityInwardsWaternetLine waternetLine in waternet.WaternetLines)
{
ChartMultipleAreaData waternetLineChartData = MacroStabilityInwardsChartDataFactory.CreateWaternetZoneChartData(waternetLine.Name, true);
waternetLineChartData.Areas = MacroStabilityInwardsChartDataPointsFactory.CreateWaternetZonePoints(waternetLine, surfaceLine);
chartData.Add(waternetLineChartData);
}
}
public void Constructor_ExpectedValues()
{
// Setup
var phreaticLine = new MacroStabilityInwardsPhreaticLine("Phreatic Line", Enumerable.Empty <Point2D>());
var waternetLine = new MacroStabilityInwardsWaternetLine("Waternet Line", Enumerable.Empty <Point2D>(), phreaticLine);
// Call
var waternet = new MacroStabilityInwardsWaternet(new[]
{
phreaticLine
}, new[]
{
waternetLine
});
// Assert
Assert.AreSame(phreaticLine, waternet.PhreaticLines.Single());
Assert.AreSame(waternetLine, waternet.WaternetLines.Single());
}
public void GetWaternetExtreme_ValidInput_SetsAssessmentLevelToCalculatorInputAndReturnsMacroStabilityInwardsWaternet()
{
// Setup
RoundedDouble assessmentLevel = new Random(21).NextRoundedDouble();
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
MacroStabilityInwardsWaternet waternet = DerivedMacroStabilityInwardsInput.GetWaternetExtreme(calculation.InputParameters, new GeneralMacroStabilityInwardsInput(), assessmentLevel);
// Assert
var calculatorFactory = (TestMacroStabilityInwardsCalculatorFactory)MacroStabilityInwardsCalculatorFactory.Instance;
WaternetCalculatorStub calculator = calculatorFactory.LastCreatedWaternetExtremeCalculator;
Assert.AreEqual(assessmentLevel, calculator.Input.AssessmentLevel);
CalculatorOutputAssert.AssertWaternet(calculator.Output, waternet);
}
}
public void Constructor_ValidWaternet_ExpectedValues()
{
// Setup
var waternet = new MacroStabilityInwardsWaternet(new[]
{
MacroStabilityInwardsTestDataFactory.CreateMacroStabilityInwardsPhreaticLine()
}, new[]
{
MacroStabilityInwardsTestDataFactory.CreateMacroStabilityInwardsWaternetLine()
});
// Call
var properties = new MacroStabilityInwardsWaternetProperties(waternet);
// Assert
Assert.IsInstanceOf <ObjectProperties <MacroStabilityInwardsWaternet> >(properties);
TestHelper.AssertTypeConverter <MacroStabilityInwardsWaternetProperties, ExpandableReadOnlyArrayConverter>(
nameof(MacroStabilityInwardsWaternetProperties.PhreaticLines));
Assert.AreSame(waternet, properties.Data);
}
private static void SetWaternetZonesChartData(MacroStabilityInwardsWaternet waternet, ChartDataCollection chartData,
IDictionary <MacroStabilityInwardsPhreaticLine, ChartLineData> phreaticLineLookup,
IDictionary <MacroStabilityInwardsWaternetLine, ChartMultipleAreaData> waternetLineLookup)
{
chartData.Clear();
phreaticLineLookup.Clear();
waternetLineLookup.Clear();
foreach (MacroStabilityInwardsPhreaticLine phreaticLine in waternet.PhreaticLines)
{
ChartLineData phreaticLineChartData = MacroStabilityInwardsChartDataFactory.CreatePhreaticLineChartData(phreaticLine.Name, false);
chartData.Add(phreaticLineChartData);
phreaticLineLookup.Add(phreaticLine, phreaticLineChartData);
}
foreach (MacroStabilityInwardsWaternetLine waternetLine in waternet.WaternetLines)
{
ChartMultipleAreaData waternetLineChartData = MacroStabilityInwardsChartDataFactory.CreateWaternetZoneChartData(waternetLine.Name, false);
chartData.Add(waternetLineChartData);
waternetLineLookup.Add(waternetLine, waternetLineChartData);
}
}
/// <summary>
/// Creates a new collection of <see cref="PersistableWaternet"/>.
/// </summary>
/// <param name="dailyWaternet">The daily Waternet to use.</param>
/// <param name="extremeWaternet">The extreme Waternet to use.</param>
/// <param name="generalInput">General calculation parameters that are the same across all calculations.</param>
/// <param name="idFactory">The factory for creating IDs.</param>
/// <param name="registry">The persistence registry.</param>
/// <returns>A collection of <see cref="PersistableWaternet"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
public static IEnumerable <PersistableWaternet> Create(MacroStabilityInwardsWaternet dailyWaternet,
MacroStabilityInwardsWaternet extremeWaternet,
GeneralMacroStabilityInwardsInput generalInput,
IdFactory idFactory,
MacroStabilityInwardsExportRegistry registry)
{
if (dailyWaternet == null)
{
throw new ArgumentNullException(nameof(dailyWaternet));
}
if (extremeWaternet == null)
{
throw new ArgumentNullException(nameof(extremeWaternet));
}
if (idFactory == null)
{
throw new ArgumentNullException(nameof(idFactory));
}
if (registry == null)
{
throw new ArgumentNullException(nameof(registry));
}
if (generalInput == null)
{
throw new ArgumentNullException(nameof(generalInput));
}
createdHeadLines = new Dictionary <MacroStabilityInwardsPhreaticLine, PersistableHeadLine>(new PhreaticLineComparer());
return(new[]
{
Create(dailyWaternet, generalInput, MacroStabilityInwardsExportStageType.Daily, idFactory, registry),
Create(extremeWaternet, generalInput, MacroStabilityInwardsExportStageType.Extreme, idFactory, registry)
});
}
/// <summary>
/// Asserts whether <paramref name="actual"/> corresponds to <paramref name="original"/>.
/// </summary>
/// <param name="original">The original <see cref="WaternetCalculatorResult"/>.</param>
/// <param name="actual">The actual <see cref="MacroStabilityInwardsWaternet"/>.</param>
/// <exception cref="AssertionException">Thrown when <paramref name="actual"/>
/// does not correspond to <paramref name="original"/>.</exception>
public static void AssertWaternet(WaternetCalculatorResult original, MacroStabilityInwardsWaternet actual)
{
WaternetPhreaticLineResult[] originalPhreaticLines = original.PhreaticLines.ToArray();
WaternetLineResult[] originalWaternetLines = original.WaternetLines.ToArray();
MacroStabilityInwardsPhreaticLine[] actualPhreaticLines = actual.PhreaticLines.ToArray();
MacroStabilityInwardsWaternetLine[] actualWaternetLines = actual.WaternetLines.ToArray();
Assert.AreEqual(originalPhreaticLines.Length, actualPhreaticLines.Length);
Assert.AreEqual(originalWaternetLines.Length, actualWaternetLines.Length);
for (var i = 0; i < originalPhreaticLines.Length; i++)
{
Assert.AreEqual(originalPhreaticLines[i].Name, actualPhreaticLines[i].Name);
CollectionAssert.AreEqual(originalPhreaticLines[i].Geometry, actualPhreaticLines[i].Geometry);
}
for (var i = 0; i < originalWaternetLines.Length; i++)
{
Assert.AreEqual(originalWaternetLines[i].Name, actualWaternetLines[i].Name);
CollectionAssert.AreEqual(originalWaternetLines[i].Geometry, actualWaternetLines[i].Geometry);
Assert.AreEqual(originalWaternetLines[i].PhreaticLine.Name, actualWaternetLines[i].PhreaticLine.Name);
CollectionAssert.AreEqual(originalWaternetLines[i].PhreaticLine.Geometry, actualWaternetLines[i].PhreaticLine.Geometry);
}
}
/// <summary>
/// Asserts whether <paramref name="chartDataCollection"/> contains no Waternet chart data.
/// </summary>
/// <param name="waternet">The original <see cref="MacroStabilityInwardsWaternet"/>.</param>
/// <param name="chartDataCollection">The actual <see cref="ChartData"/>.</param>
/// <exception cref="AssertionException">Thrown when a Waternet layer is present.</exception>
public static void AssertWaternetChartData(MacroStabilityInwardsWaternet waternet, ChartDataCollection chartDataCollection)
{
MacroStabilityInwardsViewChartDataAssert.AssertWaternetChartData(waternet,
false,
chartDataCollection);
}
