// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.

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

namespace System.Json
{
    /// <summary>
    /// JsonPrimitive unit tests
    /// </summary>
    public class JsonPrimitiveTests
    {
        const string DateTimeFormat = "yyyy-MM-ddTHH:mm:ss.fffK";

        /// <summary>
        /// Validates round-trip of <see cref="JsonPrimitive"/> values created from <see cref="Int16"/> values.
        /// </summary>
        [Fact]
        public void JsonPrimitiveFromInt16()
        {
            short[] values = new short[] { Int16.MinValue, Int16.MaxValue, 1 };
            for (int i = 0; i < values.Length; i++)
            {
                this.ValidateJson(new JsonPrimitive(values[i]), GetExpectedRepresentation(values[i]), JsonType.Number);
                this.TestReadAsRoundtrip<short>(new JsonPrimitive(values[i]), values[i]);
            }
        }

        /// <summary>
        /// Validates round-trip of <see cref="JsonPrimitive"/> values created from <see cref="Int32"/> values.
        /// </summary>
        [Fact]
        public void JsonPrimitiveFromInt32()
        {
            int[] values = new int[] { Int32.MinValue, Int32.MaxValue, 12345678 };
            for (int i = 0; i < values.Length; i++)
            {
                this.ValidateJson(new JsonPrimitive(values[i]), GetExpectedRepresentation(values[i]), JsonType.Number);
                this.TestReadAsRoundtrip<int>(new JsonPrimitive(values[i]), values[i]);
            }
        }

        /// <summary>
        /// Validates round-trip of <see cref="JsonPrimitive"/> values created from <see cref="Int64"/> values.
        /// </summary>
        [Fact]
        public void JsonPrimitiveFromInt64()
        {
            long[] values = new long[] { Int64.MinValue, Int64.MaxValue, 12345678901232L };
            for (int i = 0; i < values.Length; i++)
            {
                this.ValidateJson(new JsonPrimitive(values[i]), GetExpectedRepresentation(values[i]), JsonType.Number);
                this.TestReadAsRoundtrip<long>(new JsonPrimitive(values[i]), values[i]);
            }
        }

        /// <summary>
        /// Validates round-trip of <see cref="JsonPrimitive"/> values created from <see cref="UInt64"/> values.
        /// </summary>
        [Fact]
        public void JsonPrimitiveFromUInt64()
        {
            ulong[] values = new ulong[] { UInt64.MinValue, UInt64.MaxValue, 12345678901232L };
            for (int i = 0; i < values.Length; i++)
            {
                this.ValidateJson(new JsonPrimitive(values[i]), GetExpectedRepresentation(values[i]), JsonType.Number);
                this.TestReadAsRoundtrip<ulong>(new JsonPrimitive(values[i]), values[i]);
            }
        }

        /// <summary>
        /// Validates round-trip of <see cref="JsonPrimitive"/> values created from <see cref="UInt32"/> values.
        /// </summary>
        [Fact]
        public void JsonPrimitiveFromUInt32()
        {
            uint[] values = new uint[] { UInt32.MinValue, UInt32.MaxValue, 3234567890 };
            for (int i = 0; i < values.Length; i++)
            {
                this.ValidateJson(new JsonPrimitive(values[i]), GetExpectedRepresentation(values[i]), JsonType.Number);
                this.TestReadAsRoundtrip<uint>(new JsonPrimitive(values[i]), values[i]);
            }
        }

        /// <summary>
        /// Validates round-trip of <see cref="JsonPrimitive"/> values created from <see cref="UInt16"/> values.
        /// </summary>
        [Fact]
        public void JsonPrimitiveFromUInt16()
        {
            ushort[] values = new ushort[] { UInt16.MinValue, UInt16.MaxValue, 33333 };
            for (int i = 0; i < values.Length; i++)
            {
                this.ValidateJson(new JsonPrimitive(values[i]), GetExpectedRepresentation(values[i]), JsonType.Number);
                this.TestReadAsRoundtrip<ushort>(new JsonPrimitive(values[i]), values[i]);
            }
        }

        /// <summary>
        /// Validates round-trip of <see cref="JsonPrimitive"/> values created from <see cref="Byte"/> values.
        /// </summary>
        [Fact]
        public void JsonPrimitiveFromByte()
        {
            byte[] values = new byte[] { Byte.MinValue, Byte.MaxValue, 0x83 };
            for (int i = 0; i < values.Length; i++)
            {
                this.ValidateJson(new JsonPrimitive(values[i]), GetExpectedRepresentation(values[i]), JsonType.Number);
                this.TestReadAsRoundtrip<byte>(new JsonPrimitive(values[i]), values[i]);
            }
        }

        /// <summary>
        /// Validates round-trip of <see cref="JsonPrimitive"/> values created from <see cref="SByte"/> values.
        /// </summary>
        [Fact]
        public void JsonPrimitiveFromSByte()
        {
            sbyte[] values = new sbyte[] { SByte.MinValue, SByte.MaxValue, -0x33 };
            for (int i = 0; i < values.Length; i++)
            {
                this.ValidateJson(new JsonPrimitive(values[i]), GetExpectedRepresentation(values[i]), JsonType.Number);
                this.TestReadAsRoundtrip<sbyte>(new JsonPrimitive(values[i]), values[i]);
            }
        }

        /// <summary>
        /// Validates round-trip of <see cref="JsonPrimitive"/> values created from <see cref="Single"/> values.
        /// </summary>
        [Fact]
        public void JsonPrimitiveFromFloat()
        {
            float[] values = new float[] { float.MinValue, float.MaxValue, 1.234f, float.PositiveInfinity, float.NegativeInfinity, float.NaN };
            for (int i = 0; i < values.Length; i++)
            {
                this.ValidateJson(new JsonPrimitive(values[i]), GetExpectedRepresentation(values[i]), JsonType.Number);
                this.TestReadAsRoundtrip<float>(new JsonPrimitive(values[i]), values[i]);
            }
        }

        /// <summary>
        /// Validates round-trip of <see cref="JsonPrimitive"/> values created from <see cref="Double"/> values.
        /// </summary>
        [Fact]
        public void JsonPrimitiveFromDouble()
        {
            double[] values = new double[] { double.MinValue, double.MaxValue, 1.234, double.PositiveInfinity, double.NegativeInfinity, double.NaN };
            for (int i = 0; i < values.Length; i++)
            {
                this.ValidateJson(new JsonPrimitive(values[i]), GetExpectedRepresentation(values[i]), JsonType.Number);
                this.TestReadAsRoundtrip<double>(new JsonPrimitive(values[i]), values[i]);
            }
        }

        /// <summary>
        /// Validates round-trip of <see cref="JsonPrimitive"/> values created from <see cref="Decimal"/> values.
        /// </summary>
        [Fact]
        public void JsonPrimitiveFromDecimal()
        {
            decimal[] values = new decimal[] { decimal.MinValue, decimal.MaxValue, 123456789.123456789m };
            for (int i = 0; i < values.Length; i++)
            {
                this.ValidateJson(new JsonPrimitive(values[i]), GetExpectedRepresentation(values[i]), JsonType.Number);
                this.TestReadAsRoundtrip<decimal>(new JsonPrimitive(values[i]), values[i]);
            }
        }

