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

using Deltares.DamEngine.Data.General;
using Deltares.DamEngine.Data.Geotechnics;
using Deltares.DamEngine.Data.Standard.Calculation;
using Deltares.DamEngine.Data.Standard.Logging;
using Deltares.DamEngine.Io.XmlInput;
using Deltares.DamEngine.Io.XmlOutput;
using NUnit.Framework;

namespace Deltares.DamEngine.Interface.Tests
{
    [TestFixture]
    public class ConversionHelperTests
    {
        [Test]
        [TestCase(InputDamProjectType.AssessmentRegional, DamProjectType.AssessmentRegional)]
        [TestCase(InputDamProjectType.Design, DamProjectType.Design)]
        [TestCase(InputDamProjectType.Operational, DamProjectType.Operational)]
        public void CanConvertToDamProjectType(InputDamProjectType inputDamProjectType, DamProjectType damProjectType)
        {
            Assert.AreEqual(damProjectType, ConversionHelper.ConvertToDamProjectType(inputDamProjectType));
        }

        [Test]
        [TestCase(DamProjectType.AssessmentRegional, InputDamProjectType.AssessmentRegional)]
        [TestCase(DamProjectType.Design, InputDamProjectType.Design)]
        [TestCase(DamProjectType.Operational, InputDamProjectType.Operational)]
        public void CanConvertToInputDamProjectType(DamProjectType damProjectType, InputDamProjectType inputDamProjectType)
        {
            Assert.AreEqual(inputDamProjectType, ConversionHelper.ConvertToInputDamProjectType(damProjectType));
        }

        [Test]
        [TestCase(PlLineCreationMethod.ExpertKnowledgeLinearInDike, LocationWaternetOptionsPhreaticLineCreationMethod.ExpertKnowledgeLinearInDike)]
        [TestCase(PlLineCreationMethod.ExpertKnowledgeRRD, LocationWaternetOptionsPhreaticLineCreationMethod.ExpertKnowledgeRRD)]
        [TestCase(PlLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD, LocationWaternetOptionsPhreaticLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD)]
        [TestCase(PlLineCreationMethod.None, LocationWaternetOptionsPhreaticLineCreationMethod.None)]
        [TestCase(PlLineCreationMethod.Sensors, LocationWaternetOptionsPhreaticLineCreationMethod.Sensors)]
        public void CanConvertToPlLineCreationMethod(PlLineCreationMethod plLineCreationMethod, LocationWaternetOptionsPhreaticLineCreationMethod inputPhreaticLineCreationMethod)
        {
            Assert.AreEqual(inputPhreaticLineCreationMethod, ConversionHelper.ConvertToInputPhreaticLineCreationMethod(plLineCreationMethod));
        }

        [Test]
        [TestCase(LocationWaternetOptionsPhreaticLineCreationMethod.ExpertKnowledgeLinearInDike, PlLineCreationMethod.ExpertKnowledgeLinearInDike)]
        [TestCase(LocationWaternetOptionsPhreaticLineCreationMethod.ExpertKnowledgeRRD, PlLineCreationMethod.ExpertKnowledgeRRD)]
        [TestCase(LocationWaternetOptionsPhreaticLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD, PlLineCreationMethod.GaugesWithFallbackToExpertKnowledgeRRD)]
        [TestCase(LocationWaternetOptionsPhreaticLineCreationMethod.None, PlLineCreationMethod.None)]
        [TestCase(LocationWaternetOptionsPhreaticLineCreationMethod.Sensors, PlLineCreationMethod.Sensors)]
        public void CanConvertToInputPlLineCreationMethod(LocationWaternetOptionsPhreaticLineCreationMethod inputPhreaticLineCreationMethod, PlLineCreationMethod plLineCreationMethod)
        {
            Assert.AreEqual(plLineCreationMethod, ConversionHelper.ConvertToPhreaticLineCreationMethod(inputPhreaticLineCreationMethod));
        }

        [Test]
        [TestCase(LocationWaternetOptionsIntrusionVerticalWaterPressure.FullHydroStatic, IntrusionVerticalWaterPressureType.FullHydroStatic)]
        [TestCase(LocationWaternetOptionsIntrusionVerticalWaterPressure.HydroStatic, IntrusionVerticalWaterPressureType.HydroStatic)]
        [TestCase(LocationWaternetOptionsIntrusionVerticalWaterPressure.Linear, IntrusionVerticalWaterPressureType.Linear)]
        [TestCase(LocationWaternetOptionsIntrusionVerticalWaterPressure.SemiTimeDependent, IntrusionVerticalWaterPressureType.SemiTimeDependent)]
        [TestCase(LocationWaternetOptionsIntrusionVerticalWaterPressure.Standard, IntrusionVerticalWaterPressureType.Standard)]
        public void CanConvertToIntrusionVerticalWaterPressureType(LocationWaternetOptionsIntrusionVerticalWaterPressure inputIntrusionVerticalWaterPressureType, IntrusionVerticalWaterPressureType intrusionVerticalWaterPressureType)
        {
            Assert.AreEqual(intrusionVerticalWaterPressureType, ConversionHelper.ConvertToIntrusionVerticalWaterPressure(inputIntrusionVerticalWaterPressureType));
        }

