public void Should_be_able_to_call_ConvertToBoolean()
 {
     const bool expected = true;
     object value = new DynamicDictionaryValue(expected);
     var actual = Convert.ToBoolean(value);
     Assert.Equal(expected, actual);
 }

 public void Should_be_able_to_call_ConvertToInt16()
 {
     const short expected = 42;
     object value = new DynamicDictionaryValue(expected);
     var actual = Convert.ToInt16(value);
     Assert.Equal(expected, actual);
 }

 public void Should_be_able_to_call_ConvertToDateTime()
 {
     DateTime expected = new DateTime(1952, 3, 11);
     object value = new DynamicDictionaryValue(expected);
     var actual = Convert.ToDateTime(value);
     Assert.Equal(expected, actual);
 }

 public void Should_be_able_to_call_ConvertToChar()
 {
     const char expected = 'a';
     object value = new DynamicDictionaryValue(expected);
     var actual = Convert.ToChar(value);
     Assert.Equal(expected, actual);
 }

 public void Should_be_able_to_call_ConvertChangeType()
 {
     const int expected = 42;
     object value = new DynamicDictionaryValue(expected);
     var actual = Convert.ChangeType(value, typeof(int));
     Assert.Equal(expected, actual);
 }

        public void Integer_dictionary_values_are_Json_serialized_as_integers()
        {
            dynamic value = 42;
            var input = new DynamicDictionaryValue(value);

            var sut = new Json.JavaScriptSerializer();
            var actual = sut.Serialize(input);

            actual.ShouldEqual(@"42");
        }

        public void Should_be_able_to_implictly_cast_long_to_other_value_types()
        {
            // Given
            dynamic valueLong = new DynamicDictionaryValue((long)10);

            // Then
            Assert.Equal(10, valueLong);
            Assert.Equal(10.0, valueLong);
            Assert.Equal(10M, valueLong);
        }

        public void Should_return_true_when_value_is_null_and_compared_with_null_using_equality_operator()
        {
            // Given
            var value = new DynamicDictionaryValue(null);

            // When
            var result = (value == null);

            // Then
            result.ShouldBeTrue();
        }

        public void Should_return_false_when_value_is_not_null_and_compared_with_non_equal_value_using_equality_operator()
        {
            // Given
            var value = new DynamicDictionaryValue(10);

            // When
            var result = (value == 11);

            // Then
            result.ShouldBeFalse();
        }

        public void Should_return_true_when_hasvalue_is_checked_when_value_is_null()
        {
            // Given
            var value = new DynamicDictionaryValue(string.Empty);

            // When
            var result = value.HasValue;

            // Then
            result.ShouldBeTrue();
        }

        public void Should_return_false_when_hasvalue_is_checked_when_value_is_not_null()
        {
            // Given
            var value = new DynamicDictionaryValue(null);

            // When
            var result = value.HasValue;

            // Then
            result.ShouldBeFalse();
        }

        public void Should_be_able_to_call_ConvertToByte()
        {
            //Given
            const byte expected = 42;
            object value = new DynamicDictionaryValue(expected);

            //When
            var actual = Convert.ToByte(value);

            //Then
            Assert.Equal(expected, actual);
        }

        public void String_dictionary_values_are_Json_serialized_as_strings()
        {
            //Given
            dynamic value = "42";
            var input = new DynamicDictionaryValue(value);

            //When
            var actual = SimpleJson.SerializeObject(input, new NancySerializationStrategy());

            //Then
            actual.ShouldEqual(@"""42""");
        }

        public void Should_return_false_when_value_is_0_and_implicitly_cast_to_bool()
        {
            // Given, When
            dynamic valueInt = new DynamicDictionaryValue(0);
            dynamic valueFloat = new DynamicDictionaryValue(0.0);
            dynamic valueDec = new DynamicDictionaryValue(0.0M);

            // Then
            Assert.False(valueInt);
            Assert.False(valueFloat);
            Assert.False(valueDec);
        }

        public void Should_implicitly_convert_from_string_based_on_given_generic_type_of_datetime()
        {
            //Given
            DateTime expected = DateTime.Parse("13 Dec, 2012");
            dynamic value = new DynamicDictionaryValue("13 December 2012");

            //When
            DateTime actual = value.TryParse<DateTime>();

            //Then
            Assert.Equal(expected, actual);
        }

        public void Should_implicitly_convert_from_string_based_on_given_generic_type_of_short()
        {
            //Given
            const short expected = (short)13;
            dynamic value = new DynamicDictionaryValue("13");

            //When
            short actual = value.TryParse<short>();

            //Then
            Assert.Equal(expected, actual);
        }

        public void Should_implicitly_convert_from_string_based_on_given_generic_type_of_double()
        {
            //Given
            const double expected = 37.48d;
            dynamic value = new DynamicDictionaryValue("37.48");

            //When
            double actual = value.TryParse<double>();

            //Then
            Assert.Equal(expected, actual);
        }

        public void Should_implicitly_convert_from_string_based_on_given_generic_type_of_decimal()
        {
            //Given
            const decimal expected = 55.23m;
            dynamic value = new DynamicDictionaryValue("55.23");

            //When
            decimal actual = value.TryParse<decimal>();

            //Then
            Assert.Equal(expected, actual);
        }

        public void Should_return_default_when_given_string_that_is_not_a_number()
        {
            //Given
            const int expected = 100;
            dynamic value = new DynamicDictionaryValue("4abc2");

            //When
            int actual = value.TryParse<int>(expected);

            //Then
            Assert.Equal(expected, actual);
        }

        public void Should_implicitly_convert_from_string_based_on_given_generic_type_of_int()
        {
            //Given
            const int expected = 42;
            dynamic value = new DynamicDictionaryValue("42");

            //When
            int actual = value.TryParse<int>();

            //Then
            Assert.Equal(expected, actual);
        }