Imported Upstream version 3.6.0

Former-commit-id: da6be194a6b1221998fc28233f2503bd61dd9d14

external/aspnetwebstack/test/System.Json.Test.Unit/Common/AnyInstance.cs

@@ -0,0 +1,222 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Dynamic;
+using System.Linq.Expressions;
+using System.Reflection;
+
+namespace System.Json
+{
+    public static class AnyInstance
+    {
+        public const bool AnyBool = true;
+        public const string AnyString = "hello";
+        public const string AnyString2 = "world";
+        public const char AnyChar = 'c';
+        public const int AnyInt = 123456789;
+        [CLSCompliant(false)]
+        public const uint AnyUInt = 3123456789;
+        public const long AnyLong = 123456789012345L;
+        [CLSCompliant(false)]
+        public const ulong AnyULong = UInt64.MaxValue;
+        public const short AnyShort = -12345;
+        [CLSCompliant(false)]
+        public const ushort AnyUShort = 40000;
+        public const byte AnyByte = 0xDC;
+        [CLSCompliant(false)]
+        public const sbyte AnySByte = -34;
+        public const double AnyDouble = 123.45;
+        public const float AnyFloat = 23.4f;
+        public const decimal AnyDecimal = 1234.5678m;
+        public static readonly Guid AnyGuid = new Guid(0x11223344, 0x5566, 0x7788, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x00);
+        public static readonly DateTime AnyDateTime = new DateTime(2010, 02, 15, 22, 45, 20, DateTimeKind.Utc);
+        public static readonly DateTimeOffset AnyDateTimeOffset = new DateTimeOffset(2010, 2, 5, 15, 45, 20, TimeSpan.FromHours(-3));
+        public static readonly Uri AnyUri = new Uri("http://tempuri.org/");
+
+        public static readonly JsonArray AnyJsonArray;
+        public static readonly JsonObject AnyJsonObject;
+
+        public static readonly JsonPrimitive AnyJsonPrimitive = new JsonPrimitive("hello");
+
+        public static readonly JsonValue AnyJsonValue1 = AnyJsonPrimitive;
+        public static readonly JsonValue AnyJsonValue2;
+        public static readonly JsonValue AnyJsonValue3 = null;
+
+        public static readonly JsonValue DefaultJsonValue = GetDefaultJsonValue();
+
+        public static readonly Person AnyPerson = Person.CreateSample();
+        public static readonly Address AnyAddress = Address.CreateSample();
+
+        public static readonly dynamic AnyDynamic = TestDynamicObject.CreatePersonAsDynamic(AnyPerson);
+
+        public static JsonValue[] AnyJsonValueArray
+        {
+            get
+            {
+                return new JsonValue[]
+                {
+                    AnyInstance.AnyJsonArray,
+                    AnyInstance.AnyJsonObject,
+                    AnyInstance.AnyJsonPrimitive,
+                    AnyInstance.DefaultJsonValue
+                };
+            }
+        }
+
+        static AnyInstance()
+        {
+            AnyJsonArray = new JsonArray { 1, 2, 3 };
+            AnyJsonObject = new JsonObject { { "one", 1 }, { "two", 2 } };
+            AnyJsonArray.Changing += new EventHandler<JsonValueChangeEventArgs>(PreventChanging);
+            AnyJsonObject.Changing += new EventHandler<JsonValueChangeEventArgs>(PreventChanging);
+            AnyJsonValue2 = AnyJsonArray;
+        }
+
+        private static void PreventChanging(object sender, JsonValueChangeEventArgs e)
+        {
+            throw new InvalidOperationException("AnyInstance.AnyJsonArray or AnyJsonObject cannot be modified; please clone the instance if the test needs to change it.");
+        }
+
+        private static JsonValue GetDefaultJsonValue()
+        {
+            PropertyInfo propInfo = typeof(JsonValue).GetProperty("DefaultInstance", BindingFlags.Static | BindingFlags.NonPublic);
+            return propInfo.GetValue(null, null) as JsonValue;
+        }
+    }
+
+    public class Person
+    {
+        public string Name { get; set; }
+
+        public int Age { get; set; }
+
+        public Address Address { get; set; }
+
+        public List<Person> Friends { get; set; }
+
+        public static Person CreateSample()
+        {
+            Person anyObject = new Person
+            {
+                Name = AnyInstance.AnyString,
+                Age = AnyInstance.AnyInt,
+                Address = Address.CreateSample(),
+                Friends = new List<Person> { new Person { Name = "Bill Gates", Age = 23, Address = Address.CreateSample() }, new Person { Name = "Steve Ballmer", Age = 19, Address = Address.CreateSample() } }
+            };
+
+            return anyObject;
+        }
+
+        public string FriendsToString()
+        {
+            string s = "";
+
+            if (this.Friends != null)
+            {
+                foreach (Person p in this.Friends)
+                {
+                    s += p + ",";
+                }
+            }
+
+            return s;
+        }
+
+        public override string ToString()
+        {
+            return String.Format("{0}, {1}, [{2}], Friends=[{3}]", this.Name, this.Age, this.Address, this.FriendsToString());
+        }
+    }
+
+    public class Address
+    {
+        public const string AnyStreet = "123 1st Ave";
+
+        public const string AnyCity = "Springfield";
+
+        public const string AnyState = "ZZ";
+
+        public string Street { get; set; }
+
+        public string City { get; set; }
+
+        public string State { get; set; }
+
+        public static Address CreateSample()
+        {
+            Address address = new Address
+            {
+                Street = AnyStreet,
+                City = AnyCity,
+                State = AnyState,
+            };
+
+            return address;
+        }
+
+        public override string ToString()
+        {
+            return String.Format("{0}, {1}, {2}", this.Street, this.City, this.State);
+        }
+    }
+
+    public class TestDynamicObject : DynamicObject
+    {
+        private IDictionary<string, object> _values = new Dictionary<string, object>();
+
+        public bool UseFallbackMethod { get; set; }
+        public bool UseErrorSuggestion { get; set; }
+
+        public string TestProperty { get; set; }
+
+        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)
+        {
+            if (this.UseFallbackMethod)
+            {
+                DynamicMetaObject target = new DynamicMetaObject(Expression.Parameter(this.GetType()), BindingRestrictions.Empty);
+                DynamicMetaObject errorSuggestion = null;
+
+                if (this.UseErrorSuggestion)
+                {
+                    errorSuggestion = new DynamicMetaObject(Expression.Throw(Expression.Constant(new TestDynamicObjectException())), BindingRestrictions.Empty);
+                }
+
+                DynamicMetaObject metaObj = binder.FallbackGetMember(target, errorSuggestion);
+                Expression<Action> lambda = Expression.Lambda<Action>(metaObj.Expression, new ParameterExpression[] { });
+                lambda.Compile().Invoke();
+            }
+
+            return _values.TryGetValue(binder.Name, out result);
+        }
+
+        public static dynamic CreatePersonAsDynamic(Person person)
+        {
+            dynamic dynObj = new TestDynamicObject();
+
+            dynObj.Name = person.Name;
+            dynObj.Age = person.Age;
+            dynObj.Address = new Address();
+            dynObj.Address.City = person.Address.City;
+            dynObj.Address.Street = person.Address.Street;
+            dynObj.Address.State = person.Address.State;
+            dynObj.Friends = person.Friends;
+
+            return dynObj;
+        }
+
+        public class TestDynamicObjectException : Exception
+        {
+        }
+    }
+}

external/aspnetwebstack/test/System.Json.Test.Unit/Common/ExceptionTestHelper.cs

@@ -0,0 +1,29 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using Xunit;
+
+namespace System.Json
+{
+    public static class ExceptionHelper
+    {
+        public static void Throws<TException>(Assert.ThrowsDelegate act, Action<TException> exceptionAssert) where TException : Exception
+        {
+            Exception ex = Record.Exception(act);
+            Assert.NotNull(ex);
+            TException tex = Assert.IsAssignableFrom<TException>(ex);
+            exceptionAssert(tex);
+        }
+
+        public static void Throws<TException>(Assert.ThrowsDelegate act, string message) where TException : Exception
+        {
+            Throws<TException>(act, ex => Assert.Equal(message, ex.Message));
+        }
+
+        public static void Throws<TException>(Assert.ThrowsDelegate act) where TException : Exception
+        {
+            Throws<TException>(act, _ => { });
+        }
+
+
+    }
+}

external/aspnetwebstack/test/System.Json.Test.Unit/Extensions/JsonValueExtensionsTest.cs

