/desktop_clients/Visual Studio/Crear beneficiarios/Json100r3/Source/Src/Newtonsoft.Json.Tests/Serialization/JsonSerializerTest.cs

Large files files are truncated, but you can click here to view the full file

#region License

// Copyright (c) 2007 James Newton-King

//

// Permission is hereby granted, free of charge, to any person

// obtaining a copy of this software and associated documentation

// files (the "Software"), to deal in the Software without

// restriction, including without limitation the rights to use,

// copy, modify, merge, publish, distribute, sublicense, and/or sell

// copies of the Software, and to permit persons to whom the

// Software is furnished to do so, subject to the following

// conditions:

//

// The above copyright notice and this permission notice shall be

// included in all copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES

// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,

// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

// OTHER DEALINGS IN THE SOFTWARE.

#endregion



using System;

using System.ComponentModel;

#if !(NET35 || NET20)

using System.Collections.Concurrent;

#endif

using System.Collections.Generic;

#if !(NET20 || NET35 || PORTABLE) || NETSTANDARD1_3

using System.Numerics;

#endif

#if !(NET20 || DNXCORE50)

using System.ComponentModel.DataAnnotations;

using System.Configuration;

using System.Runtime.CompilerServices;

using System.Runtime.Serialization.Formatters;

using System.Threading;

using System.Web.Script.Serialization;

#endif

using System.Text;

using System.Text.RegularExpressions;

#if DNXCORE50

using Xunit;

using Test = Xunit.FactAttribute;

using Assert = Newtonsoft.Json.Tests.XUnitAssert;

#else

using NUnit.Framework;

#endif

using Newtonsoft.Json;

using System.IO;

using System.Collections;

using System.Xml;

using System.Xml.Serialization;

using System.Collections.ObjectModel;

using System.Diagnostics;

using Newtonsoft.Json.Bson;

using Newtonsoft.Json.Linq;

using Newtonsoft.Json.Converters;

#if !(NET20 || NET35)

using System.Runtime.Serialization.Json;

#endif

using Newtonsoft.Json.Serialization;

using Newtonsoft.Json.Tests.Linq;

using Newtonsoft.Json.Tests.TestObjects;

using Newtonsoft.Json.Tests.TestObjects.Events;

using Newtonsoft.Json.Tests.TestObjects.GeoCoding;

using Newtonsoft.Json.Tests.TestObjects.Organization;

using System.Runtime.Serialization;

using System.Globalization;

using Newtonsoft.Json.Utilities;

using System.Reflection;

#if !NET20

using System.Xml.Linq;

using System.Collections.Specialized;

using System.Linq.Expressions;

#endif

#if !(NET35 || NET20)

using System.Dynamic;

#endif

#if NET20

using Newtonsoft.Json.Utilities.LinqBridge;

using Action = Newtonsoft.Json.Serialization.Action;

#else

using System.Linq;

#endif

#if !(DNXCORE50)

using System.Drawing;



#endif



namespace Newtonsoft.Json.Tests.Serialization

{

    [TestFixture]

    public class JsonSerializerTest : TestFixtureBase

    {

        public class ListSourceTest : IListSource

        {

            private string str;



            public string strprop

            {

                get { return str; }

                set { str = value; }

            }



            [JsonIgnore]

            public bool ContainsListCollection

            {

                get { return false; }

            }



            public IList GetList()

            {

                return new List<string>();

            }

        }



        [Test]

        public void ListSourceSerialize()

        {

            ListSourceTest c = new ListSourceTest();

            c.strprop = "test";

            string json = JsonConvert.SerializeObject(c);



            Assert.AreEqual(@"{""strprop"":""test""}", json);



            ListSourceTest c2 = JsonConvert.DeserializeObject<ListSourceTest>(json);



            Assert.AreEqual("test", c2.strprop);

        }



        public struct ImmutableStruct

        {

            public ImmutableStruct(string value)

            {

                Value = value;

                Value2 = 0;

            }



            public string Value { get; }

            public int Value2 { get; set; }

        }



        [Test]

        public void DeserializeImmutableStruct()

        {

            var result = JsonConvert.DeserializeObject<ImmutableStruct>("{ \"Value\": \"working\", \"Value2\": 2 }");



            Assert.AreEqual("working", result.Value);

            Assert.AreEqual(2, result.Value2);

        }



        public struct AlmostImmutableStruct

        {

            public AlmostImmutableStruct(string value, int value2)

            {

                Value = value;

                Value2 = value2;

            }



            public string Value { get; }

            public int Value2 { get; set; }

        }



        [Test]

        public void DeserializeAlmostImmutableStruct()

        {

            var result = JsonConvert.DeserializeObject<AlmostImmutableStruct>("{ \"Value\": \"working\", \"Value2\": 2 }");



            Assert.AreEqual(null, result.Value);

            Assert.AreEqual(2, result.Value2);

        }



        public class ErroringClass

        {

            public DateTime Tags { get; set; }

        }



        [Test]

        public void DontCloseInputOnDeserializeError()

        {

            using (var s = System.IO.File.OpenRead(ResolvePath("large.json")))

            {

                try

                {

                    using (JsonTextReader reader = new JsonTextReader(new StreamReader(s)))

                    {

                        reader.SupportMultipleContent = true;

                        reader.CloseInput = false;



                        // read into array

                        reader.Read();



                        var ser = new JsonSerializer();

                        ser.CheckAdditionalContent = false;



                        ser.Deserialize<IList<ErroringClass>>(reader);

                    }



                    Assert.Fail();

                }

                catch (Exception)

                {

                    Assert.IsTrue(s.Position > 0);



                    s.Seek(0, SeekOrigin.Begin);



                    Assert.AreEqual(0, s.Position);

                }

            }

        }



        public interface ISubclassBase

        {

            int ID { get; set; }

            string Name { get; set; }

            bool P1 { get; }

        }



