/test/System.Json.Test.Integration/JsonValueDynamicTests.cs

using System.Collections.Generic;
using System.Dynamic;
using System.Globalization;
using System.Reflection;
using System.Runtime.Serialization.Json;
using Xunit;

namespace System.Json
{
    /// <summary>
    /// Tests for the dynamic support for <see cref="JsonValue"/>.
    /// </summary>
    public class JsonValueDynamicTests
    {
        string teamNameValue = "WCF RIA Base";
        string[] teamMembersValues = { "Carlos", "Chris", "Joe", "Miguel", "Yavor" };

        /// <summary>
        /// Tests for the dynamic getters in <see cref="JsonObject"/> instances.
        /// </summary>
        [Fact]
        public void JsonObjectDynamicGetters()
        {
            dynamic team = new JsonObject();
            team["TeamSize"] = this.teamMembersValues.Length;
            team["TeamName"] = this.teamNameValue;
            team["TeamMascots"] = null;
            team["TeamMembers"] = new JsonArray 
            { 
                this.teamMembersValues[0], this.teamMembersValues[1], this.teamMembersValues[2],
                this.teamMembersValues[3], this.teamMembersValues[4] 
            };

            Assert.Equal(this.teamMembersValues.Length, (int)team.TeamSize);
            Assert.Equal(this.teamNameValue, (string)team.TeamName);
            Assert.NotNull(team.TeamMascots);
            Assert.True(team.TeamMascots is JsonValue); // default

            for (int i = 0; i < this.teamMembersValues.Length; i++)
            {
                Assert.Equal(this.teamMembersValues[i], (string)team.TeamMembers[i]);
            }

            for (int i = 0; i < this.teamMembersValues.Length; i++)
            {
                Assert.Equal(this.teamMembersValues[i], (string)team.TeamMembers[i]);
            }

            // Negative tests for getters
            JsonValueTests.ExpectException<InvalidCastException>(delegate { int fail = (int)team.NonExistentProp; });
        }

        /// <summary>
        /// Tests for the dynamic setters in <see cref="JsonObject"/> instances.
        /// </summary>
        [Fact]
        public void JsonObjectDynamicSetters()
        {
            dynamic team = new JsonObject();
            team.TeamSize = this.teamMembersValues.Length;
            team.TeamName = this.teamNameValue;
            team.TeamMascots = null;
            team.TeamMembers = new JsonArray 
            { 
                this.teamMembersValues[0], this.teamMembersValues[1], this.teamMembersValues[2],
                this.teamMembersValues[3], this.teamMembersValues[4] 
            };

            Assert.Equal(this.teamMembersValues.Length, (int)team["TeamSize"]);
            Assert.Equal(this.teamNameValue, (string)team["TeamName"]);
            Assert.NotNull(team["TeamMascots"]);
            Assert.True(team["TeamMascots"] is JsonValue);

            for (int i = 0; i < this.teamMembersValues.Length; i++)
            {
                Assert.Equal(this.teamMembersValues[i], (string)team["TeamMembers"][i]);
            }

            // Could not come up with negative setter
        }

        /// <summary>
        /// Tests for the dynamic indexers in <see cref="JsonArray"/> instances.
        /// </summary>
        [Fact]
        public void JsonArrayDynamicSanity()
        {
            // Sanity test for JsonArray to ensure [] still works even if dynamic
            dynamic people = new JsonArray();
            foreach (string member in this.teamMembersValues)
            {
                people.Add(member);
            }

            Assert.Equal(this.teamMembersValues[0], (string)people[0]);
            Assert.Equal(this.teamMembersValues[1], (string)people[1]);
            Assert.Equal(this.teamMembersValues[2], (string)people[2]);
            Assert.Equal(this.teamMembersValues[3], (string)people[3]);
            Assert.Equal(this.teamMembersValues[4], (string)people[4]);

            // Note: this test and the above execute the dynamic binder differently.
            for (int i = 0; i < people.Count; i++)
            {
                Assert.Equal(this.teamMembersValues[i], (string)people[i]);
            }

            people.Add(this.teamMembersValues.Length);
            people.Add(this.teamNameValue);

            Assert.Equal(this.teamMembersValues.Length, (int)people[5]);
            Assert.Equal(this.teamNameValue, (string)people[6]);
        }

        /// <summary>
        /// Tests for calling methods in dynamic references to <see cref="JsonValue"/> instances.
        /// </summary>
        [Fact]
        public void DynamicMethodCalling()
        {
            JsonObject jo = new JsonObject();
            dynamic dyn = jo;
            dyn.Foo = "bar";
            Assert.Equal(1, jo.Count);
            Assert.Equal(1, dyn.Count);
            dyn.Remove("Foo");
            Assert.Equal(0, jo.Count);
        }

        /// <summary>
        /// Tests for using boolean operators in dynamic references to <see cref="JsonValue"/> instances.
        /// </summary>
        [Fact(Skip = "Ignore")]
        public void DynamicBooleanOperators()
        {
            JsonValue jv;
            dynamic dyn;
            foreach (bool value in new bool[] { true, false })
            {
                jv = value;
                dyn = jv;
                Log.Info("IsTrue, {0}", jv);
                if (dyn)
                {
                    Assert.True(value, "Boolean evaluation should not enter 'if' clause.");
                }
                else
                {
                    Assert.False(value, "Boolean evaluation should not enter 'else' clause.");
                }
            }

            foreach (string value in new string[] { "true", "false", "True", "False" })
            {
                bool isTrueValue = value.Equals("true", StringComparison.InvariantCultureIgnoreCase);
                jv = new JsonPrimitive(value);
                dyn = jv;
                Log.Info("IsTrue, {0}", jv);
                if (dyn)
                {
                    Assert.True(isTrueValue, "Boolean evaluation should not enter 'if' clause.");
                }
                else
                {
                    Assert.False(isTrueValue, "Boolean evaluation should not enter 'else' clause.");
                }
            }

            foreach (bool first in new bool[] { false, true })
            {
                dynamic dyn1 = new JsonPrimitive(first);
                Log.Info("Negation, {0}", first);
                Assert.Equal(!first, !dyn1);
                foreach (bool second in new bool[] { false, true })
                {
                    dynamic dyn2 = new JsonPrimitive(second);
                    Log.Info("Boolean AND, {0} && {1}", first, second);
                    Assert.Equal(first && second, (bool)(dyn1 && dyn2));
                    Log.Info("Boolean OR, {0} && {1}", first, second);
                    Assert.Equal(first || second, (bool)(dyn1 || dyn2));
                }
            }

            Log.Info("Invalid boolean operator usage");
            dynamic boolDyn = new JsonPrimitive(true);
            dynamic intDyn = new JsonPrimitive(1);
            dynamic strDyn = new JsonPrimitive("hello");

            JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info("{0}", !intDyn); });

            JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info("{0}", !strDyn); });
            JsonValueTests.ExpectException<InvalidCastException>(() => { Log.Info("{0}", intDyn && intDyn); });
            JsonValueTests.ExpectException<InvalidCastException>(() => { Log.Info("{0}", intDyn || true); });
            JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info("{0}", boolDyn && 1); });
            JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info("{0}", boolDyn && intDyn); });
            JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info("{0}", boolDyn && "hello"); });
            JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info("{0}", boolDyn && strDyn); });
            JsonValueTests.ExpectException<FormatException>(() => { Log.Info("{0}", strDyn && boolDyn); });
            JsonValueTests.ExpectException<FormatException>(() => { Log.Info("{0}", strDyn || true); });

            JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info("{0}", !intDyn.NotHere); });
            JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info("{0}", !intDyn.NotHere && true); });
            JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info("{0}", !intDyn.NotHere || false); });
        }

        /// <summary>
        /// Tests for using relational operators in dynamic references to <see cref="JsonValue"/> instances.
        /// </summary>
        [Fact(Skip = "Ignore")]
        public void DynamicRelationalOperators()
        {
            JsonValue jv = new JsonObject { { "one", 1 }, { "one_point_two", 1.2 }, { "decimal_one_point_one", 1.1m }, { "trueValue", true }, { "str", "hello" } };
            dynamic dyn = jv;
            JsonValue defaultJsonValue = jv.ValueOrDefault(-1);

            Log.Info("Equality");
            Assert.True(dyn.one == 1);
            Assert.True(dyn.one_point_two == 1.2);
            Assert.False(dyn.one == 1.2);
            Assert.False(dyn.one_point_two == 1);
            Assert.False(dyn.one == 2);
            Assert.False(dyn.one_point_two == 1.3);
            Assert.True(dyn.one == 1m);
            Assert.False(dyn.one == 2m);
            Assert.True(dyn.decimal_one_point_one == 1.1m);

            Assert.True(dyn.NotHere == null);
            Assert.True(dyn.NotHere == dyn.NotHere);
            Assert.True(dyn.NotHere == defaultJsonValue);
            // DISABLED, 197375, Assert.False(dyn.NotHere == 1);
            Assert.False(dyn.NotHere == jv);

            Log.Info("Inequality");
            Assert.False(dyn.one != 1);
            Assert.False(dyn.one_point_two != 1.2);
            Assert.True(dyn.one != 1.2);
            Assert.True(dyn.one_point_two != 1);
            Assert.True(dyn.one != 2);
            Assert.True(dyn.one_point_two != 1.3);
            Assert.False(dyn.one != 1m);
            Assert.True(dyn.one != 2m);

            Assert.False(dyn.NotHere != null);
            Assert.False(dyn.NotHere != dyn.NotHere);
            Assert.False(dyn.NotHere != defaultJsonValue);
            // DISABLED, 197375, Assert.True(dyn.NotHere != 1);
            Assert.True(dyn.NotHere != jv);

            Log.Info("Less than");
            Assert.True(dyn.one < 2);
            Assert.False(dyn.one < 1);
            Assert.False(dyn.one < 0);
            Assert.True(dyn.one_point_two < 1.3);
            Assert.False(dyn.one_point_two < 1.2);
            Assert.False(dyn.one_point_two < 1.1);

            Assert.True(dyn.one < 1.1);
            Assert.Equal(1 < 1.0, dyn.one < 1.0);
            Assert.False(dyn.one < 0.9);
            Assert.True(dyn.one_point_two < 2);
            Assert.False(dyn.one_point_two < 1);
            Assert.Equal(1.2 < 1.2f, dyn.one_point_two < 1.2f);

            Log.Info("Greater than");
            Assert.False(dyn.one > 2);
            Assert.False(dyn.one > 1);
            Assert.True(dyn.one > 0);
            Assert.False(dyn.one_point_two > 1.3);
            Assert.False(dyn.one_point_two > 1.2);
            Assert.True(dyn.one_point_two > 1.1);

            Assert.False(dyn.one > 1.1);
            Assert.Equal(1 > 1.0, dyn.one > 1.0);
            Assert.True(dyn.one > 0.9);
            Assert.False(dyn.one_point_two > 2);
            Assert.True(dyn.one_point_two > 1);
            Assert.Equal(1.2 > 1.2f, dyn.one_point_two > 1.2f);

            Log.Info("Less than or equals");
            Assert.True(dyn.one <= 2);
            Assert.True(dyn.one <= 1);
            Assert.False(dyn.one <= 0);
            Assert.True(dyn.one_point_two <= 1.3);
            Assert.True(dyn.one_point_two <= 1.2);
            Assert.False(dyn.one_point_two <= 1.1);

            Assert.True(dyn.one <= 1.1);
            Assert.Equal(1 <= 1.0, dyn.one <= 1.0);
            Assert.False(dyn.one <= 0.9);
            Assert.True(dyn.one_point_two <= 2);
            Assert.False(dyn.one_point_two <= 1);
            Assert.Equal(1.2 <= 1.2f, dyn.one_point_two <= 1.2f);

            Log.Info("Greater than or equals");
            Assert.False(dyn.one >= 2);
            Assert.True(dyn.one >= 1);
            Assert.True(dyn.one >= 0);
            Assert.False(dyn.one_point_two >= 1.3);
            Assert.True(dyn.one_point_two >= 1.2);
            Assert.True(dyn.one_point_two >= 1.1);

            Assert.False(dyn.one >= 1.1);
            Assert.Equal(1 >= 1.0, dyn.one >= 1.0);
            Assert.True(dyn.one >= 0.9);
            Assert.False(dyn.one_point_two >= 2);
            Assert.True(dyn.one_point_two >= 1);
            Assert.Equal(1.2 >= 1.2f, dyn.one_point_two >= 1.2f);

            Log.Info("Invalid number conversions");
            JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info(dyn.decimal_one_point_one == 1.1); });
            JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info(dyn.one != (uint)2); });

            Log.Info("Invalid data types for relational operators");
            JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info(dyn.trueValue >= dyn.trueValue); });
            JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info(dyn.NotHere < dyn.NotHere); });
            JsonValueTests.ExpectException<InvalidOperationException>(() => { Log.Info(dyn.str < "Jello"); });

            // DISABLED, 197315
            Log.Info("Conversions from string");
            jv = new JsonObject { { "one", "1" }, { "twelve_point_two", "1.22e1" } };
            dyn = jv;
            Assert.True(dyn.one == 1);
            Assert.True(dyn.twelve_point_two == 1.22e1);
            Assert.True(dyn.one >= 0.5f);
            Assert.True(dyn.twelve_point_two <= 13);
            Assert.True(dyn.one < 2);
            Assert.Equal(dyn.twelve_point_two.ReadAs<int>() > 12, dyn.twelve_point_two > 12);
        }

        /// <summary>
        /// Tests for using arithmetic operators in dynamic references to <see cref="JsonValue"/> instances.
        /// </summary>
        [Fact(Skip = "Ignore")]
        public void ArithmeticOperators()
        {
            int seed = MethodBase.GetCurrentMethod().Name.GetHashCode();
            Log.Info("Seed: {0}", seed);
            Random rndGen = new Random(seed);
            int i1 = rndGen.Next(-10000, 10000);
            int i2 = rndGen.Next(-10000, 10000);
            JsonValue jv1 = i1;
            JsonValue jv2 = i2;
            Log.Info("jv1 = {0}, jv2 = {1}", jv1, jv2);
            dynamic dyn1 = jv1;
            dynamic dyn2 = jv2;

            string str1 = i1.ToString(CultureInfo.InvariantCulture);
            string str2 = i2.ToString(CultureInfo.InvariantCulture);
            JsonValue jvstr1 = str1;
            JsonValue jvstr2 = str2;

            Log.Info("Unary +");
            Assert.Equal<int>(+i1, +dyn1);
            Assert.Equal<int>(+i2, +dyn2);

            Log.Info("Unary -");
            Assert.Equal<int>(-i1, -dyn1);
            Assert.Equal<int>(-i2, -dyn2);

            Log.Info("Unary ~ (bitwise NOT)");
            Assert.Equal<int>(~i1, ~dyn1);
            Assert.Equal<int>(~i2, ~dyn2);

            Log.Info("Binary +: {0}", i1 + i2);
            Assert.Equal<int>(i1 + i2, dyn1 + dyn2);
            Assert.Equal<int>(i1 + i2, dyn2 + dyn1);
            Assert.Equal<int>(i1 + i2, dyn1 + i2);
            Assert.Equal<int>(i1 + i2, dyn2 + i1);

            // DISABLED, 197394
            // Assert.Equal<int>(i1 + i2, dyn1 + str2);
            // Assert.Equal<int>(i1 + i2, dyn1 + jvstr2);

            Log.Info("Binary -: {0}, {1}", i1 - i2, i2 - i1);
            Assert.Equal<int>(i1 - i2, dyn1 - dyn2);
            Assert.Equal<int>(i2 - i1, dyn2 - dyn1);
            Assert.Equal<int>(i1 - i2, dyn1 - i2);
            Assert.Equal<int>(i2 - i1, dyn2 - i1);

            Log.Info("Binary *: {0}", i1 * i2);
            Assert.Equal<int>(i1 * i2, dyn1 * dyn2);
            Assert.Equal<int>(i1 * i2, dyn2 * dyn1);
            Assert.Equal<int>(i1 * i2, dyn1 * i2);
            Assert.Equal<int>(i1 * i2, dyn2 * i1);

            while (i1 == 0)
            {
                i1 = rndGen.Next(-10000, 10000);
                jv1 = i1;
                dyn1 = jv1;
                Log.Info("Using new (non-zero) i1 value: {0}", i1);
            }

            while (i2 == 0)
            {
                i2 = rndGen.Next(-10000, 10000);
                jv2 = i2;
                dyn2 = jv2;
                Log.Info("Using new (non-zero) i2 value: {0}", i2);
            }

            Log.Info("Binary / (integer division): {0}, {1}", i1 / i2, i2 / i1);
            Assert.Equal<int>(i1 / i2, dyn1 / dyn2);
            Assert.Equal<int>(i2 / i1, dyn2 / dyn1);
            Assert.Equal<int>(i1 / i2, dyn1 / i2);
            Assert.Equal<int>(i2 / i1, dyn2 / i1);

            Log.Info("Binary % (modulo): {0}, {1}", i1 % i2, i2 % i1);
            Assert.Equal<int>(i1 % i2, dyn1 % dyn2);
            Assert.Equal<int>(i2 % i1, dyn2 % dyn1);
            Assert.Equal<int>(i1 % i2, dyn1 % i2);
            Assert.Equal<int>(i2 % i1, dyn2 % i1);

            Log.Info("Binary & (bitwise AND): {0}", i1 & i2);
            Assert.Equal<int>(i1 & i2, dyn1 & dyn2);
            Assert.Equal<int>(i1 & i2, dyn2 & dyn1);
            Assert.Equal<int>(i1 & i2, dyn1 & i2);
            Assert.Equal<int>(i1 & i2, dyn2 & i1);

            Log.Info("Binary | (bitwise OR): {0}", i1 | i2);
            Assert.Equal<int>(i1 | i2, dyn1 | dyn2);
            Assert.Equal<int>(i1 | i2, dyn2 | dyn1);
            Assert.Equal<int>(i1 | i2, dyn1 | i2);
            Assert.Equal<int>(i1 | i2, dyn2 | i1);

            Log.Info("Binary ^ (bitwise XOR): {0}", i1 ^ i2);
            Assert.Equal<int>(i1 ^ i2, dyn1 ^ dyn2);
            Assert.Equal<int>(i1 ^ i2, dyn2 ^ dyn1);
            Assert.Equal<int>(i1 ^ i2, dyn1 ^ i2);
            Assert.Equal<int>(i1 ^ i2, dyn2 ^ i1);

            i1 = rndGen.Next(1, 10);
            i2 = rndGen.Next(1, 10);
            jv1 = i1;
            jv2 = i2;
            dyn1 = jv1;
            dyn2 = jv2;
            Log.Info("New i1, i2: {0}, {1}", i1, i2);

            Log.Info("Left shift: {0}", i1 << i2);
            Assert.Equal<int>(i1 << i2, dyn1 << dyn2);
            Assert.Equal<int>(i1 << i2, dyn1 << i2);

            i1 = i1 << i2;
            jv1 = i1;
            dyn1 = jv1;
            Log.Info("New i1: {0}", i1);
            Log.Info("Right shift: {0}", i1 >> i2);
            Assert.Equal<int>(i1 >> i2, dyn1 >> dyn2);
            Assert.Equal<int>(i1 >> i2, dyn1 >> i2);

            i2 += 4;
            jv2 = i2;
            dyn2 = jv2;
            Log.Info("New i2: {0}", i2);
            Log.Info("Right shift: {0}", i1 >> i2);
            Assert.Equal<int>(i1 >> i2, dyn1 >> dyn2);
            Assert.Equal<int>(i1 >> i2, dyn1 >> i2);
        }

        /// <summary>
        /// Tests for conversions between data types in arithmetic operations.
        /// </summary>
        [Fact(Skip = "Ignore")]
        public void ArithmeticConversion()
        {
            JsonObject jo = new JsonObject
            {
                { "byteVal", (byte)10 },
                { "sbyteVal", (sbyte)10 },
                { "shortVal", (short)10 },
                { "ushortVal", (ushort)10 },
                { "intVal", 10 },
                { "uintVal", (uint)10 },
                { "longVal", 10L },
                { "ulongVal", (ulong)10 },
                { "charVal", (char)10 },
                { "decimalVal", 10m },
                { "doubleVal", 10.0 },
                { "floatVal", 10f },
            };
            dynamic dyn = jo;

            Log.Info("Conversion from byte");
            // DISABLED, 197387, ValidateResult<int>(dyn.byteVal + (byte)10, 20);
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.byteVal + (sbyte)10));
            ValidateResult<short>(dyn.byteVal + (short)10, 20);
            ValidateResult<ushort>(dyn.byteVal + (ushort)10, 20);
            ValidateResult<int>(dyn.byteVal + (int)10, 20);
            ValidateResult<uint>(dyn.byteVal + (uint)10, 20);
            ValidateResult<long>(dyn.byteVal + 10L, 20);
            ValidateResult<ulong>(dyn.byteVal + (ulong)10, 20);
            ValidateResult<decimal>(dyn.byteVal + 10m, 20);
            ValidateResult<float>(dyn.byteVal + 10f, 20);
            ValidateResult<double>(dyn.byteVal + 10.0, 20);

            Log.Info("Conversion from sbyte");
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.sbyteVal + (byte)10));
            // DISABLED, 197387, ValidateResult<int>(dyn.sbyteVal + (sbyte)10, 20);
            ValidateResult<short>(dyn.sbyteVal + (short)10, 20);
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.sbyteVal + (ushort)10));
            ValidateResult<int>(dyn.sbyteVal + (int)10, 20);
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.sbyteVal + (uint)10));
            ValidateResult<long>(dyn.sbyteVal + 10L, 20);
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.sbyteVal + (ulong)10));
            ValidateResult<decimal>(dyn.sbyteVal + 10m, 20);
            ValidateResult<float>(dyn.sbyteVal + 10f, 20);
            ValidateResult<double>(dyn.sbyteVal + 10.0, 20);

            Log.Info("Conversion from short");
            ValidateResult<short>(dyn.shortVal + (byte)10, 20);
            ValidateResult<short>(dyn.shortVal + (sbyte)10, 20);
            ValidateResult<short>(dyn.shortVal + (short)10, 20);
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.shortVal + (ushort)10));
            ValidateResult<int>(dyn.shortVal + (int)10, 20);
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.shortVal + (uint)10));
            ValidateResult<long>(dyn.shortVal + 10L, 20);
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.shortVal + (ulong)10));
            ValidateResult<decimal>(dyn.shortVal + 10m, 20);
            ValidateResult<float>(dyn.shortVal + 10f, 20);
            ValidateResult<double>(dyn.shortVal + 10.0, 20);

            Log.Info("Conversion from ushort");
            ValidateResult<ushort>(dyn.ushortVal + (byte)10, 20);
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.ushortVal + (sbyte)10));
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.ushortVal + (short)10));
            ValidateResult<ushort>(dyn.ushortVal + (ushort)10, 20);
            ValidateResult<int>(dyn.ushortVal + (int)10, 20);
            ValidateResult<uint>(dyn.ushortVal + (uint)10, 20);
            ValidateResult<long>(dyn.ushortVal + 10L, 20);
            ValidateResult<ulong>(dyn.ushortVal + (ulong)10, 20);
            ValidateResult<decimal>(dyn.ushortVal + 10m, 20);
            ValidateResult<float>(dyn.ushortVal + 10f, 20);
            ValidateResult<double>(dyn.ushortVal + 10.0, 20);

            Log.Info("Conversion from int");
            ValidateResult<int>(dyn.intVal + (byte)10, 20);
            ValidateResult<int>(dyn.intVal + (sbyte)10, 20);
            ValidateResult<int>(dyn.intVal + (short)10, 20);
            ValidateResult<int>(dyn.intVal + (ushort)10, 20);
            ValidateResult<int>(dyn.intVal + (int)10, 20);
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.intVal + (uint)10));
            ValidateResult<long>(dyn.intVal + 10L, 20);
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.intVal + (ulong)10));
            ValidateResult<decimal>(dyn.intVal + 10m, 20);
            ValidateResult<float>(dyn.intVal + 10f, 20);
            ValidateResult<double>(dyn.intVal + 10.0, 20);

            Log.Info("Conversion from uint");
            ValidateResult<uint>(dyn.uintVal + (byte)10, 20);
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.uintVal + (sbyte)10));
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.uintVal + (short)10));
            ValidateResult<uint>(dyn.uintVal + (ushort)10, 20);
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.uintVal + (int)10));
            ValidateResult<uint>(dyn.uintVal + (uint)10, 20);
            ValidateResult<long>(dyn.uintVal + 10L, 20);
            ValidateResult<ulong>(dyn.uintVal + (ulong)10, 20);
            ValidateResult<decimal>(dyn.uintVal + 10m, 20);
            ValidateResult<float>(dyn.uintVal + 10f, 20);
            ValidateResult<double>(dyn.uintVal + 10.0, 20);

            Log.Info("Conversion from long");
            ValidateResult<long>(dyn.longVal + (byte)10, 20);
            ValidateResult<long>(dyn.longVal + (sbyte)10, 20);
            ValidateResult<long>(dyn.longVal + (short)10, 20);
            ValidateResult<long>(dyn.longVal + (ushort)10, 20);
            ValidateResult<long>(dyn.longVal + (int)10, 20);
            ValidateResult<long>(dyn.longVal + (uint)10, 20);
            ValidateResult<long>(dyn.longVal + 10L, 20);
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.longVal + (ulong)10));
            ValidateResult<decimal>(dyn.longVal + 10m, 20);
            ValidateResult<float>(dyn.longVal + 10f, 20);
            ValidateResult<double>(dyn.longVal + 10.0, 20);

            Log.Info("Conversion from ulong");
            ValidateResult<ulong>(dyn.ulongVal + (byte)10, 20);
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.ulongVal + (sbyte)10));
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.ulongVal + (short)10));
            ValidateResult<ulong>(dyn.ulongVal + (ushort)10, 20);
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.ulongVal + (int)10));
            ValidateResult<ulong>(dyn.ulongVal + (uint)10, 20);
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.ulongVal + (long)10));
            ValidateResult<ulong>(dyn.ulongVal + (ulong)10, 20);
            ValidateResult<decimal>(dyn.ulongVal + 10m, 20);
            ValidateResult<float>(dyn.ulongVal + 10f, 20);
            ValidateResult<double>(dyn.ulongVal + 10.0, 20);

            Log.Info("Conversion from float");
            ValidateResult<float>(dyn.floatVal + (byte)10, 20);
            ValidateResult<float>(dyn.floatVal + (sbyte)10, 20);
            ValidateResult<float>(dyn.floatVal + (short)10, 20);
            ValidateResult<float>(dyn.floatVal + (ushort)10, 20);
            ValidateResult<float>(dyn.floatVal + (int)10, 20);
            ValidateResult<float>(dyn.floatVal + (uint)10, 20);
            ValidateResult<float>(dyn.floatVal + 10L, 20);
            ValidateResult<float>(dyn.floatVal + (ulong)10, 20);
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.floatVal + 10m));
            ValidateResult<float>(dyn.floatVal + 10f, 20);
            ValidateResult<double>(dyn.floatVal + 10.0, 20);

            Log.Info("Conversion from double");
            ValidateResult<double>(dyn.doubleVal + (byte)10, 20);
            ValidateResult<double>(dyn.doubleVal + (sbyte)10, 20);
            ValidateResult<double>(dyn.doubleVal + (short)10, 20);
            ValidateResult<double>(dyn.doubleVal + (ushort)10, 20);
            ValidateResult<double>(dyn.doubleVal + (int)10, 20);
            ValidateResult<double>(dyn.doubleVal + (uint)10, 20);
            ValidateResult<double>(dyn.doubleVal + 10L, 20);
            ValidateResult<double>(dyn.doubleVal + (ulong)10, 20);
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.doubleVal + 10m));
            ValidateResult<double>(dyn.doubleVal + 10f, 20);
            ValidateResult<double>(dyn.doubleVal + 10.0, 20);

            Log.Info("Conversion from decimal");
            ValidateResult<decimal>(dyn.decimalVal + (byte)10, 20);
            ValidateResult<decimal>(dyn.decimalVal + (sbyte)10, 20);
            ValidateResult<decimal>(dyn.decimalVal + (short)10, 20);
            ValidateResult<decimal>(dyn.decimalVal + (ushort)10, 20);
            ValidateResult<decimal>(dyn.decimalVal + (int)10, 20);
            ValidateResult<decimal>(dyn.decimalVal + (uint)10, 20);
            ValidateResult<decimal>(dyn.decimalVal + 10L, 20);
            ValidateResult<decimal>(dyn.decimalVal + (ulong)10, 20);
            ValidateResult<decimal>(dyn.decimalVal + 10m, 20);
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.decimalVal + 10f));
            JsonValueTests.ExpectException<InvalidOperationException>(() => Log.Info("{0}", dyn.decimalVal + 10.0));
        }

        /// <summary>
        /// Tests for implicit casts between dynamic references to <see cref="JsonPrimitive"/> instances
        /// and the supported CLR types.
        /// </summary>
        [Fact]
        public void ImplicitPrimitiveCastTests()
        {
            DateTime now = DateTime.Now;
            int seed = now.Year * 10000 + now.Month * 100 + now.Day;
            Log.Info("Seed: {0}", seed);
            Random rndGen = new Random(seed);
            int intValue = rndGen.Next(1, 127);
            Log.Info("Value: {0}", intValue);

            uint uintValue = (uint)intValue;
            short shortValue = (short)intValue;
            ushort ushortValue = (ushort)intValue;
            long longValue = (long)intValue;
            ulong ulongValue = (ulong)intValue;
            byte byteValue = (byte)intValue;
            sbyte sbyteValue = (sbyte)intValue;
            float floatValue = (float)intValue;
            double doubleValue = (double)intValue;
            decimal decimalValue = (decimal)intValue;
            string stringValue = intValue.ToString(CultureInfo.InvariantCulture);

            dynamic dyn = new JsonObject
            {
                { "Byte", byteValue },
                { "SByte", sbyteValue },
                { "Int16", shortValue },
                { "UInt16", ushortValue },
                { "Int32", intValue },
                { "UInt32", uintValue },
                { "Int64", longValue },
                { "UInt64", ulongValue },
                { "Double", doubleValue },
                { "Single", floatValue },
                { "Decimal", decimalValue },
                { "String", stringValue },
                { "True", "true" },
                { "False", "false" },
            };

            Log.Info("dyn: {0}", dyn);

            Log.Info("Casts to Byte");

            byte byteFromByte = dyn.Byte;
            byte byteFromSByte = dyn.SByte;
            byte byteFromShort = dyn.Int16;
            byte byteFromUShort = dyn.UInt16;
            byte byteFromInt = dyn.Int32;
            byte byteFromUInt = dyn.UInt32;
            byte byteFromLong = dyn.Int64;
            byte byteFromULong = dyn.UInt64;
            byte byteFromDouble = dyn.Double;
            byte byteFromFloat = dyn.Single;
            byte byteFromDecimal = dyn.Decimal;
            byte byteFromString = dyn.String;

            Assert.Equal<byte>(byteValue, byteFromByte);
            Assert.Equal<byte>(byteValue, byteFromSByte);
            Assert.Equal<byte>(byteValue, byteFromShort);
            Assert.Equal<byte>(byteValue, byteFromUShort);
            Assert.Equal<byte>(byteValue, byteFromInt);
            Assert.Equal<byte>(byteValue, byteFromUInt);
            Assert.Equal<byte>(byteValue, byteFromLong);
            Assert.Equal<byte>(byteValue, byteFromULong);
            Assert.Equal<byte>(byteValue, byteFromDouble);
            Assert.Equal<byte>(byteValue, byteFromFloat);
            Assert.Equal<byte>(byteValue, byteFromDecimal);
            Assert.Equal<byte>(byteValue, byteFromString);

            Log.Info("Casts to SByte");

            sbyte sbyteFromByte = dyn.Byte;
            sbyte sbyteFromSByte = dyn.SByte;
            sbyte sbyteFromShort = dyn.Int16;
            sbyte sbyteFromUShort = dyn.UInt16;
            sbyte sbyteFromInt = dyn.Int32;
            sbyte sbyteFromUInt = dyn.UInt32;
            sbyte sbyteFromLong = dyn.Int64;
            sbyte sbyteFromULong = dyn.UInt64;
            sbyte sbyteFromDouble = dyn.Double;
            sbyte sbyteFromFloat = dyn.Single;
            sbyte sbyteFromDecimal = dyn.Decimal;
            sbyte sbyteFromString = dyn.String;

            Assert.Equal<sbyte>(sbyteValue, sbyteFromByte);
            Assert.Equal<sbyte>(sbyteValue, sbyteFromSByte);
            Assert.Equal<sbyte>(sbyteValue, sbyteFromShort);
            Assert.Equal<sbyte>(sbyteValue, sbyteFromUShort);
            Assert.Equal<sbyte>(sbyteValue, sbyteFromInt);
            Assert.Equal<sbyte>(sbyteValue, sbyteFromUInt);
            Assert.Equal<sbyte>(sbyteValue, sbyteFromLong);
            Assert.Equal<sbyte>(sbyteValue, sbyteFromULong);
            Assert.Equal<sbyte>(sbyteValue, sbyteFromDouble);
            Assert.Equal<sbyte>(sbyteValue, sbyteFromFloat);
            Assert.Equal<sbyte>(sbyteValue, sbyteFromDecimal);
            Assert.Equal<sbyte>(sbyteValue, sbyteFromString);

            Log.Info("Casts to Short");

            short shortFromByte = dyn.Byte;
            short shortFromSByte = dyn.SByte;
            short shortFromShort = dyn.Int16;
            short shortFromUShort = dyn.UInt16;
            short shortFromInt = dyn.Int32;
            short shortFromUInt = dyn.UInt32;
            short shortFromLong = dyn.Int64;
            short shortFromULong = dyn.UInt64;
            short shortFromDouble = dyn.Double;
            short shortFromFloat = dyn.Single;
            short shortFromDecimal = dyn.Decimal;
            short shortFromString = dyn.String;

            Assert.Equal<short>(shortValue, shortFromByte);
            Assert.Equal<short>(shortValue, shortFromSByte);
            Assert.Equal<short>(shortValue, shortFromShort);
            Assert.Equal<short>(shortValue, shortFromUShort);
            Assert.Equal<short>(shortValue, shortFromInt);
            Assert.Equal<short>(shortValue, shortFromUInt);
            Assert.Equal<short>(shortValue, shortFromLong);
            Assert.Equal<short>(shortValue, shortFromULong);
            Assert.Equal<short>(shortValue, shortFromDouble);
            Assert.Equal<short>(shortValue, shortFromFloat);
            Assert.Equal<short>(shortValue, shortFromDecimal);
            Assert.Equal<short>(shortValue, shortFromString);

            Log.Info("Casts to UShort");

            ushort ushortFromByte = dyn.Byte;
            ushort ushortFromSByte = dyn.SByte;
            ushort ushortFromShort = dyn.Int16;
            ushort ushortFromUShort = dyn.UInt16;
            ushort ushortFromInt = dyn.Int32;
            ushort ushortFromUInt = dyn.UInt32;
            ushort ushortFromLong = dyn.Int64;
            ushort ushortFromULong = dyn.UInt64;
            ushort ushortFromDouble = dyn.Double;
            ushort ushortFromFloat = dyn.Single;
            ushort ushortFromDecimal = dyn.Decimal;
            ushort ushortFromString = dyn.String;

            Assert.Equal<ushort>(ushortValue, ushortFromByte);
            Assert.Equal<ushort>(ushortValue, ushortFromSByte);
            Assert.Equal<ushort>(ushortValue, ushortFromShort);
            Assert.Equal<ushort>(ushortValue, ushortFromUShort);
            Assert.Equal<ushort>(ushortValue, ushortFromInt);
            Assert.Equal<ushort>(ushortValue, ushortFromUInt);
            Assert.Equal<ushort>(ushortValue, ushortFromLong);
            Assert.Equal<ushort>(ushortValue, ushortFromULong);
            Assert.Equal<ushort>(ushortValue, ushortFromDouble);
            Assert.Equal<ushort>(ushortValue, ushortFromFloat);
            Assert.Equal<ushort>(ushortValue, ushortFromDecimal);
            Assert.Equal<ushort>(ushortValue, ushortFromString);

            Log.Info("Casts to Int");

            int intFromByte = dyn.Byte;
            int intFromSByte = dyn.SByte;
            int intFromShort = dyn.Int16;
            int intFromUShort = dyn.UInt16;
            int intFromInt = dyn.Int32;
            int intFromUInt = dyn.UInt32;
            int intFromLong = dyn.Int64;
            int intFromULong = dyn.UInt64;
            int intFromDouble = dyn.Double;
            int intFromFloat = dyn.Single;
            int intFromDecimal = dyn.Decimal;
            int intFromString = dyn.String;

            Assert.Equal<int>(intValue, intFromByte);
            Assert.Equal<int>(intValue, intFromSByte);
            Assert.Equal<int>(intValue, intFromShort);
            Assert.Equal<int>(intValue, intFromUShort);
            Assert.Equal<int>(intValue, intFromInt);
            Assert.Equal<int>(intValue, intFromUInt);
            Assert.Equal<int>(intValue, intFromLong);
            Assert.Equal<int>(intValue, intFromULong);
            Assert.Equal<int>(intValue, intFromDouble);
            Assert.Equal<int>(intValue, intFromFloat);
            Assert.Equal<int>(intValue, intFromDecimal);
            Assert.Equal<int>(intValue, intFromString);

            Log.Info("Casts to UInt");

            uint uintFromByte = dyn.Byte;
            uint uintFromSByte = dyn.SByte;
            uint uintFromShort = dyn.Int16;
            uint uintFromUShort = dyn.UInt16;
            uint uintFromInt = dyn.Int32;
            uint uintFromUInt = dyn.UInt32;
            uint uintFromLong = dyn.Int64;
            uint uintFromULong = dyn.UInt64;
            uint uintFromDouble = dyn.Double;
            uint uintFromFloat = dyn.Single;
            uint uintFromDecimal = dyn.Decimal;
            uint uintFromString = dyn.String;

            Assert.Equal<uint>(uintValue, uintFromByte);
            Assert.Equal<uint>(uintValue, uintFromSByte);
            Assert.Equal<uint>(uintValue, uintFromShort);
            Assert.Equal<uint>(uintValue, uintFromUShort);
            Assert.Equal<uint>(uintValue, uintFromInt);
            Assert.Equal<uint>(uintValue, uintFromUInt);
            Assert.Equal<uint>(uintValue, uintFromLong);
            Assert.Equal<uint>(uintValue, uintFromULong);
            Assert.Equal<uint>(uintValue, uintFromDouble);
            Assert.Equal<uint>(uintValue, uintFromFloat);
            Assert.Equal<uint>(uintValue, uintFromDecimal);
            Assert.Equal<uint>(uintValue, uintFromString);

            Log.Info("Casts to Long");

            long longFromByte = dyn.Byte;
            long longFromSByte = dyn.SByte;
            long longFromShort = dyn.Int16;
            long longFromUShort = dyn.UInt16;
            long longFromInt = dyn.Int32;
            long longFromUInt = dyn.UInt32;
            long longFromLong = dyn.Int64;
            long longFromULong = dyn.UInt64;
            long longFromDouble = dyn.Double;
            long longFromFloat = dyn.Single;
            long longFromDecimal = dyn.Decimal;
            long longFromString = dyn.String;

            Assert.Equal<long>(longValue, longFromByte);
            Assert.Equal<long>(longValue, longFromSByte);
            Assert.Equal<long>(longValue, longFromShort);
            Assert.Equal<long>(longValue, longFromUShort);
            Assert.Equal<long>(longValue, longFromInt);
            Assert.Equal<long>(longValue, longFromUInt);
            Assert.Equal<long>(longValue, longFromLong);
            Assert.Equal<long>(longValue, longFromULong);
            Assert.Equal<long>(longValue, longFromDouble);
            Assert.Equal<long>(longValue, longFromFloat);
            Assert.Equal<long>(longValue, longFromDecimal);
            Assert.Equal<long>(longValue, longFromString);

            Log.Info("Casts to ULong");

            ulong ulongFromByte = dyn.Byte;
            ulong ulongFromSByte = dyn.SByte;
            ulong ulongFromShort = dyn.Int16;
            ulong ulongFromUShort = dyn.UInt16;
            ulong ulongFromInt = dyn.Int32;
            ulong ulongFromUInt = dyn.UInt32;
            ulong ulongFromLong = dyn.Int64;
            ulong ulongFromULong = dyn.UInt64;
            ulong ulongFromDouble = dyn.Double;
            ulong ulongFromFloat = dyn.Single;
            ulong ulongFromDecimal = dyn.Decimal;
            ulong ulongFromString = dyn.String;

            Assert.Equal<ulong>(ulongValue, ulongFromByte);
            Assert.Equal<ulong>(ulongValue, ulongFromSByte);
            Assert.Equal<ulong>(ulongValue, ulongFromShort);
            Assert.Equal<ulong>(ulongValue, ulongFromUShort);
            Assert.Equal<ulong>(ulongValue, ulongFromInt);
            Assert.Equal<ulong>(ulongValue, ulongFromUInt);
            Assert.Equal<ulong>(ulongValue, ulongFromLong);
            Assert.Equal<ulong>(ulongValue, ulongFromULong);
            Assert.Equal<ulong>(ulongValue, ulongFromDouble);
            Assert.Equal<ulong>(ulongValue, ulongFromFloat);
            Assert.Equal<ulong>(ulongValue, ulongFromDecimal);
            Assert.Equal<ulong>(ulongValue, ulongFromString);

            Log.Info("Casts to Float");

            float floatFromByte = dyn.Byte;
            float floatFromSByte = dyn.SByte;
            float floatFromShort = dyn.Int16;
            float floatFromUShort = dyn.UInt16;
            float floatFromInt = dyn.Int32;
            float floatFromUInt = dyn.UInt32;
            float floatFromLong = dyn.Int64;
            float floatFromULong = dyn.UInt64;
            float floatFromDouble = dyn.Double;
            float floatFromFloat = dyn.Single;
            float floatFromDecimal = dyn.Decimal;
            float floatFromString = dyn.String;

            Assert.Equal<float>(floatValue, floatFromByte);
            Assert.Equal<float>(floatValue, floatFromSByte);
            Assert.Equal<float>(floatValue, floatFromShort);
            Assert.Equal<float>(floatValue, floatFromUShort);
            Assert.Equal<float>(floatValue, floatFromInt);
            Assert.Equal<float>(floatValue, floatFromUInt);
            Assert.Equal<float>(floatValue, floatFromLong);
            Assert.Equal<float>(floatValue, floatFromULong);
            Assert.Equal<float>(floatValue, floatFromDouble);
            Assert.Equal<float>(floatValue, floatFromFloat);
            Assert.Equal<float>(floatValue, floatFromDecimal);
            Assert.Equal<float>(floatValue, floatFromString);

            Log.Info("Casts to Double");

            double doubleFromByte = dyn.Byte;
            double doubleFromSByte = dyn.SByte;
            double doubleFromShort = dyn.Int16;
            double doubleFromUShort = dyn.UInt16;
            double doubleFromInt = dyn.Int32;
            double doubleFromUInt = dyn.UInt32;
            double doubleFromLong = dyn.Int64;
            double doubleFromULong = dyn.UInt64;
            double doubleFromDouble = dyn.Double;
            double doubleFromFloat = dyn.Single;
            double doubleFromDecimal = dyn.Decimal;
            double doubleFromString = dyn.String;

            Assert.Equal<double>(doubleValue, doubleFromByte);
            Assert.Equal<double>(doubleValue, doubleFromSByte);
            Assert.Equal<double>(doubleValue, doubleFromShort);
            Assert.Equal<double>(doubleValue, doubleFromUShort);
            Assert.Equal<double>(doubleValue, doubleFromInt);
            Assert.Equal<double>(doubleValue, doubleFromUInt);
            Assert.Equal<double>(doubleValue, doubleFromLong);
            Assert.Equal<double>(doubleValue, doubleFromULong);
            Assert.Equal<double>(doubleValue, doubleFromDouble);
            Assert.Equal<double>(doubleValue, doubleFromFloat);
            Assert.Equal<double>(doubleValue, doubleFromDecimal);
            Assert.Equal<double>(doubleValue, doubleFromString);

            Log.Info("Casts to Decimal");

            decimal decimalFromByte = dyn.Byte;
            decimal decimalFromSByte = dyn.SByte;
            decimal decimalFromShort = dyn.Int16;
            decimal decimalFromUShort = dyn.UInt16;
            decimal decimalFromInt = dyn.Int32;
            decimal decimalFromUInt = dyn.UInt32;
            decimal decimalFromLong = dyn.Int64;
            decimal decimalFromULong = dyn.UInt64;
            decimal decimalFromDouble = dyn.Double;
            decimal decimalFromFloat = dyn.Single;
            decimal decimalFromDecimal = dyn.Decimal;
            decimal decimalFromString = dyn.String;

            Assert.Equal<decimal>(decimalValue, decimalFromByte);
            Assert.Equal<decimal>(decimalValue, decimalFromSByte);
            Assert.Equal<decimal>(decimalValue, decimalFromShort);
            Assert.Equal<decimal>(decimalValue, decimalFromUShort);
            Assert.Equal<decimal>(decimalValue, decimalFromInt);
            Assert.Equal<decimal>(decimalValue, decimalFromUInt);
            Assert.Equal<decimal>(decimalValue, decimalFromLong);
            Assert.Equal<decimal>(decimalValue, decimalFromULong);
            Assert.Equal<decimal>(decimalValue, decimalFromDouble);
            Assert.Equal<decimal>(decimalValue, decimalFromFloat);
            Assert.Equal<decimal>(decimalValue, decimalFromDecimal);
            Assert.Equal<decimal>(decimalValue, decimalFromString);

            Log.Info("Casts to String");

            string stringFromByte = dyn.Byte;
            string stringFromSByte = dyn.SByte;
            string stringFromShort = dyn.Int16;
            string stringFromUShort = dyn.UInt16;
            string stringFromInt = dyn.Int32;
            string stringFromUInt = dyn.UInt32;
            string stringFromLong = dyn.Int64;
            string stringFromULong = dyn.UInt64;
            string stringFromDouble = dyn.Double;
            string stringFromFloat = dyn.Single;
            string stringFromDecimal = dyn.Decimal;
            string stringFromString = dyn.String;

            Assert.Equal(stringValue, stringFromByte);
            Assert.Equal(stringValue, stringFromSByte);
            Assert.Equal(stringValue, stringFromShort);
            Assert.Equal(stringValue, stringFromUShort);
            Assert.Equal(stringValue, stringFromInt);
            Assert.Equal(stringValue, stringFromUInt);
            Assert.Equal(stringValue, stringFromLong);
            Assert.Equal(stringValue, stringFromULong);
            Assert.Equal(stringValue, stringFromDouble);
            Assert.Equal(stringValue, stringFromFloat);
            Assert.Equal(stringValue, stringFromDecimal);
            Assert.Equal(stringValue, stringFromString);

            Log.Info("Casts to Boolean");

            bool bTrue = dyn.True;
            bool bFalse = dyn.False;
            Assert.True(bTrue);
            Assert.False(bFalse);
        }

        /// <summary>
        /// Test for creating a JsonValue from a deep-nested dynamic object.
        /// </summary>
        [Fact]
        public void CreateFromDeepNestedDynamic()
        {
            int count = 5000;
            string expected = "";

            dynamic dyn = new TestDynamicObject();
            dynamic cur = dyn;

            for (int i = 0; i < count; i++)
            {
                expected += "{\"" + i + "\":";
                cur[i.ToString()] = new TestDynamicObject();
                cur = cur[i.ToString()];
            }

            expected += "{}";

            for (int i = 0; i < count; i++)
            {
                expected += "}";
            }

            JsonValue jv = JsonValueExtensions.CreateFrom(dyn);
            Assert.Equal(expected, jv.ToString());
        }

        private void ValidateResult<ResultType>(dynamic value, ResultType expectedResult)
        {
            Assert.IsAssignableFrom(typeof(ResultType), value);
            Assert.Equal<ResultType>(expectedResult, (ResultType)value);
        }

        /// <summary>
        /// Concrete DynamicObject class for testing purposes.
        /// </summary>
        internal class TestDynamicObject : DynamicObject
        {
            private IDictionary<string, object> _values = new Dictionary<string, object>();

            public override IEnumerable<string> GetDynamicMemberNames()
            {
                return _values.Keys;
            }

            public override bool TrySetMember(SetMemberBinder binder, object value)
            {
                _values[binder.Name] = value;
                return true;
            }

            public override bool TryGetMember(GetMemberBinder binder, out object result)
            {
                return _values.TryGetValue(binder.Name, out result);
            }

            public override bool TrySetIndex(SetIndexBinder binder, object[] indexes, object value)
            {
                string key = indexes[0].ToString();

                if (_values.ContainsKey(key))
                {
                    _values[key] = value;
                }
                else
                {
                    _values.Add(key, value);
                }
                return true;
            }

            public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
            {
                string key = indexes[0].ToString();

                if (_values.ContainsKey(key))
                {
                    result = _values[key];