@@ -0,0 +1,478 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Runtime.Serialization;
+using System.Runtime.Serialization.Json;
+using Xunit;
+using Xunit.Extensions;
+
+namespace System.Json
+{
+    public class JsonValueExtensionsTest
+    {
+        const string DynamicPropertyNotDefined = "'{0}' does not contain a definition for property '{1}'.";
+        const string OperationNotSupportedOnJsonTypeMsgFormat = "Operation not supported on JsonValue instance of 'JsonType.{0}' type.";
+
+        [Fact]
+        public void CreateFromTypeTest()
+        {
+            JsonValue[] values =
+            {
+                AnyInstance.AnyJsonObject,
+                AnyInstance.AnyJsonArray,
+                AnyInstance.AnyJsonPrimitive,
+                AnyInstance.DefaultJsonValue
+            };
+
+            foreach (JsonValue value in values)
+            {
+                Assert.Same(value, JsonValueExtensions.CreateFrom(value));
+            }
+        }
+
+        public static IEnumerable<object[]> PrimitiveTestData
+        {
+            get
+            {
+                yield return new object[] { AnyInstance.AnyBool };
+                yield return new object[] { AnyInstance.AnyByte };
+                yield return new object[] { AnyInstance.AnyChar };
+                yield return new object[] { AnyInstance.AnyDateTime };
+                yield return new object[] { AnyInstance.AnyDateTimeOffset };
+                yield return new object[] { AnyInstance.AnyDecimal };
+                yield return new object[] { AnyInstance.AnyDouble };
+                yield return new object[] { AnyInstance.AnyFloat };
+                yield return new object[] { AnyInstance.AnyGuid };
+                yield return new object[] { AnyInstance.AnyLong };
+                yield return new object[] { AnyInstance.AnySByte };
+                yield return new object[] { AnyInstance.AnyShort };
+                yield return new object[] { AnyInstance.AnyUInt };
+                yield return new object[] { AnyInstance.AnyULong };
+                yield return new object[] { AnyInstance.AnyUri };
+                yield return new object[] { AnyInstance.AnyUShort };
+                yield return new object[] { AnyInstance.AnyInt };
+                yield return new object[] { AnyInstance.AnyString };
+            }
+        }
+
+        [Theory]
+        [PropertyData("PrimitiveTestData")]
+        public void CreateFromPrimitiveTest(object value)
+        {
+            Type valueType = value.GetType();
+            Assert.Equal(value, JsonValueExtensions.CreateFrom(value).ReadAs(valueType));
+        }
+
+        [Fact]
+        public void CreateFromComplexTest()
+        {
+            JsonValue target = JsonValueExtensions.CreateFrom(AnyInstance.AnyPerson);
+
+            Assert.Equal(AnyInstance.AnyPerson.Name, (string)target["Name"]);
+            Assert.Equal(AnyInstance.AnyPerson.Age, (int)target["Age"]);
+            Assert.Equal(AnyInstance.AnyPerson.Address.City, (string)target.ValueOrDefault("Address", "City"));
+        }
+
+        [Fact]
+        public void CreateFromDynamicSimpleTest()
+        {
+            JsonValue target;
+
+            target = JsonValueExtensions.CreateFrom(AnyInstance.AnyDynamic);
+            Assert.NotNull(target);
+
+            string expected = "{\"Name\":\"Bill Gates\",\"Age\":21,\"Grades\":[\"F\",\"B-\",\"C\"]}";
+            dynamic obj = new TestDynamicObject();
+            obj.Name = "Bill Gates";
+            obj.Age = 21;
+            obj.Grades = new[] { "F", "B-", "C" };
+
+            target = JsonValueExtensions.CreateFrom(obj);
+            Assert.Equal<string>(expected, target.ToString());
+
+            target = JsonValueExtensions.CreateFrom(new TestDynamicObject());
+            Assert.Equal<string>("{}", target.ToString());
+        }
+
+        [Fact]
+        public void CreateFromDynamicComplextTest()
+        {
+            JsonValue target;
+            Person person = AnyInstance.AnyPerson;
+            dynamic dyn = TestDynamicObject.CreatePersonAsDynamic(person);
+
+            dyn.TestProperty = AnyInstance.AnyString;
+
+            target = JsonValueExtensions.CreateFrom(dyn);
+            Assert.NotNull(target);
+            Assert.Equal<string>(AnyInstance.AnyString, dyn.TestProperty);
+            Person jvPerson = target.ReadAsType<Person>();
+            Assert.Equal(person.ToString(), jvPerson.ToString());
+
+            Person p1 = Person.CreateSample();
+            Person p2 = Person.CreateSample();
+
+            p2.Name += "__2";
+            p2.Age += 10;
+            p2.Address.City += "__2";
+
+            Person[] friends = new Person[] { p1, p2 };
+            target = JsonValueExtensions.CreateFrom(friends);
+            Person[] personArr = target.ReadAsType<Person[]>();
+            Assert.Equal<int>(friends.Length, personArr.Length);
+            Assert.Equal<string>(friends[0].ToString(), personArr[0].ToString());
+            Assert.Equal<string>(friends[1].ToString(), personArr[1].ToString());
+        }
+
+        [Fact]
+        public void CreateFromDynamicBinderFallbackTest()
+        {
+            JsonValue target;
+            Person person = AnyInstance.AnyPerson;
+            dynamic dyn = new TestDynamicObject();
+            dyn.Name = AnyInstance.AnyString;
+
+            dyn.UseFallbackMethod = true;
+            string expectedMessage = String.Format(DynamicPropertyNotDefined, dyn.GetType().FullName, "Name");
+            ExceptionHelper.Throws<InvalidOperationException>(() => target = JsonValueExtensions.CreateFrom(dyn), expectedMessage);
+
+            dyn.UseErrorSuggestion = true;
+            ExceptionHelper.Throws<TestDynamicObject.TestDynamicObjectException>(() => target = JsonValueExtensions.CreateFrom(dyn));
+        }
+
+        [Fact]
+        public void CreateFromNestedDynamicTest()
+        {
+            JsonValue target;
+            string expected = "{\"Name\":\"Root\",\"Level1\":{\"Name\":\"Level1\",\"Level2\":{\"Name\":\"Level2\"}}}";
+            dynamic dyn = new TestDynamicObject();
+            dyn.Name = "Root";
+            dyn.Level1 = new TestDynamicObject();
+            dyn.Level1.Name = "Level1";
+            dyn.Level1.Level2 = new TestDynamicObject();
+            dyn.Level1.Level2.Name = "Level2";
+
+            target = JsonValueExtensions.CreateFrom(dyn);
+            Assert.NotNull(target);
+            Assert.Equal<string>(expected, target.ToString());
+        }
+
+        [Fact]
+        public void CreateFromDynamicWithJsonValueChildrenTest()
+        {
+            JsonValue target;
+            string level3 = "{\"Name\":\"Level3\",\"Null\":null}";
+            string level2 = "{\"Name\":\"Level2\",\"JsonObject\":" + AnyInstance.AnyJsonObject.ToString() + ",\"JsonArray\":" + AnyInstance.AnyJsonArray.ToString() + ",\"Level3\":" + level3 + "}";
+            string level1 = "{\"Name\":\"Level1\",\"JsonPrimitive\":" + AnyInstance.AnyJsonPrimitive.ToString() + ",\"Level2\":" + level2 + "}";
+            string expected = "{\"Name\":\"Root\",\"Level1\":" + level1 + "}";
+
+            dynamic dyn = new TestDynamicObject();
+            dyn.Name = "Root";
+            dyn.Level1 = new TestDynamicObject();
+            dyn.Level1.Name = "Level1";
+            dyn.Level1.JsonPrimitive = AnyInstance.AnyJsonPrimitive;
+            dyn.Level1.Level2 = new TestDynamicObject();
+            dyn.Level1.Level2.Name = "Level2";
+            dyn.Level1.Level2.JsonObject = AnyInstance.AnyJsonObject;
+            dyn.Level1.Level2.JsonArray = AnyInstance.AnyJsonArray;
+            dyn.Level1.Level2.Level3 = new TestDynamicObject();
+            dyn.Level1.Level2.Level3.Name = "Level3";
+            dyn.Level1.Level2.Level3.Null = null;
+
+            target = JsonValueExtensions.CreateFrom(dyn);
+            Assert.Equal<string>(expected, target.ToString());
+        }
+
+        [Fact]
+        public void CreateFromDynamicJVTest()
+        {
+            JsonValue target;
+
+            dynamic[] values = new dynamic[]
+            {
+                AnyInstance.AnyJsonArray,
+                AnyInstance.AnyJsonObject,
+                AnyInstance.AnyJsonPrimitive,
+                AnyInstance.DefaultJsonValue
+            };
+
+            foreach (dynamic dyn in values)
+            {
+                target = JsonValueExtensions.CreateFrom(dyn);
+                Assert.Same(dyn, target);
+            }
+        }
+
+        [Fact]
+        public void ReadAsTypeFallbackTest()
+        {
+            JsonValue jv = AnyInstance.AnyInt;
+            Person personFallback = Person.CreateSample();
+
+            Person personResult = jv.ReadAsType<Person>(personFallback);
+            Assert.Same(personFallback, personResult);
+
+            int intFallback = 45;
+            int intValue = jv.ReadAsType<int>(intFallback);
+            Assert.Equal<int>(AnyInstance.AnyInt, intValue);
+        }
+
+        [Fact(Skip = "See bug #228569 in CSDMain")]
+        public void ReadAsTypeCollectionTest()
+        {
+            JsonValue jsonValue;
+            jsonValue = JsonValue.Parse("[1,2,3]");
+
+            List<object> list = jsonValue.ReadAsType<List<object>>();
+            Array array = jsonValue.ReadAsType<Array>();
+            object[] objArr = jsonValue.ReadAsType<object[]>();
+
+            IList[] collections = 
+            {
+                list, array, objArr
+            };
+
+            foreach (IList collection in collections)
+            {
+                Assert.Equal<int>(jsonValue.Count, collection.Count);
+
+                for (int i = 0; i < jsonValue.Count; i++)
+                {
+                    Assert.Equal<int>((int)jsonValue[i], (int)collection[i]);
+                }
+            }
+
+            jsonValue = JsonValue.Parse("{\"A\":1,\"B\":2,\"C\":3}");
+            Dictionary<string, object> dictionary = jsonValue.ReadAsType<Dictionary<string, object>>();
+
+            Assert.Equal<int>(jsonValue.Count, dictionary.Count);
+            foreach (KeyValuePair<string, JsonValue> pair in jsonValue)
+            {
+                Assert.Equal((int)jsonValue[pair.Key], (int)dictionary[pair.Key]);
+            }
+        }
+
+        [Fact]
+        public void TryReadAsInvalidCollectionTest()
+        {
+            JsonValue jo = AnyInstance.AnyJsonObject;
+            JsonValue ja = AnyInstance.AnyJsonArray;
+            JsonValue jp = AnyInstance.AnyJsonPrimitive;
+            JsonValue jd = AnyInstance.DefaultJsonValue;
+
+            JsonValue[] invalidArrays = 
+            {
+                jo, jp, jd
+            };
+
+            JsonValue[] invalidDictionaries =
+            {
+                ja, jp, jd
+            };
+
+            bool success;
+            object[] array;
+            Dictionary<string, object> dictionary;
+
+            foreach (JsonValue value in invalidArrays)
+            {
+                success = value.TryReadAsType<object[]>(out array);
+                Console.WriteLine("Try reading {0} as object[]; success = {1}", value.ToString(), success);
+                Assert.False(success);
+                Assert.Null(array);
+            }
+
+            foreach (JsonValue value in invalidDictionaries)
+            {
+                success = value.TryReadAsType<Dictionary<string, object>>(out dictionary);
+                Console.WriteLine("Try reading {0} as Dictionary<string, object>; success = {1}", value.ToString(), success);
+                Assert.False(success);
+                Assert.Null(dictionary);
+            }
+        }
+
+        [Fact]
+        public void ReadAsExtensionsOnDynamicTest()
+        {
+            dynamic jv = JsonValueExtensions.CreateFrom(AnyInstance.AnyPerson);
+            bool success;
+            object obj;
+
+            success = jv.TryReadAsType(typeof(Person), out obj);
+            Assert.True(success);
+            Assert.NotNull(obj);
+            Assert.Equal<string>(AnyInstance.AnyPerson.ToString(), obj.ToString());
+
+            obj = jv.ReadAsType(typeof(Person));
+            Assert.NotNull(obj);
+            Assert.Equal<string>(AnyInstance.AnyPerson.ToString(), obj.ToString());
+        }
+
+#if CODEPLEX
+        [Fact]
+        public void ToCollectionTest()
+        {
+            JsonValue target;
+            object[] array;
+
+            target = AnyInstance.AnyJsonArray;
+            array = target.ToObjectArray();
+
+            Assert.Equal(target.Count, array.Length);
+
+            for (int i = 0; i < target.Count; i++)
+            {
+                Assert.Equal(array[i], target[i].ReadAs(array[i].GetType()));
+            }
+
+            target = AnyInstance.AnyJsonObject;
+            IDictionary<string, object> dictionary = target.ToDictionary();
+
+            Assert.Equal(target.Count, dictionary.Count);
+
+            foreach (KeyValuePair<string, JsonValue> pair in target)
+            {
+                Assert.True(dictionary.ContainsKey(pair.Key));
+                Assert.Equal<string>(target[pair.Key].ToString(), dictionary[pair.Key].ToString());
+            }
+        }
+
+        [Fact]
+        public void ToCollectionsNestedTest()
+        {
+            JsonArray ja = JsonValue.Parse("[1, {\"A\":[1,2,3]}, 5]") as JsonArray;
+            JsonObject jo = JsonValue.Parse("{\"A\":1,\"B\":[1,2,3]}") as JsonObject;
+
+            object[] objArray = ja.ToObjectArray();
+            Assert.NotNull(objArray);
+            Assert.Equal<int>(ja.Count, objArray.Length);
+            Assert.Equal((int)ja[0], (int)objArray[0]);
+            Assert.Equal((int)ja[2], (int)objArray[2]);
+
+            IDictionary<string, object> dict = objArray[1] as IDictionary<string, object>;
+            Assert.NotNull(dict);
+
+            objArray = dict["A"] as object[];
+            Assert.NotNull(objArray);
+            for (int i = 0; i < 3; i++)
+            {
+                Assert.Equal(i + 1, (int)objArray[i]);
+            }
+
+            dict = jo.ToDictionary();
+            Assert.NotNull(dict);
+            Assert.Equal<int>(jo.Count, dict.Count);
+            Assert.Equal<int>(1, (int)dict["A"]);
+
+            objArray = dict["B"] as object[];
+            Assert.NotNull(objArray);
+            for (int i = 1; i < 3; i++)
+            {
+                Assert.Equal(i + 1, (int)objArray[i]);
+            }
+        }
+
+        [Fact]
+        public void ToCollectionsInvalidTest()
+        {
+            JsonValue jo = AnyInstance.AnyJsonObject;
+            JsonValue ja = AnyInstance.AnyJsonArray;
+            JsonValue jp = AnyInstance.AnyJsonPrimitive;
+            JsonValue jd = AnyInstance.DefaultJsonValue;
+
+            ExceptionTestHelper.ExpectException<NotSupportedException>(delegate { var ret = jd.ToObjectArray(); }, String.Format(OperationNotSupportedOnJsonTypeMsgFormat, jd.JsonType));
+            ExceptionTestHelper.ExpectException<NotSupportedException>(delegate { var ret = jd.ToDictionary(); }, String.Format(OperationNotSupportedOnJsonTypeMsgFormat, jd.JsonType));
+
+            ExceptionTestHelper.ExpectException<NotSupportedException>(delegate { var ret = jp.ToObjectArray(); }, String.Format(OperationNotSupportedOnJsonTypeMsgFormat, jp.JsonType));
+            ExceptionTestHelper.ExpectException<NotSupportedException>(delegate { var ret = jp.ToDictionary(); }, String.Format(OperationNotSupportedOnJsonTypeMsgFormat, jp.JsonType));
+
+            ExceptionTestHelper.ExpectException<NotSupportedException>(delegate { var ret = jo.ToObjectArray(); }, String.Format(OperationNotSupportedOnJsonTypeMsgFormat, jo.JsonType));
+            ExceptionTestHelper.ExpectException<NotSupportedException>(delegate { var ret = ja.ToDictionary(); }, String.Format(OperationNotSupportedOnJsonTypeMsgFormat, ja.JsonType));
+        }
+
+        // 195843 JsonValue to support generic extension methods defined in JsonValueExtensions.
+        // 195867 Consider creating extension point for allowing new extension methods to be callable via dynamic interface
+        //[Fact] This requires knowledge of the C# binder to be able to get the generic call parameters.
+        public void ReadAsGenericExtensionsOnDynamicTest()
+        {
+            dynamic jv = JsonValueExtensions.CreateFrom(AnyInstance.AnyPerson);
+            Person person;
+            bool success;
+
+            person = jv.ReadAsType<Person>();
+            Assert.NotNull(person);
+            Assert.Equal<string>(AnyInstance.AnyPerson.ToString(), person.ToString());
+
+            success = jv.TryReadAsType<Person>(out person);
+            Assert.True(success);
+            Assert.NotNull(person);
+            Assert.Equal<string>(AnyInstance.AnyPerson.ToString(), person.ToString());
+        }
+#else
+        [Fact(Skip = "See bug #228569 in CSDMain")]
+        public void TestDataContractJsonSerializerSettings()
+        {
+            TestTypeForSerializerSettings instance = new TestTypeForSerializerSettings
+            {
+                BaseRef = new DerivedType(),
+                Date = AnyInstance.AnyDateTime,
+                Dict = new Dictionary<string, object>
+                {
+                    { "one", 1 },
+                    { "two", 2 },
+                    { "two point five", 2.5 },
+                }
+            };
+
+            JsonObject dict = new JsonObject
+            {
+                { "one", 1 },
+                { "two", 2 },
+                { "two point five", 2.5 },
+            };
+
+            JsonObject equivalentJsonObject = new JsonObject
+            {
+                { "BaseRef", new JsonObject { { "__type", "DerivedType:NS" } } },
+                { "Date", AnyInstance.AnyDateTime },
+                { "Dict", dict },
+            };
+
+            JsonObject createdFromType = JsonValueExtensions.CreateFrom(instance) as JsonObject;
+            Assert.Equal(equivalentJsonObject.ToString(), createdFromType.ToString());
+
+            TestTypeForSerializerSettings newInstance = equivalentJsonObject.ReadAsType<TestTypeForSerializerSettings>();
+            // DISABLED, 198487 - Assert.Equal(instance.Date, newInstance.Date);
+            Assert.Equal(instance.BaseRef.GetType().FullName, newInstance.BaseRef.GetType().FullName);
+            Assert.Equal(3, newInstance.Dict.Count);
+            Assert.Equal(1, newInstance.Dict["one"]);
+            Assert.Equal(2, newInstance.Dict["two"]);
+            Assert.Equal(2.5, Convert.ToDouble(newInstance.Dict["two point five"], CultureInfo.InvariantCulture));
+        }
+
+        [DataContract]
+        public class TestTypeForSerializerSettings
+        {
+            [DataMember]
+            public BaseType BaseRef { get; set; }
+            [DataMember]
+            public DateTime Date { get; set; }
+            [DataMember]
+            public Dictionary<string, object> Dict { get; set; }
+        }
+
+        [DataContract(Name = "BaseType", Namespace = "NS")]
+        [KnownType(typeof(DerivedType))]
+        public class BaseType
+        {
+        }
+
+        [DataContract(Name = "DerivedType", Namespace = "NS")]
+        public class DerivedType : BaseType
+        {
+        }
+#endif
+    }
+}