        public interface ISubclass : ISubclassBase

        {

            new bool P1 { get; set; }

            int P2 { get; set; }

        }



        public interface IMainClass

        {

            int ID { get; set; }

            string Name { get; set; }

            ISubclass Subclass { get; set; }

        }



        public class Subclass : ISubclass

        {

            public int ID { get; set; }

            public string Name { get; set; }

            public bool P1 { get; set; }

            public int P2 { get; set; }

        }



        public class MainClass : IMainClass

        {

            public int ID { get; set; }

            public string Name { get; set; }

            public ISubclass Subclass { get; set; }

        }



        public class MyFactory

        {

            public static ISubclass InstantiateSubclass()

            {

                return new Subclass

                {

                    ID = 123,

                    Name = "ABC",

                    P1 = true,

                    P2 = 44

                };

            }



            public static IMainClass InstantiateManiClass()

            {

                return new MainClass

                {

                    ID = 567,

                    Name = "XYZ",

                    Subclass = InstantiateSubclass()

                };

            }

        }



        [Test]

        public void SerializeInterfaceWithHiddenProperties()

        {

            var mySubclass = MyFactory.InstantiateSubclass();

            var myMainClass = MyFactory.InstantiateManiClass();



            //Class implementing interface with hidden members - flat object. 

            var strJsonSubclass = JsonConvert.SerializeObject(mySubclass, Formatting.Indented);



            StringAssert.AreEqual(@"{

  ""ID"": 123,

  ""Name"": ""ABC"",

  ""P1"": true,

  ""P2"": 44

}", strJsonSubclass);



            //Class implementing interface with hidden members - member of another class. 

            var strJsonMainClass = JsonConvert.SerializeObject(myMainClass, Formatting.Indented);



            StringAssert.AreEqual(@"{

  ""ID"": 567,

  ""Name"": ""XYZ"",

  ""Subclass"": {

    ""ID"": 123,

    ""Name"": ""ABC"",

    ""P1"": true,

    ""P2"": 44

  }

}", strJsonMainClass);

        }



        [Test]

        public void DeserializeGenericIEnumerableWithImplicitConversion()

        {

            string deserialized = @"{

  ""Enumerable"": [ ""abc"", ""def"" ] 

}";

            var enumerableClass = JsonConvert.DeserializeObject<GenericIEnumerableWithImplicitConversion>(deserialized);

            var enumerableObject = enumerableClass.Enumerable.ToArray();

            Assert.AreEqual(2, enumerableObject.Length);

            Assert.AreEqual("abc", enumerableObject[0].Value);

            Assert.AreEqual("def", enumerableObject[1].Value);

        }



        public class GenericIEnumerableWithImplicitConversion

        {

            public IEnumerable<ClassWithImplicitOperator> Enumerable { get; set; }

        }



        public class ClassWithImplicitOperator

        {

            public string Value { get; set; }



            public static implicit operator ClassWithImplicitOperator(string value)

            {

                return new ClassWithImplicitOperator() { Value = value };

            }

        }



#if !(PORTABLE || PORTABLE40 || NET20 || NET35)

        [Test]

        public void LargeIntegerAsString()

        {

            var largeBrokenNumber = JsonConvert.DeserializeObject<Foo64>("{\"Blah\": 43443333222211111117 }");

            Assert.AreEqual("43443333222211111117", largeBrokenNumber.Blah);



            var largeOddWorkingNumber = JsonConvert.DeserializeObject<Foo64>("{\"Blah\": 53443333222211111117 }");

            Assert.AreEqual("53443333222211111117", largeOddWorkingNumber.Blah);

        }



        public class Foo64

        {

            public string Blah { get; set; }

        }

#endif



#if !NET20

        [Test]

        public void DeserializeMSDateTimeOffset()

        {

            DateTimeOffset d = JsonConvert.DeserializeObject<DateTimeOffset>(@"""/Date(1418924498000+0800)/""");

            long initialTicks = DateTimeUtils.ConvertDateTimeToJavaScriptTicks(d.DateTime, d.Offset);



            Assert.AreEqual(1418924498000, initialTicks);

            Assert.AreEqual(8, d.Offset.Hours);

        }

#endif



        [Test]

        public void DeserializeBoolean_Null()

        {

            ExceptionAssert.Throws<JsonSerializationException>(

                () => JsonConvert.DeserializeObject<IList<bool>>(@"[null]"),

                "Error converting value {null} to type 'System.Boolean'. Path '[0]', line 1, position 5.");

        }



        [Test]

        public void DeserializeBoolean_DateTime()

        {

            ExceptionAssert.Throws<JsonReaderException>(

                () => JsonConvert.DeserializeObject<IList<bool>>(@"['2000-12-20T10:55:55Z']"),

                "Could not convert string to boolean: 2000-12-20T10:55:55Z. Path '[0]', line 1, position 23.");

        }



        [Test]

        public void DeserializeBoolean_BadString()

        {

            ExceptionAssert.Throws<JsonReaderException>(

                () => JsonConvert.DeserializeObject<IList<bool>>(@"['pie']"),

                @"Could not convert string to boolean: pie. Path '[0]', line 1, position 6.");

        }



        [Test]

        public void DeserializeBoolean_EmptyString()

        {

            ExceptionAssert.Throws<JsonSerializationException>(

                () => JsonConvert.DeserializeObject<IList<bool>>(@"['']"),

                @"Error converting value {null} to type 'System.Boolean'. Path '[0]', line 1, position 3.");

        }



#if !(PORTABLE || PORTABLE40 || NET35 || NET20)

        [Test]

        public void DeserializeBooleans()

