/modules/JSON/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 || SILVERLIGHT)
using System.Collections.Concurrent;
#endif
using System.Collections.Generic;
#if !(NET20 || NET35 || SILVERLIGHT || PORTABLE)
using System.Numerics;
#endif
#if !SILVERLIGHT && !NET20 && !NETFX_CORE
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 !NETFX_CORE
using NUnit.Framework;
#else
using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
using TestFixture = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute;
using Test = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute;
#endif
using Newtonsoft.Json;
using System.IO;
using System.Collections;
using System.Xml;
using System.Xml.Serialization;
using System.Collections.ObjectModel;
using Newtonsoft.Json.Bson;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Converters;
#if !NET20
using System.Runtime.Serialization.Json;
#endif
using Newtonsoft.Json.Serialization;
using Newtonsoft.Json.Tests.Linq;
using Newtonsoft.Json.Tests.TestObjects;
using System.Runtime.Serialization;
using System.Globalization;
using Newtonsoft.Json.Utilities;
using System.Reflection;
#if !NET20 && !SILVERLIGHT
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;
#else
using System.Linq;
#endif
#if !(SILVERLIGHT || NETFX_CORE)
using System.Drawing;
using System.Diagnostics;
#endif

namespace Newtonsoft.Json.Tests.Serialization
{
  [TestFixture]
  public class JsonSerializerTest : TestFixtureBase
  {
    public class GenericItem<T>
    {
      public T Value { get; set; }
    }

    public class NonGenericItem : GenericItem<string>
    {

    }

    public class GenericClass<T, TValue> : IEnumerable<T>
      where T : GenericItem<TValue>, new()
    {
      public IList<T> Items { get; set; }

      public GenericClass()
      {
        Items = new List<T>();
      }

      public IEnumerator<T> GetEnumerator()
      {
        if (Items != null)
        {
          foreach (T item in Items)
          {
            yield return item;
          }
        }
        else
          yield break;
      }

      IEnumerator IEnumerable.GetEnumerator()
      {
        return GetEnumerator();
      }
    }

    public class NonGenericClass : GenericClass<GenericItem<string>, string>
    {

    }

#pragma warning disable 169
    public class CustomerInvoice
    {
      // we're only modifing the tax rate
      public decimal TaxRate { get; set; }

      // everything else gets stored here
      [JsonExtensionData]
      private IDictionary<string, JToken> _additionalData;
    }
#pragma warning restore 169

    [Test]
    public void ExtensionDataExample()
    {
      string json = @"{
        'HourlyRate': 150,
        'Hours': 40,
        'TaxRate': 0.125
      }";

      var invoice = JsonConvert.DeserializeObject<CustomerInvoice>(json);

      // increase tax to 15%
      invoice.TaxRate = 0.15m;

      string result = JsonConvert.SerializeObject(invoice);
      // {
      //   'TaxRate': 0.15,
      //   'HourlyRate': 150,
      //   'Hours': 40
      // }

      Assert.AreEqual(@"{""TaxRate"":0.15,""HourlyRate"":150,""Hours"":40}", result);
    }

    public class ExtensionDataTestClass
    {
      public string Name { get; set; }
      [JsonProperty("custom_name")]
      public string CustomName { get; set; }
      [JsonIgnore]
      public IList<int> Ignored { get; set; }
      public bool GetPrivate { get; internal set; }
      public bool GetOnly
      {
        get { return true; }
      }
      public readonly string Readonly = "Readonly";
      public IList<int> Ints { get; set; }
        
      [JsonExtensionData]
      internal IDictionary<string, JToken> ExtensionData { get; set; }

      public ExtensionDataTestClass()
      {
        Ints = new List<int> { 0 };
      }
    }

    public class JObjectExtensionDataTestClass
    {
      public string Name { get; set; }
      [JsonExtensionData]
      public JObject ExtensionData { get; set; }
    }

    [Test]
    public void RoundTripJObjectExtensionData()
    {
      JObjectExtensionDataTestClass c = new JObjectExtensionDataTestClass();
      c.Name = "Name!";
      c.ExtensionData = new JObject
        {
          {"one",1},
          {"two","II"},
          {"three",new JArray(1,1,1)}
        };

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

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

      Assert.AreEqual("Name!", c2.Name);
      Assert.IsTrue(JToken.DeepEquals(c.ExtensionData, c2.ExtensionData));
    }

    [Test]
    public void JsonSerializerProperties()
    {
      JsonSerializer serializer = new JsonSerializer();

      DefaultSerializationBinder customBinder = new DefaultSerializationBinder();
      serializer.Binder = customBinder;
      Assert.AreEqual(customBinder, serializer.Binder);

      serializer.CheckAdditionalContent = true;
      Assert.AreEqual(true, serializer.CheckAdditionalContent);

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

#if !NETFX_CORE
      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.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 || NETFX_CORE || NET20)
      serializer.TypeNameAssemblyFormat = FormatterAssemblyStyle.Full;
      Assert.AreEqual(FormatterAssemblyStyle.Full, serializer.TypeNameAssemblyFormat);
#endif