        /// <summary>
        /// Validates round-trip of <see cref="JsonPrimitive"/> values created from <see cref="Boolean"/> values.
        /// </summary>
        [Fact]
        public void JsonPrimitiveFromBoolean()
        {
            bool[] values = new bool[] { true, false };
            for (int i = 0; i < values.Length; i++)
            {
                this.ValidateJson(new JsonPrimitive(values[i]), GetExpectedRepresentation(values[i]), JsonType.Boolean);
                this.TestReadAsRoundtrip<bool>(new JsonPrimitive(values[i]), values[i]);
            }
        }

        /// <summary>
        /// Validates round-trip of <see cref="JsonPrimitive"/> values created from <see cref="Char"/> values.
        /// </summary>
        [Fact]
        public void JsonPrimitiveFromChar()
        {
            char[] values = new char[] { 'H', '\0', '\uffff' };
            for (int i = 0; i < values.Length; i++)
            {
                this.ValidateJson(new JsonPrimitive(values[i]), GetExpectedRepresentation(values[i]), JsonType.String);
                this.TestReadAsRoundtrip<char>(new JsonPrimitive(values[i]), values[i]);
            }
        }

        /// <summary>
        /// Validates round-trip of <see cref="JsonPrimitive"/> values created from <see cref="String"/> values.
        /// </summary>
        [Fact]
        public void JsonPrimitiveFromString()
        {
            string[] values = new string[] { "Hello", "abcdef", "\r\t123\n32" };
            for (int i = 0; i < values.Length; i++)
            {
                this.ValidateJson(new JsonPrimitive(values[i]), GetExpectedRepresentation(values[i]), JsonType.String);
                this.TestReadAsRoundtrip<string>(new JsonPrimitive(values[i]), values[i]);
            }
        }

        /// <summary>
        /// Validates round-trip of <see cref="JsonPrimitive"/> values created from <see cref="DateTime"/> values.
        /// </summary>
        [Fact]
        public void JsonPrimitiveFromDateTime()
        {
            DateTime[] values = new DateTime[]
            {
                new DateTime(2000, 10, 16, 8, 0, 0, DateTimeKind.Utc),
                new DateTime(2000, 10, 16, 8, 0, 0, DateTimeKind.Local),
            };
            for (int i = 0; i < values.Length; i++)
            {
                this.ValidateJson(new JsonPrimitive(values[i]), GetExpectedRepresentation(values[i]), JsonType.String);
                this.TestReadAsRoundtrip<DateTime>(new JsonPrimitive(values[i]), values[i]);
            }
        }

        /// <summary>
        /// Validates round-trip of <see cref="JsonPrimitive"/> values created from <see cref="Uri"/> values.
        /// </summary>
        [Fact]
        public void JsonPrimitiveFromUri()
        {
            Uri[] values = new Uri[] { new Uri("http://tempuri.org"), new Uri("foo/bar", UriKind.Relative) };
            for (int i = 0; i < values.Length; i++)
            {
                this.ValidateJson(new JsonPrimitive(values[i]), GetExpectedRepresentation(values[i]), JsonType.String);
                this.TestReadAsRoundtrip<Uri>(new JsonPrimitive(values[i]), values[i]);
            }
        }

        /// <summary>
        /// Validates round-trip of <see cref="JsonPrimitive"/> values created from <see cref="Guid"/> values.
        /// </summary>
        [Fact]
        public void JsonPrimitiveFromGuid()
        {
            Guid[] values = new Guid[] { Guid.NewGuid(), Guid.Empty, Guid.NewGuid() };
            for (int i = 0; i < values.Length; i++)
            {
                this.ValidateJson(new JsonPrimitive(values[i]), GetExpectedRepresentation(values[i]), JsonType.String);
                this.TestReadAsRoundtrip<Guid>(new JsonPrimitive(values[i]), values[i]);
            }
        }

        /// <summary>
        /// Validates round-trip of <see cref="JsonPrimitive"/> values created from different types of values.
        /// </summary>
        [Fact]
        public void JsonPrimitiveFromObject()
        {
            List<KeyValuePair<object, JsonType>> values = new List<KeyValuePair<object, JsonType>>
            {
                new KeyValuePair<object, JsonType>(true, JsonType.Boolean),
                new KeyValuePair<object, JsonType>((short)1, JsonType.Number),
                new KeyValuePair<object, JsonType>(234, JsonType.Number),
                new KeyValuePair<object, JsonType>(3435434233443L, JsonType.Number),
                new KeyValuePair<object, JsonType>(UInt64.MaxValue, JsonType.Number),
                new KeyValuePair<object, JsonType>(UInt32.MaxValue, JsonType.Number),
                new KeyValuePair<object, JsonType>(UInt16.MaxValue, JsonType.Number),
                new KeyValuePair<object, JsonType>(Byte.MaxValue, JsonType.Number),
                new KeyValuePair<object, JsonType>(SByte.MinValue, JsonType.Number),
                new KeyValuePair<object, JsonType>(double.MaxValue, JsonType.Number),
                new KeyValuePair<object, JsonType>(float.Epsilon, JsonType.Number),
                new KeyValuePair<object, JsonType>(decimal.MinusOne, JsonType.Number),
                new KeyValuePair<object, JsonType>("hello", JsonType.String),
                new KeyValuePair<object, JsonType>(Guid.NewGuid(), JsonType.String),
                new KeyValuePair<object, JsonType>(DateTime.UtcNow, JsonType.String),
                new KeyValuePair<object, JsonType>(new Uri("http://www.microsoft.com"), JsonType.String),
            };

            foreach (var value in values)
            {
                string json = GetExpectedRepresentation(value.Key);
                JsonValue jsonValue = JsonValue.Parse(json);
                Assert.IsType(typeof(JsonPrimitive), jsonValue);
                this.ValidateJson((JsonPrimitive)jsonValue, json, value.Value);
            }
        }

        /// <summary>
        /// Negative tests for <see cref="JsonPrimitive"/> constructors with null values.
        /// </summary>
        [Fact]
        public void NullChecks()
        {
            ExpectException<ArgumentNullException>(() => new JsonPrimitive((string)null));
            ExpectException<ArgumentNullException>(() => new JsonPrimitive((Uri)null));
        }

