Index: DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/ConversionHelperTests.cs =================================================================== diff -u -r1618 -r1723 --- DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/ConversionHelperTests.cs (.../ConversionHelperTests.cs) (revision 1618) +++ DamEngine/trunk/src/Deltares.DamEngine.Interface.Tests/ConversionHelperTests.cs (.../ConversionHelperTests.cs) (revision 1723) @@ -387,151 +387,151 @@ } [Test] - [TestCase(LoadSituation.Dry, 0)] - [TestCase(LoadSituation.Wet, 1)] + [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(0, LoadSituation.Dry)] - [TestCase(1, LoadSituation.Wet)] + [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(DikeDrySensitivity.None, 0)] - [TestCase(DikeDrySensitivity.Dry, 1)] + [TestCase(DikeDrySensitivity.None, ConversionHelper.DikeDrySensitivityNone)] + [TestCase(DikeDrySensitivity.Dry, ConversionHelper.DikeDrySensitivityDry)] public void CanConvertToOutputDikeDrySensitivity(DikeDrySensitivity dikeDrySensitivity, int outputDikeDrySensitivity) { Assert.AreEqual(outputDikeDrySensitivity, ConversionHelper.ConvertToOutputDikeDrySensitivity(dikeDrySensitivity)); } [Test] - [TestCase(0, DikeDrySensitivity.None)] - [TestCase(1, DikeDrySensitivity.Dry)] + [TestCase(ConversionHelper.DikeDrySensitivityNone, DikeDrySensitivity.None)] + [TestCase(ConversionHelper.DikeDrySensitivityDry, DikeDrySensitivity.Dry)] public void CanConvertToDikeDrySensitivity(int outputDikeDrySensitivity, DikeDrySensitivity dikeDrySensitivity) { Assert.AreEqual(dikeDrySensitivity, ConversionHelper.ConvertToDikeDrySensitivity(outputDikeDrySensitivity)); } [Test] - [TestCase(HydraulicShortcutType.HydraulicShortcut, 0)] - [TestCase(HydraulicShortcutType.NoHydraulicShortcut, 1)] + [TestCase(HydraulicShortcutType.HydraulicShortcut, ConversionHelper.HydraulicShortcutTypeHydraulicShortcut)] + [TestCase(HydraulicShortcutType.NoHydraulicShortcut, ConversionHelper.HydraulicShortcutTypeNoHydraulicShortcut)] public void CanConvertToOutputHydraulicShortcutType(HydraulicShortcutType hydraulicShortcutType, int outputHydraulicShortcutType) { Assert.AreEqual(outputHydraulicShortcutType, ConversionHelper.ConvertToOutputHydraulicShortcutType(hydraulicShortcutType)); } [Test] - [TestCase(0, HydraulicShortcutType.HydraulicShortcut)] - [TestCase(1, HydraulicShortcutType.NoHydraulicShortcut)] + [TestCase(ConversionHelper.HydraulicShortcutTypeHydraulicShortcut, HydraulicShortcutType.HydraulicShortcut)] + [TestCase(ConversionHelper.HydraulicShortcutTypeNoHydraulicShortcut, HydraulicShortcutType.NoHydraulicShortcut)] public void CanConvertToHydraulicShortcutType(int outputHydraulicShortcutType, HydraulicShortcutType hydraulicShortcutType) { Assert.AreEqual(hydraulicShortcutType, ConversionHelper.ConvertToHydraulicShortcutType(outputHydraulicShortcutType)); } [Test] - [TestCase(UpliftType.Uplift, 0)] - [TestCase(UpliftType.NoUplift, 1)] + [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(0, UpliftType.Uplift)] - [TestCase(1, UpliftType.NoUplift)] + [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, 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)] + [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.HorizontalBalance, ConversionHelper.MStabModelTypeHorizontalBalance)] + [TestCase(MStabModelType.BishopUpliftVan, ConversionHelper.MStabModelTypeBishopUpliftVan)] + [TestCase(MStabModelType.SpencerHigh, ConversionHelper.MStabModelTypeSpencerHigh)] + [TestCase(MStabModelType.SpencerLow, ConversionHelper.MStabModelTypeSpencerLow)] 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)] + [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.MStabModelTypeHorizontalBalance, MStabModelType.HorizontalBalance)] + [TestCase(ConversionHelper.MStabModelTypeBishopUpliftVan, MStabModelType.BishopUpliftVan)] + [TestCase(ConversionHelper.MStabModelTypeSpencerHigh, MStabModelType.SpencerHigh)] + [TestCase(ConversionHelper.MStabModelTypeSpencerLow, 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)] + [TestCase(ScenarioType.Scenario01, ConversionHelper.ScenarioTypeScenario01)] + [TestCase(ScenarioType.Scenario02, ConversionHelper.ScenarioTypeScenario02)] + [TestCase(ScenarioType.Scenario03, ConversionHelper.ScenarioTypeScenario03)] + [TestCase(ScenarioType.Scenario04, ConversionHelper.ScenarioTypeScenario04)] + [TestCase(ScenarioType.Scenario05, ConversionHelper.ScenarioTypeScenario05)] + [TestCase(ScenarioType.Scenario06, ConversionHelper.ScenarioTypeScenario06)] + [TestCase(ScenarioType.Scenario07, ConversionHelper.ScenarioTypeScenario07)] + [TestCase(ScenarioType.Scenario08, ConversionHelper.ScenarioTypeScenario08)] + [TestCase(ScenarioType.Scenario09, ConversionHelper.ScenarioTypeScenario09)] + [TestCase(ScenarioType.Scenario10, ConversionHelper.ScenarioTypeScenario10)] + [TestCase(ScenarioType.Scenario11, ConversionHelper.ScenarioTypeScenario11)] 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)] + [TestCase(ConversionHelper.ScenarioTypeScenario01, ScenarioType.Scenario01)] + [TestCase(ConversionHelper.ScenarioTypeScenario02, ScenarioType.Scenario02)] + [TestCase(ConversionHelper.ScenarioTypeScenario03, ScenarioType.Scenario03)] + [TestCase(ConversionHelper.ScenarioTypeScenario04, ScenarioType.Scenario04)] + [TestCase(ConversionHelper.ScenarioTypeScenario05, ScenarioType.Scenario05)] + [TestCase(ConversionHelper.ScenarioTypeScenario06, ScenarioType.Scenario06)] + [TestCase(ConversionHelper.ScenarioTypeScenario07, ScenarioType.Scenario07)] + [TestCase(ConversionHelper.ScenarioTypeScenario08, ScenarioType.Scenario08)] + [TestCase(ConversionHelper.ScenarioTypeScenario09, ScenarioType.Scenario09)] + [TestCase(ConversionHelper.ScenarioTypeScenario10, ScenarioType.Scenario10)] + [TestCase(ConversionHelper.ScenarioTypeScenario11, 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)] + [TestCase(PipingModelType.Bligh, ConversionHelper.PipingModelTypeBligh)] + [TestCase(PipingModelType.SellmeijerVnk, ConversionHelper.PipingModelTypeSellmeijer)] + [TestCase(PipingModelType.Sellmeijer4Forces, ConversionHelper.PipingModelTypeSellmeijer4Forces)] + [TestCase(PipingModelType.Wti2017, ConversionHelper.PipingModelTypeWti2017)] 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)] + [TestCase(ConversionHelper.PipingModelTypeBligh, PipingModelType.Bligh)] + [TestCase(ConversionHelper.PipingModelTypeSellmeijer, PipingModelType.SellmeijerVnk)] + [TestCase(ConversionHelper.PipingModelTypeSellmeijer4Forces, PipingModelType.Sellmeijer4Forces)] + [TestCase(ConversionHelper.PipingModelTypeWti2017, PipingModelType.Wti2017)] public void CanConvertToPipingModelType(int outputPipingModelType, PipingModelType pipingModelType) { Assert.AreEqual(pipingModelType, ConversionHelper.ConvertToPipingModelType(outputPipingModelType)); @@ -558,16 +558,16 @@ } [Test] - [TestCase(RegionalResultType.ProbabilityOfFailure, 0)] - [TestCase(RegionalResultType.SafetyFactor, 1)] + [TestCase(RegionalResultType.ProbabilityOfFailure, ConversionHelper.RwResultTypeProbabilityOfFailure)] + [TestCase(RegionalResultType.SafetyFactor, ConversionHelper.RwResultTypeSafetyFactor)] public void CanConvertToOutputRegionalResultType(RegionalResultType regionalResultType, int outputRegionalResultType) { Assert.AreEqual(outputRegionalResultType, ConversionHelper.ConvertToOutputRegionalResultType(regionalResultType)); } [Test] - [TestCase(0, RegionalResultType.ProbabilityOfFailure)] - [TestCase(1, RegionalResultType.SafetyFactor)] + [TestCase(ConversionHelper.RwResultTypeProbabilityOfFailure, RegionalResultType.ProbabilityOfFailure)] + [TestCase(ConversionHelper.RwResultTypeSafetyFactor, RegionalResultType.SafetyFactor)] public void CanConvertToRegionalResultType(int outputRegionalResultType, RegionalResultType regionalResultType) { Assert.AreEqual(regionalResultType, ConversionHelper.ConvertToRegionalResultType(outputRegionalResultType));