        [Test]
        [TestCase(IntrusionVerticalWaterPressureType.FullHydroStatic, LocationWaternetOptionsIntrusionVerticalWaterPressure.FullHydroStatic)]
        [TestCase(IntrusionVerticalWaterPressureType.HydroStatic, LocationWaternetOptionsIntrusionVerticalWaterPressure.HydroStatic)]
        [TestCase(IntrusionVerticalWaterPressureType.Linear, LocationWaternetOptionsIntrusionVerticalWaterPressure.Linear)]
        [TestCase(IntrusionVerticalWaterPressureType.SemiTimeDependent, LocationWaternetOptionsIntrusionVerticalWaterPressure.SemiTimeDependent)]
        [TestCase(IntrusionVerticalWaterPressureType.Standard, LocationWaternetOptionsIntrusionVerticalWaterPressure.Standard)]
        public void CanConvertToInputIntrusionVerticalWaterPressureType(IntrusionVerticalWaterPressureType intrusionVerticalWaterPressureType, LocationWaternetOptionsIntrusionVerticalWaterPressure inputIntrusionVerticalWaterPressureType)
        {
            Assert.AreEqual(inputIntrusionVerticalWaterPressureType, ConversionHelper.ConvertToInputIntrusionVerticalWaterPressure(intrusionVerticalWaterPressureType));
        }

        [Test]
        [TestCase(0, CalculationResult.NoRun)]
        [TestCase(1, CalculationResult.Succeeded)]
        [TestCase(2, CalculationResult.NoInput)]
        [TestCase(3, CalculationResult.NoLicense)]
        [TestCase(4, CalculationResult.UserAbort)]
        [TestCase(5, CalculationResult.InvalidInputStructure)]
        [TestCase(6, CalculationResult.InvalidInputData)]
        [TestCase(7, CalculationResult.RunFailed)]
        [TestCase(8, CalculationResult.UnexpectedError)]
        public void CanConvertToOutputCalculationResult(int result, CalculationResult calculationResult)
        {
            Assert.AreEqual(result, ConversionHelper.ConvertToOutputCalculationResult(calculationResult));
        }

        [Test]
        [TestCase(CalculationResult.NoRun, 0)]
        [TestCase(CalculationResult.Succeeded, 1)]
        [TestCase(CalculationResult.NoInput, 2)]
        [TestCase(CalculationResult.NoLicense, 3)]
        [TestCase(CalculationResult.UserAbort, 4)]
        [TestCase(CalculationResult.InvalidInputStructure, 5)]
        [TestCase(CalculationResult.InvalidInputData, 6)]
        [TestCase(CalculationResult.RunFailed, 7)]
        [TestCase(CalculationResult.UnexpectedError, 8)]
        public void CanConvertToCalculationResult(CalculationResult result, int calculationResult)
        {
            Assert.AreEqual(result, ConversionHelper.ConvertToCalculationResult(calculationResult));

        }

        [Test]
        [TestCase(ConversionHelper.CpNone, CharacteristicPointType.None)]
        [TestCase(ConversionHelper.CpSurfaceLevelOutside, CharacteristicPointType.SurfaceLevelOutside)]
        [TestCase(ConversionHelper.CpDikeToeAtRiver, CharacteristicPointType.DikeToeAtRiver)]
        [TestCase(ConversionHelper.CpShoulderTopOutside, CharacteristicPointType.ShoulderTopOutside)]
        [TestCase(ConversionHelper.CpShoulderBaseOutside, CharacteristicPointType.ShoulderBaseOutside)]
        [TestCase(ConversionHelper.CpDikeTopAtRiver, CharacteristicPointType.DikeTopAtRiver)]
        [TestCase(ConversionHelper.CpDikeLine, CharacteristicPointType.DikeLine)]
        [TestCase(ConversionHelper.CpTrafficLoadOutside, CharacteristicPointType.TrafficLoadOutside)]
        [TestCase(ConversionHelper.CpTrafficLoadInside, CharacteristicPointType.TrafficLoadInside)]
        [TestCase(ConversionHelper.CpDikeTopAtPolder, CharacteristicPointType.DikeTopAtPolder)]
        [TestCase(ConversionHelper.CpShoulderBaseInside, CharacteristicPointType.ShoulderBaseInside)]
        [TestCase(ConversionHelper.CpShoulderTopInside, CharacteristicPointType.ShoulderTopInside)]
        [TestCase(ConversionHelper.CpDikeToeAtPolder, CharacteristicPointType.DikeToeAtPolder)]
        [TestCase(ConversionHelper.CpDitchDikeSide, CharacteristicPointType.DitchDikeSide)]
        [TestCase(ConversionHelper.CpBottomDitchDikeSide, CharacteristicPointType.BottomDitchDikeSide)]
        [TestCase(ConversionHelper.CpBottomDitchPolderSide, CharacteristicPointType.BottomDitchPolderSide)]
        [TestCase(ConversionHelper.CpDitchPolderSide, CharacteristicPointType.DitchPolderSide)]
        [TestCase(ConversionHelper.CpSurfaceLevelInside, CharacteristicPointType.SurfaceLevelInside)]
        public void CanConvertToCharacteristicPointType(int inputPointType, CharacteristicPointType characteristicPointType)
        {
            Assert.AreEqual(characteristicPointType, ConversionHelper.ConvertToDamPointType(inputPointType));
        }