        /// <summary>
        /// Tests for casting string values into non-string values.
        /// </summary>
        [Fact]
        public void CastingFromStringTests()
        {
            int seed = MethodBase.GetCurrentMethod().Name.GetHashCode();
            Random rndGen = new Random(seed);

            Assert.Equal(false, (bool)(new JsonPrimitive("false")));
            Assert.Equal(false, (bool)(new JsonPrimitive("False")));
            Assert.Equal(true, (bool)(new JsonPrimitive("true")));
            Assert.Equal(true, (bool)(new JsonPrimitive("True")));

            byte b = PrimitiveCreator.CreateInstanceOfByte(rndGen);
            Assert.Equal(b, (byte)(new JsonPrimitive(b.ToString(CultureInfo.InvariantCulture))));

            decimal dec = PrimitiveCreator.CreateInstanceOfDecimal(rndGen);
            Assert.Equal(dec, (decimal)(new JsonPrimitive(dec.ToString(CultureInfo.InvariantCulture))));

            double dbl = rndGen.NextDouble() * rndGen.Next();
            Assert.Equal(dbl, (double)(new JsonPrimitive(dbl.ToString("R", CultureInfo.InvariantCulture))));

            Assert.Equal(Double.PositiveInfinity, (double)(new JsonPrimitive("Infinity")));
            Assert.Equal(Double.NegativeInfinity, (double)(new JsonPrimitive("-Infinity")));
            Assert.Equal(Double.NaN, (double)(new JsonPrimitive("NaN")));

            ExpectException<InvalidCastException>(delegate { var d = (double)(new JsonPrimitive("INF")); });
            ExpectException<InvalidCastException>(delegate { var d = (double)(new JsonPrimitive("-INF")); });
            ExpectException<InvalidCastException>(delegate { var d = (double)(new JsonPrimitive("infinity")); });
            ExpectException<InvalidCastException>(delegate { var d = (double)(new JsonPrimitive("INFINITY")); });
            ExpectException<InvalidCastException>(delegate { var d = (double)(new JsonPrimitive("nan")); });
            ExpectException<InvalidCastException>(delegate { var d = (double)(new JsonPrimitive("Nan")); });

            float flt = (float)(rndGen.NextDouble() * rndGen.Next());
            Assert.Equal(flt, (float)(new JsonPrimitive(flt.ToString("R", CultureInfo.InvariantCulture))));

            Assert.Equal(Single.PositiveInfinity, (float)(new JsonPrimitive("Infinity")));
            Assert.Equal(Single.NegativeInfinity, (float)(new JsonPrimitive("-Infinity")));
            Assert.Equal(Single.NaN, (float)(new JsonPrimitive("NaN")));

            ExpectException<InvalidCastException>(delegate { var f = (float)(new JsonPrimitive("INF")); });
            ExpectException<InvalidCastException>(delegate { var f = (float)(new JsonPrimitive("-INF")); });
            ExpectException<InvalidCastException>(delegate { var f = (float)(new JsonPrimitive("infinity")); });
            ExpectException<InvalidCastException>(delegate { var f = (float)(new JsonPrimitive("INFINITY")); });
            ExpectException<InvalidCastException>(delegate { var f = (float)(new JsonPrimitive("nan")); });
            ExpectException<InvalidCastException>(delegate { var f = (float)(new JsonPrimitive("Nan")); });

            int i = PrimitiveCreator.CreateInstanceOfInt32(rndGen);
            Assert.Equal(i, (int)(new JsonPrimitive(i.ToString(CultureInfo.InvariantCulture))));

            long l = PrimitiveCreator.CreateInstanceOfInt64(rndGen);
            Assert.Equal(l, (long)(new JsonPrimitive(l.ToString(CultureInfo.InvariantCulture))));

            sbyte sb = PrimitiveCreator.CreateInstanceOfSByte(rndGen);
            Assert.Equal(sb, (sbyte)(new JsonPrimitive(sb.ToString(CultureInfo.InvariantCulture))));

            short s = PrimitiveCreator.CreateInstanceOfInt16(rndGen);
            Assert.Equal(s, (short)(new JsonPrimitive(s.ToString(CultureInfo.InvariantCulture))));

            ushort ui16 = PrimitiveCreator.CreateInstanceOfUInt16(rndGen);
            Assert.Equal(ui16, (ushort)(new JsonPrimitive(ui16.ToString(CultureInfo.InvariantCulture))));

            uint ui32 = PrimitiveCreator.CreateInstanceOfUInt32(rndGen);
            Assert.Equal(ui32, (uint)(new JsonPrimitive(ui32.ToString(CultureInfo.InvariantCulture))));

            ulong ui64 = PrimitiveCreator.CreateInstanceOfUInt64(rndGen);
            Assert.Equal(ui64, (ulong)(new JsonPrimitive(ui64.ToString(CultureInfo.InvariantCulture))));
        }

        /// <summary>
        /// Tests for casting <see cref="JsonPrimitive"/> created from special floating point values (infinity, NaN).
        /// </summary>
        [Fact]
        public void CastingNumbersTest()
        {
            Assert.Equal(float.PositiveInfinity, (float)(new JsonPrimitive(double.PositiveInfinity)));
            Assert.Equal(float.NegativeInfinity, (float)(new JsonPrimitive(double.NegativeInfinity)));
            Assert.Equal(float.NaN, (float)(new JsonPrimitive(double.NaN)));

            Assert.Equal(double.PositiveInfinity, (double)(new JsonPrimitive(float.PositiveInfinity)));
            Assert.Equal(double.NegativeInfinity, (double)(new JsonPrimitive(float.NegativeInfinity)));
            Assert.Equal(double.NaN, (double)(new JsonPrimitive(float.NaN)));
        }

        /// <summary>
        /// Tests for the many formats which can be cast to a <see cref="DateTime"/>.
        /// </summary>
        [Fact]
        public void CastingDateTimeTest()
        {
            int seed = MethodBase.GetCurrentMethod().Name.GetHashCode();
            Random rndGen = new Random(seed);
            DateTime dt = new DateTime(
                rndGen.Next(1000, 3000), // year
                rndGen.Next(1, 13), // month
                rndGen.Next(1, 28), // day
                rndGen.Next(0, 24), // hour
                rndGen.Next(0, 60), // minute
                rndGen.Next(0, 60), // second
                DateTimeKind.Utc);
            Log.Info("dt = {0}", dt);

            const string JsonDateFormat = "yyyy-MM-ddTHH:mm:ssZ";
            string dateString = dt.ToString(JsonDateFormat, CultureInfo.InvariantCulture);
            JsonValue jv = dateString;
            DateTime dt2 = (DateTime)jv;
            Assert.Equal(dt.ToUniversalTime(), dt2.ToUniversalTime());

            const string DateTimeLocalFormat = "yyyy-MM-ddTHH:mm:ss";
            const string DateLocalFormat = "yyyy-MM-dd";
            const string TimeLocalFormat = "HH:mm:ss";

            for (int i = 0; i < 100; i++)
            {
                DateTime dateLocal = PrimitiveCreator.CreateInstanceOfDateTime(rndGen).ToLocalTime();
                dateLocal = new DateTime(dateLocal.Year, dateLocal.Month, dateLocal.Day, dateLocal.Hour, dateLocal.Minute, dateLocal.Second, DateTimeKind.Local);
                string localDateTime = dateLocal.ToString(DateTimeLocalFormat, CultureInfo.InvariantCulture);
                string localDate = dateLocal.ToString(DateLocalFormat, CultureInfo.InvariantCulture);
                string localTime = dateLocal.ToString(TimeLocalFormat, CultureInfo.InvariantCulture);

                Assert.Equal(dateLocal, new JsonPrimitive(localDateTime).ReadAs<DateTime>());
                Assert.Equal(dateLocal.Date, new JsonPrimitive(localDate).ReadAs<DateTime>());
                DateTime timeOnly = new JsonPrimitive(localTime).ReadAs<DateTime>();
                Assert.Equal(dateLocal.Hour, timeOnly.Hour);
                Assert.Equal(dateLocal.Minute, timeOnly.Minute);
                Assert.Equal(dateLocal.Second, timeOnly.Second);

                DataContractJsonSerializer dcjs = new DataContractJsonSerializer(typeof(DateTime));
                using (MemoryStream ms = new MemoryStream())
                {
                    dcjs.WriteObject(ms, dateLocal);
                    ms.Position = 0;
                    JsonValue jvFromString = JsonValue.Load(ms);
                    Assert.Equal(dateLocal, jvFromString.ReadAs<DateTime>());
                }

                using (MemoryStream ms = new MemoryStream())
                {
                    DateTime dateUtc = dateLocal.ToUniversalTime();
                    dcjs.WriteObject(ms, dateUtc);
                    ms.Position = 0;
                    JsonValue jvFromString = JsonValue.Load(ms);
                    Assert.Equal(dateUtc, jvFromString.ReadAs<DateTime>());
                }
            }
        }

