// Copyright (C) Stichting Deltares 2018. All rights reserved.
//
// This file is part of the application DAM - UI.
//
// DAM - UI is free software: you can redistribute it and/or modify
// it under the terms of the GNU 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 General Public License for more details.
//
// You should have received a copy of the GNU 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.Collections.Generic;
using System.IO;
using System.Linq;
using Deltares.Dam.Data;
using Deltares.Dam.Data.DataPlugins;
using Deltares.Dam.Data.DataPlugins.Configuration;
using Deltares.Dam.Data.Importers;
using Deltares.Standard.Language;
using Deltares.Standard.TestUtils;

using NUnit.Framework;

namespace Deltares.Dam.Tests
{
    [TestFixture]
    public class DataPluginImporterTests
    {
        private string tmpTestFolder;

        [TestFixtureSetUp]
        public void FixtureSetup()
        {
            tmpTestFolder = Path.Combine(Directory.GetCurrentDirectory(), "TmpDataPluginImporterTests");
            if (!Directory.Exists(tmpTestFolder))
                Directory.CreateDirectory(tmpTestFolder);
        }

        [TestFixtureTearDown]
        public void FixtureTearDown()
        {
            if (Directory.Exists(tmpTestFolder))
                Directory.Delete(tmpTestFolder, true);
        }

        const string directoryWithCsvFiles = @"..\..\..\data\Dam\Waterboards\Groot Salland\Binnenwaarts\";

        //Project Invoer1 uses both a locations.csv and a cross section shapefile
        const string invoer1DirectoryWithCsvFiles = @"..\..\..\data\DamEngineTestProjects\Invoer1\STBI - toDesign\csvfiles\";
        const string invoer1DirectoryWithDataShapeFiles = @"..\..\..\data\DamEngineTestProjects\Invoer1\STBI - toDesign\shapefiles\";
        private const string Location1Id = "RK210-560";
        private const string Location2Id = "RK210-570";

        List<DataSource> srcDataSources;
        DataPluginImporter dataPluginImporter;

        private void SetupInvoer1WithShapeFiles()
        {
            srcDataSources = new List<DataSource>
            {
                new DataSource
                {
                    DataSourceType = DataSourceType.CsvFiles,
                    DataLocation = invoer1DirectoryWithCsvFiles
                },
                new DataSource
                {
                    DataSourceType = DataSourceType.DataShapeFiles,
                    DataLocation = invoer1DirectoryWithDataShapeFiles
                }
            };
            dataPluginImporter = new DataPluginImporter
            {
                Attributes = new[]
                {
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.LocationAttributeId,
                        AttributeName = "LocationId",
                        DataSource = "Locationv2.shp"
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.DikeRingAttributeId,
                        AttributeName = "DIKERINGID",
                        DataSource = "Locationv2.shp"
                    },
                    // Head Pl2 will be put in location, Head Pl3 will be put in scenario if not already imported from scenarios.csv
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.HeadPl3AttributeId,
                        AttributeName = "stijgh_m",
                        DataSource = "winterstijg_zonderDSM.shp"
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.HeadPl2AttributeId,
                        AttributeName = "PLHIGH",
                        DataSource = "Polderpeilen.shp"
                    },
                }
            };

