//-----------------------------------------------------------------------
// <copyright file="DamProjectData.cs" company="Deltares">     
//  Copyright (c) 2011 Deltares. All rights reserved.
// </copyright>
// <author>B.S.T.I.M. The</author>
// <email>tom.the@deltares.nl</email>
// <date>04-08-2011</date>
// <summary>n.a.</summary>
//-----------------------------------------------------------------------

namespace Deltares.Dam.Tests
{
    using System.IO;
    using System.Collections.Generic;
    using Data;
    using NUnit.Framework;

    [TestFixture]
    public class DamCalculationBenchmarkTest
    {
        const string cmstabProgramPath = ".\\DGeoStability.exe";
        const double cTolerance = 0.001;

        #region SupportingMethods
        
        #endregion SupportingMethods

        #region Uplift
        [Test]
        public void BM04Opdrijven01SituatieZonderOpdrijven1D()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\4 Validatie opdrijfberekeningen\01 Situatie zonder opdrijven (1D)\DAM invoerfiles";

            // Read dikering
            using (DamProjectData damProjectData = DamIntegrationTestHelper.CreateDamProjectDataFromCsvFiles(cFolderName))
            {
                Assert.AreEqual(1, damProjectData.WaterBoard.Dikes.Count);
                Dike dike = damProjectData.WaterBoard.Dikes[0];
                Assert.AreEqual(1, dike.Locations.Count);

                // Specify calculation
                DamIntegrationTestHelper.AddCalculationSpecificationsToDamProjectData(damProjectData);

                // Calculate dijkring
                var damProjectCalculator = new DamProjectCalculator(damProjectData);
                damProjectCalculator.CalculationBaseDirectory = Path.GetFullPath(Path.Combine(cFolderName, "CalculationFiles"));
                damProjectCalculator.MStabProgramPath = cmstabProgramPath;
                List<List<CsvExportData>> allCalculationresults = damProjectCalculator.Calculate(damProjectData, dike.Scenarios);
                Assert.IsTrue(allCalculationresults[0][0].IsUplift.Value);
                Assert.AreEqual(1.024077029, allCalculationresults[0][0].Pl3MinUplift.Value, cTolerance);
                Assert.AreEqual(49.1, allCalculationresults[0][0].Pl3LocalLocationXMinUplift.Value, cTolerance); // Due to improvement of PLLineCreator this value was changed from 51.1
                //Assert.AreEqual(1.0880, allCalculationresults[0][0].StabilitySafetyFactor.Value, cTolerance);
            }
        }