external/aspnetwebstack/test/System.Json.Test.Unit/JsonDefaultTest.cs

@@ -0,0 +1,155 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.IO;
+using System.Runtime.Serialization.Json;
+using Xunit;
+
+namespace System.Json
+{
+    public class JsonDefaultTest
+    {
+        const string IndexerNotSupportedMsgFormat = "'{0}' type indexer is not supported on JsonValue of 'JsonType.Default' type.";
+        const string OperationNotAllowedOnDefaultMsgFormat = "Operation not supported on JsonValue instances of 'JsonType.Default' type.";
+
+        [Fact]
+        public void PropertiesTest()
+        {
+            JsonValue target = AnyInstance.DefaultJsonValue;
+
+            Assert.Equal(JsonType.Default, target.JsonType);
+            Assert.Equal(0, target.Count);
+            Assert.Equal(false, target.ContainsKey("hello"));
+            Assert.Equal(false, target.ContainsKey(String.Empty));
+        }
+
+        [Fact]
+        public void SaveTest()
+        {
+            JsonValue target = AnyInstance.DefaultJsonValue;
+            using (MemoryStream ms = new MemoryStream())
+            {
+                ExceptionHelper.Throws<InvalidOperationException>(() => target.Save(ms), "Operation not supported on JsonValue instances of 'JsonType.Default' type.");
+            }
+        }
+
+        [Fact]
+        public void ToStringTest()
+        {
+            JsonValue target;
+
+            target = AnyInstance.DefaultJsonValue;
+            Assert.Equal(target.ToString(), "Default");
+        }
+
+        [Fact(Skip = "See bug #228569 in CSDMain")]
+        public void ReadAsTests()
+        {
+            JsonValue target = AnyInstance.DefaultJsonValue;
+            string typeName = target.GetType().FullName;
+
+            string errorMsgFormat = "Cannot read '{0}' as '{1}' type.";
+
+            ExceptionHelper.Throws<NotSupportedException>(delegate { target.ReadAs(typeof(bool)); }, String.Format(errorMsgFormat, typeName, typeof(bool)));
+            ExceptionHelper.Throws<NotSupportedException>(delegate { target.ReadAs(typeof(string)); }, String.Format(errorMsgFormat, typeName, typeof(string)));
+            ExceptionHelper.Throws<NotSupportedException>(delegate { target.ReadAs(typeof(JsonObject)); }, String.Format(errorMsgFormat, typeName, typeof(JsonObject)));
+
+            ExceptionHelper.Throws<NotSupportedException>(delegate { target.ReadAs<bool>(); }, String.Format(errorMsgFormat, typeName, typeof(bool)));
+            ExceptionHelper.Throws<NotSupportedException>(delegate { target.ReadAs<string>(); }, String.Format(errorMsgFormat, typeName, typeof(string)));
+            ExceptionHelper.Throws<NotSupportedException>(delegate { target.ReadAs<JsonObject>(); }, String.Format(errorMsgFormat, typeName, typeof(JsonObject)));
+
+            bool boolValue;
+            string stringValue;
+            JsonObject objValue;
+
+            object value;
+
+            Assert.False(target.TryReadAs(typeof(bool), out value), "TryReadAs expected to return false");
+            Assert.Null(value);
+
+            Assert.False(target.TryReadAs(typeof(string), out value), "TryReadAs expected to return false");
+            Assert.Null(value);
+
+            Assert.False(target.TryReadAs(typeof(JsonObject), out value), "TryReadAs expected to return false");
+            Assert.Null(value);
+
+            Assert.False(target.TryReadAs<bool>(out boolValue), "TryReadAs expected to return false");
+            Assert.False(boolValue);
+
+            Assert.False(target.TryReadAs<string>(out stringValue), "TryReadAs expected to return false");
+            Assert.Null(stringValue);
+
+            Assert.False(target.TryReadAs<JsonObject>(out objValue), "TryReadAs expected to return false");
+            Assert.Null(objValue);
+        }
+
+        [Fact]
+        public void ItemTests()
+        {
+            JsonValue target = AnyInstance.DefaultJsonValue;
+
+            ExceptionHelper.Throws<InvalidOperationException>(delegate { var v = target["MissingProperty"]; }, String.Format(IndexerNotSupportedMsgFormat, typeof(string).FullName));
+            ExceptionHelper.Throws<InvalidOperationException>(delegate { target["NewProperty"] = AnyInstance.AnyJsonValue1; }, String.Format(IndexerNotSupportedMsgFormat, typeof(string).FullName));
+        }
+
+        [Fact]
+        public void DynamicItemTests()
+        {
+            dynamic target = AnyInstance.DefaultJsonValue;
+
+            var getByKey = target["SomeKey"];
+            Assert.Same(getByKey, AnyInstance.DefaultJsonValue);
+
+            var getByIndex = target[10];
+            Assert.Same(getByIndex, AnyInstance.DefaultJsonValue);
+
+            ExceptionHelper.Throws<InvalidOperationException>(delegate { target["SomeKey"] = AnyInstance.AnyJsonObject; }, String.Format(IndexerNotSupportedMsgFormat, typeof(string).FullName));
+            ExceptionHelper.Throws<InvalidOperationException>(delegate { target[10] = AnyInstance.AnyJsonObject; }, String.Format(IndexerNotSupportedMsgFormat, typeof(int).FullName));
+        }
+
+        [Fact(Skip = "See bug #228569 in CSDMain")]
+        public void InvalidAssignmentValueTest()
+        {
+            JsonValue target;
+            JsonValue value = AnyInstance.DefaultJsonValue;
+
+            target = AnyInstance.AnyJsonArray;
+            ExceptionHelper.Throws<ArgumentException>(delegate { target[0] = value; }, OperationNotAllowedOnDefaultMsgFormat);
+
+            target = AnyInstance.AnyJsonObject;
+            ExceptionHelper.Throws<ArgumentException>(delegate { target["key"] = value; }, OperationNotAllowedOnDefaultMsgFormat);
+        }
+
+        [Fact]
+        public void DefaultConcatTest()
+        {
+            JsonValue jv = JsonValueExtensions.CreateFrom(AnyInstance.AnyPerson);
+            dynamic target = JsonValueExtensions.CreateFrom(AnyInstance.AnyPerson);
+            Person person = AnyInstance.AnyPerson;
+
+            Assert.Equal(JsonType.Default, target.Friends[100000].Name.JsonType);
+            Assert.Equal(JsonType.Default, target.Friends[0].Age.Minutes.JsonType);
+
+            JsonValue jv1 = target.MissingProperty as JsonValue;
+            Assert.NotNull(jv1);
+
+            JsonValue jv2 = target.MissingProperty1.MissingProperty2 as JsonValue;
+            Assert.NotNull(jv2);
+
+            Assert.Same(jv1, jv2);
+            Assert.Same(target.Person.Name.MissingProperty, AnyInstance.DefaultJsonValue);
+        }
+
+        [Fact]
+        public void CastingDefaultValueTest()
+        {
+            JsonValue jv = AnyInstance.DefaultJsonValue;
+            dynamic d = jv;
+
+            ExceptionHelper.Throws<InvalidCastException>(delegate { float p = (float)d; });
+            ExceptionHelper.Throws<InvalidCastException>(delegate { byte p = (byte)d; });
+            ExceptionHelper.Throws<InvalidCastException>(delegate { int p = (int)d; });
+
+            Assert.Null((string)d);
+        }
+    }
+}

