Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.Test/Calculators/UpliftVan/UpliftVanCalculatorTest.cs =================================================================== diff -u -rbcb7ee1318355c19145c87d641d31c97307d59dd -r3096dd0aeecf478a662cae38533233949c76e103 --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.Test/Calculators/UpliftVan/UpliftVanCalculatorTest.cs (.../UpliftVanCalculatorTest.cs) (revision bcb7ee1318355c19145c87d641d31c97307d59dd) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.Test/Calculators/UpliftVan/UpliftVanCalculatorTest.cs (.../UpliftVanCalculatorTest.cs) (revision 3096dd0aeecf478a662cae38533233949c76e103) @@ -136,11 +136,11 @@ }) .ToDictionary(x => x.layer, x => x.soil); - UpliftVanKernelInputHelper.AssertSoilModels(SoilModelCreator.Create(soils), upliftVanKernel.SoilModel); - UpliftVanKernelInputHelper.AssertSoilProfiles(SoilProfileCreator.Create(input.SoilProfile, layersWithSoils), upliftVanKernel.SoilProfile); - UpliftVanKernelInputHelper.AssertStabilityLocations(StabilityLocationCreator.Create(input), upliftVanKernel.Location); - UpliftVanKernelInputHelper.AssertSurfaceLines(SurfaceLineCreator.Create(input.SurfaceLine), upliftVanKernel.SurfaceLine); - UpliftVanKernelInputHelper.AssertSlipPlanesUpliftVan(SlipPlaneUpliftVanCreator.Create(input), upliftVanKernel.SlipPlaneUpliftVan); + UpliftVanKernelInputAssert.AssertSoilModels(SoilModelCreator.Create(soils), upliftVanKernel.SoilModel); + UpliftVanKernelInputAssert.AssertSoilProfiles(SoilProfileCreator.Create(input.SoilProfile, layersWithSoils), upliftVanKernel.SoilProfile); + UpliftVanKernelInputAssert.AssertStabilityLocations(StabilityLocationCreator.Create(input), upliftVanKernel.Location); + UpliftVanKernelInputAssert.AssertSurfaceLines(SurfaceLineCreator.Create(input.SurfaceLine), upliftVanKernel.SurfaceLine); + UpliftVanKernelInputAssert.AssertSlipPlanesUpliftVan(SlipPlaneUpliftVanCreator.Create(input), upliftVanKernel.SlipPlaneUpliftVan); Assert.AreEqual(input.GridAutomaticDetermined, upliftVanKernel.GridAutomaticDetermined); Assert.AreEqual(input.CreateZones, upliftVanKernel.CreateZones); @@ -168,9 +168,9 @@ Assert.AreEqual(upliftVanKernel.ZValue, result.ZValue); Assert.AreEqual(upliftVanKernel.ForbiddenZonesXEntryMax, result.ForbiddenZonesXEntryMax); Assert.AreEqual(upliftVanKernel.ForbiddenZonesXEntryMin, result.ForbiddenZonesXEntryMin); - UpliftVanCalculatorOutputHelper.AssertSlidingCurve(UpliftVanSlidingCurveResultCreator.Create(upliftVanKernel.SlidingCurveResult), + UpliftVanCalculatorOutputAssert.AssertSlidingCurve(UpliftVanSlidingCurveResultCreator.Create(upliftVanKernel.SlidingCurveResult), result.SlidingCurveResult); - UpliftVanCalculatorOutputHelper.AssertSlipPlaneGrid(UpliftVanCalculationGridResultCreator.Create(upliftVanKernel.SlipPlaneResult), + UpliftVanCalculatorOutputAssert.AssertSlipPlaneGrid(UpliftVanCalculationGridResultCreator.Create(upliftVanKernel.SlipPlaneResult), result.CalculationGridResult); } @@ -289,7 +289,10 @@ }, Enumerable.Empty(), new UpliftVanSoilLayer.ConstructionProperties()) - }, Enumerable.Empty()); + }, new[] + { + new UpliftVanPreconsolidationStress(new Point2D(0, 0), 1.1) + }); } private static MacroStabilityInwardsSurfaceLine CreateValidSurfaceLine() Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil/Calculators/UpliftVan/Output/UpliftVanCalculatorOutputAssert.cs =================================================================== diff -u --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil/Calculators/UpliftVan/Output/UpliftVanCalculatorOutputAssert.cs (revision 0) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil/Calculators/UpliftVan/Output/UpliftVanCalculatorOutputAssert.cs (revision 3096dd0aeecf478a662cae38533233949c76e103) @@ -0,0 +1,144 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System.Linq; +using NUnit.Framework; +using Ringtoets.MacroStabilityInwards.KernelWrapper.Calculators.UpliftVan.Output; + +namespace Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil.Calculators.UpliftVan.Output +{ + /// + /// Class for asserting Uplift Van calculator output. + /// + public static class UpliftVanCalculatorOutputAssert + { + /// + /// Asserts whether is equal to . + /// + /// The expected . + /// The actual . + /// Thrown when + /// is not equal to . + public static void AssertSlidingCurve(UpliftVanSlidingCurveResult expected, UpliftVanSlidingCurveResult actual) + { + Assert.AreEqual(expected.IteratedHorizontalForce, actual.IteratedHorizontalForce); + Assert.AreEqual(expected.NonIteratedHorizontalForce, actual.NonIteratedHorizontalForce); + AssertCircle(expected.LeftCircle, actual.LeftCircle); + AssertCircle(expected.RightCircle, actual.RightCircle); + AssertSlices(expected.Slices.ToArray(), actual.Slices.ToArray()); + } + + /// + /// Asserts whether is equal to . + /// + /// The expected . + /// The actual . + /// Thrown when + /// is not equal to . + public static void AssertSlipPlaneGrid(UpliftVanCalculationGridResult expected, UpliftVanCalculationGridResult actual) + { + CollectionAssert.AreEqual(expected.TangentLines, actual.TangentLines); + AssertGrid(expected.LeftGrid, actual.LeftGrid); + AssertGrid(expected.RightGrid, actual.RightGrid); + } + + /// + /// Asserts whether is equal to . + /// + /// The expected . + /// The actual . + /// Thrown when + /// is not equal to . + private static void AssertCircle(UpliftVanSlidingCircleResult expected, UpliftVanSlidingCircleResult actual) + { + Assert.AreEqual(expected.Center, actual.Center); + Assert.AreEqual(expected.Radius, actual.Radius); + Assert.AreEqual(expected.IsActive, actual.IsActive); + Assert.AreEqual(expected.NonIteratedForce, actual.NonIteratedForce); + Assert.AreEqual(expected.IteratedForce, actual.IteratedForce); + Assert.AreEqual(expected.DrivingMoment, actual.DrivingMoment); + Assert.AreEqual(expected.ResistingMoment, actual.ResistingMoment); + } + + /// + /// Asserts whether is equal to . + /// + /// The expected array. + /// The actual array. + /// Thrown when + /// is not equal to . + private static void AssertSlices(UpliftVanSliceResult[] expected, UpliftVanSliceResult[] actual) + { + Assert.AreEqual(expected.Length, actual.Length); + + for (var i = 0; i < expected.Length; i++) + { + Assert.AreEqual(expected[i].Cohesion, actual[i].Cohesion); + Assert.AreEqual(expected[i].FrictionAngle, actual[i].FrictionAngle); + Assert.AreEqual(expected[i].CriticalPressure, actual[i].CriticalPressure); + Assert.AreEqual(expected[i].OverConsolidationRatio, actual[i].OverConsolidationRatio); + Assert.AreEqual(expected[i].Pop, actual[i].Pop); + Assert.AreEqual(expected[i].DegreeOfConsolidationPorePressureSoil, actual[i].DegreeOfConsolidationPorePressureSoil); + Assert.AreEqual(expected[i].DegreeOfConsolidationPorePressureLoad, actual[i].DegreeOfConsolidationPorePressureLoad); + Assert.AreEqual(expected[i].Dilatancy, actual[i].Dilatancy); + Assert.AreEqual(expected[i].ExternalLoad, actual[i].ExternalLoad); + Assert.AreEqual(expected[i].HydrostaticPorePressure, actual[i].HydrostaticPorePressure); + Assert.AreEqual(expected[i].LeftForce, actual[i].LeftForce); + Assert.AreEqual(expected[i].LeftForceAngle, actual[i].LeftForceAngle); + Assert.AreEqual(expected[i].LeftForceY, actual[i].LeftForceY); + Assert.AreEqual(expected[i].RightForce, actual[i].RightForce); + Assert.AreEqual(expected[i].RightForceAngle, actual[i].RightForceAngle); + Assert.AreEqual(expected[i].RightForceY, actual[i].RightForceY); + Assert.AreEqual(expected[i].LoadStress, actual[i].LoadStress); + Assert.AreEqual(expected[i].NormalStress, actual[i].NormalStress); + Assert.AreEqual(expected[i].PorePressure, actual[i].PorePressure); + Assert.AreEqual(expected[i].HorizontalPorePressure, actual[i].HorizontalPorePressure); + Assert.AreEqual(expected[i].VerticalPorePressure, actual[i].VerticalPorePressure); + Assert.AreEqual(expected[i].PiezometricPorePressure, actual[i].PiezometricPorePressure); + Assert.AreEqual(expected[i].EffectiveStress, actual[i].EffectiveStress); + Assert.AreEqual(expected[i].EffectiveStressDaily, actual[i].EffectiveStressDaily); + Assert.AreEqual(expected[i].ExcessPorePressure, actual[i].ExcessPorePressure); + Assert.AreEqual(expected[i].ShearStress, actual[i].ShearStress); + Assert.AreEqual(expected[i].SoilStress, actual[i].SoilStress); + Assert.AreEqual(expected[i].TotalPorePressure, actual[i].TotalPorePressure); + Assert.AreEqual(expected[i].TotalStress, actual[i].TotalStress); + Assert.AreEqual(expected[i].Weight, actual[i].Weight); + } + } + + /// + /// Asserts whether is equal to . + /// + /// The expected . + /// The actual . + /// Thrown when + /// is not equal to . + private static void AssertGrid(UpliftVanGridResult expected, UpliftVanGridResult actual) + { + Assert.AreEqual(expected.XLeft, actual.XLeft); + Assert.AreEqual(expected.XRight, actual.XRight); + Assert.AreEqual(expected.ZTop, actual.ZTop); + Assert.AreEqual(expected.ZBottom, actual.ZBottom); + Assert.AreEqual(expected.NumberOfHorizontalPoints, actual.NumberOfHorizontalPoints); + Assert.AreEqual(expected.NumberOfVerticalPoints, actual.NumberOfVerticalPoints); + } + } +} \ No newline at end of file Fisheye: Tag 3096dd0aeecf478a662cae38533233949c76e103 refers to a dead (removed) revision in file `Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil/Calculators/UpliftVan/Output/UpliftVanCalculatorOutputHelper.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil/Kernels/UpliftVan/Input/UpliftVanKernelInputAssert.cs =================================================================== diff -u --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil/Kernels/UpliftVan/Input/UpliftVanKernelInputAssert.cs (revision 0) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil/Kernels/UpliftVan/Input/UpliftVanKernelInputAssert.cs (revision 3096dd0aeecf478a662cae38533233949c76e103) @@ -0,0 +1,335 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System.Linq; +using Deltares.WTIStability; +using Deltares.WTIStability.Data.Geo; +using NUnit.Framework; + +namespace Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil.Kernels.UpliftVan.Input +{ + /// + /// Class for asserting Uplift Van kernel input. + /// + public static class UpliftVanKernelInputAssert + { + /// + /// Asserts whether is equal to . + /// + /// The expected . + /// The actual . + /// Thrown when + /// is not equal to . + public static void AssertSoilModels(SoilModel expected, SoilModel actual) + { + Assert.AreEqual(expected.Soils.Count, actual.Soils.Count); + + for (var i = 0; i < expected.Soils.Count; i++) + { + AssertSoils(expected.Soils[i], actual.Soils[i]); + } + } + + /// + /// Asserts whether is equal to . + /// + /// The expected . + /// The actual . + /// Thrown when + /// is not equal to . + public static void AssertSoilProfiles(SoilProfile2D expected, SoilProfile2D actual) + { + AssertSoilLayers(expected.Surfaces.ToArray(), actual.Surfaces.ToArray()); + AssertPreconsolidationStresses(expected.PreconsolidationStresses.ToArray(), actual.PreconsolidationStresses.ToArray()); + AssertGeometryDatas(expected.Geometry, actual.Geometry); + } + + /// + /// Asserts whether is equal to . + /// + /// The expected . + /// The actual . + /// Thrown when + /// is not equal to . + public static void AssertStabilityLocations(StabilityLocation expected, StabilityLocation actual) + { + Assert.AreEqual(expected.DikeSoilScenario, actual.DikeSoilScenario); + Assert.AreEqual(expected.WaterLevelRiver, actual.WaterLevelRiver); + Assert.AreEqual(expected.WaterLevelRiverAverage, actual.WaterLevelRiverAverage); + Assert.AreEqual(expected.WaterLevelPolder, actual.WaterLevelPolder); + Assert.AreEqual(expected.WaterLevelRiverLow, actual.WaterLevelRiverLow); + Assert.AreEqual(expected.DrainageConstructionPresent, actual.DrainageConstructionPresent); + Assert.AreEqual(expected.XCoordMiddleDrainageConstruction, actual.XCoordMiddleDrainageConstruction); + Assert.AreEqual(expected.ZCoordMiddleDrainageConstruction, actual.ZCoordMiddleDrainageConstruction); + Assert.AreEqual(expected.MinimumLevelPhreaticLineAtDikeTopRiver, actual.MinimumLevelPhreaticLineAtDikeTopRiver); + Assert.AreEqual(expected.MinimumLevelPhreaticLineAtDikeTopPolder, actual.MinimumLevelPhreaticLineAtDikeTopPolder); + Assert.AreEqual(expected.UseDefaultOffsets, actual.UseDefaultOffsets); + Assert.AreEqual(expected.PlLineOffsetBelowPointBRingtoetsWti2017, actual.PlLineOffsetBelowPointBRingtoetsWti2017); + Assert.AreEqual(expected.PlLineOffsetBelowDikeTopAtPolder, actual.PlLineOffsetBelowDikeTopAtPolder); + Assert.AreEqual(expected.PlLineOffsetBelowShoulderBaseInside, actual.PlLineOffsetBelowShoulderBaseInside); + Assert.AreEqual(expected.PlLineOffsetBelowDikeToeAtPolder, actual.PlLineOffsetBelowDikeToeAtPolder); + Assert.AreEqual(expected.HeadInPlLine2Outwards, actual.HeadInPlLine2Outwards); + Assert.AreEqual(expected.HeadInPlLine2Inwards, actual.HeadInPlLine2Inwards); + Assert.AreEqual(expected.AdjustPl3And4ForUplift, actual.AdjustPl3And4ForUplift); + Assert.AreEqual(expected.PenetrationLength, actual.PenetrationLength); + Assert.AreEqual(expected.LeakageLengthOutwardsPl3, actual.LeakageLengthOutwardsPl3); + Assert.AreEqual(expected.LeakageLengthInwardsPl3, actual.LeakageLengthInwardsPl3); + Assert.AreEqual(expected.LeakageLengthOutwardsPl4, actual.LeakageLengthOutwardsPl4); + Assert.AreEqual(expected.LeakageLengthInwardsPl4, actual.LeakageLengthInwardsPl4); + Assert.AreEqual(expected.WaternetCreationMode, actual.WaternetCreationMode); + } + + /// + /// Asserts whether is equal to . + /// + /// The expected . + /// The actual . + /// Thrown when + /// is not equal to . + public static void AssertSurfaceLines(SurfaceLine2 expected, SurfaceLine2 actual) + { + Assert.AreEqual(expected.Name, actual.Name); + AssertGeometryPointStrings(expected.Geometry, actual.Geometry); + AssertCharacteristicPointSets(expected.CharacteristicPoints, actual.CharacteristicPoints); + } + + /// + /// Asserts whether is equal to . + /// + /// The expected . + /// The actual . + /// Thrown when + /// is not equal to . + public static void AssertSlipPlanesUpliftVan(SlipPlaneUpliftVan expected, SlipPlaneUpliftVan actual) + { + AssertSlipCircleGrid(expected.SlipPlaneLeftGrid, actual.SlipPlaneLeftGrid); + AssertSlipCircleGrid(expected.SlipPlaneRightGrid, actual.SlipPlaneRightGrid); + AssertSlipCircleTangentLine(expected.SlipCircleTangentLine, actual.SlipCircleTangentLine); + } + + /// + /// Asserts whether is equal to . + /// + /// The expected array. + /// The actual array. + /// Thrown when + /// is not equal to . + private static void AssertSoilLayers(SoilLayer2D[] expected, SoilLayer2D[] actual) + { + Assert.AreEqual(expected.Length, actual.Length); + + for (var i = 0; i < expected.Length; i++) + { + SoilLayer2D expectedSurface = expected[i]; + SoilLayer2D actualSurface = actual[i]; + + Assert.AreEqual(expectedSurface.IsAquifer, actualSurface.IsAquifer); + AssertGeometrySurfaces(expectedSurface.GeometrySurface, actualSurface.GeometrySurface); + AssertSoils(expectedSurface.Soil, actualSurface.Soil); + Assert.AreEqual(expectedSurface.WaterpressureInterpolationModel, actualSurface.WaterpressureInterpolationModel); + } + } + + /// + /// Asserts whether is equal to . + /// + /// The expected array. + /// The actual array. + /// Thrown when + /// is not equal to . + private static void AssertPreconsolidationStresses(PreConsolidationStress[] expected, PreConsolidationStress[] actual) + { + Assert.AreEqual(expected.Length, actual.Length); + + for (var i = 0; i < expected.Length; i++) + {PreConsolidationStress + expectedPreconsolidationStress = expected[i]; + PreConsolidationStress actualPreconsolidationStress = actual[i]; + + Assert.AreEqual(expectedPreconsolidationStress.StressValue, actualPreconsolidationStress.StressValue); + Assert.AreEqual(expectedPreconsolidationStress.X, actualPreconsolidationStress.X); + Assert.AreEqual(expectedPreconsolidationStress.Z, actualPreconsolidationStress.Z); + } + } + + /// + /// Asserts whether is equal to . + /// + /// The expected . + /// The actual . + /// Thrown when + /// is not equal to . + private static void AssertGeometrySurfaces(GeometrySurface expected, GeometrySurface actual) + { + CollectionAssert.AreEqual(new[] + { + expected.OuterLoop + }.Concat(expected.InnerLoops), + new[] + { + actual.OuterLoop + }.Concat(actual.InnerLoops), + new GeometryLoopComparer()); + } + + /// + /// Asserts whether is equal to . + /// + /// The expected . + /// The actual . + /// Thrown when + /// is not equal to . + private static void AssertSoils(Soil expected, Soil actual) + { + Assert.AreEqual(expected.Name, actual.Name); + Assert.AreEqual(expected.UsePop, actual.UsePop); + Assert.AreEqual(expected.ShearStrengthModel, actual.ShearStrengthModel); + Assert.AreEqual(expected.AbovePhreaticLevel, actual.AbovePhreaticLevel); + Assert.AreEqual(expected.BelowPhreaticLevel, actual.BelowPhreaticLevel); + Assert.AreEqual(expected.Cohesion, actual.Cohesion); + Assert.AreEqual(expected.FrictionAngle, actual.FrictionAngle); + Assert.AreEqual(expected.RatioCuPc, actual.RatioCuPc); + Assert.AreEqual(expected.StrengthIncreaseExponent, actual.StrengthIncreaseExponent); + Assert.AreEqual(expected.PoP, actual.PoP); + Assert.AreEqual(expected.DilatancyType, actual.DilatancyType); + } + + /// + /// Asserts whether is equal to . + /// + /// The expected . + /// The actual . + /// Thrown when + /// is not equal to . + private static void AssertGeometryDatas(GeometryData expected, GeometryData actual) + { + AssertGeometrySurfaces(expected.Surfaces.ToArray(), actual.Surfaces.ToArray()); + + CollectionAssert.AreEqual(expected.Loops, actual.Loops, new GeometryLoopComparer()); + CollectionAssert.AreEqual(expected.Curves, actual.Curves, new GeometryCurveComparer()); + CollectionAssert.AreEqual(expected.Points, actual.Points, new StabilityPointComparer()); + + Assert.AreEqual(expected.Bottom, actual.Bottom); + Assert.AreEqual(expected.Left, actual.Left); + Assert.AreEqual(expected.Right, actual.Right); + } + + /// + /// Asserts whether is equal to . + /// + /// The expected array. + /// The actual array. + /// Thrown when + /// is not equal to . + private static void AssertGeometrySurfaces(GeometrySurface[] expected, GeometrySurface[] actual) + { + Assert.AreEqual(expected.Length, actual.Length); + + for (var i = 0; i < expected.Length; i++) + { + AssertGeometrySurfaces(expected[i], actual[i]); + } + } + + /// + /// Asserts whether is equal to . + /// + /// The expected . + /// The actual . + /// Thrown when + /// is not equal to . + private static void AssertCharacteristicPointSets(CharacteristicPointSet expected, CharacteristicPointSet actual) + { + Assert.AreEqual(expected.Count, actual.Count); + + for (var i = 0; i < expected.Count; i++) + { + CharacteristicPoint expectedCharacteristicPoint = expected[i]; + CharacteristicPoint actualCharacteristicPoint = actual[i]; + + AssertGeometryPoints(expectedCharacteristicPoint.GeometryPoint, actualCharacteristicPoint.GeometryPoint); + Assert.AreEqual(expectedCharacteristicPoint.CharacteristicPointType, actualCharacteristicPoint.CharacteristicPointType); + } + } + + /// + /// Asserts whether is equal to . + /// + /// The expected . + /// The actual . + /// Thrown when + /// is not equal to . + private static void AssertGeometryPointStrings(GeometryPointString expected, GeometryPointString actual) + { + Assert.AreEqual(expected.Points.Count, actual.Points.Count); + + for (var i = 0; i < expected.Points.Count; i++) + { + AssertGeometryPoints(expected.Points[i], actual.Points[i]); + } + } + + /// + /// Asserts whether is equal to . + /// + /// The expected . + /// The actual . + /// Thrown when + /// is not equal to . + private static void AssertGeometryPoints(GeometryPoint expected, GeometryPoint actual) + { + Assert.AreEqual(expected.X, actual.X); + Assert.AreEqual(expected.Z, actual.Z); + } + + /// + /// Asserts whether is equal to . + /// + /// The expected . + /// The actual . + /// Thrown when + /// is not equal to . + private static void AssertSlipCircleGrid(SlipCircleGrid expected, SlipCircleGrid actual) + { + Assert.AreEqual(expected.GridXLeft, actual.GridXLeft); + Assert.AreEqual(expected.GridXRight, actual.GridXRight); + Assert.AreEqual(expected.GridZTop, actual.GridZTop); + Assert.AreEqual(expected.GridZBottom, actual.GridZBottom); + Assert.AreEqual(expected.GridXNumber, actual.GridXNumber); + Assert.AreEqual(expected.GridZNumber, actual.GridZNumber); + } + + /// + /// Asserts whether is equal to . + /// + /// The expected . + /// The actual . + /// Thrown when + /// is not equal to . + private static void AssertSlipCircleTangentLine(SlipCircleTangentLine expected, SlipCircleTangentLine actual) + { + Assert.AreEqual(expected.AutomaticAtBoundaries, actual.AutomaticAtBoundaries); + Assert.AreEqual(expected.TangentLineZTop, actual.TangentLineZTop); + Assert.AreEqual(expected.TangentLineZBottom, actual.TangentLineZBottom); + Assert.AreEqual(expected.TangentLineNumber, actual.TangentLineNumber); + } + } +} \ No newline at end of file Fisheye: Tag 3096dd0aeecf478a662cae38533233949c76e103 refers to a dead (removed) revision in file `Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil/Kernels/UpliftVan/Input/UpliftVanKernelInputHelper.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil.csproj =================================================================== diff -u -r01f2f9421fd1bc8dcef928a2d86da8840da24ef5 -r3096dd0aeecf478a662cae38533233949c76e103 --- Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil.csproj (.../Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil.csproj) (revision 01f2f9421fd1bc8dcef928a2d86da8840da24ef5) +++ Ringtoets/MacroStabilityInwards/test/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil/Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil.csproj (.../Ringtoets.MacroStabilityInwards.KernelWrapper.TestUtil.csproj) (revision 3096dd0aeecf478a662cae38533233949c76e103) @@ -59,9 +59,9 @@ - + - +