// Copyright (C) Stichting Deltares 2023. 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;
using Deltares.Dam.Data;
using Deltares.Dam.Data.DamEngineIo;
using Deltares.DamEngine.Io.XmlInput;
using Deltares.DamEngine.Io.XmlOutput;
using Deltares.Geotechnics;
using Deltares.Geotechnics.Soils;
using Deltares.Geotechnics.SurfaceLines;
using Deltares.Standard;
using Deltares.Standard.Extensions;
using Deltares.Standard.Logging;
using NUnit.Framework;

namespace Deltares.Dam.Tests.DamEngineIo;

[TestFixture]
public class ConversionHelperTests
{
    [Test]
    [TestCase(InputDamProjectType.Design, DamProjectType.Design)]
    [TestCase(InputDamProjectType.Operational, DamProjectType.Calamity)]
    public void CanConvertToDamProjectType(InputDamProjectType inputDamProjectType, DamProjectType damProjectType)
    {
        Assert.AreEqual(damProjectType, ConversionHelper.ConvertToDamProjectType(inputDamProjectType));
    }

    [Test]
    [TestCase(DamProjectType.Design, InputDamProjectType.Design)]
    [TestCase(DamProjectType.Calamity, 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(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, 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(0, WaterpressureInterpolationModel.Automatic)]
    [TestCase(1, WaterpressureInterpolationModel.Hydrostatic)]
    public void CanConvertToWaterpressureInterpolationModel(int inputInterpolationModel, WaterpressureInterpolationModel interpolationModel)
    {
        Assert.AreEqual(interpolationModel, ConversionHelper.ConvertToWaterpressureInterpolationModel(inputInterpolationModel));
    }

    [Test]
    [TestCase(SoilProfileType.SoilProfile1D, 0)]
    [TestCase(SoilProfileType.SoilGeometryStiFile, 2)]
    public void CanConvertToInputSoilGeometryType(SoilProfileType soilProfileType, int inputSoilGeometryType)
    {
        Assert.AreEqual(inputSoilGeometryType, ConversionHelper.ConvertToInputSoilProfileType(soilProfileType));
    }

    [Test]
    [TestCase(0, SoilProfileType.SoilProfile1D)]
    [TestCase(2, SoilProfileType.SoilGeometryStiFile)]
    public void CanConvertToSoilGeometryType(int inputSoilGeometryType, SoilProfileType soilProfileType)
    {
        Assert.AreEqual(soilProfileType, ConversionHelper.ConvertToSoilProfileType(inputSoilGeometryType));
    }

    [Test]
    [TestCase(FailureMechanismSystemType.StabilityInside, ConversionHelper.InputFailureMechanismStabilityInside)]
    [TestCase(FailureMechanismSystemType.StabilityOutside, ConversionHelper.InputFailureMechanismStabilityOutside)]
    [TestCase(FailureMechanismSystemType.Piping, ConversionHelper.InputFailureMechanismPiping)]
    public void CanConvertToInputFailureMechanismSystemType(FailureMechanismSystemType failureMechanismSystemType, int inputFailureMechanismSystemType)
    {
        Assert.AreEqual(inputFailureMechanismSystemType, ConversionHelper.ConvertToInputFailureMechanismSystemType(failureMechanismSystemType));
    }

    [Test]
    [TestCase(ConversionHelper.InputFailureMechanismStabilityInside, FailureMechanismSystemType.StabilityInside)]
    [TestCase(ConversionHelper.InputFailureMechanismStabilityOutside, FailureMechanismSystemType.StabilityOutside)]
    [TestCase(ConversionHelper.InputFailureMechanismPiping, FailureMechanismSystemType.Piping)]
    public void CanConvertToFailureMechanismSystemType(int inputFailureMechanismSystemType, FailureMechanismSystemType failureMechanismSystemType)
    {
        Assert.AreEqual(failureMechanismSystemType, ConversionHelper.ConvertToFailureMechanismSystemType(inputFailureMechanismSystemType));
    }

    [Test]
    [TestCase(FailureMechanismSystemType.StabilityInside, ConversionHelper.InputSegmentFailureMechanismStability)]
    [TestCase(FailureMechanismSystemType.StabilityOutside, ConversionHelper.InputSegmentFailureMechanismStability)]
    [TestCase(FailureMechanismSystemType.Piping, ConversionHelper.InputSegmentFailureMechanismPiping)]
    public void CanConvertToInputSegmentFailureMechanismType(FailureMechanismSystemType failureMechanismSystemType, int inputFailureMechanismSystemType)
    {
        Assert.AreEqual(inputFailureMechanismSystemType, ConversionHelper.ConvertToInputSegmentFailureMechanismType(failureMechanismSystemType));
    }

    [Test]
    [TestCase(ConversionHelper.InputSegmentFailureMechanismStability, FailureMechanismSystemType.StabilityInside)]
    [TestCase(ConversionHelper.InputSegmentFailureMechanismPiping, FailureMechanismSystemType.Piping)]
    public void CanConvertToSegmentFailureMechanismType(int inputFailureMechanismSystemType, FailureMechanismSystemType failureMechanismSystemType)
    {
        Assert.AreEqual(failureMechanismSystemType, ConversionHelper.ConvertToSegmentFailureMechanismType(inputFailureMechanismSystemType));
    }

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

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

    [Test]
    [TestCase(MStabZonesType.NoZones, ConversionHelper.InputZoneTypeNoZones)]
    [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.InputZoneTypesForbiddenZones, MStabZonesType.ForbiddenZone)]
    public void CanConvertToZoneType(int inputZoneType, MStabZonesType zoneType)
    {
        Assert.AreEqual(zoneType, ConversionHelper.ConvertToZoneType(inputZoneType));
    }

    [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.ConvertToMessageType(messageType));
    }

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

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