        [Test]
        [TestCase(CharacteristicPointType.None, ConversionHelper.CpNone)]
        [TestCase(CharacteristicPointType.SurfaceLevelOutside, ConversionHelper.CpSurfaceLevelOutside)]
        [TestCase(CharacteristicPointType.DikeToeAtRiver, ConversionHelper.CpDikeToeAtRiver)]
        [TestCase(CharacteristicPointType.ShoulderTopOutside, ConversionHelper.CpShoulderTopOutside)]
        [TestCase(CharacteristicPointType.ShoulderBaseOutside, ConversionHelper.CpShoulderBaseOutside)]
        [TestCase(CharacteristicPointType.DikeTopAtRiver, ConversionHelper.CpDikeTopAtRiver)]
        [TestCase(CharacteristicPointType.DikeLine, ConversionHelper.CpDikeLine)]
        [TestCase(CharacteristicPointType.TrafficLoadOutside, ConversionHelper.CpTrafficLoadOutside)]
        [TestCase(CharacteristicPointType.TrafficLoadInside, ConversionHelper.CpTrafficLoadInside)]
        [TestCase(CharacteristicPointType.DikeTopAtPolder, ConversionHelper.CpDikeTopAtPolder)]
        [TestCase(CharacteristicPointType.ShoulderBaseInside, ConversionHelper.CpShoulderBaseInside)]
        [TestCase(CharacteristicPointType.ShoulderTopInside, ConversionHelper.CpShoulderTopInside)]
        [TestCase(CharacteristicPointType.DikeToeAtPolder, ConversionHelper.CpDikeToeAtPolder)]
        [TestCase(CharacteristicPointType.DitchDikeSide, ConversionHelper.CpDitchDikeSide)]
        [TestCase(CharacteristicPointType.BottomDitchDikeSide, ConversionHelper.CpBottomDitchDikeSide)]
        [TestCase(CharacteristicPointType.BottomDitchPolderSide, ConversionHelper.CpBottomDitchPolderSide)]
        [TestCase(CharacteristicPointType.DitchPolderSide, ConversionHelper.CpDitchPolderSide)]
        [TestCase(CharacteristicPointType.SurfaceLevelInside, ConversionHelper.CpSurfaceLevelInside)]
        public void CanConvertToInputPointType(CharacteristicPointType characteristicPointType, int inputPointType)
        {
            Assert.AreEqual(inputPointType, ConversionHelper.ConvertToInputPointType(characteristicPointType));
        }

        [Test]
        [TestCase(0, WaterpressureInterpolationModel.Automatic)]
        [TestCase(1, WaterpressureInterpolationModel.Hydrostatic)]
        public void CanConvertToWaterpressureInterpolationModel(int inputInterpolationModel, WaterpressureInterpolationModel interpolationModel)
        {
            Assert.AreEqual(interpolationModel, ConversionHelper.ConvertToWaterpressureInterpolationModel(inputInterpolationModel));
        }

        [Test]
        [TestCase(SoilProfileType.ProfileType1D, 0)]
        [TestCase(SoilProfileType.ProfileType2D, 1)]
        [TestCase(SoilProfileType.ProfileTypeStiFile, 2)]
        public void CanConvertToInputSoilGeometryType(SoilProfileType soilProfileType, int inputSoilGeometryType)
        {
            Assert.AreEqual(inputSoilGeometryType, ConversionHelper.ConvertToInputSoilGeometryType(soilProfileType));
        }

        [Test]
        [TestCase(0, SoilProfileType.ProfileType1D)]
        [TestCase(1, SoilProfileType.ProfileType2D)]
        [TestCase(2, SoilProfileType.ProfileTypeStiFile)]
        public void CanConvertToSoilGeometryType(int inputSoilGeometryType, SoilProfileType soilProfileType)
        {
            Assert.AreEqual(soilProfileType, ConversionHelper.ConvertToSoilGeometryType(inputSoilGeometryType));
        }

        [Test]
        [TestCase(FailureMechanismSystemType.StabilityInside, 0)]
        [TestCase(FailureMechanismSystemType.StabilityOutside, 1)]
        [TestCase(FailureMechanismSystemType.Piping, 2)]
        [TestCase(FailureMechanismSystemType.HorizontalBalance, 3)]
        public void CanConvertToInputFailureMechanismSystemType(FailureMechanismSystemType failureMechanismSystemType, int inputFailureMechanismSystemType)
        {
            Assert.AreEqual(inputFailureMechanismSystemType, ConversionHelper.ConvertToInputFailureMechanismSystemType(failureMechanismSystemType));
        }

        [Test]
        [TestCase(0, FailureMechanismSystemType.StabilityInside)]
        [TestCase(1, FailureMechanismSystemType.StabilityOutside)]
        [TestCase(2, FailureMechanismSystemType.Piping)]
        [TestCase(3, FailureMechanismSystemType.HorizontalBalance)]
        public void CanConvertToFailureMechanismSystemType(int inputFailureMechanismSystemType, FailureMechanismSystemType failureMechanismSystemType)
        {
            Assert.AreEqual(failureMechanismSystemType, ConversionHelper.ConvertToFailureMechanismSystemType(inputFailureMechanismSystemType));
        }

        [Test]
        [TestCase(AnalysisType.AdaptGeometry, InputAnalysisType.AdaptGeometry)]
        [TestCase(AnalysisType.NoAdaption, InputAnalysisType.NoAdaption)]
        public void CanConvertToInputAnalysisType(AnalysisType analysisType, InputAnalysisType inputAnalysisType)
        {
            Assert.AreEqual(inputAnalysisType, ConversionHelper.ConvertToInputAnalysisType(analysisType));
        }

        [Test]
        [TestCase(InputAnalysisType.AdaptGeometry, AnalysisType.AdaptGeometry)]
        [TestCase(InputAnalysisType.NoAdaption, AnalysisType.NoAdaption)]
        public void CanConvertToAnalysisType(InputAnalysisType inputAnalysisType, AnalysisType analysisType)
        {
            Assert.AreEqual(analysisType, ConversionHelper.ConvertToAnalysisType(inputAnalysisType));
        }

        [Test]
        [TestCase(MStabZonesType.NoZones, ConversionHelper.InputZoneTypeNoZones)]
        [TestCase(MStabZonesType.ZoneAreas, ConversionHelper.InputZoneTypeZoneAreas)]
        [TestCase(MStabZonesType.ForbiddenZone, ConversionHelper.InputZoneTypesForbiddenZones)]
        public void CanConvertToInputZoneType(MStabZonesType zoneType, int inputZoneType)
        {
            Assert.AreEqual(inputZoneType, ConversionHelper.ConvertToInputZoneType(zoneType));
        }