external/aspnetwebstack/test/System.Json.Test.Unit/JsonPrimitiveTest.cs

@@ -0,0 +1,412 @@
+// 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.Runtime.Serialization.Json;
+using System.Text;
+using Xunit;
+
+namespace System.Json
+{
+    public class JsonPrimitiveTest
+    {
+        const string DateTimeFormat = "yyyy-MM-ddTHH:mm:ss.fffK";
+
+        [Fact]
+        public void JsonPrimitiveConstructorTest()
+        {
+            Assert.Equal(AnyInstance.AnyString, (string)(new JsonPrimitive(AnyInstance.AnyString)));
+            Assert.Equal(AnyInstance.AnyChar, (char)(new JsonPrimitive(AnyInstance.AnyChar)));
+            Assert.Equal(AnyInstance.AnyUri, (Uri)(new JsonPrimitive(AnyInstance.AnyUri)));
+            Assert.Equal(AnyInstance.AnyGuid, (Guid)(new JsonPrimitive(AnyInstance.AnyGuid)));
+            Assert.Equal(AnyInstance.AnyDateTime, (DateTime)(new JsonPrimitive(AnyInstance.AnyDateTime)));
+            Assert.Equal(AnyInstance.AnyDateTimeOffset, (DateTimeOffset)(new JsonPrimitive(AnyInstance.AnyDateTimeOffset)));
+            Assert.Equal(AnyInstance.AnyBool, (bool)(new JsonPrimitive(AnyInstance.AnyBool)));
+            Assert.Equal(AnyInstance.AnyByte, (byte)(new JsonPrimitive(AnyInstance.AnyByte)));
+            Assert.Equal(AnyInstance.AnyShort, (short)(new JsonPrimitive(AnyInstance.AnyShort)));
+            Assert.Equal(AnyInstance.AnyInt, (int)(new JsonPrimitive(AnyInstance.AnyInt)));
+            Assert.Equal(AnyInstance.AnyLong, (long)(new JsonPrimitive(AnyInstance.AnyLong)));
+            Assert.Equal(AnyInstance.AnySByte, (sbyte)(new JsonPrimitive(AnyInstance.AnySByte)));
+            Assert.Equal(AnyInstance.AnyUShort, (ushort)(new JsonPrimitive(AnyInstance.AnyUShort)));
+            Assert.Equal(AnyInstance.AnyUInt, (uint)(new JsonPrimitive(AnyInstance.AnyUInt)));
+            Assert.Equal(AnyInstance.AnyULong, (ulong)(new JsonPrimitive(AnyInstance.AnyULong)));
+            Assert.Equal(AnyInstance.AnyDecimal, (decimal)(new JsonPrimitive(AnyInstance.AnyDecimal)));
+            Assert.Equal(AnyInstance.AnyFloat, (float)(new JsonPrimitive(AnyInstance.AnyFloat)));
+            Assert.Equal(AnyInstance.AnyDouble, (double)(new JsonPrimitive(AnyInstance.AnyDouble)));
+        }
+
+        [Fact]
+        public void ValueTest()
+        {
+            object[] values = 
+            {
+                AnyInstance.AnyInt, AnyInstance.AnyString, AnyInstance.AnyGuid, AnyInstance.AnyDecimal, AnyInstance.AnyBool, AnyInstance.AnyDateTime
+            };
+
+            foreach (object value in values)
+            {
+                JsonPrimitive jp;
+                bool success = JsonPrimitive.TryCreate(value, out jp);
+                Assert.True(success);
+                Assert.Equal(value, jp.Value);
+            }
+        }
+
+        [Fact]
+        public void TryCreateTest()
+        {
+            object[] numberValues =
+            {
+                AnyInstance.AnyByte, AnyInstance.AnySByte, AnyInstance.AnyShort, AnyInstance.AnyDecimal, 
+                AnyInstance.AnyDouble, AnyInstance.AnyShort, AnyInstance.AnyInt, AnyInstance.AnyLong, 
+                AnyInstance.AnyUShort, AnyInstance.AnyUInt, AnyInstance.AnyULong, AnyInstance.AnyFloat
+            };
+
+            object[] booleanValues =
+            {
+                true, false
+            };
+
+
+            object[] stringValues =
+            {
+                AnyInstance.AnyString, AnyInstance.AnyChar, 
+                AnyInstance.AnyDateTime, AnyInstance.AnyDateTimeOffset,
+                AnyInstance.AnyGuid, AnyInstance.AnyUri
+            };
+
+            CheckValues(numberValues, JsonType.Number);
+            CheckValues(booleanValues, JsonType.Boolean);
+            CheckValues(stringValues, JsonType.String);
+        }
+
+        [Fact]
+        public void TryCreateInvalidTest()
+        {
+            bool success;
+            JsonPrimitive target;
+
+            object[] values =
+            {
+                AnyInstance.AnyJsonArray, AnyInstance.AnyJsonObject, AnyInstance.AnyJsonPrimitive, 
+                null, AnyInstance.DefaultJsonValue, AnyInstance.AnyDynamic, AnyInstance.AnyAddress,
+                AnyInstance.AnyPerson
+            };
+
+            foreach (object value in values)
+            {
+                success = JsonPrimitive.TryCreate(value, out target);
+                Assert.False(success);
+                Assert.Null(target);
+            }
+        }
+
+        [Fact]
+        public void NumberToNumberConversionTest()
+        {
+            long longValue;
+            Assert.Equal((long)AnyInstance.AnyInt, (long)(new JsonPrimitive(AnyInstance.AnyInt)));
+            Assert.Equal((long)AnyInstance.AnyUInt, (long)(new JsonPrimitive(AnyInstance.AnyUInt)));
+            Assert.True(new JsonPrimitive(AnyInstance.AnyInt).TryReadAs<long>(out longValue));
+            Assert.Equal((long)AnyInstance.AnyInt, longValue);
+
+            int intValue;
+            Assert.Equal((int)AnyInstance.AnyShort, (int)(new JsonPrimitive(AnyInstance.AnyShort)));
+            Assert.Equal((int)AnyInstance.AnyUShort, (int)(new JsonPrimitive(AnyInstance.AnyUShort)));
+            Assert.True(new JsonPrimitive(AnyInstance.AnyUShort).TryReadAs<int>(out intValue));
+            Assert.Equal((int)AnyInstance.AnyUShort, intValue);
+
+            short shortValue;
+            Assert.Equal((short)AnyInstance.AnyByte, (short)(new JsonPrimitive(AnyInstance.AnyByte)));
+            Assert.Equal((short)AnyInstance.AnySByte, (short)(new JsonPrimitive(AnyInstance.AnySByte)));
+            Assert.True(new JsonPrimitive(AnyInstance.AnyByte).TryReadAs<short>(out shortValue));
+            Assert.Equal((short)AnyInstance.AnyByte, shortValue);
+
+            double dblValue;
+            Assert.Equal((double)AnyInstance.AnyFloat, (double)(new JsonPrimitive(AnyInstance.AnyFloat)));
+            Assert.Equal((double)AnyInstance.AnyDecimal, (double)(new JsonPrimitive(AnyInstance.AnyDecimal)));
+            Assert.True(new JsonPrimitive(AnyInstance.AnyFloat).TryReadAs<double>(out dblValue));
+            Assert.Equal((double)AnyInstance.AnyFloat, dblValue);
+            ExceptionHelper.Throws<OverflowException>(delegate { int i = (int)(new JsonPrimitive(1L << 32)); });
+            Assert.False(new JsonPrimitive(1L << 32).TryReadAs<int>(out intValue));
+            Assert.Equal(default(int), intValue);
+
+            byte byteValue;
+            ExceptionHelper.Throws<OverflowException>(delegate { byte b = (byte)(new JsonPrimitive(1L << 32)); });
+            ExceptionHelper.Throws<OverflowException>(delegate { byte b = (byte)(new JsonPrimitive(SByte.MinValue)); });
+            Assert.False(new JsonPrimitive(SByte.MinValue).TryReadAs<byte>(out byteValue));
+            Assert.Equal(default(byte), byteValue);
+        }
+
+        [Fact]
+        public void NumberToStringConverstionTest()
+        {
+            Dictionary<string, JsonPrimitive> allNumbers = new Dictionary<string, JsonPrimitive>
+            {
+                { AnyInstance.AnyByte.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyByte) },
+                { AnyInstance.AnySByte.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnySByte) },
+                { AnyInstance.AnyShort.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyShort) },
+                { AnyInstance.AnyUShort.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyUShort) },
+                { AnyInstance.AnyInt.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyInt) },
+                { AnyInstance.AnyUInt.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyUInt) },
+                { AnyInstance.AnyLong.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyLong) },
+                { AnyInstance.AnyULong.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyULong) },
+                { AnyInstance.AnyDecimal.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyDecimal) },
+                { AnyInstance.AnyDouble.ToString("R", CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyDouble) },
+                { AnyInstance.AnyFloat.ToString("R", CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyFloat) },
+            };
+
+            foreach (string stringRepresentation in allNumbers.Keys)
+            {
+                JsonPrimitive jp = allNumbers[stringRepresentation];
+                Assert.Equal(stringRepresentation, (string)jp);
+                Assert.Equal(stringRepresentation, jp.ReadAs<string>());
+            }
+        }
+
+        [Fact]
+        public void NonNumberToStringConversionTest()
+        {
+            Dictionary<string, JsonPrimitive> allValues = new Dictionary<string, JsonPrimitive>
+            {
+                { new string(AnyInstance.AnyChar, 1), new JsonPrimitive(AnyInstance.AnyChar) },
+                { AnyInstance.AnyBool.ToString(CultureInfo.InvariantCulture).ToLowerInvariant(), new JsonPrimitive(AnyInstance.AnyBool) },
+                { AnyInstance.AnyGuid.ToString("D", CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyGuid) },
+                { AnyInstance.AnyDateTime.ToString(DateTimeFormat, CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyDateTime) },
+                { AnyInstance.AnyDateTimeOffset.ToString(DateTimeFormat, CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyDateTimeOffset) },
+            };
+
+            foreach (char escapedChar in "\r\n\t\u0000\uffff\u001f\\\"")
+            {
+                allValues.Add(new string(escapedChar, 1), new JsonPrimitive(escapedChar));
+            }
+
+            foreach (string stringRepresentation in allValues.Keys)
+            {
+                JsonPrimitive jp = allValues[stringRepresentation];
+                Assert.Equal(stringRepresentation, (string)jp);
+                Assert.Equal(stringRepresentation, jp.ReadAs<string>());
+            }
+        }
+
+        [Fact]
+        public void NonNumberToNumberConversionTest()
+        {
+            Assert.Equal(1, new JsonPrimitive('1').ReadAs<int>());
+            Assert.Equal<byte>(AnyInstance.AnyByte, new JsonPrimitive(AnyInstance.AnyByte.ToString(CultureInfo.InvariantCulture)).ReadAs<byte>());
+            Assert.Equal<sbyte>(AnyInstance.AnySByte, (sbyte)(new JsonPrimitive(AnyInstance.AnySByte.ToString(CultureInfo.InvariantCulture))));
+            Assert.Equal<short>(AnyInstance.AnyShort, (short)(new JsonPrimitive(AnyInstance.AnyShort.ToString(CultureInfo.InvariantCulture))));
+            Assert.Equal<ushort>(AnyInstance.AnyUShort, new JsonPrimitive(AnyInstance.AnyUShort.ToString(CultureInfo.InvariantCulture)).ReadAs<ushort>());
+            Assert.Equal<int>(AnyInstance.AnyInt, new JsonPrimitive(AnyInstance.AnyInt.ToString(CultureInfo.InvariantCulture)).ReadAs<int>());
+            Assert.Equal<uint>(AnyInstance.AnyUInt, (uint)(new JsonPrimitive(AnyInstance.AnyUInt.ToString(CultureInfo.InvariantCulture))));
+            Assert.Equal<long>(AnyInstance.AnyLong, (long)(new JsonPrimitive(AnyInstance.AnyLong.ToString(CultureInfo.InvariantCulture))));
+            Assert.Equal<ulong>(AnyInstance.AnyULong, new JsonPrimitive(AnyInstance.AnyULong.ToString(CultureInfo.InvariantCulture)).ReadAs<ulong>());
+
+            Assert.Equal<decimal>(AnyInstance.AnyDecimal, (decimal)(new JsonPrimitive(AnyInstance.AnyDecimal.ToString(CultureInfo.InvariantCulture))));
+            Assert.Equal<float>(AnyInstance.AnyFloat, new JsonPrimitive(AnyInstance.AnyFloat.ToString(CultureInfo.InvariantCulture)).ReadAs<float>());
+            Assert.Equal<double>(AnyInstance.AnyDouble, (double)(new JsonPrimitive(AnyInstance.AnyDouble.ToString(CultureInfo.InvariantCulture))));
+
+            Assert.Equal<byte>(Convert.ToByte(1.23, CultureInfo.InvariantCulture), new JsonPrimitive("1.23").ReadAs<byte>());
+            Assert.Equal<int>(Convert.ToInt32(12345.6789, CultureInfo.InvariantCulture), new JsonPrimitive("12345.6789").ReadAs<int>());
+            Assert.Equal<short>(Convert.ToInt16(1.23e2), (short)new JsonPrimitive("1.23e2"));
+            Assert.Equal<float>(Convert.ToSingle(1.23e40), (float)new JsonPrimitive("1.23e40"));
+            Assert.Equal<float>(Convert.ToSingle(1.23e-38), (float)new JsonPrimitive("1.23e-38"));
+
+            ExceptionHelper.Throws<InvalidCastException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyBool).ReadAs<sbyte>(); });
+            ExceptionHelper.Throws<InvalidCastException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyBool).ReadAs<short>(); });
+            ExceptionHelper.Throws<InvalidCastException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyBool).ReadAs<uint>(); });
+            ExceptionHelper.Throws<InvalidCastException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyBool).ReadAs<long>(); });
+            ExceptionHelper.Throws<InvalidCastException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyBool).ReadAs<double>(); });
+
+            ExceptionHelper.Throws<FormatException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyUri).ReadAs<int>(); });
+            ExceptionHelper.Throws<FormatException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyDateTime).ReadAs<float>(); });
+            ExceptionHelper.Throws<InvalidCastException>(delegate { var n = (decimal)(new JsonPrimitive('c')); });
+            ExceptionHelper.Throws<InvalidCastException>(delegate { var n = (byte)(new JsonPrimitive("0xFF")); });
+            ExceptionHelper.Throws<InvalidCastException>(delegate { var n = (sbyte)(new JsonPrimitive(AnyInstance.AnyDateTimeOffset)); });
+            ExceptionHelper.Throws<FormatException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyUri).ReadAs<uint>(); });
+            ExceptionHelper.Throws<FormatException>(delegate { var n = new JsonPrimitive(AnyInstance.AnyDateTime).ReadAs<double>(); });
+            ExceptionHelper.Throws<InvalidCastException>(delegate { var n = (long)(new JsonPrimitive('c')); });
+            ExceptionHelper.Throws<InvalidCastException>(delegate { var n = (ulong)(new JsonPrimitive("0xFF")); });
+            ExceptionHelper.Throws<InvalidCastException>(delegate { var n = (short)(new JsonPrimitive(AnyInstance.AnyDateTimeOffset)); });
+            ExceptionHelper.Throws<InvalidCastException>(delegate { var n = (ushort)(new JsonPrimitive('c')); });
+
+            ExceptionHelper.Throws<OverflowException>(delegate { int i = (int)new JsonPrimitive((1L << 32).ToString(CultureInfo.InvariantCulture)); });
+            ExceptionHelper.Throws<OverflowException>(delegate { byte b = (byte)new JsonPrimitive("-1"); });
+        }
+
+        [Fact]
+        public void StringToNonNumberConversionTest()
+        {
+            const string DateTimeWithOffsetFormat = "yyyy-MM-ddTHH:mm:sszzz";
+            const string DateTimeWithOffsetFormat2 = "yyy-MM-ddTHH:mm:ss.fffK";
+            const string DateTimeWithoutOffsetWithoutTimeFormat = "yyy-MM-dd";
+            const string DateTimeWithoutOffsetFormat = "yyy-MM-ddTHH:mm:ss";
+            const string DateTimeWithoutOffsetFormat2 = "yyy-MM-ddTHH:mm:ss.fff";
+            const string TimeWithoutOffsetFormat = "HH:mm:ss";
+            const string TimeWithoutOffsetFormat2 = "HH:mm";
+
+            Assert.Equal(false, new JsonPrimitive("false").ReadAs<bool>());
+            Assert.Equal(false, (bool)(new JsonPrimitive("False")));
+            Assert.Equal(true, (bool)(new JsonPrimitive("true")));
+            Assert.Equal(true, new JsonPrimitive("True").ReadAs<bool>());
+
+            Assert.Equal<Uri>(AnyInstance.AnyUri, new JsonPrimitive(AnyInstance.AnyUri.ToString()).ReadAs<Uri>());
+            Assert.Equal<char>(AnyInstance.AnyChar, (char)(new JsonPrimitive(new string(AnyInstance.AnyChar, 1))));
+            Assert.Equal<Guid>(AnyInstance.AnyGuid, (Guid)(new JsonPrimitive(AnyInstance.AnyGuid.ToString("D", CultureInfo.InvariantCulture))));
+
+            DateTime anyLocalDateTime = AnyInstance.AnyDateTime.ToLocalTime();
+            DateTime anyUtcDateTime = AnyInstance.AnyDateTime.ToUniversalTime();
+
+            Assert.Equal<DateTime>(anyUtcDateTime, (DateTime)(new JsonPrimitive(anyUtcDateTime.ToString(DateTimeFormat, CultureInfo.InvariantCulture))));
+            Assert.Equal<DateTime>(anyLocalDateTime, new JsonPrimitive(anyLocalDateTime.ToString(DateTimeWithOffsetFormat2, CultureInfo.InvariantCulture)).ReadAs<DateTime>());
+            Assert.Equal<DateTime>(anyUtcDateTime, new JsonPrimitive(anyUtcDateTime.ToString(DateTimeWithOffsetFormat2, CultureInfo.InvariantCulture)).ReadAs<DateTime>());
+            Assert.Equal<DateTime>(anyLocalDateTime.Date, (DateTime)(new JsonPrimitive(anyLocalDateTime.ToString(DateTimeWithoutOffsetWithoutTimeFormat, CultureInfo.InvariantCulture))));
+            Assert.Equal<DateTime>(anyLocalDateTime, new JsonPrimitive(anyLocalDateTime.ToString(DateTimeWithoutOffsetFormat, CultureInfo.InvariantCulture)).ReadAs<DateTime>());
+            Assert.Equal<DateTime>(anyLocalDateTime, new JsonPrimitive(anyLocalDateTime.ToString(DateTimeWithoutOffsetFormat2, CultureInfo.InvariantCulture)).ReadAs<DateTime>());
+
+            DateTime dt = new JsonPrimitive(anyLocalDateTime.ToString(TimeWithoutOffsetFormat, CultureInfo.InvariantCulture)).ReadAs<DateTime>();
+            Assert.Equal(anyLocalDateTime.Hour, dt.Hour);
+            Assert.Equal(anyLocalDateTime.Minute, dt.Minute);
+            Assert.Equal(anyLocalDateTime.Second, dt.Second);
+
+            dt = new JsonPrimitive(anyLocalDateTime.ToString(TimeWithoutOffsetFormat2, CultureInfo.InvariantCulture)).ReadAs<DateTime>();
+            Assert.Equal(anyLocalDateTime.Hour, dt.Hour);
+            Assert.Equal(anyLocalDateTime.Minute, dt.Minute);
+            Assert.Equal(0, dt.Second);
+
+            Assert.Equal<DateTimeOffset>(AnyInstance.AnyDateTimeOffset, new JsonPrimitive(AnyInstance.AnyDateTimeOffset.ToString(DateTimeFormat, CultureInfo.InvariantCulture)).ReadAs<DateTimeOffset>());
+            Assert.Equal<DateTimeOffset>(AnyInstance.AnyDateTimeOffset, new JsonPrimitive(AnyInstance.AnyDateTimeOffset.ToString(DateTimeWithOffsetFormat, CultureInfo.InvariantCulture)).ReadAs<DateTimeOffset>());
+            Assert.Equal<DateTimeOffset>(AnyInstance.AnyDateTimeOffset, new JsonPrimitive(AnyInstance.AnyDateTimeOffset.ToString(DateTimeWithOffsetFormat2, CultureInfo.InvariantCulture)).ReadAs<DateTimeOffset>());
+            Assert.Equal<DateTimeOffset>(AnyInstance.AnyDateTimeOffset.ToLocalTime(), (DateTimeOffset)(new JsonPrimitive(AnyInstance.AnyDateTimeOffset.ToLocalTime().ToString(DateTimeWithoutOffsetFormat, CultureInfo.InvariantCulture))));
+            Assert.Equal<DateTimeOffset>(AnyInstance.AnyDateTimeOffset.ToLocalTime(), (DateTimeOffset)(new JsonPrimitive(AnyInstance.AnyDateTimeOffset.ToLocalTime().ToString(DateTimeWithoutOffsetFormat2, CultureInfo.InvariantCulture))));
+
+            DataContractJsonSerializer dcjs = new DataContractJsonSerializer(typeof(DateTime));
+            MemoryStream ms = new MemoryStream();
+            dcjs.WriteObject(ms, AnyInstance.AnyDateTime);
+            string dcjsSerializedDateTime = Encoding.UTF8.GetString(ms.ToArray());
+            Assert.Equal(AnyInstance.AnyDateTime, JsonValue.Parse(dcjsSerializedDateTime).ReadAs<DateTime>());
+
+            ExceptionHelper.Throws<InvalidCastException>(delegate { var b = (bool)(new JsonPrimitive("notBool")); });
+            ExceptionHelper.Throws<UriFormatException>(delegate { var u = new JsonPrimitive("not an uri - " + new string('r', 100000)).ReadAs<Uri>(); });
+            ExceptionHelper.Throws<FormatException>(delegate { var date = new JsonPrimitive("not a date time").ReadAs<DateTime>(); });
+            ExceptionHelper.Throws<InvalidCastException>(delegate { var dto = (DateTimeOffset)(new JsonPrimitive("not a date time offset")); });
+            ExceptionHelper.Throws<InvalidCastException>(delegate { var c = (char)new JsonPrimitive(""); });
+            ExceptionHelper.Throws<InvalidCastException>(delegate { var c = (char)new JsonPrimitive("cc"); });
+            ExceptionHelper.Throws<FormatException>(delegate { var g = new JsonPrimitive("not a guid").ReadAs<Guid>(); });
+        }
+
+        [Fact]
+        public void AspNetDateTimeFormatConversionTest()
+        {
+            DateTime unixEpochUtc = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+            DateTime unixEpochLocal = unixEpochUtc.ToLocalTime();
+            Assert.Equal(unixEpochUtc, new JsonPrimitive("/Date(0)/").ReadAs<DateTime>());
+            Assert.Equal(unixEpochLocal, new JsonPrimitive("/Date(0-0900)/").ReadAs<DateTime>());
+            Assert.Equal(unixEpochLocal, new JsonPrimitive("/Date(0+1000)/").ReadAs<DateTime>());
+        }
+
+        [Fact]
+        public void ToStringTest()
+        {
+            char anyUnescapedChar = 'c';
+            string anyUnescapedString = "hello";
+
+            Dictionary<string, JsonPrimitive> toStringResults = new Dictionary<string, JsonPrimitive>
+            {
+                // Boolean types
+                { AnyInstance.AnyBool.ToString(CultureInfo.InvariantCulture).ToLowerInvariant(), new JsonPrimitive(AnyInstance.AnyBool) },
+
+                // Numeric types
+                { AnyInstance.AnyByte.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyByte) },
+                { AnyInstance.AnySByte.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnySByte) },
+                { AnyInstance.AnyShort.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyShort) },
+                { AnyInstance.AnyUShort.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyUShort) },
+                { AnyInstance.AnyInt.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyInt) },
+                { AnyInstance.AnyUInt.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyUInt) },
+                { AnyInstance.AnyLong.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyLong) },
+                { AnyInstance.AnyULong.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyULong) },
+                { AnyInstance.AnyFloat.ToString("R", CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyFloat) },
+                { AnyInstance.AnyDouble.ToString("R", CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyDouble) },
+                { AnyInstance.AnyDecimal.ToString(CultureInfo.InvariantCulture), new JsonPrimitive(AnyInstance.AnyDecimal) },
+
+                // String types
+                { "\"" + new string(anyUnescapedChar, 1) + "\"", new JsonPrimitive(anyUnescapedChar) },
+                { "\"" + anyUnescapedString + "\"", new JsonPrimitive(anyUnescapedString) },
+                { "\"" + AnyInstance.AnyDateTime.ToString(DateTimeFormat, CultureInfo.InvariantCulture) + "\"", new JsonPrimitive(AnyInstance.AnyDateTime) },
+                { "\"" + AnyInstance.AnyDateTimeOffset.ToString(DateTimeFormat, CultureInfo.InvariantCulture) + "\"", new JsonPrimitive(AnyInstance.AnyDateTimeOffset) },
+                { "\"" + AnyInstance.AnyUri.GetComponents(UriComponents.SerializationInfoString, UriFormat.UriEscaped).Replace("/", "\\/") + "\"", new JsonPrimitive(AnyInstance.AnyUri) },
+                { "\"" + AnyInstance.AnyGuid.ToString("D", CultureInfo.InvariantCulture) + "\"", new JsonPrimitive(AnyInstance.AnyGuid) },
+            };
+
+            foreach (string stringRepresentation in toStringResults.Keys)
+            {
+                string actualResult = toStringResults[stringRepresentation].ToString();
+                Assert.Equal(stringRepresentation, actualResult);
+            }
+
+            Dictionary<string, JsonPrimitive> escapedValues = new Dictionary<string, JsonPrimitive>
+            {
+                { "\"\\u000d\"", new JsonPrimitive('\r') },
+                { "\"\\u000a\"", new JsonPrimitive('\n') },
+                { "\"\\\\\"", new JsonPrimitive('\\') },
+                { "\"\\/\"", new JsonPrimitive('/') },
+                { "\"\\u000b\"", new JsonPrimitive('\u000b') },
+                { "\"\\\"\"", new JsonPrimitive('\"') },
+                { "\"slash-r-\\u000d-fffe-\\ufffe-ffff-\\uffff-tab-\\u0009\"", new JsonPrimitive("slash-r-\r-fffe-\ufffe-ffff-\uffff-tab-\t") },
+            };
+
+            foreach (string stringRepresentation in escapedValues.Keys)
+            {
+                string actualResult = escapedValues[stringRepresentation].ToString();
+                Assert.Equal(stringRepresentation, actualResult);
+            }
+        }
+
+        [Fact]
+        public void JsonTypeTest()
+        {
+            Assert.Equal(JsonType.Boolean, new JsonPrimitive(AnyInstance.AnyBool).JsonType);
+            Assert.Equal(JsonType.Number, new JsonPrimitive(AnyInstance.AnyByte).JsonType);
+            Assert.Equal(JsonType.Number, new JsonPrimitive(AnyInstance.AnySByte).JsonType);
+            Assert.Equal(JsonType.Number, new JsonPrimitive(AnyInstance.AnyShort).JsonType);
+            Assert.Equal(JsonType.Number, new JsonPrimitive(AnyInstance.AnyUShort).JsonType);
+            Assert.Equal(JsonType.Number, new JsonPrimitive(AnyInstance.AnyInt).JsonType);
+            Assert.Equal(JsonType.Number, new JsonPrimitive(AnyInstance.AnyUInt).JsonType);
+            Assert.Equal(JsonType.Number, new JsonPrimitive(AnyInstance.AnyLong).JsonType);
+            Assert.Equal(JsonType.Number, new JsonPrimitive(AnyInstance.AnyULong).JsonType);
+            Assert.Equal(JsonType.Number, new JsonPrimitive(AnyInstance.AnyDecimal).JsonType);
+            Assert.Equal(JsonType.Number, new JsonPrimitive(AnyInstance.AnyDouble).JsonType);
+            Assert.Equal(JsonType.Number, new JsonPrimitive(AnyInstance.AnyFloat).JsonType);
+            Assert.Equal(JsonType.String, new JsonPrimitive(AnyInstance.AnyChar).JsonType);
+            Assert.Equal(JsonType.String, new JsonPrimitive(AnyInstance.AnyString).JsonType);
+            Assert.Equal(JsonType.String, new JsonPrimitive(AnyInstance.AnyUri).JsonType);
+            Assert.Equal(JsonType.String, new JsonPrimitive(AnyInstance.AnyGuid).JsonType);
+            Assert.Equal(JsonType.String, new JsonPrimitive(AnyInstance.AnyDateTime).JsonType);
+            Assert.Equal(JsonType.String, new JsonPrimitive(AnyInstance.AnyDateTimeOffset).JsonType);
+        }
+
+        [Fact]
+        public void InvalidPropertyTest()
+        {
+            JsonValue target = AnyInstance.AnyJsonPrimitive;
+            Assert.True(target.Count == 0);
+            Assert.False(target.ContainsKey(String.Empty));
+            Assert.False(target.ContainsKey(AnyInstance.AnyString));
+        }
+
+        private void CheckValues(object[] values, JsonType expectedType)
+        {
+            JsonPrimitive target;
+            bool success;
+
+            foreach (object value in values)
+            {
+                success = JsonPrimitive.TryCreate(value, out target);
+                Assert.True(success);
+                Assert.NotNull(target);
+                Assert.Equal(expectedType, target.JsonType);
+            }
+        }
+    }
+}