        /// <summary>
        /// Tests for date parsing form the RFC2822 format.
        /// </summary>
        [Fact]
        public void Rfc2822DateTimeFormatTest()
        {
            string[] localFormats = new string[]
            {
                "ddd, d MMM yyyy HH:mm:ss zzz",
                "d MMM yyyy HH:mm:ss zzz",
                "ddd, dd MMM yyyy HH:mm:ss zzz",
                "ddd, dd MMM yyyy HH:mm zzz",
            };

            string[] utcFormats = new string[]
            {
                @"ddd, d MMM yyyy HH:mm:ss \U\T\C",
                "d MMM yyyy HH:mm:ssZ",
                @"ddd, dd MMM yyyy HH:mm:ss \U\T\C",
                "ddd, dd MMM yyyy HH:mmZ",
            };

            DateTime today = DateTime.Today;
            int seed = today.Year * 10000 + today.Month * 100 + today.Day;
            Log.Info("Seed: {0}", seed);
            Random rndGen = new Random(seed);
            const int DatesToTry = 100;
            const string DateTraceFormat = "ddd yyyy/MM/dd HH:mm:ss.fffZ";

            for (int i = 0; i < DatesToTry; i++)
            {
                DateTime dt = PrimitiveCreator.CreateInstanceOfDateTime(rndGen);
                dt = new DateTime(dt.Year, dt.Month, dt.Day, dt.Hour, dt.Minute, dt.Second, dt.Kind);
                Log.Info("Test with date: {0} ({1})", dt.ToString(DateTraceFormat, CultureInfo.InvariantCulture), dt.Kind);
                string[] formatsToTest = dt.Kind == DateTimeKind.Utc ? utcFormats : localFormats;
                foreach (string format in formatsToTest)
                {
                    string strDate = dt.ToString(format, CultureInfo.InvariantCulture);
                    Log.Info("As string: {0} (format = {1})", strDate, format);
                    JsonPrimitive jp = new JsonPrimitive(strDate);
                    DateTime parsedDate = jp.ReadAs<DateTime>();
                    Log.Info("Parsed date: {0} ({1})", parsedDate.ToString(DateTraceFormat, CultureInfo.InvariantCulture), parsedDate.Kind);

                    DateTime dtExpected = dt;
                    DateTime dtActual = parsedDate;

                    if (dt.Kind != parsedDate.Kind)
                    {
                        dtExpected = dtExpected.ToUniversalTime();
                        dtActual = dtActual.ToUniversalTime();
                    }

                    Assert.Equal(dtExpected.Year, dtActual.Year);
                    Assert.Equal(dtExpected.Month, dtActual.Month);
                    Assert.Equal(dtExpected.Day, dtActual.Day);
                    Assert.Equal(dtExpected.Hour, dtActual.Hour);
                    Assert.Equal(dtExpected.Minute, dtActual.Minute);
                    if (format.Contains(":ss"))
                    {
                        Assert.Equal(dtExpected.Second, dtActual.Second);
                    }
                    else
                    {
                        Assert.Equal(0, parsedDate.Second);
                    }
                }

                Log.Info("");
            }
        }

