// Copyright (C) Stichting Deltares 2018. All rights reserved.
//
// This file is part of the Dam Engine.
//
// The Dam Engine is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
// All names, logos, and references to "Deltares" are registered trademarks of
// Stichting Deltares and remain full property of Stichting Deltares at all times.
// All rights reserved.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Xml.Linq;
using Deltares.DamEngine.Calculators.KernelWrappers.DamMacroStabilityCommon.Assemblers;
using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.General.PlLines;
using Deltares.DamEngine.Data.Geometry;
using Deltares.DamEngine.Data.Geotechnics;
using NUnit.Framework;

namespace Deltares.DamEngine.Calculators.Tests.KernelWrappers.DamMacroStabilityCommon
{
    [TestFixture]
    public class DamMStabAssemblerTest
    {
        #region Setup/Teardown

        [SetUp]
        public void TestSetup()
        {
            assembler = new DamMStabAssembler();

            // Dike
            dike = new Dike();
            dike.Name = "Dike";

            // Segments
            segment1 = new Segment();
            segment1.Name = "Segment1";

            // Locations
            location1 = new Location();
            location1.Name = "Location1";
            location1.Segment = segment1;
            dike.Locations.Add(location1);

            // Surface lines
            surfaceLine1 = new SurfaceLine2
            {
                Name = "SurfaceLine1",
                CharacteristicPoints = { GeometryMustContainPoint = true },
                Geometry = new GeometryPointString()
            };
            dike.SurfaceLines2.Add(surfaceLine1);
            surfaceLine2 = new SurfaceLine2
            {
                Name = "SurfaceLine2",
                CharacteristicPoints = { GeometryMustContainPoint = true },
                Geometry = new GeometryPointString()
            };
            dike.SurfaceLines2.Add(surfaceLine2);

            // Soil profiles
            soilProfile1 = new SoilProfile1D();
            soilProfile1.Name = "SoilProfile1";
            soilProfile1.BottomLevel = -25.3;
            Soil soilClay = new Soil("Clay", 20.0, 20.0);
            Soil soilPeat = new Soil("Peat", 20.0, 20.0);
            Soil soilSand = new Soil("Sand", 20.0, 20.0);
            SoilLayer1D layer = new SoilLayer1D();
            layer.Name = "L1";
            layer.TopLevel = -1.52;
            layer.Soil = soilClay;
            layer.IsAquifer = false;
            soilProfile1.Layers.Add(layer);
            layer = new SoilLayer1D();
            layer.Name = "L2";
            layer.TopLevel = -3.18;
            layer.Soil = soilPeat;
            layer.IsAquifer = false;
            soilProfile1.Layers.Add(layer);
            layer = new SoilLayer1D();
            layer.Name = "L3";
            layer.TopLevel = -7.37;
            layer.Soil = soilSand;
            layer.IsAquifer = true;
            soilProfile1.Layers.Add(layer);
            layer = new SoilLayer1D();
            layer.Name = "L4";
            layer.TopLevel = -12.28;
            layer.Soil = soilPeat;
            layer.IsAquifer = false;
            soilProfile1.Layers.Add(layer);
            layer = new SoilLayer1D();
            layer.Name = "L5";
            layer.TopLevel = -15.62;
            layer.Soil = soilClay;
            layer.IsAquifer = false;
            soilProfile1.Layers.Add(layer);
            layer = new SoilLayer1D();
            layer.Name = "L6";
            layer.TopLevel = -18.39;
            layer.Soil = soilSand;
            layer.IsAquifer = true;
            soilProfile1.Layers.Add(layer);
            dike.SoilProfiles.Add(soilProfile1);

            // Locations' Segments
            location1.Segment = segment1;

            // Locations' surface lines
            location1.SurfaceLine = surfaceLine1;

            // Segments' Soil profile probabilities
//            segment1.AddSoilProfileProbability(soilProfile1, 100.0, FailureMechanismSystemType.StabilityInside);

            // Surface lines' points
            surfaceLine1.EnsurePointOfType(15.3, -3.52, CharacteristicPointType.SurfaceLevelOutside);
            surfaceLine1.EnsurePointOfType(19.4, -1.46, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine1.EnsurePointOfType(27.4, 8.56, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine1.EnsurePointOfType(35.2, 8.62, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine1.EnsurePointOfType(41.5, -3.76, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine1.EnsurePointOfType(85.4, -3.61, CharacteristicPointType.SurfaceLevelInside);

            surfaceLine2.EnsurePointOfType(0.0, -1.46, CharacteristicPointType.SurfaceLevelOutside);
            surfaceLine2.EnsurePointOfType(19.4, -1.46, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine2.EnsurePointOfType(27.4, 8.56, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine2.EnsurePointOfType(35.2, 8.62, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine2.EnsurePointOfType(41.5, -3.76, CharacteristicPointType.DikeToeAtPolder);
            surfaceLine2.EnsurePoint(46.7, -3.82);
            surfaceLine2.EnsurePoint(47.5, -4.78);
            surfaceLine2.EnsurePoint(51.2, -4.82);
            surfaceLine2.EnsurePoint(53.1, -3.78);
            surfaceLine2.EnsurePointOfType(85.4, -3.61, CharacteristicPointType.SurfaceLevelInside);

            // PL Lines
            peelLines = new PlLines();
            peelLine1 = new PlLine();
            peelLine1.Name = "PLLine1";
            peelLine1.IsPhreatic = false;
            peelLine1.BoundaryLayer = 2;
            peelLine1.Points.Add(new PlLinePoint(35.2, -7.56));
            peelLine1.Points.Add(new PlLinePoint(42.5, -6.12));
            peelLine1.Points.Add(new PlLinePoint(45.3, -8.73));
            peelLines.Lines[PlLineType.Pl1] = peelLine1;
            peelLine2 = new PlLine();
            peelLine2.Name = "PLLine2";
            peelLine2.IsPhreatic = true;
            peelLine2.BoundaryLayer = 5;
            peelLine2.Points.Add(new PlLinePoint(16.2, 3.23));
            peelLine2.Points.Add(new PlLinePoint(18.4, 1.19));
            peelLine2.Points.Add(new PlLinePoint(21.8, -0.45));
            peelLine2.Points.Add(new PlLinePoint(22.5, -1.73));
            peelLines.Lines[PlLineType.Pl1] = peelLine2;

            // Calculation options
            calculationOptions = new MStabCalculationOptions();
            calculationOptions.MinimalCircleDepth = 1.1;

            // Zone areas
            zoneAreas = new MStabZoneAreas();
            zoneAreas.DikeTableHeight = 12.0;
            zoneAreas.DikeTableWidth = 1.5;
            zoneAreas.XCoordinateDikeTopAtRiver = 10.0;
            zoneAreas.XCoordinateDikeTopAtPolder = 18.0;
            zoneAreas.XCoordinateStartRestProfile = 20.0;
            zoneAreas.SafetyFactorZone1A = 1.2;
            zoneAreas.SafetyFactorZone1B = 1.3;

            // Geometry creation options
            geometryCreationOptions = new MStabGeometryCreationOptions();
            geometryCreationOptions.SoilProfileType = SoilProfileType.ProfileType2D;
            geometryCreationOptions.SoilGeometry2DFilename = "geometry2D filename";
            geometryCreationOptions.XOffsetSoilGeometry2DOrigin = 12.0;
            geometryCreationOptions.MaterialForDike = "clay dike";
            geometryCreationOptions.MaterialForShoulder = "sand shoulder";
            geometryCreationOptions.IsUseOriginalPlLineAssignments = true;
            geometryCreationOptions.IsUseOriginalCalculationOptions = true;
            geometryCreationOptions.IsDrySituation = true;
            geometryCreationOptions.IsDesign = true;

            // MStabDesignEmbankment design 
            design = new EmbankmentDesignParameters();
            design.EmbankmentMaterialname = "soiltest";
            design.PreviousGeometry2DFilename = "soilname/Path/testFileNameWithPLLines.sti";
            
            // Sheetpiling 
            sheetPiling = new SheetPiling();
            sheetPiling.XCoordinate = 11.11;
            sheetPiling.YCoordinate = 22.22;
            sheetPiling.ZCoordinate = 33.33;
            sheetPiling.Length = 20.0;

            // Horizontal Balance Area
            horizontalBalanceArea = new HorizontalBalanceArea();
            horizontalBalanceArea.XLeft = 13.11;
            horizontalBalanceArea.XRight = 14.11;
            horizontalBalanceArea.YTop = 15.11;
            horizontalBalanceArea.YBottom = 16.11;
            horizontalBalanceArea.PlaneCount = 17;

            // Slip Circle Definition
            slipCircleDefinition = new SlipCircleDefinition();
            slipCircleDefinition.XCoordinateLastUpliftPoint = 18.11;
            slipCircleDefinition.UpliftVanTangentLinesDefinition = TangentLinesDefinition.Specified;
            slipCircleDefinition.GridSizeDetermination = GridSizeDetermination.Specified;
            slipCircleDefinition.UpliftVanLeftGridVerticalPointCount = 19;
            slipCircleDefinition.UpliftVanLeftGridVerticalPointDistance = 20.11;
            slipCircleDefinition.UpliftVanLeftGridHorizontalPointCount = 21;
            slipCircleDefinition.UpliftVanLeftGridHorizontalPointDistance = 22.11;
            slipCircleDefinition.UpliftVanRightGridVerticalPointCount = 23;
            slipCircleDefinition.UpliftVanRightGridVerticalPointDistance = 24.11;
            slipCircleDefinition.UpliftVanRightGridHorizontalPointCount = 25;
            slipCircleDefinition.UpliftVanRightGridHorizontalPointDistance = 26.11;
            slipCircleDefinition.BishopGridVerticalPointCount = 27;
            slipCircleDefinition.BishopGridVerticalPointDistance = 28.11;
            slipCircleDefinition.BishopGridHorizontalPointCount = 29;
            slipCircleDefinition.BishopGridHorizontalPointDistance = 30.11;

            // DAMMStab (class containing all)
            damFailureMechanismeCalculationSpecification = new DamFailureMechanismeCalculationSpecification
            {
                FailureMechanismParametersMStab = new FailureMechanismParametersMStab()
                {
                    Location = location1,
                    SurfaceLine = location1.SurfaceLine,
                    PlLines = peelLines,
                    SoilProfile = soilProfile1,
                    EmbankmentDesignParameters = design,
                    MStabParameters = new MStabParameters()
                    {
                        SoilDatabaseName = @"X:\GeoData\Soils\TestDatabase.mdb",
                        Model = MStabModelType.UpliftVan,
                        ShearStrength = MStabShearStrength.CPhi,
                        ProjectFileName = @"X:\MStab\Demo.sti",
                        ZoneAreas = zoneAreas,
                        GeometryCreationOptions = geometryCreationOptions,
                        SheetPiling = sheetPiling,
                        HorizontalBalanceArea = horizontalBalanceArea,
                        SlipCircleDefinition = slipCircleDefinition,
                        CalculationOptions = calculationOptions
                        
                    }
                }
            };
        }

        [TearDown]
        public void TearDown()
        {
        }

        #endregion

        private const string TestDirectory = "TestResults";
        private const string TestFileName = "DikeMStabAssemblerTest.xml";
        private const string TestFileNameWithPlLines = "DikeMStabAssemblerTestWithPLLines.xml";

        private const double Precision = 1e-8;

        private DamFailureMechanismeCalculationSpecification damFailureMechanismeCalculationSpecification;
        private DamMStabAssembler assembler;

        private Dike dike;
        private Segment segment1;
        private Location location1;
        private SurfaceLine2 surfaceLine1;
        private SurfaceLine2 surfaceLine2;
        private SoilProfile1D soilProfile1;

        private PlLines peelLines;
        private PlLine peelLine1;
        private PlLine peelLine2;

        private MStabZoneAreas zoneAreas;
        private MStabCalculationOptions calculationOptions;
        private MStabGeometryCreationOptions geometryCreationOptions;
        private SheetPiling sheetPiling;
        private HorizontalBalanceArea horizontalBalanceArea;
        private EmbankmentDesignParameters design;
        private SlipCircleDefinition slipCircleDefinition;

        [TestFixtureSetUp]
        public void TestFixtureSetup()
        {
        }

        [Test]
        public void CanCreateAndValidateMStabInputXML()
        {
            // Do the thing: create XML element from SoilProfile
            geometryCreationOptions.IntrusionVerticalWaterPressureType = IntrusionVerticalWaterPressureType.HydroStatic;
            geometryCreationOptions.PenetrationLength = 1.4;
            XDocument doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);

            Directory.CreateDirectory(TestDirectory);
            doc.Save(Path.Combine(TestDirectory, TestFileName));

            // Validate against schema
            string message;
            if (!assembler.ValidateSchema(doc, out message))
            {
                Assert.Fail("SCHEMA VALIDATION: " + message);
            }

            // Compare resulting XML to original object

            // Input
            XElement inputElement = (from element in doc.Root.Descendants()
                                     where element.Name.LocalName == DamMStabAssembler.XmlElementNameInput
                                     select element).Single();

            // Database
            Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.ProjectFileName, inputElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeMStabFileName), "SoilDB Name");
            Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.SoilDatabaseName, inputElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeSoilDBName), "SoilDB Name");

            // Surface lines
            XElement surfaceLineElement = (from element in inputElement.Descendants()
                                           where element.Name.LocalName == DamMStabAssembler.XmlElementSurfaceLine
                                           select element).Single();

            // Surface points
            IEnumerable<XElement> surfacePointElements = from element in surfaceLineElement.Descendants()
                                                         where element.Name.LocalName == DamMStabAssembler.XmlElementSurfacePoint
                                                         select element;

            Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.Location.SurfaceLine.Geometry.Count, surfacePointElements.Count(), "Number of surface line points");

            IEnumerator<XElement> surfacePointElementEnumerator = surfacePointElements.GetEnumerator();
            foreach (GeometryPoint point in damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.Location.SurfaceLine.Geometry.Points)
            {
                surfacePointElementEnumerator.MoveNext();
                XElement surfaceLinePointElement = surfacePointElementEnumerator.Current;
                Assert.AreEqual(point.X, surfaceLinePointElement.AttributeAs<double>(DamMStabAssembler.XmlAttributeXCoord), Precision, String.Format("X of GeometryPoint #{0}", 
                    damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.Location.SurfaceLine.Geometry.Points.IndexOf(point)));
                Assert.AreEqual(point.Z, surfaceLinePointElement.AttributeAs<double>(DamMStabAssembler.XmlAttributeYCoord), Precision, String.Format("Z of GeometryPoint #{0}",
                    damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.Location.SurfaceLine.Geometry.Points.IndexOf(point)));
            }

            // External PL lines
            IEnumerable<XElement> externalPlLineCollectionElements = from element in inputElement.Descendants()
                                                                     where element.Name.LocalName == DamMStabAssembler.XmlElementExternalPLLines
                                                                     select element;

            Assert.AreEqual(1, externalPlLineCollectionElements.Count(), String.Format("There should be exactly one {0} tag", DamMStabAssembler.XmlElementExternalPLLines));

            XElement externalPlLineCollectionElement = externalPlLineCollectionElements.Single();

            IEnumerable<XElement> peelLineCollectionElements = from element in externalPlLineCollectionElement.Descendants()
                                                               where element.Name.LocalName == DamMStabAssembler.XmlElementPLLine
                                                               select element;

            Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.PlLines.PlLineCount, peelLineCollectionElements.Count(), "Number of PL lines");
            IEnumerator<XElement> peelLineElementEnumerator = peelLineCollectionElements.GetEnumerator();
            foreach (PlLineType plLineType in Enum.GetValues(typeof(PlLineType)))
            {
                PlLine line = damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.PlLines.Lines[plLineType];
                peelLineElementEnumerator.MoveNext();
                XElement peelLineElement = peelLineElementEnumerator.Current;

                Assert.AreEqual(line.IsPhreatic, peelLineElement.AttributeAs<bool>(DamMStabAssembler.XmlAttributeIsPhreatic), String.Format("{0}", DamMStabAssembler.XmlAttributeIsPhreatic));
                Assert.AreEqual(line.BoundaryLayer, peelLineElement.AttributeAs<int>(DamMStabAssembler.XmlAttributeBoundaryLayer), String.Format("{0}", DamMStabAssembler.XmlAttributeBoundaryLayer));

                IEnumerable<XElement> peelPointCollectionElements = from element in peelLineElement.Descendants()
                                                                    where element.Name.LocalName == DamMStabAssembler.XmlElementPLPoint
                                                                    select element;
                Assert.AreEqual(line.Points.Count, peelPointCollectionElements.Count(), "Number of PL line Points");
                IEnumerator<XElement> peelPointElementEnumerator = peelPointCollectionElements.GetEnumerator();
                foreach (PlLinePoint point in line.Points)
                {
                    peelPointElementEnumerator.MoveNext();
                    XElement peelPointElement = peelPointElementEnumerator.Current;
                    Assert.AreEqual(point.X, peelPointElement.AttributeAs<double>(DamMStabAssembler.XmlAttributeXCoord), Precision, String.Format("X of GeometryPoint #{0}", line.Points.IndexOf(point)));
                    Assert.AreEqual(point.Z, peelPointElement.AttributeAs<double>(DamMStabAssembler.XmlAttributeYCoord), Precision, String.Format("Z of GeometryPoint #{0}", line.Points.IndexOf(point)));
                }
            }

            // Model
            XElement modelElement = (from element in doc.Root.Descendants()
                where element.Name.LocalName == DamMStabAssembler.XmlElementModel
                select element).Single();
            Assert.AreEqual(MStabModelType.UpliftVan.ToString(), modelElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeCalculationModel), DamMStabAssembler.XmlAttributeCalculationModel);
            Assert.AreEqual(MStabShearStrength.CPhi.ToString(), modelElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeShearStrength), DamMStabAssembler.XmlAttributeShearStrength);
            Assert.AreEqual(false, modelElement.AttributeAs<bool>(DamMStabAssembler.XmlAttributeProbabilistic), DamMStabAssembler.XmlAttributeProbabilistic);

