PageRenderTime 66ms CodeModel.GetById 22ms RepoModel.GetById 0ms app.codeStats 2ms

/Src/Newtonsoft.Json.Tests/Serialization/JsonSerializerTest.cs

https://github.com/rishabhjivan/Newtonsoft.Json
C# | 7989 lines | 7047 code | 841 blank | 101 comment | 61 complexity | 47375c7d5e276f3ea785fa4217096b31 MD5 | raw file
Possible License(s): LGPL-2.1

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

  1. #region License
  2. // Copyright (c) 2007 James Newton-King
  3. //
  4. // Permission is hereby granted, free of charge, to any person
  5. // obtaining a copy of this software and associated documentation
  6. // files (the "Software"), to deal in the Software without
  7. // restriction, including without limitation the rights to use,
  8. // copy, modify, merge, publish, distribute, sublicense, and/or sell
  9. // copies of the Software, and to permit persons to whom the
  10. // Software is furnished to do so, subject to the following
  11. // conditions:
  12. //
  13. // The above copyright notice and this permission notice shall be
  14. // included in all copies or substantial portions of the Software.
  15. //
  16. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  17. // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  18. // OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  19. // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  20. // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  21. // WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  22. // FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  23. // OTHER DEALINGS IN THE SOFTWARE.
  24. #endregion
  25. using System;
  26. using System.ComponentModel;
  27. #if !(NET35 || NET20)
  28. using System.Collections.Concurrent;
  29. #endif
  30. using System.Collections.Generic;
  31. #if !(NET20 || NET35 || PORTABLE)
  32. using System.Numerics;
  33. #endif
  34. #if !NET20 && !NETFX_CORE
  35. using System.ComponentModel.DataAnnotations;
  36. using System.Configuration;
  37. using System.Runtime.CompilerServices;
  38. using System.Runtime.Serialization.Formatters;
  39. using System.Threading;
  40. using System.Web.Script.Serialization;
  41. #endif
  42. using System.Text;
  43. using System.Text.RegularExpressions;
  44. #if !NETFX_CORE
  45. using NUnit.Framework;
  46. #else
  47. using Microsoft.VisualStudio.TestPlatform.UnitTestFramework;
  48. using TestFixture = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestClassAttribute;
  49. using Test = Microsoft.VisualStudio.TestPlatform.UnitTestFramework.TestMethodAttribute;
  50. #endif
  51. using Newtonsoft.Json;
  52. using System.IO;
  53. using System.Collections;
  54. using System.Xml;
  55. using System.Xml.Serialization;
  56. using System.Collections.ObjectModel;
  57. using Newtonsoft.Json.Bson;
  58. using Newtonsoft.Json.Linq;
  59. using Newtonsoft.Json.Converters;
  60. #if !NET20
  61. using System.Runtime.Serialization.Json;
  62. #endif
  63. using Newtonsoft.Json.Serialization;
  64. using Newtonsoft.Json.Tests.Linq;
  65. using Newtonsoft.Json.Tests.TestObjects;
  66. using System.Runtime.Serialization;
  67. using System.Globalization;
  68. using Newtonsoft.Json.Utilities;
  69. using System.Reflection;
  70. #if !NET20
  71. using System.Xml.Linq;
  72. using System.Collections.Specialized;
  73. using System.Linq.Expressions;
  74. #endif
  75. #if !(NET35 || NET20)
  76. using System.Dynamic;
  77. #endif
  78. #if NET20
  79. using Newtonsoft.Json.Utilities.LinqBridge;
  80. #else
  81. using System.Linq;
  82. #endif
  83. #if !(NETFX_CORE)
  84. using System.Drawing;
  85. using System.Diagnostics;
  86. #endif
  87. namespace Newtonsoft.Json.Tests.Serialization
  88. {
  89. [TestFixture]
  90. public class JsonSerializerTest : TestFixtureBase
  91. {
  92. public class BaseClass
  93. {
  94. internal bool IsTransient { get; set; }
  95. }
  96. public class ChildClass : BaseClass
  97. {
  98. public new bool IsTransient { get; set; }
  99. }
  100. [Test]
  101. public void NewProperty()
  102. {
  103. Assert.AreEqual(@"{""IsTransient"":true}", JsonConvert.SerializeObject(new ChildClass { IsTransient = true }));
  104. var childClass = JsonConvert.DeserializeObject<ChildClass>(@"{""IsTransient"":true}");
  105. Assert.AreEqual(true, childClass.IsTransient);
  106. }
  107. public class BaseClassVirtual
  108. {
  109. internal virtual bool IsTransient { get; set; }
  110. }
  111. public class ChildClassVirtual : BaseClassVirtual
  112. {
  113. public virtual new bool IsTransient { get; set; }
  114. }
  115. [Test]
  116. public void NewPropertyVirtual()
  117. {
  118. Assert.AreEqual(@"{""IsTransient"":true}", JsonConvert.SerializeObject(new ChildClassVirtual { IsTransient = true }));
  119. var childClass = JsonConvert.DeserializeObject<ChildClassVirtual>(@"{""IsTransient"":true}");
  120. Assert.AreEqual(true, childClass.IsTransient);
  121. }
  122. public class ResponseWithNewGenericProperty<T> : SimpleResponse
  123. {
  124. public new T Data { get; set; }
  125. }
  126. public class ResponseWithNewGenericPropertyVirtual<T> : SimpleResponse
  127. {
  128. public virtual new T Data { get; set; }
  129. }
  130. public class ResponseWithNewGenericPropertyOverride<T> : ResponseWithNewGenericPropertyVirtual<T>
  131. {
  132. public override T Data { get; set; }
  133. }
  134. public abstract class SimpleResponse
  135. {
  136. public string Result { get; set; }
  137. public string Message { get; set; }
  138. public object Data { get; set; }
  139. protected SimpleResponse()
  140. {
  141. }
  142. protected SimpleResponse(string message)
  143. {
  144. Message = message;
  145. }
  146. }
  147. [Test]
  148. public void CanSerializeWithBuiltInTypeAsGenericArgument()
  149. {
  150. var input = new ResponseWithNewGenericProperty<int>()
  151. {
  152. Message = "Trying out integer as type parameter",
  153. Data = 25,
  154. Result = "This should be fine"
  155. };
  156. var json = JsonConvert.SerializeObject(input);
  157. var deserialized = JsonConvert.DeserializeObject<ResponseWithNewGenericProperty<int>>(json);
  158. Assert.AreEqual(input.Data, deserialized.Data);
  159. Assert.AreEqual(input.Message, deserialized.Message);
  160. Assert.AreEqual(input.Result, deserialized.Result);
  161. }
  162. [Test]
  163. public void CanSerializeWithBuiltInTypeAsGenericArgumentVirtual()
  164. {
  165. var input = new ResponseWithNewGenericPropertyVirtual<int>()
  166. {
  167. Message = "Trying out integer as type parameter",
  168. Data = 25,
  169. Result = "This should be fine"
  170. };
  171. var json = JsonConvert.SerializeObject(input);
  172. var deserialized = JsonConvert.DeserializeObject<ResponseWithNewGenericPropertyVirtual<int>>(json);
  173. Assert.AreEqual(input.Data, deserialized.Data);
  174. Assert.AreEqual(input.Message, deserialized.Message);
  175. Assert.AreEqual(input.Result, deserialized.Result);
  176. }
  177. [Test]
  178. public void CanSerializeWithBuiltInTypeAsGenericArgumentOverride()
  179. {
  180. var input = new ResponseWithNewGenericPropertyOverride<int>()
  181. {
  182. Message = "Trying out integer as type parameter",
  183. Data = 25,
  184. Result = "This should be fine"
  185. };
  186. var json = JsonConvert.SerializeObject(input);
  187. var deserialized = JsonConvert.DeserializeObject<ResponseWithNewGenericPropertyOverride<int>>(json);
  188. Assert.AreEqual(input.Data, deserialized.Data);
  189. Assert.AreEqual(input.Message, deserialized.Message);
  190. Assert.AreEqual(input.Result, deserialized.Result);
  191. }
  192. [Test]
  193. public void CanSerializedWithGenericClosedTypeAsArgument()
  194. {
  195. var input = new ResponseWithNewGenericProperty<List<int>>()
  196. {
  197. Message = "More complex case - generic list of int",
  198. Data = Enumerable.Range(50, 70).ToList(),
  199. Result = "This should be fine too"
  200. };
  201. var json = JsonConvert.SerializeObject(input);
  202. var deserialized = JsonConvert.DeserializeObject<ResponseWithNewGenericProperty<List<int>>>(json);
  203. CollectionAssert.AreEqual(input.Data, deserialized.Data);
  204. Assert.AreEqual(input.Message, deserialized.Message);
  205. Assert.AreEqual(input.Result, deserialized.Result);
  206. }
  207. [Test]
  208. public void JsonSerializerProperties()
  209. {
  210. JsonSerializer serializer = new JsonSerializer();
  211. DefaultSerializationBinder customBinder = new DefaultSerializationBinder();
  212. serializer.Binder = customBinder;
  213. Assert.AreEqual(customBinder, serializer.Binder);
  214. serializer.CheckAdditionalContent = true;
  215. Assert.AreEqual(true, serializer.CheckAdditionalContent);
  216. serializer.ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor;
  217. Assert.AreEqual(ConstructorHandling.AllowNonPublicDefaultConstructor, serializer.ConstructorHandling);
  218. #if !NETFX_CORE
  219. serializer.Context = new StreamingContext(StreamingContextStates.Other);
  220. Assert.AreEqual(new StreamingContext(StreamingContextStates.Other), serializer.Context);
  221. #endif
  222. CamelCasePropertyNamesContractResolver resolver = new CamelCasePropertyNamesContractResolver();
  223. serializer.ContractResolver = resolver;
  224. Assert.AreEqual(resolver, serializer.ContractResolver);
  225. serializer.Converters.Add(new StringEnumConverter());
  226. Assert.AreEqual(1, serializer.Converters.Count);
  227. serializer.Culture = new CultureInfo("en-nz");
  228. Assert.AreEqual("en-NZ", serializer.Culture.ToString());
  229. serializer.DateFormatHandling = DateFormatHandling.MicrosoftDateFormat;
  230. Assert.AreEqual(DateFormatHandling.MicrosoftDateFormat, serializer.DateFormatHandling);
  231. serializer.DateFormatString = "yyyy";
  232. Assert.AreEqual("yyyy", serializer.DateFormatString);
  233. serializer.DateParseHandling = DateParseHandling.None;
  234. Assert.AreEqual(DateParseHandling.None, serializer.DateParseHandling);
  235. serializer.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
  236. Assert.AreEqual(DateTimeZoneHandling.Utc, serializer.DateTimeZoneHandling);
  237. serializer.DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate;
  238. Assert.AreEqual(DefaultValueHandling.IgnoreAndPopulate, serializer.DefaultValueHandling);
  239. serializer.FloatFormatHandling = FloatFormatHandling.Symbol;
  240. Assert.AreEqual(FloatFormatHandling.Symbol, serializer.FloatFormatHandling);
  241. serializer.FloatParseHandling = FloatParseHandling.Decimal;
  242. Assert.AreEqual(FloatParseHandling.Decimal, serializer.FloatParseHandling);
  243. serializer.Formatting = Formatting.Indented;
  244. Assert.AreEqual(Formatting.Indented, serializer.Formatting);
  245. serializer.MaxDepth = 9001;
  246. Assert.AreEqual(9001, serializer.MaxDepth);
  247. serializer.MissingMemberHandling = MissingMemberHandling.Error;
  248. Assert.AreEqual(MissingMemberHandling.Error, serializer.MissingMemberHandling);
  249. serializer.NullValueHandling = NullValueHandling.Ignore;
  250. Assert.AreEqual(NullValueHandling.Ignore, serializer.NullValueHandling);
  251. serializer.ObjectCreationHandling = ObjectCreationHandling.Replace;
  252. Assert.AreEqual(ObjectCreationHandling.Replace, serializer.ObjectCreationHandling);
  253. serializer.PreserveReferencesHandling = PreserveReferencesHandling.All;
  254. Assert.AreEqual(PreserveReferencesHandling.All, serializer.PreserveReferencesHandling);
  255. serializer.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
  256. Assert.AreEqual(ReferenceLoopHandling.Ignore, serializer.ReferenceLoopHandling);
  257. IdReferenceResolver referenceResolver = new IdReferenceResolver();
  258. serializer.ReferenceResolver = referenceResolver;
  259. Assert.AreEqual(referenceResolver, serializer.ReferenceResolver);
  260. serializer.StringEscapeHandling = StringEscapeHandling.EscapeNonAscii;
  261. Assert.AreEqual(StringEscapeHandling.EscapeNonAscii, serializer.StringEscapeHandling);
  262. MemoryTraceWriter traceWriter = new MemoryTraceWriter();
  263. serializer.TraceWriter = traceWriter;
  264. Assert.AreEqual(traceWriter, serializer.TraceWriter);
  265. #if !(PORTABLE || PORTABLE40 || NETFX_CORE || NET20)
  266. serializer.TypeNameAssemblyFormat = FormatterAssemblyStyle.Full;
  267. Assert.AreEqual(FormatterAssemblyStyle.Full, serializer.TypeNameAssemblyFormat);
  268. #endif
  269. serializer.TypeNameHandling = TypeNameHandling.All;
  270. Assert.AreEqual(TypeNameHandling.All, serializer.TypeNameHandling);
  271. }
  272. [Test]
  273. public void JsonSerializerSettingsProperties()
  274. {
  275. JsonSerializerSettings settings = new JsonSerializerSettings();
  276. DefaultSerializationBinder customBinder = new DefaultSerializationBinder();
  277. settings.Binder = customBinder;
  278. Assert.AreEqual(customBinder, settings.Binder);
  279. settings.CheckAdditionalContent = true;
  280. Assert.AreEqual(true, settings.CheckAdditionalContent);
  281. settings.ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor;
  282. Assert.AreEqual(ConstructorHandling.AllowNonPublicDefaultConstructor, settings.ConstructorHandling);
  283. #if !NETFX_CORE
  284. settings.Context = new StreamingContext(StreamingContextStates.Other);
  285. Assert.AreEqual(new StreamingContext(StreamingContextStates.Other), settings.Context);
  286. #endif
  287. CamelCasePropertyNamesContractResolver resolver = new CamelCasePropertyNamesContractResolver();
  288. settings.ContractResolver = resolver;
  289. Assert.AreEqual(resolver, settings.ContractResolver);
  290. settings.Converters.Add(new StringEnumConverter());
  291. Assert.AreEqual(1, settings.Converters.Count);
  292. settings.Culture = new CultureInfo("en-nz");
  293. Assert.AreEqual("en-NZ", settings.Culture.ToString());
  294. settings.DateFormatHandling = DateFormatHandling.MicrosoftDateFormat;
  295. Assert.AreEqual(DateFormatHandling.MicrosoftDateFormat, settings.DateFormatHandling);
  296. settings.DateFormatString = "yyyy";
  297. Assert.AreEqual("yyyy", settings.DateFormatString);
  298. settings.DateParseHandling = DateParseHandling.None;
  299. Assert.AreEqual(DateParseHandling.None, settings.DateParseHandling);
  300. settings.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
  301. Assert.AreEqual(DateTimeZoneHandling.Utc, settings.DateTimeZoneHandling);
  302. settings.DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate;
  303. Assert.AreEqual(DefaultValueHandling.IgnoreAndPopulate, settings.DefaultValueHandling);
  304. settings.FloatFormatHandling = FloatFormatHandling.Symbol;
  305. Assert.AreEqual(FloatFormatHandling.Symbol, settings.FloatFormatHandling);
  306. settings.FloatParseHandling = FloatParseHandling.Decimal;
  307. Assert.AreEqual(FloatParseHandling.Decimal, settings.FloatParseHandling);
  308. settings.Formatting = Formatting.Indented;
  309. Assert.AreEqual(Formatting.Indented, settings.Formatting);
  310. settings.MaxDepth = 9001;
  311. Assert.AreEqual(9001, settings.MaxDepth);
  312. settings.MissingMemberHandling = MissingMemberHandling.Error;
  313. Assert.AreEqual(MissingMemberHandling.Error, settings.MissingMemberHandling);
  314. settings.NullValueHandling = NullValueHandling.Ignore;
  315. Assert.AreEqual(NullValueHandling.Ignore, settings.NullValueHandling);
  316. settings.ObjectCreationHandling = ObjectCreationHandling.Replace;
  317. Assert.AreEqual(ObjectCreationHandling.Replace, settings.ObjectCreationHandling);
  318. settings.PreserveReferencesHandling = PreserveReferencesHandling.All;
  319. Assert.AreEqual(PreserveReferencesHandling.All, settings.PreserveReferencesHandling);
  320. settings.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
  321. Assert.AreEqual(ReferenceLoopHandling.Ignore, settings.ReferenceLoopHandling);
  322. IdReferenceResolver referenceResolver = new IdReferenceResolver();
  323. settings.ReferenceResolver = referenceResolver;
  324. Assert.AreEqual(referenceResolver, settings.ReferenceResolver);
  325. settings.StringEscapeHandling = StringEscapeHandling.EscapeNonAscii;
  326. Assert.AreEqual(StringEscapeHandling.EscapeNonAscii, settings.StringEscapeHandling);
  327. MemoryTraceWriter traceWriter = new MemoryTraceWriter();
  328. settings.TraceWriter = traceWriter;
  329. Assert.AreEqual(traceWriter, settings.TraceWriter);
  330. #if !(PORTABLE || PORTABLE40 || NETFX_CORE || NET20)
  331. settings.TypeNameAssemblyFormat = FormatterAssemblyStyle.Full;
  332. Assert.AreEqual(FormatterAssemblyStyle.Full, settings.TypeNameAssemblyFormat);
  333. #endif
  334. settings.TypeNameHandling = TypeNameHandling.All;
  335. Assert.AreEqual(TypeNameHandling.All, settings.TypeNameHandling);
  336. }
  337. [Test]
  338. public void JsonSerializerProxyProperties()
  339. {
  340. JsonSerializerProxy serializerProxy = new JsonSerializerProxy(new JsonSerializerInternalReader(new JsonSerializer()));
  341. DefaultSerializationBinder customBinder = new DefaultSerializationBinder();
  342. serializerProxy.Binder = customBinder;
  343. Assert.AreEqual(customBinder, serializerProxy.Binder);
  344. serializerProxy.CheckAdditionalContent = true;
  345. Assert.AreEqual(true, serializerProxy.CheckAdditionalContent);
  346. serializerProxy.ConstructorHandling = ConstructorHandling.AllowNonPublicDefaultConstructor;
  347. Assert.AreEqual(ConstructorHandling.AllowNonPublicDefaultConstructor, serializerProxy.ConstructorHandling);
  348. #if !NETFX_CORE
  349. serializerProxy.Context = new StreamingContext(StreamingContextStates.Other);
  350. Assert.AreEqual(new StreamingContext(StreamingContextStates.Other), serializerProxy.Context);
  351. #endif
  352. CamelCasePropertyNamesContractResolver resolver = new CamelCasePropertyNamesContractResolver();
  353. serializerProxy.ContractResolver = resolver;
  354. Assert.AreEqual(resolver, serializerProxy.ContractResolver);
  355. serializerProxy.Converters.Add(new StringEnumConverter());
  356. Assert.AreEqual(1, serializerProxy.Converters.Count);
  357. serializerProxy.Culture = new CultureInfo("en-nz");
  358. Assert.AreEqual("en-NZ", serializerProxy.Culture.ToString());
  359. serializerProxy.DateFormatHandling = DateFormatHandling.MicrosoftDateFormat;
  360. Assert.AreEqual(DateFormatHandling.MicrosoftDateFormat, serializerProxy.DateFormatHandling);
  361. serializerProxy.DateFormatString = "yyyy";
  362. Assert.AreEqual("yyyy", serializerProxy.DateFormatString);
  363. serializerProxy.DateParseHandling = DateParseHandling.None;
  364. Assert.AreEqual(DateParseHandling.None, serializerProxy.DateParseHandling);
  365. serializerProxy.DateTimeZoneHandling = DateTimeZoneHandling.Utc;
  366. Assert.AreEqual(DateTimeZoneHandling.Utc, serializerProxy.DateTimeZoneHandling);
  367. serializerProxy.DefaultValueHandling = DefaultValueHandling.IgnoreAndPopulate;
  368. Assert.AreEqual(DefaultValueHandling.IgnoreAndPopulate, serializerProxy.DefaultValueHandling);
  369. serializerProxy.FloatFormatHandling = FloatFormatHandling.Symbol;
  370. Assert.AreEqual(FloatFormatHandling.Symbol, serializerProxy.FloatFormatHandling);
  371. serializerProxy.FloatParseHandling = FloatParseHandling.Decimal;
  372. Assert.AreEqual(FloatParseHandling.Decimal, serializerProxy.FloatParseHandling);
  373. serializerProxy.Formatting = Formatting.Indented;
  374. Assert.AreEqual(Formatting.Indented, serializerProxy.Formatting);
  375. serializerProxy.MaxDepth = 9001;
  376. Assert.AreEqual(9001, serializerProxy.MaxDepth);
  377. serializerProxy.MissingMemberHandling = MissingMemberHandling.Error;
  378. Assert.AreEqual(MissingMemberHandling.Error, serializerProxy.MissingMemberHandling);
  379. serializerProxy.NullValueHandling = NullValueHandling.Ignore;
  380. Assert.AreEqual(NullValueHandling.Ignore, serializerProxy.NullValueHandling);
  381. serializerProxy.ObjectCreationHandling = ObjectCreationHandling.Replace;
  382. Assert.AreEqual(ObjectCreationHandling.Replace, serializerProxy.ObjectCreationHandling);
  383. serializerProxy.PreserveReferencesHandling = PreserveReferencesHandling.All;
  384. Assert.AreEqual(PreserveReferencesHandling.All, serializerProxy.PreserveReferencesHandling);
  385. serializerProxy.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;
  386. Assert.AreEqual(ReferenceLoopHandling.Ignore, serializerProxy.ReferenceLoopHandling);
  387. IdReferenceResolver referenceResolver = new IdReferenceResolver();
  388. serializerProxy.ReferenceResolver = referenceResolver;
  389. Assert.AreEqual(referenceResolver, serializerProxy.ReferenceResolver);
  390. serializerProxy.StringEscapeHandling = StringEscapeHandling.EscapeNonAscii;
  391. Assert.AreEqual(StringEscapeHandling.EscapeNonAscii, serializerProxy.StringEscapeHandling);
  392. MemoryTraceWriter traceWriter = new MemoryTraceWriter();
  393. serializerProxy.TraceWriter = traceWriter;
  394. Assert.AreEqual(traceWriter, serializerProxy.TraceWriter);
  395. #if !(PORTABLE || PORTABLE40 || NETFX_CORE || NET20)
  396. serializerProxy.TypeNameAssemblyFormat = FormatterAssemblyStyle.Full;
  397. Assert.AreEqual(FormatterAssemblyStyle.Full, serializerProxy.TypeNameAssemblyFormat);
  398. #endif
  399. serializerProxy.TypeNameHandling = TypeNameHandling.All;
  400. Assert.AreEqual(TypeNameHandling.All, serializerProxy.TypeNameHandling);
  401. }
  402. #if !(NETFX_CORE || PORTABLE || PORTABLE40)
  403. [Test]
  404. public void DeserializeISerializableIConvertible()
  405. {
  406. Ratio ratio = new Ratio(2, 1);
  407. string json = JsonConvert.SerializeObject(ratio);
  408. Assert.AreEqual(@"{""n"":2,""d"":1}", json);
  409. Ratio ratio2 = JsonConvert.DeserializeObject<Ratio>(json);
  410. Assert.AreEqual(ratio.Denominator, ratio2.Denominator);
  411. Assert.AreEqual(ratio.Numerator, ratio2.Numerator);
  412. }
  413. #endif
  414. [Test]
  415. public void DeserializeLargeFloat()
  416. {
  417. object o = JsonConvert.DeserializeObject("100000000000000000000000000000000000000.0");
  418. CustomAssert.IsInstanceOfType(typeof(double), o);
  419. Assert.IsTrue(MathUtils.ApproxEquals(1E+38, (double)o));
  420. }
  421. [Test]
  422. public void SerializeDeserializeRegex()
  423. {
  424. Regex regex = new Regex("(hi)", RegexOptions.CultureInvariant);
  425. string json = JsonConvert.SerializeObject(regex, Formatting.Indented);
  426. Regex r2 = JsonConvert.DeserializeObject<Regex>(json);
  427. Assert.AreEqual("(hi)", r2.ToString());
  428. Assert.AreEqual(RegexOptions.CultureInvariant, r2.Options);
  429. }
  430. [Test]
  431. public void EmbedJValueStringInNewJObject()
  432. {
  433. string s = null;
  434. var v = new JValue(s);
  435. var o = JObject.FromObject(new { title = v });
  436. JObject oo = new JObject
  437. {
  438. {"title", v}
  439. };
  440. string output = o.ToString();
  441. Assert.AreEqual(null, v.Value);
  442. Assert.AreEqual(JTokenType.String, v.Type);
  443. Assert.AreEqual(@"{
  444. ""title"": null
  445. }", output);
  446. }
  447. // bug: the generic member (T) that hides the base member will not
  448. // be used when serializing and deserializing the object,
  449. // resulting in unexpected behavior during serialization and deserialization.
  450. public class Foo1
  451. {
  452. public object foo { get; set; }
  453. }
  454. public class Bar1
  455. {
  456. public object bar { get; set; }
  457. }
  458. public class Foo1<T> : Foo1
  459. {
  460. public new T foo { get; set; }
  461. public T foo2 { get; set; }
  462. }
  463. public class FooBar1 : Foo1
  464. {
  465. public new Bar1 foo { get; set; }
  466. }
  467. [Test]
  468. public void BaseClassSerializesAsExpected()
  469. {
  470. var original = new Foo1 { foo = "value" };
  471. var json = JsonConvert.SerializeObject(original);
  472. var expectedJson = @"{""foo"":""value""}";
  473. Assert.AreEqual(expectedJson, json); // passes
  474. }
  475. [Test]
  476. public void BaseClassDeserializesAsExpected()
  477. {
  478. var json = @"{""foo"":""value""}";
  479. var deserialized = JsonConvert.DeserializeObject<Foo1>(json);
  480. Assert.AreEqual("value", deserialized.foo); // passes
  481. }
  482. [Test]
  483. public void DerivedClassHidingBasePropertySerializesAsExpected()
  484. {
  485. var original = new FooBar1 { foo = new Bar1 { bar = "value" } };
  486. var json = JsonConvert.SerializeObject(original);
  487. var expectedJson = @"{""foo"":{""bar"":""value""}}";
  488. Assert.AreEqual(expectedJson, json); // passes
  489. }
  490. [Test]
  491. public void DerivedClassHidingBasePropertyDeserializesAsExpected()
  492. {
  493. var json = @"{""foo"":{""bar"":""value""}}";
  494. var deserialized = JsonConvert.DeserializeObject<FooBar1>(json);
  495. Assert.IsNotNull(deserialized.foo); // passes
  496. Assert.AreEqual("value", deserialized.foo.bar); // passes
  497. }
  498. [Test]
  499. public void DerivedGenericClassHidingBasePropertySerializesAsExpected()
  500. {
  501. var original = new Foo1<Bar1> { foo = new Bar1 { bar = "value" }, foo2 = new Bar1 { bar = "value2" } };
  502. var json = JsonConvert.SerializeObject(original);
  503. var expectedJson = @"{""foo"":{""bar"":""value""},""foo2"":{""bar"":""value2""}}";
  504. Assert.AreEqual(expectedJson, json);
  505. }
  506. [Test]
  507. public void DerivedGenericClassHidingBasePropertyDeserializesAsExpected()
  508. {
  509. var json = @"{""foo"":{""bar"":""value""},""foo2"":{""bar"":""value2""}}";
  510. var deserialized = JsonConvert.DeserializeObject<Foo1<Bar1>>(json);
  511. Assert.IsNotNull(deserialized.foo2); // passes (bug only occurs for generics that /hide/ another property)
  512. Assert.AreEqual("value2", deserialized.foo2.bar); // also passes, with no issue
  513. Assert.IsNotNull(deserialized.foo);
  514. Assert.AreEqual("value", deserialized.foo.bar);
  515. }
  516. #if !NETFX_CORE
  517. [Test]
  518. public void ConversionOperator()
  519. {
  520. // Creating a simple dictionary that has a non-string key
  521. var dictStore = new Dictionary<DictionaryKeyCast, int>();
  522. for (var i = 0; i < 800; i++)
  523. {
  524. dictStore.Add(new DictionaryKeyCast(i.ToString(CultureInfo.InvariantCulture), i), i);
  525. }
  526. var settings = new JsonSerializerSettings { Formatting = Formatting.Indented };
  527. var jsonSerializer = JsonSerializer.Create(settings);
  528. var ms = new MemoryStream();
  529. var streamWriter = new StreamWriter(ms);
  530. jsonSerializer.Serialize(streamWriter, dictStore);
  531. streamWriter.Flush();
  532. ms.Seek(0, SeekOrigin.Begin);
  533. var stopWatch = Stopwatch.StartNew();
  534. var deserialize = jsonSerializer.Deserialize(new StreamReader(ms), typeof(Dictionary<DictionaryKeyCast, int>));
  535. stopWatch.Stop();
  536. Console.WriteLine("Time elapsed: " + stopWatch.ElapsedMilliseconds);
  537. }
  538. #endif
  539. internal class DictionaryKeyCast
  540. {
  541. private String _name;
  542. private int _number;
  543. public DictionaryKeyCast(String name, int number)
  544. {
  545. _name = name;
  546. _number = number;
  547. }
  548. public override string ToString()
  549. {
  550. return _name + " " + _number;
  551. }
  552. public static implicit operator DictionaryKeyCast(string dictionaryKey)
  553. {
  554. var strings = dictionaryKey.Split(' ');
  555. return new DictionaryKeyCast(strings[0], Convert.ToInt32(strings[1]));
  556. }
  557. }
  558. #if !NET20
  559. [DataContract]
  560. public class BaseDataContractWithHidden
  561. {
  562. [DataMember(Name = "virtualMember")]
  563. public virtual string VirtualMember { get; set; }
  564. [DataMember(Name = "nonVirtualMember")]
  565. public string NonVirtualMember { get; set; }
  566. public virtual object NewMember { get; set; }
  567. }
  568. public class ChildDataContractWithHidden : BaseDataContractWithHidden
  569. {
  570. [DataMember(Name = "NewMember")]
  571. public new virtual string NewMember { get; set; }
  572. public override string VirtualMember { get; set; }
  573. public string AddedMember { get; set; }
  574. }
  575. [Test]
  576. public void ChildDataContractTestWithHidden()
  577. {
  578. var cc = new ChildDataContractWithHidden
  579. {
  580. VirtualMember = "VirtualMember!",
  581. NonVirtualMember = "NonVirtualMember!",
  582. NewMember = "NewMember!"
  583. };
  584. string result = JsonConvert.SerializeObject(cc);
  585. Assert.AreEqual(@"{""NewMember"":""NewMember!"",""virtualMember"":""VirtualMember!"",""nonVirtualMember"":""NonVirtualMember!""}", result);
  586. }
  587. // ignore hiding members compiler warning
  588. #pragma warning disable 108,114
  589. [DataContract]
  590. public class BaseWithContract
  591. {
  592. [DataMember(Name = "VirtualWithDataMemberBase")]
  593. public virtual string VirtualWithDataMember { get; set; }
  594. [DataMember]
  595. public virtual string Virtual { get; set; }
  596. [DataMember(Name = "WithDataMemberBase")]
  597. public string WithDataMember { get; set; }
  598. [DataMember]
  599. public string JustAProperty { get; set; }
  600. }
  601. [DataContract]
  602. public class BaseWithoutContract
  603. {
  604. [DataMember(Name = "VirtualWithDataMemberBase")]
  605. public virtual string VirtualWithDataMember { get; set; }
  606. [DataMember]
  607. public virtual string Virtual { get; set; }
  608. [DataMember(Name = "WithDataMemberBase")]
  609. public string WithDataMember { get; set; }
  610. [DataMember]
  611. public string JustAProperty { get; set; }
  612. }
  613. [DataContract]
  614. public class SubWithoutContractNewProperties : BaseWithContract
  615. {
  616. [DataMember(Name = "VirtualWithDataMemberSub")]
  617. public string VirtualWithDataMember { get; set; }
  618. public string Virtual { get; set; }
  619. [DataMember(Name = "WithDataMemberSub")]
  620. public string WithDataMember { get; set; }
  621. public string JustAProperty { get; set; }
  622. }
  623. [DataContract]
  624. public class SubWithoutContractVirtualProperties : BaseWithContract
  625. {
  626. public override string VirtualWithDataMember { get; set; }
  627. [DataMember(Name = "VirtualSub")]
  628. public override string Virtual { get; set; }
  629. }
  630. [DataContract]
  631. public class SubWithContractNewProperties : BaseWithContract
  632. {
  633. [DataMember(Name = "VirtualWithDataMemberSub")]
  634. public string VirtualWithDataMember { get; set; }
  635. [DataMember(Name = "Virtual2")]
  636. public string Virtual { get; set; }
  637. [DataMember(Name = "WithDataMemberSub")]
  638. public string WithDataMember { get; set; }
  639. [DataMember(Name = "JustAProperty2")]
  640. public string JustAProperty { get; set; }
  641. }
  642. [DataContract]
  643. public class SubWithContractVirtualProperties : BaseWithContract
  644. {
  645. [DataMember(Name = "VirtualWithDataMemberSub")]
  646. public virtual string VirtualWithDataMember { get; set; }
  647. }
  648. #pragma warning restore 108,114
  649. [Test]
  650. public void SubWithoutContractNewPropertiesTest()
  651. {
  652. BaseWithContract baseWith = new SubWithoutContractNewProperties
  653. {
  654. JustAProperty = "JustAProperty!",
  655. Virtual = "Virtual!",
  656. VirtualWithDataMember = "VirtualWithDataMember!",
  657. WithDataMember = "WithDataMember!"
  658. };
  659. baseWith.JustAProperty = "JustAProperty2!";
  660. baseWith.Virtual = "Virtual2!";
  661. baseWith.VirtualWithDataMember = "VirtualWithDataMember2!";
  662. baseWith.WithDataMember = "WithDataMember2!";
  663. string json = AssertSerializeDeserializeEqual(baseWith);
  664. Assert.AreEqual(@"{
  665. ""JustAProperty"": ""JustAProperty2!"",
  666. ""Virtual"": ""Virtual2!"",
  667. ""VirtualWithDataMemberBase"": ""VirtualWithDataMember2!"",
  668. ""VirtualWithDataMemberSub"": ""VirtualWithDataMember!"",
  669. ""WithDataMemberBase"": ""WithDataMember2!"",
  670. ""WithDataMemberSub"": ""WithDataMember!""
  671. }", json);
  672. }
  673. [Test]
  674. public void SubWithoutContractVirtualPropertiesTest()
  675. {
  676. BaseWithContract baseWith = new SubWithoutContractVirtualProperties
  677. {
  678. JustAProperty = "JustAProperty!",
  679. Virtual = "Virtual!",
  680. VirtualWithDataMember = "VirtualWithDataMember!",
  681. WithDataMember = "WithDataMember!"
  682. };
  683. baseWith.JustAProperty = "JustAProperty2!";
  684. baseWith.Virtual = "Virtual2!";
  685. baseWith.VirtualWithDataMember = "VirtualWithDataMember2!";
  686. baseWith.WithDataMember = "WithDataMember2!";
  687. string json = JsonConvert.SerializeObject(baseWith, Formatting.Indented);
  688. Console.WriteLine(json);
  689. Assert.AreEqual(@"{
  690. ""VirtualWithDataMemberBase"": ""VirtualWithDataMember2!"",
  691. ""VirtualSub"": ""Virtual2!"",
  692. ""WithDataMemberBase"": ""WithDataMember2!"",
  693. ""JustAProperty"": ""JustAProperty2!""
  694. }", json);
  695. }
  696. [Test]
  697. public void SubWithContractNewPropertiesTest()
  698. {
  699. BaseWithContract baseWith = new SubWithContractNewProperties
  700. {
  701. JustAProperty = "JustAProperty!",
  702. Virtual = "Virtual!",
  703. VirtualWithDataMember = "VirtualWithDataMember!",
  704. WithDataMember = "WithDataMember!"
  705. };
  706. baseWith.JustAProperty = "JustAProperty2!";
  707. baseWith.Virtual = "Virtual2!";
  708. baseWith.VirtualWithDataMember = "VirtualWithDataMember2!";
  709. baseWith.WithDataMember = "WithDataMember2!";
  710. string json = AssertSerializeDeserializeEqual(baseWith);
  711. Assert.AreEqual(@"{
  712. ""JustAProperty"": ""JustAProperty2!"",
  713. ""JustAProperty2"": ""JustAProperty!"",
  714. ""Virtual"": ""Virtual2!"",
  715. ""Virtual2"": ""Virtual!"",
  716. ""VirtualWithDataMemberBase"": ""VirtualWithDataMember2!"",
  717. ""VirtualWithDataMemberSub"": ""VirtualWithDataMember!"",
  718. ""WithDataMemberBase"": ""WithDataMember2!"",
  719. ""WithDataMemberSub"": ""WithDataMember!""
  720. }", json);
  721. }
  722. [Test]
  723. public void SubWithContractVirtualPropertiesTest()
  724. {
  725. BaseWithContract baseWith = new SubWithContractVirtualProperties
  726. {
  727. JustAProperty = "JustAProperty!",
  728. Virtual = "Virtual!",
  729. VirtualWithDataMember = "VirtualWithDataMember!",
  730. WithDataMember = "WithDataMember!"
  731. };
  732. baseWith.JustAProperty = "JustAProperty2!";
  733. baseWith.Virtual = "Virtual2!";
  734. baseWith.VirtualWithDataMember = "VirtualWithDataMember2!";
  735. baseWith.WithDataMember = "WithDataMember2!";
  736. string json = AssertSerializeDeserializeEqual(baseWith);
  737. Assert.AreEqual(@"{
  738. ""JustAProperty"": ""JustAProperty2!"",
  739. ""Virtual"": ""Virtual2!"",
  740. ""VirtualWithDataMemberBase"": ""VirtualWithDataMember2!"",
  741. ""VirtualWithDataMemberSub"": ""VirtualWithDataMember!"",
  742. ""WithDataMemberBase"": ""WithDataMember2!""
  743. }", json);
  744. }
  745. private string AssertSerializeDeserializeEqual(object o)
  746. {
  747. MemoryStream ms = new MemoryStream();
  748. DataContractJsonSerializer s = new DataContractJsonSerializer(o.GetType());
  749. s.WriteObject(ms, o);
  750. var data = ms.ToArray();
  751. JObject dataContractJson = JObject.Parse(Encoding.UTF8.GetString(data, 0, data.Length));
  752. dataContractJson = new JObject(dataContractJson.Properties().OrderBy(p => p.Name));
  753. JObject jsonNetJson = JObject.Parse(JsonConvert.SerializeObject(o));
  754. jsonNetJson = new JObject(jsonNetJson.Properties().OrderBy(p => p.Name));
  755. Console.WriteLine("Results for " + o.GetType().Name);
  756. Console.WriteLine("DataContractJsonSerializer: " + dataContractJson);
  757. Console.WriteLine("JsonDotNetSerializer : " + jsonNetJson);
  758. Assert.AreEqual(dataContractJson.Count, jsonNetJson.Count);
  759. foreach (KeyValuePair<string, JToken> property in dataContractJson)
  760. {
  761. Assert.IsTrue(JToken.DeepEquals(jsonNetJson[property.Key], property.Value), "Property not equal: " + property.Key);
  762. }
  763. return jsonNetJson.ToString();
  764. }
  765. #endif
  766. [Test]
  767. public void PersonTypedObjectDeserialization()
  768. {
  769. Store store = new Store();
  770. string jsonText = JsonConvert.SerializeObject(store);
  771. Store deserializedStore = (Store)JsonConvert.DeserializeObject(jsonText, typeof(Store));
  772. Assert.AreEqual(store.Establised, deserializedStore.Establised);
  773. Assert.AreEqual(store.product.Count, deserializedStore.product.Count);
  774. Console.WriteLine(jsonText);
  775. }
  776. [Test]
  777. public void TypedObjectDeserialization()
  778. {
  779. Product product = new Product();
  780. product.Name = "Apple";
  781. product.ExpiryDate = new DateTime(2008, 12, 28);
  782. product.Price = 3.99M;
  783. product.Sizes = new string[] { "Small", "Medium", "Large" };
  784. string output = JsonConvert.SerializeObject(product);
  785. //{
  786. // "Name": "Apple",
  787. // "ExpiryDate": "\/Date(1230375600000+1300)\/",
  788. // "Price": 3.99,
  789. // "Sizes": [
  790. // "Small",
  791. // "Medium",
  792. // "Large"
  793. // ]
  794. //}
  795. Product deserializedProduct = (Product)JsonConvert.DeserializeObject(output, typeof(Product));
  796. Assert.AreEqual("Apple", deserializedProduct.Name);
  797. Assert.AreEqual(new DateTime(2008, 12, 28), deserializedProduct.ExpiryDate);
  798. Assert.AreEqual(3.99m, deserializedProduct.Price);
  799. Assert.AreEqual("Small", deserializedProduct.Sizes[0]);
  800. Assert.AreEqual("Medium", deserializedProduct.Sizes[1]);
  801. Assert.AreEqual("Large", deserializedProduct.Sizes[2]);
  802. }
  803. //[Test]
  804. //public void Advanced()
  805. //{
  806. // Product product = new Product();
  807. // product.ExpiryDate = new DateTime(2008, 12, 28);
  808. // JsonSerializer serializer = new JsonSerializer();
  809. // serializer.Converters.Add(new JavaScriptDateTimeConverter());
  810. // serializer.NullValueHandling = NullValueHandling.Ignore;
  811. // using (StreamWriter sw = new StreamWriter(@"c:\json.txt"))
  812. // using (JsonWriter writer = new JsonTextWriter(sw))
  813. // {
  814. // serializer.Serialize(writer, product);
  815. // // {"ExpiryDate":new Date(1230375600000),"Price":0}
  816. // }
  817. //}
  818. [Test]
  819. public void JsonConvertSerializer()
  820. {
  821. string value = @"{""Name"":""Orange"", ""Price"":3.99, ""ExpiryDate"":""01/24/2010 12:00:00""}";
  822. Product p = JsonConvert.DeserializeObject(value, typeof(Product)) as Product;
  823. Assert.AreEqual("Orange", p.Name);
  824. Assert.AreEqual(new DateTime(2010, 1, 24, 12, 0, 0), p.ExpiryDate);
  825. Assert.AreEqual(3.99m, p.Price);
  826. }
  827. [Test]
  828. public void DeserializeJavaScriptDate()
  829. {
  830. DateTime dateValue = new DateTime(2010, 3, 30);
  831. Dictionary<string, object> testDictionary = new Dictionary<string, object>();
  832. testDictionary["date"] = dateValue;
  833. string jsonText = JsonConvert.SerializeObject(testDictionary);
  834. #if !NET20
  835. MemoryStream ms = new MemoryStream();
  836. DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(Dictionary<string, object>));
  837. serializer.WriteObject(ms, testDictionary);
  838. byte[] data = ms.ToArray();
  839. string output = Encoding.UTF8.GetString(data, 0, data.Length);
  840. #endif
  841. Dictionary<string, object> deserializedDictionary = (Dictionary<string, object>)JsonConvert.DeserializeObject(jsonText, typeof(Dictionary<string, object>));
  842. DateTime deserializedDate = (DateTime)deserializedDictionary["date"];
  843. Assert.AreEqual(dateValue, deserializedDate);
  844. }
  845. [Test]
  846. public void TestMethodExecutorObject()
  847. {
  848. MethodExecutorObject executorObject = new MethodExecutorObject();
  849. executorObject.serverClassName = "BanSubs";
  850. executorObject.serverMethodParams = new object[] { "21321546", "101", "1236", "D:\\1.txt" };
  851. executorObject.clientGetResultFunction = "ClientBanSubsCB";
  852. string output = JsonConvert.SerializeObject(executorObject);
  853. MethodExecutorObject executorObject2 = JsonConvert.DeserializeObject(output, typeof(MethodExecutorObject)) as MethodExecutorObject;
  854. Assert.AreNotSame(executorObject, executorObject2);
  855. Assert.AreEqual(executorObject2.serverClassName, "BanSubs");
  856. Assert.AreEqual(executorObject2.serverMethodParams.Length, 4);
  857. CustomAssert.Contains(executorObject2.serverMethodParams, "101");
  858. Assert.AreEqual(executorObject2.clientGetResultFunction, "ClientBanSubsCB");
  859. }
  860. #if !NETFX_CORE
  861. [Test]
  862. public void HashtableDeserialization()
  863. {
  864. string value = @"{""Name"":""Orange"", ""Price"":3.99, ""ExpiryDate"":""01/24/2010 12:00:00""}";
  865. Hashtable p = JsonConvert.DeserializeObject(value, typeof(Hashtable)) as Hashtable;
  866. Assert.AreEqual("Orange", p["Name"].ToString());
  867. }
  868. [Test]
  869. public void TypedHashtableDeserialization()
  870. {
  871. string value = @"{""Name"":""Orange"", ""Hash"":{""ExpiryDate"":""01/24/2010 12:00:00"",""UntypedArray"":[""01/24/2010 12:00:00""]}}";
  872. TypedSubHashtable p = JsonConvert.DeserializeObject(value, typeof(TypedSubHashtable)) as TypedSubHashtable;
  873. Assert.AreEqual("01/24/2010 12:00:00", p.Hash["ExpiryDate"].ToString());
  874. Assert.AreEqual(@"[
  875. ""01/24/2010 12:00:00""
  876. ]", p.Hash["UntypedArray"].ToString());
  877. }
  878. #endif
  879. [Test]
  880. public void SerializeDeserializeGetOnlyProperty()
  881. {
  882. string value = JsonConvert.SerializeObject(new GetOnlyPropertyClass());
  883. GetOnlyPropertyClass c = JsonConvert.DeserializeObject<GetOnlyPropertyClass>(value);
  884. Assert.AreEqual(c.Field, "Field");
  885. Assert.AreEqual(c.GetOnlyProperty, "GetOnlyProperty");
  886. }
  887. [Test]
  888. public void SerializeDeserializeSetOnlyProperty()
  889. {
  890. string value = JsonConvert.SerializeObject(new SetOnlyPropertyClass());
  891. SetOnlyPropertyClass c = JsonConvert.DeserializeObject<SetOnlyPropertyClass>(value);
  892. Assert.AreEqual(c.Field, "Field");
  893. }
  894. [Test]
  895. public void JsonIgnoreAttributeTest()
  896. {
  897. string json = JsonConvert.SerializeObject(new JsonIgnoreAttributeTestClass());
  898. Assert.AreEqual(@"{""Field"":0,""Property"":21}", json);
  899. JsonIgnoreAttributeTestClass c = JsonConvert.DeserializeObject<JsonIgnoreAttributeTestClass>(@"{""Field"":99,""Property"":-1,""IgnoredField"":-1,""IgnoredObject"":[1,2,3,4,5]}");
  900. Assert.AreEqual(0, c.IgnoredField);
  901. Assert.AreEqual(99, c.Field);
  902. }
  903. [Test]
  904. public void GoogleSearchAPI()
  905. {
  906. string json = @"{
  907. results:
  908. [
  909. {
  910. GsearchResultClass:""GwebSearch"",
  911. unescapedUrl : ""http://www.google.com/"",
  912. url : ""http://www.google.com/"",
  913. visibleUrl : ""www.google.com"",
  914. cacheUrl :
  915. ""http://www.google.com/search?q=cache:zhool8dxBV4J:www.google.com"",
  916. title : ""Google"",
  917. titleNoFormatting : ""Google"",
  918. content : ""Enables users to search the Web, Usenet, and
  919. images. Features include PageRank, caching and translation of
  920. results, and an option to find similar pages.""
  921. },
  922. {
  923. GsearchResultClass:""GwebSearch"",
  924. unescapedUrl : ""http://news.google.com/"",
  925. url : ""http://news.google.com/"",
  926. visibleUrl : ""news.google.com"",
  927. cacheUrl :
  928. ""http://www.google.com/search?q=cache:Va_XShOz_twJ:news.google.com"",
  929. title : ""Google News"",
  930. titleNoFormatting : ""Google News"",
  931. content : ""Aggregated headlines and a search engine of many of the world's news sources.""
  932. },
  933. {
  934. GsearchResultClass:""GwebSearch"",
  935. unescapedUrl : ""http://groups.google.com/"",
  936. url : ""http://groups.google.com/"",
  937. visibleUrl : ""groups.google.com"",
  938. cacheUrl :
  939. ""http://www.google.com/search?q=cache:x2uPD3hfkn0J:groups.google.com"",
  940. title : ""Google Groups"",
  941. titleNoFormatting : ""Google Groups"",
  942. content : ""Enables users to search and browse the Usenet
  943. archives which consist of over 700 million messages, and post new
  944. comments.""
  945. },
  946. {
  947. GsearchResultClass:""GwebSearch"",
  948. unescapedUrl : ""http://maps.google.com/"",
  949. url : ""http://maps.google.com/"",
  950. visibleUrl : ""maps.google.com"",
  951. cacheUrl :
  952. ""http://www.google.com/search?q=cache:dkf5u2twBXIJ:maps.google.com"",
  953. title : ""Google Maps"",
  954. titleNoFormatting : ""Google Maps"",
  955. content : ""Provides directions, interactive maps, and
  956. satellite/aerial imagery of the United States. Can also search by
  957. keyword such as type of business.""
  958. }
  959. ],
  960. adResults:
  961. [
  962. {
  963. GsearchResultClass:""GwebSearch.ad"",
  964. title : ""Gartner Symposium/ITxpo"",
  965. content1 : ""Meet brilliant Gartner IT analysts"",
  966. content2 : ""20-23 May 2007- Barcelona, Spain"",
  967. url :
  968. ""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="",
  969. impressionUrl :
  970. ""http://www.google.com/uds/css/ad-indicator-on.gif?ai=BVualExYGRo3hD5ianAPJvejjD8-s6ye7kdTwArbI4gTAlrECEAEYASDXtMMFOAFQubWAjvr_____AWDXw_4EiAEBmAEAyAEBgAIB"",
  971. unescapedUrl :
  972. ""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="",
  973. visibleUrl : ""www.gartner.com""
  974. }
  975. ]
  976. }
  977. ";
  978. object o = JsonConvert.DeserializeObject(json);
  979. string s = string.Empty;
  980. s += s;
  981. }
  982. [Test]
  983. public void TorrentDeserializeTest()
  984. {
  985. string jsonText = @"{
  986. """":"""",
  987. ""label"": [
  988. [""SomeName"",6]
  989. ],
  990. ""torrents"": [
  991. [""192D99A5C943555CB7F00A852821CF6D6DB3008A"",201,""filename.avi"",178311826,1000,178311826,72815250,408,1603,7,121430,""NameOfLabelPrevioslyDefined"",3,6,0,8,128954,-1,0],
  992. ],
  993. ""torrentc"": ""1816000723""
  994. }";
  995. JObject o = (JObject)JsonConvert.DeserializeObject(jsonText);
  996. Assert.AreEqual(4, o.Children().Count());
  997. JToken torrentsArray = (JToken)o["torrents"];
  998. JToken nestedTorrentsArray = (JToken)torrentsArray[0];
  999. Assert.AreEqual(nestedTorrentsArray.Children().Count(), 19);
  1000. }
  1001. [Test]
  1002. public void JsonPropertyClassSerialize()
  1003. {
  1004. JsonPropertyClass test = new JsonPropertyClass();
  1005. test.Pie = "Delicious";
  1006. test.SweetCakesCount = int.MaxValue;
  1007. string jsonText = JsonConvert.SerializeObject(test);
  1008. Assert.AreEqual(@"{""pie"":""Delicious"",""pie1"":""PieChart!"",""sweet_cakes_count"":2147483647}", jsonText);
  1009. JsonPropertyClass test2 = JsonConvert.DeserializeObject<JsonPropertyClass>(jsonText);
  1010. Assert.AreEqual(test.Pie, test2.Pie);
  1011. Assert.AreEqual(test.SweetCakesCount, test2.SweetCakesCount);
  1012. }
  1013. [Test]
  1014. public void BadJsonPropertyClassSerialize()
  1015. {
  1016. ExceptionAssert.Throws<JsonSerializationException>(
  1017. @"A member with the name 'p…

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