        {

            IList<bool> l = JsonConvert.DeserializeObject<IList<bool>>(@"[

  1,

  0,

  1.1,

  0.0,

  0.000000000001,

  9999999999,

  -9999999999,

  9999999999999999999999999999999999999999999999999999999999999999999999,

  -9999999999999999999999999999999999999999999999999999999999999999999999,

  'true',

  'TRUE',

  'false',

  'FALSE'

]");



            int i = 0;

            Assert.AreEqual(true, l[i++]);

            Assert.AreEqual(false, l[i++]);

            Assert.AreEqual(true, l[i++]);

            Assert.AreEqual(false, l[i++]);

            Assert.AreEqual(true, l[i++]);

            Assert.AreEqual(true, l[i++]);

            Assert.AreEqual(true, l[i++]);

            Assert.AreEqual(true, l[i++]);

            Assert.AreEqual(true, l[i++]);

            Assert.AreEqual(true, l[i++]);

            Assert.AreEqual(true, l[i++]);

            Assert.AreEqual(false, l[i++]);

            Assert.AreEqual(false, l[i++]);

        }



        [Test]

        public void DeserializeNullableBooleans()

        {

            IList<bool?> l = JsonConvert.DeserializeObject<IList<bool?>>(@"[

  1,

  0,

  1.1,

  0.0,

  0.000000000001,

  9999999999,

  -9999999999,

  9999999999999999999999999999999999999999999999999999999999999999999999,

  -9999999999999999999999999999999999999999999999999999999999999999999999,

  'true',

  'TRUE',

  'false',

  'FALSE',

  '',

  null

]");



            int i = 0;

            Assert.AreEqual(true, l[i++]);

            Assert.AreEqual(false, l[i++]);

            Assert.AreEqual(true, l[i++]);

            Assert.AreEqual(false, l[i++]);

            Assert.AreEqual(true, l[i++]);

            Assert.AreEqual(true, l[i++]);

            Assert.AreEqual(true, l[i++]);

            Assert.AreEqual(true, l[i++]);

            Assert.AreEqual(true, l[i++]);

            Assert.AreEqual(true, l[i++]);

            Assert.AreEqual(true, l[i++]);

            Assert.AreEqual(false, l[i++]);

            Assert.AreEqual(false, l[i++]);

            Assert.AreEqual(null, l[i++]);

            Assert.AreEqual(null, l[i++]);

        }

#endif



        [Test]

        public void CaseInsensitiveRequiredPropertyConstructorCreation()

        {

            FooRequired foo1 = new FooRequired(new[] { "A", "B", "C" });

            string json = JsonConvert.SerializeObject(foo1);



            StringAssert.AreEqual(@"{""Bars"":[""A"",""B"",""C""]}", json);



            FooRequired foo2 = JsonConvert.DeserializeObject<FooRequired>(json);

            Assert.AreEqual(foo1.Bars.Count, foo2.Bars.Count);

            Assert.AreEqual(foo1.Bars[0], foo2.Bars[0]);

            Assert.AreEqual(foo1.Bars[1], foo2.Bars[1]);

            Assert.AreEqual(foo1.Bars[2], foo2.Bars[2]);

        }



        public class FooRequired

        {

            [JsonProperty(Required = Required.Always)]

            public List<string> Bars { get; private set; }



            public FooRequired(IEnumerable<string> bars)

            {

                Bars = new List<string>();

                if (bars != null)

                {

                    Bars.AddRange(bars);

                }

            }

        }



        [Test]

        public void CoercedEmptyStringWithRequired()

        {

            ExceptionAssert.Throws<JsonSerializationException>(() => { JsonConvert.DeserializeObject<Binding>("{requiredProperty:''}"); }, "Required property 'RequiredProperty' expects a value but got null. Path '', line 1, position 21.");

        }



        [Test]

        public void CoercedEmptyStringWithRequired_DisallowNull()

        {

            ExceptionAssert.Throws<JsonSerializationException>(() => { JsonConvert.DeserializeObject<Binding_DisallowNull>("{requiredProperty:''}"); }, "Required property 'RequiredProperty' expects a non-null value. Path '', line 1, position 21.");

        }



        [Test]

        public void DisallowNull_NoValue()

        {

            Binding_DisallowNull o = JsonConvert.DeserializeObject<Binding_DisallowNull>("{}");

            Assert.IsNull(o.RequiredProperty);

        }



        [Test]

        public void CoercedEmptyStringWithRequiredConstructor()

        {

            ExceptionAssert.Throws<JsonSerializationException>(() => { JsonConvert.DeserializeObject<FooRequired>("{Bars:''}"); }, "Required property 'Bars' expects a value but got null. Path '', line 1, position 9.");

        }



        public class IgnoredProperty

        {

            [JsonIgnore]

            [JsonProperty(Required = Required.Always)]

            public string StringProp1 { get; set; }



            [JsonIgnore]

            public string StringProp2 { get; set; }

        }



        [Test]

        public void NoErrorWhenValueDoesNotMatchIgnoredProperty()

        {

            IgnoredProperty p = JsonConvert.DeserializeObject<IgnoredProperty>("{'StringProp1':[1,2,3],'StringProp2':{}}");

            Assert.IsNull(p.StringProp1);

            Assert.IsNull(p.StringProp2);

        }



        public class Binding

        {

            [JsonProperty(Required = Required.Always)]

            public Binding RequiredProperty { get; set; }

        }



        public class Binding_DisallowNull

        {

            [JsonProperty(Required = Required.DisallowNull)]

            public Binding RequiredProperty { get; set; }

        }



        [Test]

        public void Serialize_Required_DisallowedNull()

        {

            ExceptionAssert.Throws<JsonSerializationException>(() => { JsonConvert.SerializeObject(new Binding_DisallowNull()); }, "Cannot write a null value for property 'RequiredProperty'. Property requires a non-null value. Path ''.");

        }



        [Test]

        public void Serialize_Required_DisallowedNull_NullValueHandlingIgnore()

        {

            string json = JsonConvert.SerializeObject(new Binding_DisallowNull(), new JsonSerializerSettings

            {

                NullValueHandling = NullValueHandling.Ignore

            });

            Assert.AreEqual("{}", json);

        }