      serializer.TypeNameHandling = TypeNameHandling.All;
      Assert.AreEqual(TypeNameHandling.All, serializer.TypeNameHandling);
    }

    [Test]
    public void JsonSerializerSettingsProperties()
    {
      JsonSerializerSettings settings = new JsonSerializerSettings();

      DefaultSerializationBinder customBinder = new DefaultSerializationBinder();
      settings.Binder = customBinder;
      Assert.AreEqual(customBinder, settings.Binder);

      settings.CheckAdditionalContent = true;
      Assert.AreEqual(true, settings.CheckAdditionalContent);

      settings.ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor;
      Assert.AreEqual(ConstructorHandling.AllowNonPublicDefaultConstructor, settings.ConstructorHandling);

#if !NETFX_CORE
      settings.Context = new StreamingContext(StreamingContextStates.Other);
      Assert.AreEqual(new StreamingContext(StreamingContextStates.Other), settings.Context);
#endif

      CamelCasePropertyNamesContractResolver resolver = new CamelCasePropertyNamesContractResolver();
      settings.ContractResolver = resolver;
      Assert.AreEqual(resolver, settings.ContractResolver);

      settings.Converters.Add(new StringEnumConverter());
      Assert.AreEqual(1, settings.Converters.Count);

      settings.Culture = new CultureInfo("en-nz");
      Assert.AreEqual("en-NZ", settings.Culture.ToString());

      settings.DateFormatHandling = DateFormatHandling.MicrosoftDateFormat;
      Assert.AreEqual(DateFormatHandling.MicrosoftDateFormat, settings.DateFormatHandling);

      settings.DateFormatString = "yyyy";
      Assert.AreEqual("yyyy", settings.DateFormatString);

      settings.DateParseHandling = DateParseHandling.None;
      Assert.AreEqual(DateParseHandling.None, settings.DateParseHandling);

      settings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
      Assert.AreEqual(DateTimeZoneHandling.Utc, settings.DateTimeZoneHandling);

      settings.DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate;
      Assert.AreEqual(DefaultValueHandling.IgnoreAndPopulate, settings.DefaultValueHandling);

      settings.FloatFormatHandling = FloatFormatHandling.Symbol;
      Assert.AreEqual(FloatFormatHandling.Symbol, settings.FloatFormatHandling);

      settings.FloatParseHandling = FloatParseHandling.Decimal;
      Assert.AreEqual(FloatParseHandling.Decimal, settings.FloatParseHandling);

      settings.Formatting = Formatting.Indented;
      Assert.AreEqual(Formatting.Indented, settings.Formatting);

      settings.MaxDepth = 9001;
      Assert.AreEqual(9001, settings.MaxDepth);

      settings.MissingMemberHandling = MissingMemberHandling.Error;
      Assert.AreEqual(MissingMemberHandling.Error, settings.MissingMemberHandling);

      settings.NullValueHandling = NullValueHandling.Ignore;
      Assert.AreEqual(NullValueHandling.Ignore, settings.NullValueHandling);

      settings.ObjectCreationHandling = ObjectCreationHandling.Replace;
      Assert.AreEqual(ObjectCreationHandling.Replace, settings.ObjectCreationHandling);

      settings.PreserveReferencesHandling = PreserveReferencesHandling.All;
      Assert.AreEqual(PreserveReferencesHandling.All, settings.PreserveReferencesHandling);

      settings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
      Assert.AreEqual(ReferenceLoopHandling.Ignore, settings.ReferenceLoopHandling);

      IdReferenceResolver referenceResolver = new IdReferenceResolver();
      settings.ReferenceResolver = referenceResolver;
      Assert.AreEqual(referenceResolver, settings.ReferenceResolver);

      settings.StringEscapeHandling = StringEscapeHandling.EscapeNonAscii;
      Assert.AreEqual(StringEscapeHandling.EscapeNonAscii, settings.StringEscapeHandling);

      MemoryTraceWriter traceWriter = new MemoryTraceWriter();
      settings.TraceWriter = traceWriter;
      Assert.AreEqual(traceWriter, settings.TraceWriter);

#if !(PORTABLE || PORTABLE40 || NETFX_CORE || NET20)
      settings.TypeNameAssemblyFormat = FormatterAssemblyStyle.Full;
      Assert.AreEqual(FormatterAssemblyStyle.Full, settings.TypeNameAssemblyFormat);
#endif

      settings.TypeNameHandling = TypeNameHandling.All;
      Assert.AreEqual(TypeNameHandling.All, settings.TypeNameHandling);
    }

    [Test]
    public void JsonSerializerProxyProperties()
    {
      JsonSerializerProxy serializerProxy = new JsonSerializerProxy(new JsonSerializerInternalReader(new JsonSerializer()));

      DefaultSerializationBinder customBinder = new DefaultSerializationBinder();
      serializerProxy.Binder = customBinder;
      Assert.AreEqual(customBinder, serializerProxy.Binder);

      serializerProxy.CheckAdditionalContent = true;
      Assert.AreEqual(true, serializerProxy.CheckAdditionalContent);

      serializerProxy.ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor;
      Assert.AreEqual(ConstructorHandling.AllowNonPublicDefaultConstructor, serializerProxy.ConstructorHandling);

#if !NETFX_CORE
      serializerProxy.Context = new StreamingContext(StreamingContextStates.Other);
      Assert.AreEqual(new StreamingContext(StreamingContextStates.Other), serializerProxy.Context);
#endif

      CamelCasePropertyNamesContractResolver resolver = new CamelCasePropertyNamesContractResolver();
      serializerProxy.ContractResolver = resolver;
      Assert.AreEqual(resolver, serializerProxy.ContractResolver);

      serializerProxy.Converters.Add(new StringEnumConverter());
      Assert.AreEqual(1, serializerProxy.Converters.Count);

      serializerProxy.Culture = new CultureInfo("en-nz");
      Assert.AreEqual("en-NZ", serializerProxy.Culture.ToString());

      serializerProxy.DateFormatHandling = DateFormatHandling.MicrosoftDateFormat;
      Assert.AreEqual(DateFormatHandling.MicrosoftDateFormat, serializerProxy.DateFormatHandling);

      serializerProxy.DateFormatString = "yyyy";
      Assert.AreEqual("yyyy", serializerProxy.DateFormatString);

      serializerProxy.DateParseHandling = DateParseHandling.None;
      Assert.AreEqual(DateParseHandling.None, serializerProxy.DateParseHandling);

      serializerProxy.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
      Assert.AreEqual(DateTimeZoneHandling.Utc, serializerProxy.DateTimeZoneHandling);

      serializerProxy.DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate;
      Assert.AreEqual(DefaultValueHandling.IgnoreAndPopulate, serializerProxy.DefaultValueHandling);

      serializerProxy.FloatFormatHandling = FloatFormatHandling.Symbol;
      Assert.AreEqual(FloatFormatHandling.Symbol, serializerProxy.FloatFormatHandling);

      serializerProxy.FloatParseHandling = FloatParseHandling.Decimal;
      Assert.AreEqual(FloatParseHandling.Decimal, serializerProxy.FloatParseHandling);

      serializerProxy.Formatting = Formatting.Indented;
      Assert.AreEqual(Formatting.Indented, serializerProxy.Formatting);

      serializerProxy.MaxDepth = 9001;
      Assert.AreEqual(9001, serializerProxy.MaxDepth);

      serializerProxy.MissingMemberHandling = MissingMemberHandling.Error;
      Assert.AreEqual(MissingMemberHandling.Error, serializerProxy.MissingMemberHandling);

      serializerProxy.NullValueHandling = NullValueHandling.Ignore;
      Assert.AreEqual(NullValueHandling.Ignore, serializerProxy.NullValueHandling);

      serializerProxy.ObjectCreationHandling = ObjectCreationHandling.Replace;
      Assert.AreEqual(ObjectCreationHandling.Replace, serializerProxy.ObjectCreationHandling);

      serializerProxy.PreserveReferencesHandling = PreserveReferencesHandling.All;
      Assert.AreEqual(PreserveReferencesHandling.All, serializerProxy.PreserveReferencesHandling);

      serializerProxy.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
      Assert.AreEqual(ReferenceLoopHandling.Ignore, serializerProxy.ReferenceLoopHandling);

      IdReferenceResolver referenceResolver = new IdReferenceResolver();
      serializerProxy.ReferenceResolver = referenceResolver;
      Assert.AreEqual(referenceResolver, serializerProxy.ReferenceResolver);

      serializerProxy.StringEscapeHandling = StringEscapeHandling.EscapeNonAscii;
      Assert.AreEqual(StringEscapeHandling.EscapeNonAscii, serializerProxy.StringEscapeHandling);

      MemoryTraceWriter traceWriter = new MemoryTraceWriter();
      serializerProxy.TraceWriter = traceWriter;
      Assert.AreEqual(traceWriter, serializerProxy.TraceWriter);

#if !(PORTABLE || PORTABLE40 || NETFX_CORE || NET20)
      serializerProxy.TypeNameAssemblyFormat = FormatterAssemblyStyle.Full;
      Assert.AreEqual(FormatterAssemblyStyle.Full, serializerProxy.TypeNameAssemblyFormat);
#endif

      serializerProxy.TypeNameHandling = TypeNameHandling.All;
      Assert.AreEqual(TypeNameHandling.All, serializerProxy.TypeNameHandling);
    }