        /// <summary>
        /// Tests for the <see cref="System.Json.JsonValue.ReadAs{T}()"/> function from string values.
        /// </summary>
        [Fact]
        public void ReadAsFromStringTests()
        {
            int seed = MethodBase.GetCurrentMethod().Name.GetHashCode();
            Random rndGen = new Random(seed);

            TestReadAsFromStringRoundtrip<bool>(false, "false");
            TestReadAsFromStringRoundtrip<bool>(false, "False");
            TestReadAsFromStringRoundtrip<bool>(true, "true");
            TestReadAsFromStringRoundtrip<bool>(true, "True");
            TestReadAsFromStringRoundtrip<byte>(PrimitiveCreator.CreateInstanceOfByte(rndGen));
            TestReadAsFromStringRoundtrip<char>(PrimitiveCreator.CreateInstanceOfChar(rndGen));
            TestReadAsFromStringRoundtrip<decimal>(PrimitiveCreator.CreateInstanceOfDecimal(rndGen));
            TestReadAsFromStringRoundtrip<int>(PrimitiveCreator.CreateInstanceOfInt32(rndGen));
            TestReadAsFromStringRoundtrip<long>(PrimitiveCreator.CreateInstanceOfInt64(rndGen));
            TestReadAsFromStringRoundtrip<sbyte>(PrimitiveCreator.CreateInstanceOfSByte(rndGen));
            TestReadAsFromStringRoundtrip<short>(PrimitiveCreator.CreateInstanceOfInt16(rndGen));
            TestReadAsFromStringRoundtrip<ushort>(PrimitiveCreator.CreateInstanceOfUInt16(rndGen));
            TestReadAsFromStringRoundtrip<uint>(PrimitiveCreator.CreateInstanceOfUInt32(rndGen));
            TestReadAsFromStringRoundtrip<ulong>(PrimitiveCreator.CreateInstanceOfUInt64(rndGen));
            double dbl = rndGen.NextDouble() * rndGen.Next();
            TestReadAsFromStringRoundtrip<double>(dbl, dbl.ToString("R", CultureInfo.InvariantCulture));
            TestReadAsFromStringRoundtrip<double>(double.PositiveInfinity, "Infinity");
            TestReadAsFromStringRoundtrip<double>(double.NegativeInfinity, "-Infinity");
            TestReadAsFromStringRoundtrip<double>(double.NaN, "NaN");
            float flt = (float)(rndGen.NextDouble() * rndGen.Next());
            TestReadAsFromStringRoundtrip<float>(flt, flt.ToString("R", CultureInfo.InvariantCulture));
            TestReadAsFromStringRoundtrip<float>(float.PositiveInfinity, "Infinity");
            TestReadAsFromStringRoundtrip<float>(float.NegativeInfinity, "-Infinity");
            TestReadAsFromStringRoundtrip<float>(float.NaN, "NaN");
            Guid guid = PrimitiveCreator.CreateInstanceOfGuid(rndGen);
            TestReadAsFromStringRoundtrip<Guid>(guid, guid.ToString("N", CultureInfo.InvariantCulture));
            TestReadAsFromStringRoundtrip<Guid>(guid, guid.ToString("D", CultureInfo.InvariantCulture));
            TestReadAsFromStringRoundtrip<Guid>(guid, guid.ToString("B", CultureInfo.InvariantCulture));
            TestReadAsFromStringRoundtrip<Guid>(guid, guid.ToString("P", CultureInfo.InvariantCulture));
            TestReadAsFromStringRoundtrip<Guid>(guid, guid.ToString("X", CultureInfo.InvariantCulture));
            TestReadAsFromStringRoundtrip<Guid>(guid, guid.ToString("X", CultureInfo.InvariantCulture).Replace("0x", "0X"));
            TestReadAsFromStringRoundtrip<Guid>(guid, guid.ToString("X", CultureInfo.InvariantCulture).Replace("{", " { "));
            TestReadAsFromStringRoundtrip<Guid>(guid, guid.ToString("X", CultureInfo.InvariantCulture).Replace("}", " } "));
            TestReadAsFromStringRoundtrip<Guid>(guid, guid.ToString("X", CultureInfo.InvariantCulture).Replace(",", "  ,    "));
            TestReadAsFromStringRoundtrip<Guid>(guid, guid.ToString("X", CultureInfo.InvariantCulture).Replace("0x", "0x0000"));
            Uri uri = null;
            do
            {
                try
                {
                    uri = PrimitiveCreator.CreateInstanceOfUri(rndGen);
                }
                catch (UriFormatException)
                {
                }
            } while (uri == null);

            TestReadAsFromStringRoundtrip<Uri>(uri);
            TestReadAsFromStringRoundtrip<string>(PrimitiveCreator.CreateInstanceOfString(rndGen));

            // Roundtrip reference DateTime to remove some of the precision in the ticks. Otherwise, value is too precise.
            DateTimeOffset dateTimeOffset = PrimitiveCreator.CreateInstanceOfDateTimeOffset(rndGen);
            const string ISO8601Format = "yyyy-MM-ddTHH:mm:sszzz";
            dateTimeOffset = DateTimeOffset.ParseExact(dateTimeOffset.ToString(ISO8601Format, CultureInfo.InvariantCulture), ISO8601Format, CultureInfo.InvariantCulture);
            DateTime dateTime = dateTimeOffset.UtcDateTime;
            TestReadAsFromStringRoundtrip<DateTime>(dateTime, dateTimeOffset.ToUniversalTime().ToString(@"ddd, d MMM yyyy HH:mm:ss \U\T\C"));
            TestReadAsFromStringRoundtrip<DateTime>(dateTime, dateTimeOffset.ToUniversalTime().ToString(@"ddd, d MMM yyyy HH:mm:ss \G\M\T"));
            TestReadAsFromStringRoundtrip<DateTime>(dateTime.ToLocalTime(), dateTimeOffset.ToString(@"ddd, d MMM yyyy HH:mm:ss zzz"));
            TestReadAsFromStringRoundtrip<DateTime>(dateTime, dateTime.ToString("yyyy-MM-ddTHH:mm:ssK"));
            TestReadAsFromStringRoundtrip<DateTime>(dateTime.ToLocalTime(), dateTimeOffset.ToString(@"ddd, d MMM yyyy HH:mm:ss zzz"));
            TestReadAsFromStringRoundtrip<DateTime>(dateTime.ToLocalTime(), dateTimeOffset.ToString("yyyy-MM-ddTHH:mm:sszzz"));
            TestReadAsFromStringRoundtrip<DateTimeOffset>(dateTimeOffset.UtcDateTime, dateTimeOffset.ToUniversalTime().ToString(@"ddd, d MMM yyyy HH:mm:ss \U\T\C"));
            TestReadAsFromStringRoundtrip<DateTimeOffset>(dateTimeOffset.UtcDateTime, dateTimeOffset.ToUniversalTime().ToString(@"ddd, d MMM yyyy HH:mm:ss \G\M\T"));
            TestReadAsFromStringRoundtrip<DateTimeOffset>(dateTimeOffset, dateTimeOffset.ToUniversalTime().ToString(@"ddd, d MMM yyyy HH:mm:ss zzz"));
            TestReadAsFromStringRoundtrip<DateTimeOffset>(dateTimeOffset, dateTime.ToString("yyyy-MM-ddTHH:mm:ssK"));
            TestReadAsFromStringRoundtrip<DateTimeOffset>(dateTimeOffset, dateTimeOffset.ToString("yyyy-MM-ddTHH:mm:sszzz"));
            TestReadAsFromStringRoundtrip<DateTimeOffset>(dateTimeOffset, dateTimeOffset.ToString(@"ddd, d MMM yyyy HH:mm:ss zzz"));

            // Create ASPNetFormat DateTime
            long unixEpochMilliseconds = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).Ticks / 10000;
            long millisecondsFromUnixEpoch = dateTime.Ticks / 10000 - unixEpochMilliseconds;
            string AspNetFormattedDateTime = String.Format("/Date({0})/", millisecondsFromUnixEpoch);
            string AspNetFormattedDateTimeWithValidTZ = String.Format("/Date({0}+0700)/", millisecondsFromUnixEpoch);
            string AspNetFormattedDateTimeInvalid1 = String.Format("/Date({0}+99999)/", millisecondsFromUnixEpoch);
            string AspNetFormattedDateTimeInvalid2 = String.Format("/Date({0}+07z0)/", millisecondsFromUnixEpoch);
            TestReadAsFromStringRoundtrip<DateTime>(dateTime, AspNetFormattedDateTime);
            TestReadAsFromStringRoundtrip<DateTime>(dateTime.ToLocalTime(), AspNetFormattedDateTimeWithValidTZ);
            TestReadAsFromStringRoundtrip<DateTimeOffset>(dateTimeOffset, AspNetFormattedDateTime);
            TestReadAsFromStringRoundtrip<DateTimeOffset>(dateTimeOffset, AspNetFormattedDateTimeWithValidTZ);

            ExpectException<FormatException>(delegate { new JsonPrimitive(AspNetFormattedDateTimeInvalid1).ReadAs<DateTime>(); });
            ExpectException<FormatException>(delegate { new JsonPrimitive(AspNetFormattedDateTimeInvalid2).ReadAs<DateTime>(); });
            ExpectException<FormatException>(delegate { new JsonPrimitive(AspNetFormattedDateTimeInvalid1).ReadAs<DateTimeOffset>(); });
            ExpectException<FormatException>(delegate { new JsonPrimitive(AspNetFormattedDateTimeInvalid2).ReadAs<DateTimeOffset>(); });