        [JsonObject(ItemRequired = Required.DisallowNull)]

        public class DictionaryWithNoNull

        {

            public string Name { get; set; }

        }



        [Test]

        public void Serialize_ItemRequired_DisallowedNull()

        {

            ExceptionAssert.Throws<JsonSerializationException>(() => { JsonConvert.SerializeObject(new DictionaryWithNoNull()); }, "Cannot write a null value for property 'Name'. Property requires a non-null value. Path ''.");

        }



        public class DictionaryKeyContractResolver : DefaultContractResolver

        {

            protected override string ResolveDictionaryKey(string dictionaryKey)

            {

                return dictionaryKey;

            }



            protected override string ResolvePropertyName(string propertyName)

            {

#if DNXCORE50

                return propertyName.ToUpperInvariant();

#else

                return propertyName.ToUpper(CultureInfo.InvariantCulture);

#endif

            }

        }



        [Test]

        public void DictionaryKeyContractResolverTest()

        {

            var person = new

            {

                Name = "James",

                Age = 1,

                RoleNames = new Dictionary<string, bool>

                {

                    { "IsAdmin", true },

                    { "IsModerator", false }

                }

            };



            string json = JsonConvert.SerializeObject(person, Formatting.Indented, new JsonSerializerSettings

            {

                ContractResolver = new DictionaryKeyContractResolver()

            });



            Assert.AreEqual(@"{

  ""NAME"": ""James"",

  ""AGE"": 1,

  ""ROLENAMES"": {

    ""IsAdmin"": true,

    ""IsModerator"": false

  }

}", json);

        }



        [Test]

        public void IncompleteContainers()

        {

            ExceptionAssert.Throws<JsonSerializationException>(

                () => JsonConvert.DeserializeObject<IList<object>>("[1,"),

                "Unexpected end when deserializing array. Path '[0]', line 1, position 3.");



            ExceptionAssert.Throws<JsonSerializationException>(

                () => JsonConvert.DeserializeObject<IList<int>>("[1,"),

                "Unexpected end when deserializing array. Path '[0]', line 1, position 3.");



            ExceptionAssert.Throws<JsonSerializationException>(

                () => JsonConvert.DeserializeObject<IList<int>>("[1"),

                "Unexpected end when deserializing array. Path '[0]', line 1, position 2.");



            ExceptionAssert.Throws<JsonSerializationException>(

                () => JsonConvert.DeserializeObject<IDictionary<string, int>>("{'key':1,"),

                "Unexpected end when deserializing object. Path 'key', line 1, position 9.");



            ExceptionAssert.Throws<JsonSerializationException>(

                () => JsonConvert.DeserializeObject<IDictionary<string, int>>("{'key':1"),

                "Unexpected end when deserializing object. Path 'key', line 1, position 8.");



            ExceptionAssert.Throws<JsonSerializationException>(

                () => JsonConvert.DeserializeObject<IncompleteTestClass>("{'key':1,"),

                "Unexpected end when deserializing object. Path 'key', line 1, position 9.");



            ExceptionAssert.Throws<JsonSerializationException>(

                () => JsonConvert.DeserializeObject<IncompleteTestClass>("{'key':1"),

                "Unexpected end when deserializing object. Path 'key', line 1, position 8.");

        }



        public class IncompleteTestClass

        {

            public int Key { get; set; }

        }



#if !NET20

        public enum EnumA

        {

            [EnumMember(Value = "value_a")]

            ValueA

        }



        [Test]

        public void DeserializeEnumsByName()

        {

            var e1 = JsonConvert.DeserializeObject<EnumA>("'ValueA'");

            Assert.AreEqual(EnumA.ValueA, e1);



            var e2 = JsonConvert.DeserializeObject<EnumA>("'value_a'", new StringEnumConverter());

            Assert.AreEqual(EnumA.ValueA, e2);

        }

#endif



        public class RequiredPropertyTestClass

        {

            [JsonRequired]

            internal string Name { get; set; }

        }



        [Test]

        public void RequiredPropertyTest()

        {

            RequiredPropertyTestClass c1 = new RequiredPropertyTestClass();



            ExceptionAssert.Throws<JsonSerializationException>(

                () => JsonConvert.SerializeObject(c1),

                "Cannot write a null value for property 'Name'. Property requires a value. Path ''.");



            RequiredPropertyTestClass c2 = new RequiredPropertyTestClass

            {

                Name = "Name!"

            };



            string json = JsonConvert.SerializeObject(c2);



            Assert.AreEqual(@"{""Name"":""Name!""}", json);



            ExceptionAssert.Throws<JsonSerializationException>(

                () => JsonConvert.DeserializeObject<RequiredPropertyTestClass>(@"{}"),

                "Required property 'Name' not found in JSON. Path '', line 1, position 2.");



            ExceptionAssert.Throws<JsonSerializationException>(

                () => JsonConvert.DeserializeObject<RequiredPropertyTestClass>(@"{""Name"":null}"),

                "Required property 'Name' expects a value but got null. Path '', line 1, position 13.");



            RequiredPropertyTestClass c3 = JsonConvert.DeserializeObject<RequiredPropertyTestClass>(@"{""Name"":""Name!""}");



            Assert.AreEqual("Name!", c3.Name);

        }



        public class RequiredPropertyConstructorTestClass

        {

            public RequiredPropertyConstructorTestClass(string name)

            {

                Name = name;

            }



            [JsonRequired]

            internal string Name { get; set; }

        }



        [Test]

        public void RequiredPropertyConstructorTest()

