/Src/Newtonsoft.Json.Tests/Serialization/JsonSerializerTest.cs
C# | 10919 lines | 9618 code | 1115 blank | 186 comment | 90 complexity | 81370c05b63ccbc8000265efea61c55d MD5 | raw file
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)
- using System.Numerics;
- #endif
- #if !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
- 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 !(NETFX_CORE)
- using System.Drawing;
- using System.Diagnostics;
- #endif
- namespace Newtonsoft.Json.Tests.Serialization
- {
- [TestFixture]
- public class JsonSerializerTest : TestFixtureBase
- {
- [Test]
- public void ExtensionDataWithNull()
- {
- string json = @"{
- 'TaxRate': 0.125,
- 'a':null
- }";
- var invoice = JsonConvert.DeserializeObject<ExtendedObject>(json);
- Assert.AreEqual(JTokenType.Null, invoice._additionalData["a"].Type);
- Assert.AreEqual(typeof(double), ((JValue)invoice._additionalData["TaxRate"]).Value.GetType());
- string result = JsonConvert.SerializeObject(invoice);
- Assert.AreEqual(@"{""TaxRate"":0.125,""a"":null}", result);
- }
- [Test]
- public void ExtensionDataFloatParseHandling()
- {
- string json = @"{
- 'TaxRate': 0.125,
- 'a':null
- }";
- var invoice = JsonConvert.DeserializeObject<ExtendedObject>(json, new JsonSerializerSettings
- {
- FloatParseHandling = FloatParseHandling.Decimal
- });
- Assert.AreEqual(typeof(decimal), ((JValue)invoice._additionalData["TaxRate"]).Value.GetType());
- }
- #pragma warning disable 649
- class ExtendedObject
- {
- [JsonExtensionData]
- internal IDictionary<string, JToken> _additionalData;
- }
- #pragma warning restore 649
- 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));
- }
- 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 virtual new 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 virtual new 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);
- Assert.AreEqual(input.Data, deserialized.Data);
- Assert.AreEqual(input.Message, deserialized.Message);
- Assert.AreEqual(input.Result, deserialized.Result);
- }
- [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 PublicExtensionDataAttributeTestClassWithNonDefaultConstructor
- {
- public string Name { get; set; }
- public PublicExtensionDataAttributeTestClassWithNonDefaultConstructor(string name)
- {
- Name = name;
- }
- [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 DeserializePublicExtensionDataTypeNamdHandlingNonDefaultConstructor()
- {
- 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""
- }
- }";
- PublicExtensionDataAttributeTestClassWithNonDefaultConstructor c2 = JsonConvert.DeserializeObject<PublicExtensionDataAttributeTestClassWithNonDefaultConstructor>(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 new virtual 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!""
- }", jso…
Large files files are truncated, but you can click here to view the full file