        [Test]
        [TestCase(ConversionHelper.InputZoneTypeNoZones, MStabZonesType.NoZones)]
        [TestCase(ConversionHelper.InputZoneTypeZoneAreas, MStabZonesType.ZoneAreas)]
        [TestCase(ConversionHelper.InputZoneTypesForbiddenZones, MStabZonesType.ForbiddenZone)]
        public void CanConvertToZoneType(int inputZoneType, MStabZonesType zoneType)
        {
            Assert.AreEqual(zoneType, ConversionHelper.ConvertToZoneType(inputZoneType));
        }

        [Test]
        [TestCase(MStabSearchMethod.Grid, ConversionHelper.InputSearchMethodGrid)]
        [TestCase(MStabSearchMethod.GeneticAlgorithm, ConversionHelper.InputSearchMethodGenetic)]
        public void CanConvertToInputSearchMethod(MStabSearchMethod searchMethod, int inputSearchMethod)
        {
            Assert.AreEqual(inputSearchMethod, ConversionHelper.ConvertToInputSearchMethod(searchMethod));
        }

        [Test]
        [TestCase(ConversionHelper.InputSearchMethodGrid, MStabSearchMethod.Grid)]
        [TestCase(ConversionHelper.InputSearchMethodGenetic, MStabSearchMethod.GeneticAlgorithm)]
        public void CanConvertToSearchMethod(int inputSearchMethod, MStabSearchMethod searchMethod)
        {
            Assert.AreEqual(searchMethod, ConversionHelper.ConvertToSearchMethod(inputSearchMethod));
        }

        [Test]
        [TestCase(LogMessageType.Error, MessageMessageType.Error)]
        [TestCase(LogMessageType.Debug, MessageMessageType.Info)]
        [TestCase(LogMessageType.FatalError, MessageMessageType.Error)]
        [TestCase(LogMessageType.Info, MessageMessageType.Info)]
        [TestCase(LogMessageType.Trace, MessageMessageType.Info)]
        [TestCase(LogMessageType.Warning, MessageMessageType.Warning)]
        public void CanConvertToInputMessageType(LogMessageType logMessageType, MessageMessageType messageType)
        {
            Assert.AreEqual(messageType, ConversionHelper.ConvertToInputMessageType(logMessageType));
        }

        [Test]
        [TestCase(MessageMessageType.Error, LogMessageType.Error)]
        [TestCase(MessageMessageType.Info, LogMessageType.Info)]
        [TestCase(MessageMessageType.Warning, LogMessageType.Warning)]
        public void CanConvertToMessageType(MessageMessageType messageType, LogMessageType logMessageType)
        {
            Assert.AreEqual(logMessageType, ConversionHelper.ConvertToLogMessageType(messageType));
        }

        [Test]
        [TestCase(ShearStrengthModel.None, SoilShearStrengthModel.None)]
        [TestCase(ShearStrengthModel.CPhi, SoilShearStrengthModel.CPhi)]
        [TestCase(ShearStrengthModel.StressTable, SoilShearStrengthModel.StressTable)]
        [TestCase(ShearStrengthModel.PseudoValues, SoilShearStrengthModel.PseudoValues)]
        [TestCase(ShearStrengthModel.SuMeasured, SoilShearStrengthModel.SuMeasured)]
        [TestCase(ShearStrengthModel.SuCalculated, SoilShearStrengthModel.SuCalculated)]
        [TestCase(ShearStrengthModel.SuGradient, SoilShearStrengthModel.SuGradient)]
        [TestCase(ShearStrengthModel.SuCalculatedWithYield, SoilShearStrengthModel.SuCalculatedWithYield)]
        [TestCase(ShearStrengthModel.CPhiOrSuCalculated, SoilShearStrengthModel.CPhiOrSuCalculated)]
        public void CanConvertToSoilShearStrengthModel(ShearStrengthModel shearStrengthModel, SoilShearStrengthModel soilShearStrengthModel)
        {
            Assert.AreEqual(soilShearStrengthModel, ConversionHelper.ConvertToSoilShearStrengthModel(shearStrengthModel));
        }

        [Test]
        [TestCase(GridSizeDetermination.Automatic, ConversionHelper.InputGridTypeAutomatic)]
        [TestCase(GridSizeDetermination.Specified, ConversionHelper.InputGridTypeSpecified)]
        public void CanConvertToInputGridSizeDetermination(GridSizeDetermination gridDetermination, int inputGridDetermination)
        {
            Assert.AreEqual(inputGridDetermination, ConversionHelper.ConvertToInputGridDetermination(gridDetermination));
        }

        [Test]
        [TestCase(ConversionHelper.InputGridTypeAutomatic, GridSizeDetermination.Automatic)]
        [TestCase(ConversionHelper.InputGridTypeSpecified, GridSizeDetermination.Specified)]
        public void CanConvertToGridSizeDetermination(int inputGridDetermination, GridSizeDetermination gridDetermination)
        {
            Assert.AreEqual(gridDetermination, ConversionHelper.ConvertToGridDetermination(inputGridDetermination));
        }

        [Test]
        [TestCase(SoilShearStrengthModel.None, ShearStrengthModel.None)]
        [TestCase(SoilShearStrengthModel.CPhi, ShearStrengthModel.CPhi)]
        [TestCase(SoilShearStrengthModel.StressTable, ShearStrengthModel.StressTable)]
        [TestCase(SoilShearStrengthModel.PseudoValues, ShearStrengthModel.PseudoValues)]
        [TestCase(SoilShearStrengthModel.SuMeasured, ShearStrengthModel.SuMeasured)]
        [TestCase(SoilShearStrengthModel.SuCalculated, ShearStrengthModel.SuCalculated)]
        [TestCase(SoilShearStrengthModel.SuGradient, ShearStrengthModel.SuGradient)]
        [TestCase(SoilShearStrengthModel.SuCalculatedWithYield, ShearStrengthModel.SuCalculatedWithYield)]
        [TestCase(SoilShearStrengthModel.CPhiOrSuCalculated, ShearStrengthModel.CPhiOrSuCalculated)]
        public void CanConvertToShearStrengthModel(SoilShearStrengthModel soilShearStrengthModel, ShearStrengthModel shearStrengthModel)
        {
            Assert.AreEqual(shearStrengthModel, ConversionHelper.ConvertToShearStrengthModel(soilShearStrengthModel));
        }

