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); }