            ExpectException<FormatException>(delegate { new JsonPrimitive("INF").ReadAs<float>(); });
            ExpectException<FormatException>(delegate { new JsonPrimitive("-INF").ReadAs<float>(); });
            ExpectException<FormatException>(delegate { new JsonPrimitive("infinity").ReadAs<float>(); });
            ExpectException<FormatException>(delegate { new JsonPrimitive("INFINITY").ReadAs<float>(); });
            ExpectException<FormatException>(delegate { new JsonPrimitive("nan").ReadAs<float>(); });
            ExpectException<FormatException>(delegate { new JsonPrimitive("Nan").ReadAs<float>(); });

            ExpectException<FormatException>(delegate { new JsonPrimitive("INF").ReadAs<double>(); });
            ExpectException<FormatException>(delegate { new JsonPrimitive("-INF").ReadAs<double>(); });
            ExpectException<FormatException>(delegate { new JsonPrimitive("infinity").ReadAs<double>(); });
            ExpectException<FormatException>(delegate { new JsonPrimitive("INFINITY").ReadAs<double>(); });
            ExpectException<FormatException>(delegate { new JsonPrimitive("nan").ReadAs<double>(); });
            ExpectException<FormatException>(delegate { new JsonPrimitive("Nan").ReadAs<double>(); });
        }

        /// <summary>
        /// Tests for the <see cref="System.Json.JsonValue.ReadAs{T}()">JsonValue.ReadAs&lt;string&gt;</see> method from number values.
        /// </summary>
        [Fact]
        public void TestReadAsStringFromNumbers()
        {
            int seed = MethodBase.GetCurrentMethod().Name.GetHashCode();
            Random rndGen = new Random(seed);

            int intValue = PrimitiveCreator.CreateInstanceOfInt32(rndGen);
            JsonValue jv = intValue;
            Assert.Equal(intValue.ToString(CultureInfo.InvariantCulture), jv.ToString());
            Assert.Equal(intValue.ToString(CultureInfo.InvariantCulture), jv.ReadAs<string>());

            uint uintValue = PrimitiveCreator.CreateInstanceOfUInt32(rndGen);
            jv = uintValue;
            Assert.Equal(uintValue.ToString(CultureInfo.InvariantCulture), jv.ToString());
            Assert.Equal(uintValue.ToString(CultureInfo.InvariantCulture), jv.ReadAs<string>());

            long longValue = PrimitiveCreator.CreateInstanceOfInt64(rndGen);
            jv = longValue;
            Assert.Equal(longValue.ToString(CultureInfo.InvariantCulture), jv.ToString());
            Assert.Equal(longValue.ToString(CultureInfo.InvariantCulture), jv.ReadAs<string>());

            ulong ulongValue = PrimitiveCreator.CreateInstanceOfUInt64(rndGen);
            jv = ulongValue;
            Assert.Equal(ulongValue.ToString(CultureInfo.InvariantCulture), jv.ToString());
            Assert.Equal(ulongValue.ToString(CultureInfo.InvariantCulture), jv.ReadAs<string>());

            short shortValue = PrimitiveCreator.CreateInstanceOfInt16(rndGen);
            jv = shortValue;
            Assert.Equal(shortValue.ToString(CultureInfo.InvariantCulture), jv.ToString());
            Assert.Equal(shortValue.ToString(CultureInfo.InvariantCulture), jv.ReadAs<string>());

            ushort ushortValue = PrimitiveCreator.CreateInstanceOfUInt16(rndGen);
            jv = ushortValue;
            Assert.Equal(ushortValue.ToString(CultureInfo.InvariantCulture), jv.ToString());
            Assert.Equal(ushortValue.ToString(CultureInfo.InvariantCulture), jv.ReadAs<string>());

            byte byteValue = PrimitiveCreator.CreateInstanceOfByte(rndGen);
            jv = byteValue;
            Assert.Equal(byteValue.ToString(CultureInfo.InvariantCulture), jv.ToString());
            Assert.Equal(byteValue.ToString(CultureInfo.InvariantCulture), jv.ReadAs<string>());

            sbyte sbyteValue = PrimitiveCreator.CreateInstanceOfSByte(rndGen);
            jv = sbyteValue;
            Assert.Equal(sbyteValue.ToString(CultureInfo.InvariantCulture), jv.ToString());
            Assert.Equal(sbyteValue.ToString(CultureInfo.InvariantCulture), jv.ReadAs<string>());

            decimal decValue = PrimitiveCreator.CreateInstanceOfDecimal(rndGen);
            jv = decValue;
            Assert.Equal(decValue.ToString(CultureInfo.InvariantCulture), jv.ToString());
            Assert.Equal(decValue.ToString(CultureInfo.InvariantCulture), jv.ReadAs<string>());

            float fltValue = PrimitiveCreator.CreateInstanceOfSingle(rndGen);
            jv = fltValue;
            Assert.Equal(fltValue.ToString("R", CultureInfo.InvariantCulture), jv.ToString());
            Assert.Equal(fltValue.ToString("R", CultureInfo.InvariantCulture), jv.ReadAs<string>());

            double dblValue = PrimitiveCreator.CreateInstanceOfDouble(rndGen);
            jv = dblValue;
            Assert.Equal(dblValue.ToString("R", CultureInfo.InvariantCulture), jv.ToString());
            Assert.Equal(dblValue.ToString("R", CultureInfo.InvariantCulture), jv.ReadAs<string>());
        }

        /// <summary>
        /// Tests for the <see cref="System.Json.JsonValue.ReadAs{T}()">JsonValue.ReadAs&lt;string&gt;</see> method from date values.
        /// </summary>
        [Fact]
        public void TestReadAsStringFromDates()
        {
            int seed = MethodBase.GetCurrentMethod().Name.GetHashCode();
            Random rndGen = new Random(seed);

            DateTime dateTimeValue = PrimitiveCreator.CreateInstanceOfDateTime(rndGen);
            JsonValue jv = dateTimeValue;
            Assert.Equal("\"" + dateTimeValue.ToString(DateTimeFormat, CultureInfo.InvariantCulture) + "\"", jv.ToString());
            Assert.Equal(dateTimeValue.ToString(DateTimeFormat, CultureInfo.InvariantCulture), jv.ReadAs<string>());
        }

        /// <summary>
        /// Tests for the <see cref="System.Json.JsonValue.ReadAs{T}()">JsonValue.ReadAs&lt;string&gt;</see> method from char values.
        /// </summary>
        [Fact]
        public void TestReadAsStringFromChar()
        {
            char[] chars = "abc\u0000\b\f\r\n\t\ufedc".ToCharArray();

            foreach (char c in chars)
            {
                string expected = new string(c, 1);
                JsonValue jv = c;
                string actual1 = jv.ReadAs<string>();
                string actual2 = (string)jv;

                Assert.Equal(expected, actual1);
                Assert.Equal(expected, actual2);
            }
        }

