// Copyright (C) Stichting Deltares 2025. 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.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.That(ConversionHelper.ConvertToDamProjectType(inputDamProjectType), Is.EqualTo(damProjectType));
    }

    [Test]
    [TestCase(DamProjectType.Design, InputDamProjectType.Design)]
    [TestCase(DamProjectType.Calamity, InputDamProjectType.Operational)]
    public void CanConvertToInputDamProjectType(DamProjectType damProjectType, InputDamProjectType inputDamProjectType)
    {
        Assert.That(ConversionHelper.ConvertToInputDamProjectType(damProjectType), Is.EqualTo(inputDamProjectType));
    }

    [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.That(ConversionHelper.ConvertToInputPhreaticLineCreationMethod(plLineCreationMethod), Is.EqualTo(inputPhreaticLineCreationMethod));
    }

    [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.That(ConversionHelper.ConvertToPhreaticLineCreationMethod(inputPhreaticLineCreationMethod), Is.EqualTo(plLineCreationMethod));
    }

    [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.That(ConversionHelper.ConvertToIntrusionVerticalWaterPressure(inputIntrusionVerticalWaterPressureType), Is.EqualTo(intrusionVerticalWaterPressureType));
    }

    [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.That(ConversionHelper.ConvertToInputIntrusionVerticalWaterPressure(intrusionVerticalWaterPressureType), Is.EqualTo(inputIntrusionVerticalWaterPressureType));
    }

    [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.That(ConversionHelper.ConvertToDamPointType(inputPointType), Is.EqualTo(characteristicPointType));
    }

    [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.That(ConversionHelper.ConvertToInputPointType(characteristicPointType), Is.EqualTo(inputPointType));
    }

    [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.That(ConversionHelper.ConvertToOutputCalculationResult(calculationResult), Is.EqualTo(result));
    }

    [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.That(ConversionHelper.ConvertToCalculationResult(calculationResult), Is.EqualTo(result));
    }

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

    [Test]
    [TestCase(SoilProfileType.SoilProfile1D, SegmentSoilGeometryProbabilitySoilProfileType.ProfileType1D)]
    [TestCase(SoilProfileType.SoilProfile2D, SegmentSoilGeometryProbabilitySoilProfileType.ProfileType2D)]
    public void CanConvertToInputSoilGeometryType(SoilProfileType soilProfileType, SegmentSoilGeometryProbabilitySoilProfileType inputSoilGeometryType)
    {
        Assert.That(ConversionHelper.ConvertToInputSoilProfileType(soilProfileType), Is.EqualTo(inputSoilGeometryType));
    }

    [Test]
    [TestCase(SegmentSoilGeometryProbabilitySoilProfileType.ProfileType1D, SoilProfileType.SoilProfile1D)]
    [TestCase(SegmentSoilGeometryProbabilitySoilProfileType.ProfileType2D, SoilProfileType.SoilProfile2D)]
    public void CanConvertToSoilGeometryType(SegmentSoilGeometryProbabilitySoilProfileType inputSoilGeometryType, SoilProfileType soilProfileType)
    {
        Assert.That(ConversionHelper.ConvertToSoilProfileType(inputSoilGeometryType), Is.EqualTo(soilProfileType));
    }

    [Test]
    [TestCase(FailureMechanismSystemType.StabilityInside, InputFailureMechanismSystemType.StabilityInside)]
    [TestCase(FailureMechanismSystemType.StabilityOutside, InputFailureMechanismSystemType.StabilityOutside)]
    [TestCase(FailureMechanismSystemType.Piping, InputFailureMechanismSystemType.Piping)]
    public void CanConvertToInputFailureMechanismSystemType(FailureMechanismSystemType failureMechanismSystemType, InputFailureMechanismSystemType inputFailureMechanismSystemType)
    {
        Assert.That(ConversionHelper.ConvertToInputFailureMechanismSystemType(failureMechanismSystemType), Is.EqualTo(inputFailureMechanismSystemType));
    }

    [Test]
    [TestCase(InputFailureMechanismSystemType.StabilityInside, FailureMechanismSystemType.StabilityInside)]
    [TestCase(InputFailureMechanismSystemType.StabilityOutside, FailureMechanismSystemType.StabilityOutside)]
    [TestCase(InputFailureMechanismSystemType.Piping, FailureMechanismSystemType.Piping)]
    public void CanConvertToFailureMechanismSystemType(InputFailureMechanismSystemType inputFailureMechanismSystemType, FailureMechanismSystemType failureMechanismSystemType)
    {
        Assert.That(ConversionHelper.ConvertToFailureMechanismSystemType(inputFailureMechanismSystemType), Is.EqualTo(failureMechanismSystemType));
    }

    [Test]
    [TestCase(FailureMechanismSystemType.StabilityInside, SegmentSoilGeometryProbabilitySegmentFailureMechanismType.Stability)]
    [TestCase(FailureMechanismSystemType.StabilityOutside, SegmentSoilGeometryProbabilitySegmentFailureMechanismType.Stability)]
    [TestCase(FailureMechanismSystemType.Piping, SegmentSoilGeometryProbabilitySegmentFailureMechanismType.Piping)]
    public void CanConvertToInputSegmentFailureMechanismType(FailureMechanismSystemType failureMechanismSystemType, SegmentSoilGeometryProbabilitySegmentFailureMechanismType inputFailureMechanismSystemType)
    {
        Assert.That(ConversionHelper.ConvertToInputSegmentFailureMechanismType(failureMechanismSystemType), Is.EqualTo(inputFailureMechanismSystemType));
    }

    [Test]
    [TestCase(SegmentSoilGeometryProbabilitySegmentFailureMechanismType.Stability, FailureMechanismSystemType.StabilityInside)]
    [TestCase(SegmentSoilGeometryProbabilitySegmentFailureMechanismType.Piping, FailureMechanismSystemType.Piping)]
    public void CanConvertToSegmentFailureMechanismType(SegmentSoilGeometryProbabilitySegmentFailureMechanismType inputFailureMechanismSystemType, FailureMechanismSystemType failureMechanismSystemType)
    {
        Assert.That(ConversionHelper.ConvertToSegmentFailureMechanismType(inputFailureMechanismSystemType), Is.EqualTo(failureMechanismSystemType));
    }

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

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

    [Test]
    [TestCase(StabilityZoneType.NoZones, LocationStabilityOptionsZoneType.NoZones)]
    [TestCase(StabilityZoneType.ForbiddenZone, LocationStabilityOptionsZoneType.ForbiddenZones)]
    public void CanConvertToInputZoneType(StabilityZoneType zoneType, LocationStabilityOptionsZoneType inputZoneType)
    {
        Assert.That(ConversionHelper.ConvertToInputZoneType(zoneType), Is.EqualTo(inputZoneType));
    }

    [Test]
    [TestCase(LocationStabilityOptionsZoneType.NoZones, StabilityZoneType.NoZones)]
    [TestCase(LocationStabilityOptionsZoneType.ForbiddenZones, StabilityZoneType.ForbiddenZone)]
    public void CanConvertToZoneType(LocationStabilityOptionsZoneType inputZoneType, StabilityZoneType zoneType)
    {
        Assert.That(ConversionHelper.ConvertToZoneType(inputZoneType), Is.EqualTo(zoneType));
    }

    [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.That(ConversionHelper.ConvertToInputMessageType(logMessageType), Is.EqualTo(messageType));
    }

    [Test]
    [TestCase(MessageMessageType.Error, LogMessageType.Error)]
    [TestCase(MessageMessageType.Info, LogMessageType.Info)]
    [TestCase(MessageMessageType.Warning, LogMessageType.Warning)]
    public void CanConvertToMessageType(MessageMessageType messageType, LogMessageType logMessageType)
    {
        Assert.That(ConversionHelper.ConvertToMessageType(messageType), Is.EqualTo(logMessageType));
    }

    [Test]
    [TestCase(StabilitySearchMethod.Grid, StabilityParametersSearchMethod.CalculationGrid)]
    [TestCase(StabilitySearchMethod.BeeSwarm, StabilityParametersSearchMethod.BeeSwarm)]
    public void CanConvertToInputSearchMethod(StabilitySearchMethod searchMethod, StabilityParametersSearchMethod inputSearchMethod)
    {
        Assert.That(ConversionHelper.ConvertToInputSearchMethod(searchMethod), Is.EqualTo(inputSearchMethod));
    }

    [Test]
    [TestCase(StabilityParametersSearchMethod.CalculationGrid, StabilitySearchMethod.Grid)]
    [TestCase(StabilityParametersSearchMethod.BeeSwarm, StabilitySearchMethod.BeeSwarm)]
    public void CanConvertToSearchMethod(StabilityParametersSearchMethod inputSearchMethod, StabilitySearchMethod searchMethod)
    {
        Assert.That(ConversionHelper.ConvertToSearchMethod(inputSearchMethod), Is.EqualTo(searchMethod));
    }

    [Test]
    [TestCase(GridSizeDetermination.Automatic, StabilityParametersBishopSearchAreaDetermination.Automatic)]
    [TestCase(GridSizeDetermination.Specified, StabilityParametersBishopSearchAreaDetermination.Specified)]
    public void CanConvertToInputBishopSearchAreaDetermination(GridSizeDetermination gridDetermination, StabilityParametersBishopSearchAreaDetermination inputGridDetermination)
    {
        Assert.That(ConversionHelper.ConvertToInputBishopSearchAreaDetermination(gridDetermination), Is.EqualTo(inputGridDetermination));
    }

    [Test]
    [TestCase(StabilityParametersBishopSearchAreaDetermination.Automatic, GridSizeDetermination.Automatic)]
    [TestCase(StabilityParametersBishopSearchAreaDetermination.Specified, GridSizeDetermination.Specified)]
    public void CanConvertToBishopSearchAreaDetermination(StabilityParametersBishopSearchAreaDetermination inputGridDetermination, GridSizeDetermination gridDetermination)
    {
        Assert.That(ConversionHelper.ConvertToBishopSearchAreaDetermination(inputGridDetermination), Is.EqualTo(gridDetermination));
    }

    [Test]
    [TestCase(GridSizeDetermination.Automatic, StabilityParametersUpliftVanGridDetermination.Automatic)]
    [TestCase(GridSizeDetermination.Specified, StabilityParametersUpliftVanGridDetermination.Specified)]
    public void CanConvertToUpliftVanInputGridSizeDetermination(GridSizeDetermination gridDetermination, StabilityParametersUpliftVanGridDetermination inputGridDetermination)
    {
        Assert.That(ConversionHelper.ConvertToInputUpliftVanGridDetermination(gridDetermination), Is.EqualTo(inputGridDetermination));
    }

    [Test]
    [TestCase(StabilityParametersUpliftVanGridDetermination.Automatic, GridSizeDetermination.Automatic)]
    [TestCase(StabilityParametersUpliftVanGridDetermination.Specified, GridSizeDetermination.Specified)]
    public void CanConvertToUpliftVanGridSizeDetermination(StabilityParametersUpliftVanGridDetermination inputGridDetermination, GridSizeDetermination gridDetermination)
    {
        Assert.That(ConversionHelper.ConvertToUpliftVanGridDetermination(inputGridDetermination), Is.EqualTo(gridDetermination));
    }

    [Test]
    [TestCase(TangentLinesDefinition.OnBoundaryLines, StabilityParametersUpliftVanTangentLinesDefinition.OnBoundaryLines)]
    [TestCase(TangentLinesDefinition.Specified, StabilityParametersUpliftVanTangentLinesDefinition.Specified)]
    [TestCase(TangentLinesDefinition.Automatic, StabilityParametersUpliftVanTangentLinesDefinition.Automatic)]
    public void CanConvertToInputTangentLinesDefinition(TangentLinesDefinition tangentLineType, StabilityParametersUpliftVanTangentLinesDefinition inputTangentLineType)
    {
        Assert.That(ConversionHelper.ConvertToInputTangentLinesDefinition(tangentLineType), Is.EqualTo(inputTangentLineType));
    }

    [Test]
    [TestCase(StabilityParametersUpliftVanTangentLinesDefinition.OnBoundaryLines, TangentLinesDefinition.OnBoundaryLines)]
    [TestCase(StabilityParametersUpliftVanTangentLinesDefinition.Specified, TangentLinesDefinition.Specified)]
    [TestCase(StabilityParametersUpliftVanTangentLinesDefinition.Automatic, TangentLinesDefinition.Automatic)]
    public void CanConvertToTangentLinesDefinition(StabilityParametersUpliftVanTangentLinesDefinition inputTangentLineType, TangentLinesDefinition tangentLineType)
    {
        Assert.That(ConversionHelper.ConvertToTangentLinesDefinition(inputTangentLineType), Is.EqualTo(tangentLineType));
    }

    [Test]
    [TestCase(ShearStrengthModel.CPhi, SoilShearStrengthModel.CPhi)]
    [TestCase(ShearStrengthModel.CuCalculated, SoilShearStrengthModel.SuCalculated)]
    [TestCase(ShearStrengthModel.StressTable, SoilShearStrengthModel.SigmaTauCurve)]
    public void CanConvertToSoilShearStrengthModel(ShearStrengthModel shearStrengthModel, SoilShearStrengthModel soilShearStrengthModel)
    {
        Assert.That(ConversionHelper.ConvertToSoilShearStrengthModel(shearStrengthModel), Is.EqualTo(soilShearStrengthModel));
    }

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

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

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

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

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

    [Test]
    [TestCase(StabilityModelType.Bishop, InputStabilityModelType.Bishop)]
    [TestCase(StabilityModelType.UpliftVan, InputStabilityModelType.UpliftVan)]
    [TestCase(StabilityModelType.BishopUpliftVan, InputStabilityModelType.BishopUpliftVan)]
    public void CanConvertToInputMStabModelType(StabilityModelType stabilityModelType, InputStabilityModelType inputMStabModelType)
    {
        Assert.That(ConversionHelper.ConvertToInputMStabModelType(stabilityModelType), Is.EqualTo(inputMStabModelType));
    }

    [Test]
    [TestCase(InputStabilityModelType.Bishop, StabilityModelType.Bishop)]
    [TestCase(InputStabilityModelType.UpliftVan, StabilityModelType.UpliftVan)]
    [TestCase(InputStabilityModelType.BishopUpliftVan, StabilityModelType.BishopUpliftVan)]
    public void CanConvertToMStabModelType(InputStabilityModelType inputMStabModelType, StabilityModelType stabilityModelType)
    {
        Assert.That(ConversionHelper.ConvertToMStabModelType(inputMStabModelType), Is.EqualTo(stabilityModelType));
    }

    [Test]
    [TestCase(DesignResultStabilityDesignResultsStabilityModelType.Bishop, StabilityModelType.Bishop)]
    [TestCase(DesignResultStabilityDesignResultsStabilityModelType.UpliftVan, StabilityModelType.UpliftVan)]
    [TestCase(DesignResultStabilityDesignResultsStabilityModelType.BishopUpliftVan, StabilityModelType.BishopUpliftVan)]
    public void CanConvertToOutputStabilityModelType(DesignResultStabilityDesignResultsStabilityModelType outputStabilityModelType,
                                                     StabilityModelType stabilityModelType)
    {
        Assert.That(ConversionHelper.ConvertToOutputStabilityModelType(stabilityModelType), Is.EqualTo(outputStabilityModelType));
    }

    [Test]
    [TestCase(StabilityModelType.Bishop, DesignResultStabilityDesignResultsStabilityModelType.Bishop)]
    [TestCase(StabilityModelType.UpliftVan, DesignResultStabilityDesignResultsStabilityModelType.UpliftVan)]
    [TestCase(StabilityModelType.BishopUpliftVan, DesignResultStabilityDesignResultsStabilityModelType.BishopUpliftVan)]
    public void CanConvertToStabilityModelType(StabilityModelType stabilityModelType,
                                               DesignResultStabilityDesignResultsStabilityModelType outputStabilityModelType)
    {
        Assert.That(ConversionHelper.ConvertToStabilityModelType(outputStabilityModelType), Is.EqualTo(stabilityModelType));
    }

    [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.That(ConversionHelper.ConvertToTimeStepUnit(inputTimeStepUnit), Is.EqualTo(timeStepUnit));
    }

    [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.That(ConversionHelper.ConvertToInputTimeStepUnit(timeStepUnit), Is.EqualTo(inputTimeStepUnit));
    }

    [TestCase(SegmentSoilGeometryProbabilitySegmentFailureMechanismType.All)]
    public void CannotConvertToSegmentFailureMechanismType(SegmentSoilGeometryProbabilitySegmentFailureMechanismType inputFailureMechanismSystemType)
    {
        Assert.That(() => ConversionHelper.ConvertToSegmentFailureMechanismType(inputFailureMechanismSystemType), Throws.InstanceOf<ConversionException>().With.Message.EqualTo("Couldn't convert 'All' 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.That(ConversionHelper.ConvertToPlLineType(inputPlLineType), Is.EqualTo(plLineType));
    }

    [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.That(ConversionHelper.ConvertToInputPlLineType(plLineType), Is.EqualTo(inputPlLineType));
    }

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

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

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

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

    [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("MohrCoulomb", ShearStrengthModel.CPhi)]
    [TestCase("SHANSEP", ShearStrengthModel.CuCalculated)]
    [TestCase("SigmaTauTable", ShearStrengthModel.StressTable)]
    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>());
    }
}