//-----------------------------------------------------------------------
// <copyright file="DamMStabAssemblerTest.cs" company="Deltares">
//  Copyright (c) 2010 Deltares. All rights reserved.
// </copyright>
// <author>B.S.T.I.M. The</author>
// <email>tom.the@deltares.nl</email>
// <date>18-05-2010</date>
// <summary>Contains tests for xml file creator for DGSMStabDam.dll</summary>
//-----------------------------------------------------------------------


using Deltares.Geometry;
using Deltares.Geotechnics.GeotechnicalGeometry;
using Deltares.Standard.IO.DtoAssembler;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Xml.Linq;
using Deltares.Dam.Data;
using Deltares.Dam.Data.Assemblers;

using NUnit.Framework;
using Deltares.Geotechnics;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;

namespace Deltares.Dam.Tests
{
    [TestFixture]
    public class DamMStabAssemblerTest
    {
        #region Setup/Teardown

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

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

            // Segments
            this.segment1 = new Dam.Data.Segment();
            this.segment1.Name = "Segment1";
            //this.dike.Segments.Add(this.segment1);

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

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

            // Soil profiles
            this.soilProfile1 = new SoilProfile1D();
            this.soilProfile1.Name = "SoilProfile1";
            this.soilProfile1.X = 34534.34;
            this.soilProfile1.Y = 49453.68;
            this.soilProfile1.BottomLevel = -25.3;
            this.soilProfile1.HasPhreaticLevel = true;
            this.soilProfile1.PhreaticLevel = -3.54;
            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.Id = "L1";
            layer.Name = "Layer 1";
            layer.TopLevel = -1.52;
            layer.Soil = soilClay;
            layer.IsAquifer = false;
            this.soilProfile1.Layers.Add(layer);
            layer = new SoilLayer1D();
            layer.Id = "L2";
            layer.Name = "Layer 2";
            layer.TopLevel = -3.18;
            layer.Soil = soilPeat;
            layer.IsAquifer = false;
            this.soilProfile1.Layers.Add(layer);
            layer = new SoilLayer1D();
            layer.Id = "L3";
            layer.Name = "Layer 3";
            layer.TopLevel = -7.37;
            layer.Soil = soilSand;
            layer.IsAquifer = true;
            this.soilProfile1.Layers.Add(layer);
            layer = new SoilLayer1D();
            layer.Id = "L4";
            layer.Name = "Layer 4";
            layer.TopLevel = -12.28;
            layer.Soil = soilPeat;
            layer.IsAquifer = false;
            this.soilProfile1.Layers.Add(layer);
            layer = new SoilLayer1D();
            layer.Id = "L5";
            layer.Name = "Layer 5";
            layer.TopLevel = -15.62;
            layer.Soil = soilClay;
            layer.IsAquifer = false;
            this.soilProfile1.Layers.Add(layer);
            layer = new SoilLayer1D();
            layer.Id = "L6";
            layer.Name = "Layer 6";
            layer.TopLevel = -18.39;
            layer.Soil = soilSand;
            layer.IsAquifer = true;
            this.soilProfile1.Layers.Add(layer);
            this.dike.SoilProfiles.Add(this.soilProfile1);

            // Locations' Segments
            this.location1.Segment = this.segment1;

            // Locations' surface lines
            this.location1.SurfaceLine2 = this.surfaceLine1;

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

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

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

            // PL Lines
            this.peelLines = new PLLines();
            this.peelLine1 = new PLLine();
            this.peelLine1.Name = "PLLine1";
            this.peelLine1.IsPhreatic = false;
            this.peelLine1.BoundaryLayer = 2;
            this.peelLine1.Points.Add(new PLLinePoint(35.2, -7.56));
            this.peelLine1.Points.Add(new PLLinePoint(42.5, -6.12));
            this.peelLine1.Points.Add(new PLLinePoint(45.3, -8.73));
            this.peelLines.Lines[PLLineType.PL1] = this.peelLine1;
            this.peelLine2 = new PLLine();
            this.peelLine2.Name = "PLLine2";
            this.peelLine2.IsPhreatic = true;
            this.peelLine2.BoundaryLayer = 5;
            this.peelLine2.Points.Add(new PLLinePoint(16.2, 3.23));
            this.peelLine2.Points.Add(new PLLinePoint(18.4, 1.19));
            this.peelLine2.Points.Add(new PLLinePoint(21.8, -0.45));
            this.peelLine2.Points.Add(new PLLinePoint(22.5, -1.73));
            this.peelLines.Lines[PLLineType.PL1] = peelLine2;

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

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

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

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

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

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

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