        {

            RequiredPropertyConstructorTestClass c1 = new RequiredPropertyConstructorTestClass(null);



            ExceptionAssert.Throws<JsonSerializationException>(

                () => JsonConvert.SerializeObject(c1),

                "Cannot write a null value for property 'Name'. Property requires a value. Path ''.");



            RequiredPropertyConstructorTestClass c2 = new RequiredPropertyConstructorTestClass("Name!");



            string json = JsonConvert.SerializeObject(c2);



            Assert.AreEqual(@"{""Name"":""Name!""}", json);



            ExceptionAssert.Throws<JsonSerializationException>(

                () => JsonConvert.DeserializeObject<RequiredPropertyConstructorTestClass>(@"{}"),

                "Required property 'Name' not found in JSON. Path '', line 1, position 2.");



            RequiredPropertyConstructorTestClass c3 = JsonConvert.DeserializeObject<RequiredPropertyConstructorTestClass>(@"{""Name"":""Name!""}");



            Assert.AreEqual("Name!", c3.Name);

        }



        public class IgnoredPropertiesTestClass

        {

            [JsonIgnore]

            public Version IgnoredProperty { get; set; }



            [JsonIgnore]

            public List<Version> IgnoredList { get; set; }



            [JsonIgnore]

            public Dictionary<string, Version> IgnoredDictionary { get; set; }



            [JsonProperty(Required = Required.Always)]

            public string Name { get; set; }

        }



        public class IgnoredPropertiesContractResolver : DefaultContractResolver

        {

            public override JsonContract ResolveContract(Type type)

            {

                if (type == typeof(Version))

                {

                    throw new Exception("Error!");

                }



                return base.ResolveContract(type);

            }

        }



        [Test]

        public void NeverResolveIgnoredPropertyTypes()

        {

            Version v = new Version(1, 2, 3, 4);



            IgnoredPropertiesTestClass c1 = new IgnoredPropertiesTestClass

            {

                IgnoredProperty = v,

                IgnoredList = new List<Version>

                {

                    v

                },

                IgnoredDictionary = new Dictionary<string, Version>

                {

                    { "Value", v }

                },

                Name = "Name!"

            };



            string json = JsonConvert.SerializeObject(c1, Formatting.Indented, new JsonSerializerSettings

            {

                ContractResolver = new IgnoredPropertiesContractResolver()

            });



            Assert.AreEqual(@"{

  ""Name"": ""Name!""

}", json);



            string deserializeJson = @"{

  ""IgnoredList"": [

    {

      ""Major"": 1,

      ""Minor"": 2,

      ""Build"": 3,

      ""Revision"": 4,

      ""MajorRevision"": 0,

      ""MinorRevision"": 4

    }

  ],

  ""IgnoredDictionary"": {

    ""Value"": {

      ""Major"": 1,

      ""Minor"": 2,

      ""Build"": 3,

      ""Revision"": 4,

      ""MajorRevision"": 0,

      ""MinorRevision"": 4

    }

  },

  ""Name"": ""Name!""

}";



            IgnoredPropertiesTestClass c2 = JsonConvert.DeserializeObject<IgnoredPropertiesTestClass>(deserializeJson, new JsonSerializerSettings

            {

                ContractResolver = new IgnoredPropertiesContractResolver()

            });



            Assert.AreEqual("Name!", c2.Name);

        }



#if !(NET20 || NET35 || PORTABLE40)

        [Test]

        public void SerializeValueTuple()

        {

            ValueTuple<int, int, string> t = ValueTuple.Create(1, 2, "string");



            string json = JsonConvert.SerializeObject(t, Formatting.Indented);



            StringAssert.AreEqual(@"{

  ""Item1"": 1,

  ""Item2"": 2,

  ""Item3"": ""string""

}", json);



            ValueTuple<int, int, string> t2 = JsonConvert.DeserializeObject<ValueTuple<int, int, string>>(json);



            Assert.AreEqual(1, t2.Item1);

            Assert.AreEqual(2, t2.Item2);

            Assert.AreEqual("string", t2.Item3);

        }

#endif



        [Test]

        public void DeserializeStructWithConstructorAttribute()

        {

            ImmutableStructWithConstructorAttribute result = JsonConvert.DeserializeObject<ImmutableStructWithConstructorAttribute>("{ \"Value\": \"working\" }");



            Assert.AreEqual("working", result.Value);

        }



        public struct ImmutableStructWithConstructorAttribute

        {

            [JsonConstructor]

            public ImmutableStructWithConstructorAttribute(string value)

            {

                Value = value;

            }



            public string Value { get; }

        }



