Index: DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/ConversionHelperTests.cs
===================================================================
diff -u -r941 -r1062
--- DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/ConversionHelperTests.cs	(.../ConversionHelperTests.cs)	(revision 941)
+++ DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/ConversionHelperTests.cs	(.../ConversionHelperTests.cs)	(revision 1062)
@@ -29,10 +29,10 @@
 
 namespace Deltares.DamEngine.Interface.Tests
 {
-	[TestFixture]
+    [TestFixture]
     public class ConversionHelperTests
     {
-		[Test]
+        [Test]
         [TestCase(InputDamProjectType.Assessment, DamProjectType.Assessment)]
         [TestCase(InputDamProjectType.AssessmentRegional, DamProjectType.AssessmentRegional)]
         [TestCase(InputDamProjectType.Design, DamProjectType.Design)]
@@ -150,6 +150,7 @@
         {
             Assert.AreEqual(characteristicPointType, ConversionHelper.ConvertToDamPointType(inputPointType));
         }
+
         [Test]
         [TestCase(CharacteristicPointType.None, ConversionHelper.CpNone)]
         [TestCase(CharacteristicPointType.SurfaceLevelOutside, ConversionHelper.CpSurfaceLevelOutside)]
@@ -256,7 +257,7 @@
 
         [Test]
         [TestCase(MStabSearchMethod.Grid, ConversionHelper.InputSearchMethodGrid)]
-        [TestCase(MStabSearchMethod.GeneticAlgorithm, ConversionHelper.InputSearchMethodGenetic)]        
+        [TestCase(MStabSearchMethod.GeneticAlgorithm, ConversionHelper.InputSearchMethodGenetic)]
         public void CanConvertToInputSearchMethod(MStabSearchMethod searchMethod, int inputSearchMethod)
         {
             Assert.AreEqual(inputSearchMethod, ConversionHelper.ConvertToInputSearchMethod(searchMethod));
@@ -386,5 +387,172 @@
         {
             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(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));
+        }
     }
 }