        [Test]
        [TestCase(TangentLinesDefinition.OnBoundaryLines, ConversionHelper.InputTangentLinesOnBoundatyLines)]
        [TestCase(TangentLinesDefinition.Specified, ConversionHelper.InputTangentLinesSpecified)]
        public void CanConvertToInputTangentLinesDefinition(TangentLinesDefinition tangentLineType, int inputTangentLineType)
        {
            Assert.AreEqual(inputTangentLineType, ConversionHelper.ConvertToInputTangentLinesDefinition(tangentLineType));
        }

        [Test]
        [TestCase(ConversionHelper.InputTangentLinesOnBoundatyLines, TangentLinesDefinition.OnBoundaryLines)]
        [TestCase(ConversionHelper.InputTangentLinesSpecified, TangentLinesDefinition.Specified)]
        public void CanConvertToTangentLinesDefinition(int inputTangentLineType, TangentLinesDefinition tangentLineType)
        {
            Assert.AreEqual(tangentLineType, ConversionHelper.ConvertToTangentLinesDefinition(inputTangentLineType));
        }

        [Test]
        [TestCase(DilatancyType.Zero, SoilDilatancyType.Zero)]
        [TestCase(DilatancyType.Phi, SoilDilatancyType.Phi)]
        [TestCase(DilatancyType.MinusPhi, SoilDilatancyType.MinusPhi)]
        public void CanConvertToSoilDilatancyType(DilatancyType dilatancyType, SoilDilatancyType soilDilatancyType)
        {
            Assert.AreEqual(soilDilatancyType, ConversionHelper.ConvertToSoilDilatancyType(dilatancyType));
        }

        [Test]
        [TestCase(SoilDilatancyType.Zero, DilatancyType.Zero)]
        [TestCase(SoilDilatancyType.Phi, DilatancyType.Phi)]
        [TestCase(SoilDilatancyType.MinusPhi, DilatancyType.MinusPhi)]
        public void CanConvertToDilatancyType(SoilDilatancyType soilDilatancyType, DilatancyType dilatancyType)
        {
            Assert.AreEqual(dilatancyType, ConversionHelper.ConvertToDilatancyType(soilDilatancyType));
        }

        [Test]
        [TestCase(LocationDesignOptionsStabilityDesignMethod.SlopeAdaptionBeforeShoulderAdaption, StabilityDesignMethod.SlopeAdaptionBeforeShoulderAdaption)]
        [TestCase(LocationDesignOptionsStabilityDesignMethod.OptimizedSlopeAndShoulderAdaption, StabilityDesignMethod.OptimizedSlopeAndShoulderAdaption)]
        public void CanConvertToInputStabilityDesignMethod(LocationDesignOptionsStabilityDesignMethod inputStabilityDesignMethod, StabilityDesignMethod stabilityDesignMethod)
        {
            Assert.AreEqual(stabilityDesignMethod, ConversionHelper.ConvertToDamStabilityDesignMethod(inputStabilityDesignMethod));
        }

        [Test]
        [TestCase(StabilityDesignMethod.SlopeAdaptionBeforeShoulderAdaption, LocationDesignOptionsStabilityDesignMethod.SlopeAdaptionBeforeShoulderAdaption)]
        [TestCase(StabilityDesignMethod.OptimizedSlopeAndShoulderAdaption, LocationDesignOptionsStabilityDesignMethod.OptimizedSlopeAndShoulderAdaption)]
        public void CanConvertToDamStabilityDesignMethod(StabilityDesignMethod stabilityDesignMethod, LocationDesignOptionsStabilityDesignMethod inputStabilityDesignMethod)
        {
            Assert.AreEqual(inputStabilityDesignMethod, ConversionHelper.ConvertToInputStabilityDesignMethod(stabilityDesignMethod));
        }

        [Test]
        [TestCase(LoadSituation.Dry, 0)]
        [TestCase(LoadSituation.Wet, 1)]
        public void CanConvertToOutputLoadSituation(LoadSituation loadSituation, int outputLoadSituation)
        {
            Assert.AreEqual(outputLoadSituation, ConversionHelper.ConvertToOutputLoadSituation(loadSituation));
        }

        [Test]
        [TestCase(0, LoadSituation.Dry)]
        [TestCase(1, LoadSituation.Wet)]
        public void CanConvertToLoadSituation(int outputLoadSituation, LoadSituation loadSituation)
        {
            Assert.AreEqual(loadSituation, ConversionHelper.ConvertToLoadSituation(outputLoadSituation));
        }

        [Test]
        [TestCase(DikeDrySensitivity.None, 0)]
        [TestCase(DikeDrySensitivity.Dry, 1)]
        public void CanConvertToOutputDikeDrySensitivity(DikeDrySensitivity dikeDrySensitivity, int outputDikeDrySensitivity)
        {
            Assert.AreEqual(outputDikeDrySensitivity, ConversionHelper.ConvertToOutputDikeDrySensitivity(dikeDrySensitivity));
        }

        [Test]
        [TestCase(0, DikeDrySensitivity.None)]
        [TestCase(1, DikeDrySensitivity.Dry)]
        public void CanConvertToDikeDrySensitivity(int outputDikeDrySensitivity, DikeDrySensitivity dikeDrySensitivity)
        {
            Assert.AreEqual(dikeDrySensitivity, ConversionHelper.ConvertToDikeDrySensitivity(outputDikeDrySensitivity));
        }


