Fisheye: Tag c0edeb23f0e6623c13f36ad5a57efa7edf847993 refers to a dead (removed) revision in file `Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.IO/Configurations/Converters/ConfigurationFailureMechanismCategoryTypeConverter.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.IO/Configurations/Converters/ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter.cs
===================================================================
diff -u
--- Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.IO/Configurations/Converters/ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter.cs	(revision 0)
+++ Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.IO/Configurations/Converters/ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter.cs	(revision c0edeb23f0e6623c13f36ad5a57efa7edf847993)
@@ -0,0 +1,167 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets 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 System.ComponentModel;
+using System.Globalization;
+using Ringtoets.Common.Data.FailureMechanism;
+using Ringtoets.GrassCoverErosionOutwards.IO.Properties;
+
+namespace Ringtoets.GrassCoverErosionOutwards.IO.Configurations.Converters
+{
+    /// <summary>
+    /// Converts <see cref="ConfigurationGrassCoverErosionOutwardsCategoryType"/> to <see cref="string"/>
+    /// or <see cref="FailureMechanismCategoryType"/> and back.
+    /// </summary>
+    public class ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter : TypeConverter
+    {
+        public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
+        {
+            return destinationType == typeof(FailureMechanismCategoryType)
+                   || base.CanConvertTo(context, destinationType);
+        }
+
+        /// <inheritdoc />
+        /// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="value" />
+        /// contains an invalid value of <see cref="ConfigurationGrassCoverErosionOutwardsCategoryType"/>.</exception>
+        public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
+        {
+            var categoryType = (ConfigurationGrassCoverErosionOutwardsCategoryType) value;
+            if (!Enum.IsDefined(typeof(ConfigurationGrassCoverErosionOutwardsCategoryType), categoryType))
+            {
+                throw new InvalidEnumArgumentException(nameof(value),
+                                                       (int) categoryType,
+                                                       typeof(ConfigurationGrassCoverErosionOutwardsCategoryType));
+            }
+
+            if (destinationType == typeof(FailureMechanismCategoryType))
+            {
+                switch (categoryType)
+                {
+                    case ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificFactorizedSignalingNorm:
+                        return FailureMechanismCategoryType.MechanismSpecificFactorizedSignalingNorm;
+                    case ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificSignalingNorm:
+                        return FailureMechanismCategoryType.MechanismSpecificSignalingNorm;
+                    case ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificLowerLimitNorm:
+                        return FailureMechanismCategoryType.MechanismSpecificLowerLimitNorm;
+                    case ConfigurationGrassCoverErosionOutwardsCategoryType.LowerLimitNorm:
+                        return FailureMechanismCategoryType.LowerLimitNorm;
+                    case ConfigurationGrassCoverErosionOutwardsCategoryType.FactorizedLowerLimitNorm:
+                        return FailureMechanismCategoryType.FactorizedLowerLimitNorm;
+                    default:
+                        throw new NotSupportedException();
+                }
+            }
+
+            if (destinationType == typeof(string))
+            {
+                switch (categoryType)
+                {
+                    case ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificFactorizedSignalingNorm:
+                        return Resources.FailureMechanismCategoryType_MechanismSpecificFactorizedSignalingNorm_DisplayName;
+                    case ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificSignalingNorm:
+                        return Resources.FailureMechanismCategoryType_MechanismSpecificSignalingNorm_DisplayName;
+                    case ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificLowerLimitNorm:
+                        return Resources.FailureMechanismCategoryType_MechanismSpecificLowerLimitNorm_DisplayName;
+                    case ConfigurationGrassCoverErosionOutwardsCategoryType.LowerLimitNorm:
+                        return Resources.FailureMechanismCategoryType_LowerLimitNorm_DisplayName;
+                    case ConfigurationGrassCoverErosionOutwardsCategoryType.FactorizedLowerLimitNorm:
+                        return Resources.FailureMechanismCategoryType_FactorizedLowerLimitNorm_DisplayName;
+                    default:
+                        throw new NotSupportedException();
+                }
+            }
+
+            return base.ConvertTo(context, culture, value, destinationType);
+        }
+
+        public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
+        {
+            return sourceType == typeof(string)
+                   || sourceType == typeof(FailureMechanismCategoryType)
+                   || base.CanConvertFrom(context, sourceType);
+        }
+
+        /// <inheritdoc />
+        /// <exception cref="InvalidEnumArgumentException">Thrown when <paramref name="value" />
+        /// contains an invalid value of <see cref="ConfigurationGrassCoverErosionOutwardsCategoryType"/>.</exception>
+        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
+        {
+            if (value is FailureMechanismCategoryType)
+            {
+                var categoryType = (FailureMechanismCategoryType) value;
+                if (!Enum.IsDefined(typeof(FailureMechanismCategoryType), categoryType))
+                {
+                    throw new InvalidEnumArgumentException(nameof(value),
+                                                           (int) categoryType,
+                                                           typeof(FailureMechanismCategoryType));
+                }
+
+                switch (categoryType)
+                {
+                    case FailureMechanismCategoryType.MechanismSpecificFactorizedSignalingNorm:
+                        return ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificFactorizedSignalingNorm;
+                    case FailureMechanismCategoryType.MechanismSpecificSignalingNorm:
+                        return ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificSignalingNorm;
+                    case FailureMechanismCategoryType.MechanismSpecificLowerLimitNorm:
+                        return ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificLowerLimitNorm;
+                    case FailureMechanismCategoryType.LowerLimitNorm:
+                        return ConfigurationGrassCoverErosionOutwardsCategoryType.LowerLimitNorm;
+                    case FailureMechanismCategoryType.FactorizedLowerLimitNorm:
+                        return ConfigurationGrassCoverErosionOutwardsCategoryType.FactorizedLowerLimitNorm;
+                    default:
+                        throw new NotSupportedException();
+                }
+            }
+
+            var stringValue = value as string;
+            if (stringValue != null)
+            {
+                if (stringValue == Resources.FailureMechanismCategoryType_MechanismSpecificFactorizedSignalingNorm_DisplayName)
+                {
+                    return ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificFactorizedSignalingNorm;
+                }
+
+                if (stringValue == Resources.FailureMechanismCategoryType_MechanismSpecificSignalingNorm_DisplayName)
+                {
+                    return ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificSignalingNorm;
+                }
+
+                if (stringValue == Resources.FailureMechanismCategoryType_MechanismSpecificLowerLimitNorm_DisplayName)
+                {
+                    return ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificLowerLimitNorm;
+                }
+
+                if (stringValue == Resources.FailureMechanismCategoryType_LowerLimitNorm_DisplayName)
+                {
+                    return ConfigurationGrassCoverErosionOutwardsCategoryType.LowerLimitNorm;
+                }
+
+                if (stringValue == Resources.FailureMechanismCategoryType_FactorizedLowerLimitNorm_DisplayName)
+                {
+                    return ConfigurationGrassCoverErosionOutwardsCategoryType.FactorizedLowerLimitNorm;
+                }
+            }
+
+            return base.ConvertFrom(context, culture, value);
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.IO/Configurations/FailureMechanismCategoryWaveConditionsCalculationConfigurationExporter.cs
===================================================================
diff -u -r5621f8fe7b06f7edfebedf20d0018b1f354706f1 -rc0edeb23f0e6623c13f36ad5a57efa7edf847993
--- Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.IO/Configurations/FailureMechanismCategoryWaveConditionsCalculationConfigurationExporter.cs	(.../FailureMechanismCategoryWaveConditionsCalculationConfigurationExporter.cs)	(revision 5621f8fe7b06f7edfebedf20d0018b1f354706f1)
+++ Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.IO/Configurations/FailureMechanismCategoryWaveConditionsCalculationConfigurationExporter.cs	(.../FailureMechanismCategoryWaveConditionsCalculationConfigurationExporter.cs)	(revision c0edeb23f0e6623c13f36ad5a57efa7edf847993)
@@ -56,7 +56,7 @@
         {
             var configuration = new FailureMechanismCategoryWaveConditionsCalculationConfiguration(calculation.Name);
             SetConfigurationProperties(configuration, calculation);
-            configuration.CategoryType = (ConfigurationGrassCoverErosionOutwardsCategoryType?) new ConfigurationFailureMechanismCategoryTypeConverter()
+            configuration.CategoryType = (ConfigurationGrassCoverErosionOutwardsCategoryType?) new ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter()
                 .ConvertFrom(calculation.InputParameters.CategoryType);
             return configuration;
         }
Index: Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.IO/Configurations/failureMechanismCategoryWaveConditionsCalculationConfigurationWriter.cs
===================================================================
diff -u -rbb81cbc775643d95f096bddf5e5dbdae234cf921 -rc0edeb23f0e6623c13f36ad5a57efa7edf847993
--- Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.IO/Configurations/failureMechanismCategoryWaveConditionsCalculationConfigurationWriter.cs	(.../failureMechanismCategoryWaveConditionsCalculationConfigurationWriter.cs)	(revision bb81cbc775643d95f096bddf5e5dbdae234cf921)
+++ Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.IO/Configurations/failureMechanismCategoryWaveConditionsCalculationConfigurationWriter.cs	(.../failureMechanismCategoryWaveConditionsCalculationConfigurationWriter.cs)	(revision c0edeb23f0e6623c13f36ad5a57efa7edf847993)
@@ -57,7 +57,7 @@
                 return;
             }
 
-            var converter = new ConfigurationFailureMechanismCategoryTypeConverter();
+            var converter = new ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter();
             writer.WriteElementString(WaveConditionsCalculationConfigurationSchemaIdentifiers.CategoryType,
                                       converter.ConvertToInvariantString(configuration.CategoryType.Value));
         }
Index: Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.IO/Ringtoets.GrassCoverErosionOutwards.IO.csproj
===================================================================
diff -u -r5621f8fe7b06f7edfebedf20d0018b1f354706f1 -rc0edeb23f0e6623c13f36ad5a57efa7edf847993
--- Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.IO/Ringtoets.GrassCoverErosionOutwards.IO.csproj	(.../Ringtoets.GrassCoverErosionOutwards.IO.csproj)	(revision 5621f8fe7b06f7edfebedf20d0018b1f354706f1)
+++ Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.IO/Ringtoets.GrassCoverErosionOutwards.IO.csproj	(.../Ringtoets.GrassCoverErosionOutwards.IO.csproj)	(revision c0edeb23f0e6623c13f36ad5a57efa7edf847993)
@@ -17,7 +17,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Configurations\ConfigurationGrassCoverErosionOutwardsCategoryType.cs" />
-    <Compile Include="Configurations\Converters\ConfigurationFailureMechanismCategoryTypeConverter.cs" />
+    <Compile Include="Configurations\Converters\ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter.cs" />
     <Compile Include="Configurations\FailureMechanismCategoryWaveConditionsCalculationConfiguration.cs" />
     <Compile Include="Configurations\FailureMechanismCategoryWaveConditionsCalculationConfigurationExporter.cs" />
     <Compile Include="Configurations\failureMechanismCategoryWaveConditionsCalculationConfigurationWriter.cs" />
Fisheye: Tag c0edeb23f0e6623c13f36ad5a57efa7edf847993 refers to a dead (removed) revision in file `Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.IO.Test/Configurations/Converters/ConfigurationFailureMechanismCategoryTypeConverterTest.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.IO.Test/Configurations/Converters/ConfigurationGrassCoverErosionOutwardsCategoryTypeConverterTest.cs
===================================================================
diff -u
--- Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.IO.Test/Configurations/Converters/ConfigurationGrassCoverErosionOutwardsCategoryTypeConverterTest.cs	(revision 0)
+++ Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.IO.Test/Configurations/Converters/ConfigurationGrassCoverErosionOutwardsCategoryTypeConverterTest.cs	(revision c0edeb23f0e6623c13f36ad5a57efa7edf847993)
@@ -0,0 +1,258 @@
+// Copyright (C) Stichting Deltares 2017. All rights reserved.
+//
+// This file is part of Ringtoets.
+//
+// Ringtoets 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 System.ComponentModel;
+using System.Globalization;
+using Core.Common.TestUtil;
+using NUnit.Framework;
+using Ringtoets.Common.Data.FailureMechanism;
+using Ringtoets.GrassCoverErosionOutwards.IO.Configurations;
+using Ringtoets.GrassCoverErosionOutwards.IO.Configurations.Converters;
+
+namespace Ringtoets.GrassCoverErosionOutwards.IO.Test.Configurations.Converters
+{
+    [TestFixture]
+    public class ConfigurationGrassCoverErosionOutwardsCategoryTypeConverterTest
+    {
+        [Test]
+        public void Constructor_ExpectedValues()
+        {
+            // Call
+            var converter = new ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter();
+
+            // Assert
+            Assert.IsInstanceOf<TypeConverter>(converter);
+        }
+
+        [Test]
+        public void CanConvertTo_String_ReturnTrue()
+        {
+            // Setup
+            var converter = new ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter();
+
+            // Call
+            bool canConvertTo = converter.CanConvertTo(typeof(string));
+
+            // Assert
+            Assert.IsTrue(canConvertTo);
+        }
+
+        [Test]
+        public void CanConvertTo_FailureMechanismCategoryType_ReturnTrue()
+        {
+            // Setup
+            var converter = new ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter();
+
+            // Call
+            bool canConvertTo = converter.CanConvertTo(typeof(FailureMechanismCategoryType));
+
+            // Assert
+            Assert.IsTrue(canConvertTo);
+        }
+
+        [Test]
+        public void CanConvertTo_OtherType_ReturnFalse()
+        {
+            // Setup
+            var converter = new ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter();
+
+            // Call
+            bool canConvertTo = converter.CanConvertTo(typeof(object));
+
+            // Assert
+            Assert.IsFalse(canConvertTo);
+        }
+
+        [Test]
+        [TestCase(ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificFactorizedSignalingNorm, "Iv-IIv")]
+        [TestCase(ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificSignalingNorm, "IIv-IIIv")]
+        [TestCase(ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificLowerLimitNorm, "IIIv-IVv")]
+        [TestCase(ConfigurationGrassCoverErosionOutwardsCategoryType.LowerLimitNorm, "IVv-Vv")]
+        [TestCase(ConfigurationGrassCoverErosionOutwardsCategoryType.FactorizedLowerLimitNorm, "Vv-VIv")]
+        public void ConvertTo_ValidConfigurationFailureMechanismCategoryType_ReturnExpectedText(
+            ConfigurationGrassCoverErosionOutwardsCategoryType value, string expectedText)
+        {
+            // Setup
+            var converter = new ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter();
+
+            // Call
+            object convertTo = converter.ConvertTo(null, CultureInfo.CurrentCulture, value, typeof(string));
+
+            // Assert
+            Assert.AreEqual(expectedText, convertTo);
+        }
+
+        [Test]
+        [TestCase(ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificFactorizedSignalingNorm, FailureMechanismCategoryType.MechanismSpecificFactorizedSignalingNorm)]
+        [TestCase(ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificSignalingNorm, FailureMechanismCategoryType.MechanismSpecificSignalingNorm)]
+        [TestCase(ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificLowerLimitNorm, FailureMechanismCategoryType.MechanismSpecificLowerLimitNorm)]
+        [TestCase(ConfigurationGrassCoverErosionOutwardsCategoryType.LowerLimitNorm, FailureMechanismCategoryType.LowerLimitNorm)]
+        [TestCase(ConfigurationGrassCoverErosionOutwardsCategoryType.FactorizedLowerLimitNorm, FailureMechanismCategoryType.FactorizedLowerLimitNorm)]
+        public void ConvertTo_ValidConfigurationFailureMechanismCategoryType_ReturnFailureMechanismCategoryType(
+            ConfigurationGrassCoverErosionOutwardsCategoryType originalValue, FailureMechanismCategoryType expectedResult)
+        {
+            // Setup
+            var converter = new ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter();
+
+            // Call
+            object categoryType = converter.ConvertTo(null, CultureInfo.CurrentCulture, originalValue, typeof(FailureMechanismCategoryType));
+
+            // Assert
+            Assert.AreEqual(expectedResult, categoryType);
+        }
+
+        [Test]
+        [TestCase(typeof(string))]
+        [TestCase(typeof(FailureMechanismCategoryType))]
+        public void ConvertTo_InvalidConfigurationFailureMechanismCategoryType_ThrowInvalidEnumArgumentException(Type destinationType)
+        {
+            // Setup
+            const ConfigurationGrassCoverErosionOutwardsCategoryType invalidValue = (ConfigurationGrassCoverErosionOutwardsCategoryType) 99;
+            var converter = new ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter();
+
+            // Call
+            TestDelegate call = () => converter.ConvertTo(invalidValue, destinationType);
+
+            // Assert
+            string expectedMessage = $"The value of argument 'value' ({invalidValue}) is invalid for Enum type '{nameof(ConfigurationGrassCoverErosionOutwardsCategoryType)}'.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<InvalidEnumArgumentException>(call, expectedMessage);
+        }
+
+        [Test]
+        public void CanConvertFrom_String_ReturnTrue()
+        {
+            // Setup
+            var converter = new ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter();
+
+            // Call
+            bool canConvertFrom = converter.CanConvertFrom(typeof(string));
+
+            // Assert
+            Assert.IsTrue(canConvertFrom);
+        }
+
+        [Test]
+        public void CanConvertFrom_FailureMechanismCategoryType_ReturnTrue()
+        {
+            // Setup
+            var converter = new ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter();
+
+            // Call
+            bool canConvertFrom = converter.CanConvertFrom(typeof(FailureMechanismCategoryType));
+
+            // Assert
+            Assert.IsTrue(canConvertFrom);
+        }
+
+        [Test]
+        public void CanConvertFrom_OtherType_ReturnFalse()
+        {
+            // Setup
+            var converter = new ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter();
+
+            // Call
+            bool canConvertFrom = converter.CanConvertFrom(typeof(object));
+
+            // Assert
+            Assert.IsFalse(canConvertFrom);
+        }
+
+        [Test]
+        [TestCase("Iv-IIv", ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificFactorizedSignalingNorm)]
+        [TestCase("IIv-IIIv", ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificSignalingNorm)]
+        [TestCase("IIIv-IVv", ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificLowerLimitNorm)]
+        [TestCase("IVv-Vv", ConfigurationGrassCoverErosionOutwardsCategoryType.LowerLimitNorm)]
+        [TestCase("Vv-VIv", ConfigurationGrassCoverErosionOutwardsCategoryType.FactorizedLowerLimitNorm)]
+        public void ConvertFrom_ValidStringValue_ReturnConfigurationFailureMechanismCategoryType(
+            string value, ConfigurationGrassCoverErosionOutwardsCategoryType expectedResult)
+        {
+            // Setup
+            var converter = new ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter();
+
+            // Call
+            object convertFrom = converter.ConvertFrom(value);
+
+            // Assert
+            Assert.AreEqual(expectedResult, convertFrom);
+        }
+
+        [Test]
+        public void ConvertFrom_InvalidText_ThrowNotSupportedException()
+        {
+            // Setup
+            var converter = new ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter();
+
+            // Call
+            TestDelegate call = () => converter.ConvertFrom("1x");
+
+            // Assert
+            Assert.Throws<NotSupportedException>(call);
+        }
+
+        [Test]
+        [TestCase(FailureMechanismCategoryType.MechanismSpecificFactorizedSignalingNorm, ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificFactorizedSignalingNorm)]
+        [TestCase(FailureMechanismCategoryType.MechanismSpecificSignalingNorm, ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificSignalingNorm)]
+        [TestCase(FailureMechanismCategoryType.MechanismSpecificLowerLimitNorm, ConfigurationGrassCoverErosionOutwardsCategoryType.MechanismSpecificLowerLimitNorm)]
+        [TestCase(FailureMechanismCategoryType.LowerLimitNorm, ConfigurationGrassCoverErosionOutwardsCategoryType.LowerLimitNorm)]
+        [TestCase(FailureMechanismCategoryType.FactorizedLowerLimitNorm, ConfigurationGrassCoverErosionOutwardsCategoryType.FactorizedLowerLimitNorm)]
+        public void ConvertFrom_ValidFailureMechanismCategoryType_ReturnConfigurationFailureMechanismCategoryType(
+            FailureMechanismCategoryType originalValue, ConfigurationGrassCoverErosionOutwardsCategoryType expectedResult)
+        {
+            // Setup
+            var converter = new ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter();
+
+            // Call
+            object categoryType = converter.ConvertFrom(originalValue);
+
+            // Assert
+            Assert.AreEqual(expectedResult, categoryType);
+        }
+
+        [Test]
+        public void ConvertFrom_InvalidFailureMechanismCategoryType_ThrowInvalidEnumArgumentException()
+        {
+            // Setup
+            const FailureMechanismCategoryType invalidValue = (FailureMechanismCategoryType) 99;
+            var converter = new ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter();
+
+            // Call
+            TestDelegate call = () => converter.ConvertFrom(invalidValue);
+
+            // Assert
+            string expectedMessage = $"The value of argument 'value' ({invalidValue}) is invalid for Enum type '{nameof(FailureMechanismCategoryType)}'.";
+            TestHelper.AssertThrowsArgumentExceptionAndTestMessage<InvalidEnumArgumentException>(call, expectedMessage);
+        }
+
+        [Test]
+        public void ConvertFrom_Null_ThrowNotSupportedException()
+        {
+            // Setup
+            var converter = new ConfigurationGrassCoverErosionOutwardsCategoryTypeConverter();
+
+            // Call
+            TestDelegate call = () => converter.ConvertFrom(null);
+
+            // Assert
+            Assert.Throws<NotSupportedException>(call);
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.IO.Test/Ringtoets.GrassCoverErosionOutwards.IO.Test.csproj
===================================================================
diff -u -r5621f8fe7b06f7edfebedf20d0018b1f354706f1 -rc0edeb23f0e6623c13f36ad5a57efa7edf847993
--- Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.IO.Test/Ringtoets.GrassCoverErosionOutwards.IO.Test.csproj	(.../Ringtoets.GrassCoverErosionOutwards.IO.Test.csproj)	(revision 5621f8fe7b06f7edfebedf20d0018b1f354706f1)
+++ Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.IO.Test/Ringtoets.GrassCoverErosionOutwards.IO.Test.csproj	(.../Ringtoets.GrassCoverErosionOutwards.IO.Test.csproj)	(revision c0edeb23f0e6623c13f36ad5a57efa7edf847993)
@@ -19,7 +19,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Configurations\ConfigurationGrassCoverErosionOutwardsCategoryTypeTest.cs" />
-    <Compile Include="Configurations\Converters\ConfigurationFailureMechanismCategoryTypeConverterTest.cs" />
+    <Compile Include="Configurations\Converters\ConfigurationGrassCoverErosionOutwardsCategoryTypeConverterTest.cs" />
     <Compile Include="Configurations\FailureMechanismCategoryWaveConditionsCalculationConfigurationExporterTest.cs" />
     <Compile Include="Configurations\FailureMechanismCategoryWaveConditionsCalculationConfigurationTest.cs" />
     <Compile Include="Configurations\FailureMechanismCategoryWaveConditionsCalculationConfigurationWriterTest.cs" />