#if !(DNXCORE50 || NET20)

        [MetadataType(typeof(CustomerValidation))]

        public partial class CustomerWithMetadataType

        {

            public System.Guid UpdatedBy_Id { get; set; }



            public class CustomerValidation

            {

                [JsonIgnore]

                public System.Guid UpdatedBy_Id { get; set; }

            }

        }



        [Test]

        public void SerializeMetadataType()

        {

            CustomerWithMetadataType c = new CustomerWithMetadataType()

            {

                UpdatedBy_Id = Guid.NewGuid()

            };

            string json = JsonConvert.SerializeObject(c);



            Assert.AreEqual("{}", json);



            CustomerWithMetadataType c2 = JsonConvert.DeserializeObject<CustomerWithMetadataType>("{'UpdatedBy_Id':'F6E0666D-13C7-4745-B486-800812C8F6DE'}");



            Assert.AreEqual(Guid.Empty, c2.UpdatedBy_Id);

        }



        [Serializable]

        public partial class FaqItem

        {

            public FaqItem()

            {

                this.Sections = new HashSet<FaqSection>();

            }



            public int FaqId { get; set; }

            public string Name { get; set; }

            public bool IsDeleted { get; set; }



            public virtual ICollection<FaqSection> Sections { get; set; }

        }



        [MetadataType(typeof(FaqItemMetadata))]

        partial class FaqItem

        {

            [JsonProperty("FullSectionsProp")]

            public ICollection<FaqSection> FullSections

            {

                get { return Sections; }

            }

        }



        public class FaqItemMetadata

        {

            [JsonIgnore]

            public virtual ICollection<FaqSection> Sections { get; set; }

        }



        public class FaqSection

        {

        }



        public class FaqItemProxy : FaqItem

        {

            public bool IsProxy { get; set; }



            public override ICollection<FaqSection> Sections

            {

                get { return base.Sections; }

                set { base.Sections = value; }

            }

        }



        [Test]

        public void SerializeMetadataType2()

        {

            FaqItem c = new FaqItem()

            {

                FaqId = 1,

                Sections =

                {

                    new FaqSection()

                }

            };



            string json = JsonConvert.SerializeObject(c, Formatting.Indented);



            StringAssert.AreEqual(@"{

  ""FaqId"": 1,

  ""Name"": null,

  ""IsDeleted"": false,

  ""FullSectionsProp"": [

    {}

  ]

}", json);



            FaqItem c2 = JsonConvert.DeserializeObject<FaqItem>(json);



            Assert.AreEqual(1, c2.FaqId);

            Assert.AreEqual(1, c2.Sections.Count);

        }



        [Test]

        public void SerializeMetadataTypeInheritance()

        {

            FaqItemProxy c = new FaqItemProxy();

            c.FaqId = 1;

            c.Sections.Add(new FaqSection());

            c.IsProxy = true;



            string json = JsonConvert.SerializeObject(c, Formatting.Indented);



            StringAssert.AreEqual(@"{

  ""IsProxy"": true,

  ""FaqId"": 1,

  ""Name"": null,

  ""IsDeleted"": false,

  ""FullSectionsProp"": [

    {}

  ]

}", json);



            FaqItemProxy c2 = JsonConvert.DeserializeObject<FaqItemProxy>(json);



            Assert.AreEqual(1, c2.FaqId);

            Assert.AreEqual(1, c2.Sections.Count);

        }

#endif



        public class NullTestClass

        {

            public JObject Value1 { get; set; }

            public JValue Value2 { get; set; }

            public JRaw Value3 { get; set; }

            public JToken Value4 { get; set; }

            public object Value5 { get; set; }

        }



        [Test]

        public void DeserializeNullToJTokenProperty()

        {

            NullTestClass otc = JsonConvert.DeserializeObject<NullTestClass>(@"{

    ""Value1"": null,

    ""Value2"": null,

    ""Value3"": null,

    ""Value4"": null,

    ""Value5"": null

}");

            Assert.IsNull(otc.Value1);

            Assert.AreEqual(JTokenType.Null, otc.Value2.Type);

            Assert.AreEqual(JTokenType.Raw, otc.Value3.Type);

            Assert.AreEqual(JTokenType.Null, otc.Value4.Type);

            Assert.IsNull(otc.Value5);

        }



        public class Link

        {

            /// <summary>

            /// The unique identifier.

            /// </summary>

            public int Id;



            /// <summary>

            /// The parent information identifier.

            /// </summary>

            public int ParentId;



            /// <summary>

            /// The child information identifier.

            /// </summary>

            public int ChildId;

        }



#if !(NET20 || NET35 || PORTABLE40 || PORTABLE)

        [Test]

        public void ReadIntegerWithError()

        {

            string json = @"{

    ParentId: 1,

    ChildId: 333333333333333333333333333333333333333

}";



            Link l = JsonConvert.DeserializeObject<Link>(json, new JsonSerializerSettings

            {

                Error = (s, a) => a.ErrorContext.Handled = true

            });



            Assert.AreEqual(0, l.ChildId);

        }

#endif



#if !(NET20 || NET35)

        [Test]

        public void DeserializeObservableCollection()

        {

            ObservableCollection<string> s = JsonConvert.DeserializeObject<ObservableCollection<string>>("['1','2']");

            Assert.AreEqual(2, s.Count);

            Assert.AreEqual("1", s[0]);

            Assert.AreEqual("2", s[1]);

        }

#endif



        [Test]

        public void DeserializeBoolAsStringInDictionary()

        {

            Dictionary<string, string> d = JsonConvert.DeserializeObject<Dictionary<string, string>>("{\"Test1\":false}");

            Assert.AreEqual(1, d.Count);

            Assert.AreEqual("false", d["Test1"]);

        }



#if !NET20

        [Test]

        public void PopulateResetSettings()

        {

            JsonTextReader reader = new JsonTextReader(new StringReader(@"[""2000-01-01T01:01:01+00:00""]"));

            Assert.AreEqual(DateParseHandling.DateTime, reader.DateParseHandling);



            JsonSerializer serializer = new JsonSerializer();

            serializer.DateParseHandling = DateParseHandling.DateTimeOffset;



            IList<object> l = new List<object>();

            serializer.Populate(reader, l);



            Assert.AreEqual(typeof(DateTimeOffset), l[0].GetType());

            Assert.AreEqual(new DateTimeOffset(2000, 1, 1, 1, 1, 1, TimeSpan.Zero), l[0]);



            Assert.AreEqual(DateParseHandling.DateTime, reader.DateParseHandling);

        }