        [Test]
        [TestCase(HydraulicShortcutType.HydraulicShortcut, 0)]
        [TestCase(HydraulicShortcutType.NoHydraulicShortcut, 1)]
        public void CanConvertToOutputHydraulicShortcutType(HydraulicShortcutType hydraulicShortcutType, int outputHydraulicShortcutType)
        {
            Assert.AreEqual(outputHydraulicShortcutType, ConversionHelper.ConvertToOutputHydraulicShortcutType(hydraulicShortcutType));
        }

        [Test]
        [TestCase(0, HydraulicShortcutType.HydraulicShortcut)]
        [TestCase(1, HydraulicShortcutType.NoHydraulicShortcut)]
        public void CanConvertToHydraulicShortcutType(int outputHydraulicShortcutType, HydraulicShortcutType hydraulicShortcutType)
        {
            Assert.AreEqual(hydraulicShortcutType, ConversionHelper.ConvertToHydraulicShortcutType(outputHydraulicShortcutType));
        }

        [Test]
        [TestCase(UpliftType.Uplift, 0)]
        [TestCase(UpliftType.NoUplift, 1)]
        public void CanConvertToOutputUpliftType(UpliftType upliftType, int outputUpliftType)
        {
            Assert.AreEqual(outputUpliftType, ConversionHelper.ConvertToOutputUpliftType(upliftType));
        }

        [Test]
        [TestCase(0, UpliftType.Uplift)]
        [TestCase(1, UpliftType.NoUplift)]
        public void CanConvertToUpliftType(int outputUpliftType, UpliftType upliftType)
        {
            Assert.AreEqual(upliftType, ConversionHelper.ConvertToUpliftType(outputUpliftType));
        }

        [Test]
        [TestCase(MStabModelType.Bishop, 0)]
        [TestCase(MStabModelType.Spencer, 1)]
        [TestCase(MStabModelType.Fellenius, 2)]
        [TestCase(MStabModelType.UpliftVan, 3)]
        [TestCase(MStabModelType.UpliftSpencer, 4)]
        [TestCase(MStabModelType.BishopRandomField, 5)]
        [TestCase(MStabModelType.HorizontalBalance, 6)]
        [TestCase(MStabModelType.BishopUpliftVan, 7)]
        [TestCase(MStabModelType.SpencerHigh, 8)]
        [TestCase(MStabModelType.SpencerLow, 9)]
        public void CanConvertToOutputMStabModelType(MStabModelType mStabModelType, int outputMStabModelType)
        {
            Assert.AreEqual(outputMStabModelType, ConversionHelper.ConvertToOutputMStabModelType(mStabModelType));
        }

        [Test]
        [TestCase(0, MStabModelType.Bishop)]
        [TestCase(1, MStabModelType.Spencer)]
        [TestCase(2, MStabModelType.Fellenius)]
        [TestCase(3, MStabModelType.UpliftVan)]
        [TestCase(4, MStabModelType.UpliftSpencer)]
        [TestCase(5, MStabModelType.BishopRandomField)]
        [TestCase(6, MStabModelType.HorizontalBalance)]
        [TestCase(7, MStabModelType.BishopUpliftVan)]
        [TestCase(8, MStabModelType.SpencerHigh)]
        [TestCase(9, MStabModelType.SpencerLow)]
        public void CanConvertToMStabModelType(int outputMStabModelType, MStabModelType mStabModelType)
        {
            Assert.AreEqual(mStabModelType, ConversionHelper.ConvertToMStabModelType(outputMStabModelType));
        }

        [Test]
        [TestCase(ScenarioType.Scenario01, 0)]
        [TestCase(ScenarioType.Scenario02, 1)]
        [TestCase(ScenarioType.Scenario03, 2)]
        [TestCase(ScenarioType.Scenario04, 3)]
        [TestCase(ScenarioType.Scenario05, 4)]
        [TestCase(ScenarioType.Scenario06, 5)]
        [TestCase(ScenarioType.Scenario07, 6)]
        [TestCase(ScenarioType.Scenario08, 7)]
        [TestCase(ScenarioType.Scenario09, 8)]
        [TestCase(ScenarioType.Scenario10, 9)]
        [TestCase(ScenarioType.Scenario11, 10)]
        public void CanConvertToOutputScenarioType(ScenarioType scenarioType, int outputScenarioType)
        {
            Assert.AreEqual(outputScenarioType, ConversionHelper.ConvertToOutputScenarioType(scenarioType));
        }

        [Test]
        [TestCase(0, ScenarioType.Scenario01)]
        [TestCase(1, ScenarioType.Scenario02)]
        [TestCase(2, ScenarioType.Scenario03)]
        [TestCase(3, ScenarioType.Scenario04)]
        [TestCase(4, ScenarioType.Scenario05)]
        [TestCase(5, ScenarioType.Scenario06)]
        [TestCase(6, ScenarioType.Scenario07)]
        [TestCase(7, ScenarioType.Scenario08)]
        [TestCase(8, ScenarioType.Scenario09)]
        [TestCase(9, ScenarioType.Scenario10)]
        [TestCase(10, ScenarioType.Scenario11)]
        public void CanConvertToScenarioType(int outputScenarioType, ScenarioType scenarioType)
        {
            Assert.AreEqual(scenarioType, ConversionHelper.ConvertToScenarioType(outputScenarioType));
        }

        [Test]
        [TestCase(PipingModelType.Bligh, 0)]
        [TestCase(PipingModelType.SellmeijerVnk, 1)]
        [TestCase(PipingModelType.Sellmeijer4Forces, 2)]
        [TestCase(PipingModelType.Wti2017, 3)]        
        public void CanConvertToOutputPipingModelType(PipingModelType pipingModelType, int outputPipingModelType)
        {
            Assert.AreEqual(outputPipingModelType, ConversionHelper.ConvertToOutputPipingModelType(pipingModelType));
        }

