Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryData.cs =================================================================== diff -u -r6087 -r6106 --- DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryData.cs (.../GeometryData.cs) (revision 6087) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryData.cs (.../GeometryData.cs) (revision 6106) @@ -355,17 +355,17 @@ } } - private void ReplacePointsForLoop(GeometryData clonedGeometryData, GeometryLoop clonedLoop) + private static void ReplacePointsForLoop(GeometryData clonedGeometryData, GeometryLoop clonedLoop) { - for (int i = 0; i < clonedLoop.CalcPoints.Count; i++) + for (var i = 0; i < clonedLoop.CalcPoints.Count; i++) { clonedLoop.CalcPoints[i] = clonedGeometryData.GetPointAtLocation(clonedLoop.CalcPoints[i]); } } - private void ReplaceCurvesForLoop(GeometryData clonedGeometryData, GeometryLoop clonedLoop) + private static void ReplaceCurvesForLoop(GeometryData clonedGeometryData, GeometryLoop clonedLoop) { - for (int i = 0; i < clonedLoop.CurveList.Count; i++) + for (var i = 0; i < clonedLoop.CurveList.Count; i++) { clonedLoop.CurveList[i].HeadPoint = clonedGeometryData.GetPointAtLocation(clonedLoop.CurveList[i].HeadPoint); clonedLoop.CurveList[i].EndPoint = clonedGeometryData.GetPointAtLocation(clonedLoop.CurveList[i].EndPoint); @@ -1217,18 +1217,15 @@ public GeometryLoop FindLoopThatHasSameLoopCurves(GeometryLoop outerLoop) { foreach (GeometrySurface geometrySurface in Surfaces) - { + { if (geometrySurface.OuterLoop.HasSameCurves(outerLoop)) { return geometrySurface.OuterLoop; } - foreach (GeometryLoop innerLoop in geometrySurface.InnerLoops) + foreach (GeometryLoop innerLoop in geometrySurface.InnerLoops.Where(innerLoop => innerLoop.HasSameCurves(outerLoop))) { - if (innerLoop.HasSameCurves(outerLoop)) - { - return innerLoop; - } + return innerLoop; } } Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2.cs =================================================================== diff -u -r6087 -r6106 --- DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2.cs (.../SurfaceLine2.cs) (revision 6087) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geotechnics/SurfaceLine2.cs (.../SurfaceLine2.cs) (revision 6106) @@ -169,8 +169,8 @@ /// /// The start x. /// The end x. - /// collection of points between start X and end X (inlcuding those) - /// End value is smaller then the start value + /// collection of points between start X and end X (including those) + /// End value is smaller than the start value public virtual IEnumerable GetPointSegmentIncluding(double startX, double endX) { if (endX < startX) @@ -185,7 +185,7 @@ } /// - /// Validates this surfaceline. + /// Validates this surface line. /// /// All validation messages. [Validate] @@ -317,21 +317,21 @@ { foreach (KeyValuePair annotation in geometryAnnotations) { - AddCharacteristicPoint((Point2D) annotation.Key.Clone(), annotation.Value); + AddCharacteristicPoint(annotation.Key.Clone(), annotation.Value); } } } /// - /// Collapses all characteristic point annotations in the given surfaceline into - /// a dictionary keyed on instances in that surfaceline + /// Collapses all characteristic point annotations in the given surface line into + /// a dictionary keyed on instances in that surface line /// and their annotations. /// /// The referenced surfaceline. /// True if should be a clone from /// .; false if it should /// take the same instance instead. - /// Dictionary keyed on instances in the surfaceline + /// Dictionary keyed on instances in the surface line /// that have annotations. private Dictionary GetCharacteristicAnnotationsInSource(SurfaceLine2 source, bool cloneGeometry) { @@ -344,11 +344,11 @@ /// Handlers return value in case /// is true. /// - /// The referenced surfaceline. + /// The referenced surface line. /// True if should be a clone from /// .; false if it should /// take the same instance instead. - /// Dictionary keyed on instances in the surfaceline + /// Dictionary keyed on instances in the surface line /// that have annotations. private Dictionary GetCharacteristicAnnotationsInSource_GeometryMustContainPoints(SurfaceLine2 source, bool cloneGeometry) { @@ -369,8 +369,8 @@ /// Handles return value in case /// is false. /// - /// The referenced surfaceline. - /// Dictionary keyed on instances in the surfaceline + /// The referenced surface line. + /// Dictionary keyed on instances in the surface line /// that have annotations. private static Dictionary GetCharacteristicAnnotationsInSource_GeometryMustNotContainPoints(SurfaceLine2 source) { Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/Waternet.cs =================================================================== diff -u -r6087 -r6106 --- DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/Waternet.cs (.../Waternet.cs) (revision 6087) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/Waternet.cs (.../Waternet.cs) (revision 6106) @@ -28,8 +28,6 @@ /// public class Waternet : GeometryObject { - private PhreaticLine phreaticLine; - /// /// Initializes a new instance of the class. /// @@ -44,17 +42,7 @@ /// /// The phreatic line. /// - public PhreaticLine PhreaticLine - { - get - { - return phreaticLine; - } - set - { - phreaticLine = value; - } - } + public PhreaticLine PhreaticLine { get; set; } /// /// Gets the head line list. Index: DamEngine/trunk/src/Deltares.DamEngine.Data/General/PlLines/Pl1Line.cs =================================================================== diff -u -r6087 -r6106 --- DamEngine/trunk/src/Deltares.DamEngine.Data/General/PlLines/Pl1Line.cs (.../Pl1Line.cs) (revision 6087) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/General/PlLines/Pl1Line.cs (.../Pl1Line.cs) (revision 6106) @@ -31,17 +31,17 @@ foreach (Point2D point in pl1Line.CalcPoints) { - var newPoint = (Point2D) point.Clone(); + Point2D newPoint = point.Clone(); CalcPoints.Add(newPoint); } } public new Pl1Line Clone() { - var newPL1Line = new Pl1Line(); + var newPl1Line = new Pl1Line(); - newPL1Line.Assign(this); + newPl1Line.Assign(this); - return newPL1Line; + return newPl1Line; } } \ No newline at end of file Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryLoop.cs =================================================================== diff -u -r6087 -r6106 --- DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryLoop.cs (.../GeometryLoop.cs) (revision 6087) +++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryLoop.cs (.../GeometryLoop.cs) (revision 6106) @@ -163,8 +163,6 @@ /// The cloned GeometryLoop public override GeometryLoop Clone() { - // Note: explicit use of CalcPoints to ensure calcPoints are populated - List p = CalcPoints; GeometryPointString clonedGeometryPointString = base.Clone(); var clonedGeometryLoop = new GeometryLoop(); clonedGeometryLoop.CalcPoints.AddRange(clonedGeometryPointString.CalcPoints); Index: DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/Common/SoilProfile2DHelper.cs =================================================================== diff -u -r6087 -r6106 --- DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/Common/SoilProfile2DHelper.cs (.../SoilProfile2DHelper.cs) (revision 6087) +++ DamEngine/trunk/src/Deltares.DamEngine.Calculators/KernelWrappers/Common/SoilProfile2DHelper.cs (.../SoilProfile2DHelper.cs) (revision 6106) @@ -332,24 +332,29 @@ { for (var i = 0; i < count; i++) { - if (HasAquiferAVerticalPartAtGivenX(layerType, xCoordinate, soilProfile, i)) - { - xCoordinatesAll.Add(xCoordinate - deviationX); - xCoordinatesAll.Add(xCoordinate + deviationX); - } - else - { - if (xCoordinatesAll.IndexOf(xCoordinate) < 0) - { - xCoordinatesAll.Add(xCoordinate); - } - } + AddXCoordinate(layerType, soilProfile, xCoordinate, i, xCoordinatesAll); } } } return xCoordinatesAll.ToArray(); } + private static void AddXCoordinate(LayerType layerType, SoilProfile2D soilProfile, double xCoordinate, int i, List xCoordinatesAll) + { + if (HasAquiferAVerticalPartAtGivenX(layerType, xCoordinate, soilProfile, i)) + { + xCoordinatesAll.Add(xCoordinate - deviationX); + xCoordinatesAll.Add(xCoordinate + deviationX); + } + else + { + if (xCoordinatesAll.IndexOf(xCoordinate) < 0) + { + xCoordinatesAll.Add(xCoordinate); + } + } + } + internal static List ConnectPolyLines(List polyLines) { List connectedPolyLinesSamePoint = ConnectPolyLines(PolyLineConnectionType.SamePoint, polyLines); Index: DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SurfaceLine2Tests.cs =================================================================== diff -u -r6086 -r6106 --- DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SurfaceLine2Tests.cs (.../SurfaceLine2Tests.cs) (revision 6086) +++ DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geotechnics/SurfaceLine2Tests.cs (.../SurfaceLine2Tests.cs) (revision 6106) @@ -34,109 +34,134 @@ public void TestAddingCharacteristicPointsOnSameLocationDoesNotAddDoublePointsInGeometry() { SurfaceLine2 surfaceLine = FillSurfaceLine2(); - Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(10)); + Assert.That(surfaceLine.CharacteristicPoints, Has.Count.EqualTo(10)); ValidateSurfaceLine(surfaceLine); } [Test] public void TestDeepCloneWithoutGeometryMustContainPoint() { SurfaceLine2 surfaceLine = FillSurfaceLine2(); - Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(10)); - Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9)); + Assert.Multiple(() => + { + Assert.That(surfaceLine.CharacteristicPoints, Has.Count.EqualTo(10)); + Assert.That(surfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9)); + }); // Note: resetting GeometryMustContainPoint to false after filling the surface line will erase all Characteristic Points. // So the actual code should NEVER reset the GeometryMustContainPoint for filled surface lines. surfaceLine.CharacteristicPoints.GeometryMustContainPoint = false; - Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(0)); + Assert.That(surfaceLine.CharacteristicPoints, Is.Empty); SurfaceLine2 newSurfaceLine = surfaceLine.FullDeepClone(); surfaceLine.CharacteristicPoints.Clear(); surfaceLine.Geometry.CalcPoints.Clear(); - Assert.That(newSurfaceLine.CharacteristicPoints.Count, Is.EqualTo(0)); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9)); + Assert.Multiple(() => + { + Assert.That(newSurfaceLine.CharacteristicPoints, Is.Empty); + Assert.That(newSurfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9)); + }); } [Test] public void TestDeepCloneWithGeometryMustContainPoint() { SurfaceLine2 surfaceLine = FillSurfaceLine2(); - Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(10)); - Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9)); + Assert.Multiple(() => + { + Assert.That(surfaceLine.CharacteristicPoints, Has.Count.EqualTo(10)); + Assert.That(surfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9)); + }); // Note: resetting GeometryMustContainPoint to true after filling the surface line reset the Characteristic Points to be // equal to the amount of geometry points, keeping only one type, possibly making the surface line invalid. // So the actual code should NEVER reset the GeometryMustContainPoint for filled surface lines. surfaceLine.CharacteristicPoints.GeometryMustContainPoint = true; - Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9)); - Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(9)); + Assert.Multiple(() => + { + Assert.That(surfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9)); + Assert.That(surfaceLine.CharacteristicPoints, Has.Count.EqualTo(9)); + }); SurfaceLine2 newSurfaceLine = surfaceLine.FullDeepClone(); surfaceLine.CharacteristicPoints.Clear(); surfaceLine.Geometry.CalcPoints.Clear(); - - Assert.That(newSurfaceLine.CharacteristicPoints.Count, Is.EqualTo(9)); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9)); + Assert.Multiple(() => + { + Assert.That(newSurfaceLine.CharacteristicPoints, Has.Count.EqualTo(9)); + Assert.That(newSurfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9)); + }); } [Test] public void TestDeepCloneWithoutSettingGeometryMustContainPoint() { SurfaceLine2 surfaceLine = FillSurfaceLine2(); - Assert.That(surfaceLine.CharacteristicPoints.Count, Is.EqualTo(10)); - Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9)); + Assert.Multiple(() => + { + Assert.That(surfaceLine.CharacteristicPoints, Has.Count.EqualTo(10)); + Assert.That(surfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9)); + }); SurfaceLine2 newSurfaceLine = surfaceLine.FullDeepClone(); surfaceLine.CharacteristicPoints.Clear(); surfaceLine.Geometry.CalcPoints.Clear(); - - Assert.That(newSurfaceLine.CharacteristicPoints.Count, Is.EqualTo(10)); - Assert.That(newSurfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9)); + Assert.Multiple(() => + { + Assert.That(newSurfaceLine.CharacteristicPoints, Has.Count.EqualTo(10)); + Assert.That(newSurfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9)); + }); var tolerance = 1e-8; surfaceLine = FillSurfaceLine2(); - Assert.That(newSurfaceLine.CharacteristicPoints[0].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[0].Point.X).Within(tolerance)); - Assert.That(newSurfaceLine.CharacteristicPoints[0].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[0].Point.Z).Within(tolerance)); - Assert.That(newSurfaceLine.CharacteristicPoints[0].CharacteristicPointType, - Is.EqualTo(surfaceLine.CharacteristicPoints[0].CharacteristicPointType)); - Assert.That(newSurfaceLine.CharacteristicPoints[1].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[1].Point.X).Within(tolerance)); - Assert.That(newSurfaceLine.CharacteristicPoints[1].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[1].Point.Z).Within(tolerance)); - Assert.That(newSurfaceLine.CharacteristicPoints[1].CharacteristicPointType, - Is.EqualTo(surfaceLine.CharacteristicPoints[1].CharacteristicPointType)); - Assert.That(newSurfaceLine.CharacteristicPoints[2].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[2].Point.X).Within(tolerance)); - Assert.That(newSurfaceLine.CharacteristicPoints[2].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[2].Point.Z).Within(tolerance)); - Assert.That(newSurfaceLine.CharacteristicPoints[2].CharacteristicPointType, - Is.EqualTo(surfaceLine.CharacteristicPoints[2].CharacteristicPointType)); - Assert.That(newSurfaceLine.CharacteristicPoints[3].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[3].Point.X).Within(tolerance)); - Assert.That(newSurfaceLine.CharacteristicPoints[3].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[3].Point.Z).Within(tolerance)); - Assert.That(newSurfaceLine.CharacteristicPoints[3].CharacteristicPointType, - Is.EqualTo(surfaceLine.CharacteristicPoints[3].CharacteristicPointType)); - Assert.That(newSurfaceLine.CharacteristicPoints[4].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[4].Point.X).Within(tolerance)); - Assert.That(newSurfaceLine.CharacteristicPoints[4].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[4].Point.Z).Within(tolerance)); - Assert.That(newSurfaceLine.CharacteristicPoints[4].CharacteristicPointType, - Is.EqualTo(surfaceLine.CharacteristicPoints[4].CharacteristicPointType)); - Assert.That(newSurfaceLine.CharacteristicPoints[5].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[5].Point.X).Within(tolerance)); - Assert.That(newSurfaceLine.CharacteristicPoints[5].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[5].Point.Z).Within(tolerance)); - Assert.That(newSurfaceLine.CharacteristicPoints[5].CharacteristicPointType, - Is.EqualTo(surfaceLine.CharacteristicPoints[5].CharacteristicPointType)); - Assert.That(newSurfaceLine.CharacteristicPoints[6].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[6].Point.X).Within(tolerance)); - Assert.That(newSurfaceLine.CharacteristicPoints[6].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[6].Point.Z).Within(tolerance)); - Assert.That(newSurfaceLine.CharacteristicPoints[6].CharacteristicPointType, - Is.EqualTo(surfaceLine.CharacteristicPoints[6].CharacteristicPointType)); - Assert.That(newSurfaceLine.CharacteristicPoints[7].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[7].Point.X).Within(tolerance)); - Assert.That(newSurfaceLine.CharacteristicPoints[7].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[7].Point.Z).Within(tolerance)); - Assert.That(newSurfaceLine.CharacteristicPoints[7].CharacteristicPointType, - Is.EqualTo(surfaceLine.CharacteristicPoints[7].CharacteristicPointType)); - Assert.That(newSurfaceLine.CharacteristicPoints[8].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[8].Point.X).Within(tolerance)); - Assert.That(newSurfaceLine.CharacteristicPoints[8].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[8].Point.Z).Within(tolerance)); - Assert.That(newSurfaceLine.CharacteristicPoints[8].CharacteristicPointType, - Is.EqualTo(surfaceLine.CharacteristicPoints[8].CharacteristicPointType)); - Assert.That(newSurfaceLine.CharacteristicPoints[9].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[9].Point.X).Within(tolerance)); - Assert.That(newSurfaceLine.CharacteristicPoints[9].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[9].Point.Z).Within(tolerance)); - Assert.That(newSurfaceLine.CharacteristicPoints[9].CharacteristicPointType, - Is.EqualTo(surfaceLine.CharacteristicPoints[9].CharacteristicPointType)); + Assert.Multiple(() => + { + Assert.That(newSurfaceLine.CharacteristicPoints[0].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[0].Point.X).Within(tolerance)); + Assert.That(newSurfaceLine.CharacteristicPoints[0].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[0].Point.Z).Within(tolerance)); + Assert.That(newSurfaceLine.CharacteristicPoints[0].CharacteristicPointType, + Is.EqualTo(surfaceLine.CharacteristicPoints[0].CharacteristicPointType)); + Assert.That(newSurfaceLine.CharacteristicPoints[1].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[1].Point.X).Within(tolerance)); + Assert.That(newSurfaceLine.CharacteristicPoints[1].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[1].Point.Z).Within(tolerance)); + Assert.That(newSurfaceLine.CharacteristicPoints[1].CharacteristicPointType, + Is.EqualTo(surfaceLine.CharacteristicPoints[1].CharacteristicPointType)); + Assert.That(newSurfaceLine.CharacteristicPoints[2].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[2].Point.X).Within(tolerance)); + Assert.That(newSurfaceLine.CharacteristicPoints[2].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[2].Point.Z).Within(tolerance)); + Assert.That(newSurfaceLine.CharacteristicPoints[2].CharacteristicPointType, + Is.EqualTo(surfaceLine.CharacteristicPoints[2].CharacteristicPointType)); + Assert.That(newSurfaceLine.CharacteristicPoints[3].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[3].Point.X).Within(tolerance)); + Assert.That(newSurfaceLine.CharacteristicPoints[3].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[3].Point.Z).Within(tolerance)); + Assert.That(newSurfaceLine.CharacteristicPoints[3].CharacteristicPointType, + Is.EqualTo(surfaceLine.CharacteristicPoints[3].CharacteristicPointType)); + Assert.That(newSurfaceLine.CharacteristicPoints[4].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[4].Point.X).Within(tolerance)); + Assert.That(newSurfaceLine.CharacteristicPoints[4].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[4].Point.Z).Within(tolerance)); + Assert.That(newSurfaceLine.CharacteristicPoints[4].CharacteristicPointType, + Is.EqualTo(surfaceLine.CharacteristicPoints[4].CharacteristicPointType)); + Assert.That(newSurfaceLine.CharacteristicPoints[5].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[5].Point.X).Within(tolerance)); + Assert.That(newSurfaceLine.CharacteristicPoints[5].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[5].Point.Z).Within(tolerance)); + Assert.That(newSurfaceLine.CharacteristicPoints[5].CharacteristicPointType, + Is.EqualTo(surfaceLine.CharacteristicPoints[5].CharacteristicPointType)); + Assert.That(newSurfaceLine.CharacteristicPoints[6].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[6].Point.X).Within(tolerance)); + Assert.That(newSurfaceLine.CharacteristicPoints[6].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[6].Point.Z).Within(tolerance)); + Assert.That(newSurfaceLine.CharacteristicPoints[6].CharacteristicPointType, + Is.EqualTo(surfaceLine.CharacteristicPoints[6].CharacteristicPointType)); + Assert.That(newSurfaceLine.CharacteristicPoints[7].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[7].Point.X).Within(tolerance)); + Assert.That(newSurfaceLine.CharacteristicPoints[7].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[7].Point.Z).Within(tolerance)); + Assert.That(newSurfaceLine.CharacteristicPoints[7].CharacteristicPointType, + Is.EqualTo(surfaceLine.CharacteristicPoints[7].CharacteristicPointType)); + Assert.That(newSurfaceLine.CharacteristicPoints[8].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[8].Point.X).Within(tolerance)); + Assert.That(newSurfaceLine.CharacteristicPoints[8].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[8].Point.Z).Within(tolerance)); + Assert.That(newSurfaceLine.CharacteristicPoints[8].CharacteristicPointType, + Is.EqualTo(surfaceLine.CharacteristicPoints[8].CharacteristicPointType)); + Assert.That(newSurfaceLine.CharacteristicPoints[9].Point.X, Is.EqualTo(surfaceLine.CharacteristicPoints[9].Point.X).Within(tolerance)); + Assert.That(newSurfaceLine.CharacteristicPoints[9].Point.Z, Is.EqualTo(surfaceLine.CharacteristicPoints[9].Point.Z).Within(tolerance)); + Assert.That(newSurfaceLine.CharacteristicPoints[9].CharacteristicPointType, + Is.EqualTo(surfaceLine.CharacteristicPoints[9].CharacteristicPointType)); + }); } private static void ValidateSurfaceLine(SurfaceLine2 surfaceLine) { - var tolerance = 0.001; - Assert.That(surfaceLine.CharacteristicPoints.Count(cp => Math.Abs(cp.Point.X - 13.0) < tolerance && Math.Abs(cp.Point.Z - 5.4) < tolerance), Is.EqualTo(2)); - // Because TrafficLoadOutside and DikeTopAtPolder are on the same location, 1 point less should be in the geometry - Assert.That(surfaceLine.Geometry.CalcPoints.Count, Is.EqualTo(9)); + const double tolerance = 0.001; + Assert.Multiple(() => + { + Assert.That(surfaceLine.CharacteristicPoints.Count(cp => Math.Abs(cp.Point.X - 13.0) < tolerance && Math.Abs(cp.Point.Z - 5.4) < tolerance), Is.EqualTo(2)); + // Because TrafficLoadOutside and DikeTopAtPolder are on the same location, 1 point less should be in the geometry + Assert.That(surfaceLine.Geometry.CalcPoints, Has.Count.EqualTo(9)); + }); Assert.That(surfaceLine.Geometry.CalcPoints.Count(cp => Math.Abs(cp.X - 13.0) < tolerance && Math.Abs(cp.Z - 5.4) < tolerance), Is.EqualTo(1)); }