external/aspnetwebstack/test/System.Json.Test.Unit/JsonTypeTest.cs

@@ -0,0 +1,28 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace System.Json
+{
+    public class JsonTypeTest
+    {
+        [Fact]
+        public void JsonTypeValues()
+        {
+            string[] allJsonTypeExpectedValues = new string[] { "Array", "Boolean", "Default", "Number", "Object", "String" };
+            JsonType[] allJsonTypeActualValues = (JsonType[])Enum.GetValues(typeof(JsonType));
+
+            Assert.Equal(allJsonTypeExpectedValues.Length, allJsonTypeActualValues.Length);
+
+            List<string> allJsonTypeActualStringValues = new List<string>(allJsonTypeActualValues.Select((x) => x.ToString()));
+            allJsonTypeActualStringValues.Sort(StringComparer.Ordinal);
+
+            for (int i = 0; i < allJsonTypeExpectedValues.Length; i++)
+            {
+                Assert.Equal(allJsonTypeExpectedValues[i], allJsonTypeActualStringValues[i]);
+            }
+        }
+    }
+}

external/aspnetwebstack/test/System.Json.Test.Unit/JsonValueDynamicTest.cs

@@ -0,0 +1,470 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Dynamic;
+using System.Runtime.Serialization.Json;
+using Xunit;
+
+namespace System.Json
+{
+    public class JsonValueDynamicTest
+    {
+        const string InvalidIndexType = "Invalid '{0}' index type; only 'System.String' and non-negative 'System.Int32' types are supported.";
+        const string NonSingleNonNullIndexNotSupported = "Null index or multidimensional indexing is not supported by this indexer; use 'System.Int32' or 'System.String' for array and object indexing respectively.";
+
+        [Fact]
+        public void SettingDifferentValueTypes()
+        {
+            dynamic dyn = new JsonObject();
+            dyn.boolean = AnyInstance.AnyBool;
+            dyn.int16 = AnyInstance.AnyShort;
+            dyn.int32 = AnyInstance.AnyInt;
+            dyn.int64 = AnyInstance.AnyLong;
+            dyn.uint16 = AnyInstance.AnyUShort;
+            dyn.uint32 = AnyInstance.AnyUInt;
+            dyn.uint64 = AnyInstance.AnyULong;
+            dyn.@char = AnyInstance.AnyChar;
+            dyn.dbl = AnyInstance.AnyDouble;
+            dyn.flt = AnyInstance.AnyFloat;
+            dyn.dec = AnyInstance.AnyDecimal;
+            dyn.str = AnyInstance.AnyString;
+            dyn.uri = AnyInstance.AnyUri;
+            dyn.@byte = AnyInstance.AnyByte;
+            dyn.@sbyte = AnyInstance.AnySByte;
+            dyn.guid = AnyInstance.AnyGuid;
+            dyn.dateTime = AnyInstance.AnyDateTime;
+            dyn.dateTimeOffset = AnyInstance.AnyDateTimeOffset;
+            dyn.JsonArray = AnyInstance.AnyJsonArray;
+            dyn.JsonPrimitive = AnyInstance.AnyJsonPrimitive;
+            dyn.JsonObject = AnyInstance.AnyJsonObject;
+
+            JsonObject jo = (JsonObject)dyn;
+            Assert.Equal(AnyInstance.AnyBool, (bool)jo["boolean"]);
+            Assert.Equal(AnyInstance.AnyShort, (short)jo["int16"]);
+            Assert.Equal(AnyInstance.AnyUShort, (ushort)jo["uint16"]);
+            Assert.Equal(AnyInstance.AnyInt, (int)jo["int32"]);
+            Assert.Equal(AnyInstance.AnyUInt, (uint)jo["uint32"]);
+            Assert.Equal(AnyInstance.AnyLong, (long)jo["int64"]);
+            Assert.Equal(AnyInstance.AnyULong, (ulong)jo["uint64"]);
+            Assert.Equal(AnyInstance.AnySByte, (sbyte)jo["sbyte"]);
+            Assert.Equal(AnyInstance.AnyByte, (byte)jo["byte"]);
+            Assert.Equal(AnyInstance.AnyChar, (char)jo["char"]);
+            Assert.Equal(AnyInstance.AnyDouble, (double)jo["dbl"]);
+            Assert.Equal(AnyInstance.AnyFloat, (float)jo["flt"]);
+            Assert.Equal(AnyInstance.AnyDecimal, (decimal)jo["dec"]);
+            Assert.Equal(AnyInstance.AnyString, (string)jo["str"]);
+            Assert.Equal(AnyInstance.AnyUri, (Uri)jo["uri"]);
+            Assert.Equal(AnyInstance.AnyGuid, (Guid)jo["guid"]);
+            Assert.Equal(AnyInstance.AnyDateTime, (DateTime)jo["dateTime"]);
+            Assert.Equal(AnyInstance.AnyDateTimeOffset, (DateTimeOffset)jo["dateTimeOffset"]);
+            Assert.Same(AnyInstance.AnyJsonArray, jo["JsonArray"]);
+            Assert.Equal(AnyInstance.AnyJsonPrimitive, jo["JsonPrimitive"]);
+            Assert.Same(AnyInstance.AnyJsonObject, jo["JsonObject"]);
+
+            Assert.Equal(AnyInstance.AnyBool, (bool)dyn.boolean);
+            Assert.Equal(AnyInstance.AnyShort, (short)dyn.int16);
+            Assert.Equal(AnyInstance.AnyUShort, (ushort)dyn.uint16);
+            Assert.Equal(AnyInstance.AnyInt, (int)dyn.int32);
+            Assert.Equal(AnyInstance.AnyUInt, (uint)dyn.uint32);
+            Assert.Equal(AnyInstance.AnyLong, (long)dyn.int64);
+            Assert.Equal(AnyInstance.AnyULong, (ulong)dyn.uint64);
+            Assert.Equal(AnyInstance.AnySByte, (sbyte)dyn.@sbyte);
+            Assert.Equal(AnyInstance.AnyByte, (byte)dyn.@byte);
+            Assert.Equal(AnyInstance.AnyChar, (char)dyn.@char);
+            Assert.Equal(AnyInstance.AnyDouble, (double)dyn.dbl);
+            Assert.Equal(AnyInstance.AnyFloat, (float)dyn.flt);
+            Assert.Equal(AnyInstance.AnyDecimal, (decimal)dyn.dec);
+            Assert.Equal(AnyInstance.AnyString, (string)dyn.str);
+            Assert.Equal(AnyInstance.AnyUri, (Uri)dyn.uri);
+            Assert.Equal(AnyInstance.AnyGuid, (Guid)dyn.guid);
+            Assert.Equal(AnyInstance.AnyDateTime, (DateTime)dyn.dateTime);
+            Assert.Equal(AnyInstance.AnyDateTimeOffset, (DateTimeOffset)dyn.dateTimeOffset);
+            Assert.Same(AnyInstance.AnyJsonArray, dyn.JsonArray);
+            Assert.Equal(AnyInstance.AnyJsonPrimitive, dyn.JsonPrimitive);
+            Assert.Same(AnyInstance.AnyJsonObject, dyn.JsonObject);
+
+            ExceptionHelper.Throws<ArgumentException>(delegate { dyn.other = Console.Out; });
+            ExceptionHelper.Throws<ArgumentException>(delegate { dyn.other = dyn.NonExistentProp; });
+        }
+
+        [Fact]
+        public void NullTests()
+        {
+            dynamic dyn = new JsonObject();
+            JsonObject jo = (JsonObject)dyn;
+
+            dyn.@null = null;
+            Assert.Same(dyn.@null, AnyInstance.DefaultJsonValue);
+
+            jo["@null"] = null;
+            Assert.Null(jo["@null"]);
+        }
+
+        [Fact]
+        public void DynamicNotationTest()
+        {
+            bool boolValue;
+            JsonValue jsonValue;
+
+            Person person = Person.CreateSample();
+            dynamic jo = JsonValueExtensions.CreateFrom(person);
+
+            dynamic target = jo;
+            Assert.Equal<int>(person.Age, target.Age.ReadAs<int>()); // JsonPrimitive
+            Assert.Equal<string>(person.Address.ToString(), ((JsonObject)target.Address).ReadAsType<Address>().ToString()); // JsonObject
+
+            target = jo.Address.City;  // JsonPrimitive
+            Assert.NotNull(target);
+            Assert.Equal<string>(target.ReadAs<string>(), person.Address.City);
+
+            target = jo.Friends;  // JsonArray
+            Assert.NotNull(target);
+            jsonValue = target as JsonValue;
+            Assert.Equal<int>(person.Friends.Count, jsonValue.ReadAsType<List<Person>>().Count);
+
+            target = jo.Friends[1].Address.City;
+            Assert.NotNull(target);
+            Assert.Equal<string>(target.ReadAs<string>(), person.Address.City);
+
+            target = jo.Address.NonExistentProp.NonExistentProp2; // JsonObject (default)
+            Assert.NotNull(target);
+            Assert.True(jo is JsonObject);
+            Assert.False(target.TryReadAs<bool>(out boolValue));
+            Assert.True(target.TryReadAs<JsonValue>(out jsonValue));
+            Assert.Same(target, jsonValue);
+
+            Assert.Same(jo.Address.NonExistent, AnyInstance.DefaultJsonValue);
+            Assert.Same(jo.Friends[1000], AnyInstance.DefaultJsonValue);
+            Assert.Same(jo.Age.NonExistentProp, AnyInstance.DefaultJsonValue);
+            Assert.Same(jo.Friends.NonExistentProp, AnyInstance.DefaultJsonValue);
+        }
+
+        [Fact]
+        public void PropertyAccessTest()
+        {
+            Person p = AnyInstance.AnyPerson;
+            JsonObject jo = JsonValueExtensions.CreateFrom(p) as JsonObject;
+            JsonArray ja = JsonValueExtensions.CreateFrom(p.Friends) as JsonArray;
+            JsonPrimitive jp = AnyInstance.AnyJsonPrimitive;
+            JsonValue jv = AnyInstance.DefaultJsonValue;
+
+            dynamic jod = jo;
+            dynamic jad = ja;
+            dynamic jpd = jp;
+            dynamic jvd = jv;
+
+            Assert.Equal(jo.Count, jod.Count);
+            Assert.Equal(jo.JsonType, jod.JsonType);
+            Assert.Equal(jo.Keys.Count, jod.Keys.Count);
+            Assert.Equal(jo.Values.Count, jod.Values.Count);
+            Assert.Equal(p.Age, (int)jod.Age);
+            Assert.Equal(p.Age, (int)jod["Age"]);
+            Assert.Equal(p.Age, (int)jo["Age"]);
+            Assert.Equal(p.Address.City, (string)jo["Address"]["City"]);
+            Assert.Equal(p.Address.City, (string)jod["Address"]["City"]);
+            Assert.Equal(p.Address.City, (string)jod.Address.City);
+
+            Assert.Equal(p.Friends.Count, ja.Count);
+            Assert.Equal(ja.Count, jad.Count);
+            Assert.Equal(ja.IsReadOnly, jad.IsReadOnly);
+            Assert.Equal(ja.JsonType, jad.JsonType);
+            Assert.Equal(p.Friends[0].Age, (int)ja[0]["Age"]);
+            Assert.Equal(p.Friends[0].Age, (int)jad[0].Age);
+
+            Assert.Equal(jp.JsonType, jpd.JsonType);
+        }
+
+        [Fact]
+        public void ConcatDynamicAssignmentTest()
+        {
+            string value = "MyValue";
+            dynamic dynArray = JsonValue.Parse(AnyInstance.AnyJsonArray.ToString());
+            dynamic dynObj = JsonValue.Parse(AnyInstance.AnyJsonObject.ToString());
+
+            JsonValue target;
+
+            target = dynArray[0] = dynArray[1] = dynArray[2] = value;
+            Assert.Equal((string)target, value);
+            Assert.Equal((string)dynArray[0], value);
+            Assert.Equal((string)dynArray[1], value);
+            Assert.Equal((string)dynArray[2], value);
+
+            target = dynObj["key0"] = dynObj["key1"] = dynObj["key2"] = value;
+            Assert.Equal((string)target, value);
+            Assert.Equal((string)dynObj["key0"], value);
+            Assert.Equal((string)dynObj["key1"], value);
+            Assert.Equal((string)dynObj["key2"], value);
+            foreach (KeyValuePair<string, JsonValue> pair in AnyInstance.AnyJsonObject)
+            {
+                Assert.Equal<string>(AnyInstance.AnyJsonObject[pair.Key].ToString(), dynObj[pair.Key].ToString());
+            }
+        }
+
+        [Fact]
+        public void IndexConversionTest()
+        {
+            dynamic target = AnyInstance.AnyJsonArray;
+            dynamic expected = AnyInstance.AnyJsonArray[0];
+            dynamic result;
+
+            dynamic[] zero_indexes = 
+            {
+                (short)0,
+                (ushort)0,
+                (byte)0,
+                (sbyte)0,
+                (char)0,
+                (int)0
+            };
+
+
+            result = target[(short)0];
+            Assert.Same(expected, result);
+            result = target[(ushort)0];
+            Assert.Same(expected, result);
+            result = target[(byte)0];
+            Assert.Same(expected, result);
+            result = target[(sbyte)0];
+            Assert.Same(expected, result);
+            result = target[(char)0];
+            Assert.Same(expected, result);
+
+            foreach (dynamic zero_index in zero_indexes)
+            {
+                result = target[zero_index];
+                Assert.Same(expected, result);
+            }
+        }
+
+        [Fact]
+        public void InvalidIndexTest()
+        {
+            object index1 = new object();
+            bool index2 = true;
+            Person index3 = AnyInstance.AnyPerson;
+            JsonObject jo = AnyInstance.AnyJsonObject;
+
+            dynamic target;
+            object ret;
+
+            JsonValue[] values = { AnyInstance.AnyJsonObject, AnyInstance.AnyJsonArray };
+
+            foreach (JsonValue value in values)
+            {
+                target = value;
+
+                ExceptionHelper.Throws<ArgumentException>(delegate { ret = target[index1]; }, String.Format(InvalidIndexType, index1.GetType().FullName));
+                ExceptionHelper.Throws<ArgumentException>(delegate { ret = target[index2]; }, String.Format(InvalidIndexType, index2.GetType().FullName));
+                ExceptionHelper.Throws<ArgumentException>(delegate { ret = target[index3]; }, String.Format(InvalidIndexType, index3.GetType().FullName));
+                ExceptionHelper.Throws<ArgumentException>(delegate { ret = target[null]; }, NonSingleNonNullIndexNotSupported);
+
+                ExceptionHelper.Throws<ArgumentException>(delegate { ret = target[0, 1]; }, NonSingleNonNullIndexNotSupported);
+                ExceptionHelper.Throws<ArgumentException>(delegate { ret = target["key1", "key2"]; }, NonSingleNonNullIndexNotSupported);
+
+                ExceptionHelper.Throws<ArgumentException>(delegate { ret = target[true]; }, String.Format(InvalidIndexType, true.GetType().FullName));
+
+                ExceptionHelper.Throws<ArgumentException>(delegate { target[index1] = jo; }, String.Format(InvalidIndexType, index1.GetType().FullName));
+                ExceptionHelper.Throws<ArgumentException>(delegate { target[index2] = jo; }, String.Format(InvalidIndexType, index2.GetType().FullName));
+                ExceptionHelper.Throws<ArgumentException>(delegate { target[index3] = jo; }, String.Format(InvalidIndexType, index3.GetType().FullName));
+                ExceptionHelper.Throws<ArgumentException>(delegate { target[null] = jo; }, NonSingleNonNullIndexNotSupported);
+
+                ExceptionHelper.Throws<ArgumentException>(delegate { target[0, 1] = jo; }, NonSingleNonNullIndexNotSupported);
+                ExceptionHelper.Throws<ArgumentException>(delegate { target["key1", "key2"] = jo; }, NonSingleNonNullIndexNotSupported);
+
+                ExceptionHelper.Throws<ArgumentException>(delegate { target[true] = jo; }, String.Format(InvalidIndexType, true.GetType().FullName));
+            }
+        }
+
+        [Fact]
+        public void InvalidCastingTests()
+        {
+            dynamic dyn;
+            string value = "NameValue";
+
+            dyn = AnyInstance.AnyJsonPrimitive;
+            ExceptionHelper.Throws<InvalidOperationException>(delegate { dyn.name = value; });
+
+            dyn = AnyInstance.AnyJsonArray;
+            ExceptionHelper.Throws<InvalidOperationException>(delegate { dyn.name = value; });
+
+            dyn = new JsonObject(AnyInstance.AnyJsonObject);
+            dyn.name = value;
+            Assert.Equal((string)dyn.name, value);
+
+            dyn = AnyInstance.DefaultJsonValue;
+            ExceptionHelper.Throws<InvalidOperationException>(delegate { dyn.name = value; });
+        }
+
+        [Fact]
+        public void CastTests()
+        {
+            dynamic dyn = JsonValueExtensions.CreateFrom(AnyInstance.AnyPerson) as JsonObject;
+            string city = dyn.Address.City;
+
+            Assert.Equal<string>(AnyInstance.AnyPerson.Address.City, dyn.Address.City.ReadAs<string>());
+            Assert.Equal<string>(AnyInstance.AnyPerson.Address.City, city);
+
+            JsonValue[] values = 
+            {
+                AnyInstance.AnyInt,
+                AnyInstance.AnyString,
+                AnyInstance.AnyDateTime,
+                AnyInstance.AnyJsonObject,
+                AnyInstance.AnyJsonArray,
+                AnyInstance.DefaultJsonValue 
+            };
+
+            int loopCount = 2;
+            bool explicitCast = true;
+
+            while (loopCount > 0)
+            {
+                loopCount--;
+
+                foreach (JsonValue jv in values)
+                {
+                    EvaluateNoExceptions<JsonValue>(null, explicitCast);
+                    EvaluateNoExceptions<JsonValue>(jv, explicitCast);
+                    EvaluateNoExceptions<object>(jv, explicitCast);
+                    EvaluateNoExceptions<IDynamicMetaObjectProvider>(jv, explicitCast);
+                    EvaluateNoExceptions<IEnumerable<KeyValuePair<string, JsonValue>>>(jv, explicitCast);
+                    EvaluateNoExceptions<string>(null, explicitCast);
+
+                    EvaluateExpectExceptions<int>(null, explicitCast);
+                    EvaluateExpectExceptions<Person>(jv, explicitCast);
+                    EvaluateExpectExceptions<Exception>(jv, explicitCast);
+
+                    EvaluateIgnoreExceptions<JsonObject>(jv, explicitCast);
+                    EvaluateIgnoreExceptions<int>(jv, explicitCast);
+                    EvaluateIgnoreExceptions<string>(jv, explicitCast);
+                    EvaluateIgnoreExceptions<DateTime>(jv, explicitCast);
+                    EvaluateIgnoreExceptions<JsonArray>(jv, explicitCast);
+                    EvaluateIgnoreExceptions<JsonPrimitive>(jv, explicitCast);
+                }
+
+                explicitCast = false;
+            }
+
+            EvaluateNoExceptions<IDictionary<string, JsonValue>>(AnyInstance.AnyJsonObject, false);
+            EvaluateNoExceptions<IList<JsonValue>>(AnyInstance.AnyJsonArray, false);
+        }
+
+        static void EvaluateNoExceptions<T>(JsonValue value, bool cast)
+        {
+            Evaluate<T>(value, cast, false, true);
+        }
+
+        static void EvaluateExpectExceptions<T>(JsonValue value, bool cast)
+        {
+            Evaluate<T>(value, cast, true, true);
+        }
+
+        static void EvaluateIgnoreExceptions<T>(JsonValue value, bool cast)
+        {
+            Evaluate<T>(value, cast, true, false);
+        }
+
+        static void Evaluate<T>(JsonValue value, bool cast, bool throwExpected, bool assertExceptions)
+        {
+            T ret2;
+            object obj = null;
+            bool exceptionThrown = false;
+            string retstr2, retstr1;
+
+            Console.WriteLine("Test info: expected:[{0}], explicitCast type:[{1}]", value, typeof(T));
+
+            try
+            {
+                if (typeof(int) == typeof(T))
+                {
+                    obj = ((int)value);
+                }
+                else if (typeof(string) == typeof(T))
+                {
+                    obj = ((string)value);
+                }
+                else if (typeof(DateTime) == typeof(T))
+                {
+                    obj = ((DateTime)value);
+                }
+                else if (typeof(IList<JsonValue>) == typeof(T))
+                {
+                    obj = (IList<JsonValue>)value;
+                }
+                else if (typeof(IDictionary<string, JsonValue>) == typeof(T))
+                {
+                    obj = (IDictionary<string, JsonValue>)value;
+                }
+                else if (typeof(JsonValue) == typeof(T))
+                {
+                    obj = (JsonValue)value;
+                }
+                else if (typeof(JsonObject) == typeof(T))
+                {
+                    obj = (JsonObject)value;
+                }
+                else if (typeof(JsonArray) == typeof(T))
+                {
+                    obj = (JsonArray)value;
+                }
+                else if (typeof(JsonPrimitive) == typeof(T))
+                {
+                    obj = (JsonPrimitive)value;
+                }
+                else
+                {
+                    obj = (T)(object)value;
+                }
+
+                retstr1 = obj == null ? "null" : obj.ToString();
+            }
+            catch (Exception ex)
+            {
+                exceptionThrown = true;
+                retstr1 = ex.Message;
+            }
+
+            if (assertExceptions)
+            {
+                Assert.Equal<bool>(throwExpected, exceptionThrown);
+            }
+
+            exceptionThrown = false;
+
+            try
+            {
+                dynamic dyn = value as dynamic;
+                if (cast)
+                {
+                    ret2 = (T)dyn;
+                }
+                else
+                {
+                    ret2 = dyn;
+                }
+                retstr2 = ret2 != null ? ret2.ToString() : "null";
+            }
+            catch (Exception ex)
+            {
+                exceptionThrown = true;
+                retstr2 = ex.Message;
+            }
+
+            if (assertExceptions)
+            {
+                Assert.Equal<bool>(throwExpected, exceptionThrown);
+            }
+
+            // fixup string
+            retstr1 = retstr1.Replace("\'Person\'", String.Format("\'{0}\'", typeof(Person).FullName));
+            if (retstr1.EndsWith(".")) retstr1 = retstr1.Substring(0, retstr1.Length - 1);
+
+            // fixup string
+            retstr2 = retstr2.Replace("\'string\'", String.Format("\'{0}\'", typeof(string).FullName));
+            retstr2 = retstr2.Replace("\'int\'", String.Format("\'{0}\'", typeof(int).FullName));
+            if (retstr2.EndsWith(".")) retstr2 = retstr2.Substring(0, retstr2.Length - 1);
+
+            Assert.Equal<string>(retstr1, retstr2);
+        }
+    }
+}