            // Zone Areas
            XElement zoneAreasElement = (from element in doc.Root.Descendants()
                where element.Name.LocalName == DamMStabAssembler.XmlElementZoneAreas
                select element).Single();
            Assert.AreEqual(zoneAreas.DikeTableHeight, zoneAreasElement.AttributeAs<double>("DikeTableHeight"), "DikeTableHeight");
            Assert.AreEqual(zoneAreas.DikeTableWidth, zoneAreasElement.AttributeAs<double>("DikeTableWidth"), "DikeTableWidth");
            Assert.AreEqual(zoneAreas.XCoordinateDikeTopAtRiver, zoneAreasElement.AttributeAs<double>("XCoordinateDikeTopAtRiver"), "XCoordinateDikeTopAtRiver");
            Assert.AreEqual(zoneAreas.XCoordinateDikeTopAtPolder, zoneAreasElement.AttributeAs<double>("XCoordinateDikeTopAtPolder"), "XCoordinateDikeTopAtPolder");
            Assert.AreEqual(zoneAreas.XCoordinateStartRestProfile, zoneAreasElement.AttributeAs<double>("XCoordinateStartRestProfile"), "XCoordinateStartRestProfile");
            Assert.AreEqual(zoneAreas.SafetyFactorZone1A, zoneAreasElement.AttributeAs<double>("SafetyFactorZone1A"), "SafetyFactorZone1A");
            Assert.AreEqual(zoneAreas.SafetyFactorZone1B, zoneAreasElement.AttributeAs<double>("SafetyFactorZone1B"), "SafetyFactorZone1B");