            dataPluginImporter.SetDataSources("", srcDataSources);

        }

        private void SetupInvoer1WithoutShapeFiles()
        {
            srcDataSources = new List<DataSource>
            {
                new DataSource
                {
                    DataSourceType = DataSourceType.CsvFiles,
                    DataLocation = invoer1DirectoryWithCsvFiles
                },
            };
            dataPluginImporter = new DataPluginImporter();
            dataPluginImporter.SetDataSources("", srcDataSources);
        }

        private const string HemPolderLocationId1 = "TPL_Hempolder_0010";
        private const string HemPolderLocationId2 = "TPL_Hempolder_0020";
        private void SetupInvoerHemPolderWithShapeFiles(string folder, string shapefile)
        {
            srcDataSources = new List<DataSource>
            {
                new DataSource
                {
                    DataSourceType = DataSourceType.CsvFiles,
                    DataLocation = folder
                },
                new DataSource
                {
                    DataSourceType = DataSourceType.DataShapeFiles,
                    DataLocation = folder
                }
            };
            dataPluginImporter = new DataPluginImporter
            {
                Attributes = new[]
                {
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.LocationAttributeId,
                        AttributeName = "LocationId",
                        DataSource = "Locations.shp"
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.DikeRingAttributeId,
                        AttributeName = "DikeRingId",
                        DataSource = "Locations.shp"
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.HeadPl3AttributeId,
                        AttributeName = "HEADPL3",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.HeadPl4AttributeId,
                        AttributeName = "HEADPL4",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.PlLineOffsetBelowDikeTopAtRiverAttributeId,
                        AttributeName = "PLOBDTOPR",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.PlLineOffsetBelowDikeTopAtPolderAttributeId,
                        AttributeName = "PLOBDTOPP",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.PlLineOffsetBelowShoulderBaseInsideAttributeId,
                        AttributeName = "PLOBSB",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.PlLineOffsetBelowDikeToeAtPolderAttributeId,
                        AttributeName = "PLOBDTOEP",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.UsePlLineOffsetBelowDikeCrestMiddleAttributeId,
                        AttributeName = "USEPLOBDCM",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.PlLineOffsetBelowDikeCrestMiddleAttributeId,
                        AttributeName = "PLOBDCM",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.UsePlLineOffsetFactorBelowShoulderCrestAttributeId,
                        AttributeName = "USEPLOFBSC",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.PlLineOffsetFactorBelowShoulderCrestAttributeId,
                        AttributeName = "PLOFBSC",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.UpliftCriterionStabilityAttributeId,
                        AttributeName = "UPLSTAB",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.UpliftCriterionPipingAttributeId,
                        AttributeName = "UPLPIPING",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.DikeTableHeightAttributeId,
                        AttributeName = "DTH",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.RiverLevelAttributeId,
                        AttributeName = "WHEIGHT",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.RiverLevelLowAttributeId,
                        AttributeName = "WHEIGHTLOW",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.RequiredSafetyFactorPipingAttributeId,
                        AttributeName = "FPIPING",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.RequiredSafetyFactorStabilityInnerSlopeAttributeId,
                        AttributeName = "FSTABIN",
                        DataSource = shapefile
                    },
                    new DataAttribute
                    {
                        AttributeId = LocationShapeFileAttributeMap.RequiredSafetyFactorStabilityOuterSlopeAttributeId,
                        AttributeName = "FSTABOUT",
                        DataSource = shapefile
                    },
                }
            };
            dataPluginImporter.SetDataSources("", srcDataSources);
        }
        private void SetupInvoerHemPolderWithoutShapeFiles(string folder)
        {
            srcDataSources = new List<DataSource>
            {
                new DataSource
                {
                    DataSourceType = DataSourceType.CsvFiles,
                    DataLocation = folder
                },
            };
            dataPluginImporter = new DataPluginImporter();
            dataPluginImporter.SetDataSources("", srcDataSources);
        }

        [Test]
        public void CanDefineDataSources()
        {
            var srcDataSources = new List<DataSource>();
            var dataPluginImporter = new DataPluginImporter();

            srcDataSources.Add(new DataSource
                                 {
                                     DataSourceType = DataSourceType.CsvFiles,
                                     DataLocation = directoryWithCsvFiles
                                 });
            dataPluginImporter.SetDataSources("", srcDataSources);
            //var destDataSources = dataPluginImporter.DataSources.ToList();
            var destDataSources = dataPluginImporter.DataSources.ToList();
            Assert.AreEqual(srcDataSources.Count, destDataSources.Count());
            Assert.IsTrue(srcDataSources[0].Equals(destDataSources.FirstOrDefault()));
        }

        [Test]
        [ExpectedException(typeof(DataPluginImporterException))]
        public void ThrowsExceptionWhenRequestingDataWhenDataSourcesNotDefined()
        {
            var dataPluginImporter = new DataPluginImporter();
            var info  = dataPluginImporter.WaterBoardInfo;
            Assert.IsNotNull(info);
        }

        [Test]
        [Category(Categories.Slow)]
        public void CanRetrieveWaterboardInfo()
        {
            var srcDataSources = new List<DataSource>
                    {
                        new DataSource
                            {
                                DataSourceType = DataSourceType.CsvFiles,
                                DataLocation = directoryWithCsvFiles
                            }
                    };
            var dataPluginImporter = new DataPluginImporter();
            dataPluginImporter.SetDataSources("", srcDataSources);
            dataPluginImporter.ImportDataForDikeRings(null, null);

            var info = dataPluginImporter.WaterBoardInfo;
            if (LocalizationManager.CurrentLanguage == LanguageType.Dutch)
            {
                Assert.AreEqual("Waterschap", info.Name);
            }
            else
            {
                Assert.AreEqual("WaterBoard", info.Name);
            }
            Assert.AreEqual("Waterschap", info.Description);
        }

        /// <summary>
        /// Some parameters for location can be read from either locations.csv or shapefile
        /// The value from shapefile overwrites the value from locations.csv
        /// In this test the values for headpl2 in the import files are:
        /// In shapefiles: -5.37 for both locations
        /// In locations.csv: -99 for both locations
        /// Expected value in location will be -5.37 for both locations
        /// </summary>
        [Test]
        public void ValuesFromShapeFileOverwriteValuesFromLocationsCsv()
        {
            SetupInvoer1WithShapeFiles();
            string dikeRingId = dataPluginImporter.GetDikeRingIdList().FirstOrDefault();
            dataPluginImporter.ImportDataForDikeRings(new List<string> { dikeRingId }, null);

            IEnumerable<NameValueParameter> locationDetails = dataPluginImporter.GetLocationDetails(dikeRingId, Location1Id);
            var nameValueParameters = locationDetails as NameValueParameter[] ?? locationDetails.ToArray();
            Assert.IsTrue(nameValueParameters.Any());
            Assert.AreEqual("-5.37", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL2")).ParameterValue);

            locationDetails = dataPluginImporter.GetLocationDetails(dikeRingId, Location2Id);
            Assert.AreEqual("-5.37", locationDetails.First(x => x.ParameterName.Equals("HeadPL2")).ParameterValue);
        }

        /// <summary>
        /// Some parameters for scenario can be read from either locations.csv, shapefile or scenarios.csv
        /// The value from scenarios.csv overwrites the value from shapefile, which overwrites the value from locations.csv
        /// In this test the values for headpl3 in the import files are:
        /// In scenarios.csv: not defined
        /// In shapefiles: not defined
        /// In locations.csv: -99 for both locations
        /// Expected value in scenario will be -99
        /// </summary>
        [Test]
        public void ValuesFromLocationsCsvAreCopiedToScenarioIfNotDefinedInScenariosCsvOrShapeFile()
        {
            SetupInvoer1WithoutShapeFiles();
            string dikeRingId = dataPluginImporter.GetDikeRingIdList().FirstOrDefault();
            dataPluginImporter.ImportDataForDikeRings(new List<string> { dikeRingId }, null);
        
            string scenarioId = dataPluginImporter.GetScenarioList(dikeRingId, Location1Id).FirstOrDefault();
            IEnumerable<NameValueParameter> scenarioDetails = dataPluginImporter.GetScenarioDetails(dikeRingId, Location1Id, scenarioId);
            var nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.IsTrue(nameValueParameters.Any());
            Assert.AreEqual("-99", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue);
        
            scenarioDetails = dataPluginImporter.GetScenarioDetails(dikeRingId, Location2Id, scenarioId);
            Assert.AreEqual("-99", scenarioDetails.First(x => x.ParameterName.Equals("HeadPL3")).ParameterValue);
        }

        /// <summary>
        /// Some parameters for scenario can be read from either locations.csv, shapefile or scenarios.csv
        /// The value from scenarios.csv overwrites the value from shapefile, which overwrites the value from locations.csv
        /// In this test the values for headpl3 in the import files are:
        /// In scenarios.csv: not defined
        /// In shapefiles: -3.651 for location 1, -3.632 for location 2
        /// In locations.csv: -99 for both locations
        /// Expected value in scenario will be -3.651 for location 1, -3.632 for location 2
        /// </summary>
        [Test]
        public void ValuesFromShapeFileAreCopiedToScenarioIfNotDefinedInScenariosCsv()
        {
            SetupInvoer1WithShapeFiles();
            string dikeRingId = dataPluginImporter.GetDikeRingIdList().FirstOrDefault();
            dataPluginImporter.ImportDataForDikeRings(new List<string> { dikeRingId }, null);
        
            string scenarioId = dataPluginImporter.GetScenarioList(dikeRingId, Location1Id).FirstOrDefault();
            IEnumerable<NameValueParameter> scenarioDetails = dataPluginImporter.GetScenarioDetails(dikeRingId, Location1Id, scenarioId);
            var nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.IsTrue(nameValueParameters.Any());
            Assert.AreEqual("-3.651", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue);
        
            scenarioDetails = dataPluginImporter.GetScenarioDetails(dikeRingId, Location2Id, scenarioId);
            Assert.AreEqual("-3.632", scenarioDetails.First(x => x.ParameterName.Equals("HeadPL3")).ParameterValue);
        }

        private void CreateBasicDataFiles(string importFolder)
        {
            var importFile = importFolder + "\\characteristicpoints.csv";
            if (File.Exists(importFile))
                File.Delete(importFile);
            using (var writer = File.CreateText(importFile))
            {
                writer.WriteLine("LOCATIONID;X_Maaiveld binnenwaarts;Y_Maaiveld binnenwaarts;Z_Maaiveld binnenwaarts;X_Insteek sloot polderzijde;Y_Insteek sloot polderzijde;Z_Insteek sloot polderzijde;X_Slootbodem polderzijde;Y_Slootbodem polderzijde;Z_Slootbodem polderzijde;X_Slootbodem dijkzijde;Y_Slootbodem dijkzijde;Z_Slootbodem dijkzijde;X_Insteek sloot dijkzijde;Y_Insteek_sloot dijkzijde;Z_Insteek sloot dijkzijde;X_Teen dijk binnenwaarts;Y_Teen dijk binnenwaarts;Z_Teen dijk binnenwaarts;X_Kruin binnenberm;Y_Kruin binnenberm;Z_Kruin binnenberm;X_Insteek binnenberm;Y_Insteek binnenberm;Z_Insteek binnenberm;X_Kruin binnentalud;Y_Kruin binnentalud;Z_Kruin binnentalud;X_Verkeersbelasting kant binnenwaarts;Y_Verkeersbelasting kant binnenwaarts;Z_Verkeersbelasting kant binnenwaarts;X_Verkeersbelasting kant buitenwaarts;Y_Verkeersbelasting kant buitenwaarts;Z_Verkeersbelasting kant buitenwaarts;X_Kruin buitentalud;Y_Kruin buitentalud;Z_Kruin buitentalud;X_Insteek buitenberm;Y_Insteek buitenberm;Z_Insteek buitenberm;X_Kruin buitenberm;Y_Kruin buitenberm;Z_Kruin buitenberm;X_Teen dijk buitenwaarts;Y_Teen dijk buitenwaarts;Z_Teen dijk buitenwaarts;X_Insteek geul;Y_Insteek geul;Z_Insteek geul;X_Teen geul;Y_Teen geul;Z_Teen geul;X_Maaiveld buitenwaarts;Y_Maaiveld buitenwaarts;Z_Maaiveld buitenwaarts");
            }
            importFile = importFolder + "\\segments.csv";
            if (File.Exists(importFile))
                File.Delete(importFile);
            using (var writer = File.CreateText(importFile))
            {
                writer.WriteLine("segment_id;soilprofile_id;probability;calculation_type");
            }
            importFile = importFolder + "\\soilprofiles.csv";
            if (File.Exists(importFile))
                File.Delete(importFile);
            using (var writer = File.CreateText(importFile))
            {
                writer.WriteLine("soilprofile_id;top_level;soil_name");
            }
            importFile = importFolder + "\\surfacelines.csv";
            if (File.Exists(importFile))
                File.Delete(importFile);
            using (var writer = File.CreateText(importFile))
            {
                writer.WriteLine("LOCATIONID;X1;Y1;Z1;.....;Xn;Yn;Zn;(Profiel)");
            }
        }

        private void CreateLocationsFileWithRiverLevel(string importFile)
        {
            // A valid locations.csv has at least 3 columns
            // Required are location_id, surfaceline_id, segment_id.
            // For the test we need dikering_id as well.
            // Include column for RiverLevel=water_height
            if (File.Exists(importFile))
                File.Delete(importFile);
            using (var writer = File.CreateText(importFile))
            {
                writer.WriteLine("location_id;dikering_id;surfaceline_id;segment_id;water_height");
                writer.WriteLine("RK210-560;Actualisatie;RK210-560;1;1.2");
                writer.WriteLine("RK210-570;Actualisatie;RK210-570;1;2.2");
            }
        }

        private void CreateLocationsFileWithoutRiverLevel(string importFile)
        {
            // A valid locations.csv has at least 3 columns
            // Required are location_id, surfaceline_id, segment_id.
            // For the test we need dikering_id as well.
            // Do NOT include column for RiverLevel=water_height
            if (File.Exists(importFile))
                File.Delete(importFile);
            using (var writer = File.CreateText(importFile))
            {
                writer.WriteLine("location_id;dikering_id;surfaceline_id;segment_id;polderlevel");
                writer.WriteLine("RK210-560;Actualisatie;RK210-560;1;1.2");
                writer.WriteLine("RK210-570;Actualisatie;RK210-570;1;2.2");
            }
        }

        private void CreateScenariosFileWithRiverLevel(string importFile)
        {
            // A valid scenarios.csv has at least 2 columns
            // Required are location_id, location_scenario_id 
            // Include column for RiverLevel=water_height
            if (File.Exists(importFile))
                File.Delete(importFile);
            using (var writer = File.CreateText(importFile))
            {
                writer.WriteLine("location_id;location_scenario_id;water_height");
                writer.WriteLine("RK210-560;1;0.1");
                writer.WriteLine("RK210-570;1;0.2");
            }
        }

        private void CreateScenariosFileWithoutRiverLevel(string importFile)
        {
            // A valid scenarios.csv has at least 2 columns
            // Required are location_id, location_scenario_id
            // Do NOT include column for RiverLevel=water_height
            if (File.Exists(importFile))
                File.Delete(importFile);
            using (var writer = File.CreateText(importFile))
            {
                writer.WriteLine("location_id;location_scenario_id");
                writer.WriteLine("RK210-560;1");
                writer.WriteLine("RK210-570;1");
            }
        }

        /// <summary>
        /// RiverLevel must be specified in locations.csv, shapefile or scenarios.csv
        /// In this test reading from shapefile is skipped, RiverLevel is defined in locations, not in scenarios
        /// </summary>
        [Test]
        public void ImportRiverLevelFromLocationsTest()
        {
            // Setup folder for situation where RiverLevel is specified in locations
            var importFolder = Path.Combine(tmpTestFolder, "TmpImportFilesRiverLevelFromLocations");
            if (!Directory.Exists(importFolder))
                Directory.CreateDirectory(importFolder);
            srcDataSources = new List<DataSource>
            {
                new DataSource
                {
                    DataSourceType = DataSourceType.CsvFiles,
                    DataLocation = importFolder
                },
            };
            // Create basic datafiles that are needed to succeed the import method
            CreateBasicDataFiles(importFolder);
            // Create locations.csv that includes RiverLevel
            string importLocationsFile = importFolder + "\\locations.csv";
            CreateLocationsFileWithRiverLevel(importLocationsFile);
            // Create scenarios.csv that does NOT include RiverLevel
            var importScenarioFile = importFolder + "\\scenarios.csv";
            CreateScenariosFileWithoutRiverLevel(importScenarioFile);

            dataPluginImporter = new DataPluginImporter();
            dataPluginImporter.SetDataSources("", srcDataSources);
            string dikeRingId = dataPluginImporter.GetDikeRingIdList().FirstOrDefault();
            dataPluginImporter.ImportDataForDikeRings(new List<string> { dikeRingId }, null);

            // Expected: The values of location are used for scenario, because it was not specified in scenarios.csv
            string scenarioId = dataPluginImporter.GetScenarioList(dikeRingId, "RK210-560").FirstOrDefault();
            IEnumerable<NameValueParameter> scenarioDetails = dataPluginImporter.GetScenarioDetails(dikeRingId, "RK210-560", scenarioId);
            var nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.AreEqual("1.2", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue);
            scenarioId = dataPluginImporter.GetScenarioList(dikeRingId, "RK210-570").FirstOrDefault();
            scenarioDetails = dataPluginImporter.GetScenarioDetails(dikeRingId, "RK210-570", scenarioId);
            nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.AreEqual("2.2", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue);
            // Expected: no error messages
            Assert.AreEqual(0, dataPluginImporter.ImportLogMessages.Count);
        }

        /// <summary>
        /// RiverLevel must be specified in locations.csv, shapefile or scenarios.csv
        /// In this test reading from shapefile is skipped, RiverLevel is defined in locations and in scenarios
        /// </summary>
        [Test]
        public void ImportRiverLevelFromScenariosTest()
        {
            // Setup folder for situation where RiverLevel is specified in locations and scenarios
            var importFolder = Path.Combine(tmpTestFolder, "TmpImportFilesRiverLevelFromScenarios");
            if (!Directory.Exists(importFolder))
                Directory.CreateDirectory(importFolder);
            srcDataSources = new List<DataSource>
            {
                new DataSource
                {
                    DataSourceType = DataSourceType.CsvFiles,
                    DataLocation = importFolder
                },
            };
            // Create basic datafiles that are needed to succeed the import method
            CreateBasicDataFiles(importFolder);
            // Create locations.csv that includes RiverLevel
            string importLocationsFile = importFolder + "\\locations.csv";
            CreateLocationsFileWithRiverLevel(importLocationsFile);
            // Create scenarios.csv that includes RiverLevel
            var importScenarioFile = importFolder + "\\scenarios.csv";
            CreateScenariosFileWithRiverLevel(importScenarioFile);

            dataPluginImporter = new DataPluginImporter();
            dataPluginImporter.SetDataSources("", srcDataSources);
            string dikeRingId = dataPluginImporter.GetDikeRingIdList().FirstOrDefault();
            dataPluginImporter.ImportDataForDikeRings(new List<string> { dikeRingId }, null);

            // Expected: The values of scenarios are used for scenario
            string scenarioId = dataPluginImporter.GetScenarioList(dikeRingId, "RK210-560").FirstOrDefault();
            IEnumerable<NameValueParameter> scenarioDetails = dataPluginImporter.GetScenarioDetails(dikeRingId, "RK210-560", scenarioId);
            var nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.AreEqual("0.1", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue);
            scenarioId = dataPluginImporter.GetScenarioList(dikeRingId, "RK210-570").FirstOrDefault();
            scenarioDetails = dataPluginImporter.GetScenarioDetails(dikeRingId, "RK210-570", scenarioId);
            nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.AreEqual("0.2", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue);
            // Expected: no error messages
            Assert.AreEqual(0, dataPluginImporter.ImportLogMessages.Count);
        }

        /// <summary>
        /// RiverLevel must be specified in locations.csv, shapefile or scenarios.csv
        /// In this test reading from shapefile is skipped, RiverLevel is NOT defined in locations or scenarios
        /// </summary>
        [Test]
        public void ImportRiverLevelNotSpecifiedTest()
        {
            // Setup folder for situation where RiverLevel is NOT specified in locations and scenarios
            var importFolder = Path.Combine(tmpTestFolder, "TmpImportFilesRiverLevelNotSpecified");
            if (!Directory.Exists(importFolder))
                Directory.CreateDirectory(importFolder);
            srcDataSources = new List<DataSource>
            {
                new DataSource
                {
                    DataSourceType = DataSourceType.CsvFiles,
                    DataLocation = importFolder
                },
            };
            // Create basic datafiles that are needed to succeed the import method
            CreateBasicDataFiles(importFolder);
            // Create locations.csv that includes RiverLevel
            string importLocationsFile = importFolder + "\\locations.csv";
            CreateLocationsFileWithoutRiverLevel(importLocationsFile);
            // Create scenarios.csv that includes RiverLevel
            var importScenarioFile = importFolder + "\\scenarios.csv";
            CreateScenariosFileWithoutRiverLevel(importScenarioFile);

            dataPluginImporter = new DataPluginImporter();
            dataPluginImporter.SetDataSources("", srcDataSources);
            string dikeRingId = dataPluginImporter.GetDikeRingIdList().FirstOrDefault();
            dataPluginImporter.ImportDataForDikeRings(new List<string> { dikeRingId }, null);

            // Expected: The values are null
            string scenarioId = dataPluginImporter.GetScenarioList(dikeRingId, "RK210-560").FirstOrDefault();
            IEnumerable<NameValueParameter> scenarioDetails = dataPluginImporter.GetScenarioDetails(dikeRingId, "RK210-560", scenarioId);
            var nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.AreEqual(null, nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue);
            scenarioId = dataPluginImporter.GetScenarioList(dikeRingId, "RK210-570").FirstOrDefault();
            scenarioDetails = dataPluginImporter.GetScenarioDetails(dikeRingId, "RK210-570", scenarioId);
            nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.AreEqual(null, nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue);
            // Expected: no error messages
            Assert.AreEqual(0, dataPluginImporter.ImportLogMessages.Count);
        }

        /// <summary>
        /// Test for values that can be read from both scenarios.csv and locations.csv/shapefile for situation:
        /// Locations.csv: filled with only required values (none)
        /// Shapefiles: none
        /// Scenarios.csv: filled with only required values (none)
        /// Expected result: scenario will be filled with defaults
        /// See Log.xlsx for all the values that are in all the files, expected values in column Locations_basic.csv + Scenario_basic.csv
        /// </summary>
        [Test]
        public void ImportHemPolderScenarioDefaultsTest()
        {
            // Copy import data to test folder
            var importFolder = Path.Combine(tmpTestFolder, "ImportHemPolderScenarioDefaultsTest");
            if (Directory.Exists(importFolder))
            {
                Directory.Delete(importFolder, true);
            }
            if (!Directory.Exists(importFolder))
            {
                Directory.CreateDirectory(importFolder);
            }
            var testDataFolderCsv = Path.Combine(Directory.GetCurrentDirectory(), @"..\..\Dam\Tests\TestData\HempolderImport\csvfiles");
            File.Copy(Path.Combine(testDataFolderCsv, "characteristicpoints.csv"), Path.Combine(importFolder, "characteristicpoints.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "segments.csv"), Path.Combine(importFolder, "segments.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "soilprofiles.csv"), Path.Combine(importFolder, "soilprofiles.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "surfacelines.csv"), Path.Combine(importFolder, "surfacelines.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "locations_basic.csv"), Path.Combine(importFolder, "locations.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "scenarios_basic.csv"), Path.Combine(importFolder, "scenarios.csv"));
            // create importer
            SetupInvoerHemPolderWithoutShapeFiles(importFolder);
            string dikeRingId = dataPluginImporter.GetDikeRingIdList().FirstOrDefault();
            dataPluginImporter.ImportDataForDikeRings(new List<string> { dikeRingId }, null);
            // check values for location 1
            string scenarioId = dataPluginImporter.GetScenarioList(dikeRingId, HemPolderLocationId1).FirstOrDefault();
            IEnumerable<NameValueParameter> scenarioDetails = dataPluginImporter.GetScenarioDetails(dikeRingId, HemPolderLocationId1, scenarioId);
            var nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.AreEqual(null, nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue);
            Assert.AreEqual(null, nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL4")).ParameterValue);
            Assert.AreEqual("0.5", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtRiver")).ParameterValue);
            Assert.AreEqual("1.5", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtPolder")).ParameterValue);
            Assert.AreEqual("0.1", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowShoulderBaseInside")).ParameterValue);
            Assert.AreEqual("0.1", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeToeAtPolder")).ParameterValue);
            Assert.AreEqual(null, nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetBelowDikeCrestMiddle")).ParameterValue);
            Assert.AreEqual(null, nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeCrestMiddle")).ParameterValue);
            Assert.AreEqual(null, nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetFactorBelowShoulderCrest")).ParameterValue);
            Assert.AreEqual(null, nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetFactorBelowShoulderCrest")).ParameterValue);
            Assert.AreEqual("1.2", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionStability")).ParameterValue);
            Assert.AreEqual("1.2", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionPiping")).ParameterValue);
            Assert.AreEqual(null, nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("DikeTableHeight")).ParameterValue);
            Assert.AreEqual(null, nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue);
            Assert.AreEqual(null, nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevelLow")).ParameterValue);
            Assert.AreEqual("1", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorPiping")).ParameterValue);
            Assert.AreEqual("1", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityInnerSlope")).ParameterValue);
            Assert.AreEqual("1", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityOuterSlope")).ParameterValue);
            // check values for location 2
            scenarioId = dataPluginImporter.GetScenarioList(dikeRingId, HemPolderLocationId2).FirstOrDefault();
            scenarioDetails = dataPluginImporter.GetScenarioDetails(dikeRingId, HemPolderLocationId2, scenarioId);
            nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.AreEqual(null, nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue);
            Assert.AreEqual(null, nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL4")).ParameterValue);
            Assert.AreEqual("0.5", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtRiver")).ParameterValue);
            Assert.AreEqual("1.5", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtPolder")).ParameterValue);
            Assert.AreEqual("0.1", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowShoulderBaseInside")).ParameterValue);
            Assert.AreEqual("0.1", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeToeAtPolder")).ParameterValue);
            Assert.AreEqual(null, nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetBelowDikeCrestMiddle")).ParameterValue);
            Assert.AreEqual(null, nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeCrestMiddle")).ParameterValue);
            Assert.AreEqual(null, nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetFactorBelowShoulderCrest")).ParameterValue);
            Assert.AreEqual(null, nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetFactorBelowShoulderCrest")).ParameterValue);
            Assert.AreEqual("1.2", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionStability")).ParameterValue);
            Assert.AreEqual("1.2", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionPiping")).ParameterValue);
            Assert.AreEqual(null, nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("DikeTableHeight")).ParameterValue);
            Assert.AreEqual(null, nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue);
            Assert.AreEqual(null, nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevelLow")).ParameterValue);
            Assert.AreEqual("1", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorPiping")).ParameterValue);
            Assert.AreEqual("1", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityInnerSlope")).ParameterValue);
            Assert.AreEqual("1", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityOuterSlope")).ParameterValue);
        }

        /// <summary>
        /// Test for values that can be read from both scenarios.csv and locations.csv/shapefile for situation:
        /// Locations.csv: completely filled
        /// Shapefiles: none
        /// Scenarios.csv: filled with only required values (waterheight)
        /// Expected result: scenario will be filled with values from locations.csv
        /// See Log.xlsx for all the values that are in all the files, expected values in column Locations_complete.csv + Scenario_basic.csv
        /// </summary>
        [Test]
        public void ImportHemPolderScenarioFromLocationsCsvTest()
        {
            // Copy import data to test folder
            var importFolder = Path.Combine(tmpTestFolder, "ImportHemPolderScenarioFromLocationsCsvTest");
            if (Directory.Exists(importFolder))
            {
                Directory.Delete(importFolder, true);
            }
            if (!Directory.Exists(importFolder))
            {
                Directory.CreateDirectory(importFolder);
            }
            var testDataFolderCsv = Path.Combine(Directory.GetCurrentDirectory(), @"..\..\Dam\Tests\TestData\HempolderImport\csvfiles");
            File.Copy(Path.Combine(testDataFolderCsv, "characteristicpoints.csv"), Path.Combine(importFolder, "characteristicpoints.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "segments.csv"), Path.Combine(importFolder, "segments.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "soilprofiles.csv"), Path.Combine(importFolder, "soilprofiles.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "surfacelines.csv"), Path.Combine(importFolder, "surfacelines.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "locations_complete.csv"), Path.Combine(importFolder, "locations.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "scenarios_basic.csv"), Path.Combine(importFolder, "scenarios.csv"));
            // create importer
            SetupInvoerHemPolderWithoutShapeFiles(importFolder);
            string dikeRingId = dataPluginImporter.GetDikeRingIdList().FirstOrDefault();
            dataPluginImporter.ImportDataForDikeRings(new List<string> { dikeRingId }, null);
            // check values for location 1
            string scenarioId = dataPluginImporter.GetScenarioList(dikeRingId, HemPolderLocationId1).FirstOrDefault();
            IEnumerable<NameValueParameter> scenarioDetails = dataPluginImporter.GetScenarioDetails(dikeRingId, HemPolderLocationId1, scenarioId);
            var nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.AreEqual("0.11", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue);
            Assert.AreEqual("2.11", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL4")).ParameterValue);
            Assert.AreEqual("0.55", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtRiver")).ParameterValue);
            Assert.AreEqual("0.56", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtPolder")).ParameterValue);
            Assert.AreEqual("0.57", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowShoulderBaseInside")).ParameterValue);
            Assert.AreEqual("0.58", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeToeAtPolder")).ParameterValue);
            Assert.AreEqual("True", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetBelowDikeCrestMiddle")).ParameterValue);
            Assert.AreEqual("0.59", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeCrestMiddle")).ParameterValue);
            Assert.AreEqual("True", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetFactorBelowShoulderCrest")).ParameterValue);
            Assert.AreEqual("0.6", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetFactorBelowShoulderCrest")).ParameterValue);
            Assert.AreEqual("0.88", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionStability")).ParameterValue);
            Assert.AreEqual("0.77", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionPiping")).ParameterValue);
            Assert.AreEqual("2.88", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("DikeTableHeight")).ParameterValue);
            Assert.AreEqual("1.11", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue);
            Assert.AreEqual("1.77", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevelLow")).ParameterValue);
            Assert.AreEqual("1.09", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorPiping")).ParameterValue);
            Assert.AreEqual("1.12", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityInnerSlope")).ParameterValue);
            Assert.AreEqual("1.14", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityOuterSlope")).ParameterValue);
            // check values for location 2
            scenarioId = dataPluginImporter.GetScenarioList(dikeRingId, HemPolderLocationId2).FirstOrDefault();
            scenarioDetails = dataPluginImporter.GetScenarioDetails(dikeRingId, HemPolderLocationId2, scenarioId);
            nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.AreEqual("1.11", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue);
            Assert.AreEqual("3.11", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL4")).ParameterValue);
            Assert.AreEqual("0.65", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtRiver")).ParameterValue);
            Assert.AreEqual("0.66", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtPolder")).ParameterValue);
            Assert.AreEqual("0.67", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowShoulderBaseInside")).ParameterValue);
            Assert.AreEqual("0.68", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeToeAtPolder")).ParameterValue);
            Assert.AreEqual("True", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetBelowDikeCrestMiddle")).ParameterValue);
            Assert.AreEqual("0.69", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeCrestMiddle")).ParameterValue);
            Assert.AreEqual("True", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetFactorBelowShoulderCrest")).ParameterValue);
            Assert.AreEqual("0.7", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetFactorBelowShoulderCrest")).ParameterValue);
            Assert.AreEqual("0.99", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionStability")).ParameterValue);
            Assert.AreEqual("0.66", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionPiping")).ParameterValue);
            Assert.AreEqual("2.99", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("DikeTableHeight")).ParameterValue);
            Assert.AreEqual("1.22", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue);
            Assert.AreEqual("1.88", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevelLow")).ParameterValue);
            Assert.AreEqual("1.1", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorPiping")).ParameterValue);
            Assert.AreEqual("1.13", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityInnerSlope")).ParameterValue);
            Assert.AreEqual("1.15", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityOuterSlope")).ParameterValue);
        }

        /// <summary>
        /// Test for values that can be read from both scenarios.csv and locations.csv/shapefile for situation:
        /// Locations.csv: filled completely
        /// Shapefiles: line shapes filled completely
        /// Scenarios.csv: filled with only required values (waterheight)
        /// Expected result: scenario will be filled with values from shapefiles
        /// See Log.xlsx for all the values that are in all the files, expected values in column Locations_complete.csv + LijnScenario.shp + Scenario_basic.csv
        /// </summary>
        [Test]
        public void ImportHemPolderLineShapeOverLocationsCsvTest()
        {
            // Copy import data to test folder
            var importFolder = Path.Combine(tmpTestFolder, "ImportHemPolderLineShapeOverLocationsCsvTest");
            if (Directory.Exists(importFolder))
            {
                Directory.Delete(importFolder, true);
            }
            if (!Directory.Exists(importFolder))
            {
                Directory.CreateDirectory(importFolder);
            }
            var testDataFolderCsv = Path.Combine(Directory.GetCurrentDirectory(), @"..\..\Dam\Tests\TestData\HempolderImport\csvfiles");
            var testDataFolderShape = Path.Combine(Directory.GetCurrentDirectory(), @"..\..\Dam\Tests\TestData\HempolderImport\shapefiles");
            File.Copy(Path.Combine(testDataFolderCsv, "characteristicpoints.csv"), Path.Combine(importFolder, "characteristicpoints.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "segments.csv"), Path.Combine(importFolder, "segments.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "soilprofiles.csv"), Path.Combine(importFolder, "soilprofiles.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "surfacelines.csv"), Path.Combine(importFolder, "surfacelines.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "locations_complete.csv"), Path.Combine(importFolder, "locations.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "scenarios_basic.csv"), Path.Combine(importFolder, "scenarios.csv"));
            var shapefiles = Directory.GetFiles(testDataFolderShape);
            foreach (var shapefile in shapefiles)
            {
                var fileName = Path.GetFileName(shapefile);
                File.Copy(Path.Combine(testDataFolderShape, fileName), Path.Combine(importFolder, fileName));
            }
            // create importer
            SetupInvoerHemPolderWithShapeFiles(importFolder, "LijnScenario.shp");
            string dikeRingId = dataPluginImporter.GetDikeRingIdList().FirstOrDefault();
            dataPluginImporter.ImportDataForDikeRings(new List<string> { dikeRingId }, null);
            // check values for location 1
            string scenarioId = dataPluginImporter.GetScenarioList(dikeRingId, HemPolderLocationId1).FirstOrDefault();
            IEnumerable<NameValueParameter> scenarioDetails = dataPluginImporter.GetScenarioDetails(dikeRingId, HemPolderLocationId1, scenarioId);
            var nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.AreEqual("1.99", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue);
            Assert.AreEqual("3.99", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL4")).ParameterValue);
            Assert.AreEqual("0.2", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtRiver")).ParameterValue);
            Assert.AreEqual("0.21", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtPolder")).ParameterValue);
            Assert.AreEqual("0.22", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowShoulderBaseInside")).ParameterValue);
            Assert.AreEqual("0.23", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeToeAtPolder")).ParameterValue);
            Assert.AreEqual("False", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetBelowDikeCrestMiddle")).ParameterValue);
            Assert.AreEqual("0.24", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeCrestMiddle")).ParameterValue);
            Assert.AreEqual("False", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetFactorBelowShoulderCrest")).ParameterValue);
            Assert.AreEqual("0.25", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetFactorBelowShoulderCrest")).ParameterValue);
            Assert.AreEqual("3", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionStability")).ParameterValue);
            Assert.AreEqual("5", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionPiping")).ParameterValue);
            Assert.AreEqual("4", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("DikeTableHeight")).ParameterValue);
            Assert.AreEqual("3.5", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue);
            Assert.AreEqual("2.5", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevelLow")).ParameterValue);
            Assert.AreEqual("0.6", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorPiping")).ParameterValue);
            Assert.AreEqual("0.63", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityInnerSlope")).ParameterValue);
            Assert.AreEqual("0.66", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityOuterSlope")).ParameterValue);
            // check values for location 2
            scenarioId = dataPluginImporter.GetScenarioList(dikeRingId, HemPolderLocationId2).FirstOrDefault();
            scenarioDetails = dataPluginImporter.GetScenarioDetails(dikeRingId, HemPolderLocationId2, scenarioId);
            nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.AreEqual("0.99", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue);
            Assert.AreEqual("2.99", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL4")).ParameterValue);
            Assert.AreEqual("0.1", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtRiver")).ParameterValue);
            Assert.AreEqual("0.11", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtPolder")).ParameterValue);
            Assert.AreEqual("0.12", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowShoulderBaseInside")).ParameterValue);
            Assert.AreEqual("0.13", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeToeAtPolder")).ParameterValue);
            Assert.AreEqual("False", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetBelowDikeCrestMiddle")).ParameterValue);
            Assert.AreEqual("0.14", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeCrestMiddle")).ParameterValue);
            Assert.AreEqual("True", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetFactorBelowShoulderCrest")).ParameterValue);
            Assert.AreEqual("0.15", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetFactorBelowShoulderCrest")).ParameterValue);
            Assert.AreEqual("2", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionStability")).ParameterValue);
            Assert.AreEqual("4", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionPiping")).ParameterValue);
            Assert.AreEqual("3", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("DikeTableHeight")).ParameterValue);
            Assert.AreEqual("3", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue);
            Assert.AreEqual("2", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevelLow")).ParameterValue);
            Assert.AreEqual("0.5", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorPiping")).ParameterValue);
            Assert.AreEqual("0.53", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityInnerSlope")).ParameterValue);
            Assert.AreEqual("0.56", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityOuterSlope")).ParameterValue);
        }

        /// <summary>
        /// Test for values that can be read from both scenarios.csv and locations.csv/shapefile for situation:
        /// Locations.csv: filled completely
        /// Shapefiles: area shapes filled completely
        /// Scenarios.csv: filled with only required values (waterheight)
        /// Expected result: scenario will be filled with values from shapefiles
        /// See Log.xlsx for all the values that are in all the files, expected values in column Locations_complete.csv + VlakScenario.shp + Scenario_basic.csv
        /// </summary>
        [Test]
        public void ImportHemPolderAreaShapeOverLocationsCsvTest()
        {
            // Copy import data to test folder
            var importFolder = Path.Combine(tmpTestFolder, "ImportHemPolderAreaShapeOverLocationsCsvTest");
            if (Directory.Exists(importFolder))
            {
                Directory.Delete(importFolder, true);
            }
            if (!Directory.Exists(importFolder))
            {
                Directory.CreateDirectory(importFolder);
            }
            var testDataFolderCsv = Path.Combine(Directory.GetCurrentDirectory(), @"..\..\Dam\Tests\TestData\HempolderImport\csvfiles");
            var testDataFolderShape = Path.Combine(Directory.GetCurrentDirectory(), @"..\..\Dam\Tests\TestData\HempolderImport\shapefiles");
            File.Copy(Path.Combine(testDataFolderCsv, "characteristicpoints.csv"), Path.Combine(importFolder, "characteristicpoints.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "segments.csv"), Path.Combine(importFolder, "segments.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "soilprofiles.csv"), Path.Combine(importFolder, "soilprofiles.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "surfacelines.csv"), Path.Combine(importFolder, "surfacelines.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "locations_complete.csv"), Path.Combine(importFolder, "locations.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "scenarios_basic.csv"), Path.Combine(importFolder, "scenarios.csv"));
            var shapefiles = Directory.GetFiles(testDataFolderShape);
            foreach (var shapefile in shapefiles)
            {
                var fileName = Path.GetFileName(shapefile);
                File.Copy(Path.Combine(testDataFolderShape, fileName), Path.Combine(importFolder, fileName));
            }
            // create importer
            SetupInvoerHemPolderWithShapeFiles(importFolder, "VlakScenario.shp");
            string dikeRingId = dataPluginImporter.GetDikeRingIdList().FirstOrDefault();
            dataPluginImporter.ImportDataForDikeRings(new List<string> { dikeRingId }, null);
            // check values for location 1
            string scenarioId = dataPluginImporter.GetScenarioList(dikeRingId, HemPolderLocationId1).FirstOrDefault();
            IEnumerable<NameValueParameter> scenarioDetails = dataPluginImporter.GetScenarioDetails(dikeRingId, HemPolderLocationId1, scenarioId);
            var nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.AreEqual("0.9", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue);
            Assert.AreEqual("2.9", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL4")).ParameterValue);
            Assert.AreEqual("0.05", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtRiver")).ParameterValue);
            Assert.AreEqual("0.06", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtPolder")).ParameterValue);
            Assert.AreEqual("0.07", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowShoulderBaseInside")).ParameterValue);
            Assert.AreEqual("0.08", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeToeAtPolder")).ParameterValue);
            Assert.AreEqual("True", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetBelowDikeCrestMiddle")).ParameterValue);
            Assert.AreEqual("0.09", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeCrestMiddle")).ParameterValue);
            Assert.AreEqual("False", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetFactorBelowShoulderCrest")).ParameterValue);
            Assert.AreEqual("0.1", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetFactorBelowShoulderCrest")).ParameterValue);
            Assert.AreEqual("4", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionStability")).ParameterValue);
            Assert.AreEqual("6", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionPiping")).ParameterValue);
            Assert.AreEqual("5", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("DikeTableHeight")).ParameterValue);
            Assert.AreEqual("4.5", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue);
            Assert.AreEqual("3.5", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevelLow")).ParameterValue);
            Assert.AreEqual("0.81", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorPiping")).ParameterValue);
            Assert.AreEqual("0.83", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityInnerSlope")).ParameterValue);
            Assert.AreEqual("0.85", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityOuterSlope")).ParameterValue);
            // check values for location 2
            scenarioId = dataPluginImporter.GetScenarioList(dikeRingId, HemPolderLocationId2).FirstOrDefault();
            scenarioDetails = dataPluginImporter.GetScenarioDetails(dikeRingId, HemPolderLocationId2, scenarioId);
            nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.AreEqual("1.9", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue);
            Assert.AreEqual("3.9", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL4")).ParameterValue);
            Assert.AreEqual("0.15", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtRiver")).ParameterValue);
            Assert.AreEqual("0.16", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtPolder")).ParameterValue);
            Assert.AreEqual("0.17", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowShoulderBaseInside")).ParameterValue);
            Assert.AreEqual("0.18", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeToeAtPolder")).ParameterValue);
            Assert.AreEqual("False", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetBelowDikeCrestMiddle")).ParameterValue);
            Assert.AreEqual("0.19", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeCrestMiddle")).ParameterValue);
            Assert.AreEqual("True", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetFactorBelowShoulderCrest")).ParameterValue);
            Assert.AreEqual("0.2", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetFactorBelowShoulderCrest")).ParameterValue);
            Assert.AreEqual("3", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionStability")).ParameterValue);
            Assert.AreEqual("5", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionPiping")).ParameterValue);
            Assert.AreEqual("4", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("DikeTableHeight")).ParameterValue);
            Assert.AreEqual("4", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue);
            Assert.AreEqual("3", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevelLow")).ParameterValue);
            Assert.AreEqual("0.7", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorPiping")).ParameterValue);
            Assert.AreEqual("0.75", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityInnerSlope")).ParameterValue);
            Assert.AreEqual("0.8", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityOuterSlope")).ParameterValue);
        }

        /// <summary>
        /// Test for values that can be read from both scenarios.csv and locations.csv/shapefile for situation:
        /// Locations.csv: filled completely
        /// Shapefiles: line shapes filled completely
        /// Scenarios.csv: filled completely
        /// Expected result: scenario will be filled with values from scenarios.csv
        /// See Log.xlsx for all the values that are in all the files, expected values in column Locations_complete.csv + LijnScenario.shp + Scenario_complete.csv
        /// </summary>
        [Test]
        public void ImportHemPolderScenarioOverShapeAndLocationsCsvTest()
        {
            // Copy import data to test folder
            var importFolder = Path.Combine(tmpTestFolder, "ImportHemPolderScenarioOverShapeAndLocationsCsvTest");
            if (Directory.Exists(importFolder))
            {
                Directory.Delete(importFolder, true);
            }
            if (!Directory.Exists(importFolder))
            {
                Directory.CreateDirectory(importFolder);
            }
            var testDataFolderCsv = Path.Combine(Directory.GetCurrentDirectory(), @"..\..\Dam\Tests\TestData\HempolderImport\csvfiles");
            var testDataFolderShape = Path.Combine(Directory.GetCurrentDirectory(), @"..\..\Dam\Tests\TestData\HempolderImport\shapefiles");
            File.Copy(Path.Combine(testDataFolderCsv, "characteristicpoints.csv"), Path.Combine(importFolder, "characteristicpoints.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "segments.csv"), Path.Combine(importFolder, "segments.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "soilprofiles.csv"), Path.Combine(importFolder, "soilprofiles.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "surfacelines.csv"), Path.Combine(importFolder, "surfacelines.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "locations_complete.csv"), Path.Combine(importFolder, "locations.csv"));
            File.Copy(Path.Combine(testDataFolderCsv, "scenarios_complete.csv"), Path.Combine(importFolder, "scenarios.csv"));
            var shapefiles = Directory.GetFiles(testDataFolderShape);
            foreach (var shapefile in shapefiles)
            {
                var fileName = Path.GetFileName(shapefile);
                File.Copy(Path.Combine(testDataFolderShape, fileName), Path.Combine(importFolder, fileName));
            }
            // create importer
            SetupInvoerHemPolderWithShapeFiles(importFolder, "LijnScenario.shp");
            string dikeRingId = dataPluginImporter.GetDikeRingIdList().FirstOrDefault();
            dataPluginImporter.ImportDataForDikeRings(new List<string> { dikeRingId }, null);
            // check values for location 1
            string scenarioId = dataPluginImporter.GetScenarioList(dikeRingId, HemPolderLocationId1).FirstOrDefault();
            IEnumerable<NameValueParameter> scenarioDetails = dataPluginImporter.GetScenarioDetails(dikeRingId, HemPolderLocationId1, scenarioId);
            var nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.AreEqual("0.25", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue);
            Assert.AreEqual("2.25", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL4")).ParameterValue);
            Assert.AreEqual("0.75", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtRiver")).ParameterValue);
            Assert.AreEqual("0.76", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtPolder")).ParameterValue);
            Assert.AreEqual("0.77", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowShoulderBaseInside")).ParameterValue);
            Assert.AreEqual("0.78", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeToeAtPolder")).ParameterValue);
            Assert.AreEqual("True", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetBelowDikeCrestMiddle")).ParameterValue);
            Assert.AreEqual("0.79", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeCrestMiddle")).ParameterValue);
            Assert.AreEqual("True", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetFactorBelowShoulderCrest")).ParameterValue);
            Assert.AreEqual("0.8", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetFactorBelowShoulderCrest")).ParameterValue);
            Assert.AreEqual("0.9", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionStability")).ParameterValue);
            Assert.AreEqual("0.91", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionPiping")).ParameterValue);
            Assert.AreEqual("0.92", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("DikeTableHeight")).ParameterValue);
            Assert.AreEqual("1.5", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue);
            Assert.AreEqual("1.25", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevelLow")).ParameterValue);
            Assert.AreEqual("0.93", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorPiping")).ParameterValue);
            Assert.AreEqual("0.94", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityInnerSlope")).ParameterValue);
            Assert.AreEqual("0.95", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityOuterSlope")).ParameterValue);
            // check values for location 2
            scenarioId = dataPluginImporter.GetScenarioList(dikeRingId, HemPolderLocationId2).FirstOrDefault();
            scenarioDetails = dataPluginImporter.GetScenarioDetails(dikeRingId, HemPolderLocationId2, scenarioId);
            nameValueParameters = scenarioDetails as NameValueParameter[] ?? scenarioDetails.ToArray();
            Assert.AreEqual("1.25", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL3")).ParameterValue);
            Assert.AreEqual("3.25", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("HeadPL4")).ParameterValue);
            Assert.AreEqual("1.75", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtRiver")).ParameterValue);
            Assert.AreEqual("1.76", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeTopAtPolder")).ParameterValue);
            Assert.AreEqual("1.77", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowShoulderBaseInside")).ParameterValue);
            Assert.AreEqual("1.78", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeToeAtPolder")).ParameterValue);
            Assert.AreEqual("True", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetBelowDikeCrestMiddle")).ParameterValue);
            Assert.AreEqual("1.79", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetBelowDikeCrestMiddle")).ParameterValue);
            Assert.AreEqual("True", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UsePlLineOffsetFactorBelowShoulderCrest")).ParameterValue);
            Assert.AreEqual("0.9", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("PlLineOffsetFactorBelowShoulderCrest")).ParameterValue);
            Assert.AreEqual("1.9", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionStability")).ParameterValue);
            Assert.AreEqual("1.91", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("UpliftCriterionPiping")).ParameterValue);
            Assert.AreEqual("1.92", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("DikeTableHeight")).ParameterValue);
            Assert.AreEqual("2.5", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevel")).ParameterValue);
            Assert.AreEqual("2.25", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RiverLevelLow")).ParameterValue);
            Assert.AreEqual("1.93", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorPiping")).ParameterValue);
            Assert.AreEqual("1.94", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityInnerSlope")).ParameterValue);
            Assert.AreEqual("1.95", nameValueParameters.FirstOrDefault(x => x.ParameterName.Equals("RequiredSafetyFactorStabilityOuterSlope")).ParameterValue);
        }
    }
}