// Copyright (C) Stichting Deltares 2018. All rights reserved.
//
// This file is part of the Dam Engine.
//
// The Dam Engine is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// 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.DamEngine.Calculators.Dikes_Design;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.Geometry;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Data.Standard.Validation;
using Deltares.DamEngine.TestHelpers.Factories;
using NUnit.Framework;

namespace Deltares.DamEngine.Calculators.Tests.DikesDesign
{
    [TestFixture]
    public class SurfaceLineHeightAdapterTest
    {
        [Test]
        public void ConstructNewSurfaceLineReturnsANewSurfaceLine()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            {
                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);
                var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
                var constructNewSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(1);
                {
                    Assert.IsNotNull(constructNewSurfaceLine);
                }
            }
        }

        [Test]
        public void AdaptedSurfaceLineHasSamePointAtToeRiver()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            {
                const double newDikeHeight = 6.0;
                var pointAtToeRiver = new GeometryPoint { X = 17, Z = 0 };
                var pointAtTopRiver = new GeometryPoint { X = 34.5, Z = 5 };
                var pointAtTopPolder = new GeometryPoint { X = 35, Z = 5 };
                var pointAtToePolder = new GeometryPoint { X = 36, Z = 0 };

                surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtRiver);
                surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
                surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
                surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
                surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);

                var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
                var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
                {
                    var newPointAtToeRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtRiver);
                    Assert.IsTrue(newPointAtToeRiver.LocationEquals(pointAtToeRiver));
                    Assert.IsTrue(newSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(pointAtToeRiver)));
                }
            }
        }

        [Test]
        public void AdaptedSurfaceLineHasSameSlopeInside()
        {
            var line = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var surfaceLine = line;
            var location = new Location();
            const double cToleranceSlope = 0.0001;
            const double newDikeHeight = 6.0;
            var pointAtToeRiver = new GeometryPoint { X = 17, Z = 0 };
            var pointAtTopRiver = new GeometryPoint { X = 34.5, Z = 5 };
            var pointAtTopPolder = new GeometryPoint { X = 35, Z = 5 };
            var pointAtToePolder = new GeometryPoint { X = 36, Z = 0 };
            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
            surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            double oldSlope = surfaceLine.TanSlopeInside();
            double newSlope = newSurfaceLine.TanSlopeInside();
            Assert.AreEqual(oldSlope, newSlope, cToleranceSlope);
        }

        [Test]
        public void AdaptedSurfaceLineHasCorrectNewPointAtTopRiver()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 2.0;
            var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
            var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
            var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
            var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
            surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            var actualPoint = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
            var expectedPoint = new GeometryPoint { X = 2, Z = 2 };
            Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
        }

        [Test]
        public void AdaptedSurfaceLineHasRemovedOldPointAtTopRiverCorrectly()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 2.0;
            var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
            var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
            var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
            var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
            surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            Assert.IsFalse(newSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(pointAtTopRiver)));
        }

        [Test]
        public void AdaptedSurfaceLineWithoutShoulderHasCorrectNewPointAtTopPolder()
        {
            var line = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var surfaceLine = line;
            var location = new Location();
            const double newDikeHeight = 2.0;
            var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
            var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
            var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
            var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
            surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            var actualPoint = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
            var expectedPoint = new GeometryPoint { X = 3, Z = 2 };
            Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
        }

        [Test]
        public void AdaptedSurfaceLineWithoutShoulderHasCorrectlyRemovedOldPointAtTopPolder()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 2.0;
            var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
            var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
            var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
            var pointAtToePolder = new GeometryPoint { X = 3, Z = 0 };
            surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            Assert.IsFalse(newSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(pointAtTopPolder)));
        }

        [Test]
        public void AdaptedSurfaceLineWithoutShoulderHasCorrectNewPointAtToePolder()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 2.0;
            var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
            var pointAtTopRiver = new GeometryPoint { X = 2, Z = 1 };
            var pointAtTopPolder = new GeometryPoint { X = 3, Z = 1 };
            var pointAtToePolder = new GeometryPoint { X = 7, Z = 0 };
            surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            var actualPoint = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
            var expectedPoint = new GeometryPoint { X = 13 };
            Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
            double oldSlope = surfaceLine.TanSlopeInside();
            double newSlope = newSurfaceLine.TanSlopeInside();
            Assert.AreEqual(oldSlope, newSlope, 0.001);
        }

        [Test]
        public void AdaptedSurfaceLineWithShoulderHasCorrectPointAtToePolder()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 2.0;
            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(2, 1, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(3, 0.5, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(4, 0.5, CharacteristicPointType.ShoulderTopInside);
            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            var expectedPoint = new GeometryPoint() { X = 7, Z = 0 };  // 
            var actualPoint = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
            Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
        }

        [Test]
        public void AdaptedSurfaceLineHasRemovedShoulderPointsCorrectly()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 3.0;
            var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
            var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
            var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
            var pointAtShoulderInsteek = new GeometryPoint { X = 3, Z = 0.5 };
            var pointAtShoulderTop = new GeometryPoint { X = 4, Z = 0.5 };
            var pointAtToePolder = new GeometryPoint { X = 5, Z = 0 };
            var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
            surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(pointAtShoulderInsteek.X, pointAtShoulderInsteek.Z, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(pointAtShoulderTop.X, pointAtShoulderTop.Z, CharacteristicPointType.ShoulderTopInside);
            surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            Assert.IsNull(newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside));
            Assert.IsNull(newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside));
            Assert.IsFalse(newSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(pointAtShoulderInsteek)));
            Assert.IsFalse(newSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(pointAtShoulderTop)));
            var newPointAtToePolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
            Assert.AreEqual(3, newSurfaceLine.GetPointSegmentIncluding(pointAtTopRiver.X, newPointAtToePolder.X).Count());
            Assert.AreEqual(5, newSurfaceLine.Geometry.Points.Count);
        }

        [Test]
        public void AdaptedSurfaceLineWithLargeShoulderHaveSameToeAtPolder()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 1.5;
            var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
            var pointAtTopRiver = new GeometryPoint { X = 1, Z = 1 };
            var pointAtTopPolder = new GeometryPoint { X = 2, Z = 1 };
            var pointAtShoulderInsteek = new GeometryPoint { X = 3, Z = 0.5 };
            var pointAtShoulderTop = new GeometryPoint { X = 5, Z = 0.5 };
            var pointAtToePolder = new GeometryPoint { X = 6, Z = 0 };
            var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
            surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(pointAtShoulderInsteek.X, pointAtShoulderInsteek.Z, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(pointAtShoulderTop.X, pointAtShoulderTop.Z, CharacteristicPointType.ShoulderTopInside);
            surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            Assert.IsTrue(pointAtToePolder.LocationEquals(newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder)));
        }

        [Test]
        public void AdaptedSurfaceLineWithLargeShoulderHaveSameTopAtShoulderInside()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 3.0;
            var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
            var pointAtTopRiver = new GeometryPoint { X = 1, Z = 2 };
            var pointAtTopPolder = new GeometryPoint { X = 2, Z = 2 };
            var pointAtShoulderInsteek = new GeometryPoint { X = 3, Z = 1 };
            var pointAtShoulderTop = new GeometryPoint { X = 5, Z = 1 };
            var pointAtToePolder = new GeometryPoint { X = 6, Z = 2 };
            var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
            surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(pointAtShoulderInsteek.X, pointAtShoulderInsteek.Z, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(pointAtShoulderTop.X, pointAtShoulderTop.Z, CharacteristicPointType.ShoulderTopInside);
            surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            Assert.IsTrue(pointAtShoulderTop.LocationEquals(newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside)));
        }

        [Test]
        public void AdaptedSurfaceLineWithLargeShoulderShouldHaveACorrectIntersectionPoint()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 3.0;
            var pointAtToeRiver = new GeometryPoint { X = 0, Z = 0 };
            var pointAtTopRiver = new GeometryPoint { X = 1, Z = 2 };
            var pointAtTopPolder = new GeometryPoint { X = 2, Z = 2 };
            var pointAtShoulderInsteek = new GeometryPoint { X = 3, Z = 1 };
            var pointAtShoulderTop = new GeometryPoint { X = 5, Z = 1 };
            var pointAtToePolder = new GeometryPoint { X = 6, Z = 0 };
            var pointAtSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };
            surfaceLine.EnsurePointOfType(pointAtToeRiver.X, pointAtToeRiver.Z, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(pointAtTopRiver.X, pointAtTopRiver.Z, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(pointAtTopPolder.X, pointAtTopPolder.Z, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(pointAtShoulderInsteek.X, pointAtShoulderInsteek.Z, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(pointAtShoulderTop.X, pointAtShoulderTop.Z, CharacteristicPointType.ShoulderTopInside);
            surfaceLine.EnsurePointOfType(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            var expectedPoint = new GeometryPoint { X = 4.5, Z = 1 };
            var actualPoint = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
            Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
        }

        [Test]
        public void AdaptedSurfaceLineWithSoulderAndDitchShouldNotCreateInvalidSurfaceLine()
        {
            var surfaceLine = FactoryForSurfaceLines.CreateRealisticSurfaceLineForHeightAdapter();
            var location = new Location();
            const double newDikeHeight = 19.2;
            var validationError = surfaceLine.Validate().FirstOrDefault(vr => vr.MessageType == ValidationResultType.Error);
            if (validationError != null)
            {
                throw new SurfaceLineException(validationError.Text);
            }
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            validationError = newSurfaceLine.Validate().FirstOrDefault(vr => vr.MessageType == ValidationResultType.Error);
            if (validationError != null)
            {
                throw new SurfaceLineException(validationError.Text);
            }
        }

        [Test]
        public void AdaptedSurfaceLineWithTrafficLoadPointsShouldAdjustThosePoints1()
        {
            var surfaceLine = FactoryForSurfaceLines.CreateRealisticSurfaceLineForHeightAdapter();
            var location = new Location();
            const double cTolerance = 0.0000001;
            const double newDikeHeight = 19.2;
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            Assert.AreEqual(newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadOutside).Z, cTolerance);
            Assert.AreEqual(newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadInside).Z, cTolerance);
        }

        [Test]
        public void AdaptedSurfaceLineWithTrafficLoadPointsShouldAdjustThosePoints2()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 1.2;
            var pointDikeToeAtRiver = new GeometryPoint { X = 0, Z = 0 };
            var pointDikeTopAtRiver = new GeometryPoint { X = 1, Z = 1 };
            var pointTrafficLoadOutside = new GeometryPoint { X = 1.1, Z = 1 };
            var pointTrafficLoadInside = new GeometryPoint { X = 1.9, Z = 1 };
            var pointDikeTopAtPolder = new GeometryPoint { X = 2, Z = 1 };
            var pointDikeToeAtPolder = new GeometryPoint { X = 3, Z = 0 };
            surfaceLine.EnsurePointOfType(pointDikeToeAtRiver.X, pointDikeToeAtRiver.Z, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(pointDikeTopAtRiver.X, pointDikeTopAtRiver.Z, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(pointTrafficLoadOutside.X, pointTrafficLoadOutside.Z, CharacteristicPointType.TrafficLoadOutside);
            surfaceLine.EnsurePointOfType(pointTrafficLoadInside.X, pointTrafficLoadInside.Z, CharacteristicPointType.TrafficLoadInside);
            surfaceLine.EnsurePointOfType(pointDikeTopAtPolder.X, pointDikeTopAtPolder.Z, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(pointDikeToeAtPolder.X, pointDikeToeAtPolder.Z, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            Assert.AreEqual(newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadOutside).Z);
            Assert.AreEqual(newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.TrafficLoadInside).Z);
        }

        /// <summary>
        /// Create dike with skewed dike table and points between characteristic points
        /// </summary>
        /// <returns></returns>
        private SurfaceLine2 CreateSurfaceLineWithSkwewedDikeTableAndInBetweenPoints()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints = { GeometryMustContainPoint = true },
                Geometry = new GeometryPointString()
            };
            var point1 = new GeometryPoint { X = 0, Z = 0 };
            var pointDikeToeAtRiver = new GeometryPoint { X = 2, Z = 0 };
            var point2 = new GeometryPoint { X = 4, Z = 1 };
            var pointDikeTopAtRiver = new GeometryPoint { X = 6, Z = 3 };
            var point3 = new GeometryPoint { X = 7, Z = 3 };
            var pointDikeTopAtPolder = new GeometryPoint { X = 8, Z = 3.5 };
            var point4 = new GeometryPoint { X = 10, Z = 1.5 };
            var pointDikeToeAtPolder = new GeometryPoint { X = 12, Z = 0.5 };
            var point5 = new GeometryPoint { X = 13, Z = 0 };
            var pointSurfaceLevelInside = new GeometryPoint { X = 100, Z = 0 };

            surfaceLine.EnsurePointOfType(pointDikeToeAtRiver.X, pointDikeToeAtRiver.Z, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(pointDikeTopAtRiver.X, pointDikeTopAtRiver.Z, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(pointDikeTopAtPolder.X, pointDikeTopAtPolder.Z, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(pointDikeToeAtPolder.X, pointDikeToeAtPolder.Z, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(pointSurfaceLevelInside.X, pointSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
            surfaceLine.EnsurePoint(point1.X, point1.Z);
            surfaceLine.EnsurePoint(point2.X, point2.Z);
            surfaceLine.EnsurePoint(point3.X, point3.Z);
            surfaceLine.EnsurePoint(point4.X, point4.Z);
            surfaceLine.EnsurePoint(point5.X, point5.Z);
            surfaceLine.SortPoints();
            return surfaceLine;
        }

        /// <summary>
        /// Test if dike with skewed dike table and points between characteristic points is constructed correctly with new height
        /// </summary>
        [Test]
        public void CanAdaptSurfaceLineWithSkewedDikeTableAndInBetweenPoints()
        {
            SurfaceLine2 surfaceLine = CreateSurfaceLineWithSkwewedDikeTableAndInBetweenPoints();
            var location = new Location();
            const double cTolerance = 0.001;
            const double newDikeHeight = 4.0;
            Assert.AreEqual(10, surfaceLine.Geometry.Points.Count);
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            Assert.AreEqual(6, newSurfaceLine.Geometry.Points.Count);
            Assert.AreEqual(7.3333, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver).X, cTolerance);
            Assert.AreEqual(4.0000, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver).Z, cTolerance);
            Assert.AreEqual(9.3333, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).X, cTolerance);
            Assert.AreEqual(4.0000, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z, cTolerance);
            Assert.AreEqual(14.6666, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).X, cTolerance);
            Assert.AreEqual(0.0000, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z, cTolerance);
            Assert.AreEqual(100.000, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).X, cTolerance);
            Assert.AreEqual(0.0000, newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).Z, cTolerance);
        }

        [Test]
        public void AdaptedSurfaceLineWithNewDefinedTopExactOnOldTop()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 2.0;
            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
            location.UseNewDikeTopWidth = true;
            location.NewDikeTopWidth = 1;
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            var expectedNewTopRiver = new GeometryPoint() { X = 2, Z = 2 };
            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
            var expectedNewTopPolder = new GeometryPoint() { X = 3, Z = 2 };
            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
            var expectedShoulderBaseInside = new GeometryPoint() { X = 5, Z = 0 };
            var actualShoulderBaseInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
            Assert.IsTrue(expectedShoulderBaseInside.LocationEquals(actualShoulderBaseInside));
            Assert.AreEqual(9, newSurfaceLine.Geometry.Points.Count);
        }

        [Test]
        public void AdaptedSurfaceLineWithNewDefinedTopSmallerThanOldTop()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 2.0;
            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(100, 0, CharacteristicPointType.SurfaceLevelInside);
            location.UseNewDikeTopWidth = true;
            location.NewDikeTopWidth = 0.8;
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            var expectedNewTopRiver = new GeometryPoint() { X = 2, Z = 2 };
            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
            var expectedNewTopPolder = new GeometryPoint() { X = 2.8, Z = 2 };
            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
            var expectedNewPoint = new GeometryPoint() { X = 3.8, Z = 1 };
            var actualNewPoint = newSurfaceLine.Geometry.Points[4];
            Assert.IsTrue(expectedNewPoint.LocationEquals(actualNewPoint));
            var expectedShoulderBaseInside = new GeometryPoint() { X = 5, Z = 0 };
            var actualShoulderBaseInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
            Assert.IsTrue(expectedShoulderBaseInside.LocationEquals(actualShoulderBaseInside));
            Assert.AreEqual(10, newSurfaceLine.Geometry.Points.Count);
        }

        [Test]
        public void AdaptedSurfaceLineWithNewDefinedTopWiderThanOldTopBeyondShoulder()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 2.0;
            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(100, -1, CharacteristicPointType.SurfaceLevelInside);
            location.UseNewDikeTopWidth = true;
            location.NewDikeTopWidth = 3;
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            var expectedNewTopRiver = new GeometryPoint() { X = 2, Z = 2 };
            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
            var expectedNewTopPolder = new GeometryPoint() { X = 5, Z = 2 };
            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
            var expectedToeInside = new GeometryPoint() { X = 8, Z = -1 };
            var actualToeInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
            Assert.IsTrue(expectedToeInside.LocationEquals(actualToeInside));
            Assert.AreEqual(5, newSurfaceLine.Geometry.Points.Count);
        }

        [Test]
        public void AdaptedSurfaceLineWithNewDefinedTopWiderThanOldTopOnShoulderTopInside()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 2.0;
            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(100, -1, CharacteristicPointType.SurfaceLevelInside);
            location.UseNewDikeTopWidth = true;
            location.NewDikeTopWidth = 2;
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            var expectedNewTopRiver = new GeometryPoint() { X = 2, Z = 2 };
            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
            var expectedNewTopPolder = new GeometryPoint() { X = 4, Z = 2 };
            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
            var expectedToeInside = new GeometryPoint() { X = 7, Z = -1 };
            var actualToeInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
            Assert.IsTrue(expectedToeInside.LocationEquals(actualToeInside));
            Assert.AreEqual(6, newSurfaceLine.Geometry.Points.Count);
        }

        [Test]
        public void AdaptedSurfaceLineWithNewDefinedTopWiderThanOldTopIntersectingShoulder()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 2.0;
            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(100, -1, CharacteristicPointType.SurfaceLevelInside);
            location.UseNewDikeTopWidth = true;
            location.NewDikeTopWidth = 1.5;
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            var expectedNewTopRiver = new GeometryPoint() { X = 2, Z = 2 };
            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
            var expectedNewTopPolder = new GeometryPoint() { X = 3.5, Z = 2 };
            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
            var expectedShoulderBaseInside = new GeometryPoint() { X = 5.5, Z = 0 };
            var actualShoulderBaseInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
            Assert.IsTrue(expectedShoulderBaseInside.LocationEquals(actualShoulderBaseInside));
            var expectedShoulderTopInside = new GeometryPoint() { X = 6, Z = 0 };
            var actualShoulderTopInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
            Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualShoulderTopInside));
            var expectedToeInside = new GeometryPoint() { X = 7, Z = -1 };
            var actualToeInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
            Assert.IsTrue(expectedToeInside.LocationEquals(actualToeInside));
            Assert.AreEqual(7, newSurfaceLine.Geometry.Points.Count);
        }

        [Test]
        public void AdaptedSurfaceLineWithNewDefinedInsideSlope()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 2.0;
            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(100, -1, CharacteristicPointType.SurfaceLevelInside);
            location.UseNewDikeSlopeInside = true;
            location.NewDikeSlopeInside = 0.5;
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            var expectedNewTopRiver = new GeometryPoint() { X = 2, Z = 2 };
            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
            var expectedNewTopPolder = new GeometryPoint() { X = 5, Z = 2 };
            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
            var expectedToeInside = new GeometryPoint() { X = 11, Z = -1 };
            var actualToeInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
            Assert.IsTrue(expectedToeInside.LocationEquals(actualToeInside));
            Assert.AreEqual(5, newSurfaceLine.Geometry.Points.Count);
        }

        [Test]
        public void AdaptedSurfaceLineWithNewDefinedInsideSlopeEndingOnOldShoulderTop()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 2.0;
            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(100, -1, CharacteristicPointType.SurfaceLevelInside);
            location.UseNewDikeSlopeInside = true;
            location.NewDikeSlopeInside = 2;
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            var expectedNewTopRiver = new GeometryPoint() { X = 2, Z = 2 };
            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
            var expectedNewTopPolder = new GeometryPoint() { X = 5, Z = 2 };
            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
            var expectedPoint = new GeometryPoint() { X = 6, Z = 0 };
            var actualPoint = newSurfaceLine.Geometry.Points[3];
            Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
            var expectedToeInside = new GeometryPoint() { X = 7, Z = -1 };
            var actualToeInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
            Assert.IsTrue(expectedToeInside.LocationEquals(actualToeInside));
            Assert.AreEqual(6, newSurfaceLine.Geometry.Points.Count);
        }

        [Test]
        public void AdaptedSurfaceLineWithNewDefinedOutsideSlope2()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 2.0;
            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(100, -1, CharacteristicPointType.SurfaceLevelInside);
            location.UseNewDikeSlopeOutside = true;
            location.NewDikeSlopeOutside = 2;
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            var expectedNewTopRiver = new GeometryPoint() { X = 1.5, Z = 2 };
            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
            var expectedNewTopPolder = new GeometryPoint() { X = 4.5, Z = 2 };
            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
            var expectedToeInside = new GeometryPoint() { X = 7.5, Z = -1 };
            var actualToeInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
            Assert.IsTrue(expectedToeInside.LocationEquals(actualToeInside));
            Assert.AreEqual(6, newSurfaceLine.Geometry.Points.Count);
        }

        [Test]
        public void AdaptedSurfaceLineWithNewDefinedOutsideSlope05()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 2.0;
            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(100, -1, CharacteristicPointType.SurfaceLevelInside);
            location.UseNewDikeSlopeOutside = true;
            location.NewDikeSlopeOutside = 0.5;
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            var expectedNewTopRiver = new GeometryPoint() { X = 3, Z = 2 };
            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
            var expectedNewTopPolder = new GeometryPoint() { X = 6, Z = 2 };
            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
            var expectedToeInside = new GeometryPoint() { X = 9, Z = -1 };
            var actualToeInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
            Assert.IsTrue(expectedToeInside.LocationEquals(actualToeInside));
            Assert.AreEqual(6, newSurfaceLine.Geometry.Points.Count);
        }

        [Test]
        public void AdaptedSurfaceLineWithNewDefinedTopWidthAndOutsideSlopeAndInsideSlope()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 2.0;
            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(100, -1, CharacteristicPointType.SurfaceLevelInside);
            location.UseNewDikeSlopeOutside = true;
            location.NewDikeSlopeOutside = 2;
            location.UseNewDikeSlopeInside = true;
            location.NewDikeSlopeInside = 2;
            location.UseNewDikeTopWidth = true;
            location.NewDikeTopWidth = 1.5;
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            var expectedNewTopRiver = new GeometryPoint() { X = 1.5, Z = 2 };
            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
            var expectedNewTopPolder = new GeometryPoint() { X = 3, Z = 2 };
            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
            var expectedPoint = new GeometryPoint() { X = 3.5, Z = 1 };
            var actualPoint = newSurfaceLine.Geometry.Points[4];
            Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
            var expectedPoint2 = new GeometryPoint() { X = 4, Z = 1 };
            var actualPoint2 = newSurfaceLine.Geometry.Points[5];
            Assert.IsTrue(expectedPoint2.LocationEquals(actualPoint2));
            var expectedShoulderBaseInside = new GeometryPoint() { X = 5, Z = 0 };
            var actualShoulderBaseInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
            Assert.IsTrue(expectedShoulderBaseInside.LocationEquals(actualShoulderBaseInside));
            var expectedToeInside = new GeometryPoint() { X = 7, Z = -1 };
            var actualToeInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
            Assert.IsTrue(expectedToeInside.LocationEquals(actualToeInside));
            Assert.AreEqual(10, newSurfaceLine.Geometry.Points.Count);
        }

        [Test]
        public void AdaptedSurfaceLineWithNewDefinedTopWidthAndOutsideSlopeAndInsideSlope05()
        {
            var surfaceLine = new SurfaceLine2
            {
                CharacteristicPoints =
                {
                    GeometryMustContainPoint = true
                },
                Geometry = new GeometryPointString()
            };
            var location = new Location();
            const double newDikeHeight = 2.0;
            surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine.EnsurePointOfType(1, 1, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine.EnsurePointOfType(4, 1, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.ShoulderBaseInside);
            surfaceLine.EnsurePointOfType(6, 0, CharacteristicPointType.ShoulderTopInside);
            surfaceLine.EnsurePointOfType(7, -1, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine.EnsurePointOfType(100, -1, CharacteristicPointType.SurfaceLevelInside);
            location.UseNewDikeSlopeOutside = true;
            location.NewDikeSlopeOutside = 2;
            location.UseNewDikeSlopeInside = true;
            location.NewDikeSlopeInside = 0.5;
            location.UseNewDikeTopWidth = true;
            location.NewDikeTopWidth = 1.5;
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            var expectedNewTopRiver = new GeometryPoint() { X = 1.5, Z = 2 };
            var actualNewTopRiver = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtRiver);
            Assert.IsTrue(expectedNewTopRiver.LocationEquals(actualNewTopRiver));
            var expectedNewTopPolder = new GeometryPoint() { X = 3, Z = 2 };
            var actualNewTopPolder = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder);
            Assert.IsTrue(expectedNewTopPolder.LocationEquals(actualNewTopPolder));
            var expectedToeInside = new GeometryPoint() { X = 9, Z = -1 };
            var actualToeInside = newSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
            Assert.IsTrue(expectedToeInside.LocationEquals(actualToeInside));
            Assert.AreEqual(6, newSurfaceLine.Geometry.Points.Count);
        }

        [Test]
        [ExpectedException(typeof(SurfaceLineAdapterException))]
        public void HeightAdaptionThrowsExceptionIfSurfaceLIsNotLongEnough()
        {
            var surfaceLine = FactoryForSurfaceLines.CreateRealisticSurfaceLineForHeightAdapter();
            var location = new Location();
            const double newDikeHeight = 19.0;
            var pointSurfaceLevelInside = new GeometryPoint { X = 40, Z = 12 }; // Set surfacelevelinside just beside ditch to force exception
            surfaceLine.EnsurePointOfType(pointSurfaceLevelInside.X, pointSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
            var surfaceLineAdapter = new SurfaceLineHeightAdapter(surfaceLine, location);
            var newSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(newDikeHeight);
            Assert.Null(newSurfaceLine);
        }
    }
}