            // Calculation options
            XElement calculationOptionsElement = (from element in doc.Root.Descendants()
                where element.Name.LocalName == DamMStabAssembler.XmlElementCalculationOptions
                select element).Single();
            Assert.AreEqual(calculationOptions.MinimalCircleDepth, calculationOptionsElement.AttributeAs<double>(DamMStabAssembler.XmlAttributeMinimalCircleDepth), DamMStabAssembler.XmlAttributeMinimalCircleDepth);

            // GeometryCreationOptions
            XElement geometryCreationOptionsElement = (from element in doc.Root.Descendants()
                where element.Name.LocalName == DamMStabAssembler.XmlElementGeometryCreationOptions
                select element).Single();
            Assert.AreEqual("SoilGeometry2D", geometryCreationOptionsElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeSoilGeometryType), DamMStabAssembler.XmlAttributeSoilGeometryType);
            Assert.AreEqual(geometryCreationOptions.SoilGeometry2DFilename, 
                geometryCreationOptionsElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeSoilGeometry2DFilename), DamMStabAssembler.XmlAttributeSoilGeometry2DFilename);
            Assert.AreEqual(geometryCreationOptions.MaterialForDike, geometryCreationOptionsElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeMaterialForDike), DamMStabAssembler.XmlAttributeMaterialForDike);
            Assert.AreEqual(geometryCreationOptions.MaterialForShoulder, geometryCreationOptionsElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeMaterialForShoulder), DamMStabAssembler.XmlAttributeMaterialForShoulder);
            Assert.AreEqual(geometryCreationOptions.IsUseOriginalPlLineAssignments, geometryCreationOptionsElement.AttributeAs<bool>(DamMStabAssembler.XmlAttributeIsUseOriginalPLLineAssignments), DamMStabAssembler.XmlAttributeIsUseOriginalPLLineAssignments);
            Assert.AreEqual(geometryCreationOptions.IsUseOriginalCalculationOptions, geometryCreationOptionsElement.AttributeAs<bool>(DamMStabAssembler.XmlAttributeIsUseOriginalCalculationOptions), DamMStabAssembler.XmlAttributeIsUseOriginalCalculationOptions);
            Assert.AreEqual(geometryCreationOptions.IsDrySituation, geometryCreationOptionsElement.AttributeAs<bool>(DamMStabAssembler.XmlAttributeIsDrySituation), DamMStabAssembler.XmlAttributeIsDrySituation);
            Assert.AreEqual(geometryCreationOptions.IsDesign, geometryCreationOptionsElement.AttributeAs<bool>(DamMStabAssembler.XmlAttributeIsDesign), DamMStabAssembler.XmlAttributeIsDesign);
            Assert.AreEqual(geometryCreationOptions.PlLineAssignment, geometryCreationOptionsElement.AttributeAs<PlLineAssignment>(DamMStabAssembler.XmlAttributePLLineAssignment), DamMStabAssembler.XmlAttributePLLineAssignment);
            Assert.AreEqual(geometryCreationOptions.IntrusionVerticalWaterPressureType, geometryCreationOptionsElement.AttributeAs<IntrusionVerticalWaterPressureType>(DamMStabAssembler.XmlAttributeIntrusionVerticalWaterPressure), DamMStabAssembler.XmlAttributeIntrusionVerticalWaterPressure);
            Assert.AreEqual(geometryCreationOptions.PenetrationLength, geometryCreationOptionsElement.AttributeAs<double>(DamMStabAssembler.XmlAttributePenetrationLength), DamMStabAssembler.XmlAttributePenetrationLength);

            XElement designElement = (from element in doc.Root.Descendants()
                                      where element.Name.LocalName == DamMStabAssembler.XmlElementDesign
                                      select element).Single();

            Assert.AreEqual(design.EmbankmentMaterialname.ToString(),
                                designElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeEmbankmentMaterialName),
                                DamMStabAssembler.XmlAttributeEmbankmentMaterialName);
            Assert.AreEqual(design.PreviousGeometry2DFilename.ToString(),
                              designElement.AttributeAs<string>(
                                    DamMStabAssembler.XmlAttributePreviousGeometry2DFilename),
                                DamMStabAssembler.XmlAttributePreviousGeometry2DFilename);
            

            // Profile
            IEnumerable<XElement> soilProfileCollectionElements = from element in doc.Root.Descendants()
                where element.Name.LocalName == DamMStabAssembler.XmlElementProfile
                select element;

            Assert.AreEqual(1, soilProfileCollectionElements.Count(), "Number of profiles");

            XElement soilProfileElement = soilProfileCollectionElements.Single();

            Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeName), String.Format("{0}", DamMStabAssembler.XmlAttributeName));
            Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.Name, soilProfileElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeName), String.Format("{0}", DamMStabAssembler.XmlAttributeName));
            Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeBottomLevel), String.Format("{0}", DamMStabAssembler.XmlAttributeBottomLevel));
            Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.BottomLevel, soilProfileElement.AttributeAs<double>(DamMStabAssembler.XmlAttributeBottomLevel), Precision, String.Format("{0}", DamMStabAssembler.XmlAttributeBottomLevel));
            // Created no PL line so characteristic layers are unassigned
            Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeBottomSandLayerID), DamMStabAssembler.XmlAttributeBottomSandLayerID);
            Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeInBetweenSandLayerID), DamMStabAssembler.XmlAttributeInBetweenSandLayerID);
            Assert.IsNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeInfiltrationLayerID), DamMStabAssembler.XmlAttributeInfiltrationLayerID);

            // Profile layers
            IEnumerable<XElement> layersCollectionElements = from element in soilProfileElement.Descendants()
                                                             where element.Name.LocalName == DamMStabAssembler.XmlElementLayers
                                                             select element;

            Assert.AreEqual(1, layersCollectionElements.Count(), "profile layer collection tag");

            IEnumerable<XElement> layerCollectionElements = from element in layersCollectionElements.Descendants()
                                                            where element.Name.LocalName == DamMStabAssembler.XmlElementLayer
                                                            select element;

            Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.Layers.Count, layerCollectionElements.Count(), "Number of profile layers");

            IEnumerator<XElement> layerElementEnumerator = layerCollectionElements.GetEnumerator();
            foreach (SoilLayer1D layer in damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.Layers)
            {
                layerElementEnumerator.MoveNext();
                XElement layerElement = layerElementEnumerator.Current;
                Assert.IsNotNull(layerElement.Attribute(DamMStabAssembler.XmlAttributeID), String.Format("{0}", String.Format("ID of layer #{0}", damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.Layers.IndexOf(layer))));
                Assert.AreEqual(layer.Name, layerElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeID), String.Format("ID of layer #{0}", damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.Layers.IndexOf(layer)));
                Assert.IsNotNull(layerElement.Attribute(DamMStabAssembler.XmlAttributeSoilID), String.Format("{0}", String.Format("SoilID of layer #{0}", damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.Layers.IndexOf(layer))));
                Assert.AreEqual(layer.Soil.Name, layerElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeSoilID), String.Format("SoilID of layer #{0}", damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.Layers.IndexOf(layer)));
                Assert.IsNotNull(layerElement.Attribute(DamMStabAssembler.XmlAttributeTopLevel), String.Format("{0}", String.Format("TopLevel of layer #{0}", damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.Layers.IndexOf(layer))));
                Assert.AreEqual(layer.TopLevel, layerElement.AttributeAs<double>(DamMStabAssembler.XmlAttributeTopLevel), String.Format("TopLevel of layer #{0}", damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.Layers.IndexOf(layer)));
            }

        }

        [Test]
        public void CanCreateAndValidateMStabInputXMLWithPLLines()
        {
            // Create PL lines
            var location = new Location {DamType = DamType.Regional};
            Calculators.PlLinesCreator.PlLinesCreator plLineCreator = new Calculators.PlLinesCreator.PlLinesCreator();
            plLineCreator.SoilProfile = soilProfile1;
            plLineCreator.SurfaceLine = surfaceLine1;
            plLineCreator.WaterLevelRiverHigh = 4.0;
            plLineCreator.WaterLevelPolder = -4.5;
            plLineCreator.ModelParametersForPlLines.DampingFactorPl3 = 0.3;
            plLineCreator.ModelParametersForPlLines.DampingFactorPl4 = 0.4;
            plLineCreator.ModelParametersForPlLines.PenetrationLength = 1.5;
            plLineCreator.HeadInPlLine2 = 0.0;
            plLineCreator.CreateAllPlLines(location);
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            Directory.CreateDirectory(TestDirectory);
            doc.Save(Path.Combine(TestDirectory, TestFileNameWithPlLines));
            string message;
            if (!assembler.ValidateSchema(doc, out message))
            {
                Assert.Fail("SCHEMA VALIDATION: " + message);
            }
            var soilProfileCollectionElements = from element in doc.Root.Descendants()
                where element.Name.LocalName == DamMStabAssembler.XmlElementProfile
                select element;
            Assert.AreEqual(1, soilProfileCollectionElements.Count(), "Number of profiles");
            var soilProfileElement = soilProfileCollectionElements.Single();
            Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeBottomSandLayerID), DamMStabAssembler.XmlAttributeBottomSandLayerID);
            Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.BottomAquiferLayer.Name, soilProfileElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeBottomSandLayerID),
                DamMStabAssembler.XmlAttributeBottomSandLayerID);
            Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeInBetweenSandLayerID), DamMStabAssembler.XmlAttributeInBetweenSandLayerID);
            Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.InBetweenAquiferLayer.Name, soilProfileElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeInBetweenSandLayerID),
                DamMStabAssembler.XmlAttributeInBetweenSandLayerID);
            Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeInfiltrationLayerID), DamMStabAssembler.XmlAttributeInfiltrationLayerID);
            Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.SoilProfile.InfiltrationLayer.Name, soilProfileElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeInfiltrationLayerID),
                DamMStabAssembler.XmlAttributeInfiltrationLayerID);
        }


        /// <summary>
        /// SearchMethod test
        /// The default key value pair for the attribute: SearchMethod="Grid" 
        /// </summary>
        [Test]
        public void VerifyThatTheDefaultKeyValuePairSearchMethodIsWritten()
        {
            assembler = new DamMStabAssembler();
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var modelElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementModel);
            Assert.IsNotNull(modelElement);

            const string expectedValue = "Grid";
            Assert.AreEqual(expectedValue, modelElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeSearchMethod));
        }

        /// <summary>
        /// SearchMethod test
        /// The key value pair for the attribute should be: SearchMethod="GeneticAlgorithm" 
        /// </summary>
        [Test]
        public void VerifyThatTheAssemblerCorrectlyWritesTheSearchMethodAttributeValueWhenSetToGrid()
        {
            assembler = new DamMStabAssembler();
            damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.SearchMethod = MStabSearchMethod.Grid;
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var modelElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementModel);
            Assert.IsNotNull(modelElement);

            const string expectedValue = "Grid";
            Assert.AreEqual(expectedValue, modelElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeSearchMethod));
        }

        /// <summary>
        /// UseZones
        /// </summary>
        [Test]
        public void VerifyThatTheAttributeZonesTypeIsWrittenWhenSet()
        {
            assembler = new DamMStabAssembler();
            damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.CalculationOptions.ZonesType = MStabZonesType.ZoneAreas;

            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementCalculationOptions);
            Assert.IsNotNull(element);

            Assert.AreEqual(MStabZonesType.ZoneAreas, element.AttributeAs<MStabZonesType>(DamMStabAssembler.XmlAttributeZonesType));
        }

        /// <summary>
        /// ZoneAreas
        /// </summary>
        [Test]
        public void VerifyThatElementZoneAreasIsWrittenWhenSet()
        {
            assembler = new DamMStabAssembler();
            damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.ZoneAreas = new MStabZoneAreas { };
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementZoneAreas);
            Assert.IsNotNull(element);

            const int expectedValue = 1;
            Assert.AreEqual(expectedValue, element.Attributes("DikeTableHeight").Count());
            Assert.AreEqual(expectedValue, element.Attributes("DikeTableWidth").Count());
            Assert.AreEqual(expectedValue, element.Attributes("XCoordinateDikeTopAtRiver").Count());
            Assert.AreEqual(expectedValue, element.Attributes("XCoordinateStartRestProfile").Count());
            Assert.AreEqual(7, element.Attributes().Count());
        }

        /// <summary>
        /// ZoneAreas test
        /// </summary>
        [Test]
        public void VerifyThatElementZoneAreasIsNotWrittenByDefault()
        {
            damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.ZoneAreas = null;
            assembler = new DamMStabAssembler();
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var modelElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementZoneAreas);
            Assert.IsNull(modelElement);
        }

        /// <summary>
        /// ZoneAreas
        /// </summary>
        [Test]
        public void VerifyThatElementForbiddenZoneIsWrittenWhenSet()
        {
            assembler = new DamMStabAssembler();
            damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.ForbiddenZone = new MStabForbiddenZone() { };
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementForbiddenZone);
            Assert.IsNotNull(element);

            const int expectedValue = 1;
            Assert.AreEqual(expectedValue, element.Attributes("IsXEntryMinUsed").Count());
            Assert.AreEqual(expectedValue, element.Attributes("IsXEntryMaxUsed").Count());
            Assert.AreEqual(expectedValue, element.Attributes("XEntryMin").Count());
            Assert.AreEqual(expectedValue, element.Attributes("XEntryMax").Count());
            Assert.AreEqual(4, element.Attributes().Count());
        }

        /// <summary>
        /// ZoneAreas test
        /// </summary>
        [Test]
        public void VerifyThatElementForbiddenZoneIsNotWrittenByDefault()
        {
            damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.ZoneAreas = null;
            assembler = new DamMStabAssembler();
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var modelElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementForbiddenZone);
            Assert.IsNull(modelElement);
        }

        /// <summary>
        /// Traffic Load
        /// </summary>
        [Test]
        public void VerifyThatElementTrafficLoadIsWrittenWhenSet()
        {
            assembler = new DamMStabAssembler();
            surfaceLine1.EnsurePointOfType(30.1, 8.56, CharacteristicPointType.TrafficLoadOutside);
            surfaceLine1.EnsurePointOfType(31.2, 8.62, CharacteristicPointType.TrafficLoadInside);
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementTrafficLoad);
            Assert.IsNotNull(element);

            Assert.AreEqual(1, element.Attributes("XCoordinateAtRiver").Count());
            Assert.AreEqual(1, element.Attributes("XCoordinateAtPolder").Count());
            Assert.AreEqual(1, element.Attributes("Load").Count());
        }

        /// <summary>
        /// Traffic load
        /// </summary>
        [Test]
        public void VerifyThatElementTrafficLoadIsNotWrittenByDefault()
        {
            assembler = new DamMStabAssembler();
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var trafficLoadElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementTrafficLoad);
            Assert.IsNull(trafficLoadElement);
        }

        /// <summary>
        /// Calculation options
        /// </summary>
        [Test]
        public void VerifyThatElementCalculationOptionsIsWrittenWhenSet()
        {
            damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.CalculationOptions = new MStabCalculationOptions();
            assembler = new DamMStabAssembler();
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementCalculationOptions);
            Assert.IsNotNull(element);
            Assert.AreEqual(1, element.Attributes("MinimalCircleDepth").Count());
            Assert.AreEqual(1, element.Attributes("ZonesType").Count());
        }

        /// <summary>
        /// Calculation options
        /// </summary>
        [Test]
        public void VerifyThatElementCalculationOptionsIsNotWrittenByDefault()
        {
            damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.CalculationOptions = null;
            assembler = new DamMStabAssembler();
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var calculationOptionsElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementCalculationOptions);
            Assert.IsNull(calculationOptionsElement);
        }

        /// <summary>
        /// Geometry Creation Options 
        /// </summary>
        [Test]
        public void VerifyThatElementGeometryCreationOptionsIsWrittenWhenSet()
        {
            assembler = new DamMStabAssembler();
            damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.GeometryCreationOptions = geometryCreationOptions;
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementGeometryCreationOptions);
            Assert.IsNotNull(element);
            Assert.AreEqual(1, element.Attributes(DamMStabAssembler.XmlAttributeSoilGeometryType).Count());
            Assert.AreEqual(1, element.Attributes(DamMStabAssembler.XmlAttributeXOffsetSoilGeometry2DOrigin).Count());
            Assert.AreEqual(1, element.Attributes(DamMStabAssembler.XmlAttributeMaterialForDike).Count());
            Assert.AreEqual(1, element.Attributes(DamMStabAssembler.XmlAttributeMaterialForShoulder).Count());
            Assert.AreEqual(1, element.Attributes(DamMStabAssembler.XmlAttributeIsUseOriginalPLLineAssignments).Count());
            Assert.AreEqual(1, element.Attributes(DamMStabAssembler.XmlAttributeIsUseOriginalCalculationOptions).Count());
            Assert.AreEqual(1, element.Attributes(DamMStabAssembler.XmlAttributeIsDrySituation).Count());
            Assert.AreEqual(1, element.Attributes(DamMStabAssembler.XmlAttributeIsDesign).Count());
        }

        /// <summary>
        /// Geometry Creation Options 
        /// </summary>
        [Test]
        public void VerifyThatElementGeometryCreationOptionsIsNotWrittenByDefault()
        {
            damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.GeometryCreationOptions = null;
            assembler = new DamMStabAssembler();
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var geometryCreationOptionsElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementGeometryCreationOptions);
            Assert.IsNull(geometryCreationOptionsElement);
        }

        /// <summary>
        /// IsUseOriginalPLLineAssignments test
        /// The key value pair for the attribute should be: IsUseOriginalPLLineAssignments="true" 
        /// </summary>
        [Test]
        public void VerifyThatTheAssemblerCorrectlyWritesTheIsUseOriginalPLLineAssignmentsAttributeValueWhenSetToTrue()
        {
            assembler = new DamMStabAssembler();
            damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.GeometryCreationOptions.IsUseOriginalPlLineAssignments = true;
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var modelElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementGeometryCreationOptions);
            Assert.IsNotNull(modelElement);

            const string expectedValue = "true";
            Assert.AreEqual(expectedValue, modelElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeIsUseOriginalPLLineAssignments));
        }

        /// <summary>
        /// IsUseOriginalCalculationOptions test
        /// The key value pair for the attribute should be: IsUseOriginalCalculationOptions="true" 
        /// </summary>
        [Test]
        public void VerifyThatTheAssemblerCorrectlyWritesTheIsUseOriginalCalculationOptionsAttributeValueWhenSetToTrue()
        {
            assembler = new DamMStabAssembler();
            damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.GeometryCreationOptions.IsUseOriginalCalculationOptions = true;
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var modelElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementGeometryCreationOptions);
            Assert.IsNotNull(modelElement);

            const string expectedValue = "true";
            Assert.AreEqual(expectedValue, modelElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeIsUseOriginalCalculationOptions));
        }

        /// <summary>
        /// IsDrySituation test
        /// The key value pair for the attribute should be: IsDrySituation="true" 
        /// </summary>
        [Test]
        public void VerifyThatTheAssemblerCorrectlyWritesTheIsDrySituationAttributeValueWhenSetToTrue()
        {
            assembler = new DamMStabAssembler();
            damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.GeometryCreationOptions.IsDrySituation = true;
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var modelElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementGeometryCreationOptions);
            Assert.IsNotNull(modelElement);

            const string expectedValue = "true";
            Assert.AreEqual(expectedValue, modelElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeIsDrySituation));
        }

        /// <summary>
        /// IsDesign test
        /// The key value pair for the attribute should be: IsDesign="true" 
        /// </summary>
        [Test]
        public void VerifyThatTheAssemblerCorrectlyWritesTheIsDesignAttributeValueWhenSetToTrue()
        {
            assembler = new DamMStabAssembler();
            damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.GeometryCreationOptions.IsDesign = true;
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var modelElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementGeometryCreationOptions);
            Assert.IsNotNull(modelElement);

            const string expectedValue = "true";
            Assert.AreEqual(expectedValue, modelElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeIsDesign));
        }


        /// <summary>
        /// Sheetpiling
        /// </summary>
        [Test]
        public void VerifyThatElementSheetPilingIsNotWrittenByDefault()
        {
            damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.SheetPiling = null;
            assembler = new DamMStabAssembler();
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var sheetPilingElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementSheetPiling);
            Assert.IsNull(sheetPilingElement);
        }

        /// <summary>
        /// Sheetpiling
        /// </summary>
        [Test]
        public void VerifyThatElementSheetPilingIsWrittenWhenSet()
        {
            assembler = new DamMStabAssembler();
            damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.SheetPiling = sheetPiling;
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementSheetPiling);
            Assert.IsNotNull(element);
            Assert.AreEqual(1, element.Attributes("XCoordinate").Count());
            Assert.AreEqual(1, element.Attributes("YCoordinate").Count());
            Assert.AreEqual(1, element.Attributes("ZCoordinate").Count());
            Assert.AreEqual(1, element.Attributes("Length").Count());
        }

        /// <summary>
        /// Horizontal Balance Area
        /// </summary>
        [Test]
        public void VerifyThatElementHorizontalBalanceAreaIsNotWrittenByDefault()
        {
            damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.HorizontalBalanceArea = null;
            assembler = new DamMStabAssembler();
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var horizontalBalanceAreaElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementHorizontalBalanceArea);
            Assert.IsNull(horizontalBalanceAreaElement);
        }

        /// <summary>
        /// Horizontal Balance Area
        /// </summary>
        [Test]
        public void VerifyThatElementHorizontalBalanceAreaIsWrittenWhenSet()
        {
            assembler = new DamMStabAssembler();
            damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.HorizontalBalanceArea = horizontalBalanceArea;
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementHorizontalBalanceArea);
            Assert.IsNotNull(element);
            Assert.AreEqual(1, element.Attributes("XLeft").Count());
            Assert.AreEqual(1, element.Attributes("XRight").Count());
            Assert.AreEqual(1, element.Attributes("YTop").Count());
            Assert.AreEqual(1, element.Attributes("YBottom").Count());
            Assert.AreEqual(1, element.Attributes("PlaneCount").Count());
        }

        /// <summary>
        /// SlipCircleDefinition
        /// </summary>
        [Test]
        public void VerifyThatElementSlipCircleDefinitionIsNotWrittenByDefault()
        {
            damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.SlipCircleDefinition = null;
            assembler = new DamMStabAssembler();
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var slipCircledefinitionElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementSlipCircleDefinition);
            Assert.IsNull(slipCircledefinitionElement);
        }

        /// <summary>
        /// SlipCircleDefinition
        /// </summary>
        [Test]
        public void VerifyThatElementSlipCircleDefinitionIsWrittenWhenSet()
        {
            assembler = new DamMStabAssembler();
            damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab.MStabParameters.SlipCircleDefinition = slipCircleDefinition;
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementSlipCircleDefinition);
            Assert.IsNotNull(element);
            Assert.AreEqual(1, element.Attributes("XCoordinateLastUpliftPoint").Count());
            Assert.AreEqual(1, element.Attributes("UpliftVanTangentLinesDefinition").Count());
            Assert.AreEqual(1, element.Attributes("GridSizeDetermination").Count());
            Assert.AreEqual(1, element.Attributes("UpliftVanLeftGridVerticalPointCount").Count());
            Assert.AreEqual(1, element.Attributes("UpliftVanLeftGridVerticalPointDistance").Count());
            Assert.AreEqual(1, element.Attributes("UpliftVanLeftGridHorizontalPointCount").Count());
            Assert.AreEqual(1, element.Attributes("UpliftVanLeftGridHorizontalPointDistance").Count());
            Assert.AreEqual(1, element.Attributes("UpliftVanRightGridVerticalPointCount").Count());
            Assert.AreEqual(1, element.Attributes("UpliftVanRightGridVerticalPointDistance").Count());
            Assert.AreEqual(1, element.Attributes("UpliftVanRightGridHorizontalPointCount").Count());
            Assert.AreEqual(1, element.Attributes("UpliftVanRightGridHorizontalPointDistance").Count());
            Assert.AreEqual(1, element.Attributes("BishopGridVerticalPointCount").Count());
            Assert.AreEqual(1, element.Attributes("BishopGridVerticalPointDistance").Count());
            Assert.AreEqual(1, element.Attributes("BishopGridHorizontalPointCount").Count());
            Assert.AreEqual(1, element.Attributes("BishopGridHorizontalPointDistance").Count());
        }

        /// <summary>
        /// Characteristic points
        /// </summary>
        [Test]
        public void VerifyThatCharacteristicPointsAreWritten()
        {
            assembler = new DamMStabAssembler();
            surfaceLine1.EnsurePointOfType(30, 1.0, CharacteristicPointType.DikeToeAtRiver);
            surfaceLine1.EnsurePointOfType(35, 11.0, CharacteristicPointType.DikeTopAtRiver);
            surfaceLine1.EnsurePointOfType(40, 12.0, CharacteristicPointType.DikeTopAtPolder);
            surfaceLine1.EnsurePointOfType(45, 2.0, CharacteristicPointType.DikeToeAtPolder);
            var doc = assembler.CreateDataTransferObject(damFailureMechanismeCalculationSpecification.FailureMechanismParametersMStab);
            var element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementCharacteristicPoints);
            Assert.IsNotNull(element);

            element = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementCharacteristicPoint);
            Assert.IsNotNull(element);
            Assert.AreEqual(1, element.Attributes("XCoord").Count());
            Assert.AreEqual(1, element.Attributes("YCoord").Count());
            Assert.AreEqual(1, element.Attributes("CharacteristicPointType").Count());
        }

    }
}