public void Constructor_ExpectedValues()
        {
            // Call
            var converter = new ConfigurationDikeSoilScenarioTypeConverter();

            // Assert
            Assert.IsInstanceOf <TypeConverter>(converter);
        }
        public void CanConvertTo_OtherType_ReturnFalse()
        {
            // Setup
            var converter = new ConfigurationDikeSoilScenarioTypeConverter();

            // Call
            bool canConvertTo = converter.CanConvertTo(typeof(object));

            // Assert
            Assert.IsFalse(canConvertTo);
        }
        public void CanConvertTo_SupportedType_ReturnTrue(Type supportedType)
        {
            // Setup
            var converter = new ConfigurationDikeSoilScenarioTypeConverter();

            // Call
            bool canConvertTo = converter.CanConvertTo(supportedType);

            // Assert
            Assert.IsTrue(canConvertTo);
        }
        public void ConvertFrom_InvalidValueType_ThrowsNotSupportedException()
        {
            // Setup
            var invalidValue = new object();
            var converter    = new ConfigurationDikeSoilScenarioTypeConverter();

            // Call
            TestDelegate call = () => converter.ConvertFrom(invalidValue);

            // Assert
            Assert.Throws <NotSupportedException>(call);
        }
        public void ConvertFrom_VariousCases_ReturnExpectedConfigurationDikeSoilScenario(ConfigurationDikeSoilScenario expectedResult,
                                                                                         object value)
        {
            // Setup
            var converter = new ConfigurationDikeSoilScenarioTypeConverter();

            // Call
            object result = converter.ConvertFrom(value);

            // Assert
            Assert.AreEqual(expectedResult, result);
        }
        public void ConvertTo_InvalidDestinationType_ThrowsNotSupportedException()
        {
            // Setup
            var random    = new Random(21);
            var converter = new ConfigurationDikeSoilScenarioTypeConverter();

            // Call
            TestDelegate call = () => converter.ConvertTo(random.NextEnumValue <ConfigurationDikeSoilScenario>(), typeof(object));

            // Assert
            Assert.Throws <NotSupportedException>(call);
        }
        public void ConvertTo_VariousCases_ReturnExpectedResult(ConfigurationDikeSoilScenario value,
                                                                object expectedResult)
        {
            // Setup
            var  converter     = new ConfigurationDikeSoilScenarioTypeConverter();
            Type convertToType = expectedResult.GetType();

            // Call
            object result = converter.ConvertTo(value, convertToType);

            // Assert
            Assert.AreEqual(expectedResult, result);
        }
        /// <summary>
        /// Writes the <paramref name="dikeSoilScenario"/> in XML format to file when it has a value.
        /// </summary>
        /// <param name="writer">The writer to use for writing.</param>
        /// <param name="elementName">The XML element name.</param>
        /// <param name="dikeSoilScenario">The dike soil scenario to write.</param>
        /// <exception cref="InvalidOperationException">Thrown when the <paramref name="writer"/>
        /// is closed.</exception>
        /// <exception cref="NotSupportedException">Thrown when the conversion of
        /// <paramref name="dikeSoilScenario"/> cannot be performed.</exception>
        private static void WriteDikeSoilScenarioWhenContentAvailable(XmlWriter writer,
                                                                      string elementName,
                                                                      ConfigurationDikeSoilScenario?dikeSoilScenario)
        {
            if (!dikeSoilScenario.HasValue)
            {
                return;
            }

            var typeConverter = new ConfigurationDikeSoilScenarioTypeConverter();

            writer.WriteElementString(elementName,
                                      typeConverter.ConvertToInvariantString(dikeSoilScenario.Value));
        }
        public void ConvertTo_InvalidConfigurationDikeSoilScenario_ThrowsInvalidEnumArgumentException(Type convertToType)
        {
            // Setup
            const ConfigurationDikeSoilScenario invalidValue = (ConfigurationDikeSoilScenario)9999;
            var converter = new ConfigurationDikeSoilScenarioTypeConverter();

            // Call
            TestDelegate call = () => converter.ConvertTo(invalidValue, convertToType);

            // Assert
            string expectedMessage = $"The value of argument 'value' ({invalidValue}) is invalid for Enum type '{nameof(ConfigurationDikeSoilScenario)}'.";
            string parameterName   = TestHelper.AssertThrowsArgumentExceptionAndTestMessage <InvalidEnumArgumentException>(call, expectedMessage).ParamName;

            Assert.AreEqual("value", parameterName);
        }