        [Test]
        [TestCase(0, PipingModelType.Bligh)]
        [TestCase(1, PipingModelType.SellmeijerVnk)]
        [TestCase(2, PipingModelType.Sellmeijer4Forces)]
        [TestCase(3, PipingModelType.Wti2017)]
        public void CanConvertToPipingModelType(int outputPipingModelType, PipingModelType pipingModelType)
        {
            Assert.AreEqual(pipingModelType, ConversionHelper.ConvertToPipingModelType(outputPipingModelType));
        }

        [Test]
        [TestCase(PipingModelType.Bligh, InputPipingModelType.Bligh)]
        [TestCase(PipingModelType.SellmeijerVnk, InputPipingModelType.SellmeijerVnk)]
        [TestCase(PipingModelType.Sellmeijer4Forces, InputPipingModelType.Sellmeijer4Forces)]
        [TestCase(PipingModelType.Wti2017, InputPipingModelType.WbiSellmeijerRevised)]
        public void CanConvertToInputPipingModelType(PipingModelType pipingModelType, InputPipingModelType outputPipingModelType)
        {
            Assert.AreEqual(outputPipingModelType, ConversionHelper.ConvertToInputPipingModelType(pipingModelType));
        }

        [Test]
        [TestCase(InputPipingModelType.Bligh, PipingModelType.Bligh)]
        [TestCase(InputPipingModelType.SellmeijerVnk, PipingModelType.SellmeijerVnk)]
        [TestCase(InputPipingModelType.Sellmeijer4Forces, PipingModelType.Sellmeijer4Forces)]
        [TestCase(InputPipingModelType.WbiSellmeijerRevised, PipingModelType.Wti2017)]
        public void CanConvertToPipingModelType(InputPipingModelType outputPipingModelType, PipingModelType pipingModelType)
        {
            Assert.AreEqual(pipingModelType, ConversionHelper.ConvertToPipingModelType(outputPipingModelType));
        }

        [Test]
        [TestCase(RegionalResultType.ProbabilityOfFailure, 0)]
        [TestCase(RegionalResultType.SafetyFactor, 1)]
        public void CanConvertToOutputRegionalResultType(RegionalResultType regionalResultType, int outputRegionalResultType)
        {
            Assert.AreEqual(outputRegionalResultType, ConversionHelper.ConvertToOutputRegionalResultType(regionalResultType));
        }

        [Test]
        [TestCase(0, RegionalResultType.ProbabilityOfFailure)]
        [TestCase(1, RegionalResultType.SafetyFactor)]
        public void CanConvertToRegionalResultType(int outputRegionalResultType, RegionalResultType regionalResultType)
        {
            Assert.AreEqual(regionalResultType, ConversionHelper.ConvertToRegionalResultType(outputRegionalResultType));
        }

        [Test]
        [TestCase(ConversionHelper.SoilTypeClay, SoilType.Clay)]
        [TestCase(ConversionHelper.SoilTypeGravel, SoilType.Gravel)]
        [TestCase(ConversionHelper.SoilTypeLoam, SoilType.Loam)]
        [TestCase(ConversionHelper.SoilTypePeat, SoilType.Peat)]
        [TestCase(ConversionHelper.SoilTypeSand, SoilType.Sand)]
        public void CanConvertToSoilType(int dikeSoilType, SoilType soilType)
        {
            Assert.AreEqual(soilType, ConversionHelper.ConvertToSoilType(dikeSoilType));
        }

        [Test]
        [TestCase(SoilType.Clay, ConversionHelper.SoilTypeClay)]
        [TestCase(SoilType.Gravel, ConversionHelper.SoilTypeGravel)]
        [TestCase(SoilType.Loam, ConversionHelper.SoilTypeLoam)]
        [TestCase(SoilType.Peat, ConversionHelper.SoilTypePeat)]
        [TestCase(SoilType.Sand, ConversionHelper.SoilTypeSand)]
        public void CanConvertToDikeMaterialType(SoilType soilType, int dikeSoilType)
        {
            Assert.AreEqual(dikeSoilType, ConversionHelper.ConvertToInputSoilType(soilType));
        }

        [Test]
        [TestCase(DesignResultStabilityDesignResultsStabilityModelType.Bishop, MStabModelType.Bishop)]
        [TestCase(DesignResultStabilityDesignResultsStabilityModelType.UpliftVan, MStabModelType.UpliftVan)]
        [TestCase(DesignResultStabilityDesignResultsStabilityModelType.BishopUpliftVan, MStabModelType.BishopUpliftVan)]
        public void CanConvertToOutputStabilityModelType(DesignResultStabilityDesignResultsStabilityModelType outputStabilityModelType,
            MStabModelType stabilityModelType)
        {
            Assert.AreEqual(outputStabilityModelType, ConversionHelper.ConvertToOutputStabilityModelType(stabilityModelType));
        }

        [Test]
        [TestCase(MStabModelType.Bishop, DesignResultStabilityDesignResultsStabilityModelType.Bishop)]
        [TestCase(MStabModelType.UpliftVan, DesignResultStabilityDesignResultsStabilityModelType.UpliftVan)]
        [TestCase(MStabModelType.BishopUpliftVan, DesignResultStabilityDesignResultsStabilityModelType.BishopUpliftVan)]
        public void CanConvertToStabilityModelType(MStabModelType stabilityModelType,
            DesignResultStabilityDesignResultsStabilityModelType outputStabilityModelType)
        {
            Assert.AreEqual(stabilityModelType, ConversionHelper.ConvertToStabilityModelType(outputStabilityModelType));
        }