#if !(NETFX_CORE || PORTABLE || PORTABLE40)
    [Test]
    public void DeserializeISerializableIConvertible()
    {
      Ratio ratio = new Ratio(2, 1);
      string json = JsonConvert.SerializeObject(ratio);

      Assert.AreEqual(@"{""n"":2,""d"":1}", json);

      Ratio ratio2 = JsonConvert.DeserializeObject<Ratio>(json);

      Assert.AreEqual(ratio.Denominator, ratio2.Denominator);
      Assert.AreEqual(ratio.Numerator, ratio2.Numerator);
    }
#endif

    [Test]
    public void DeserializeLargeFloat()
    {
      object o = JsonConvert.DeserializeObject("100000000000000000000000000000000000000.0");

      CustomAssert.IsInstanceOfType(typeof(double), o);

      Assert.IsTrue(MathUtils.ApproxEquals(1E+38, (double)o));
    }

    [Test]
    public void SerializeDeserializeRegex()
    {
      Regex regex = new Regex("(hi)", RegexOptions.CultureInvariant);

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

      Regex r2 = JsonConvert.DeserializeObject<Regex>(json);

      Assert.AreEqual("(hi)", r2.ToString());
      Assert.AreEqual(RegexOptions.CultureInvariant, r2.Options);
    }

    [Test]
    public void ExtensionDataTest()
    {
      string json = @"{
  ""Ints"": [1,2,3],
  ""Ignored"": [1,2,3],
  ""Readonly"": ""Readonly"",
  ""Name"": ""Actually set!"",
  ""CustomName"": ""Wrong name!"",
  ""GetPrivate"": true,
  ""GetOnly"": true,
  ""NewValueSimple"": true,
  ""NewValueComplex"": [1,2,3]
}";

      ExtensionDataTestClass c = JsonConvert.DeserializeObject<ExtensionDataTestClass>(json);

      Assert.AreEqual("Actually set!", c.Name);
      Assert.AreEqual(4, c.Ints.Count);
      
      Assert.AreEqual("Readonly", (string)c.ExtensionData["Readonly"]);
      Assert.AreEqual("Wrong name!", (string)c.ExtensionData["CustomName"]);
      Assert.AreEqual(true, (bool)c.ExtensionData["GetPrivate"]);
      Assert.AreEqual(true, (bool)c.ExtensionData["GetOnly"]);
      Assert.AreEqual(true, (bool)c.ExtensionData["NewValueSimple"]);
      Assert.IsTrue(JToken.DeepEquals(new JArray(1, 2, 3), c.ExtensionData["NewValueComplex"]));
      Assert.IsTrue(JToken.DeepEquals(new JArray(1, 2, 3), c.ExtensionData["Ignored"]));

      Assert.AreEqual(7, c.ExtensionData.Count);
    }

    public class MultipleExtensionDataAttributesTestClass
    {
      public string Name { get; set; }
      [JsonExtensionData]
      internal IDictionary<string, JToken> ExtensionData1 { get; set; }
      [JsonExtensionData]
      internal IDictionary<string, JToken> ExtensionData2 { get; set; }
    }

    public class ExtensionDataAttributesInheritanceTestClass : MultipleExtensionDataAttributesTestClass
    {
      [JsonExtensionData]
      internal IDictionary<string, JToken> ExtensionData0 { get; set; }
    }

    public class FieldExtensionDataAttributeTestClass
    {
      [JsonExtensionData]
      internal IDictionary<object, object> ExtensionData;
    }

    public class PublicExtensionDataAttributeTestClass
    {
      public string Name { get; set; }
      [JsonExtensionData]
      public IDictionary<object, object> ExtensionData;
    }

    public class PublicNoReadExtensionDataAttributeTestClass
    {
      public string Name { get; set; }
      [JsonExtensionData(ReadData = false)]
      public IDictionary<object, object> ExtensionData;
    }

    public class PublicNoWriteExtensionDataAttributeTestClass
    {
      public string Name { get; set; }
      [JsonExtensionData(WriteData = false)]
      public IDictionary<object, object> ExtensionData;
    }

    public class PublicJTokenExtensionDataAttributeTestClass
    {
      public string Name { get; set; }
      [JsonExtensionData]
      public IDictionary<string, JToken> ExtensionData;
    }

    [Test]
    public void DeserializeDirectoryAccount()
    {
      string json = @"{'DisplayName':'John Smith', 'SAMAccountName':'contoso\\johns'}";

      DirectoryAccount account = JsonConvert.DeserializeObject<DirectoryAccount>(json);

      Assert.AreEqual("John Smith", account.DisplayName);
      Assert.AreEqual("contoso", account.Domain);
      Assert.AreEqual("johns", account.UserName);
    }

    [Test]
    public void SerializePublicExtensionData()
    {
      string json = JsonConvert.SerializeObject(new PublicExtensionDataAttributeTestClass
        {
          Name = "Name!",
          ExtensionData = new Dictionary<object, object>
            {
              { "Test", 1 }
            }
        });

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

    [Test]
    public void SerializePublicExtensionDataNull()
    {
      string json = JsonConvert.SerializeObject(new PublicExtensionDataAttributeTestClass
      {
        Name = "Name!"
      });

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

    [Test]
    public void SerializePublicNoWriteExtensionData()
    {
      string json = JsonConvert.SerializeObject(new PublicNoWriteExtensionDataAttributeTestClass
      {
        Name = "Name!",
        ExtensionData = new Dictionary<object, object>
            {
              { "Test", 1 }
            }
      });

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

    [Test]
    public void DeserializeNoReadPublicExtensionData()
    {
      PublicNoReadExtensionDataAttributeTestClass c = JsonConvert.DeserializeObject<PublicNoReadExtensionDataAttributeTestClass>(@"{""Name"":""Name!"",""Test"":1}");

      Assert.AreEqual(null, c.ExtensionData);
    }

    [Test]
    public void SerializePublicExtensionDataCircularReference()
    {
      var c = new PublicExtensionDataAttributeTestClass
        {
          Name = "Name!",
          ExtensionData = new Dictionary<object, object>
            {
              { "Test", 1 }
            }
        };
      c.ExtensionData["Self"] = c;

      string json = JsonConvert.SerializeObject(c, new JsonSerializerSettings
        {
          PreserveReferencesHandling = PreserveReferencesHandling.All,
          Formatting = Formatting.Indented
        });

      Assert.AreEqual(@"{
  ""$id"": ""1"",
  ""Name"": ""Name!"",
  ""Test"": 1,
  ""Self"": {
    ""$ref"": ""1""
  }
}", json);

      var c2 = JsonConvert.DeserializeObject<PublicExtensionDataAttributeTestClass>(json, new JsonSerializerSettings
        {
          PreserveReferencesHandling = PreserveReferencesHandling.All
        });

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

      PublicExtensionDataAttributeTestClass bizzaroC2 = (PublicExtensionDataAttributeTestClass)c2.ExtensionData["Self"];

      Assert.AreEqual(c2, bizzaroC2);
      Assert.AreEqual(1, (long)bizzaroC2.ExtensionData["Test"]);
    }

    [Test]
    public void DeserializePublicJTokenExtensionDataCircularReference()
    {
      string json = @"{
  ""$id"": ""1"",
  ""Name"": ""Name!"",
  ""Test"": 1,
  ""Self"": {
    ""$ref"": ""1""
  }
}";

      var c2 = JsonConvert.DeserializeObject<PublicJTokenExtensionDataAttributeTestClass>(json, new JsonSerializerSettings
      {
        PreserveReferencesHandling = PreserveReferencesHandling.All
      });

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

      JObject bizzaroC2 = (JObject)c2.ExtensionData["Self"];

      Assert.AreEqual("Name!", (string)bizzaroC2["Name"]);
      Assert.AreEqual(1, (int)bizzaroC2["Test"]);

      Assert.AreEqual(1, (int)c2.ExtensionData["Test"]);
    }

    [Test]
    public void DeserializePublicExtensionDataTypeNamdHandling()
    {
      string json = @"{
  ""$id"": ""1"",
  ""Name"": ""Name!"",
  ""Test"": 1,
  ""Self"": {
    ""$type"": ""Newtonsoft.Json.Tests.TestObjects.WagePerson, Newtonsoft.Json.Tests"",
    ""HourlyWage"": 2.0,
    ""Name"": null,
    ""BirthDate"": ""0001-01-01T00:00:00"",
    ""LastModified"": ""0001-01-01T00:00:00""
  }
}";

      PublicExtensionDataAttributeTestClass c2 = JsonConvert.DeserializeObject<PublicExtensionDataAttributeTestClass>(json, new JsonSerializerSettings
      {
        TypeNameHandling = TypeNameHandling.Objects
      });

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

      WagePerson bizzaroC2 = (WagePerson)c2.ExtensionData["Self"];

      Assert.AreEqual(2m, bizzaroC2.HourlyWage);
    }

    [Test]
    public void SerializePublicExtensionDataTypeNamdHandling()
    {
      PublicExtensionDataAttributeTestClass c = new PublicExtensionDataAttributeTestClass
        {
          Name = "Name!",
          ExtensionData = new Dictionary<object, object>
            {
              {
                "Test", new WagePerson
                  {
                    HourlyWage = 2.1m
                  }
              }
            }
        };

      string json = JsonConvert.SerializeObject(c, new JsonSerializerSettings
        {
          TypeNameHandling = TypeNameHandling.Objects,
          Formatting = Formatting.Indented
        });

      Assert.AreEqual(@"{
  ""$type"": ""Newtonsoft.Json.Tests.Serialization.JsonSerializerTest+PublicExtensionDataAttributeTestClass, Newtonsoft.Json.Tests"",
  ""Name"": ""Name!"",
  ""Test"": {
    ""$type"": ""Newtonsoft.Json.Tests.TestObjects.WagePerson, Newtonsoft.Json.Tests"",
    ""HourlyWage"": 2.1,
    ""Name"": null,
    ""BirthDate"": ""0001-01-01T00:00:00"",
    ""LastModified"": ""0001-01-01T00:00:00""
  }
}", json);
    }

    [Test]
    public void DeserializePublicExtensionData()
    {
      string json = @"{
  'Name':'Name!',
  'NoMatch':'NoMatch!',
  'ExtensionData':{'HAI':true}
}";

      var c = JsonConvert.DeserializeObject<PublicExtensionDataAttributeTestClass>(json);

      Assert.AreEqual("Name!", c.Name);
      Assert.AreEqual(2, c.ExtensionData.Count);

      Assert.AreEqual("NoMatch!", (string)c.ExtensionData["NoMatch"]);

      // the ExtensionData property is put into the extension data
      // inception
      var o = (JObject)c.ExtensionData["ExtensionData"];
      Assert.AreEqual(1, o.Count);
      Assert.IsTrue(JToken.DeepEquals(new JObject { { "HAI", true } }, o));
    }

    [Test]
    public void FieldExtensionDataAttributeTest_Serialize()
    {
      FieldExtensionDataAttributeTestClass c = new FieldExtensionDataAttributeTestClass
        {
          ExtensionData = new Dictionary<object, object>()
        };

      string json = JsonConvert.SerializeObject(c);

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

    [Test]
    public void FieldExtensionDataAttributeTest_Deserialize()
    {
      var c = JsonConvert.DeserializeObject<FieldExtensionDataAttributeTestClass>("{'first':1,'second':2}");

      Assert.AreEqual(2, c.ExtensionData.Count);
      Assert.AreEqual(1, (long)c.ExtensionData["first"]);
      Assert.AreEqual(2, (long)c.ExtensionData["second"]);
    }

    [Test]
    public void MultipleExtensionDataAttributesTest()
    {
      var c = JsonConvert.DeserializeObject<MultipleExtensionDataAttributesTestClass>("{'first':[1],'second':[2]}");

      Assert.AreEqual(null, c.ExtensionData1);
      Assert.AreEqual(2, c.ExtensionData2.Count);
      Assert.AreEqual(1, (int)((JArray)c.ExtensionData2["first"])[0]);
      Assert.AreEqual(2, (int)((JArray)c.ExtensionData2["second"])[0]);
    }

    [Test]
    public void ExtensionDataAttributesInheritanceTest()
    {
      var c = JsonConvert.DeserializeObject<ExtensionDataAttributesInheritanceTestClass>("{'first':1,'second':2}");

      Assert.AreEqual(null, c.ExtensionData1);
      Assert.AreEqual(null, c.ExtensionData2);
      Assert.AreEqual(2, c.ExtensionData0.Count);
      Assert.AreEqual(1, (int)c.ExtensionData0["first"]);
      Assert.AreEqual(2, (int)c.ExtensionData0["second"]);
    }

    [Test]
    public void GenericCollectionInheritance()
    {
      string json;

      GenericClass<GenericItem<string>, string> foo1 = new GenericClass<GenericItem<string>, string>();
      foo1.Items.Add(new GenericItem<string> {Value = "Hello"});

      json = JsonConvert.SerializeObject(new {selectList = foo1});
      Assert.AreEqual(@"{""selectList"":[{""Value"":""Hello""}]}", json);

      GenericClass<NonGenericItem, string> foo2 = new GenericClass<NonGenericItem, string>();
      foo2.Items.Add(new NonGenericItem {Value = "Hello"});

      json = JsonConvert.SerializeObject(new { selectList = foo2 });
      Assert.AreEqual(@"{""selectList"":[{""Value"":""Hello""}]}", json);

      NonGenericClass foo3 = new NonGenericClass();
      foo3.Items.Add(new NonGenericItem {Value = "Hello"});

      json = JsonConvert.SerializeObject(new { selectList = foo3 });
      Assert.AreEqual(@"{""selectList"":[{""Value"":""Hello""}]}", json);
    }

#if !NET20
    [DataContract]
    public class BaseDataContractWithHidden
    {
      [DataMember(Name = "virtualMember")]
      public virtual string VirtualMember { get; set; }

      [DataMember(Name = "nonVirtualMember")]
      public string NonVirtualMember { get; set; }

      public virtual object NewMember { get; set; }
    }

    public class ChildDataContractWithHidden : BaseDataContractWithHidden
    {
      [DataMember(Name = "NewMember")]
      public virtual new string NewMember { get; set; }
      public override string VirtualMember { get; set; }
      public string AddedMember { get; set; }
    }

    [Test]
    public void ChildDataContractTestWithHidden()
    {
      var cc = new ChildDataContractWithHidden
      {
        VirtualMember = "VirtualMember!",
        NonVirtualMember = "NonVirtualMember!",
        NewMember = "NewMember!"
      };

      string result = JsonConvert.SerializeObject(cc);
      Assert.AreEqual(@"{""NewMember"":""NewMember!"",""virtualMember"":""VirtualMember!"",""nonVirtualMember"":""NonVirtualMember!""}", result);
    }

    // ignore hiding members compiler warning
#pragma warning disable 108,114
    [DataContract]
    public class BaseWithContract
    {
      [DataMember(Name = "VirtualWithDataMemberBase")]
      public virtual string VirtualWithDataMember { get; set; }
      [DataMember]
      public virtual string Virtual { get; set; }
      [DataMember(Name = "WithDataMemberBase")]
      public string WithDataMember { get; set; }
      [DataMember]
      public string JustAProperty { get; set; }
    }

    [DataContract]
    public class BaseWithoutContract
    {
      [DataMember(Name = "VirtualWithDataMemberBase")]
      public virtual string VirtualWithDataMember { get; set; }
      [DataMember]
      public virtual string Virtual { get; set; }
      [DataMember(Name = "WithDataMemberBase")]
      public string WithDataMember { get; set; }
      [DataMember]
      public string JustAProperty { get; set; }
    }

    [DataContract]
    public class SubWithoutContractNewProperties : BaseWithContract
    {
      [DataMember(Name = "VirtualWithDataMemberSub")]
      public string VirtualWithDataMember { get; set; }
      public string Virtual { get; set; }
      [DataMember(Name = "WithDataMemberSub")]
      public string WithDataMember { get; set; }
      public string JustAProperty { get; set; }
    }

    [DataContract]
    public class SubWithoutContractVirtualProperties : BaseWithContract
    {
      public override string VirtualWithDataMember { get; set; }
      [DataMember(Name = "VirtualSub")]
      public override string Virtual { get; set; }
    }

    [DataContract]
    public class SubWithContractNewProperties : BaseWithContract
    {
      [DataMember(Name = "VirtualWithDataMemberSub")]
      public string VirtualWithDataMember { get; set; }
      [DataMember(Name = "Virtual2")]
      public string Virtual { get; set; }
      [DataMember(Name = "WithDataMemberSub")]
      public string WithDataMember { get; set; }
      [DataMember(Name = "JustAProperty2")]
      public string JustAProperty { get; set; }
    }

    [DataContract]
    public class SubWithContractVirtualProperties : BaseWithContract
    {
      [DataMember(Name = "VirtualWithDataMemberSub")]
      public virtual string VirtualWithDataMember { get; set; }
    }
#pragma warning restore 108,114

    [Test]
    public void SubWithoutContractNewPropertiesTest()
    {
      BaseWithContract baseWith = new SubWithoutContractNewProperties
        {
          JustAProperty = "JustAProperty!",
          Virtual = "Virtual!",
          VirtualWithDataMember = "VirtualWithDataMember!",
          WithDataMember = "WithDataMember!"
        };

      baseWith.JustAProperty = "JustAProperty2!";
      baseWith.Virtual = "Virtual2!";
      baseWith.VirtualWithDataMember = "VirtualWithDataMember2!";
      baseWith.WithDataMember = "WithDataMember2!";

      string json = AssertSerializeDeserializeEqual(baseWith);

      Assert.AreEqual(@"{
  ""JustAProperty"": ""JustAProperty2!"",
  ""Virtual"": ""Virtual2!"",
  ""VirtualWithDataMemberBase"": ""VirtualWithDataMember2!"",
  ""VirtualWithDataMemberSub"": ""VirtualWithDataMember!"",
  ""WithDataMemberBase"": ""WithDataMember2!"",
  ""WithDataMemberSub"": ""WithDataMember!""
}", json);
    }

    [Test]
    public void SubWithoutContractVirtualPropertiesTest()
    {
      BaseWithContract baseWith = new SubWithoutContractVirtualProperties
      {
        JustAProperty = "JustAProperty!",
        Virtual = "Virtual!",
        VirtualWithDataMember = "VirtualWithDataMember!",
        WithDataMember = "WithDataMember!"
      };

      baseWith.JustAProperty = "JustAProperty2!";
      baseWith.Virtual = "Virtual2!";
      baseWith.VirtualWithDataMember = "VirtualWithDataMember2!";
      baseWith.WithDataMember = "WithDataMember2!";

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

      Console.WriteLine(json);

      Assert.AreEqual(@"{
  ""VirtualWithDataMemberBase"": ""VirtualWithDataMember2!"",
  ""VirtualSub"": ""Virtual2!"",
  ""WithDataMemberBase"": ""WithDataMember2!"",
  ""JustAProperty"": ""JustAProperty2!""
}", json);
    }

    [Test]
    public void SubWithContractNewPropertiesTest()
    {
      BaseWithContract baseWith = new SubWithContractNewProperties
      {
        JustAProperty = "JustAProperty!",
        Virtual = "Virtual!",
        VirtualWithDataMember = "VirtualWithDataMember!",
        WithDataMember = "WithDataMember!"
      };

      baseWith.JustAProperty = "JustAProperty2!";
      baseWith.Virtual = "Virtual2!";
      baseWith.VirtualWithDataMember = "VirtualWithDataMember2!";
      baseWith.WithDataMember = "WithDataMember2!";

      string json = AssertSerializeDeserializeEqual(baseWith);

      Assert.AreEqual(@"{
  ""JustAProperty"": ""JustAProperty2!"",
  ""JustAProperty2"": ""JustAProperty!"",
  ""Virtual"": ""Virtual2!"",
  ""Virtual2"": ""Virtual!"",
  ""VirtualWithDataMemberBase"": ""VirtualWithDataMember2!"",
  ""VirtualWithDataMemberSub"": ""VirtualWithDataMember!"",
  ""WithDataMemberBase"": ""WithDataMember2!"",
  ""WithDataMemberSub"": ""WithDataMember!""
}", json);
    }

    [Test]
    public void SubWithContractVirtualPropertiesTest()
    {
      BaseWithContract baseWith = new SubWithContractVirtualProperties
      {
        JustAProperty = "JustAProperty!",
        Virtual = "Virtual!",
        VirtualWithDataMember = "VirtualWithDataMember!",
        WithDataMember = "WithDataMember!"
      };

      baseWith.JustAProperty = "JustAProperty2!";
      baseWith.Virtual = "Virtual2!";
      baseWith.VirtualWithDataMember = "VirtualWithDataMember2!";
      baseWith.WithDataMember = "WithDataMember2!";

      string json = AssertSerializeDeserializeEqual(baseWith);

      Assert.AreEqual(@"{
  ""JustAProperty"": ""JustAProperty2!"",
  ""Virtual"": ""Virtual2!"",
  ""VirtualWithDataMemberBase"": ""VirtualWithDataMember2!"",
  ""VirtualWithDataMemberSub"": ""VirtualWithDataMember!"",
  ""WithDataMemberBase"": ""WithDataMember2!""
}", json);
    }

    private string AssertSerializeDeserializeEqual(object o)
    {
      MemoryStream ms = new MemoryStream();
      DataContractJsonSerializer s = new DataContractJsonSerializer(o.GetType());
      s.WriteObject(ms, o);

      var data = ms.ToArray();
      JObject dataContractJson = JObject.Parse(Encoding.UTF8.GetString(data, 0, data.Length));
      dataContractJson = new JObject(dataContractJson.Properties().OrderBy(p => p.Name));

      JObject jsonNetJson = JObject.Parse(JsonConvert.SerializeObject(o));
      jsonNetJson = new JObject(jsonNetJson.Properties().OrderBy(p => p.Name));

      Console.WriteLine("Results for " + o.GetType().Name);
      Console.WriteLine("DataContractJsonSerializer: " + dataContractJson);
      Console.WriteLine("JsonDotNetSerializer      : " + jsonNetJson);

      Assert.AreEqual(dataContractJson.Count, jsonNetJson.Count);
      foreach (KeyValuePair<string, JToken> property in dataContractJson)
      {
        Assert.IsTrue(JToken.DeepEquals(jsonNetJson[property.Key], property.Value), "Property not equal: " + property.Key);
      }

      return jsonNetJson.ToString();
    }
#endif

    [Test]
    public void PersonTypedObjectDeserialization()
    {
      Store store = new Store();

      string jsonText = JsonConvert.SerializeObject(store);

      Store deserializedStore = (Store)JsonConvert.DeserializeObject(jsonText, typeof(Store));

      Assert.AreEqual(store.Establised, deserializedStore.Establised);
      Assert.AreEqual(store.product.Count, deserializedStore.product.Count);

      Console.WriteLine(jsonText);
    }

    [Test]
    public void TypedObjectDeserialization()
    {
      Product product = new Product();

      product.Name = "Apple";
      product.ExpiryDate = new DateTime(2008, 12, 28);
      product.Price = 3.99M;
      product.Sizes = new string[] { "Small", "Medium", "Large" };

      string output = JsonConvert.SerializeObject(product);
      //{
      //  "Name": "Apple",
      //  "ExpiryDate": "\/Date(1230375600000+1300)\/",
      //  "Price": 3.99,
      //  "Sizes": [
      //    "Small",
      //    "Medium",
      //    "Large"
      //  ]
      //}

      Product deserializedProduct = (Product)JsonConvert.DeserializeObject(output, typeof(Product));

      Assert.AreEqual("Apple", deserializedProduct.Name);
      Assert.AreEqual(new DateTime(2008, 12, 28), deserializedProduct.ExpiryDate);
      Assert.AreEqual(3.99m, deserializedProduct.Price);
      Assert.AreEqual("Small", deserializedProduct.Sizes[0]);
      Assert.AreEqual("Medium", deserializedProduct.Sizes[1]);
      Assert.AreEqual("Large", deserializedProduct.Sizes[2]);
    }

    //[Test]
    //public void Advanced()
    //{
    //  Product product = new Product();
    //  product.ExpiryDate = new DateTime(2008, 12, 28);

    //  JsonSerializer serializer = new JsonSerializer();
    //  serializer.Converters.Add(new JavaScriptDateTimeConverter());
    //  serializer.NullValueHandling = NullValueHandling.Ignore;

    //  using (StreamWriter sw = new StreamWriter(@"c:\json.txt"))
    //  using (JsonWriter writer = new JsonTextWriter(sw))
    //  {
    //    serializer.Serialize(writer, product);
    //    // {"ExpiryDate":new Date(1230375600000),"Price":0}
    //  }
    //}

    [Test]
    public void JsonConvertSerializer()
    {
      string value = @"{""Name"":""Orange"", ""Price"":3.99, ""ExpiryDate"":""01/24/2010 12:00:00""}";

      Product p = JsonConvert.DeserializeObject(value, typeof(Product)) as Product;

      Assert.AreEqual("Orange", p.Name);
      Assert.AreEqual(new DateTime(2010, 1, 24, 12, 0, 0), p.ExpiryDate);
      Assert.AreEqual(3.99m, p.Price);
    }

    [Test]
    public void DeserializeJavaScriptDate()
    {
      DateTime dateValue = new DateTime(2010, 3, 30);
      Dictionary<string, object> testDictionary = new Dictionary<string, object>();
      testDictionary["date"] = dateValue;

      string jsonText = JsonConvert.SerializeObject(testDictionary);

#if !NET20
      MemoryStream ms = new MemoryStream();
      DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(Dictionary<string, object>));
      serializer.WriteObject(ms, testDictionary);

      byte[] data = ms.ToArray();
      string output = Encoding.UTF8.GetString(data, 0, data.Length);
#endif

      Dictionary<string, object> deserializedDictionary = (Dictionary<string, object>)JsonConvert.DeserializeObject(jsonText, typeof(Dictionary<string, object>));
      DateTime deserializedDate = (DateTime)deserializedDictionary["date"];

      Assert.AreEqual(dateValue, deserializedDate);
    }

    [Test]
    public void TestMethodExecutorObject()
    {
      MethodExecutorObject executorObject = new MethodExecutorObject();
      executorObject.serverClassName = "BanSubs";
      executorObject.serverMethodParams = new object[] { "21321546", "101", "1236", "D:\\1.txt" };
      executorObject.clientGetResultFunction = "ClientBanSubsCB";

      string output = JsonConvert.SerializeObject(executorObject);

      MethodExecutorObject executorObject2 = JsonConvert.DeserializeObject(output, typeof(MethodExecutorObject)) as MethodExecutorObject;

      Assert.AreNotSame(executorObject, executorObject2);
      Assert.AreEqual(executorObject2.serverClassName, "BanSubs");
      Assert.AreEqual(executorObject2.serverMethodParams.Length, 4);
      CustomAssert.Contains(executorObject2.serverMethodParams, "101");
      Assert.AreEqual(executorObject2.clientGetResultFunction, "ClientBanSubsCB");
    }