external/aspnetwebstack/test/System.Json.Test.Unit/JsonValueLinqExtensionsTest.cs

@@ -0,0 +1,37 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace System.Json
+{
+    public class JsonValueLinqExtensionsTest
+    {
+        [Fact]
+        public void ToJsonArrayTest()
+        {
+            var target = (new List<int>(new[] { 1, 2, 3 }).Select(i => (JsonValue)i).ToJsonArray());
+            Assert.Equal("[1,2,3]", target.ToString());
+        }
+
+        [Fact]
+        public void ToJsonObjectTest()
+        {
+            JsonValue jv = new JsonObject { { "one", 1 }, { "two", 2 }, { "three", 3 } };
+
+            var result = from n in jv
+                         where n.Value.ReadAs<int>() > 1
+                         select n;
+            Assert.Equal("{\"two\":2,\"three\":3}", result.ToJsonObject().ToString());
+        }
+
+        [Fact]
+        public void ToJsonObjectFromArray()
+        {
+            JsonArray ja = new JsonArray("first", "second");
+            JsonObject jo = ja.ToJsonObject();
+            Assert.Equal("{\"0\":\"first\",\"1\":\"second\"}", jo.ToString());
+        }
+    }
+}

external/aspnetwebstack/test/System.Json.Test.Unit/Properties/AssemblyInfo.cs