        [Test]
        [Category("Slow")]
        public void BM04Opdrijven02SituatieMetOpdrijven1D()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\4 Validatie opdrijfberekeningen\02 Situatie met opdrijven (1D)\DAM invoerfiles";
            // Read dikering
            using (DamProjectData damProjectData = DamIntegrationTestHelper.CreateDamProjectDataFromCsvFiles(cFolderName))
            {
                Assert.AreEqual(1, damProjectData.WaterBoard.Dikes.Count);
                Dike dike = damProjectData.WaterBoard.Dikes[0];
                Assert.AreEqual(1, dike.Locations.Count);

                // Specify calculation
                DamIntegrationTestHelper.AddCalculationSpecificationsToDamProjectData(damProjectData);

                // Calculate dijkring
                var damProjectCalculator = new DamProjectCalculator(damProjectData);
                damProjectCalculator.CalculationBaseDirectory = Path.GetFullPath(Path.Combine(cFolderName, "CalculationFiles"));
                damProjectCalculator.MStabProgramPath = cmstabProgramPath;
                List<List<CsvExportData>> allCalculationresults = damProjectCalculator.Calculate(damProjectData, dike.Scenarios);
                Assert.IsTrue(allCalculationresults[0][0].IsUplift.Value);
                Assert.AreEqual(0.905914295, allCalculationresults[0][0].Pl3MinUplift.Value, cTolerance);
                Assert.AreEqual(-1.289245668, allCalculationresults[0][0].Pl3HeadAdjusted.Value, cTolerance);
                Assert.AreEqual(49.1, allCalculationresults[0][0].Pl3LocalLocationXMinUplift.Value, cTolerance);
            }
        }

        [Test]
        [Category("Slow")]
        public void BM04Opdrijven03SituatieMetEenLabielEvenwicht1D()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\4 Validatie opdrijfberekeningen\03 Situatie met een labiel evenwicht (1D)\DAM invoerfiles";
            using (DamProjectData damProjectData = DamIntegrationTestHelper.CreateDamProjectDataFromCsvFiles(cFolderName))
            {
                Assert.AreEqual(1, damProjectData.WaterBoard.Dikes.Count);
                Dike dike = damProjectData.WaterBoard.Dikes[0];
                Assert.AreEqual(1, dike.Locations.Count);

                // Specify calculation
                DamIntegrationTestHelper.AddCalculationSpecificationsToDamProjectData(damProjectData);

                // Calculate dijkring
                var damProjectCalculator = new DamProjectCalculator(damProjectData);
                damProjectCalculator.CalculationBaseDirectory = Path.GetFullPath(Path.Combine(cFolderName, "CalculationFiles"));
                damProjectCalculator.MStabProgramPath = cmstabProgramPath;
                List<List<CsvExportData>> allCalculationresults = damProjectCalculator.Calculate(damProjectData, dike.Scenarios);
                Assert.IsTrue(allCalculationresults[0][0].IsUplift.Value);
                Assert.AreEqual(1.0, allCalculationresults[0][0].Pl3MinUplift.Value, cTolerance);
                Assert.AreEqual(-1.289245668, allCalculationresults[0][0].Pl3HeadAdjusted.Value, cTolerance);
                Assert.AreEqual(49.1, allCalculationresults[0][0].Pl3LocalLocationXMinUplift.Value, cTolerance);
            }
        }

        [Test]
        [Category("Slow")]
        public void BM04Opdrijven04SituatieMetEenSchuineSlootbodemEnOpdrijvenOp1Locatie1D()
        {
            string cFolderName = @"..\..\..\data\Dam\Benchmarks\4 Validatie opdrijfberekeningen\04 Situatie met een schuine slootbodem en opdrijven op 1 locatie (1D)\DAM invoerfiles";
            using (DamProjectData damProjectData = DamIntegrationTestHelper.CreateDamProjectDataFromCsvFiles(cFolderName))
            {
                Assert.AreEqual(1, damProjectData.WaterBoard.Dikes.Count);
                Dike dike = damProjectData.WaterBoard.Dikes[0];
                Assert.AreEqual(1, dike.Locations.Count);

                // Specify calculation
                DamIntegrationTestHelper.AddCalculationSpecificationsToDamProjectData(damProjectData);

                // Calculate dijkring
                var damProjectCalculator = new DamProjectCalculator(damProjectData);
                damProjectCalculator.CalculationBaseDirectory = Path.GetFullPath(Path.Combine(cFolderName, "CalculationFiles"));
                damProjectCalculator.MStabProgramPath = cmstabProgramPath;
                List<List<CsvExportData>> allCalculationresults = damProjectCalculator.Calculate(damProjectData, dike.Scenarios);
                Assert.IsTrue(allCalculationresults[0][0].IsUplift.Value);
                Assert.AreEqual(0.969283045, allCalculationresults[0][0].Pl3MinUplift.Value, cTolerance);
                Assert.AreEqual(-1.6382263, allCalculationresults[0][0].Pl3HeadAdjusted.Value, cTolerance);
                Assert.AreEqual(49.1, allCalculationresults[0][0].Pl3LocalLocationXMinUplift.Value, cTolerance);
            }
        }

        [Test]
        [Category("Slow")]
        public void BM04Opdrijven04SituatieMetEenSchuineSlootbodemEnOpdrijvenOp1Locatie1D_Using_WTIStabilityKernel()
        {
            string cFolderName = @"..\..\..\data\Dam\Benchmarks\4 Validatie opdrijfberekeningen\04 Situatie met een schuine slootbodem en opdrijven op 1 locatie (1D)\DAM invoerfiles";
            using (DamProjectData damProjectData = DamIntegrationTestHelper.CreateDamProjectDataFromCsvFiles(cFolderName))
            {
                Assert.AreEqual(1, damProjectData.WaterBoard.Dikes.Count);
                Dike dike = damProjectData.WaterBoard.Dikes[0];
                Assert.AreEqual(1, dike.Locations.Count);

                // Specify calculation
                DamIntegrationTestHelper.AddCalculationSpecificationsToDamProjectData(damProjectData);

                // Calculate dijkring
                var damProjectCalculator = new DamProjectCalculator(damProjectData);
                damProjectCalculator.CalculationBaseDirectory = Path.GetFullPath(Path.Combine(cFolderName, "CalculationFiles"));
                damProjectCalculator.MStabProgramPath = cmstabProgramPath;
                damProjectData.DamProjectCalculationSpecification.SelectedStabilityKernelType = StabilityKernelType.DamClassicWti; // = StabilityKernelType.WtiMacroStability;
                List<List<CsvExportData>> allCalculationresults = damProjectCalculator.Calculate(damProjectData, dike.Scenarios);
                Assert.IsTrue(allCalculationresults[0][0].IsUplift.Value);
                Assert.AreEqual(0.969283045, allCalculationresults[0][0].Pl3MinUplift.Value, cTolerance);
                Assert.AreEqual(-1.6382263, allCalculationresults[0][0].Pl3HeadAdjusted.Value, cTolerance);
                Assert.AreEqual(49.1, allCalculationresults[0][0].Pl3LocationXMinUplift.Value, cTolerance);
            }
        }

        [Test]
        [Category("Slow")]
        public void BM04Opdrijven05SituatieMetGrondlagenBovenEnOnderHetFreatischVlak1D()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\4 Validatie opdrijfberekeningen\05 Situatie met grondlagen boven en onder het freatisch vlak (1D)\DAM invoerfiles";
            using (DamProjectData damProjectData = DamIntegrationTestHelper.CreateDamProjectDataFromCsvFiles(cFolderName))
            {
                Assert.AreEqual(1, damProjectData.WaterBoard.Dikes.Count);
                Dike dike = damProjectData.WaterBoard.Dikes[0];
                Assert.AreEqual(1, dike.Locations.Count);

                // Specify calculation
                DamIntegrationTestHelper.AddCalculationSpecificationsToDamProjectData(damProjectData);

                // Calculate dijkring
                var damProjectCalculator = new DamProjectCalculator(damProjectData);
                damProjectCalculator.CalculationBaseDirectory = Path.GetFullPath(Path.Combine(cFolderName, "CalculationFiles"));
                damProjectCalculator.MStabProgramPath = cmstabProgramPath;
                List<List<CsvExportData>> allCalculationresults = damProjectCalculator.Calculate(damProjectData, dike.Scenarios);
                Assert.IsFalse(allCalculationresults[0][0].IsUplift.Value);
                Assert.AreEqual(1.512062521, allCalculationresults[0][0].Pl3MinUplift.Value, cTolerance);
                Assert.AreEqual(43.0, allCalculationresults[0][0].Pl3LocalLocationXMinUplift.Value, cTolerance);
            }
        }

        [Test]
        public void BM04Opdrijven06SituatieMetOpdrijvenOpVerschillendeLocatiesLangsHetProfiel1D()
        {
            string cFolderName = @"..\..\..\data\Dam\Benchmarks\4 Validatie opdrijfberekeningen\06 Situatie met verschillende opdrijflocaties (1D)\DAM invoerfiles";
            using (DamProjectData damProjectData = DamIntegrationTestHelper.CreateDamProjectDataFromCsvFiles(cFolderName))
            {
                Assert.AreEqual(1, damProjectData.WaterBoard.Dikes.Count);
                Dike dike = damProjectData.WaterBoard.Dikes[0];
                Assert.AreEqual(1, dike.Locations.Count);

                // Specify calculation
                DamIntegrationTestHelper.AddCalculationSpecificationsToDamProjectData(damProjectData);

                // Calculate dijkring
                var damProjectCalculator = new DamProjectCalculator(damProjectData);
                damProjectCalculator.CalculationBaseDirectory = Path.GetFullPath(Path.Combine(cFolderName, "CalculationFiles"));
                damProjectCalculator.MStabProgramPath = cmstabProgramPath;
                List<List<CsvExportData>> allCalculationresults = damProjectCalculator.Calculate(damProjectData, dike.Scenarios);
                Assert.IsTrue(allCalculationresults[0][0].IsUplift.Value);
                // Values at bottom ditch dikeside
                Assert.AreEqual(0.820097604, allCalculationresults[0][0].Pl3MinUplift.Value, cTolerance); 
                Assert.AreEqual(-1.289245668, allCalculationresults[0][0].Pl3HeadAdjusted.Value, cTolerance);
                Assert.AreEqual(49.1, allCalculationresults[0][0].Pl3LocalLocationXMinUplift.Value, cTolerance); 
            }
        }

        [Test]
        [Ignore("Data not available yet")]
        public void BM04Opdrijven07SituatieZonderOpdrijven2D()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\4 Validatie opdrijfberekeningen\07 Situatie zonder opdrijven (2D)\DAM invoerfiles";
            using (DamProjectData damProjectData = DamIntegrationTestHelper.CreateDamProjectDataFromCsvFiles(cFolderName))
            {
                Assert.AreEqual(1, damProjectData.WaterBoard.Dikes.Count);
            }
        }

        [Test]
        [Ignore("Data not available yet")]
        public void BM04Opdrijven08SituatieMetOpdrijven2D()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\4 Validatie opdrijfberekeningen\08 Situatie met opdrijven (2D)\DAM invoerfiles";
            using (DamProjectData damProjectData = DamIntegrationTestHelper.CreateDamProjectDataFromCsvFiles(cFolderName))
            {
                Assert.AreEqual(1, damProjectData.WaterBoard.Dikes.Count);
            }
        }
        #endregion Uplift

        #region ScenarioSelectionSupportingMethods

        /// <summary>
        /// Perform scenario selection only for the project
        /// </summary>
        /// <param name="damProjectData"></param>
        /// <returns></returns>
        private EvaluationJob ComputeEvaluationJobWithScenariosSelected(DamProjectData damProjectData)
        {
            var rwScenariosCalculation = new RWScenariosCalculation();

            rwScenariosCalculation.MStabExePath = Path.GetFullPath(cmstabProgramPath);

            foreach (LocationJob locationjob in damProjectData.LocationJobs)
            {
                locationjob.Run = true;
            }
            EvaluationJob evaluationJob = damProjectData.GetEvaluationJob();

            rwScenariosCalculation.Load(evaluationJob.XML);
            rwScenariosCalculation.IsSkipStabilityCalculation = true; // skip actual calculations, because only scenario selection is tested
            rwScenariosCalculation.Run();

            string results = "";
            rwScenariosCalculation.GetResults(ref results);

            evaluationJob.XML = results;
            evaluationJob.AttachResults(damProjectData.LocationJobs);
            return evaluationJob;
        }

        /// <summary>
        /// Check if the selected situation for DikeDrySensitivity is correct
        /// </summary>
        /// <param name="projectPath"></param>
        /// <param name="resultDikeDrySensitivity"></param>
        private void CheckScenarioSelectionDikeDrySensitivity(string projectPath, DikeDrySensitivity resultDikeDrySensitivity)
        {
            DamProject.UserWorkingPath = projectPath;
            DamProject.ProjectWorkingPathLocation = ProjectPathLocation.InUserMap;

            using (DamProjectData damProjectData = DamIntegrationTestHelper.CreateDamProjectDataFromCsvFiles(projectPath))
            {
                Assert.AreEqual(1, damProjectData.WaterBoard.Dikes.Count);

                EvaluationJob evaluationJob = ComputeEvaluationJobWithScenariosSelected(damProjectData);

                Assert.IsTrue(evaluationJob.Results.Count > 0);
                foreach (RWScenariosResult result in evaluationJob.Results)
                {
                    foreach (RWScenarioResult rwScenarioResult in result.RWScenarioResults)
                    {
                        foreach (RWScenarioProfileResult rwScenarioProfileResult in rwScenarioResult.RWScenarioProfileResults)
                        {
                            Assert.AreEqual(resultDikeDrySensitivity, rwScenarioProfileResult.DikeDrySensitivity);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Check if the selected situation for DikeDrySensitivity is correct
        /// </summary>
        /// <param name="projectPath"></param>
        /// <param name="resultDikeDrySensitivity"></param>
        private void CheckScenarioSelectionHydraulicShortcut(string projectPath, HydraulicShortcutType resultHydraulicShortcut)
        {
            DamProject.UserWorkingPath = projectPath;
            DamProject.ProjectWorkingPathLocation = ProjectPathLocation.InUserMap;

            using (DamProjectData damProjectData = DamIntegrationTestHelper.CreateDamProjectDataFromCsvFiles(projectPath))
            {
                Assert.AreEqual(1, damProjectData.WaterBoard.Dikes.Count);

                EvaluationJob evaluationJob = ComputeEvaluationJobWithScenariosSelected(damProjectData);

                Assert.IsTrue(evaluationJob.Results.Count > 0);
                foreach (RWScenariosResult result in evaluationJob.Results)
                {
                    foreach (RWScenarioResult rwScenarioResult in result.RWScenarioResults)
                    {
                        foreach (RWScenarioProfileResult rwScenarioProfileResult in rwScenarioResult.RWScenarioProfileResults)
                        {
                            Assert.AreEqual(resultHydraulicShortcut, rwScenarioProfileResult.HydraulicShortcutType);
                        }
                    }
                }
            }
        }
        #endregion ScenarioSelectionSupportingBenchmarks

        #region ScenarioSelectionDroogtegevoeligheid
        [Test]
        public void BM05ScenarioSelectie01DroogtegevoeligheidFalse()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\5 Validatie scenarioselectie regionale keringen\01 Bepaling droogtegevoeligheid kade\False\DAM invoerfiles";
            string projectPath = Path.GetFullPath(cFolderName);
            CheckScenarioSelectionDikeDrySensitivity(projectPath, DikeDrySensitivity.None);
        }

        [Test]
        public void BM05ScenarioSelectie01DroogtegevoeligheidTrue()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\5 Validatie scenarioselectie regionale keringen\01 Bepaling droogtegevoeligheid kade\True\DAM invoerfiles";
            string projectPath = Path.GetFullPath(cFolderName);
            CheckScenarioSelectionDikeDrySensitivity(projectPath, DikeDrySensitivity.Dry);
        }
        #endregion ScenarioSelectionDroogtegevoeligheid

        #region ScenarioSelectionHydraulischeKortsluiting
        [Test]
        public void BM05ScenarioSelectie02HydraulischeKortsluitingStap1True()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\5 Validatie scenarioselectie regionale keringen\02 Bepaling hydraulische kortsluiting\Stap 1\Altijd Hydraulische Kortsluiting\DAM invoerfiles";
            string projectPath = Path.GetFullPath(cFolderName);
            CheckScenarioSelectionHydraulicShortcut(projectPath, HydraulicShortcutType.HydraulicShortcut);
        }

        [Test]
        public void BM05ScenarioSelectie02HydraulischeKortsluitingStap1False()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\5 Validatie scenarioselectie regionale keringen\02 Bepaling hydraulische kortsluiting\Stap 1\Geen Hydraulische Kortsluiting\DAM invoerfiles";
            string projectPath = Path.GetFullPath(cFolderName);
            CheckScenarioSelectionHydraulicShortcut(projectPath, HydraulicShortcutType.NoHydraulicShortcut);
        }

        [Test]
        public void BM05ScenarioSelectie02HydraulischeKortsluitingStap2BoezemBodemSituatie1()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\5 Validatie scenarioselectie regionale keringen\02 Bepaling hydraulische kortsluiting\Stap 2\Met boezembodem\Situatie 1\DAM invoerfiles";
            string projectPath = Path.GetFullPath(cFolderName);
            CheckScenarioSelectionHydraulicShortcut(projectPath, HydraulicShortcutType.HydraulicShortcut);
        }

        [Test]
        public void BM05ScenarioSelectie02HydraulischeKortsluitingStap2BoezemBodemSituatie2()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\5 Validatie scenarioselectie regionale keringen\02 Bepaling hydraulische kortsluiting\Stap 2\Met boezembodem\Situatie 2\DAM invoerfiles";
            string projectPath = Path.GetFullPath(cFolderName);
            CheckScenarioSelectionHydraulicShortcut(projectPath, HydraulicShortcutType.NoHydraulicShortcut);
        }

        [Test]
        public void BM05ScenarioSelectie02HydraulischeKortsluitingStap2BoezemBodemSituatie3()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\5 Validatie scenarioselectie regionale keringen\02 Bepaling hydraulische kortsluiting\Stap 2\Met boezembodem\Situatie 3\DAM invoerfiles";
            string projectPath = Path.GetFullPath(cFolderName);
            CheckScenarioSelectionHydraulicShortcut(projectPath, HydraulicShortcutType.HydraulicShortcut);
        }

        [Test]
        public void BM05ScenarioSelectie02HydraulischeKortsluitingStap2BoezemBodemSituatie4()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\5 Validatie scenarioselectie regionale keringen\02 Bepaling hydraulische kortsluiting\Stap 2\Met boezembodem\Situatie 4\DAM invoerfiles";
            string projectPath = Path.GetFullPath(cFolderName);
            CheckScenarioSelectionHydraulicShortcut(projectPath, HydraulicShortcutType.NoHydraulicShortcut);
        }

        [Test]
        public void BM05ScenarioSelectie02HydraulischeKortsluitingStap2DamwandSituatie1()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\5 Validatie scenarioselectie regionale keringen\02 Bepaling hydraulische kortsluiting\Stap 2\Met damwand\Situatie 1\DAM invoerfiles";
            string projectPath = Path.GetFullPath(cFolderName);
            CheckScenarioSelectionHydraulicShortcut(projectPath, HydraulicShortcutType.HydraulicShortcut);
        }

        [Test]
        public void BM05ScenarioSelectie02HydraulischeKortsluitingStap2DamwandSituatie2()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\5 Validatie scenarioselectie regionale keringen\02 Bepaling hydraulische kortsluiting\Stap 2\Met damwand\Situatie 2\DAM invoerfiles";
            string projectPath = Path.GetFullPath(cFolderName);
            CheckScenarioSelectionHydraulicShortcut(projectPath, HydraulicShortcutType.NoHydraulicShortcut);
        }

        [Test]
        public void BM05ScenarioSelectie02HydraulischeKortsluitingStap2DamwandSituatie3()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\5 Validatie scenarioselectie regionale keringen\02 Bepaling hydraulische kortsluiting\Stap 2\Met damwand\Situatie 3\DAM invoerfiles";
            string projectPath = Path.GetFullPath(cFolderName);
            CheckScenarioSelectionHydraulicShortcut(projectPath, HydraulicShortcutType.HydraulicShortcut);
        }

        [Test]
        public void BM05ScenarioSelectie02HydraulischeKortsluitingStap2DamwandSituatie4()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\5 Validatie scenarioselectie regionale keringen\02 Bepaling hydraulische kortsluiting\Stap 2\Met damwand\Situatie 4\DAM invoerfiles";
            string projectPath = Path.GetFullPath(cFolderName);
            CheckScenarioSelectionHydraulicShortcut(projectPath, HydraulicShortcutType.NoHydraulicShortcut);
        }

        [Test]
        public void BM05ScenarioSelectie02HydraulischeKortsluitingStap3Situatie1()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\5 Validatie scenarioselectie regionale keringen\02 Bepaling hydraulische kortsluiting\Stap 3\Situatie 1\DAM invoerfiles";
            string projectPath = Path.GetFullPath(cFolderName);
            CheckScenarioSelectionHydraulicShortcut(projectPath, HydraulicShortcutType.NoHydraulicShortcut);
        }

        [Test, Ignore("Test is not yet correct; need to work with Erik Vastenburg to fix this")]
        public void BM05ScenarioSelectie02HydraulischeKortsluitingStap3Situatie2()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\5 Validatie scenarioselectie regionale keringen\02 Bepaling hydraulische kortsluiting\Stap 3\Situatie 2\DAM invoerfiles";
            string projectPath = Path.GetFullPath(cFolderName);
            CheckScenarioSelectionHydraulicShortcut(projectPath, HydraulicShortcutType.NoHydraulicShortcut);
        }

        [Test]
        public void BM05ScenarioSelectie02HydraulischeKortsluitingStap3Situatie3()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\5 Validatie scenarioselectie regionale keringen\02 Bepaling hydraulische kortsluiting\Stap 3\Situatie 3\DAM invoerfiles";
            string projectPath = Path.GetFullPath(cFolderName);
            CheckScenarioSelectionHydraulicShortcut(projectPath, HydraulicShortcutType.NoHydraulicShortcut);
        }

        [Test, Ignore("Test is not yet correct; need to work with Erik Vastenburg to fix this")]
        public void BM05ScenarioSelectie02HydraulischeKortsluitingStap3Situatie4()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\5 Validatie scenarioselectie regionale keringen\02 Bepaling hydraulische kortsluiting\Stap 3\Situatie 4\DAM invoerfiles";
            string projectPath = Path.GetFullPath(cFolderName);
            CheckScenarioSelectionHydraulicShortcut(projectPath, HydraulicShortcutType.HydraulicShortcut);
        }

        [Test, Ignore("Test is not yet correct; need to work with Erik Vastenburg to fix this")]
        public void BM05ScenarioSelectie02HydraulischeKortsluitingStap3Situatie5()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\5 Validatie scenarioselectie regionale keringen\02 Bepaling hydraulische kortsluiting\Stap 3\Situatie 5\DAM invoerfiles";
            string projectPath = Path.GetFullPath(cFolderName);
            CheckScenarioSelectionHydraulicShortcut(projectPath, HydraulicShortcutType.HydraulicShortcut);
        }

        #endregion ScenarioSelectionHydraulischeKortsluiting

        #region ScenarioSelectionOpdrijven
        [Test]
        [Ignore("Data not available yet")]
        public void BM05ScenarioSelectie03BepalingOpdrijven()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\5 Validatie scenarioselectie regionale keringen\03 Bepaling opdrijven";
            using (DamProjectData damProjectData = DamIntegrationTestHelper.CreateDamProjectDataFromCsvFiles(cFolderName))
            {
                Assert.AreEqual(1, damProjectData.WaterBoard.Dikes.Count);
            }
        }
        #endregion ScenarioSelectionOpdrijven

        #region ScenarioSelectionBepalingScenarios
        [Test]
        [Ignore("Data not available yet")]
        public void BM05ScenarioSelectie04BepalingScenarios()
        {
            string cFolderName = @"..\..\..\data\Dam\\Benchmarks\5 Validatie scenarioselectie regionale keringen\04 Bepaling scenario_s";
            using (DamProjectData damProjectData = DamIntegrationTestHelper.CreateDamProjectDataFromCsvFiles(cFolderName))
            {
                Assert.AreEqual(1, damProjectData.WaterBoard.Dikes.Count);
            }
        }

        #endregion ScenarioSelectionBepalingScenarios

    }
}