        [Test]
        [TestCase(ConversionHelper.TimeStepUnitSecond, TimeStepUnit.Second)]
        [TestCase(ConversionHelper.TimeStepUnitMinute, TimeStepUnit.Minute)]
        [TestCase(ConversionHelper.TimeStepUnitHour, TimeStepUnit.Hour)]
        [TestCase(ConversionHelper.TimeStepUnitDay, TimeStepUnit.Day)]
        [TestCase(ConversionHelper.TimeStepUnitMonth, TimeStepUnit.Month)]
        [TestCase(ConversionHelper.TimeStepUnitWeek, TimeStepUnit.Week)]
        [TestCase(ConversionHelper.TimeStepUnitYear, TimeStepUnit.Year)]
        [TestCase(ConversionHelper.TimeStepUnitNonequidistant, TimeStepUnit.Nonequidistant)]
        public void CanConvertToTimeStepUnit(uint inputTimeStepUnit, TimeStepUnit timeStepUnit)
        {
            Assert.AreEqual(timeStepUnit, ConversionHelper.ConvertToTimeStepUnit(inputTimeStepUnit));
        }

        [Test]
        [TestCase(TimeStepUnit.Second, ConversionHelper.TimeStepUnitSecond)]
        [TestCase(TimeStepUnit.Minute, ConversionHelper.TimeStepUnitMinute)]
        [TestCase(TimeStepUnit.Hour, ConversionHelper.TimeStepUnitHour)]
        [TestCase(TimeStepUnit.Day, ConversionHelper.TimeStepUnitDay)]
        [TestCase(TimeStepUnit.Month, ConversionHelper.TimeStepUnitMonth)]
        [TestCase(TimeStepUnit.Week, ConversionHelper.TimeStepUnitWeek)]
        [TestCase(TimeStepUnit.Year, ConversionHelper.TimeStepUnitYear)]
        [TestCase(TimeStepUnit.Nonequidistant, ConversionHelper.TimeStepUnitNonequidistant)]
        public void CanConvertToInputTimeStepUnit(TimeStepUnit timeStepUnit, uint inputTimeStepUnit)
        {
            Assert.AreEqual(inputTimeStepUnit, ConversionHelper.ConvertToInputTimeStepUnit(timeStepUnit));
        }

        [TestCase(ConversionHelper.PlLineTypePl1, PlLineType.Pl1)]
        [TestCase(ConversionHelper.PlLineTypePl2, PlLineType.Pl2)]
        [TestCase(ConversionHelper.PlLineTypePl3, PlLineType.Pl3)]
        [TestCase(ConversionHelper.PlLineTypePl4, PlLineType.Pl4)]
        public void CanConvertToPlLineType(uint inputPlLineType, PlLineType plLineType)
        {
            Assert.AreEqual(plLineType, ConversionHelper.ConvertToPlLineType(inputPlLineType));
        }

        [TestCase(PlLineType.Pl1, ConversionHelper.PlLineTypePl1)]
        [TestCase(PlLineType.Pl2, ConversionHelper.PlLineTypePl2)]
        [TestCase(PlLineType.Pl3, ConversionHelper.PlLineTypePl3)]
        [TestCase(PlLineType.Pl4, ConversionHelper.PlLineTypePl4)]
        public void CanConvertToInputPlLineType(PlLineType plLineType, uint inputPlLineType)
        {
            Assert.AreEqual(inputPlLineType, ConversionHelper.ConvertToInputPlLineType(plLineType));
        }

        [TestCase(ConversionHelper.SensorTypePiezometricHead, SensorType.PiezometricHead)]
        [TestCase(ConversionHelper.SensorTypeWaterLevel, SensorType.WaterLevel)]
        [TestCase(ConversionHelper.SensorTypePolderLevel, SensorType.PolderLevel)]
        public void CanConvertToSensorType(uint inputSensorType, SensorType sensorType)
        {
            Assert.AreEqual(sensorType, ConversionHelper.ConvertToSensorType(inputSensorType));
        }

        [TestCase(SensorType.PiezometricHead, ConversionHelper.SensorTypePiezometricHead)]
        [TestCase(SensorType.WaterLevel, ConversionHelper.SensorTypeWaterLevel)]
        [TestCase(SensorType.PolderLevel, ConversionHelper.SensorTypePolderLevel)]
        public void CanConvertToInputSensorType(SensorType sensorType, uint inputSensorType)
        {
            Assert.AreEqual(inputSensorType, ConversionHelper.ConvertToInputSensorType(sensorType));
        }

        [TestCase(ConversionHelper.DataSourceTypeSensorsIgnore, DataSourceTypeSensors.Ignore)]
        [TestCase(ConversionHelper.DataSourceTypeSensorsLocationData, DataSourceTypeSensors.LocationData)]
        [TestCase(ConversionHelper.DataSourceTypeSensorsSensor, DataSourceTypeSensors.Sensor)]
        public void CanConvertToSensorType(uint inputdataSourceTypeSensors, DataSourceTypeSensors dataSourceTypeSensors)
        {
            Assert.AreEqual(dataSourceTypeSensors, ConversionHelper.ConvertToDataSourceTypeSensors(inputdataSourceTypeSensors));
        }

        [TestCase(DataSourceTypeSensors.Ignore, ConversionHelper.DataSourceTypeSensorsIgnore)]
        [TestCase(DataSourceTypeSensors.LocationData, ConversionHelper.DataSourceTypeSensorsLocationData)]
        [TestCase(DataSourceTypeSensors.Sensor, ConversionHelper.DataSourceTypeSensorsSensor)]
        public void CanConvertToInputSensorType(DataSourceTypeSensors dataSourceTypeSensors, uint inputdataSourceTypeSensors)
        {
            Assert.AreEqual(inputdataSourceTypeSensors, ConversionHelper.ConvertToInputDataSourceTypeSensors(dataSourceTypeSensors));
        }
    }
}