        /// <summary>
        /// Tests for the <see cref="System.Json.JsonValue.ReadAs{T}()"/> method where T is a number type and the value is created from a string.
        /// </summary>
        [Fact]
        public void TestReadAsNumberFromStrings()
        {
            Dictionary<object, List<Type>> valuesToNonOverflowingTypesMapping = new Dictionary<object, List<Type>>
            {
                { double.NaN.ToString("R", CultureInfo.InvariantCulture), new List<Type> { typeof(float), typeof(double) } },
                { double.NegativeInfinity.ToString("R", CultureInfo.InvariantCulture), new List<Type> { typeof(float), typeof(double) } },
                { double.PositiveInfinity.ToString("R", CultureInfo.InvariantCulture), new List<Type> { typeof(float), typeof(double) } },
                { double.MaxValue.ToString("R", CultureInfo.InvariantCulture), new List<Type> { typeof(double), typeof(float) } },
                { double.MinValue.ToString("R", CultureInfo.InvariantCulture), new List<Type> { typeof(double), typeof(float) } },
                { float.MaxValue.ToString("R", CultureInfo.InvariantCulture), new List<Type> { typeof(double), typeof(float) } },
                { float.MinValue.ToString("R", CultureInfo.InvariantCulture), new List<Type> { typeof(double), typeof(float) } },
                { Int64.MaxValue.ToString(), new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(ulong) } },
                { Int64.MinValue.ToString(), new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long) } },
                { Int32.MaxValue.ToString(), new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(ulong), typeof(uint) } },
                { Int32.MinValue.ToString(), new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int) } },
                { Int16.MaxValue.ToString(), new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(ulong), typeof(uint), typeof(ushort) } },
                { Int16.MinValue.ToString(), new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short) } },
                { SByte.MaxValue.ToString(), new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { SByte.MinValue.ToString(), new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte) } },
                { UInt64.MaxValue.ToString(), new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(ulong) } },
                { UInt32.MaxValue.ToString(), new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(ulong), typeof(uint) } },
                { UInt16.MaxValue.ToString(), new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(ulong), typeof(uint), typeof(ushort) } },
                { Byte.MaxValue.ToString(), new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { Byte.MinValue.ToString(), new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { "1", new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { "+01", new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { "01.1e+01", new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { "1e1", new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { "1.0", new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { "01.0", new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { "-1", new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte) } },
                { "-1.0", new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte) } },
                { "-01.0", new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte) } },
                { "-01.0e+01", new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte) } },
                { "-01.0e-01", new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { "-.1", new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { "-0100.0e-1", new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte) } },
            };

            foreach (KeyValuePair<object, List<Type>> mapping in valuesToNonOverflowingTypesMapping)
            {
                ConvertValueToNumber<double>(mapping);
                ConvertValueToNumber<float>(mapping);
                ConvertValueToNumber<decimal>(mapping);
                ConvertValueToNumber<long>(mapping);
                ConvertValueToNumber<int>(mapping);
                ConvertValueToNumber<short>(mapping);
                ConvertValueToNumber<sbyte>(mapping);
                ConvertValueToNumber<ulong>(mapping);
                ConvertValueToNumber<uint>(mapping);
                ConvertValueToNumber<ushort>(mapping);
                ConvertValueToNumber<byte>(mapping);
            }

            Dictionary<object, List<Type>> valuesThatAreInvalidNumber = new Dictionary<object, List<Type>>
            {
                { "1L", new List<Type> { } },
                { "0x1", new List<Type> { } },
                { "1e309", new List<Type> { } },
                { "", new List<Type> { } },
                { "-", new List<Type> { } },
                { "e10", new List<Type> { } },
            };

            foreach (KeyValuePair<object, List<Type>> mapping in valuesThatAreInvalidNumber)
            {
                ConvertValueToNumber<double, FormatException>(mapping);
                ConvertValueToNumber<float, FormatException>(mapping);
                ConvertValueToNumber<decimal, FormatException>(mapping);
                ConvertValueToNumber<long, FormatException>(mapping);
                ConvertValueToNumber<int, FormatException>(mapping);
                ConvertValueToNumber<short, FormatException>(mapping);
                ConvertValueToNumber<sbyte, FormatException>(mapping);
                ConvertValueToNumber<ulong, FormatException>(mapping);
                ConvertValueToNumber<uint, FormatException>(mapping);
                ConvertValueToNumber<ushort, FormatException>(mapping);
                ConvertValueToNumber<byte, FormatException>(mapping);
            }
        }

        /// <summary>
        /// Tests for the <see cref="System.Json.JsonValue.ReadAs{T}()"/> method where T is a number type and the value is created from a number.
        /// This is essentially a number conversion test.
        /// </summary>
        [Fact]
        public void TestReadAsNumberFromNumber()
        {
            Dictionary<object, List<Type>> valuesToNonOverflowingTypesMapping = new Dictionary<object, List<Type>>
            { 
                { double.NaN, new List<Type> { typeof(float), typeof(double) } },
                { double.NegativeInfinity, new List<Type> { typeof(float), typeof(double) } },
                { double.PositiveInfinity, new List<Type> { typeof(float), typeof(double) } },
                { float.NaN, new List<Type> { typeof(float), typeof(double) } },
                { float.NegativeInfinity, new List<Type> { typeof(float), typeof(double) } },
                { float.PositiveInfinity, new List<Type> { typeof(float), typeof(double) } },
                { double.MaxValue, new List<Type> { typeof(double), typeof(float) } },
                { double.MinValue, new List<Type> { typeof(double), typeof(float) } },
                { float.MaxValue, new List<Type> { typeof(double), typeof(float) } },
                { float.MinValue, new List<Type> { typeof(double), typeof(float) } },
                { Int64.MaxValue, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(ulong) } },
                { Int64.MinValue, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long) } },
                { Int32.MaxValue, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(ulong), typeof(uint) } },
                { Int32.MinValue, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int) } },
                { Int16.MaxValue, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(ulong), typeof(uint), typeof(ushort) } },
                { Int16.MinValue, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short) } },
                { SByte.MaxValue, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { SByte.MinValue, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte) } },
                { UInt64.MaxValue, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(ulong) } },
                { UInt64.MinValue, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { UInt32.MaxValue, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(ulong), typeof(uint) } },
                { UInt32.MinValue, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { UInt16.MaxValue, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(ulong), typeof(uint), typeof(ushort) } },
                { UInt16.MinValue, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { Byte.MaxValue, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { Byte.MinValue, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { (double)1, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { (float)1, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { (decimal)1, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { (long)1, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { (int)1, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { (short)1, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { (sbyte)1, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { (ulong)1, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { (uint)1, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { (ushort)1, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
                { (byte)1, new List<Type> { typeof(double), typeof(float), typeof(decimal), typeof(long), typeof(int), typeof(short), typeof(sbyte), typeof(ulong), typeof(uint), typeof(ushort), typeof(byte) } },
            };

            foreach (KeyValuePair<object, List<Type>> mapping in valuesToNonOverflowingTypesMapping)
            {
                ConvertValueToNumber<double>(mapping);
                ConvertValueToNumber<float>(mapping);
                ConvertValueToNumber<decimal>(mapping);
                ConvertValueToNumber<long>(mapping);
                ConvertValueToNumber<int>(mapping);
                ConvertValueToNumber<short>(mapping);
                ConvertValueToNumber<sbyte>(mapping);
                ConvertValueToNumber<ulong>(mapping);
                ConvertValueToNumber<uint>(mapping);
                ConvertValueToNumber<ushort>(mapping);
                ConvertValueToNumber<byte>(mapping);
            }
        }

        static void ConvertValueToNumber<T>(KeyValuePair<object, List<Type>> mapping)
        {
            ConvertValueToNumber<T, OverflowException>(mapping);
        }

        static void ConvertValueToNumber<T, TException>(KeyValuePair<object, List<Type>> mapping)
            where TException : Exception
        {
            JsonValue jsonValue = CastToJsonValue(mapping.Key);

            Log.Info("Converting value {0} of type {1} to type {2}.", mapping.Key, mapping.Key.GetType().Name, typeof(T).Name);

            if (mapping.Value.Contains(typeof(T)))
            {
                Console.Write("Conversion should work... ");
                T valueOfT;
                Assert.True(jsonValue.TryReadAs<T>(out valueOfT));
                if (mapping.Key.GetType() != typeof(string))
                {
                    Console.Write("and original value casted to {0} should be the same as the retrieved value... ", typeof(T).Name);
                    T castValue = (T)Convert.ChangeType(mapping.Key, typeof(T), CultureInfo.InvariantCulture);
                    Assert.Equal<T>(castValue, valueOfT);
                }
            }
            else
            {
                Console.Write("Conversion should fail... ");
                T valueOfT;
                Assert.False(jsonValue.TryReadAs<T>(out valueOfT), String.Format("It was possible to read the value as {0}", valueOfT));
                ExpectException<TException>(delegate
                {
                    jsonValue.ReadAs<T>();
                });
            }

            Log.Info("Success!");
        }

        static JsonValue CastToJsonValue(object o)
        {
            switch (Type.GetTypeCode(o.GetType()))
            {
                case TypeCode.Boolean:
                    return (JsonValue)(bool)o;
                case TypeCode.Byte:
                    return (JsonValue)(byte)o;
                case TypeCode.Char:
                    return (JsonValue)(char)o;
                case TypeCode.DateTime:
                    return (JsonValue)(DateTime)o;
                case TypeCode.Decimal:
                    return (JsonValue)(decimal)o;
                case TypeCode.Double:
                    return (JsonValue)(double)o;
                case TypeCode.Int16:
                    return (JsonValue)(short)o;
                case TypeCode.Int32:
                    return (JsonValue)(int)o;
                case TypeCode.Int64:
                    return (JsonValue)(long)o;
                case TypeCode.SByte:
                    return (JsonValue)(sbyte)o;
                case TypeCode.Single:
                    return (JsonValue)(float)o;
                case TypeCode.String:
                    return (JsonValue)(string)o;
                case TypeCode.UInt16:
                    return (JsonValue)(ushort)o;
                case TypeCode.UInt32:
                    return (JsonValue)(uint)o;
                case TypeCode.UInt64:
                    return (JsonValue)(ulong)o;
                default:
                    if (o.GetType() == typeof(DateTimeOffset))
                    {
                        return (JsonValue)(DateTimeOffset)o;
                    }

                    if (o.GetType() == typeof(Guid))
                    {
                        return (JsonValue)(Guid)o;
                    }

                    if (o.GetType() == typeof(Uri))
                    {
                        return (JsonValue)(Uri)o;
                    }

                    break;
            }

            return (JsonObject)o;
        }

        static void ExpectException<T>(Action action) where T : Exception
        {
            JsonValueTests.ExpectException<T>(action);
        }

        static string GetExpectedRepresentation(object obj)
        {
            if (obj is double)
            {
                double dbl = (double)obj;
                if (Double.IsPositiveInfinity(dbl))
                {
                    return "Infinity";
                }
                else if (Double.IsNegativeInfinity(dbl))
                {
                    return "-Infinity";
                }
            }
            else if (obj is float)
            {
                float flt = (float)obj;
                if (Single.IsPositiveInfinity(flt))
                {
                    return "Infinity";
                }
                else if (Single.IsNegativeInfinity(flt))
                {
                    return "-Infinity";
                }
            }
            else if (obj is DateTime)
            {
                DateTime dt = (DateTime)obj;
                return "\"" + dt.ToString(DateTimeFormat, CultureInfo.InvariantCulture) + "\"";
            }

            using (MemoryStream ms = new MemoryStream())
            {
                DataContractJsonSerializer dcjs = new DataContractJsonSerializer(obj.GetType());
                dcjs.WriteObject(ms, obj);
                return Encoding.UTF8.GetString(ms.GetBuffer(), 0, (int)ms.Position);
            }
        }

        void ValidateJson(JsonPrimitive jsonPrim, string expectedJson, JsonType expectedJsonType)
        {
            Assert.Equal(expectedJson, jsonPrim.ToString());
            Assert.Equal(expectedJsonType, jsonPrim.JsonType);
        }

        void TestReadAsRoundtrip<T>(JsonPrimitive jsonPrim, T myOriginalObjectOfT)
        {
            T myReadObjectOfT = jsonPrim.ReadAs<T>();
            T myTryReadObjectOfT;
            Assert.True(jsonPrim.TryReadAs<T>(out myTryReadObjectOfT));
            Assert.Equal(myOriginalObjectOfT, myReadObjectOfT);
            Assert.Equal(myOriginalObjectOfT, myTryReadObjectOfT);

            string stringValue;
            Assert.True(jsonPrim.TryReadAs<string>(out stringValue));
            if (typeof(T) == typeof(bool))
            {
                // bool returns a lowercase version. make sure we get something usable by doing another roundtrip of the value in .NET
                Assert.Equal(String.Format(CultureInfo.InvariantCulture, "{0}", myOriginalObjectOfT), bool.Parse(stringValue).ToString(CultureInfo.InvariantCulture));
            }
            else if (typeof(T) == typeof(float) || typeof(T) == typeof(double))
            {
                Assert.Equal(String.Format(CultureInfo.InvariantCulture, "{0:R}", myOriginalObjectOfT), stringValue);
            }
            else if (typeof(T) == typeof(DateTime))
            {
                Assert.Equal(String.Format(CultureInfo.InvariantCulture, "{0:" + DateTimeFormat + "}", myOriginalObjectOfT), stringValue);
            }
            else
            {
                Assert.Equal(String.Format(CultureInfo.InvariantCulture, "{0}", myOriginalObjectOfT), stringValue);
            }
        }

        void TestReadAsFromStringRoundtrip<T>(T value)
        {
            TestReadAsFromStringRoundtrip<T>(value, String.Format(CultureInfo.InvariantCulture, "{0}", value));
        }

        void TestReadAsFromStringRoundtrip<T>(T value, string valueString)
        {
            T tempOfT;
            JsonPrimitive jsonPrim = new JsonPrimitive(valueString);
            Assert.True(jsonPrim.TryReadAs<T>(out tempOfT));
            Assert.Equal<T>(value, tempOfT);
        }
    }
}