// Copyright (C) Stichting Deltares 2024. 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;
using System.Collections.Generic;
using System.Linq;
using Deltares.DamEngine.Calculators.DikesDesign;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.Geometry;
using Deltares.DamEngine.Data.Geotechnics;
using NUnit.Framework;

namespace Deltares.DamEngine.Calculators.Tests.DikesDesign;

[TestFixture]
public class SurfaceLineShoulderAdapterTest
{
    const double pointCoordinateTolerance = 0.001;

    [Test]
    public void ThrowsAnExceptionWhenNoSurfaceLevelPointExist()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        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);
        Assert.That(() => new SurfaceLineShoulderAdapter(surfaceLine, location, 0), Throws.InstanceOf<SurfaceLineAdapterException>());
    }

    /// <summary>
    /// Test if ConstructNewSurfaceLine returns a new surface line.
    /// </summary>
    [Test]
    public void ConstructNewSurfaceLineReturnsANewSurfaceLine()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        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
        };
        var pointAtSurfaceLevelInside = new GeometryPoint
        {
            X = 10,
            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(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        SurfaceLine2 constructNewSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(0, 0, false);
        Assert.IsNotNull(constructNewSurfaceLine);
    }

    /// <summary>
    /// Test if adapt the surface line without shoulder returns surfaceline with both characteristic points at shoulder inside.
    /// </summary>
    [Test]
    public void AdaptedSurfaceLineWithoutShoulderMustHaveBothCharacteristicPointsAtShoulderInside()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        var pointAtToeRiver = new GeometryPoint
        {
            X = 0,
            Z = 0
        };
        var pointAtTopRiver = new GeometryPoint
        {
            X = 2,
            Z = 2
        };
        var pointAtTopPolder = new GeometryPoint
        {
            X = 3,
            Z = 2
        };
        var pointAtToePolder = new GeometryPoint
        {
            X = 4,
            Z = 0
        };
        var pointAtSurfaceLevelInside = new GeometryPoint
        {
            X = 10,
            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(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        Assert.IsNull(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside));
        Assert.IsNull(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside));
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        Assert.IsNotNull(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside));
        Assert.IsNotNull(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside));
    }

    /// <summary>
    /// Test if adapted surface line without shoulder has correct point at top shoulder inside.
    /// </summary>
    [Test]
    public void AdaptedSurfaceLineWithoutShoulderHasCorrectPointAtTopShoulderInside()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        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
        };
        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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        surfaceLineAdapter.MaxShoulderLevel = 0.67;
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        double expectedShoulderHeight = Math.Min(shoulderHeight, surfaceLineAdapter.MaxShoulderLevel - pointAtToePolder.Z);
        var expectedPoint = new GeometryPoint(3.33, expectedShoulderHeight);
        GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
        Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
    }

    /// <summary>
    /// Test if adapted surface line without shoulder has correct intersection point at dike.
    /// </summary>
    [Test]
    public void AdaptedSurfaceLineWithoutShoulderHasCorrectIntersectionPointAtDike()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        var pointAtToeRiver = new GeometryPoint
        {
            X = 0,
            Z = 0
        };
        var pointAtTopRiver = new GeometryPoint
        {
            X = 2,
            Z = 2
        };
        var pointAtTopPolder = new GeometryPoint
        {
            X = 3,
            Z = 2
        };
        var pointAtToePolder = new GeometryPoint
        {
            X = 4,
            Z = 0
        };
        var pointAtSurfaceLevelInside = new GeometryPoint
        {
            X = 10,
            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(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        var expectedPoint = new GeometryPoint(3.5, 1);
        GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
        Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
    }

    /// <summary>
    /// Test if adapted surface line without shoulder has correct intersection point at ground level.
    /// </summary>
    [Test]
    public void AdaptedSurfaceLineWithoutShoulderHasCorrectIntersectionPointAtGroundLevel()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        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
        };
        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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        double expectedShoulderHeight = Math.Min(shoulderHeight, (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z));
        var expectedPoint = new GeometryPoint(
            pointAtTopPolder.X + (1 - expectedShoulderHeight) + shoulderLength + expectedShoulderHeight * surfaceLineAdapter.SlopeOfNewShoulder, 0);
        GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
        Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
    }

    /// <summary>
    /// Test if adapted surface line without shoulder that the new shoulder should is not higher then top of dike.
    /// </summary>
    [Test]
    public void AdaptedSurfaceLineWithoutShoulderNewShoulderShouldNotBeHeigherThenTopOfDike()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 1;
        const int shoulderHeight = 3;
        var pointAtToeRiver = new GeometryPoint
        {
            X = 0,
            Z = 0
        };
        var pointAtTopRiver = new GeometryPoint
        {
            X = 2,
            Z = 2
        };
        var pointAtTopPolder = new GeometryPoint
        {
            X = 3,
            Z = 2
        };
        var pointAtToePolder = new GeometryPoint
        {
            X = 4,
            Z = 0
        };
        var pointAtSurfaceLevelInside = new GeometryPoint
        {
            X = 10,
            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(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        double expectedZ = pointAtTopPolder.Z;
        double actualZ = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside).Z;
        Assert.AreEqual(expectedZ, actualZ);
    }

    [Test]
    public void AdaptedSurfaceLineWithoutShoulderNewShoulderLengthShouldExpand()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 3;
        const int shoulderHeight = 3;
        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
        };
        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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0)
        {
            SlopeOfNewShoulder = 2
        };
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        double expectedShoulderHeight = Math.Min(shoulderHeight, (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z));
        double expectedShoulderBaseX = pointAtTopPolder.X + (1 - expectedShoulderHeight);
        Assert.AreEqual(expectedShoulderBaseX, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside).X);
        Assert.AreEqual(expectedShoulderHeight, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside).Z);
        Assert.AreEqual(expectedShoulderBaseX + shoulderLength, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside).X);
        Assert.AreEqual(expectedShoulderHeight, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside).Z);
        Assert.AreEqual(expectedShoulderBaseX + shoulderLength + surfaceLineAdapter.SlopeOfNewShoulder * expectedShoulderHeight, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).X);
        Assert.AreEqual(0, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z);
    }

    [Test]
    public void AdaptedSurfaceLineWithShoulderHasCorrectPointAtTopShoulderInside()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        surfaceLine.EnsurePointOfType(-100, 0, CharacteristicPointType.SurfaceLevelOutside);
        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 SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        surfaceLineAdapter.MaxShoulderLevel = 0.67;
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        var expectedPoint = new GeometryPoint(3.66, 0.67);
        GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
        Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
    }

    [Test]
    public void AdaptedSurfaceLineWithShoulderHasCorrectShoulderPoints()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 2;
        const int shoulderHeight = 1;
        surfaceLine.EnsurePointOfType(-100, 0, CharacteristicPointType.SurfaceLevelOutside);
        surfaceLine.EnsurePointOfType(0, 1, CharacteristicPointType.DikeToeAtRiver);
        surfaceLine.EnsurePointOfType(1, 2, CharacteristicPointType.DikeTopAtRiver);
        surfaceLine.EnsurePointOfType(2, 2, CharacteristicPointType.DikeTopAtPolder);
        surfaceLine.EnsurePointOfType(3, 1.5, CharacteristicPointType.ShoulderBaseInside);
        surfaceLine.EnsurePointOfType(4, 1.5, CharacteristicPointType.ShoulderTopInside);
        surfaceLine.EnsurePointOfType(5, 1, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(100, 1, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0)
        {
            SlopeOfNewShoulder = 2
        };
        surfaceLineAdapter.MaxShoulderLevel = 0.67 + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z;
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        var expectedPoint = new GeometryPoint(6.00, 1);
        GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
        Assert.AreEqual(expectedPoint.X, actualPoint.X, pointCoordinateTolerance);
        Assert.AreEqual(expectedPoint.Z, actualPoint.Z, pointCoordinateTolerance);
        expectedPoint = new GeometryPoint(4.66, 1.67);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
        Assert.AreEqual(expectedPoint.X, actualPoint.X, pointCoordinateTolerance);
        Assert.AreEqual(expectedPoint.Z, actualPoint.Z, pointCoordinateTolerance);
        expectedPoint = new GeometryPoint(2.66, 1.67);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
        Assert.AreEqual(expectedPoint.X, actualPoint.X, pointCoordinateTolerance);
        Assert.AreEqual(expectedPoint.Z, actualPoint.Z, pointCoordinateTolerance);
    }

    [Test]
    public void AdaptedSurfaceLineWithShoulderHasCorrectPointAtInsteekShoulderInside()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        surfaceLine.EnsurePointOfType(-1, 0, CharacteristicPointType.SurfaceLevelOutside);
        surfaceLine.EnsurePointOfType(0, 0, CharacteristicPointType.DikeToeAtRiver);
        surfaceLine.EnsurePointOfType(1, 4, CharacteristicPointType.DikeTopAtRiver);
        surfaceLine.EnsurePointOfType(2, 4, CharacteristicPointType.DikeTopAtPolder);
        surfaceLine.EnsurePointOfType(3, 0.5, CharacteristicPointType.ShoulderBaseInside);
        surfaceLine.EnsurePointOfType(4, 0.5, CharacteristicPointType.ShoulderTopInside);
        surfaceLine.EnsurePointOfType(5, 0, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(10, 0, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        var expectedPoint = new GeometryPoint(2.857, 1.0);
        GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
        Assert.AreEqual(expectedPoint.X, actualPoint.X, pointCoordinateTolerance);
        Assert.AreEqual(expectedPoint.Z, actualPoint.Z, pointCoordinateTolerance);
    }

    [Test]
    public void AdaptedSurfaceLineHasCorrectTail()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        var pointAtToeRiver = new GeometryPoint
        {
            X = 0,
            Z = 0
        };
        var pointAtTopRiver = new GeometryPoint
        {
            X = 1,
            Z = 4
        };
        var pointAtTopPolder = new GeometryPoint
        {
            X = 2,
            Z = 4
        };
        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 extraPoint1 = new GeometryPoint
        {
            X = 8,
            Z = -2
        };
        var extraPoint2 = new GeometryPoint
        {
            X = 9,
            Z = -1
        };
        var pointAtSurfaceLevelInside = new GeometryPoint
        {
            X = 10,
            Z = 0
        };
        var pointAtSurfaceLevelOutside = new GeometryPoint
        {
            X = -1,
            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.EnsurePoint(extraPoint1.X, extraPoint1.Z);
        surfaceLine.EnsurePoint(extraPoint2.X, extraPoint2.Z);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelOutside.X, pointAtSurfaceLevelOutside.Z, CharacteristicPointType.SurfaceLevelOutside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0)
        {
            SlopeOfNewShoulder = 2
        };
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        double xToePolder = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).X;
        double xSurfaceLevelInside = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).X;
        IEnumerable<GeometryPoint> actualExtraPoints = adaptedSurfaceLine.GetPointSegmentIncluding(xToePolder, xSurfaceLevelInside);
        const int expectedNumberOfPoints = 9;
        Assert.AreEqual(expectedNumberOfPoints, adaptedSurfaceLine.Geometry.Points.Count);
        const int expectedNumberOfExtraPoints = 3;
        Assert.AreEqual(expectedNumberOfExtraPoints, actualExtraPoints.Count());
        GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside);
        double actualXValue = pointAtSurfaceLevelInside.X;
        Assert.AreEqual(actualXValue, actualPoint.X, pointCoordinateTolerance);
        Assert.AreEqual(pointAtSurfaceLevelInside.Z, actualPoint.Z, pointCoordinateTolerance);
        Assert.IsTrue(adaptedSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(extraPoint2)));
        Assert.IsFalse(adaptedSurfaceLine.Geometry.Points.Any(p => p.LocationEquals(extraPoint1)));
    }

    [Test]
    public void AdaptedSurfaceLineWithoutShoulderWithSkewedSurfaceLevelInsideHasCorrectPointsInside()
    {
        SurfaceLine2 surfaceLine = CreateSurfaceLineWithSkewedSurfaceLevelInside();
        var location = new Location();
        const int shoulderLength = 2;
        const int shoulderHeight = 1;
        Assert.IsNull(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside));
        Assert.IsNull(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside));
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(surfaceLine, adaptedSurfaceLine, shoulderHeight, shoulderLength);
    }

    [Test]
    public void AdaptedSurfaceLineWithoutShoulderWithSkewedSurfaceLevelInsideAndInbetweenPointInSlopeHasCorrectPointsInside()
    {
        SurfaceLine2 surfaceLine = CreateSurfaceLineWithSkewedSurfaceLevelInside();
        var location = new Location();
        const int shoulderLength = 2;
        const int shoulderHeight = 1;
        surfaceLine.EnsurePoint(8, 1.9);
        surfaceLine.SortPoints();
        Assert.IsNull(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside));
        Assert.IsNull(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside));
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        Assert.AreEqual(7, surfaceLine.Geometry.Points.Count);
        Assert.AreEqual(8, adaptedSurfaceLine.Geometry.Points.Count);
        EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(surfaceLine, adaptedSurfaceLine, shoulderHeight, shoulderLength);
    }

    [Test]
    public void AdaptedSurfaceLineWithShoulderWithSkewedSurfaceLevelInsideHasCorrectPointsInside()
    {
        SurfaceLine2 surfaceLine = CreateSurfaceLineWithShoulderAndSkewedSurfaceLevelInside();
        var location = new Location();
        const int shoulderLength = 2;
        const int shoulderHeight = 1;
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(surfaceLine, adaptedSurfaceLine, shoulderHeight, shoulderLength);
    }

    [Test]
    public void AdaptedSurfaceLineWithShoulderWithSkewedSurfaceLevelInsideAndInbetweenPointsHasCorrectPointsInside()
    {
        SurfaceLine2 surfaceLine = CreateSurfaceLineWithShoulderAndSkewedSurfaceLevelInside();
        var location = new Location();
        const int shoulderLength = 2;
        const int shoulderHeight = 1;
        surfaceLine.EnsurePoint(8, 1.9);
        surfaceLine.EnsurePoint(10, 1);
        surfaceLine.EnsurePoint(12, 0.5);
        surfaceLine.EnsurePoint(14, -0.5);
        surfaceLine.SortPoints();
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0)
        {
            SlopeOfNewShoulder = 2
        };
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        Assert.AreEqual(12, surfaceLine.Geometry.Points.Count);
        Assert.AreEqual(9, adaptedSurfaceLine.Geometry.Points.Count);
        EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(surfaceLine, adaptedSurfaceLine, shoulderHeight, shoulderLength);
    }

    [Test]
    public void AdaptedSurfaceLineWithTrafficLoadPointsShouldAdjustThosePoints()
    {
        SurfaceLine2 surfaceLine = CreateSurfaceLineWithShoulderAndSkewedSurfaceLevelInside();
        var location = new Location();
        const double cTolerance = 0.0000001;
        var pointTrafficLoadOutside = new GeometryPoint
        {
            X = 9.5,
            Z = 0.975
        };
        var pointTrafficLoadInside = new GeometryPoint
        {
            X = 10.5,
            Z = 0.925
        };
        surfaceLine.EnsurePointOfType(pointTrafficLoadOutside.X, pointTrafficLoadOutside.Z, CharacteristicPointType.TrafficLoadOutside);
        surfaceLine.EnsurePointOfType(pointTrafficLoadInside.X, pointTrafficLoadInside.Z, CharacteristicPointType.TrafficLoadInside);
        const int shoulderLength = 2;
        const int shoulderHeight = 1;
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        var expectedPointTrafficLoadOutside = new GeometryPoint
        {
            X = 9.5,
            Z = 1.0
        };
        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);
    }

    [Test]
    public void AdaptedSurfaceLineWithoutShoulderHasCorrectIntersectionPointAtDikeAndDitch()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        var pointAtToeRiver = new GeometryPoint
        {
            X = 0,
            Z = 0
        };
        var pointAtTopRiver = new GeometryPoint
        {
            X = 2,
            Z = 2
        };
        var pointAtTopPolder = new GeometryPoint
        {
            X = 3,
            Z = 2
        };
        var pointAtToePolder = new GeometryPoint
        {
            X = 4,
            Z = 0
        };
        var ditchTopAtDikeSide = new GeometryPoint
        {
            X = 5,
            Z = 0
        };
        var ditchBottomAtDikeSide = new GeometryPoint
        {
            X = 6,
            Z = -2
        };
        var ditchBottomAtPolderSide = new GeometryPoint
        {
            X = 7,
            Z = -2
        };
        var ditchTopAtPolderSide = new GeometryPoint
        {
            X = 8,
            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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
        surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0)
        {
            SlopeOfNewShoulder = 2
        };
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        var expectedPoint = new GeometryPoint(3.5, 1);
        GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
        Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
        var expectedShoulderTopInside = new GeometryPoint(4.5, 1);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
        Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint));
        var expectedDikeToePolder = new GeometryPoint(6.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
        Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint));
        var expectedDitchDikeSide = new GeometryPoint(11.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide);
        Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint));
        var expectedBottomDitchDikeSide = new GeometryPoint(12.5, -2);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide);
        Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint));
        var expectedBottomDitchPolderSide = new GeometryPoint(13.5, -2);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide);
        Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint));
        var expectedDitchPolderSide = new GeometryPoint(14.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide);
        Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint));
        Assert.AreEqual(9, surfaceLine.Geometry.Points.Count);
        Assert.AreEqual(12, adaptedSurfaceLine.Geometry.Points.Count);
    }

    [Test]
    public void AdaptedSurfaceLineWithoutShoulderHasDitchBottomMadeHorizontal()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        var pointAtToeRiver = new GeometryPoint
        {
            X = 0,
            Z = 0
        };
        var pointAtTopRiver = new GeometryPoint
        {
            X = 2,
            Z = 2
        };
        var pointAtTopPolder = new GeometryPoint
        {
            X = 3,
            Z = 2
        };
        var pointAtToePolder = new GeometryPoint
        {
            X = 4,
            Z = 0
        };
        var ditchTopAtDikeSide = new GeometryPoint
        {
            X = 5,
            Z = 0
        };
        var ditchBottomAtDikeSide = new GeometryPoint
        {
            X = 6,
            Z = -2
        };
        var ditchBottomAtPolderSide = new GeometryPoint
        {
            X = 7,
            Z = -3
        };
        var ditchTopAtPolderSide = new GeometryPoint
        {
            X = 8,
            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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
        surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0)
        {
            SlopeOfNewShoulder = 2
        };
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        var expectedPoint = new GeometryPoint(3.5, 1);
        GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
        Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
        var expectedShoulderTopInside = new GeometryPoint(4.5, 1);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
        Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint));
        var expectedDikeToePolder = new GeometryPoint(6.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
        Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint));
        var expectedDitchDikeSide = new GeometryPoint(11.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide);
        Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint));
        var expectedBottomDitchDikeSide = new GeometryPoint(12.5, -2);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide);
        Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint));
        var expectedBottomDitchPolderSide = new GeometryPoint(13.5, -2);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide);
        Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint));
        var expectedDitchPolderSide = new GeometryPoint(14.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide);
        Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint));
        Assert.AreEqual(9, surfaceLine.Geometry.Points.Count);
        Assert.AreEqual(12, adaptedSurfaceLine.Geometry.Points.Count);
    }

    [Test]
    public void AdaptedSurfaceLineWithoutShoulderHasNoInBetweenPointAfterAdaption()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        var pointAtToeRiver = new GeometryPoint
        {
            X = 0,
            Z = 0
        };
        var pointAtTopRiver = new GeometryPoint
        {
            X = 2,
            Z = 2
        };
        var pointAtTopPolder = new GeometryPoint
        {
            X = 3,
            Z = 2
        };
        var pointAtToePolder = new GeometryPoint
        {
            X = 4,
            Z = 0
        };
        var ditchTopAtDikeSide = new GeometryPoint
        {
            X = 5,
            Z = 0
        };
        var ditchBottomAtDikeSide = new GeometryPoint
        {
            X = 6,
            Z = -2
        };
        var ditchBottomAtPolderSide = new GeometryPoint
        {
            X = 7,
            Z = -2
        };
        var ditchTopAtPolderSide = new GeometryPoint
        {
            X = 12,
            Z = 0
        };
        var inBetweenPointAtSurfaceLevelInside = new GeometryPoint
        {
            X = 10,
            Z = 0
        };
        var pointAtSurfaceLevelInside = new GeometryPoint
        {
            X = 100,
            Z = -90
        };
        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(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
        surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
        surfaceLine.EnsurePoint(inBetweenPointAtSurfaceLevelInside.X, inBetweenPointAtSurfaceLevelInside.Z);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0)
        {
            SlopeOfNewShoulder = 2
        };
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        var expectedPoint = new GeometryPoint(3.5, 1);
        GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
        Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
        var expectedShoulderTopInside = new GeometryPoint(4.5, 1);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
        Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint));
        var expectedDikeToePolder = new GeometryPoint(6.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
        Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint));
        Assert.AreEqual(10, surfaceLine.Geometry.Points.Count);
        Assert.AreEqual(11, adaptedSurfaceLine.Geometry.Points.Count);
    }

    [Test]
    public void AdaptedSurfaceLineWithoutShoulderHasCorrectIntersectionPointAtDikeAndDitchWithPointsAtNewDitchLocation()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        var pointAtToeRiver = new GeometryPoint
        {
            X = 0,
            Z = 0
        };
        var pointAtTopRiver = new GeometryPoint
        {
            X = 2,
            Z = 2
        };
        var pointAtTopPolder = new GeometryPoint
        {
            X = 3,
            Z = 2
        };
        var pointAtToePolder = new GeometryPoint
        {
            X = 4,
            Z = 0
        };
        var ditchTopAtDikeSide = new GeometryPoint
        {
            X = 5,
            Z = 0
        };
        var ditchBottomAtDikeSide = new GeometryPoint
        {
            X = 6,
            Z = -2
        };
        var ditchBottomAtPolderSide = new GeometryPoint
        {
            X = 7,
            Z = -2
        };
        var ditchTopAtPolderSide = new GeometryPoint
        {
            X = 12,
            Z = 0
        };
        var apoint = new GeometryPoint
        {
            X = 12.5,
            Z = 0
        };
        var apoint2 = new GeometryPoint
        {
            X = 13,
            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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
        surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
        surfaceLine.EnsurePointOfType(apoint.X, apoint.Z, null);
        surfaceLine.EnsurePointOfType(apoint2.X, apoint2.Z, null);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0)
        {
            SlopeOfNewShoulder = 2
        };
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        var expectedPoint = new GeometryPoint(3.5, 1);
        GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
        Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
        var expectedShoulderTopInside = new GeometryPoint(4.5, 1);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
        Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint));
        var expectedDikeToePolder = new GeometryPoint(6.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
        Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint));
        var expectedDitchDikeSide = new GeometryPoint(11.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide);
        Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint));
        var expectedBottomDitchDikeSide = new GeometryPoint(12.5, -2);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide);
        Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint));
        var expectedBottomDitchPolderSide = new GeometryPoint(13.5, -2);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide);
        Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint));
        var expectedDitchPolderSide = new GeometryPoint(18.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide);
        Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint));
        Assert.AreEqual(11, surfaceLine.Geometry.Points.Count);
        Assert.AreEqual(11, adaptedSurfaceLine.Geometry.Points.Count);
    }

    [Test]
    public void AdaptedSurfaceLineWithoutShoulderHasCorrectIntersectionPointAtDikeAndDitchWithPointsAtAndBeyondNewDitchLocation()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        var pointAtToeRiver = new GeometryPoint
        {
            X = 0,
            Z = 0
        };
        var pointAtTopRiver = new GeometryPoint
        {
            X = 2,
            Z = 2
        };
        var pointAtTopPolder = new GeometryPoint
        {
            X = 3,
            Z = 2
        };
        var pointAtToePolder = new GeometryPoint
        {
            X = 4,
            Z = 0
        };
        var ditchTopAtDikeSide = new GeometryPoint
        {
            X = 5,
            Z = 0
        };
        var ditchBottomAtDikeSide = new GeometryPoint
        {
            X = 6,
            Z = -2
        };
        var ditchBottomAtPolderSide = new GeometryPoint
        {
            X = 7,
            Z = -2
        };
        var ditchTopAtPolderSide = new GeometryPoint
        {
            X = 8,
            Z = 0
        };
        var apoint = new GeometryPoint
        {
            X = 12,
            Z = 0
        };
        var apoint2 = new GeometryPoint
        {
            X = 13,
            Z = 0
        };
        var apoint3 = new GeometryPoint
        {
            X = 20,
            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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
        surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
        surfaceLine.EnsurePointOfType(apoint.X, apoint.Z, null);
        surfaceLine.EnsurePointOfType(apoint2.X, apoint2.Z, null);
        surfaceLine.EnsurePointOfType(apoint3.X, apoint3.Z, null);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        Assert.AreEqual(12, surfaceLine.Geometry.Points.Count);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0)
        {
            SlopeOfNewShoulder = 2
        };
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        var expectedPoint = new GeometryPoint(3.5, 1);
        GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
        Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
        var expectedShoulderTopInside = new GeometryPoint(4.5, 1);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
        Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint));
        var expectedDikeToePolder = new GeometryPoint(6.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
        Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint));
        var expectedDitchDikeSide = new GeometryPoint(11.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide);
        Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint));
        var expectedBottomDitchDikeSide = new GeometryPoint(12.5, -2);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide);
        Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint));
        var expectedBottomDitchPolderSide = new GeometryPoint(13.5, -2);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide);
        Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint));
        var expectedDitchPolderSide = new GeometryPoint(14.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide);
        Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint));
        var expectedExtraPointBeyondDitchUnchanged = new GeometryPoint(20, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints[adaptedSurfaceLine.CharacteristicPoints.Count - 2];
        Assert.IsTrue(expectedExtraPointBeyondDitchUnchanged.LocationEquals(actualPoint));
        Assert.AreEqual(12, surfaceLine.Geometry.Count);
        Assert.AreEqual(13, adaptedSurfaceLine.Geometry.Count);
    }

    /// <summary>
    /// Test whether adapted the surface line without shoulder has correct intersection point at dike and ditch with points at and beyond new ditch location2.
    /// </summary>
    [Test]
    public void AdaptedSurfaceLineWithoutShoulderHasCorrectIntersectionPointAtDikeAndDitchWithPointsAtAndBeyondNewDitchLocation2()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        var pointAtToeRiver = new GeometryPoint
        {
            X = 0,
            Z = 0
        };
        var pointAtTopRiver = new GeometryPoint
        {
            X = 2,
            Z = 2
        };
        var pointAtTopPolder = new GeometryPoint
        {
            X = 3,
            Z = 2
        };
        var pointAtToePolder = new GeometryPoint
        {
            X = 4,
            Z = 0
        };
        var ditchTopAtDikeSide = new GeometryPoint
        {
            X = 5,
            Z = 0
        };
        var ditchBottomAtDikeSide = new GeometryPoint
        {
            X = 6,
            Z = -2
        };
        var ditchBottomAtPolderSide = new GeometryPoint
        {
            X = 7,
            Z = -2
        };
        var ditchTopAtPolderSide = new GeometryPoint
        {
            X = 8,
            Z = 0
        };
        var apoint = new GeometryPoint
        {
            X = 12,
            Z = 0
        };
        var apoint2 = new GeometryPoint
        {
            X = 19,
            Z = 0
        };
        var apoint3 = new GeometryPoint
        {
            X = 20,
            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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
        surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
        surfaceLine.EnsurePointOfType(apoint.X, apoint.Z, null);
        surfaceLine.EnsurePointOfType(apoint2.X, apoint2.Z, null);
        surfaceLine.EnsurePointOfType(apoint3.X, apoint3.Z, null);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        Assert.AreEqual(12, surfaceLine.Geometry.Count);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0)
        {
            SlopeOfNewShoulder = 2
        };
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        var expectedPoint = new GeometryPoint(3.5, 1);
        GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
        Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
        var expectedShoulderTopInside = new GeometryPoint(4.5, 1);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
        Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint));
        var expectedDikeToePolder = new GeometryPoint(6.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
        Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint));
        var expectedDitchDikeSide = new GeometryPoint(11.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide);
        Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint));
        var expectedBottomDitchDikeSide = new GeometryPoint(12.5, -2);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide);
        Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint));
        var expectedBottomDitchPolderSide = new GeometryPoint(13.5, -2);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide);
        Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint));
        var expectedDitchPolderSide = new GeometryPoint(14.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide);
        Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint));
        var expectedExtraPointBeyondDitchUnchanged1 = new GeometryPoint(19, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints[adaptedSurfaceLine.CharacteristicPoints.Count - 3];
        Assert.IsTrue(expectedExtraPointBeyondDitchUnchanged1.LocationEquals(actualPoint));
        var expectedExtraPointBeyondDitchUnchanged2 = new GeometryPoint(20, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints[adaptedSurfaceLine.CharacteristicPoints.Count - 2];
        Assert.IsTrue(expectedExtraPointBeyondDitchUnchanged2.LocationEquals(actualPoint));
        Assert.AreEqual(12, surfaceLine.Geometry.Count);
        Assert.AreEqual(14, adaptedSurfaceLine.Geometry.Count);
    }

    [Test]
    public void ThrowsAnExceptionWhenNewShoulderDoesNotFit()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 100;
        const int shoulderHeight = 1;
        var pointAtToeRiver = new GeometryPoint
        {
            X = 0,
            Z = 0
        };
        var pointAtTopRiver = new GeometryPoint
        {
            X = 2,
            Z = 2
        };
        var pointAtTopPolder = new GeometryPoint
        {
            X = 3,
            Z = 2
        };
        var pointAtToePolder = new GeometryPoint
        {
            X = 4,
            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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf<SurfaceLineAdapterException>());
    }

    [Test]
    public void ThrowsAnExceptionWhenNewShoulderDoesJustNotFit()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const double shoulderLength = 94.51;
        const int shoulderHeight = 1;
        var pointAtToeRiver = new GeometryPoint
        {
            X = 0,
            Z = 0
        };
        var pointAtTopRiver = new GeometryPoint
        {
            X = 2,
            Z = 2
        };
        var pointAtTopPolder = new GeometryPoint
        {
            X = 3,
            Z = 2
        };
        var pointAtToePolder = new GeometryPoint
        {
            X = 4,
            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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z,
                                      CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf<SurfaceLineAdapterException>());
    }

    [Test]
    public void ThrowsAnExceptionWhenNewShoulderDoesJustNotFitWithDitch()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const double shoulderLength = 90.51;
        const int shoulderHeight = 1;
        var pointAtToeRiver = new GeometryPoint
        {
            X = 0,
            Z = 0
        };
        var pointAtTopRiver = new GeometryPoint
        {
            X = 2,
            Z = 2
        };
        var pointAtTopPolder = new GeometryPoint
        {
            X = 3,
            Z = 2
        };
        var pointAtToePolder = new GeometryPoint
        {
            X = 4,
            Z = 0
        };
        var ditchTopAtDikeSide = new GeometryPoint
        {
            X = 5,
            Z = 0
        };
        var ditchBottomAtDikeSide = new GeometryPoint
        {
            X = 6,
            Z = -2
        };
        var ditchBottomAtPolderSide = new GeometryPoint
        {
            X = 7,
            Z = -2
        };
        var ditchTopAtPolderSide = new GeometryPoint
        {
            X = 8,
            Z = 0
        };
        var apoint = new GeometryPoint
        {
            X = 9,
            Z = 0
        };
        var apoint2 = new GeometryPoint
        {
            X = 19,
            Z = 0
        };
        var apoint3 = new GeometryPoint
        {
            X = 20,
            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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
        surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
        surfaceLine.EnsurePointOfType(apoint.X, apoint.Z, null);
        surfaceLine.EnsurePointOfType(apoint2.X, apoint2.Z, null);
        surfaceLine.EnsurePointOfType(apoint3.X, apoint3.Z, null);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf<SurfaceLineAdapterException>());
    }

    [Test]
    public void AdaptedSurfaceLineWithoutShoulderHasCorrectPointAtTopShoulderInsideWithLimitedMaxHeight05()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        location.UseNewMaxHeightShoulderAsFraction = true;
        location.NewMaxHeightShoulderAsFraction = 0.5;
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        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
        };
        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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        surfaceLineAdapter.MaxShoulderLevel = location.NewMaxHeightShoulderAsFraction *
                                              (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) +
                                              surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z;
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        double expectedShoulderHeight = Math.Min(shoulderHeight, surfaceLineAdapter.MaxShoulderLevel + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z);
        var expectedPoint = new GeometryPoint(3.5, expectedShoulderHeight);
        GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
        Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
    }

    [Test]
    public void AdaptedSurfaceLineWithoutShoulderHasCorrectPointAtTopShoulderInsideWithLimitedMaxHeight1()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        location.UseNewMaxHeightShoulderAsFraction = true;
        location.NewMaxHeightShoulderAsFraction = 1;
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        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
        };
        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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        double expectedShoulderHeight = Math.Min(shoulderHeight, (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z));
        var expectedPoint = new GeometryPoint(3, expectedShoulderHeight);
        GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
        Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
    }

    [Test]
    public void AdaptedSurfaceLineWithoutShoulderHasCorrectPointAtTopShoulderInsideWithResetLimitedMaxHeight()
    {
        const double maxFractionOfDikeHeightForShoulderHeight = 0.5;
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        location.UseNewMaxHeightShoulderAsFraction = true;
        location.NewMaxHeightShoulderAsFraction = 1;
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        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
        };
        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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        surfaceLineAdapter.MaxShoulderLevel = maxFractionOfDikeHeightForShoulderHeight * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z -
                                                                                          surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z;
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        double expectedShoulderHeight = Math.Min(shoulderHeight, surfaceLineAdapter.MaxShoulderLevel + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z);
        var expectedPoint = new GeometryPoint(3.5, expectedShoulderHeight);
        GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
        Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
    }

    [Test]
    public void AdaptedSurfaceLineWithNewTopSlopeAngle()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        location.UseNewShoulderTopSlope = true;
        location.NewShoulderTopSlope = 0.05;
        const double shoulderLength = 4.5;
        const double shoulderHeight = 0.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 pointAtToePolder = new GeometryPoint
        {
            X = 3,
            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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        surfaceLineAdapter.MaxShoulderLevel = 0.8 * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z -
                                                     surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z;
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        var expectedBasePoint = new GeometryPoint(2.263, 0.737);
        GeometryPoint actualBasePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
        Assert.IsTrue(expectedBasePoint.LocationEquals(actualBasePoint));
        var expectedTopPoint = new GeometryPoint(7, 0.5);
        GeometryPoint actualTopPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
        Assert.IsTrue(expectedTopPoint.LocationEquals(actualTopPoint));
        var expectedToePoint = new GeometryPoint(8.5, 0.0);
        GeometryPoint actualToePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
        Assert.IsTrue(expectedToePoint.LocationEquals(actualToePoint));
    }

    [Test]
    public void AdaptedSurfaceLineWithNewVerySteepTopSlopeAngle()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        location.UseNewShoulderTopSlope = true;
        location.NewShoulderTopSlope = 0.5;
        const double shoulderLength = 4.5;
        const int shoulderHeight = 1;
        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
        };
        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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        surfaceLineAdapter.MaxShoulderLevel = 0.5 * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z -
                                                     surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z;
        Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf<SurfaceLineAdapterException>());
        // TODO (The) what to do with the outcommented code?
        // Dike top polder now coincides with the shoulder base.
        //            var expectedBasePoint = GeometryPoint.CreateNewXZPoint(2, 1);
        //            var actualBasePoint = adaptedSurfaceLine[CharacteristicPointType.ShoulderBaseInside];
        //            Assert.IsTrue(expectedBasePoint.LocationEquals(actualBasePoint));
        //            var actualDikeTopPoint = adaptedSurfaceLine[CharacteristicPointType.DikeTopAtPolder];
        //            Assert.IsTrue(expectedBasePoint.LocationEquals(actualDikeTopPoint));
        //            var expectedTopPoint = GeometryPoint.CreateNewXZPoint(7, 0.5);
        //            var actualTopPoint = adaptedSurfaceLine[CharacteristicPointType.ShoulderTopInside];
        //            Assert.IsTrue(expectedTopPoint.LocationEquals(actualTopPoint));
        //            var expectedToePoint = GeometryPoint.CreateNewXZPoint(8.5, 0.0);
        //            var actualToePoint = adaptedSurfaceLine[CharacteristicPointType.DikeToeAtPolder];
        //            Assert.IsTrue(expectedToePoint.LocationEquals(actualToePoint));
    }

    [Test]
    public void AdaptedSurfaceLineWithNewBaseSlopeAngle()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        location.UseNewShoulderBaseSlope = true;
        location.NewShoulderBaseSlope = 1;
        const double shoulderLength = 4.5;
        const int shoulderHeight = 1;
        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
        };
        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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        surfaceLineAdapter.MaxShoulderLevel = 0.5 * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z -
                                                     surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z;
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        var expectedBasePoint = new GeometryPoint(2.5, 0.5);
        GeometryPoint actualBasePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
        Assert.IsTrue(expectedBasePoint.LocationEquals(actualBasePoint));
        var expectedTopPoint = new GeometryPoint(7, 0.5);
        GeometryPoint actualTopPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
        Assert.IsTrue(expectedTopPoint.LocationEquals(actualTopPoint));
        var expectedToePoint = new GeometryPoint(7.5, 0.0);
        GeometryPoint actualToePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
        Assert.IsTrue(expectedToePoint.LocationEquals(actualToePoint));
    }

    [Test]
    public void AdaptedSurfaceLineWithNewBaseSlopeAngleButWithReset()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        location.UseNewShoulderBaseSlope = true;
        location.NewShoulderBaseSlope = 1;
        const double shoulderLength = 4.5;
        const int shoulderHeight = 1;
        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
        };
        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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        surfaceLineAdapter.MaxShoulderLevel = 0.5 * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z -
                                                     surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z;
        surfaceLineAdapter.SlopeOfNewShoulder = 2;
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        var expectedBasePoint = new GeometryPoint(2.5, 0.5);
        GeometryPoint actualBasePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
        Assert.IsTrue(expectedBasePoint.LocationEquals(actualBasePoint));
        var expectedTopPoint = new GeometryPoint(7, 0.5);
        GeometryPoint actualTopPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
        Assert.IsTrue(expectedTopPoint.LocationEquals(actualTopPoint));
        var expectedToePoint = new GeometryPoint(8, 0.0);
        GeometryPoint actualToePoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
        Assert.IsTrue(expectedToePoint.LocationEquals(actualToePoint));
    }

    [Test]
    public void AdaptedSurfaceLineWithNewBaseSlopeAngleFarTooShallow()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        location.UseNewShoulderBaseSlope = true;
        location.NewShoulderBaseSlope = 0.001;
        const double shoulderLength = 4.5;
        const int shoulderHeight = 1;
        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
        };
        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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0);
        surfaceLineAdapter.MaxShoulderLevel = 0.5 * (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z -
                                                     surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z) + surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z;
        Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf<SurfaceLineAdapterException>());
    }

    [Test]
    public void AdaptedSurfaceLineWithNewMinDistanceFromToe()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        location.UseNewMinDistanceDikeToeStartDitch = true;
        location.NewMinDistanceDikeToeStartDitch = 1;
        var pointAtToeRiver = new GeometryPoint
        {
            X = 0,
            Z = 0
        };
        var pointAtTopRiver = new GeometryPoint
        {
            X = 2,
            Z = 2
        };
        var pointAtTopPolder = new GeometryPoint
        {
            X = 3,
            Z = 2
        };
        var pointAtToePolder = new GeometryPoint
        {
            X = 4,
            Z = 0
        };
        var ditchTopAtDikeSide = new GeometryPoint
        {
            X = 5,
            Z = 0
        };
        var ditchBottomAtDikeSide = new GeometryPoint
        {
            X = 6,
            Z = -2
        };
        var ditchBottomAtPolderSide = new GeometryPoint
        {
            X = 7,
            Z = -2
        };
        var ditchTopAtPolderSide = new GeometryPoint
        {
            X = 8,
            Z = 0
        };
        var apoint = new GeometryPoint
        {
            X = 9,
            Z = 0
        };
        var apoint2 = new GeometryPoint
        {
            X = 10,
            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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
        surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
        surfaceLine.EnsurePointOfType(apoint.X, apoint.Z, null);
        surfaceLine.EnsurePointOfType(apoint2.X, apoint2.Z, null);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0)
        {
            SlopeOfNewShoulder = 2
        };
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        var expectedPoint = new GeometryPoint(3.5, 1);
        GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
        Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
        var expectedShoulderTopInside = new GeometryPoint(4.5, 1);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
        Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint));
        var expectedDikeToePolder = new GeometryPoint(6.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
        Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint));
        var expectedDitchDikeSide = new GeometryPoint(7.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide);
        Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint));
        var expectedBottomDitchDikeSide = new GeometryPoint(8.5, -2);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide);
        Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint));
        var expectedBottomDitchPolderSide = new GeometryPoint(9.5, -2);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide);
        Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint));
        var expectedDitchPolderSide = new GeometryPoint(10.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide);
        Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint));
        Assert.AreEqual(11, surfaceLine.Geometry.Count);
        Assert.AreEqual(11, adaptedSurfaceLine.Geometry.Count);
    }

    [Test]
    public void AdaptedSurfaceLineWithLargeNewMinDistanceFromToe()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        location.UseNewMinDistanceDikeToeStartDitch = true;
        location.NewMinDistanceDikeToeStartDitch = 31;
        var pointAtToeRiver = new GeometryPoint
        {
            X = 0,
            Z = 0
        };
        var pointAtTopRiver = new GeometryPoint
        {
            X = 2,
            Z = 2
        };
        var pointAtTopPolder = new GeometryPoint
        {
            X = 3,
            Z = 2
        };
        var pointAtToePolder = new GeometryPoint
        {
            X = 4,
            Z = 0
        };
        var ditchTopAtDikeSide = new GeometryPoint
        {
            X = 5,
            Z = 0
        };
        var ditchBottomAtDikeSide = new GeometryPoint
        {
            X = 6,
            Z = -2
        };
        var ditchBottomAtPolderSide = new GeometryPoint
        {
            X = 7,
            Z = -2
        };
        var ditchTopAtPolderSide = new GeometryPoint
        {
            X = 8,
            Z = 0
        };
        var apoint = new GeometryPoint
        {
            X = 9,
            Z = 0
        };
        var apoint2 = new GeometryPoint
        {
            X = 10,
            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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
        surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
        surfaceLine.EnsurePointOfType(apoint.X, apoint.Z, null);
        surfaceLine.EnsurePointOfType(apoint2.X, apoint2.Z, null);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0)
        {
            SlopeOfNewShoulder = 2
        };
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        var expectedPoint = new GeometryPoint(3.5, 1);
        GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
        Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
        var expectedShoulderTopInside = new GeometryPoint(4.5, 1);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
        Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint));
        var expectedDikeToePolder = new GeometryPoint(6.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
        Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint));
        var expectedDitchDikeSide = new GeometryPoint(37.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide);
        Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint));
        var expectedBottomDitchDikeSide = new GeometryPoint(38.5, -2);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide);
        Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint));
        var expectedBottomDitchPolderSide = new GeometryPoint(39.5, -2);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide);
        Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint));
        var expectedDitchPolderSide = new GeometryPoint(40.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide);
        Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint));
        Assert.AreEqual(11, surfaceLine.Geometry.Count);
        Assert.AreEqual(14, adaptedSurfaceLine.Geometry.Count);
    }

    [Test]
    public void AdaptedSurfaceLineWithTooLargeNewMinDistanceFromToe()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        location.UseNewMinDistanceDikeToeStartDitch = true;
        location.NewMinDistanceDikeToeStartDitch = 131;
        var pointAtToeRiver = new GeometryPoint
        {
            X = 0,
            Z = 0
        };
        var pointAtTopRiver = new GeometryPoint
        {
            X = 2,
            Z = 2
        };
        var pointAtTopPolder = new GeometryPoint
        {
            X = 3,
            Z = 2
        };
        var pointAtToePolder = new GeometryPoint
        {
            X = 4,
            Z = 0
        };
        var ditchTopAtDikeSide = new GeometryPoint
        {
            X = 5,
            Z = 0
        };
        var ditchBottomAtDikeSide = new GeometryPoint
        {
            X = 6,
            Z = -2
        };
        var ditchBottomAtPolderSide = new GeometryPoint
        {
            X = 7,
            Z = -2
        };
        var ditchTopAtPolderSide = new GeometryPoint
        {
            X = 8,
            Z = 0
        };
        var apoint = new GeometryPoint
        {
            X = 9,
            Z = 0
        };
        var apoint2 = new GeometryPoint
        {
            X = 10,
            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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
        surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
        surfaceLine.EnsurePointOfType(apoint.X, apoint.Z, null);
        surfaceLine.EnsurePointOfType(apoint2.X, apoint2.Z, null);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, 0)
        {
            SlopeOfNewShoulder = 2
        };
        Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf<SurfaceLineAdapterException>());
    }

    [Test]
    public void AdaptedSurfaceLineWithNewMinDistanceFromToeAndNewDefinition()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        location.UseNewMinDistanceDikeToeStartDitch = true;
        location.NewMinDistanceDikeToeStartDitch = 1;
        location.UseNewDitchDefinition = true;
        double polderLevel = -0.2;
        location.NewSlopeAngleDitch = 1;
        location.NewDepthDitch = 1.8;
        location.NewWidthDitchBottom = 2;
        var pointAtToeRiver = new GeometryPoint
        {
            X = 0,
            Z = 0
        };
        var pointAtTopRiver = new GeometryPoint
        {
            X = 2,
            Z = 2
        };
        var pointAtTopPolder = new GeometryPoint
        {
            X = 3,
            Z = 2
        };
        var pointAtToePolder = new GeometryPoint
        {
            X = 4,
            Z = 0
        };
        var ditchTopAtDikeSide = new GeometryPoint
        {
            X = 5,
            Z = 0
        };
        var ditchBottomAtDikeSide = new GeometryPoint
        {
            X = 6,
            Z = -2
        };
        var ditchBottomAtPolderSide = new GeometryPoint
        {
            X = 7,
            Z = -2
        };
        var ditchTopAtPolderSide = new GeometryPoint
        {
            X = 8,
            Z = 0
        };
        var apoint = new GeometryPoint
        {
            X = 9,
            Z = 0
        };
        var apoint2 = new GeometryPoint
        {
            X = 10,
            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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
        surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
        surfaceLine.EnsurePointOfType(apoint.X, apoint.Z, null);
        surfaceLine.EnsurePointOfType(apoint2.X, apoint2.Z, null);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, polderLevel)
        {
            SlopeOfNewShoulder = 2
        };
        SurfaceLine2 adaptedSurfaceLine = surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false);
        var expectedPoint = new GeometryPoint(3.5, 1);
        GeometryPoint actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside);
        Assert.IsTrue(expectedPoint.LocationEquals(actualPoint));
        var expectedShoulderTopInside = new GeometryPoint(4.5, 1);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside);
        Assert.IsTrue(expectedShoulderTopInside.LocationEquals(actualPoint));
        var expectedDikeToePolder = new GeometryPoint(6.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder);
        Assert.IsTrue(expectedDikeToePolder.LocationEquals(actualPoint));
        var expectedDitchDikeSide = new GeometryPoint(7.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchDikeSide);
        Assert.IsTrue(expectedDitchDikeSide.LocationEquals(actualPoint));
        var expectedBottomDitchDikeSide = new GeometryPoint(9.5, -2);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchDikeSide);
        Assert.IsTrue(expectedBottomDitchDikeSide.LocationEquals(actualPoint));
        var expectedBottomDitchPolderSide = new GeometryPoint(11.5, -2);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.BottomDitchPolderSide);
        Assert.IsTrue(expectedBottomDitchPolderSide.LocationEquals(actualPoint));
        var expectedDitchPolderSide = new GeometryPoint(13.5, 0);
        actualPoint = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DitchPolderSide);
        Assert.IsTrue(expectedDitchPolderSide.LocationEquals(actualPoint));
        Assert.AreEqual(11, surfaceLine.Geometry.Count);
        Assert.AreEqual(11, adaptedSurfaceLine.Geometry.Count);
    }

    [Test]
    public void AdaptedSurfaceLineWithNewMinDistanceFromToeAndNewDefinitionFailsBecausePolderLevelIsTooHigh()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var location = new Location();
        const int shoulderLength = 1;
        const int shoulderHeight = 1;
        location.UseNewMinDistanceDikeToeStartDitch = true;
        location.NewMinDistanceDikeToeStartDitch = 1;
        location.UseNewDitchDefinition = true;
        var polderLevel = 20.2;
        location.NewSlopeAngleDitch = 1;
        location.NewDepthDitch = 1.8;
        location.NewWidthDitchBottom = 2;
        var pointAtToeRiver = new GeometryPoint
        {
            X = 0,
            Z = 0
        };
        var pointAtTopRiver = new GeometryPoint
        {
            X = 2,
            Z = 2
        };
        var pointAtTopPolder = new GeometryPoint
        {
            X = 3,
            Z = 2
        };
        var pointAtToePolder = new GeometryPoint
        {
            X = 4,
            Z = 0
        };
        var ditchTopAtDikeSide = new GeometryPoint
        {
            X = 5,
            Z = 0
        };
        var ditchBottomAtDikeSide = new GeometryPoint
        {
            X = 6,
            Z = -2
        };
        var ditchBottomAtPolderSide = new GeometryPoint
        {
            X = 7,
            Z = -2
        };
        var ditchTopAtPolderSide = new GeometryPoint
        {
            X = 8,
            Z = 0
        };
        var apoint = new GeometryPoint
        {
            X = 9,
            Z = 0
        };
        var apoint2 = new GeometryPoint
        {
            X = 10,
            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(pointAtToePolder.X, pointAtToePolder.Z, CharacteristicPointType.DikeToeAtPolder);
        surfaceLine.EnsurePointOfType(ditchTopAtDikeSide.X, ditchTopAtDikeSide.Z, CharacteristicPointType.DitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtDikeSide.X, ditchBottomAtDikeSide.Z, CharacteristicPointType.BottomDitchDikeSide);
        surfaceLine.EnsurePointOfType(ditchBottomAtPolderSide.X, ditchBottomAtPolderSide.Z, CharacteristicPointType.BottomDitchPolderSide);
        surfaceLine.EnsurePointOfType(ditchTopAtPolderSide.X, ditchTopAtPolderSide.Z, CharacteristicPointType.DitchPolderSide);
        surfaceLine.EnsurePointOfType(apoint.X, apoint.Z, null);
        surfaceLine.EnsurePointOfType(apoint2.X, apoint2.Z, null);
        surfaceLine.EnsurePointOfType(pointAtSurfaceLevelInside.X, pointAtSurfaceLevelInside.Z, CharacteristicPointType.SurfaceLevelInside);
        var surfaceLineAdapter = new SurfaceLineShoulderAdapter(surfaceLine, location, polderLevel)
        {
            SlopeOfNewShoulder = 2
        };
        Assert.That(() => surfaceLineAdapter.ConstructNewSurfaceLine(shoulderLength, shoulderHeight, false), Throws.InstanceOf<SurfaceLineAdapterException>());
    }

    private SurfaceLine2 CreateSurfaceLineWithSkewedSurfaceLevelInside()
    {
        var surfaceLine = new SurfaceLine2
        {
            CharacteristicPoints =
            {
                GeometryMustContainPoint = true
            },
            Geometry = new GeometryPointString()
        };
        var pointSurfaceLevelOutside = new GeometryPoint
        {
            X = -1,
            Z = -1
        };
        var pointDikeToeAtRiver = new GeometryPoint
        {
            X = 0,
            Z = 0
        };
        var pointDikeTopAtRiver = new GeometryPoint
        {
            X = 4,
            Z = 4
        };
        var pointDikeTopAtPolder = new GeometryPoint
        {
            X = 6,
            Z = 4
        };
        var pointDikeToeAtPolder = new GeometryPoint
        {
            X = 10,
            Z = 0
        };
        var pointSurfaceLevelInside = new GeometryPoint
        {
            X = 18,
            Z = -1
        };

        surfaceLine.EnsurePointOfType(pointSurfaceLevelOutside.X, pointSurfaceLevelOutside.Z, CharacteristicPointType.SurfaceLevelOutside);
        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.SortPoints();
        return surfaceLine;
    }

    private void EvaluateAdaptedSurfaceLineWithSkewedSurfaceLevelInside(SurfaceLine2 surfaceLine, SurfaceLine2 adaptedSurfaceLine, double shoulderHeight, double shoulderLength)
    {
        const double cTolerance = 0.0000001;
        Assert.IsNotNull(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside));
        Assert.IsNotNull(adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside));
        Assert.AreEqual(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z + shoulderHeight, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside).Z, cTolerance);
        double intersectionInsideSlopeWithDikeBaseXCoordinate = surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).X + (surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeTopAtPolder).Z - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z);
        Assert.AreEqual(intersectionInsideSlopeWithDikeBaseXCoordinate - shoulderHeight, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderBaseInside).X, cTolerance);
        Assert.AreEqual(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).Z + shoulderHeight, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside).Z, cTolerance);
        Assert.AreEqual(intersectionInsideSlopeWithDikeBaseXCoordinate - shoulderHeight + shoulderLength, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.ShoulderTopInside).X, cTolerance);
        double rightShift = adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).X - surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.DikeToeAtPolder).X;
        Assert.AreEqual(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).X, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).X, cTolerance);
        Assert.AreEqual(surfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).Z, adaptedSurfaceLine.CharacteristicPoints.GetGeometryPoint(CharacteristicPointType.SurfaceLevelInside).Z, cTolerance);
    }

    private SurfaceLine2 CreateSurfaceLineWithShoulderAndSkewedSurfaceLevelInside()
    {
        SurfaceLine2 surfaceLine = CreateSurfaceLineWithSkewedSurfaceLevelInside();
        var pointShoulderBaseInside = new GeometryPoint
        {
            X = 9,
            Z = 1
        };
        var pointShoulderTopInside = new GeometryPoint
        {
            X = 11,
            Z = 0.9
        };
        var pointDikeToeAtPolder = new GeometryPoint
        {
            X = 13,
            Z = 0
        };

        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.SortPoints();
        return surfaceLine;
    }
}