        [TearDown]
        public void TearDown()
        {
            dike.Dispose();
        }

        #endregion

        private const string testDirectory = "TestResults";
        private const string testFileName = "DikeMStabAssemblerTest.xml";
        private const string testFileNameWithNullLayerIDs = "DikeMStabAssemblerTestWithNullLayerIDs.xml";
        private const string testFileNameWithPLLines = "DikeMStabAssemblerTestWithPLLines.xml";

        private const double Precision = 1e-8;

        private DamFailureMechanismeCalculationSpecification damFailureMechanismeCalculationSpecification;
        private DamMStabAssembler assembler;

        private Dike dike;
        private Dam.Data.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 Deltares.Dam.Data.SheetPiling sheetPiling;
        private HorizontalBalanceArea horizontalBalanceArea;
        private MStabDesignEmbankment design;
        private SlipCircleDefinition slipCircleDefinition;

        [TestFixtureSetUp]
        public void TestFixtureSetup()
        {
        }

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

            Directory.CreateDirectory(testDirectory);
            doc.Save(Path.Combine(testDirectory, testFileName));

            // Validate against schema
            string message;
            if (!this.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(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.ProjectFileName, inputElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeMStabFileName), "SoilDB Name");
            Assert.AreEqual(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.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(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.Location.SurfaceLine2.Geometry.Count, surfacePointElements.Count(), "Number of surface line points");

            IEnumerator<XElement> surfacePointElementEnumerator = surfacePointElements.GetEnumerator();
            foreach (GeometryPoint point in this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.Location.SurfaceLine2.Geometry.Points)
            {
                surfacePointElementEnumerator.MoveNext();
                XElement surfaceLinePointElement = surfacePointElementEnumerator.Current;
                Assert.AreEqual(point.X, surfaceLinePointElement.AttributeAs<double>(DamMStabAssembler.XmlAttributeXCoord), Precision, String.Format("X of GeometryPoint #{0}", 
                    this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.Location.SurfaceLine2.Geometry.Points.IndexOf(point)));
                Assert.AreEqual(point.Z, surfaceLinePointElement.AttributeAs<double>(DamMStabAssembler.XmlAttributeYCoord), Precision, String.Format("Z of GeometryPoint #{0}",
                    this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.Location.SurfaceLine2.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(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.PLLines.PLLineCount, peelLineCollectionElements.Count(), "Number of PL lines");
            IEnumerator<XElement> peelLineElementEnumerator = peelLineCollectionElements.GetEnumerator();
            foreach (PLLineType plLineType in Enum.GetValues(typeof(PLLineType)))
            {
                PLLine line = damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.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(this.zoneAreas.DikeTableHeight, zoneAreasElement.AttributeAs<double>("DikeTableHeight"), "DikeTableHeight");
            Assert.AreEqual(this.zoneAreas.DikeTableWidth, zoneAreasElement.AttributeAs<double>("DikeTableWidth"), "DikeTableWidth");
            Assert.AreEqual(this.zoneAreas.XCoordinateDikeTopAtRiver, zoneAreasElement.AttributeAs<double>("XCoordinateDikeTopAtRiver"), "XCoordinateDikeTopAtRiver");
            Assert.AreEqual(this.zoneAreas.XCoordinateDikeTopAtPolder, zoneAreasElement.AttributeAs<double>("XCoordinateDikeTopAtPolder"), "XCoordinateDikeTopAtPolder");
            Assert.AreEqual(this.zoneAreas.XCoordinateStartRestProfile, zoneAreasElement.AttributeAs<double>("XCoordinateStartRestProfile"), "XCoordinateStartRestProfile");
            Assert.AreEqual(this.zoneAreas.SafetyFactorZone1A, zoneAreasElement.AttributeAs<double>("SafetyFactorZone1A"), "SafetyFactorZone1A");
            Assert.AreEqual(this.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(this.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(this.geometryCreationOptions.SoilGeometryType.ToString(), geometryCreationOptionsElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeSoilGeometryType), DamMStabAssembler.XmlAttributeSoilGeometryType);
            Assert.AreEqual(this.geometryCreationOptions.SoilGeometry2DFilename, 
                geometryCreationOptionsElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeSoilGeometry2DFilename), DamMStabAssembler.XmlAttributeSoilGeometry2DFilename);
            Assert.AreEqual(this.geometryCreationOptions.MaterialForDike, geometryCreationOptionsElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeMaterialForDike), DamMStabAssembler.XmlAttributeMaterialForDike);
            Assert.AreEqual(this.geometryCreationOptions.MaterialForShoulder, geometryCreationOptionsElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeMaterialForShoulder), DamMStabAssembler.XmlAttributeMaterialForShoulder);
            Assert.AreEqual(this.geometryCreationOptions.IsUseOriginalPLLineAssignments, geometryCreationOptionsElement.AttributeAs<bool>(DamMStabAssembler.XmlAttributeIsUseOriginalPLLineAssignments), DamMStabAssembler.XmlAttributeIsUseOriginalPLLineAssignments);
            Assert.AreEqual(this.geometryCreationOptions.IsUseOriginalCalculationOptions, geometryCreationOptionsElement.AttributeAs<bool>(DamMStabAssembler.XmlAttributeIsUseOriginalCalculationOptions), DamMStabAssembler.XmlAttributeIsUseOriginalCalculationOptions);
            Assert.AreEqual(this.geometryCreationOptions.IsDrySituation, geometryCreationOptionsElement.AttributeAs<bool>(DamMStabAssembler.XmlAttributeIsDrySituation), DamMStabAssembler.XmlAttributeIsDrySituation);
            Assert.AreEqual(this.geometryCreationOptions.IsDesign, geometryCreationOptionsElement.AttributeAs<bool>(DamMStabAssembler.XmlAttributeIsDesign), DamMStabAssembler.XmlAttributeIsDesign);
            Assert.AreEqual(this.geometryCreationOptions.PLLineAssignment, geometryCreationOptionsElement.AttributeAs<PLLineAssignment>(DamMStabAssembler.XmlAttributePLLineAssignment), DamMStabAssembler.XmlAttributePLLineAssignment);
            Assert.AreEqual(this.geometryCreationOptions.IntrusionVerticalWaterPressureType, geometryCreationOptionsElement.AttributeAs<IntrusionVerticalWaterPressureType>(DamMStabAssembler.XmlAttributeIntrusionVerticalWaterPressure), DamMStabAssembler.XmlAttributeIntrusionVerticalWaterPressure);
            Assert.AreEqual(this.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(this.design.EmbankmentMaterialname.ToString(),
                                designElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeEmbankmentMaterialName),
                                DamMStabAssembler.XmlAttributeEmbankmentMaterialName);
            Assert.AreEqual(this.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.FailureMechanismeParamatersMStab.SoilProfile.Name, soilProfileElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeName), String.Format("{0}", DamMStabAssembler.XmlAttributeName));
            Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeXCoordinate), String.Format("{0}", DamMStabAssembler.XmlAttributeXCoordinate));
            Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.SoilProfile.X, soilProfileElement.AttributeAs<double>(DamMStabAssembler.XmlAttributeXCoordinate), Precision, String.Format("{0}", DamMStabAssembler.XmlAttributeXCoordinate));
            Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeYCoordinate), String.Format("{0}", DamMStabAssembler.XmlAttributeYCoordinate));
            Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.SoilProfile.Y, soilProfileElement.AttributeAs<double>(DamMStabAssembler.XmlAttributeYCoordinate), Precision, String.Format("{0}", DamMStabAssembler.XmlAttributeYCoordinate));
            Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributePhreaticLevel), String.Format("{0}", DamMStabAssembler.XmlAttributePhreaticLevel));
            Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.SoilProfile.PhreaticLevel, soilProfileElement.AttributeAs<double>(DamMStabAssembler.XmlAttributePhreaticLevel), Precision, String.Format("{0}", DamMStabAssembler.XmlAttributePhreaticLevel));
            Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeHasPhreaticLevel), String.Format("{0}", DamMStabAssembler.XmlAttributeHasPhreaticLevel));
            Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.SoilProfile.HasPhreaticLevel, soilProfileElement.AttributeAs<bool>(DamMStabAssembler.XmlAttributeHasPhreaticLevel), String.Format("{0}", DamMStabAssembler.XmlAttributeHasPhreaticLevel));
            Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeBottomLevel), String.Format("{0}", DamMStabAssembler.XmlAttributeBottomLevel));
            Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.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.FailureMechanismeParamatersMStab.SoilProfile.Layers.Count, layerCollectionElements.Count(), "Number of profile layers");

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

        }

        [Test]
        public void CanCreateAndValidateMStabInputXMLWithNullLayerIDs()
        {
            foreach (SoilLayer1D layer in this.soilProfile1.Layers)
            {
                layer.Id = null;
            }

            // Do the thing: create XML element from SoilProfile
            var doc = this.assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);

            Directory.CreateDirectory(testDirectory);
            doc.Save(Path.Combine(testDirectory, testFileNameWithNullLayerIDs));

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

        [Test]
        public void CanCreateAndValidateMStabInputXMLWithPLLines()
        {
            // Create PL lines
            using (var location = new Location { DamType = DamType.Regional })
            {
                PLLinesCreator plLineCreator = new PLLinesCreator();
                plLineCreator.SoilProfile = this.soilProfile1;
                plLineCreator.SurfaceLine = this.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 = this.assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);

                Directory.CreateDirectory(testDirectory);
                doc.Save(Path.Combine(testDirectory, testFileNameWithPLLines));

                // Validate against schema
                string message;
                if (!this.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();

                // Created PL lines so characteristic layers should be assigned
                Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeBottomSandLayerID), DamMStabAssembler.XmlAttributeBottomSandLayerID);
                Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.SoilProfile.BottomAquiferLayer.Id, soilProfileElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeBottomSandLayerID),
                                DamMStabAssembler.XmlAttributeBottomSandLayerID);
                Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeInBetweenSandLayerID), DamMStabAssembler.XmlAttributeInBetweenSandLayerID);
                Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.SoilProfile.InBetweenAquiferLayer.Id, soilProfileElement.AttributeAs<string>(DamMStabAssembler.XmlAttributeInBetweenSandLayerID),
                                DamMStabAssembler.XmlAttributeInBetweenSandLayerID);
                Assert.IsNotNull(soilProfileElement.Attribute(DamMStabAssembler.XmlAttributeInfiltrationLayerID), DamMStabAssembler.XmlAttributeInfiltrationLayerID);
                Assert.AreEqual(damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.SoilProfile.InfiltrationLayer.Id, 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(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            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();
            this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.SearchMethod = MStabSearchMethod.Grid;
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            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.FailureMechanismeParamatersMStab.MStabParameters.CalculationOptions.ZonesType = MStabZonesType.ZoneAreas;

            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            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.FailureMechanismeParamatersMStab.MStabParameters.ZoneAreas = new MStabZoneAreas { };
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            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.FailureMechanismeParamatersMStab.MStabParameters.ZoneAreas = null;
            assembler = new DamMStabAssembler();
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            var modelElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementZoneAreas);
            Assert.IsNull(modelElement);
        }

        /// <summary>
        /// ZoneAreas
        /// </summary>
        [Test]
        public void VerifyThatElementForbiddenZoneIsWrittenWhenSet()
        {
            assembler = new DamMStabAssembler();
            damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.ForbiddenZone = new MStabForbiddenZone() { };
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            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.FailureMechanismeParamatersMStab.MStabParameters.ZoneAreas = null;
            assembler = new DamMStabAssembler();
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            var modelElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementForbiddenZone);
            Assert.IsNull(modelElement);
        }

        /// <summary>
        /// Traffic Load
        /// </summary>
        [Test]
        public void VerifyThatElementTrafficLoadIsWrittenWhenSet()
        {
            assembler = new DamMStabAssembler();
            this.surfaceLine1.EnsurePointOfType(30.1, 8.56, CharacteristicPointType.TrafficLoadOutside);
            this.surfaceLine1.EnsurePointOfType(31.2, 8.62, CharacteristicPointType.TrafficLoadInside);
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            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(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            var trafficLoadElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementTrafficLoad);
            Assert.IsNull(trafficLoadElement);
        }

        /// <summary>
        /// Calculation options
        /// </summary>
        [Test]
        public void VerifyThatElementCalculationOptionsIsWrittenWhenSet()
        {
            damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.CalculationOptions = new MStabCalculationOptions();
            assembler = new DamMStabAssembler();
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            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.FailureMechanismeParamatersMStab.MStabParameters.CalculationOptions = null;
            assembler = new DamMStabAssembler();
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            var calculationOptionsElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementCalculationOptions);
            Assert.IsNull(calculationOptionsElement);
        }

        /// <summary>
        /// Geometry Creation Options 
        /// </summary>
        [Test]
        public void VerifyThatElementGeometryCreationOptionsIsWrittenWhenSet()
        {
            assembler = new DamMStabAssembler();
            damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions = this.geometryCreationOptions;
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            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.FailureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions = null;
            assembler = new DamMStabAssembler();
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            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();
            this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions.IsUseOriginalPLLineAssignments = true;
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            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();
            this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions.IsUseOriginalCalculationOptions = true;
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            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();
            this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions.IsDrySituation = true;
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            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();
            this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.GeometryCreationOptions.IsDesign = true;
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            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.FailureMechanismeParamatersMStab.MStabParameters.SheetPiling = null;
            assembler = new DamMStabAssembler();
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            var sheetPilingElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementSheetPiling);
            Assert.IsNull(sheetPilingElement);
        }

        /// <summary>
        /// Sheetpiling
        /// </summary>
        [Test]
        public void VerifyThatElementSheetPilingIsWrittenWhenSet()
        {
            assembler = new DamMStabAssembler();
            damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.SheetPiling = this.sheetPiling;
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            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.FailureMechanismeParamatersMStab.MStabParameters.HorizontalBalanceArea = null;
            assembler = new DamMStabAssembler();
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            var horizontalBalanceAreaElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementHorizontalBalanceArea);
            Assert.IsNull(horizontalBalanceAreaElement);
        }

        /// <summary>
        /// Horizontal Balance Area
        /// </summary>
        [Test]
        public void VerifyThatElementHorizontalBalanceAreaIsWrittenWhenSet()
        {
            assembler = new DamMStabAssembler();
            damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.HorizontalBalanceArea = this.horizontalBalanceArea;
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            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.FailureMechanismeParamatersMStab.MStabParameters.SlipCircleDefinition = null;
            assembler = new DamMStabAssembler();
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            var slipCircledefinitionElement = doc.GetFirstOrDefaultElementByLocalName(DamMStabAssembler.XmlElementSlipCircleDefinition);
            Assert.IsNull(slipCircledefinitionElement);
        }

        /// <summary>
        /// SlipCircleDefinition
        /// </summary>
        [Test]
        public void VerifyThatElementSlipCircleDefinitionIsWrittenWhenSet()
        {
            assembler = new DamMStabAssembler();
            damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab.MStabParameters.SlipCircleDefinition = this.slipCircleDefinition;
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            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();
            this.surfaceLine1.EnsurePointOfType(30, 1.0, CharacteristicPointType.DikeToeAtRiver);
            this.surfaceLine1.EnsurePointOfType(35, 11.0, CharacteristicPointType.DikeTopAtRiver);
            this.surfaceLine1.EnsurePointOfType(40, 12.0, CharacteristicPointType.DikeTopAtPolder);
            this.surfaceLine1.EnsurePointOfType(45, 2.0, CharacteristicPointType.DikeToeAtPolder);
            var doc = assembler.CreateDataTransferObject(this.damFailureMechanismeCalculationSpecification.FailureMechanismeParamatersMStab);
            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());
        }

    }
}