//-----------------------------------------------------------------------
// <copyright file="SurfaceLineSlopeAdapterTest.cs" company="Deltares">
//  Copyright (c) 2009 Deltares. All rights reserved.
// </copyright>
// <author>B.S.T.I.M. The</author>
// <email>tom.the@deltares.nl</email>
// <date>03-12-2009</date>
// <summary>Tests for SurfaceLineSlopeAdapter</summary>
//-----------------------------------------------------------------------

using Deltares.Geometry;
using Deltares.Geotechnics;
using Deltares.Geotechnics.GeotechnicalGeometry;
using Deltares.Dam.Data;
using Deltares.Geotechnics.SurfaceLines;
using NUnit.Framework;

namespace Deltares.Dam.Tests
{
    [TestFixture]
    public class SurfaceLineSlopeAdapterTest
    {
        private readonly Location location = new Location();

        [TestFixtureTearDown]
        public void TestFixtureTearDown()
        {
            location.Dispose();
        }

        private static SurfaceLine2 CreateSimpleDike()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints = { GeometryMustContainPoint = true },
                Geometry = new LocalizedGeometryPointString()
            };
            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(2, 1, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(3, 0, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
            return surfaceLine;
        }

        #region ConstructWithDeltaX

        [Test]
        public void ConstructNewSurfaceLineReturnsANewSurfaceLine()
        {
            using (var surfaceLine = CreateSimpleDike())
            {
                var surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                using (var constructNewSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(1))
                {
                    Assert.IsNotNull(constructNewSurfaceLine);                    
                }
            }
        }


        [Test]
        public void AdaptedSimpleDikeLineHasCorrectNewToeDikeAtPolder()
        {
            using (var surfaceLine = CreateSimpleDike())
            {
                var pointDikeToeAtPolder = new GeometryPoint { X = 3, Z = 0 };
                surfaceLine.EnsurePointOfType(pointDikeToeAtPolder.X, pointDikeToeAtPolder.Z, CharacteristicPointType.DikeToeAtPolder);
                var surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(1.0))
                {
                    var expectedPointDikeToeAtPolder = new GeometryPoint { X = 4, Z = 0 };
                    Assert.IsTrue(expectedPointDikeToeAtPolder.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder)));
                }
            }
        }

        [Test]
        public void AdaptedDikeWithShoulderHasCorrectPointsAfterToeSlope()
        {
            using (var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints = { GeometryMustContainPoint = true },
                Geometry = new LocalizedGeometryPointString()
            })
            {
                var pointShoulderBaseInside = new GeometryPoint { X = 9, Z = 1 };
                var pointShoulderTopInside = new GeometryPoint { X = 11, Z = 1 };
                var pointDikeToeAtPolder = new GeometryPoint { X = 14, Z = 0 };
                var pointSurfaceLevelInside = new GeometryPoint { X = 20, Z = 0 };
                surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
                surfaceLine.EnsurePointOfType(4, 3, CharacteristicPointType.DikeTopAtRiver);
                surfaceLine.EnsurePointOfType(6, 3, CharacteristicPointType.DikeTopAtPolder);
                surfaceLine.EnsurePointOfType(pointShoulderBaseInside.X, pointShoulderBaseInside.Z, CharacteristicPointType.ShoulderBaseInside);
                surfaceLine.EnsurePointOfType(pointShoulderTopInside.X, pointShoulderTopInside.Z, CharacteristicPointType.ShoulderTopInside);
                surfaceLine.EnsurePointOfType(pointDikeToeAtPolder.X, pointDikeToeAtPolder.Z, CharacteristicPointType.DikeToeAtPolder);
                surfaceLine.EnsurePointOfType(pointSurfaceLevelInside.X, pointSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
                var surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                // Only shoulder base inside should be moved
                const double deltaX = 1.0;
                using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(deltaX))
                {
                    var expectedPointShoulderBaseInside = new GeometryPoint { X = pointShoulderBaseInside.X + deltaX, Z = pointShoulderBaseInside.Z };
                    var expectedPointShoulderTopInside = new GeometryPoint { X = pointShoulderTopInside.X, Z = pointShoulderTopInside.Z };
                    var expectedPointDikeToeAtPolder = new GeometryPoint { X = pointDikeToeAtPolder.X, Z = pointDikeToeAtPolder.Z };
                    var expectedPointSurfaceLevelInside = new GeometryPoint { X = pointSurfaceLevelInside.X, Z = pointSurfaceLevelInside.Z };

                    Assert.IsTrue(expectedPointShoulderBaseInside.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside)));
                    Assert.IsTrue(expectedPointShoulderTopInside.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside)));
                    Assert.IsTrue(expectedPointDikeToeAtPolder.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder)));
                    Assert.IsTrue(expectedPointSurfaceLevelInside.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside)));
                }
            }
        }

        [Test]
        public void AdaptedDikeWithDitchHasCorrectPointsAfterToeSlope()
        {
            using (var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints = { GeometryMustContainPoint = true },
                Geometry = new LocalizedGeometryPointString()
            })
            {
                var pointDikeToeAtPolder = new GeometryPoint { X = 14, Z = 0 };
                var pointDitchDikeSide = new GeometryPoint { X = 16, Z = 0 };
                var pointBottomDitchDikeSide = new GeometryPoint { X = 17, Z = -1 };
                var pointBottomDitchPolderSide = new GeometryPoint { X = 18, Z = -1 };
                var pointDitchPolderSide = new GeometryPoint { X = 19, Z = 0 };
                var pointSurfaceLevelInside = new GeometryPoint { X = 30, Z = 0 };
                surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
                surfaceLine.EnsurePointOfType(4, 3, CharacteristicPointType.DikeTopAtRiver);
                surfaceLine.EnsurePointOfType(6, 3, CharacteristicPointType.DikeTopAtPolder);
                surfaceLine.EnsurePointOfType(pointDikeToeAtPolder.X, pointDikeToeAtPolder.Z, CharacteristicPointType.DikeToeAtPolder);
                surfaceLine.EnsurePointOfType(pointDitchDikeSide.X, pointDitchDikeSide.Z, CharacteristicPointType.DitchDikeSide);
                surfaceLine.EnsurePointOfType(pointBottomDitchDikeSide.X, pointBottomDitchDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
                surfaceLine.EnsurePointOfType(pointBottomDitchPolderSide.X, pointBottomDitchPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
                surfaceLine.EnsurePointOfType(pointDitchPolderSide.X, pointDitchPolderSide.Z, CharacteristicPointType.DitchPolderSide);
                surfaceLine.EnsurePointOfType(pointSurfaceLevelInside.X, pointSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
                var surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                const double deltaX = 1.0;
                // minimum distance for ditch is 5 m. Was 2 so extra 3 m required.
                const double deltaXDitch = 3;
                using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(deltaX))
                {
                    var expectedPointDikeToeAtPolder = new GeometryPoint { X = pointDikeToeAtPolder.X + deltaX, Z = pointDikeToeAtPolder.Z };
                    var expectedPointDitchDikeSide = new GeometryPoint { X = pointDitchDikeSide.X + deltaX + deltaXDitch, Z = pointDitchDikeSide.Z };
                    var expectedPointBottomDitchDikeSide = new GeometryPoint { X = pointBottomDitchDikeSide.X + deltaX + deltaXDitch, Z = pointBottomDitchDikeSide.Z };
                    var expectedPointBottomDitchPolderSide = new GeometryPoint { X = pointBottomDitchPolderSide.X + deltaX + deltaXDitch, Z = pointBottomDitchPolderSide.Z };
                    var expectedPointDitchPolderSide = new GeometryPoint { X = pointDitchPolderSide.X + deltaX + deltaXDitch, Z = pointDitchPolderSide.Z };
                    var expectedPointSurfaceLevelInside = new GeometryPoint { X = pointSurfaceLevelInside.X, Z = pointSurfaceLevelInside.Z };

                    Assert.IsTrue(expectedPointDikeToeAtPolder.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder)));
                    Assert.IsTrue(expectedPointDitchDikeSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide)));
                    Assert.IsTrue(expectedPointBottomDitchDikeSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide)));
                    Assert.IsTrue(expectedPointBottomDitchPolderSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide)));
                    Assert.IsTrue(expectedPointDitchPolderSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide)));
                    Assert.IsTrue(expectedPointSurfaceLevelInside.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside)));
                }
            }
        }

        [Test]
        public void AdaptedDikeWithShoulderAndDitchHasCorrectPointsAfterToeSlope()
        {
            using (var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints = { GeometryMustContainPoint = true },
                Geometry = new LocalizedGeometryPointString()
            })
            {
                var pointShoulderBaseInside = new GeometryPoint { X = 9, Z = 1 };
                var pointShoulderTopInside = new GeometryPoint { X = 11, Z = 1 };
                var pointDikeToeAtPolder = new GeometryPoint { X = 14, Z = 0 };
                var pointDitchDikeSide = new GeometryPoint { X = 16, Z = 0 };
                var pointBottomDitchDikeSide = new GeometryPoint { X = 17, Z = -1 };
                var pointBottomDitchPolderSide = new GeometryPoint { X = 18, Z = -1 };
                var pointDitchPolderSide = new GeometryPoint { X = 19, Z = 0 };
                var pointSurfaceLevelInside = new GeometryPoint { X = 50, Z = 0 };
                surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
                surfaceLine.EnsurePointOfType(4, 3, CharacteristicPointType.DikeTopAtRiver);
                surfaceLine.EnsurePointOfType(6, 3, CharacteristicPointType.DikeTopAtPolder);
                surfaceLine.EnsurePointOfType(pointShoulderBaseInside.X, pointShoulderBaseInside.Z, CharacteristicPointType.ShoulderBaseInside);
                surfaceLine.EnsurePointOfType(pointShoulderTopInside.X, pointShoulderTopInside.Z, CharacteristicPointType.ShoulderTopInside);
                surfaceLine.EnsurePointOfType(pointDikeToeAtPolder.X, pointDikeToeAtPolder.Z, CharacteristicPointType.DikeToeAtPolder);
                surfaceLine.EnsurePointOfType(pointDitchDikeSide.X, pointDitchDikeSide.Z, CharacteristicPointType.DitchDikeSide);
                surfaceLine.EnsurePointOfType(pointBottomDitchDikeSide.X, pointBottomDitchDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
                surfaceLine.EnsurePointOfType(pointBottomDitchPolderSide.X, pointBottomDitchPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
                surfaceLine.EnsurePointOfType(pointDitchPolderSide.X, pointDitchPolderSide.Z, CharacteristicPointType.DitchPolderSide);
                surfaceLine.EnsurePointOfType(pointSurfaceLevelInside.X, pointSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
                var surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                // Only SHoulderbase inside must be moved by 1 m.
                const double deltaX = 1.0;
                using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(deltaX))
                {
                    var expectedPointShoulderBaseInside = new GeometryPoint { X = pointShoulderBaseInside.X + deltaX, Z = pointShoulderBaseInside.Z };
                    var expectedPointShoulderTopInside = new GeometryPoint { X = pointShoulderTopInside.X, Z = pointShoulderTopInside.Z };
                    var expectedPointDikeToeAtPolder = new GeometryPoint { X = pointDikeToeAtPolder.X, Z = pointDikeToeAtPolder.Z };
                    var expectedPointDitchDikeSide = new GeometryPoint { X = pointDitchDikeSide.X, Z = pointDitchDikeSide.Z };
                    var expectedPointBottomDitchDikeSide = new GeometryPoint { X = pointBottomDitchDikeSide.X, Z = pointBottomDitchDikeSide.Z };
                    var expectedPointBottomDitchPolderSide = new GeometryPoint { X = pointBottomDitchPolderSide.X, Z = pointBottomDitchPolderSide.Z };
                    var expectedPointDitchPolderSide = new GeometryPoint { X = pointDitchPolderSide.X, Z = pointDitchPolderSide.Z };
                    var expectedPointSurfaceLevelInside = new GeometryPoint { X = pointSurfaceLevelInside.X, Z = pointSurfaceLevelInside.Z };

                    Assert.IsTrue(expectedPointShoulderBaseInside.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside)));
                    Assert.IsTrue(expectedPointShoulderTopInside.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside)));
                    Assert.IsTrue(expectedPointDikeToeAtPolder.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder)));
                    Assert.IsTrue(expectedPointDitchDikeSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide)));
                    Assert.IsTrue(expectedPointBottomDitchDikeSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide)));
                    Assert.IsTrue(expectedPointBottomDitchPolderSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide)));
                    Assert.IsTrue(expectedPointDitchPolderSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide)));
                    Assert.IsTrue(expectedPointSurfaceLevelInside.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside)));
                }
            }
        }

        [Test]
        public void AdaptedSimpleDikeLineWithInBetweenPointOnInsideSlopeHasCorrectNewToeDikeAtPolder()
        {
            using (var surfaceLine = CreateSimpleDike())
            {
                surfaceLine.EnsurePoint(2.5, 0.4); // in between point on inside slope
                surfaceLine.SortPoints();
                var surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(1.0))
                {
                    var expectedPointDikeToeAtPolder = new GeometryPoint { X = 4, Z = 0 };
                    Assert.AreEqual(6, surfaceLine.Geometry.Count);
                    Assert.AreEqual(5, adaptedSurfaceLine.Geometry.Count); // in between point should be thrown away
                    Assert.IsTrue(expectedPointDikeToeAtPolder.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder)));
                }
            }
        }

        [Test]
        public void AdaptedSurfaceLineWithTrafficLoadPointsHasAdjustedPoints()
        {
            const double cTolerance = 0.0000001;

            // Create the base surfaceline (dike with shoulder and ditch)
            using (var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints = { GeometryMustContainPoint = true },
                Geometry = new LocalizedGeometryPointString()
            })
            {
                var pointShoulderBaseInside = new GeometryPoint { X = 9, Z = 1 };
                var pointShoulderTopInside = new GeometryPoint { X = 11, Z = 1 };
                var pointDikeToeAtPolder = new GeometryPoint { X = 14, Z = 0 };
                var pointDitchDikeSide = new GeometryPoint { X = 16, Z = 0 };
                var pointBottomDitchDikeSide = new GeometryPoint { X = 17, Z = -1 };
                var pointBottomDitchPolderSide = new GeometryPoint { X = 18, Z = -1 };
                var pointDitchPolderSide = new GeometryPoint { X = 19, Z = 0 };
                var pointSurfaceLevelInside = new GeometryPoint { X = 20, Z = 0 };
                surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
                surfaceLine.EnsurePointOfType(4, 3, CharacteristicPointType.DikeTopAtRiver);
                surfaceLine.EnsurePointOfType(6, 3, CharacteristicPointType.DikeTopAtPolder);
                surfaceLine.EnsurePointOfType(pointShoulderBaseInside.X, pointShoulderBaseInside.Z, CharacteristicPointType.ShoulderBaseInside);
                surfaceLine.EnsurePointOfType(pointShoulderTopInside.X, pointShoulderTopInside.Z, CharacteristicPointType.ShoulderTopInside);
                surfaceLine.EnsurePointOfType(pointDikeToeAtPolder.X, pointDikeToeAtPolder.Z, CharacteristicPointType.DikeToeAtPolder);
                surfaceLine.EnsurePointOfType(pointDitchDikeSide.X, pointDitchDikeSide.Z, CharacteristicPointType.DitchDikeSide);
                surfaceLine.EnsurePointOfType(pointBottomDitchDikeSide.X, pointBottomDitchDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
                surfaceLine.EnsurePointOfType(pointBottomDitchPolderSide.X, pointBottomDitchPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
                surfaceLine.EnsurePointOfType(pointDitchPolderSide.X, pointDitchPolderSide.Z, CharacteristicPointType.DitchPolderSide);
                surfaceLine.EnsurePointOfType(pointSurfaceLevelInside.X, pointSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);

                // Place traffic-load on slope
                var pointTrafficLoadOutside = new GeometryPoint { X = 7, Z = 2.3333333333 };
                var pointTrafficLoadInside = new GeometryPoint { X = 8, Z = 1.6666666667 };
                surfaceLine.EnsurePointOfType(pointTrafficLoadOutside.X, pointTrafficLoadOutside.Z, CharacteristicPointType.TrafficLoadOutside);
                surfaceLine.EnsurePointOfType(pointTrafficLoadInside.X, pointTrafficLoadInside.Z, CharacteristicPointType.TrafficLoadInside);
                surfaceLine.SortPoints();
                var surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                const double deltaX = 1.0;

                using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(deltaX))
                {
                    var expectedPointTrafficLoadOutside = new GeometryPoint { X = 7, Z = 2.5 };
                    var expectedPointTrafficLoadInside = new GeometryPoint { X = 8, Z = 2.0 };

                    Assert.AreEqual(expectedPointTrafficLoadOutside.X, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadOutside).X, cTolerance);
                    Assert.AreEqual(expectedPointTrafficLoadInside.X, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadInside).X, cTolerance);
                    Assert.AreEqual(expectedPointTrafficLoadOutside.Z, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadOutside).Z, cTolerance);
                    Assert.AreEqual(expectedPointTrafficLoadInside.Z, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadInside).Z, cTolerance);

                    // Place traffic-load on shoulder
                    pointTrafficLoadOutside = new GeometryPoint { X = 9.5, Z = 1.0 };
                    pointTrafficLoadInside = new GeometryPoint { X = 10.5, Z = 1.0 };
                    surfaceLine.EnsurePointOfType(pointTrafficLoadOutside.X, pointTrafficLoadOutside.Z, CharacteristicPointType.TrafficLoadOutside);
                    surfaceLine.EnsurePointOfType(pointTrafficLoadInside.X, pointTrafficLoadInside.Z, CharacteristicPointType.TrafficLoadInside);
                    surfaceLine.SortPoints();
                }

                surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                using (var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(deltaX))
                {
                    // The resulting traffic load is part on slope part on shoulder
                    var expectedPointTrafficLoadOutside = new GeometryPoint { X = 9.5, Z = 1.25 };
                    var expectedPointTrafficLoadInside = new GeometryPoint { X = 10.5, Z = 1.0 };
                    Assert.AreEqual(expectedPointTrafficLoadOutside.X, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadOutside).X, cTolerance);
                    Assert.AreEqual(expectedPointTrafficLoadInside.X, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadInside).X, cTolerance);
                    Assert.AreEqual(expectedPointTrafficLoadOutside.Z, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadOutside).Z, cTolerance);
                    Assert.AreEqual(expectedPointTrafficLoadInside.Z, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadInside).Z, cTolerance);
                }
            }
        }
        #endregion

        #region ConstructWithSlopeTangent

        [Test]
        [ExpectedException(typeof(SurfaceLineAdapterException))]
        public void IsExceptionThrownIfSlopeDoesNotIntersectSurfaceLine()
        {
            using (var surfaceLine = CreateSimpleDike())
            {
                var surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                surfaceLineAdapter.ConstructNewSurfaceLineBySlope(0);
            }
        }

        [Test]
        public void IsNotExceptionThrownIfSlopeEqualsTheCurrentSlope()
        {
            using (var surfaceLine = CreateSimpleDike())
            {
                var surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                // When new slope matches current slope, just do nothing.
                Assert.IsNotNull(surfaceLineAdapter.ConstructNewSurfaceLineBySlope(1.0));
            }
        }

        [Test]
        public void ConstructNewSurfaceLineBySlopeReturnsANewSurfaceLine()
        {
            using (var surfaceLine = CreateSimpleDike())
            {
                var surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                Assert.IsNotNull(surfaceLineAdapter.ConstructNewSurfaceLineBySlope(0.9));
            }
        }


        [Test]
        public void AdaptedSimpleDikeLineBySlopeHasCorrectNewToeDikeAtPolder()
        {
            using (var surfaceLine = CreateSimpleDike())
            {
                var surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                const double slopeTangent = 1.0 / 3.0;
                var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLineBySlope(slopeTangent);
                // Top of dike is (2,1), so new toe of dike should be (5,0)
                var expectedPointDikeToeAtPolder = new GeometryPoint { X = 5, Z = 0 };
                Assert.IsTrue(expectedPointDikeToeAtPolder.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder)));
            }
        }

        [Test]
        public void AdaptedDikeWithShoulderBySlopeHasCorrectPointsAfterToeSlope()
        {
            using (var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints = { GeometryMustContainPoint = true },
                Geometry = new LocalizedGeometryPointString()
            })
            {
                var pointShoulderBaseInside = new GeometryPoint { X = 9, Z = 1 };
                var pointShoulderTopInside = new GeometryPoint { X = 11, Z = 1 };
                var pointDikeToeAtPolder = new GeometryPoint { X = 14, Z = 0 };
                var pointSurfaceLevelInside = new GeometryPoint { X = 50, Z = 0 };
                surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
                surfaceLine.EnsurePointOfType(4, 3, CharacteristicPointType.DikeTopAtRiver);
                surfaceLine.EnsurePointOfType(6, 3, CharacteristicPointType.DikeTopAtPolder);
                surfaceLine.EnsurePointOfType(pointShoulderBaseInside.X, pointShoulderBaseInside.Z, CharacteristicPointType.ShoulderBaseInside);
                surfaceLine.EnsurePointOfType(pointShoulderTopInside.X, pointShoulderTopInside.Z, CharacteristicPointType.ShoulderTopInside);
                surfaceLine.EnsurePointOfType(pointDikeToeAtPolder.X, pointDikeToeAtPolder.Z, CharacteristicPointType.DikeToeAtPolder);
                surfaceLine.EnsurePointOfType(pointSurfaceLevelInside.X, pointSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
                var surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                const double slopeTangent = 1.0 / 4.0;
                var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLineBySlope(slopeTangent);
                const double deltaX = 4.0;
                var expectedPointDikeToeAtPolder = new GeometryPoint { X = pointDikeToeAtPolder.X + deltaX, Z = pointDikeToeAtPolder.Z };
                var expectedPointSurfaceLevelInside = new GeometryPoint { X = pointSurfaceLevelInside.X, Z = pointSurfaceLevelInside.Z };

                Assert.IsFalse(adaptedSurfaceLine.HasAnnotation(CharacteristicPointType.ShoulderBaseInside));
                Assert.IsFalse(adaptedSurfaceLine.HasAnnotation(CharacteristicPointType.ShoulderTopInside));
                Assert.IsTrue(expectedPointDikeToeAtPolder.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder)));
                Assert.IsTrue(expectedPointSurfaceLevelInside.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside)));
            }
        }

        [Test]
        public void AdaptedDikeWithDitchBySlopeHasCorrectPointsAfterToeSlope()
        {
            using (var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints = { GeometryMustContainPoint = true },
                Geometry = new LocalizedGeometryPointString()
            })
            {
                var pointDikeToeAtPolder = new GeometryPoint { X = 14, Z = 0 };
                var pointDitchDikeSide = new GeometryPoint { X = 16, Z = 0 };
                var pointBottomDitchDikeSide = new GeometryPoint { X = 17, Z = -1 };
                var pointBottomDitchPolderSide = new GeometryPoint { X = 18, Z = -1 };
                var pointDitchPolderSide = new GeometryPoint { X = 19, Z = 0 };
                var pointSurfaceLevelInside = new GeometryPoint { X = 50, Z = 0 };
                surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
                surfaceLine.EnsurePointOfType(4, 3, CharacteristicPointType.DikeTopAtRiver);
                surfaceLine.EnsurePointOfType(6, 3, CharacteristicPointType.DikeTopAtPolder);
                surfaceLine.EnsurePointOfType(pointDikeToeAtPolder.X, pointDikeToeAtPolder.Z, CharacteristicPointType.DikeToeAtPolder);
                surfaceLine.EnsurePointOfType(pointDitchDikeSide.X, pointDitchDikeSide.Z, CharacteristicPointType.DitchDikeSide);
                surfaceLine.EnsurePointOfType(pointBottomDitchDikeSide.X, pointBottomDitchDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
                surfaceLine.EnsurePointOfType(pointBottomDitchPolderSide.X, pointBottomDitchPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
                surfaceLine.EnsurePointOfType(pointDitchPolderSide.X, pointDitchPolderSide.Z, CharacteristicPointType.DitchPolderSide);
                surfaceLine.EnsurePointOfType(pointSurfaceLevelInside.X, pointSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
                var surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                const double slopeTangent = 1.0 / 4.0;
                var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLineBySlope(slopeTangent);
                const double deltaX = 4.0;
                // minimum distance for ditch is 5 m. Was 2 so extra 3 m required.
                const double deltaXDitch = 3;
                var expectedPointDikeToeAtPolder = new GeometryPoint { X = pointDikeToeAtPolder.X + deltaX, Z = pointDikeToeAtPolder.Z };
                var expectedPointDitchDikeSide = new GeometryPoint { X = pointDitchDikeSide.X + deltaX + deltaXDitch, Z = pointDitchDikeSide.Z };
                var expectedPointBottomDitchDikeSide = new GeometryPoint { X = pointBottomDitchDikeSide.X + deltaX + deltaXDitch, Z = pointBottomDitchDikeSide.Z };
                var expectedPointBottomDitchPolderSide = new GeometryPoint { X = pointBottomDitchPolderSide.X + deltaX + deltaXDitch, Z = pointBottomDitchPolderSide.Z };
                var expectedPointDitchPolderSide = new GeometryPoint { X = pointDitchPolderSide.X + deltaX + deltaXDitch, Z = pointDitchPolderSide.Z };
                // Last point may not be shifted.
                var expectedPointSurfaceLevelInside = new GeometryPoint { X = pointSurfaceLevelInside.X, Z = pointSurfaceLevelInside.Z };

                Assert.IsTrue(expectedPointDikeToeAtPolder.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder)));
                Assert.IsTrue(expectedPointDitchDikeSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide)));
                Assert.IsTrue(expectedPointBottomDitchDikeSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide)));
                Assert.IsTrue(expectedPointBottomDitchPolderSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide)));
                Assert.IsTrue(expectedPointDitchPolderSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide)));
                Assert.IsTrue(expectedPointSurfaceLevelInside.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside)));
            }
        }

        [Test]
        [ExpectedException(typeof(SurfaceLineAdapterException))]
        public void IsExceptionThrownWhenSlopeDoesNotFit()
        {
            using (var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints = { GeometryMustContainPoint = true },
                Geometry = new LocalizedGeometryPointString()
            })
            {
                var pointDikeToeAtPolder = new GeometryPoint { X = 14, Z = 0 };
                var pointDitchDikeSide = new GeometryPoint { X = 16, Z = 0 };
                var pointBottomDitchDikeSide = new GeometryPoint { X = 17, Z = -1 };
                var pointBottomDitchPolderSide = new GeometryPoint { X = 18, Z = -1 };
                var pointDitchPolderSide = new GeometryPoint { X = 19, Z = 0 };
                var pointSurfaceLevelInside = new GeometryPoint { X = 20, Z = 0 };
                surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
                surfaceLine.EnsurePointOfType(4, 3, CharacteristicPointType.DikeTopAtRiver);
                surfaceLine.EnsurePointOfType(6, 3, CharacteristicPointType.DikeTopAtPolder);
                surfaceLine.EnsurePointOfType(pointDikeToeAtPolder.X, pointDikeToeAtPolder.Z, CharacteristicPointType.DikeToeAtPolder);
                surfaceLine.EnsurePointOfType(pointDitchDikeSide.X, pointDitchDikeSide.Z, CharacteristicPointType.DitchDikeSide);
                surfaceLine.EnsurePointOfType(pointBottomDitchDikeSide.X, pointBottomDitchDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
                surfaceLine.EnsurePointOfType(pointBottomDitchPolderSide.X, pointBottomDitchPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
                surfaceLine.EnsurePointOfType(pointDitchPolderSide.X, pointDitchPolderSide.Z, CharacteristicPointType.DitchPolderSide);
                surfaceLine.EnsurePointOfType(pointSurfaceLevelInside.X, pointSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
                var surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                const double slopeTangent = 1.0 / 4.0;
                surfaceLineAdapter.ConstructNewSurfaceLineBySlope(slopeTangent); 
            }
        }

        [Test]
        public void AdaptedDikeWithShoulderAndDitchBySlopeHasCorrectPointsAfterSlopeIntersectsBeyondDikeToe()
        {
            using (var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints = { GeometryMustContainPoint = true },
                Geometry = new LocalizedGeometryPointString()
            })
            {
                var pointShoulderBaseInside = new GeometryPoint { X = 9, Z = 1 };
                var pointShoulderTopInside = new GeometryPoint { X = 11, Z = 1 };
                var pointDikeToeAtPolder = new GeometryPoint { X = 14, Z = 0 };
                var pointDitchDikeSide = new GeometryPoint { X = 16, Z = 0 };
                var pointBottomDitchDikeSide = new GeometryPoint { X = 17, Z = -1 };
                var pointBottomDitchPolderSide = new GeometryPoint { X = 18, Z = -1 };
                var pointDitchPolderSide = new GeometryPoint { X = 19, Z = 0 };
                var pointSurfaceLevelInside = new GeometryPoint { X = 50, Z = 0 };
                surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
                surfaceLine.EnsurePointOfType(4, 3, CharacteristicPointType.DikeTopAtRiver);
                surfaceLine.EnsurePointOfType(6, 3, CharacteristicPointType.DikeTopAtPolder);
                surfaceLine.EnsurePointOfType(pointShoulderBaseInside.X, pointShoulderBaseInside.Z, CharacteristicPointType.ShoulderBaseInside);
                surfaceLine.EnsurePointOfType(pointShoulderTopInside.X, pointShoulderTopInside.Z, CharacteristicPointType.ShoulderTopInside);
                surfaceLine.EnsurePointOfType(pointDikeToeAtPolder.X, pointDikeToeAtPolder.Z, CharacteristicPointType.DikeToeAtPolder);
                surfaceLine.EnsurePointOfType(pointDitchDikeSide.X, pointDitchDikeSide.Z, CharacteristicPointType.DitchDikeSide);
                surfaceLine.EnsurePointOfType(pointBottomDitchDikeSide.X, pointBottomDitchDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
                surfaceLine.EnsurePointOfType(pointBottomDitchPolderSide.X, pointBottomDitchPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
                surfaceLine.EnsurePointOfType(pointDitchPolderSide.X, pointDitchPolderSide.Z, CharacteristicPointType.DitchPolderSide);
                surfaceLine.EnsurePointOfType(pointSurfaceLevelInside.X, pointSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
                var surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                // new slope 1/4, the new slope cuts the surface line at 18, 0. This becomes the new dike toe, all points between top and toe must be deleted.
                // The shift for the toe and all ditch points = 18 - 14 = 4 meter.
                const double slopeTangent = 1.0 / 4.0;
                var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLineBySlope(slopeTangent);
                const double deltaX = 4.0;
                // minimum distance for ditch is 5 m. Was 2 so extra 3 m required.
                const double deltaXDitch = 3;
                var expectedPointDikeToeAtPolder = new GeometryPoint { X = pointDikeToeAtPolder.X + deltaX, Z = pointDikeToeAtPolder.Z };
                var expectedPointDitchDikeSide = new GeometryPoint { X = pointDitchDikeSide.X + deltaX + deltaXDitch, Z = pointDitchDikeSide.Z };
                var expectedPointBottomDitchDikeSide = new GeometryPoint { X = pointBottomDitchDikeSide.X + deltaX + deltaXDitch, Z = pointBottomDitchDikeSide.Z };
                var expectedPointBottomDitchPolderSide = new GeometryPoint { X = pointBottomDitchPolderSide.X + deltaX + deltaXDitch, Z = pointBottomDitchPolderSide.Z };
                var expectedPointDitchPolderSide = new GeometryPoint { X = pointDitchPolderSide.X + deltaX + deltaXDitch, Z = pointDitchPolderSide.Z };
                var expectedPointSurfaceLevelInside = new GeometryPoint { X = pointSurfaceLevelInside.X, Z = pointSurfaceLevelInside.Z };

                Assert.IsFalse(adaptedSurfaceLine.HasAnnotation(CharacteristicPointType.ShoulderBaseInside));
                Assert.IsFalse(adaptedSurfaceLine.HasAnnotation(CharacteristicPointType.ShoulderTopInside));
                Assert.IsTrue(expectedPointDikeToeAtPolder.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder)));
                Assert.IsTrue(expectedPointDitchDikeSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide)));
                Assert.IsTrue(expectedPointBottomDitchDikeSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide)));
                Assert.IsTrue(expectedPointBottomDitchPolderSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide)));
                Assert.IsTrue(expectedPointDitchPolderSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide)));
                Assert.IsTrue(expectedPointSurfaceLevelInside.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside)));
            }
        }

        [Test]
        public void AdaptedDikeWithShoulderAndDitchBySlopeHasCorrectPointsAfterSlopeIntersectsInShoulderBetweenBaseAndTop()
        {
            using (var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints = { GeometryMustContainPoint = true },
                Geometry = new LocalizedGeometryPointString()
            })
            {
                var pointShoulderBaseInside = new GeometryPoint { X = 9, Z = 1 };
                var pointShoulderTopInside = new GeometryPoint { X = 11, Z = 1 };
                var pointDikeToeAtPolder = new GeometryPoint { X = 14, Z = 0 };
                var pointDitchDikeSide = new GeometryPoint { X = 16, Z = 0 };
                var pointBottomDitchDikeSide = new GeometryPoint { X = 17, Z = -1 };
                var pointBottomDitchPolderSide = new GeometryPoint { X = 18, Z = -1 };
                var pointDitchPolderSide = new GeometryPoint { X = 19, Z = 0 };
                var pointSurfaceLevelInside = new GeometryPoint { X = 50, Z = 0 };
                surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
                surfaceLine.EnsurePointOfType(4, 3, CharacteristicPointType.DikeTopAtRiver);
                surfaceLine.EnsurePointOfType(6, 3, CharacteristicPointType.DikeTopAtPolder);
                surfaceLine.EnsurePointOfType(pointShoulderBaseInside.X, pointShoulderBaseInside.Z, CharacteristicPointType.ShoulderBaseInside);
                surfaceLine.EnsurePointOfType(pointShoulderTopInside.X, pointShoulderTopInside.Z, CharacteristicPointType.ShoulderTopInside);
                surfaceLine.EnsurePointOfType(pointDikeToeAtPolder.X, pointDikeToeAtPolder.Z, CharacteristicPointType.DikeToeAtPolder);
                surfaceLine.EnsurePointOfType(pointDitchDikeSide.X, pointDitchDikeSide.Z, CharacteristicPointType.DitchDikeSide);
                surfaceLine.EnsurePointOfType(pointBottomDitchDikeSide.X, pointBottomDitchDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
                surfaceLine.EnsurePointOfType(pointBottomDitchPolderSide.X, pointBottomDitchPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
                surfaceLine.EnsurePointOfType(pointDitchPolderSide.X, pointDitchPolderSide.Z, CharacteristicPointType.DitchPolderSide);
                surfaceLine.EnsurePointOfType(pointSurfaceLevelInside.X, pointSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
                var surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                // With 1/2, the new slope cuts the shoulder at 10, 1 so only the Shoulderbase inside should be moved by 1 meter, rest must remain where it is.
                const double slopeTangent = 1.0 / 2.0;
                var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLineBySlope(slopeTangent);
                const double deltaX = 1.0;
                var expectedShoulderBaseInside = new GeometryPoint { X = pointShoulderBaseInside.X + deltaX, Z = pointShoulderBaseInside.Z };
                var expectedShoulderTopInside = new GeometryPoint { X = pointShoulderTopInside.X, Z = pointShoulderTopInside.Z };
                var expectedPointDikeToeAtPolder = new GeometryPoint { X = pointDikeToeAtPolder.X, Z = pointDikeToeAtPolder.Z };
                var expectedPointDitchDikeSide = new GeometryPoint { X = pointDitchDikeSide.X, Z = pointDitchDikeSide.Z };
                var expectedPointBottomDitchDikeSide = new GeometryPoint { X = pointBottomDitchDikeSide.X, Z = pointBottomDitchDikeSide.Z };
                var expectedPointBottomDitchPolderSide = new GeometryPoint { X = pointBottomDitchPolderSide.X, Z = pointBottomDitchPolderSide.Z };
                var expectedPointDitchPolderSide = new GeometryPoint { X = pointDitchPolderSide.X, Z = pointDitchPolderSide.Z };
                var expectedPointSurfaceLevelInside = new GeometryPoint { X = pointSurfaceLevelInside.X, Z = pointSurfaceLevelInside.Z };

                Assert.IsTrue(expectedShoulderBaseInside.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside)));
                Assert.IsTrue(expectedShoulderTopInside.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside)));
                Assert.IsTrue(expectedPointDikeToeAtPolder.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder)));
                Assert.IsTrue(expectedPointDitchDikeSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide)));
                Assert.IsTrue(expectedPointBottomDitchDikeSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide)));
                Assert.IsTrue(expectedPointBottomDitchPolderSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide)));
                Assert.IsTrue(expectedPointDitchPolderSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide)));
                Assert.IsTrue(expectedPointSurfaceLevelInside.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside)));
            }
        }

        [Test]
        public void AdaptedDikeWithShoulderAndDitchBySlopeHasCorrectPointsAfterSlopeIntersectsOnShoulderTop()
        {
            using (var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints = { GeometryMustContainPoint = true },
                Geometry = new LocalizedGeometryPointString()
            })
            {
                var pointShoulderBaseInside = new GeometryPoint { X = 9, Z = 1 };
                var pointShoulderTopInside = new GeometryPoint { X = 10, Z = 1 };
                var pointDikeToeAtPolder = new GeometryPoint { X = 14, Z = 0 };
                var pointDitchDikeSide = new GeometryPoint { X = 16, Z = 0 };
                var pointBottomDitchDikeSide = new GeometryPoint { X = 17, Z = -1 };
                var pointBottomDitchPolderSide = new GeometryPoint { X = 18, Z = -1 };
                var pointDitchPolderSide = new GeometryPoint { X = 19, Z = 0 };
                var pointSurfaceLevelInside = new GeometryPoint { X = 50, Z = 0 };
                surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
                surfaceLine.EnsurePointOfType(4, 3, CharacteristicPointType.DikeTopAtRiver);
                surfaceLine.EnsurePointOfType(6, 3, CharacteristicPointType.DikeTopAtPolder);
                surfaceLine.EnsurePointOfType(pointShoulderBaseInside.X, pointShoulderBaseInside.Z, CharacteristicPointType.ShoulderBaseInside);
                surfaceLine.EnsurePointOfType(pointShoulderTopInside.X, pointShoulderTopInside.Z, CharacteristicPointType.ShoulderTopInside);
                surfaceLine.EnsurePointOfType(pointDikeToeAtPolder.X, pointDikeToeAtPolder.Z, CharacteristicPointType.DikeToeAtPolder);
                surfaceLine.EnsurePointOfType(pointDitchDikeSide.X, pointDitchDikeSide.Z, CharacteristicPointType.DitchDikeSide);
                surfaceLine.EnsurePointOfType(pointBottomDitchDikeSide.X, pointBottomDitchDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
                surfaceLine.EnsurePointOfType(pointBottomDitchPolderSide.X, pointBottomDitchPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
                surfaceLine.EnsurePointOfType(pointDitchPolderSide.X, pointDitchPolderSide.Z, CharacteristicPointType.DitchPolderSide);
                surfaceLine.EnsurePointOfType(pointSurfaceLevelInside.X, pointSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
                var surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                // With 1/2, the new slope cuts the shoulder at 10, 1 (= ShoulderTopInside). The Shoulderbase inside should be removed, 
                // the shouldertop inside should be replaced by a normal point (without type). Nothing must be shifted
                const double slopeTangent = 1.0 / 2.0;
                var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLineBySlope(slopeTangent);

                var expectedNewPoint = new GeometryPoint { X = pointShoulderTopInside.X, Z = pointShoulderTopInside.Z };
                var expectedPointDikeToeAtPolder = new GeometryPoint { X = pointDikeToeAtPolder.X, Z = pointDikeToeAtPolder.Z };
                var expectedPointDitchDikeSide = new GeometryPoint { X = pointDitchDikeSide.X, Z = pointDitchDikeSide.Z };
                var expectedPointBottomDitchDikeSide = new GeometryPoint { X = pointBottomDitchDikeSide.X, Z = pointBottomDitchDikeSide.Z };
                var expectedPointBottomDitchPolderSide = new GeometryPoint { X = pointBottomDitchPolderSide.X, Z = pointBottomDitchPolderSide.Z };
                var expectedPointDitchPolderSide = new GeometryPoint { X = pointDitchPolderSide.X, Z = pointDitchPolderSide.Z };
                var expectedPointSurfaceLevelInside = new GeometryPoint { X = pointSurfaceLevelInside.X, Z = pointSurfaceLevelInside.Z };

                Assert.IsFalse(adaptedSurfaceLine.HasAnnotation(CharacteristicPointType.ShoulderBaseInside));
                Assert.IsFalse(adaptedSurfaceLine.HasAnnotation(CharacteristicPointType.ShoulderTopInside));
                Assert.IsTrue(adaptedSurfaceLine.Geometry.GetPointAt(expectedNewPoint.X, expectedNewPoint.Z) != null);
                Assert.IsTrue(expectedPointDikeToeAtPolder.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder)));
                Assert.IsTrue(expectedPointDitchDikeSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide)));
                Assert.IsTrue(expectedPointBottomDitchDikeSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide)));
                Assert.IsTrue(expectedPointBottomDitchPolderSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide)));
                Assert.IsTrue(expectedPointDitchPolderSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide)));
                Assert.IsTrue(expectedPointSurfaceLevelInside.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside)));
            }
        }

        [Test]
        public void AdaptedDikeWithShoulderAndDitchBySlopeHasCorrectPointsAfterSlopeIntersectsInShoulderBetweenTopAndDikeToe()
        {
            using (var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints = { GeometryMustContainPoint = true },
                Geometry = new LocalizedGeometryPointString()
            })
            {
                var pointShoulderBaseInside = new GeometryPoint { X = 7, Z = 1 };
                var pointShoulderTopInside = new GeometryPoint { X = 8, Z = 0 };
                var pointDikeToeAtPolder = new GeometryPoint { X = 14, Z = 0 };
                var pointDitchDikeSide = new GeometryPoint { X = 16, Z = 0 };
                var pointBottomDitchDikeSide = new GeometryPoint { X = 17, Z = -1 };
                var pointBottomDitchPolderSide = new GeometryPoint { X = 18, Z = -1 };
                var pointDitchPolderSide = new GeometryPoint { X = 19, Z = 0 };
                var pointSurfaceLevelInside = new GeometryPoint { X = 50, Z = 0 };
                surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
                surfaceLine.EnsurePointOfType(4, 3, CharacteristicPointType.DikeTopAtRiver);
                surfaceLine.EnsurePointOfType(6, 3, CharacteristicPointType.DikeTopAtPolder);
                surfaceLine.EnsurePointOfType(pointShoulderBaseInside.X, pointShoulderBaseInside.Z, CharacteristicPointType.ShoulderBaseInside);
                surfaceLine.EnsurePointOfType(pointShoulderTopInside.X, pointShoulderTopInside.Z, CharacteristicPointType.ShoulderTopInside);
                surfaceLine.EnsurePointOfType(pointDikeToeAtPolder.X, pointDikeToeAtPolder.Z, CharacteristicPointType.DikeToeAtPolder);
                surfaceLine.EnsurePointOfType(pointDitchDikeSide.X, pointDitchDikeSide.Z, CharacteristicPointType.DitchDikeSide);
                surfaceLine.EnsurePointOfType(pointBottomDitchDikeSide.X, pointBottomDitchDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
                surfaceLine.EnsurePointOfType(pointBottomDitchPolderSide.X, pointBottomDitchPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
                surfaceLine.EnsurePointOfType(pointDitchPolderSide.X, pointDitchPolderSide.Z, CharacteristicPointType.DitchPolderSide);
                surfaceLine.EnsurePointOfType(pointSurfaceLevelInside.X, pointSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
                var surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                // With 1/2, the new slope cuts the shoulder at 12, 0. So the entire shoulder must be deleted and a normal point must be added at the location.
                const double slopeTangent = 1.0 / 2.0;
                var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLineBySlope(slopeTangent);
                const double deltaX = 4.0; // from pointShoulderTopInside
                var expectedNewPoint = new GeometryPoint { X = pointShoulderTopInside.X + deltaX, Z = pointShoulderTopInside.Z };
                var expectedPointDikeToeAtPolder = new GeometryPoint { X = pointDikeToeAtPolder.X, Z = pointDikeToeAtPolder.Z };
                var expectedPointDitchDikeSide = new GeometryPoint { X = pointDitchDikeSide.X, Z = pointDitchDikeSide.Z };
                var expectedPointBottomDitchDikeSide = new GeometryPoint { X = pointBottomDitchDikeSide.X, Z = pointBottomDitchDikeSide.Z };
                var expectedPointBottomDitchPolderSide = new GeometryPoint { X = pointBottomDitchPolderSide.X, Z = pointBottomDitchPolderSide.Z };
                var expectedPointDitchPolderSide = new GeometryPoint { X = pointDitchPolderSide.X, Z = pointDitchPolderSide.Z };
                var expectedPointSurfaceLevelInside = new GeometryPoint { X = pointSurfaceLevelInside.X, Z = pointSurfaceLevelInside.Z };

                Assert.IsFalse(adaptedSurfaceLine.HasAnnotation(CharacteristicPointType.ShoulderBaseInside));
                Assert.IsFalse(adaptedSurfaceLine.HasAnnotation(CharacteristicPointType.ShoulderTopInside));
                Assert.IsTrue(adaptedSurfaceLine.Geometry.GetPointAt(expectedNewPoint.X, expectedNewPoint.Z) != null);
                Assert.IsTrue(expectedPointDikeToeAtPolder.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder)));
                Assert.IsTrue(expectedPointDitchDikeSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide)));
                Assert.IsTrue(expectedPointBottomDitchDikeSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide)));
                Assert.IsTrue(expectedPointBottomDitchPolderSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide)));
                Assert.IsTrue(expectedPointDitchPolderSide.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide)));
                Assert.IsTrue(expectedPointSurfaceLevelInside.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside)));
            }
        }
        
        [Test]
        public void AdaptedSimpleDikeLineWithInBetweenPointOnInsideSlopeBySlopeHasCorrectNewToeDikeAtPolder()
        {
            using (var surfaceLine = CreateSimpleDike())
            {
                var pointDikeToeAtPolder = surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
                surfaceLine.EnsurePoint(2.5, 0.4); // in between point on inside slope
                surfaceLine.SortPoints();
                var surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                const double slopeTangent = 1.0 / 4.0;
                var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLineBySlope(slopeTangent);
                const double deltaX = 3.0;
                var expectedPointDikeToeAtPolder = new GeometryPoint { X = pointDikeToeAtPolder.X + deltaX, Z = pointDikeToeAtPolder.Z };
                Assert.AreEqual(6, surfaceLine.Geometry.Count);
                Assert.AreEqual(5, adaptedSurfaceLine.Geometry.Count); // in between point should be thrown away
                Assert.IsTrue(expectedPointDikeToeAtPolder.LocationEquals(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder)));
            }
        }

        [Test]
        public void AdaptedSurfaceLineWithTrafficLoadPointsBySlopeHasAdjustedPoints()
        {
            const double cTolerance = 0.0000001;

            // Create the base surfaceline (dike with shoulder and ditch)
            using (var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints = { GeometryMustContainPoint = true },
                Geometry = new LocalizedGeometryPointString()
            })
            {
                var pointShoulderBaseInside = new GeometryPoint { X = 9, Z = 1 };
                var pointShoulderTopInside = new GeometryPoint { X = 11, Z = 1 };
                var pointDikeToeAtPolder = new GeometryPoint { X = 14, Z = 0 };
                var pointDitchDikeSide = new GeometryPoint { X = 16, Z = 0 };
                var pointBottomDitchDikeSide = new GeometryPoint { X = 17, Z = -1 };
                var pointBottomDitchPolderSide = new GeometryPoint { X = 18, Z = -1 };
                var pointDitchPolderSide = new GeometryPoint { X = 19, Z = 0 };
                var pointSurfaceLevelInside = new GeometryPoint { X = 50, Z = 0 };
                surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
                surfaceLine.EnsurePointOfType(4, 3, CharacteristicPointType.DikeTopAtRiver);
                surfaceLine.EnsurePointOfType(6, 3, CharacteristicPointType.DikeTopAtPolder);
                surfaceLine.EnsurePointOfType(pointShoulderBaseInside.X, pointShoulderBaseInside.Z, CharacteristicPointType.ShoulderBaseInside);
                surfaceLine.EnsurePointOfType(pointShoulderTopInside.X, pointShoulderTopInside.Z, CharacteristicPointType.ShoulderTopInside);
                surfaceLine.EnsurePointOfType(pointDikeToeAtPolder.X, pointDikeToeAtPolder.Z, CharacteristicPointType.DikeToeAtPolder);
                surfaceLine.EnsurePointOfType(pointDitchDikeSide.X, pointDitchDikeSide.Z, CharacteristicPointType.DitchDikeSide);
                surfaceLine.EnsurePointOfType(pointBottomDitchDikeSide.X, pointBottomDitchDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
                surfaceLine.EnsurePointOfType(pointBottomDitchPolderSide.X, pointBottomDitchPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
                surfaceLine.EnsurePointOfType(pointDitchPolderSide.X, pointDitchPolderSide.Z, CharacteristicPointType.DitchPolderSide);
                surfaceLine.EnsurePointOfType(pointSurfaceLevelInside.X, pointSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);

                // Place traffic-load on slope
                var pointTrafficLoadOutside = new GeometryPoint { X = 7, Z = 2.3333333333 };
                var pointTrafficLoadInside = new GeometryPoint { X = 8, Z = 1.6666666667 };
                surfaceLine.EnsurePointOfType(pointTrafficLoadOutside.X, pointTrafficLoadOutside.Z, CharacteristicPointType.TrafficLoadOutside);
                surfaceLine.EnsurePointOfType(pointTrafficLoadInside.X, pointTrafficLoadInside.Z, CharacteristicPointType.TrafficLoadInside);
                surfaceLine.SortPoints();
                var surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                const double slopeTangent = 1.0 / 4.0;
                var adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLineBySlope(slopeTangent);
                var expectedPointTrafficLoadOutside = new GeometryPoint { X = 7, Z = 2.75 };
                var expectedPointTrafficLoadInside = new GeometryPoint { X = 8, Z = 2.5 };
                Assert.AreEqual(expectedPointTrafficLoadOutside.X, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadOutside).X, cTolerance);
                Assert.AreEqual(expectedPointTrafficLoadInside.X, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadInside).X, cTolerance);
                Assert.AreEqual(expectedPointTrafficLoadOutside.Z, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadOutside).Z, cTolerance);
                Assert.AreEqual(expectedPointTrafficLoadInside.Z, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadInside).Z, cTolerance);

                // Place traffic-load on shoulder
                pointTrafficLoadOutside = new GeometryPoint { X = 10.0, Z = 1.0 };
                pointTrafficLoadInside = new GeometryPoint { X = 13, Z = 1.0 / 3.0 };
                surfaceLine.EnsurePointOfType(pointTrafficLoadOutside.X, pointTrafficLoadOutside.Z, CharacteristicPointType.TrafficLoadOutside);
                surfaceLine.EnsurePointOfType(pointTrafficLoadInside.X, pointTrafficLoadInside.Z, CharacteristicPointType.TrafficLoadInside);
                surfaceLine.SortPoints();
                surfaceLineAdapter = new SurfaceLineSlopeAdapter(surfaceLine, location);
                adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLineBySlope(slopeTangent);
                // The resulting traffic load is part on slope part on shoulder
                expectedPointTrafficLoadOutside = new GeometryPoint { X = 10.0, Z = 2.0 };
                expectedPointTrafficLoadInside = new GeometryPoint { X = 13, Z = 1.25 };
                Assert.AreEqual(expectedPointTrafficLoadOutside.X, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadOutside).X, cTolerance);
                Assert.AreEqual(expectedPointTrafficLoadInside.X, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadInside).X, cTolerance);
                Assert.AreEqual(expectedPointTrafficLoadOutside.Z, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadOutside).Z, cTolerance);
                Assert.AreEqual(expectedPointTrafficLoadInside.Z, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadInside).Z, cTolerance);
            }
        }
        #endregion
    }
}