@@ -0,0 +1,39 @@
+// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
+
+using System;
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("System.Json.Test.Unit")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Microsoft")]
+[assembly: AssemblyProduct("System.Json.Test.Unit")]
+[assembly: AssemblyCopyright("Copyright © Microsoft 2011")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+[assembly: CLSCompliant(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("2c4d325c-ef22-46b8-92af-79bea6364683")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

external/aspnetwebstack/test/System.Json.Test.Unit/System.Json.Test.Unit.csproj

@@ -0,0 +1,84 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{EB09CD33-992B-4A31-AB95-8673BA90F1CD}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>System.Json.Test</RootNamespace>
+    <AssemblyName>System.Json.Test</AssemblyName>
+    <FileAlignment>512</FileAlignment>
+    <ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>$(WebStackRootPath)\bin\Debug\Test\</OutputPath>
+    <DefineConstants>TRACE;DEBUG</DefineConstants>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>$(WebStackRootPath)\bin\Release\Test\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)' == 'CodeCoverage' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>$(WebStackRootPath)\bin\CodeCoverage\Test\</OutputPath>
+    <DefineConstants>TRACE;DEBUG</DefineConstants>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System" />
+    <Reference Include="System.Runtime.Serialization" />
+    <Reference Include="System.XML" />
+    <Reference Include="xunit">
+      <HintPath>..\..\packages\xunit.1.9.0.1566\lib\xunit.dll</HintPath>
+    </Reference>
+    <Reference Include="xunit.extensions">
+      <HintPath>..\..\packages\xunit.extensions.1.9.0.1566\lib\xunit.extensions.dll</HintPath>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Common\AnyInstance.cs" />
+    <Compile Include="Common\ExceptionTestHelper.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="JsonArrayTest.cs" />
+    <Compile Include="JsonDefaultTest.cs" />
+    <Compile Include="JsonObjectTest.cs" />
+    <Compile Include="JsonPrimitiveTest.cs" />
+    <Compile Include="JsonTypeTest.cs" />
+    <Compile Include="JsonValueDynamicMetaObjectTest.cs" />
+    <Compile Include="JsonValueDynamicTest.cs" />
+    <Compile Include="JsonValueLinqExtensionsTest.cs" />
+    <Compile Include="JsonValueTest.cs" />
+    <Compile Include="Extensions\JsonValueExtensionsTest.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
+      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
+      <Name>Microsoft.TestCommon</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\src\System.Json\System.Json.csproj">
+      <Project>{F0441BE9-BDC0-4629-BE5A-8765FFAA2481}</Project>
+      <Name>System.Json</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+</Project>

external/aspnetwebstack/test/System.Json.Test.Unit/packages.config

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="xunit" version="1.9.0.1566" />
+  <package id="xunit.extensions" version="1.9.0.1566" />
+</packages>