mcs/class/System.ServiceModel.Web/Test/System.Runtime.Serialization.Json/JsonReaderTest.cs

   1 //
   2 // JsonReaderTest.cs
   3 //
   4 // Author:
   5 //      Atsushi Enomoto  <atsushi@ximian.com>
   6 //
   7 // Copyright (C) 2007 Novell, Inc (http://www.novell.com)
   8 // Copyright 2014 Xamarin Inc. (http://www.xamarin.com)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29 using System;
  30 using System.Collections.Generic;
  31 using System.Globalization;
  32 using System.IO;
  33 using System.Runtime.Serialization.Json;
  34 using System.Text;
  35 using System.Threading;
  36 using System.Xml;
  37 using NUnit.Framework;
  38
  39 namespace MonoTests.System.Runtime.Serialization.Json
  40 {
  41         [TestFixture]
  42         public class JsonReaderTest
  43         {
  44                 XmlDictionaryReader reader;
  45
  46                 Stream GetInput (string s)
  47                 {
  48                         return new MemoryStream (Encoding.ASCII.GetBytes (s));
  49                 }
  50
  51                 XmlDictionaryReader CreateReader (string s)
  52                 {
  53                         return JsonReaderWriterFactory.CreateJsonReader (GetInput (s), new XmlDictionaryReaderQuotas ());
  54                 }
  55
  56                 void AssertNode (int depth, string localName, XmlNodeType nodeType, string value, string type, XmlDictionaryReader reader, string label)
  57                 {
  58                         Assert.AreEqual (localName, reader.LocalName, label + ".LocalName");
  59                         Assert.AreEqual (nodeType, reader.NodeType, label + ".NodeType");
  60                         Assert.AreEqual (value, reader.Value, label + ".Value");
  61                         Assert.AreEqual (type, reader.GetAttribute ("type"), label + ".GetAttribute('type')");
  62                 }
  63
  64                 // Constructors
  65
  66                 [Test]
  67                 [ExpectedException (typeof (ArgumentNullException))]
  68                 public void ConstructorNullBytes ()
  69                 {
  70                         JsonReaderWriterFactory.CreateJsonReader ((byte []) null, new XmlDictionaryReaderQuotas ());
  71                 }
  72
  73                 [Test]
  74                 [ExpectedException (typeof (ArgumentNullException))]
  75                 public void ConstructorNullStream ()
  76                 {
  77                         JsonReaderWriterFactory.CreateJsonReader ((Stream) null, new XmlDictionaryReaderQuotas ());
  78                 }
  79
  80                 [Test]
  81                 [ExpectedException (typeof (ArgumentNullException))]
  82                 public void ConstructorNullReaderQuotas ()
  83                 {
  84                         JsonReaderWriterFactory.CreateJsonReader (GetInput ("{}"), null);
  85                 }
  86
  87                 [Test]
  88                 public void ConstructorNullEncodingAndReaderClose ()
  89                 {
  90                         JsonReaderWriterFactory.CreateJsonReader (GetInput ("{}"), null, new XmlDictionaryReaderQuotas (), null);
  91                 }
  92
  93                 // Close()
  94
  95                 [Test]
  96                 public void CloseTwice ()
  97                 {
  98                         reader = CreateReader ("{}");
  99                         reader.Close ();
 100                         reader.Close ();
 101                 }
 102
 103                 [Test]
 104                 // hmm... [ExpectedException (typeof (InvalidOperationException))]
 105                 public void CloseAndRead ()
 106                 {
 107                         reader = CreateReader ("{}");
 108                         reader.Close ();
 109                         reader.Read ();
 110                 }
 111
 112                 [Test]
 113                 // hmm... [ExpectedException (typeof (InvalidOperationException))]
 114                 public void CloseAndMoveToFirstAttribute ()
 115                 {
 116                         reader = CreateReader ("{}");
 117                         reader.Close ();
 118                         reader.MoveToFirstAttribute ();
 119                 }
 120
 121                 // Read() several top-level types
 122
 123                 [Test]
 124                 public void ReadStateEmpty ()
 125                 {
 126                         reader = CreateReader ("");
 127                         Assert.AreEqual (ReadState.Initial, reader.ReadState, "#1");
 128                         reader.Read ();
 129                         Assert.AreEqual (ReadState.EndOfFile, reader.ReadState, "#2");
 130                         reader.Close ();
 131                         Assert.AreEqual (ReadState.Closed, reader.ReadState, "#3");
 132                 }
 133
 134                 [Test]
 135                 public void ReadStateEmpty2 ()
 136                 {
 137                         reader = CreateReader ("  ");
 138                         Assert.AreEqual (ReadState.Initial, reader.ReadState, "#1");
 139                         reader.Read ();
 140                         Assert.AreEqual (ReadState.EndOfFile, reader.ReadState, "#2");
 141                         reader.Close ();
 142                         Assert.AreEqual (ReadState.Closed, reader.ReadState, "#3");
 143                 }
 144
 145                 [Test]
 146                 public void ReadStateObject ()
 147                 {
 148                         reader = CreateReader ("{}");
 149                         Assert.AreEqual (ReadState.Initial, reader.ReadState, "#1");
 150                         reader.Read (); // element
 151                         Assert.AreEqual (ReadState.Interactive, reader.ReadState, "#2");
 152                         reader.Read (); // endelement
 153                         Assert.AreEqual (ReadState.Interactive, reader.ReadState, "#3");
 154                         reader.Read (); // endoffile
 155                         Assert.AreEqual (ReadState.EndOfFile, reader.ReadState, "#4");
 156                         reader.Close ();
 157                         Assert.AreEqual (ReadState.Closed, reader.ReadState, "#5");
 158                 }
 159
 160                 [Test]
 161                 public void ReadStateArray ()
 162                 {
 163                         reader = CreateReader ("[]");
 164                         Assert.AreEqual (ReadState.Initial, reader.ReadState, "#1");
 165                         reader.Read (); // element
 166                         Assert.AreEqual (ReadState.Interactive, reader.ReadState, "#2");
 167                         reader.Read (); // endelement
 168                         Assert.AreEqual (ReadState.Interactive, reader.ReadState, "#3");
 169                         reader.Read (); // endoffile
 170                         Assert.AreEqual (ReadState.EndOfFile, reader.ReadState, "#4");
 171                         reader.Close ();
 172                         Assert.AreEqual (ReadState.Closed, reader.ReadState, "#5");
 173                 }
 174
 175                 [Test]
 176                 public void ReadNumber ()
 177                 {
 178                         reader = CreateReader ("1234");
 179                         Assert.AreEqual (ReadState.Initial, reader.ReadState, "#1");
 180                         reader.Read (); // dummy root element
 181                         Assert.AreEqual (ReadState.Interactive, reader.ReadState, "#2");
 182                         Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#2-1");
 183                         Assert.AreEqual ("root", reader.LocalName, "#2-2");
 184                         reader.Read (); // content (number)
 185                         Assert.AreEqual (ReadState.Interactive, reader.ReadState, "#3");
 186                         Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#3-1");
 187                         Assert.AreEqual ("1234", reader.Value, "#3-2");
 188                         reader.Read (); // endelement
 189                         Assert.AreEqual (ReadState.Interactive, reader.ReadState, "#4");
 190                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#4-1");
 191                         reader.Read (); // endoffile
 192                         Assert.AreEqual (ReadState.EndOfFile, reader.ReadState, "#5");
 193                         reader.Close ();
 194                         Assert.AreEqual (ReadState.Closed, reader.ReadState, "#6");
 195                 }
 196
 197                 [Test]
 198                 public void ReadBool ()
 199                 {
 200                         reader = CreateReader ("true");
 201                         Assert.AreEqual (ReadState.Initial, reader.ReadState, "#1");
 202                         reader.Read (); // dummy root element
 203                         Assert.AreEqual (ReadState.Interactive, reader.ReadState, "#2");
 204                         Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#2-1");
 205                         Assert.AreEqual ("root", reader.LocalName, "#2-2");
 206                         Assert.AreEqual ("boolean", reader.GetAttribute ("type"), "#2-3");
 207                         reader.Read (); // content (boolean)
 208                         Assert.AreEqual (ReadState.Interactive, reader.ReadState, "#3");
 209                         Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#3-1");
 210                         Assert.AreEqual ("true", reader.Value, "#3-2");
 211                         reader.Read (); // endelement
 212                         Assert.AreEqual (ReadState.Interactive, reader.ReadState, "#4");
 213                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#4-1");
 214                         reader.Read (); // endoffile
 215                         Assert.AreEqual (ReadState.EndOfFile, reader.ReadState, "#5");
 216                         reader.Close ();
 217                         Assert.AreEqual (ReadState.Closed, reader.ReadState, "#6");
 218                 }
 219
 220                 [Test]
 221                 public void ReadNull ()
 222                 {
 223                         reader = CreateReader ("null");
 224                         Assert.AreEqual (ReadState.Initial, reader.ReadState, "#1");
 225                         reader.Read (); // dummy root element
 226                         Assert.AreEqual (ReadState.Interactive, reader.ReadState, "#2");
 227                         Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#2-1");
 228                         Assert.AreEqual ("root", reader.LocalName, "#2-2");
 229                         // When it is null, the value is never given and the reader is skipped to the end element.
 230                         reader.Read (); // endlement
 231                         Assert.AreEqual (ReadState.Interactive, reader.ReadState, "#3");
 232                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#3-1");
 233                         reader.Read (); // endoffile
 234                         Assert.AreEqual (ReadState.EndOfFile, reader.ReadState, "#4");
 235                         reader.Close ();
 236                         Assert.AreEqual (ReadState.Closed, reader.ReadState, "#4");
 237                 }
 238
 239                 [Test]
 240                 public void ReadString ()
 241                 {
 242                         reader = CreateReader ("\"true\"");
 243                         Assert.AreEqual (ReadState.Initial, reader.ReadState, "#1");
 244                         reader.Read (); // dummy root element
 245                         Assert.AreEqual (ReadState.Interactive, reader.ReadState, "#2");
 246                         Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "#2-1");
 247                         Assert.AreEqual ("root", reader.LocalName, "#2-2");
 248                         Assert.AreEqual ("string", reader.GetAttribute ("type"), "#2-3");
 249                         reader.Read (); // content (number)
 250                         Assert.AreEqual (ReadState.Interactive, reader.ReadState, "#3");
 251                         Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#3-1");
 252                         Assert.AreEqual ("true", reader.Value, "#3-2");
 253                         reader.Read (); // endelement
 254                         Assert.AreEqual (ReadState.Interactive, reader.ReadState, "#4");
 255                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#4-1");
 256                         reader.Read (); // endoffile
 257                         Assert.AreEqual (ReadState.EndOfFile, reader.ReadState, "#5");
 258                         reader.Close ();
 259                         Assert.AreEqual (ReadState.Closed, reader.ReadState, "#6");
 260                 }
 261
 262                 // MoveToAttribute() / MoveToElement()
 263
 264                 [Test]
 265                 public void MoveToAttributeObject ()
 266                 {
 267                         reader = CreateReader ("{}");
 268                         Assert.IsFalse (reader.MoveToFirstAttribute (), "#1");
 269                         reader.Read (); // element
 270                         Assert.IsTrue (reader.MoveToFirstAttribute (), "#2");
 271                         Assert.AreEqual ("type", reader.LocalName, "#3");
 272                         Assert.AreEqual ("object", reader.Value, "#4");
 273                         Assert.IsTrue (reader.ReadAttributeValue (), "#5");
 274                         Assert.AreEqual ("object", reader.Value, "#6");
 275                         Assert.IsFalse (reader.MoveToNextAttribute (), "#7");
 276                         Assert.IsTrue (reader.MoveToFirstAttribute (), "#8");
 277                         Assert.IsFalse (reader.MoveToNextAttribute (), "#9");
 278                 }
 279
 280                 [Test]
 281                 public void MoveToElementObject ()
 282                 {
 283                         reader = CreateReader ("{}");
 284                         reader.Read (); // element
 285                         Assert.IsTrue (reader.MoveToFirstAttribute (), "#1");
 286                         Assert.IsTrue (reader.MoveToElement (), "#1-1");
 287
 288                         Assert.IsTrue (reader.MoveToFirstAttribute (), "#2");
 289                         Assert.IsTrue (reader.ReadAttributeValue (), "#2-1");
 290                         Assert.IsTrue (reader.MoveToElement (), "#2-2");
 291
 292                         Assert.IsTrue (reader.MoveToFirstAttribute (), "#3");
 293                         Assert.IsFalse (reader.MoveToNextAttribute (), "#3-1");
 294                         Assert.IsTrue (reader.MoveToElement (), "#3-2");
 295                 }
 296
 297                 [Test]
 298                 public void MoveToAttributeArray ()
 299                 {
 300                         reader = CreateReader ("[]");
 301                         Assert.IsFalse (reader.MoveToFirstAttribute (), "#1");
 302                         reader.Read (); // element
 303                         Assert.IsTrue (reader.MoveToFirstAttribute (), "#2");
 304                         Assert.AreEqual ("type", reader.LocalName, "#3");
 305                         Assert.AreEqual ("array", reader.Value, "#4");
 306                         Assert.IsTrue (reader.ReadAttributeValue (), "#5");
 307                         Assert.AreEqual ("array", reader.Value, "#6");
 308                         Assert.IsFalse (reader.MoveToNextAttribute (), "#7");
 309                         Assert.IsTrue (reader.MoveToFirstAttribute (), "#8");
 310                         Assert.IsFalse (reader.MoveToNextAttribute (), "#9");
 311                 }
 312
 313                 [Test]
 314                 public void MoveToElementArray ()
 315                 {
 316                         reader = CreateReader ("[]");
 317                         reader.Read (); // element
 318                         Assert.IsTrue (reader.MoveToFirstAttribute (), "#1");
 319                         Assert.IsTrue (reader.MoveToElement (), "#1-1");
 320
 321                         Assert.IsTrue (reader.MoveToFirstAttribute (), "#2");
 322                         Assert.IsTrue (reader.ReadAttributeValue (), "#2-1");
 323                         Assert.IsTrue (reader.MoveToElement (), "#2-2");
 324
 325                         Assert.IsTrue (reader.MoveToFirstAttribute (), "#3");
 326                         Assert.IsFalse (reader.MoveToNextAttribute (), "#3-1");
 327                         Assert.IsTrue (reader.MoveToElement (), "#3-2");
 328                 }
 329
 330                 [Test]
 331                 public void MoveToAttributeSimpleDummyRoot ()
 332                 {
 333                         reader = CreateReader ("1234");
 334                         Assert.IsFalse (reader.MoveToFirstAttribute (), "#1");
 335                         reader.Read (); // element
 336                         Assert.IsTrue (reader.MoveToFirstAttribute (), "#2");
 337                         Assert.AreEqual ("type", reader.LocalName, "#3");
 338                         Assert.AreEqual ("number", reader.Value, "#4");
 339                         Assert.IsTrue (reader.ReadAttributeValue (), "#5");
 340                         Assert.AreEqual ("number", reader.Value, "#6");
 341                         Assert.IsFalse (reader.MoveToNextAttribute (), "#7");
 342                         Assert.IsTrue (reader.MoveToFirstAttribute (), "#8");
 343                         Assert.IsFalse (reader.MoveToNextAttribute (), "#9");
 344                 }
 345
 346                 [Test]
 347                 public void MoveToElementSimpleDummyRoot ()
 348                 {
 349                         reader = CreateReader ("1234");
 350                         reader.Read (); // element
 351                         Assert.IsTrue (reader.MoveToFirstAttribute (), "#1");
 352                         Assert.IsTrue (reader.MoveToElement (), "#1-1");
 353
 354                         Assert.IsTrue (reader.MoveToFirstAttribute (), "#2");
 355                         Assert.IsTrue (reader.ReadAttributeValue (), "#2-1");
 356                         Assert.IsTrue (reader.MoveToElement (), "#2-2");
 357
 358                         Assert.IsTrue (reader.MoveToFirstAttribute (), "#3");
 359                         Assert.IsFalse (reader.MoveToNextAttribute (), "#3-1");
 360                         Assert.IsTrue (reader.MoveToElement (), "#3-2");
 361                 }
 362
 363                 // Read() arrays and objects
 364
 365                 [Test]
 366                 public void ReadArrayContent ()
 367                 {
 368                         reader = CreateReader ("[123, \"123\", true, \"true\"]");
 369
 370                         // number value
 371                         reader.Read (); // element
 372                         AssertNode (0, "root", XmlNodeType.Element, String.Empty, "array", reader, "#1");
 373
 374                         reader.Read (); // 123 - element
 375                         Assert.AreEqual ("number", reader.GetAttribute ("type"), "#2-0");
 376                         AssertNode (1, "item", XmlNodeType.Element, String.Empty, "number", reader, "#2");
 377                         reader.Read (); // 123 - text
 378                         AssertNode (2, String.Empty, XmlNodeType.Text, "123", null, reader, "#3");
 379                         reader.Read (); // 123 - endelement
 380                         AssertNode (1, "item", XmlNodeType.EndElement, String.Empty, null, reader, "#4");
 381
 382                         // string value #1
 383                         reader.Read (); // "123" - element
 384                         Assert.AreEqual ("string", reader.GetAttribute ("type"), "#5-0");
 385                         AssertNode (1, "item", XmlNodeType.Element, String.Empty, "string", reader, "#5");
 386                         reader.Read (); // "123" - text
 387                         AssertNode (2, String.Empty, XmlNodeType.Text, "123", null, reader, "#6");
 388                         reader.Read (); // "123" - endelement
 389                         AssertNode (1, "item", XmlNodeType.EndElement, String.Empty, null, reader, "#7");
 390
 391                         reader.Read (); // true - element
 392                         Assert.AreEqual ("boolean", reader.GetAttribute ("type"), "#8-0");
 393                         AssertNode (1, "item", XmlNodeType.Element, String.Empty, "boolean", reader, "#8");
 394                         reader.Read (); // true - text
 395                         AssertNode (2, String.Empty, XmlNodeType.Text, "true", null, reader, "#9");
 396                         reader.Read (); // true - endelement
 397                         AssertNode (1, "item", XmlNodeType.EndElement, String.Empty, null, reader, "#10");
 398
 399                         // string value #2
 400                         reader.Read (); // "true" - element
 401                         Assert.AreEqual ("string", reader.GetAttribute ("type"), "#11-0");
 402                         AssertNode (1, "item", XmlNodeType.Element, String.Empty, "string", reader, "#11");
 403                         reader.Read (); // "true" - text
 404                         AssertNode (2, String.Empty, XmlNodeType.Text, "true", null, reader, "#12");
 405                         reader.Read (); // "true" - endelement
 406                         AssertNode (1, "item", XmlNodeType.EndElement, String.Empty, null, reader, "#13");
 407                         Assert.IsTrue (reader.Read (), "#14"); // ]
 408                         AssertNode (0, "root", XmlNodeType.EndElement, String.Empty, null, reader, "#15");
 409                         Assert.IsFalse (reader.Read (), "#16"); // EOF
 410                 }
 411
 412                 [Test]
 413                 public void ReadObjectContent ()
 414                 {
 415                         reader = CreateReader ("{\"A\":123, \"B\": \"123\", \"C\" :true, \"D\" : \"true\"}");
 416
 417                         // number value
 418                         reader.Read (); // element
 419                         AssertNode (0, "root", XmlNodeType.Element, String.Empty, "object", reader, "#1");
 420
 421                         reader.Read (); // 123 - element
 422                         AssertNode (1, "A", XmlNodeType.Element, String.Empty, "number", reader, "#2");
 423                         reader.Read (); // 123 - text
 424                         AssertNode (2, String.Empty, XmlNodeType.Text, "123", null, reader, "#3");
 425                         reader.Read (); // 123 - endelement
 426                         AssertNode (1, "A", XmlNodeType.EndElement, String.Empty, null, reader, "#4");
 427
 428                         // string value #1
 429                         reader.Read (); // "123" - element
 430                         AssertNode (1, "B", XmlNodeType.Element, String.Empty, "string", reader, "#5");
 431                         reader.Read (); // "123" - text
 432                         AssertNode (2, String.Empty, XmlNodeType.Text, "123", null, reader, "#6");
 433                         reader.Read (); // "123" - endelement
 434                         AssertNode (1, "B", XmlNodeType.EndElement, String.Empty, null, reader, "#7");
 435
 436                         reader.Read (); // true - element
 437                         AssertNode (1, "C", XmlNodeType.Element, String.Empty, "boolean", reader, "#8");
 438                         reader.Read (); // true - text
 439                         AssertNode (2, String.Empty, XmlNodeType.Text, "true", null, reader, "#9");
 440                         reader.Read (); // true - endelement
 441                         AssertNode (1, "C", XmlNodeType.EndElement, String.Empty, null, reader, "#10");
 442
 443                         // string value #2
 444                         reader.Read (); // "true" - element
 445                         AssertNode (1, "D", XmlNodeType.Element, String.Empty, "string", reader, "#11");
 446                         reader.Read (); // "true" - text
 447                         AssertNode (2, String.Empty, XmlNodeType.Text, "true", null, reader, "#12");
 448                         reader.Read (); // "true" - endelement
 449                         AssertNode (1, "D", XmlNodeType.EndElement, String.Empty, null, reader, "#13");
 450                         Assert.IsTrue (reader.Read (), "#14"); // }
 451                         AssertNode (0, "root", XmlNodeType.EndElement, String.Empty, null, reader, "#15");
 452                         Assert.IsFalse (reader.Read (), "#16"); // EOF
 453                 }
 454
 455                 [Test]
 456                 public void ReadNestedObjects ()
 457                 {
 458                         reader = CreateReader ("{\"A\": [123, {\"B\": \"456\", \"C\" :true}], \"D\" : {\"E\" : \"false\"}}");
 459                         Assert.IsTrue (reader.Read (), "#1"); // {
 460                         AssertNode (0, "root", XmlNodeType.Element, String.Empty, "object", reader, "#2");
 461                         Assert.IsTrue (reader.Read (), "#3"); // A
 462                         AssertNode (1, "A", XmlNodeType.Element, String.Empty, "array", reader, "#4");
 463                         Assert.IsTrue (reader.Read (), "#5"); // (<123>)
 464                         AssertNode (2, "item", XmlNodeType.Element, String.Empty, "number", reader, "#6");
 465                         Assert.IsTrue (reader.Read (), "#7"); // (123)
 466                         AssertNode (3, String.Empty, XmlNodeType.Text, "123", null, reader, "#8");
 467                         Assert.IsTrue (reader.Read (), "#9"); // (</123>)
 468                         AssertNode (2, "item", XmlNodeType.EndElement, String.Empty, null, reader, "#10");
 469                         Assert.IsTrue (reader.Read (), "#11"); // {
 470                         AssertNode (2, "item", XmlNodeType.Element, String.Empty, "object", reader, "#12");
 471                         Assert.IsTrue (reader.Read (), "#13"); // B
 472                         AssertNode (3, "B", XmlNodeType.Element, String.Empty, "string", reader, "#14");
 473                         Assert.IsTrue (reader.Read (), "#15"); // "456"
 474                         AssertNode (4, String.Empty, XmlNodeType.Text, "456", null, reader, "#16");
 475                         Assert.IsTrue (reader.Read (), "#17"); // /B
 476                         AssertNode (3, "B", XmlNodeType.EndElement, String.Empty, null, reader, "#18");
 477
 478                         Assert.IsTrue (reader.Read (), "#19"); // C
 479                         AssertNode (3, "C", XmlNodeType.Element, String.Empty, "boolean", reader, "#20");
 480                         Assert.IsTrue (reader.Read (), "#21"); // true
 481                         AssertNode (4, String.Empty, XmlNodeType.Text, "true", null, reader, "#22");
 482                         Assert.IsTrue (reader.Read (), "#23"); // /C
 483                         AssertNode (3, "C", XmlNodeType.EndElement, String.Empty, null, reader, "#24");
 484                         Assert.IsTrue (reader.Read (), "#25"); // }
 485                         AssertNode (2, "item", XmlNodeType.EndElement, String.Empty, null, reader, "#26");
 486                         Assert.IsTrue (reader.Read (), "#27"); // ]
 487                         AssertNode (1, "A", XmlNodeType.EndElement, String.Empty, null, reader, "#28");
 488                         Assert.IsTrue (reader.Read (), "#29"); // {
 489                         AssertNode (1, "D", XmlNodeType.Element, String.Empty, "object", reader, "#30");
 490                         Assert.IsTrue (reader.Read (), "#31"); // D
 491                         AssertNode (2, "E", XmlNodeType.Element, String.Empty, "string", reader, "#32");
 492                         Assert.IsTrue (reader.Read (), "#33"); // "false"
 493                         AssertNode (3, String.Empty, XmlNodeType.Text, "false", null, reader, "#34");
 494                         Assert.IsTrue (reader.Read (), "#35"); // /D
 495                         AssertNode (2, "E", XmlNodeType.EndElement, String.Empty, null, reader, "#36");
 496                         Assert.IsTrue (reader.Read (), "#37"); // }
 497                         AssertNode (1, "D", XmlNodeType.EndElement, String.Empty, null, reader, "#38");
 498                         Assert.IsTrue (reader.Read (), "#39"); // }
 499                         AssertNode (0, "root", XmlNodeType.EndElement, String.Empty, null, reader, "#40");
 500                         Assert.IsFalse (reader.Read (), "#41"); // EOF
 501                 }
 502
 503                 void ReadToEnd (XmlDictionaryReader reader)
 504                 {
 505                         while (!reader.EOF)
 506                                 reader.Read ();
 507                 }
 508
 509                 // Read() valid and invalid contents
 510
 511                 [Test]
 512                 [ExpectedException (typeof (XmlException))]
 513                 public void ReadTwoTopLevelContents ()
 514                 {
 515                         ReadToEnd (CreateReader ("{}{}"));
 516                 }
 517
 518                 [Test]
 519                 [ExpectedException (typeof (XmlException))]
 520                 public void ReadMissingCloseCurly ()
 521                 {
 522                         ReadToEnd (CreateReader ("{"));
 523                 }
 524
 525                 [Test]
 526                 [ExpectedException (typeof (XmlException))]
 527                 public void ReadMissingCloseCurly2 ()
 528                 {
 529                         ReadToEnd (CreateReader ("{{}"));
 530                 }
 531
 532                 [Test]
 533                 [ExpectedException (typeof (XmlException))]
 534                 public void ReadExtraCloseCurly ()
 535                 {
 536                         ReadToEnd (CreateReader ("}"));
 537                 }
 538
 539                 [Test]
 540                 [ExpectedException (typeof (XmlException))]
 541                 public void ReadExtraCloseCurly2 ()
 542                 {
 543                         ReadToEnd (CreateReader ("{}}"));
 544                 }
 545
 546                 [Test]
 547                 [ExpectedException (typeof (XmlException))]
 548                 public void ReadMissingCloseBrace ()
 549                 {
 550                         ReadToEnd (CreateReader ("["));
 551                 }
 552
 553                 [Test]
 554                 [ExpectedException (typeof (XmlException))]
 555                 public void ReadMissingCloseBrace2 ()
 556                 {
 557                         ReadToEnd (CreateReader ("[[]"));
 558                 }
 559
 560                 [Test]
 561                 [ExpectedException (typeof (XmlException))]
 562                 public void ReadExtraCloseBrace ()
 563                 {
 564                         ReadToEnd (CreateReader ("]"));
 565                 }
 566
 567                 [Test]
 568                 [ExpectedException (typeof (XmlException))]
 569                 [Category ("NotDotNet")] // hmm, why does it pass?
 570                 public void ReadExtraCloseBrace2 ()
 571                 {
 572                         ReadToEnd (CreateReader ("[]]"));
 573                 }
 574
 575                 [Test]
 576                 [ExpectedException (typeof (XmlException))]
 577                 public void ReadOpenCurlyCloseBrace ()
 578                 {
 579                         ReadToEnd (CreateReader ("{]"));
 580                 }
 581
 582                 [Test]
 583                 [ExpectedException (typeof (XmlException))]
 584                 public void ReadOpenBraceCloseCurly ()
 585                 {
 586                         ReadToEnd (CreateReader ("[}"));
 587                 }
 588
 589                 [Test]
 590                 [ExpectedException (typeof (XmlException))]
 591                 public void ReadParens ()
 592                 {
 593                         ReadToEnd (CreateReader ("()"));
 594                 }
 595
 596                 [Test]
 597                 public void ReadValidNumber ()
 598                 {
 599                         ReadToEnd (CreateReader ("0"));
 600                 }
 601
 602                 [Test]
 603                 public void ReadValidNumber2 ()
 604                 {
 605                         ReadToEnd (CreateReader ("-0"));
 606                 }
 607
 608                 [Test]
 609                 public void ReadValidNumber3 ()
 610                 {
 611                         ReadToEnd (CreateReader ("0e5"));
 612                 }
 613
 614                 [Test]
 615                 public void ReadValidNumber4 ()
 616                 {
 617                         ReadToEnd (CreateReader ("0.5"));
 618                 }
 619
 620                 [Test]
 621                 [ExpectedException (typeof (XmlException))]
 622                 public void ReadInvalidNumber ()
 623                 {
 624                         CultureInfo originalCulture = Thread.CurrentThread.CurrentCulture;
 625                         try {
 626                                 Thread.CurrentThread.CurrentCulture = new CultureInfo ("de-DE");
 627                                 // if we read a number just by current culture, it will be regarded as correct JSON.
 628                                 ReadToEnd (CreateReader ("123,45"));
 629                         } finally {
 630                                 Thread.CurrentThread.CurrentCulture = originalCulture;
 631                         }
 632                 }
 633
 634                 [Test]
 635                 public void ReadValidNumberGerman ()
 636                 {
 637                         CultureInfo originalCulture = Thread.CurrentThread.CurrentCulture;
 638                         try {
 639                                 Thread.CurrentThread.CurrentCulture = new CultureInfo ("de-DE");
 640                                 var s = GetInput ("123.45"); // German is ',' for decimals
 641                                 var r = new DataContractJsonSerializer (typeof (double));
 642                                 var d = (double) r.ReadObject (s);
 643                                 Assert.AreEqual (123.45, d, "InvariantCulture");
 644                         } finally {
 645                                 Thread.CurrentThread.CurrentCulture = originalCulture;
 646                         }
 647                 }
 648
 649                 [Test]
 650                 [ExpectedException (typeof (XmlException))]
 651                 public void ReadInvalidNumber2 ()
 652                 {
 653                         ReadToEnd (CreateReader ("+5"));
 654                 }
 655
 656                 [Test]
 657                 [ExpectedException (typeof (XmlException))]
 658                 [Category ("NotDotNet")] // likely .NET bug
 659                 public void ReadInvalidNumber3 ()
 660                 {
 661                         ReadToEnd (CreateReader ("01"));
 662                 }
 663
 664                 [Test]
 665                 [ExpectedException (typeof (XmlException))]
 666                 public void ReadInvalidNumber4 ()
 667                 {
 668                         ReadToEnd (CreateReader (".1"));
 669                 }
 670
 671                 [Test]
 672                 [ExpectedException (typeof (XmlException))]
 673                 [Category ("NotDotNet")] // likely .NET bug
 674                 public void ReadInvalidNumber5 ()
 675                 {
 676                         ReadToEnd (CreateReader ("10."));
 677                 }
 678
 679                 [Test]
 680                 [ExpectedException (typeof (XmlException))]
 681                 public void ReadInvalidNumber7 ()
 682                 {
 683                         ReadToEnd (CreateReader ("e5"));
 684                 }
 685
 686                 [Test]
 687                 [ExpectedException (typeof (XmlException))]
 688                 [Category ("NotDotNet")] // likely .NET bug
 689                 public void ReadInvalidNumber8 ()
 690                 {
 691                         ReadToEnd (CreateReader ("-e5"));
 692                 }
 693
 694                 [Test]
 695                 [ExpectedException (typeof (XmlException))]
 696                 [Category ("NotDotNet")] // likely .NET bug
 697                 public void ReadInvalidNumber9 ()
 698                 {
 699                         ReadToEnd (CreateReader ("-e5.5"));
 700                 }
 701
 702                 [Test]
 703                 public void ReadInvalidNumber10 () // bug #531904
 704                 {
 705                         ReadToEnd (CreateReader ("4.29153442382814E-05"));
 706                 }
 707
 708                 [Test]
 709                 [ExpectedException (typeof (XmlException))]
 710                 public void ReadInvalidObjectContent ()
 711                 {
 712                         ReadToEnd (CreateReader ("{\"foo\"}"));
 713                 }
 714
 715                 [Test]
 716                 [ExpectedException (typeof (XmlException))]
 717                 [Category ("NotDotNet")] // likely .NET bug
 718                 public void ReadInvalidObjectContent2 ()
 719                 {
 720                         ReadToEnd (CreateReader ("{\"A\": 123 456}"));
 721                 }
 722
 723                 [Test]
 724                 [ExpectedException (typeof (XmlException))]
 725                 public void ReadInvalidObjectContent3 ()
 726                 {
 727                         ReadToEnd (CreateReader ("{, \"A\":123, \"B\":456}"));
 728                 }
 729
 730                 [Test]
 731                 [ExpectedException (typeof (XmlException))]
 732                 [Category ("NotDotNet")] // likely .NET bug
 733                 public void ReadInvalidObjectContent4 ()
 734                 {
 735                         ReadToEnd (CreateReader ("{\"A\":123, \"B\":456,}"));
 736                 }
 737
 738                 [Test]
 739                 [ExpectedException (typeof (XmlException))]
 740                 public void ReadInvalidArrayContent ()
 741                 {
 742                         ReadToEnd (CreateReader ("[\"foo\":\"bar\"]"));
 743                 }
 744
 745                 [Test]
 746                 [ExpectedException (typeof (XmlException))]
 747                 [Category ("NotDotNet")] // likely .NET bug
 748                 public void ReadInvalidArrayContent2 ()
 749                 {
 750                         ReadToEnd (CreateReader ("[123 456]"));
 751                 }
 752
 753                 [Test]
 754                 [ExpectedException (typeof (XmlException))]
 755                 public void ReadInvalidArrayContent3 ()
 756                 {
 757                         ReadToEnd (CreateReader ("[,123,456]"));
 758                 }
 759
 760                 [Test]
 761                 [ExpectedException (typeof (XmlException))]
 762                 [Category ("NotDotNet")] // likely .NET bug
 763                 public void ReadInvalidArrayContent4 ()
 764                 {
 765                         ReadToEnd (CreateReader ("[123,456,]"));
 766                 }
 767
 768                 [Test]
 769                 public void ReadObjectRuntimeTypeAsAttribute ()
 770                 {
 771                         XmlDictionaryReader r = CreateReader ("{\"__type\":\"System.Int32\"}");
 772                         r.Read ();
 773                         AssertNode (0, "root", XmlNodeType.Element, String.Empty, "object", r, "#1");
 774                         Assert.IsTrue (r.MoveToAttribute ("type"), "#2");
 775                         AssertNode (0, "type", XmlNodeType.Attribute, "object", "object", r, "#3");
 776                         Assert.IsTrue (r.MoveToAttribute ("__type"), "#4");
 777                         AssertNode (0, "__type", XmlNodeType.Attribute, "System.Int32", "object", r, "#5");
 778                         r.Read ();
 779                         Assert.AreEqual (XmlNodeType.EndElement, r.NodeType, "#6");
 780                 }
 781
 782                 [Test]
 783                 public void ReadObjectRuntimeType ()
 784                 {
 785                         XmlDictionaryReader r = CreateReader ("{\"__type\":\"System.Int32\", \"foo\":true}");
 786                         r.Read ();
 787                         AssertNode (0, "root", XmlNodeType.Element, String.Empty, "object", r, "#1");
 788                         Assert.IsTrue (r.MoveToAttribute ("type"), "#2");
 789                         AssertNode (0, "type", XmlNodeType.Attribute, "object", "object", r, "#3");
 790                         Assert.IsTrue (r.MoveToAttribute ("__type"), "#4");
 791                         AssertNode (0, "__type", XmlNodeType.Attribute, "System.Int32", "object", r, "#5");
 792                         r.Read ();
 793                         Assert.AreEqual (XmlNodeType.Element, r.NodeType, "#6");
 794                         Assert.AreEqual ("foo", r.LocalName, "#7");
 795                 }
 796
 797                 [Test]
 798                 [ExpectedException (typeof (XmlException))]
 799                 public void ReadInvalidObjectRuntimeTypeValue ()
 800                 {
 801                         ReadToEnd (CreateReader ("{\"__type\":true}"));
 802                 }
 803
 804                 [Test]
 805                 public void ReadObjectRuntimeTypeIncorrectPosition ()
 806                 {
 807                         XmlReader r = CreateReader ("{\"foo\" : false, \"__type\" : \"System.Int32\"}");
 808                         r.Read ();
 809                         // When __type is not at the first content, it is not regarded as an attribute. Note that it is not treated as an error.
 810                         Assert.IsFalse (r.MoveToAttribute ("__type"));
 811                         r.Skip ();
 812                 }
 813
 814                 [Test]
 815                 public void ReadObjectRuntimeTypeInArray ()
 816                 {
 817                         XmlReader r = CreateReader (@"[{""__type"":""DCWithEnum:#MonoTests.System.Runtime.Serialization.Json"",""_colors"":0}]");
 818                         r.Read ();
 819                         Assert.AreEqual ("root", r.LocalName, "#1-1");
 820                         Assert.AreEqual ("array", r.GetAttribute ("type"), "#1-2");
 821                         r.Read ();
 822                         Assert.AreEqual ("item", r.LocalName, "#2-1");
 823                         Assert.AreEqual ("object", r.GetAttribute ("type"), "#2-2");
 824                         Assert.IsNotNull (r.GetAttribute ("__type"), "#2-3");
 825                         r.Read ();
 826                 }
 827
 828                 [Test]
 829                 public void Skip ()
 830                 {
 831                         XmlReader r = CreateReader ("{\"type\" : \"\", \"valid\" : \"0\", \"other\" : \"\"}");
 832                         r.ReadStartElement ();
 833                         r.MoveToContent ();
 834                         Assert.AreEqual ("type", r.Name, "Skip-1");
 835                         r.ReadElementContentAsString ();
 836                         r.MoveToContent ();
 837                         Assert.AreEqual ("valid", r.Name, "Skip-2");
 838                         r.Skip ();
 839                         Assert.AreEqual ("other", r.Name, "Skip-3");
 840                 }
 841
 842                 [Test]
 843                 public void Depth ()
 844                 {
 845                         XmlReader r = CreateReader ("{\"type\" : \"\", \"valid\" : \"0\"}");
 846                         r.ReadStartElement ();
 847                         r.Read ();
 848                         Assert.AreEqual (2, r.Depth, "Depth-1");
 849                 }
 850
 851                 [Test]
 852                 public void UnicodeEncodingAutoDetect ()
 853                 {
 854                         var ms = new MemoryStream (Encoding.Unicode.GetBytes ("{\"type\" : \"\", \"valid\" : \"0\"}"));
 855                         XmlReader r = JsonReaderWriterFactory.CreateJsonReader (ms, new XmlDictionaryReaderQuotas ());
 856                         r.ReadStartElement ();
 857                         r.Read ();
 858                 }
 859
 860                 [Test]
 861                 public void ReadNumberAsObject ()
 862                 {
 863                         const double testValue = 42.42D;
 864                         var serializer = new DataContractJsonSerializer (typeof (object));
 865                         var serializedStream = GetInput (testValue.ToString (CultureInfo.InvariantCulture));
 866                         var deserializedValue = serializer.ReadObject (serializedStream);
 867                         Assert.AreEqual (typeof (decimal), deserializedValue.GetType ());
 868                         Assert.AreEqual (testValue, (decimal) deserializedValue);
 869                 }
 870
 871                 [Test]
 872                 public void IEnumerableTest ()
 873                 {
 874                         string json = "[\"A\", \"B\"]";
 875                         using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(json))) {
 876                                 DataContractJsonSerializer jsonSerializer = new
 877                                         DataContractJsonSerializer(typeof(IEnumerable<string>));
 878                                 var result = jsonSerializer.ReadObject(stream);
 879                                 Assert.AreEqual (typeof (List<string>), result.GetType ());
 880                         }
 881                 }
 882         }
 883 }