public void EnumConversionStrategyTest()
        {
            var    strategy = new EnumConversionStrategy();
            object newValue;


            Assert.IsFalse(strategy.TryConvert(new object(), typeof(object), out newValue));


            // String to Enum

            Assert.IsFalse(strategy.TryConvert("XXX", typeof(ConvertEnumTest), out newValue));

            Assert.IsTrue(strategy.TryConvert("One", typeof(ConvertEnumTest), out newValue));
            Assert.AreEqual(ConvertEnumTest.One, newValue);

            Assert.IsTrue(strategy.TryConvert("Two", typeof(ConvertEnumTest), out newValue));
            Assert.AreEqual(ConvertEnumTest.Two, newValue);

            Assert.IsTrue(strategy.TryConvert(" THREE ", typeof(ConvertEnumTest), out newValue));
            Assert.AreEqual(ConvertEnumTest.Three, newValue);


            // Int to Enum

            Assert.IsFalse(strategy.TryConvert(5, typeof(ConvertEnumTest), out newValue));

            Assert.IsTrue(strategy.TryConvert(1, typeof(ConvertEnumTest), out newValue));
            Assert.AreEqual(ConvertEnumTest.One, newValue);

            Assert.IsTrue(strategy.TryConvert(2, typeof(ConvertEnumTest), out newValue));
            Assert.AreEqual(ConvertEnumTest.Two, newValue);

            Assert.IsTrue(strategy.TryConvert(2, typeof(ConvertEnumTest2), out newValue));
            Assert.AreEqual(ConvertEnumTest2.Two, newValue);


            // Enum to Xxx

            Assert.IsFalse(strategy.TryConvert(ConvertEnumTest.One, typeof(DateTime), out newValue));

            Assert.IsTrue(strategy.TryConvert(ConvertEnumTest.One, typeof(decimal), out newValue));
            Assert.AreEqual(1m, newValue);

            Assert.IsTrue(strategy.TryConvert(ConvertEnumTest.One, typeof(string), out newValue));
            Assert.AreEqual("One", newValue);

            Assert.IsTrue(strategy.TryConvert(ConvertEnumTest.One, typeof(int), out newValue));
            Assert.AreEqual(1, newValue);

            Assert.IsTrue(strategy.TryConvert(ConvertEnumTest.One, typeof(byte), out newValue));
            Assert.AreEqual((byte)1, newValue);

            Assert.IsTrue(strategy.TryConvert(ConvertEnumTest.One, typeof(long), out newValue));
            Assert.AreEqual((long)1, newValue);
        }
        public void EnumConversionStrategyTest()
        {
            var strategy = new EnumConversionStrategy();

            Assert.IsFalse(strategy.CanConvert(typeof(object), typeof(object)));
            Assert.IsTrue(strategy.CanConvert(typeof(ConvertEnumTest), typeof(int)));
            Assert.IsTrue(strategy.CanConvert(typeof(int), typeof(ConvertEnumTest)));
            Assert.IsTrue(strategy.CanConvert(typeof(ConvertEnumTest), typeof(string)));
            Assert.IsTrue(strategy.CanConvert(typeof(string), typeof(ConvertEnumTest)));
            Assert.IsFalse(strategy.CanConvert(typeof(object), typeof(ConvertEnumTest)));

            var val = strategy.Convert(typeof(ConvertEnumTest), typeof(int), ConvertEnumTest.Two, null);

            Assert.AreEqual(2, val);

            val = strategy.Convert(typeof(ConvertEnumTest), typeof(string), ConvertEnumTest.Two, null);
            Assert.AreEqual("Two", val);

            val = strategy.Convert(typeof(int), typeof(ConvertEnumTest), 2, null);
            Assert.AreEqual(ConvertEnumTest.Two, val);

            val = strategy.Convert(typeof(string), typeof(ConvertEnumTest), "Two", null);
            Assert.AreEqual(ConvertEnumTest.Two, val);
        }