    [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(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(ShearStrengthModel.CPhi, SoilShearStrengthModel.CPhi)]
    [TestCase(ShearStrengthModel.CuCalculated, SoilShearStrengthModel.SuCalculated)]
    public void CanConvertToSoilShearStrengthModel(ShearStrengthModel shearStrengthModel, SoilShearStrengthModel soilShearStrengthModel)
    {
        Assert.AreEqual(soilShearStrengthModel, ConversionHelper.ConvertToSoilShearStrengthModel(shearStrengthModel));
    }

    [Test]
    [TestCase(SoilShearStrengthModel.CPhi, ShearStrengthModel.CPhi)]
    [TestCase(SoilShearStrengthModel.SuCalculated, ShearStrengthModel.CuCalculated)]
    public void CanConvertToShearStrengthModel(SoilShearStrengthModel soilShearStrengthModel, ShearStrengthModel shearStrengthModel)
    {
        Assert.AreEqual(shearStrengthModel, ConversionHelper.ConvertToShearStrengthModel(soilShearStrengthModel));
    }

    [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, ConversionHelper.LoadSituationDry)]
    [TestCase(LoadSituation.Wet, ConversionHelper.LoadSituationWet)]
    public void CanConvertToOutputLoadSituation(LoadSituation loadSituation, int outputLoadSituation)
    {
        Assert.AreEqual(outputLoadSituation, ConversionHelper.ConvertToOutputLoadSituation(loadSituation));
    }

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

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

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

    [Test]
    [TestCase(MStabModelType.Bishop, ConversionHelper.MStabModelTypeBishop)]
    [TestCase(MStabModelType.Spencer, ConversionHelper.MStabModelTypeSpencer)]
    [TestCase(MStabModelType.Fellenius, ConversionHelper.MStabModelTypeFellenius)]
    [TestCase(MStabModelType.UpliftVan, ConversionHelper.MStabModelTypeUpliftVan)]
    [TestCase(MStabModelType.UpliftSpencer, ConversionHelper.MStabModelTypeUpliftSpencer)]
    [TestCase(MStabModelType.BishopRandomField, ConversionHelper.MStabModelTypeBishopRandomField)]
    [TestCase(MStabModelType.BishopUpliftVan, ConversionHelper.MStabModelTypeBishopUpliftVan)]
    public void CanConvertToOutputMStabModelType(MStabModelType mStabModelType, int outputMStabModelType)
    {
        Assert.AreEqual(outputMStabModelType, ConversionHelper.ConvertToOutputMStabModelType(mStabModelType));
    }

    [Test]
    [TestCase(ConversionHelper.MStabModelTypeBishop, MStabModelType.Bishop)]
    [TestCase(ConversionHelper.MStabModelTypeSpencer, MStabModelType.Spencer)]
    [TestCase(ConversionHelper.MStabModelTypeFellenius, MStabModelType.Fellenius)]
    [TestCase(ConversionHelper.MStabModelTypeUpliftVan, MStabModelType.UpliftVan)]
    [TestCase(ConversionHelper.MStabModelTypeUpliftSpencer, MStabModelType.UpliftSpencer)]
    [TestCase(ConversionHelper.MStabModelTypeBishopRandomField, MStabModelType.BishopRandomField)]
    [TestCase(ConversionHelper.MStabModelTypeBishopUpliftVan, MStabModelType.BishopUpliftVan)]
    public void CanConvertToMStabModelType(int outputMStabModelType, MStabModelType mStabModelType)
    {
        Assert.AreEqual(mStabModelType, ConversionHelper.ConvertToMStabModelType(outputMStabModelType));
    }

    [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.InputSegmentFailureMechanismAll)]
    public void CannotConvertToSegmentFailureMechanismType(int inputFailureMechanismSystemType)
    {
        Assert.That(() => ConversionHelper.ConvertToSegmentFailureMechanismType(inputFailureMechanismSystemType), Throws.InstanceOf<ConversionException>().With.Message.EqualTo("Couldn't convert '0' to type FailureMechanismSystemType"));
    }

    [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));
    }

    [TestCase("Sand", SoilType.Sand)]
    [TestCase("Peat", SoilType.Peat)]
    [TestCase("Loam", SoilType.Loam)]
    [TestCase("Clay", SoilType.Clay)]
    [TestCase("Gravel", SoilType.Gravel)]
    public void CanConvertToSoilType(string inputSoilType, SoilType expectedSoilType)
    {
        Assert.That(ConversionHelper.ConvertToSoilType(inputSoilType), Is.EqualTo(expectedSoilType));
    }

    [TestCase("CPhi", ShearStrengthModel.CPhi)]
    [TestCase("CuCalculated", ShearStrengthModel.CuCalculated)]
    public void CanConvertToShearStrengthModel(string inputSoilType, ShearStrengthModel expectedSoilType)
    {
        Assert.That(ConversionHelper.ConvertToShearStrengthModel(inputSoilType), Is.EqualTo(expectedSoilType));
    }
    
    [TestCase("None")]
    [TestCase("Stress table")]
    [TestCase("Pseudo values")]
    [TestCase("Su measured")]
    [TestCase("Su gradient")]
    [TestCase("Su calculated with yield")]
    [TestCase("C phi or Su calculated")]
    public void WhenInvalidInputSoilType_ThenConvertToShearStrengthModelThrowsException(string inputSoilType)
    {
        Assert.That(() => ConversionHelper.ConvertToShearStrengthModel(inputSoilType), Throws.InstanceOf<NotImplementedException>());
    }
}