#endif



        public class BaseClass

        {

            internal bool IsTransient { get; set; }

        }



        public class ChildClass : BaseClass

        {

            public new bool IsTransient { get; set; }

        }



        [Test]

        public void NewProperty()

        {

            Assert.AreEqual(@"{""IsTransient"":true}", JsonConvert.SerializeObject(new ChildClass { IsTransient = true }));



            var childClass = JsonConvert.DeserializeObject<ChildClass>(@"{""IsTransient"":true}");

            Assert.AreEqual(true, childClass.IsTransient);

        }



        public class BaseClassVirtual

        {

            internal virtual bool IsTransient { get; set; }

        }



        public class ChildClassVirtual : BaseClassVirtual

        {

            public new virtual bool IsTransient { get; set; }

        }



        [Test]

        public void NewPropertyVirtual()

        {

            Assert.AreEqual(@"{""IsTransient"":true}", JsonConvert.SerializeObject(new ChildClassVirtual { IsTransient = true }));



            var childClass = JsonConvert.DeserializeObject<ChildClassVirtual>(@"{""IsTransient"":true}");

            Assert.AreEqual(true, childClass.IsTransient);

        }



        public class ResponseWithNewGenericProperty<T> : SimpleResponse

        {

            public new T Data { get; set; }

        }



        public class ResponseWithNewGenericPropertyVirtual<T> : SimpleResponse

        {

            public new virtual T Data { get; set; }

        }



        public class ResponseWithNewGenericPropertyOverride<T> : ResponseWithNewGenericPropertyVirtual<T>

        {

            public override T Data { get; set; }

        }



        public abstract class SimpleResponse

        {

            public string Result { get; set; }

            public string Message { get; set; }

            public object Data { get; set; }



            protected SimpleResponse()

            {

            }



            protected SimpleResponse(string message)

            {

                Message = message;

            }

        }



        [Test]

        public void CanSerializeWithBuiltInTypeAsGenericArgument()

        {

            var input = new ResponseWithNewGenericProperty<int>()

            {

                Message = "Trying out integer as type parameter",

                Data = 25,

                Result = "This should be fine"

            };



            var json = JsonConvert.SerializeObject(input);

            var deserialized = JsonConvert.DeserializeObject<ResponseWithNewGenericProperty<int>>(json);



            Assert.AreEqual(input.Data, deserialized.Data);

            Assert.AreEqual(input.Message, deserialized.Message);

            Assert.AreEqual(input.Result, deserialized.Result);

        }



        [Test]

        public void CanSerializeWithBuiltInTypeAsGenericArgumentVirtual()

        {

            var input = new ResponseWithNewGenericPropertyVirtual<int>()

            {

                Message = "Trying out integer as type parameter",

                Data = 25,

                Result = "This should be fine"

            };



            var json = JsonConvert.SerializeObject(input);

            var deserialized = JsonConvert.DeserializeObject<ResponseWithNewGenericPropertyVirtual<int>>(json);



            Assert.AreEqual(input.Data, deserialized.Data);

            Assert.AreEqual(input.Message, deserialized.Message);

            Assert.AreEqual(input.Result, deserialized.Result);

        }



        [Test]

        public void CanSerializeWithBuiltInTypeAsGenericArgumentOverride()

        {

            var input = new ResponseWithNewGenericPropertyOverride<int>()

            {

                Message = "Trying out integer as type parameter",

                Data = 25,

                Result = "This should be fine"

            };



            var json = JsonConvert.SerializeObject(input);

            var deserialized = JsonConvert.DeserializeObject<ResponseWithNewGenericPropertyOverride<int>>(json);



            Assert.AreEqual(input.Data, deserialized.Data);

            Assert.AreEqual(input.Message, deserialized.Message);

            Assert.AreEqual(input.Result, deserialized.Result);

        }



        [Test]

        public void CanSerializedWithGenericClosedTypeAsArgument()

        {

            var input = new ResponseWithNewGenericProperty<List<int>>()

            {

                Message = "More complex case - generic list of int",

                Data = Enumerable.Range(50, 70).ToList(),

                Result = "This should be fine too"

            };



            var json = JsonConvert.SerializeObject(input);

            var deserialized = JsonConvert.DeserializeObject<ResponseWithNewGenericProperty<List<int>>>(json);



            CollectionAssert.AreEqual(input.Data, deserialized.Data);

            Assert.AreEqual(input.Message, deserialized.Message);

            Assert.AreEqual(input.Result, deserialized.Result);

        }



        [Test]

        public void DeserializeVersionString()

        {

            string json = "['1.2.3.4']";

            List<Version> deserialized = JsonConvert.DeserializeObject<List<Version>>(json);



            Assert.AreEqual(1, deserialized[0].Major);

            Assert.AreEqual(2, deserialized[0].Minor);

            Assert.AreEqual(3, deserialized[0].Build);

            Assert.AreEqual(4, deserialized[0].Revision);

        }



        [Test]

        public void DeserializeVersionString_Fail()

        {

            string json = "['1.2.3.4444444444444444444444']";



            ExceptionAssert.Throws<JsonSerializationException>(() => { JsonConvert.DeserializeObject<List<Version>>(json); }, @"Error converting value ""1.2.3.4444444444444444444444"" to type 'System.Version'. Path '[0]', line 1, position 31.");

        }



        [Test]

        public void DeserializeJObjectWithComments()

        {

            string json = @"/* Test */

            {

                /*Test*/""A"":/* Test */true/* Test */,

                /* Test */""B"":/* Test */false/* Test */,

                /* Test */""C"":/* Test */[

                    /* Test */

                    1/* Test */

                ]/* Test */

            }

            /* Test */";

            JObject o = (JObject)JsonConvert.DeserializeObject(json);

            Assert.AreEqual(3, o.Count);

            Assert.AreEqual(true, (bool)o["A"]);

            Assert.AreEqual(false, (bool)o["B"]);

            Assert.AreEqual(1, o["C"].Count());

            Assert.AreEqual(1, (int)o["C"][0]);



            Assert.IsTrue(JToken.DeepEquals(o, JObject.Parse(json)));



            json = @"{/* Test */}";

            o = (JObject)JsonConvert.DeserializeObject(json);

            Assert.AreEqual(0, o.Count);

            Assert.IsTrue(JToken.DeepEquals(o, JObject.Parse(json)));



            json = @"{""A"": true/* Test */}";

            o = (JObject)JsonConvert.DeserializeObject(json);

            Assert.AreEqual(1, o.Count);

            Assert.AreEqual(true, (bool)o["A"]);

            Assert.IsTrue(JToken.DeepEquals(o, JObject.Parse(json)));

        }



        public class CommentTestObject

        {

            public bool? A { get; set; }

        }



        [Test]

        public void DeserializeCommentTestObjectWithComments()

        {

            CommentTestObject o = JsonConvert.DeserializeObject<CommentTestObject>(@"{/* Test */}");

            Assert.AreEqual(null, o.A);



            o = JsonConvert.DeserializeObject<CommentTestObject>(@"{""A"": true/* Test */}");

            Assert.AreEqual(true, o.A);

        }



        [Test]

        public void JsonSerializerProperties()

        {

            JsonSerializer serializer = new JsonSerializer();



            DefaultSerializationBinder customBinder = new DefaultSerializationBinder();

#pragma warning disable CS0618 // Type or member is obsolete

            serializer.Binder = customBinder;

            Assert.AreEqual(customBinder, serializer.Binder);

#pragma warning restore CS0618 // Type or member is obsolete



            Assert.IsInstanceOf(typeof(DefaultSerializationBinder), serializer.SerializationBinder);



            serializer.SerializationBinder = customBinder;

            Assert.AreEqual(customBinder, serializer.SerializationBinder);



#pragma warning disable CS0618 // Type or member is obsolete

            // can still fetch because DefaultSerializationBinder inherits from SerializationBinder

            Assert.AreEqual(customBinder, serializer.Binder);

#pragma warning restore CS0618 // Type or member is obsolete



            serializer.CheckAdditionalContent = true;

            Assert.AreEqual(true, serializer.CheckAdditionalContent);



            serializer.ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor;

            Assert.AreEqual(ConstructorHandling.AllowNonPublicDefaultConstructor, serializer.ConstructorHandling);



#if !(DNXCORE50)

            serializer.Context = new StreamingContext(StreamingContextStates.Other);

            Assert.AreEqual(new StreamingContext(StreamingContextStates.Other), serializer.Context);

#endif



            CamelCasePropertyNamesContractResolver resolver = new CamelCasePropertyNamesContractResolver();

            serializer.ContractResolver = resolver;

            Assert.AreEqual(resolver, serializer.ContractResolver);



            serializer.Converters.Add(new StringEnumConverter());

            Assert.AreEqual(1, serializer.Converters.Count);



            serializer.Culture = new CultureInfo("en-nz");

            Assert.AreEqual("en-NZ", serializer.Culture.ToString());



            serializer.EqualityComparer = EqualityComparer<object>.Default;

            Assert.AreEqual(EqualityComparer<object>.Default, serializer.EqualityComparer);



            serializer.DateFormatHandling = DateFormatHandling.MicrosoftDateFormat;

            Assert.AreEqual(DateFormatHandling.MicrosoftDateFormat, serializer.DateFormatHandling);



            serializer.DateFormatString = "yyyy";

            Assert.AreEqual("yyyy", serializer.DateFormatString);



            serializer.DateParseHandling = DateParseHandling.None;

            Assert.AreEqual(DateParseHandling.None, serializer.DateParseHandling);



            serializer.DateTimeZoneHandling = DateTimeZoneHandling.Utc;

            Assert.AreEqual(DateTimeZoneHandling.Utc, serializer.DateTimeZoneHandling);



            serializer.DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate;

            Assert.AreEqual(DefaultValueHandling.IgnoreAndPopulate, serializer.DefaultValueHandling);



            serializer.FloatFormatHandling = FloatFormatHandling.Symbol;

            Assert.AreEqual(FloatFormatHandling.Symbol, serializer.FloatFormatHandling);



            serializer.FloatParseHandling = FloatParseHandling.Decimal;

            Assert.AreEqual(FloatParseHandling.Decimal, serializer.FloatParseHandling);



            serializer.Formatting = Formatting.Indented;

            Assert.AreEqual(Formatting.Indented, serializer.Formatting);



            serializer.MaxDepth = 9001;

            Assert.AreEqual(9001, serializer.MaxDepth);



            serializer.MissingMemberHandling = MissingMemberHandling.Error;

            Assert.AreEqual(MissingMemberHandling.Error, serializer.MissingMemberHandling);



            serializer.NullValueHandling = NullValueHandling.Ignore;

            Assert.AreEqual(NullValueHandling.Ignore, serializer.NullValueHandling);



            serializer.ObjectCreationHandling = ObjectCreationHandling.Replace;

            Assert.AreEqual(ObjectCreationHandling.Replace, serializer.ObjectCreationHandling);



            serializer.PreserveReferencesHandling = PreserveReferencesHandling.All;

            Assert.AreEqual(PreserveReferencesHandling.All, serializer.PreserveReferencesHandling);



            serializer.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;

            Assert.AreEqual(ReferenceLoopHandling.Ignore, serializer.ReferenceLoopHandling);



            IdReferenceResolver referenceResolver = new IdReferenceResolver();

            serializer.ReferenceResolver = referenceResolver;

            Assert.AreEqual(referenceResolver, serializer.ReferenceResolver);



            serializer.StringEscapeHandling = StringEscapeHandling.EscapeNonAscii;

            Assert.AreEqual(StringEscapeHandling.EscapeNonAscii, serializer.StringEscapeHandling);



            MemoryTraceWriter traceWriter = new MemoryTraceWriter();

            serializer.TraceWriter = traceWriter;

            Assert.AreEqual(traceWriter, serializer.TraceWriter);



#if !(PORTABLE || PORTABLE40 || NET20 || DNXCORE50)

#pragma warning disable 618

            serializer.TypeNameAssemblyFormat = FormatterAssemblyStyle.Full;

            Assert.AreEqual(FormatterAssemblyStyle.Full, serializer.TypeNameAssemblyFormat);

#pragma warning restore 618



            Assert.AreEqual(TypeNameAssemblyFormatHandling.Full, serializer.TypeNameAssemblyFormatHandling);



            serializer.TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple;

#pragma warning disable 618

            Assert.AreEqual(FormatterAssemblyStyle.Simple, serializer.TypeNameAssemblyFormat);

#pragma warning restore 618

#endif



           …