#if !SILVERLIGHT && !NETFX_CORE
    [Test]
    public void HashtableDeserialization()
    {
      string value = @"{""Name"":""Orange"", ""Price"":3.99, ""ExpiryDate"":""01/24/2010 12:00:00""}";

      Hashtable p = JsonConvert.DeserializeObject(value, typeof(Hashtable)) as Hashtable;

      Assert.AreEqual("Orange", p["Name"].ToString());
    }

    [Test]
    public void TypedHashtableDeserialization()
    {
      string value = @"{""Name"":""Orange"", ""Hash"":{""ExpiryDate"":""01/24/2010 12:00:00"",""UntypedArray"":[""01/24/2010 12:00:00""]}}";

      TypedSubHashtable p = JsonConvert.DeserializeObject(value, typeof(TypedSubHashtable)) as TypedSubHashtable;

      Assert.AreEqual("01/24/2010 12:00:00", p.Hash["ExpiryDate"].ToString());
      Assert.AreEqual(@"[
  ""01/24/2010 12:00:00""
]", p.Hash["UntypedArray"].ToString());
    }
#endif

    [Test]
    public void SerializeDeserializeGetOnlyProperty()
    {
      string value = JsonConvert.SerializeObject(new GetOnlyPropertyClass());

      GetOnlyPropertyClass c = JsonConvert.DeserializeObject<GetOnlyPropertyClass>(value);

      Assert.AreEqual(c.Field, "Field");
      Assert.AreEqual(c.GetOnlyProperty, "GetOnlyProperty");
    }

    [Test]
    public void SerializeDeserializeSetOnlyProperty()
    {
      string value = JsonConvert.SerializeObject(new SetOnlyPropertyClass());

      SetOnlyPropertyClass c = JsonConvert.DeserializeObject<SetOnlyPropertyClass>(value);

      Assert.AreEqual(c.Field, "Field");
    }

    [Test]
    public void JsonIgnoreAttributeTest()
    {
      string json = JsonConvert.SerializeObject(new JsonIgnoreAttributeTestClass());

      Assert.AreEqual(@"{""Field"":0,""Property"":21}", json);

      JsonIgnoreAttributeTestClass c = JsonConvert.DeserializeObject<JsonIgnoreAttributeTestClass>(@"{""Field"":99,""Property"":-1,""IgnoredField"":-1,""IgnoredObject"":[1,2,3,4,5]}");

      Assert.AreEqual(0, c.IgnoredField);
      Assert.AreEqual(99, c.Field);
    }

    [Test]
    public void GoogleSearchAPI()
    {
      string json = @"{
    results:
        [
            {
                GsearchResultClass:""GwebSearch"",
                unescapedUrl : ""http://www.google.com/"",
                url : ""http://www.google.com/"",
                visibleUrl : ""www.google.com"",
                cacheUrl : 
""http://www.google.com/search?q=cache:zhool8dxBV4J:www.google.com"",
                title : ""Google"",
                titleNoFormatting : ""Google"",
                content : ""Enables users to search the Web, Usenet, and 
images. Features include PageRank,   caching and translation of 
results, and an option to find similar pages.""
            },
            {
                GsearchResultClass:""GwebSearch"",
                unescapedUrl : ""http://news.google.com/"",
                url : ""http://news.google.com/"",
                visibleUrl : ""news.google.com"",
                cacheUrl : 
""http://www.google.com/search?q=cache:Va_XShOz_twJ:news.google.com"",
                title : ""Google News"",
                titleNoFormatting : ""Google News"",
                content : ""Aggregated headlines and a search engine of many of the world's news sources.""
            },
            
            {
                GsearchResultClass:""GwebSearch"",
                unescapedUrl : ""http://groups.google.com/"",
                url : ""http://groups.google.com/"",
                visibleUrl : ""groups.google.com"",
                cacheUrl : 
""http://www.google.com/search?q=cache:x2uPD3hfkn0J:groups.google.com"",
                title : ""Google Groups"",
                titleNoFormatting : ""Google Groups"",
                content : ""Enables users to search and browse the Usenet 
archives which consist of over 700   million messages, and post new 
comments.""
            },
            
            {
                GsearchResultClass:""GwebSearch"",
                unescapedUrl : ""http://maps.google.com/"",
                url : ""http://maps.google.com/"",
                visibleUrl : ""maps.google.com"",
                cacheUrl : 
""http://www.google.com/search?q=cache:dkf5u2twBXIJ:maps.google.com"",
                title : ""Google Maps"",
                titleNoFormatting : ""Google Maps"",
                content : ""Provides directions, interactive maps, and 
satellite/aerial imagery of the United   States. Can also search by 
keyword such as type of business.""
            }
        ],
        
    adResults:
        [
            {
                GsearchResultClass:""GwebSearch.ad"",
                title : ""Gartner Symposium/ITxpo"",
                content1 : ""Meet brilliant Gartner IT analysts"",
                content2 : ""20-23 May 2007- Barcelona, Spain"",
                url : 
""http://www.google.com/url?sa=L&ai=BVualExYGRo3hD5ianAPJvejjD8-s6ye7kdTwArbI4gTAlrECEAEYASDXtMMFOAFQubWAjvr_____AWDXw_4EiAEBmAEAyAEBgAIB&num=1&q=http://www.gartner.com/it/sym/2007/spr8/spr8.jsp%3Fsrc%3D_spain_07_%26WT.srch%3D1&usg=__CxRH06E4Xvm9Muq13S4MgMtnziY="", 

                impressionUrl : 
""http://www.google.com/uds/css/ad-indicator-on.gif?ai=BVualExYGRo3hD5ianAPJvejjD8-s6ye7kdTwArbI4gTAlrECEAEYASDXtMMFOAFQubWAjvr_____AWDXw_4EiAEBmAEAyAEBgAIB"", 

                unescapedUrl : 
""http://www.google.com/url?sa=L&ai=BVualExYGRo3hD5ianAPJvejjD8-s6ye7kdTwArbI4gTAlrECEAEYASDXtMMFOAFQubWAjvr_____AWDXw_4EiAEBmAEAyAEBgAIB&num=1&q=http://www.gartner.com/it/sym/2007/spr8/spr8.jsp%3Fsrc%3D_spain_07_%26WT.srch%3D1&usg=__CxRH06E4Xvm9Muq13S4MgMtnziY="", 

                visibleUrl : ""www.gartner.com""
            }
        ]
}
";
      object o = JsonConvert.DeserializeObject(json);
      string s = string.Empty;
      s += s;
    }

    [Test]
    public void TorrentDeserializeTest()
    {
      string jsonText = @"{
"""":"""",
""label"": [
       [""SomeName"",6]
],
""torrents"": [
       [""192D99A5C943555CB7F00A852821CF6D6DB3008A"",201,""filename.av…