public void Constructor_ExpectedValues() { // Setup const string waternetLineName = "<some name>"; const string phreaticLineName = "PL1"; var geometry = new List <Point2D> { new Point2D(0.0, 0.0), new Point2D(15.0, 15.0) }; // Call var waternetLine = new MacroStabilityInwardsWaternetLine(waternetLineName, geometry, new MacroStabilityInwardsPhreaticLine(phreaticLineName, Enumerable.Empty <Point2D>())); // Assert Assert.AreEqual(waternetLineName, waternetLine.Name); CollectionAssert.AreEqual(new List <Point2D> { new Point2D(0.0, 0.0), new Point2D(15.0, 15.0) }, waternetLine.Geometry); Assert.AreEqual(phreaticLineName, waternetLine.PhreaticLine.Name); CollectionAssert.IsEmpty(waternetLine.PhreaticLine.Geometry); }
/// <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 Constructor_ValidWaternetLine_ExpectedValues() { // Setup MacroStabilityInwardsWaternetLine waternetLine = MacroStabilityInwardsTestDataFactory.CreateMacroStabilityInwardsWaternetLine(); // Call var properties = new MacroStabilityInwardsWaternetLineProperties(waternetLine); // Assert Assert.IsInstanceOf <ObjectProperties <MacroStabilityInwardsWaternetLine> >(properties); TestHelper.AssertTypeConverter <MacroStabilityInwardsWaternetLineProperties, ExpandableReadOnlyArrayConverter>( nameof(MacroStabilityInwardsWaternetLineProperties.Geometry)); Assert.AreSame(waternetLine, properties.Data); }
public void Create_WithValidData_ReturnsPersistableWaternetCollection() { // Setup var phreaticLine1 = new MacroStabilityInwardsPhreaticLine("Phreatic Line", Enumerable.Empty <Point2D>()); var waternetLine1 = new MacroStabilityInwardsWaternetLine("Waternet Line", Enumerable.Empty <Point2D>(), phreaticLine1); var phreaticLine2 = new MacroStabilityInwardsPhreaticLine("Phreatic Line", Enumerable.Empty <Point2D>()); var waternetLine2 = new MacroStabilityInwardsWaternetLine("Waternet Line", Enumerable.Empty <Point2D>(), phreaticLine2); var dailyWaternet = new MacroStabilityInwardsWaternet(new[] { phreaticLine1 }, new[] { waternetLine1 }); var extremeWaternet = new MacroStabilityInwardsWaternet(new[] { phreaticLine2 }, new[] { waternetLine2 }); 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 static PersistableReferenceLine Create(MacroStabilityInwardsWaternetLine waternetLine, IdFactory idFactory) { string headLineId = createdHeadLines[waternetLine.PhreaticLine].Id; var referenceLine = new PersistableReferenceLine { Id = idFactory.Create(), Label = waternetLine.Name, Points = waternetLine.Geometry.Select(point => new PersistablePoint(point.X, point.Y)).ToArray(), TopHeadLineId = headLineId, BottomHeadLineId = headLineId }; return(referenceLine); }
public void ToString_Always_ReturnsName() { // Setup const string expectedName = "PL2"; var waternetLine = new MacroStabilityInwardsWaternetLine(expectedName, Enumerable.Empty <Point2D>(), MacroStabilityInwardsTestDataFactory.CreateMacroStabilityInwardsPhreaticLine()); var properties = new MacroStabilityInwardsWaternetLineProperties(waternetLine); // Call var name = properties.ToString(); // Assert Assert.AreEqual(name, expectedName); }
/// <summary> /// Create points of the Waternet zone in 2D space based on the provide <paramref name="waternetLine"/>. /// </summary> /// <param name="waternetLine">The Waternet line to create the zone for.</param> /// <param name="surfaceLine">The <see cref="MacroStabilityInwardsSurfaceLine"/> that may intersect with /// the <see cref="MacroStabilityInwardsWaternetLine.PhreaticLine"/> and by doing that restricts the /// drawn height of it.</param> /// <returns>A collection of points in 2D space or an empty collection when: /// <list type="bullet"> /// <item><paramref name="waternetLine"/> is <c>null</c>;</item> /// <item><paramref name="surfaceLine"/> is <c>null</c>;</item> /// <item>The geometry of the <see cref="MacroStabilityInwardsWaternetLine"/> is <c>empty</c>;</item> /// <item>The geometry of the <see cref="MacroStabilityInwardsWaternetLine.PhreaticLine"/> is <c>empty</c>.</item> /// </list> /// </returns> public static IEnumerable <IEnumerable <Point2D> > CreateWaternetZonePoints(MacroStabilityInwardsWaternetLine waternetLine, MacroStabilityInwardsSurfaceLine surfaceLine) { if (waternetLine == null || surfaceLine == null || !waternetLine.Geometry.Any() || !waternetLine.PhreaticLine.Geometry.Any()) { return(new Point2D[0][]); } IEnumerable <Point2D> surfaceLineLocalGeometry = surfaceLine.LocalGeometry.ToArray(); IEnumerable <Point2D> phreaticLineGeometry = new RoundedPoint2DCollection(2, waternetLine.PhreaticLine.Geometry).ToArray(); IEnumerable <Point2D> waternetLineGeometry = new RoundedPoint2DCollection(2, waternetLine.Geometry).ToArray(); return(IsSurfaceLineAboveWaternetZone(surfaceLineLocalGeometry, waternetLineGeometry, phreaticLineGeometry) ? CreateZoneAreas(waternetLineGeometry, phreaticLineGeometry) : GetWaternetZoneWithSurfaceLineIntersection(surfaceLineLocalGeometry, waternetLineGeometry, phreaticLineGeometry).ToArray()); }
/// <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); } } }
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 GetProperties_WithData_ReturnExpectedValues() { // Setup var random = new Random(21); var waternetLine = new MacroStabilityInwardsWaternetLine("Zone A", new[] { new Point2D(random.NextDouble(), random.NextDouble()), new Point2D(random.NextDouble(), random.NextDouble()) }, new MacroStabilityInwardsPhreaticLine("PL1", Enumerable.Empty <Point2D>())); // Call var properties = new MacroStabilityInwardsWaternetLineProperties(waternetLine); // Assert Assert.AreEqual(waternetLine.Name, properties.Name); CollectionAssert.AreEqual(waternetLine.Geometry, properties.Geometry); Assert.AreEqual(waternetLine.PhreaticLine.Name, properties.PhreaticLineName); }
public void Constructor_ValidData_PropertiesHaveExpectedAttributeValues() { // Setup MacroStabilityInwardsWaternetLine waternetLine = MacroStabilityInwardsTestDataFactory.CreateMacroStabilityInwardsWaternetLine(); // Call var properties = new MacroStabilityInwardsWaternetLineProperties(waternetLine); // Assert PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties); Assert.AreEqual(3, dynamicProperties.Count); const string waterStressesCategoryName = "Waterspanningen"; PropertyDescriptor nameProperty = dynamicProperties[0]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(nameProperty, waterStressesCategoryName, "Naam", "De naam van de zone.", true); PropertyDescriptor geometryProperty = dynamicProperties[1]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(geometryProperty, waterStressesCategoryName, "Geometrie", "De geometrie van de zone.", true); PropertyDescriptor phreaticLineNameProperty = dynamicProperties[2]; PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(phreaticLineNameProperty, waterStressesCategoryName, "Stijghoogtelijn", "De stijghoogtelijn behorend bij de zone.", true); }