mcs/class/System.XML/Test/System.Xml/XmlReaderCommonTests.cs

   1 //\r
   2 // System.Xml.XmlReaderCommonTests\r
   3 //\r
   4 // Authors:\r
   5 //   Atsushi Enomoto <ginga@kit.hi-ho.ne.jp>\r
   6 //\r
   7 // (C) 2003 Atsushi Enomoto\r
   8 //  Note: Most of testcases are moved from XmlTextReaderTests.cs and\r
   9 //  XmlNodeReaderTests.cs.\r
  10 //\r
  11 \r
  12 using System;\r
  13 using System.IO;\r
  14 using System.Text;\r
  15 using System.Xml;\r
  16 using System.Xml.Schema;\r
  17 using System.Xml.XPath;\r
  18 #if NET_4_5\r
  19 using System.Threading;\r
  20 using System.Threading.Tasks;\r
  21 #endif\r
  22 \r
  23 using NUnit.Framework;\r
  24 \r
  25 namespace MonoTests.System.Xml\r
  26 {\r
  27         [TestFixture]\r
  28         public class XmlReaderTests\r
  29         {\r
  30                 [SetUp]\r
  31                 public void GetReady ()\r
  32                 {\r
  33                         document = new XmlDocument ();\r
  34                         document.LoadXml (xml1);\r
  35                 }\r
  36 \r
  37                 XmlDocument document;\r
  38                 const string xml1 = "<root attr1='value1'><child /></root>";\r
  39                 const string xml2 = "<root><foo/><bar>test.</bar></root>";\r
  40                 const string xml3 = "<root>  test of <b>mixed</b> string.<![CDATA[ cdata string.]]></root>";\r
  41                 const string xml4 = "<root>test of <b>mixed</b> string.</root>";\r
  42                 XmlTextReader xtr;\r
  43                 XmlNodeReader xnr;\r
  44 \r
  45                 // copy from XmlTextReaderTests\r
  46                 private void AssertStartDocument (XmlReader xmlReader)\r
  47                 {\r
  48                         Assert.IsTrue (xmlReader.ReadState == ReadState.Initial);\r
  49                         Assert.IsTrue (xmlReader.NodeType == XmlNodeType.None);\r
  50                         Assert.IsTrue (xmlReader.Depth == 0);\r
  51                         Assert.IsTrue (!xmlReader.EOF);\r
  52                 }\r
  53 \r
  54                 private void AssertNode (\r
  55                         XmlReader xmlReader,\r
  56                         XmlNodeType nodeType,\r
  57                         int depth,\r
  58                         bool isEmptyElement,\r
  59                         string name,\r
  60                         string prefix,\r
  61                         string localName,\r
  62                         string namespaceURI,\r
  63                         string value,\r
  64                         int attributeCount)\r
  65                 {\r
  66                         AssertNode ("", xmlReader, nodeType, depth,\r
  67                                 isEmptyElement, name, prefix, localName,\r
  68                                 namespaceURI, value, attributeCount);\r
  69                 }\r
  70 \r
  71                 private void AssertNode (\r
  72                         string label,\r
  73                         XmlReader xmlReader,\r
  74                         XmlNodeType nodeType,\r
  75                         int depth,\r
  76                         bool isEmptyElement,\r
  77                         string name,\r
  78                         string prefix,\r
  79                         string localName,\r
  80                         string namespaceURI,\r
  81                         string value,\r
  82                         int attributeCount)\r
  83                 {\r
  84                         Assert.IsTrue (xmlReader.Read (), label + " Read() return value");\r
  85                         Assert.IsTrue (xmlReader.ReadState == ReadState.Interactive, label + " ReadState");\r
  86                         Assert.IsTrue (!xmlReader.EOF, label + " !EOF");\r
  87                         AssertNodeValues (label, xmlReader, nodeType, depth,\r
  88                                 isEmptyElement, name, prefix, localName,\r
  89                                 namespaceURI, value, value != String.Empty,\r
  90                                 attributeCount, attributeCount > 0);\r
  91                 }\r
  92 \r
  93                 private void AssertNodeValues (\r
  94                         string label,\r
  95                         XmlReader xmlReader,\r
  96                         XmlNodeType nodeType,\r
  97                         int depth,\r
  98                         bool isEmptyElement,\r
  99                         string name,\r
 100                         string prefix,\r
 101                         string localName,\r
 102                         string namespaceURI,\r
 103                         string value,\r
 104                         int attributeCount)\r
 105                 {\r
 106                         AssertNodeValues (label, xmlReader, nodeType, depth,\r
 107                                 isEmptyElement, name, prefix, localName,\r
 108                                 namespaceURI, value, value != String.Empty,\r
 109                                 attributeCount, attributeCount > 0);\r
 110                 }\r
 111 \r
 112                 private void AssertNodeValues (\r
 113                         string label,\r
 114                         XmlReader xmlReader,\r
 115                         XmlNodeType nodeType,\r
 116                         int depth,\r
 117                         bool isEmptyElement,\r
 118                         string name,\r
 119                         string prefix,\r
 120                         string localName,\r
 121                         string namespaceURI,\r
 122                         string value,\r
 123                         bool hasValue,\r
 124                         int attributeCount,\r
 125                         bool hasAttributes)\r
 126                 {\r
 127                         label = String.Concat (label, "(", xmlReader.GetType ().Name, ")");\r
 128                         Assert.AreEqual (nodeType, xmlReader.NodeType, label + ": NodeType");\r
 129                         Assert.AreEqual (isEmptyElement, xmlReader.IsEmptyElement, label + ": IsEmptyElement");\r
 130 \r
 131                         Assert.AreEqual (name, xmlReader.Name, label + ": name");\r
 132 \r
 133                         Assert.AreEqual (prefix, xmlReader.Prefix, label + ": prefix");\r
 134 \r
 135                         Assert.AreEqual (localName, xmlReader.LocalName, label + ": localName");\r
 136 \r
 137                         Assert.AreEqual (namespaceURI, xmlReader.NamespaceURI, label + ": namespaceURI");\r
 138 \r
 139                         Assert.AreEqual (depth, xmlReader.Depth, label + ": Depth");\r
 140 \r
 141                         Assert.AreEqual (hasValue, xmlReader.HasValue, label + ": hasValue");\r
 142 \r
 143                         Assert.AreEqual (value, xmlReader.Value, label + ": Value");\r
 144 \r
 145                         Assert.AreEqual (hasAttributes, xmlReader.HasAttributes, label + ": hasAttributes");\r
 146 \r
 147                         Assert.AreEqual (attributeCount, xmlReader.AttributeCount, label + ": attributeCount");\r
 148                 }\r
 149 \r
 150                 private void AssertAttribute (\r
 151                         XmlReader xmlReader,\r
 152                         string name,\r
 153                         string prefix,\r
 154                         string localName,\r
 155                         string namespaceURI,\r
 156                         string value)\r
 157                 {\r
 158                         Assert.AreEqual (value, xmlReader [name], "value");\r
 159 \r
 160                         Assert.IsTrue (xmlReader.GetAttribute (name) == value);\r
 161 \r
 162                         if (namespaceURI != String.Empty) {\r
 163                                 Assert.IsTrue (xmlReader[localName, namespaceURI] == value);\r
 164                                 Assert.IsTrue (xmlReader.GetAttribute (localName, namespaceURI) == value);\r
 165                         }\r
 166                 }\r
 167 \r
 168                 private void AssertEndDocument (XmlReader xmlReader)\r
 169                 {\r
 170                         Assert.IsTrue (!xmlReader.Read (), "could read");\r
 171                         Assert.AreEqual (XmlNodeType.None, xmlReader.NodeType, "NodeType is not XmlNodeType.None");\r
 172                         Assert.AreEqual (0, xmlReader.Depth, "Depth is not 0");\r
 173                         Assert.AreEqual (ReadState.EndOfFile, xmlReader.ReadState, "ReadState is not ReadState.EndOfFile");\r
 174                         Assert.IsTrue (xmlReader.EOF, "not EOF");\r
 175 \r
 176                         xmlReader.Close ();\r
 177                         Assert.AreEqual (ReadState.Closed, xmlReader.ReadState, "ReadState is not ReadState.Cosed");\r
 178                 }\r
 179 \r
 180                 private delegate void TestMethod (XmlReader reader);\r
 181 \r
 182                 private void RunTest (string xml, TestMethod method)\r
 183                 {\r
 184                         xtr = new XmlTextReader (new StringReader (xml));\r
 185                         method (xtr);\r
 186 \r
 187                         // DTD validation\r
 188                         xtr = new XmlTextReader (new StringReader (xml));\r
 189                         XmlValidatingReader xvr = new XmlValidatingReader (xtr);\r
 190                         xvr.ValidationType = ValidationType.DTD;\r
 191                         xvr.EntityHandling = EntityHandling.ExpandCharEntities;\r
 192                         method (xvr);\r
 193 \r
 194                         // XSD validation\r
 195                         xtr = new XmlTextReader (new StringReader (xml));\r
 196                         xvr = new XmlValidatingReader (xtr);\r
 197                         xvr.EntityHandling = EntityHandling.ExpandCharEntities;\r
 198                         method (xvr);\r
 199 \r
 200                         document.XmlResolver = null;\r
 201                         document.LoadXml (xml);\r
 202                         xnr = new XmlNodeReader (document);\r
 203                         method (xnr);\r
 204 #if NET_2_0\r
 205 /*\r
 206                         // XPathNavigatorReader tests\r
 207                         System.Xml.XPath.XPathDocument doc = new System.Xml.XPath.XPathDocument (new StringReader (xml));\r
 208                         XmlReader xpr = doc.CreateNavigator ().ReadSubtree ();\r
 209                         method (xpr);\r
 210 */\r
 211 #endif\r
 212                 }\r
 213 \r
 214 \r
 215 \r
 216 \r
 217 \r
 218                 [Test]\r
 219                 public void InitialState ()\r
 220                 {\r
 221                         RunTest (xml1, new TestMethod (InitialState));\r
 222                 }\r
 223 \r
 224                 private void InitialState (XmlReader reader)\r
 225                 {\r
 226                         Assert.AreEqual (0, reader.Depth, "Depth");\r
 227                         Assert.AreEqual (false, reader.EOF, "EOF");\r
 228                         Assert.AreEqual (false, reader.HasValue, "HasValue");\r
 229                         Assert.AreEqual (false, reader.IsEmptyElement, "IsEmptyElement");\r
 230                         Assert.AreEqual (String.Empty, reader.LocalName, "LocalName");\r
 231                         Assert.AreEqual (XmlNodeType.None, reader.NodeType, "NodeType");\r
 232                         Assert.AreEqual (ReadState.Initial, reader.ReadState, "ReadState");\r
 233                 }\r
 234 \r
 235                 [Test]\r
 236                 public void Read ()\r
 237                 {\r
 238                         RunTest (xml1, new TestMethod (Read));\r
 239                 }\r
 240 \r
 241                 public void Read (XmlReader reader)\r
 242                 {\r
 243                         reader.Read ();\r
 244                         Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "<root>.NodeType");\r
 245                         Assert.AreEqual ("root", reader.Name, "<root>.Name");\r
 246                         Assert.AreEqual (ReadState.Interactive, reader.ReadState, "<root>.ReadState");\r
 247                         Assert.AreEqual (0, reader.Depth, "<root>.Depth");\r
 248 \r
 249                         // move to 'child'\r
 250                         reader.Read ();\r
 251                         Assert.AreEqual (1, reader.Depth, "<child/>.Depth");\r
 252                         Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "<child/>.NodeType");\r
 253                         Assert.AreEqual ("child", reader.Name, "<child/>.Name");\r
 254 \r
 255                         reader.Read ();\r
 256                         Assert.AreEqual (0, reader.Depth, "</root>.Depth");\r
 257                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "</root>.NodeType");\r
 258                         Assert.AreEqual ("root", reader.Name, "</root>.Name");\r
 259 \r
 260                         reader.Read ();\r
 261                         Assert.AreEqual (true, reader.EOF, "end.EOF");\r
 262                         Assert.AreEqual (XmlNodeType.None, reader.NodeType, "end.NodeType");\r
 263                 }\r
 264 \r
 265                 [Test]\r
 266                 [Category ("NotDotNet")]\r
 267                 public void ReadAttributeValue ()\r
 268                 {\r
 269                         RunTest ("<root attr=''/>", new TestMethod (ReadAttributeValue));\r
 270                 }\r
 271 \r
 272                 public void ReadAttributeValue (XmlReader reader)\r
 273                 {\r
 274                         reader.Read (); // root\r
 275                         Assert.IsTrue (reader.MoveToFirstAttribute ());\r
 276                         // It looks like that MS.NET shows AttributeCount and\r
 277                         // HasAttributes as the same as element node!\r
 278                         this.AssertNodeValues ("#1",\r
 279                                 reader, XmlNodeType.Attribute,\r
 280                                 1, false, "attr", "", "attr", "", "", true, 1, true);\r
 281                         Assert.IsTrue (reader.ReadAttributeValue ());\r
 282                         // MS.NET XmlTextReader fails. Its Prefix returns \r
 283                         // null instead of "". It is fixed in MS.NET 2.0.\r
 284                         this.AssertNodeValues ("#2",\r
 285                                 reader, XmlNodeType.Text,\r
 286                                 2, false, "", "", "", "", "", true, 1, true);\r
 287                         Assert.IsTrue (reader.MoveToElement ());\r
 288                         this.AssertNodeValues ("#3",\r
 289                                 reader, XmlNodeType.Element,\r
 290                                 0, true, "root", "", "root", "", "", false, 1, true);\r
 291                 }\r
 292 \r
 293                 [Test]\r
 294                 public void ReadEmptyElement ()\r
 295                 {\r
 296                         RunTest (xml2, new TestMethod (ReadEmptyElement));\r
 297                 }\r
 298 \r
 299                 public void ReadEmptyElement (XmlReader reader)\r
 300                 {\r
 301                         reader.Read (); // root\r
 302                         Assert.AreEqual (false, reader.IsEmptyElement);\r
 303                         reader.Read (); // foo\r
 304                         Assert.AreEqual ("foo", reader.Name);\r
 305                         Assert.AreEqual (true, reader.IsEmptyElement);\r
 306                         reader.Read (); // bar\r
 307                         Assert.AreEqual ("bar", reader.Name);\r
 308                         Assert.AreEqual (false, reader.IsEmptyElement);\r
 309                 }\r
 310 \r
 311                 [Test]\r
 312                 public void ReadStringFromElement ()\r
 313                 {\r
 314                         RunTest (xml3, new TestMethod (ReadStringFromElement));\r
 315                 }\r
 316 \r
 317                 public void ReadStringFromElement (XmlReader reader)\r
 318                 {\r
 319                         // Note: ReadString() test works only when the reader is\r
 320                         // positioned at the container element.\r
 321                         // In case the reader is positioned at the first \r
 322                         // character node, XmlTextReader and XmlNodeReader works\r
 323                         // different!!\r
 324 \r
 325                         reader.Read ();\r
 326                         string s = reader.ReadString ();\r
 327                         Assert.AreEqual ("  test of ", s, "readString.1.ret_val");\r
 328                         Assert.AreEqual ("b", reader.Name, "readString.1.Name");\r
 329                         s = reader.ReadString ();\r
 330                         Assert.AreEqual ("mixed", s, "readString.2.ret_val");\r
 331                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "readString.2.NodeType");\r
 332                         s = reader.ReadString ();       // never proceeds.\r
 333                         Assert.AreEqual (String.Empty, s, "readString.3.ret_val");\r
 334                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "readString.3.NodeType");\r
 335                         reader.Read ();\r
 336                         Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "readString.4.NodeType");\r
 337                         Assert.AreEqual (" string.", reader.Value, "readString.4.Value");\r
 338                         s = reader.ReadString ();       // reads the same Text node.\r
 339                         Assert.AreEqual (" string. cdata string.", s, "readString.5.ret_val");\r
 340                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "readString.5.NodeType");\r
 341                 }\r
 342 \r
 343                 [Test]\r
 344                 public void ReadInnerXml ()\r
 345                 {\r
 346                         const string xml = "<root><foo>test of <b>mixed</b> string.</foo><bar /></root>";\r
 347                         RunTest (xml, new TestMethod (ReadInnerXml));\r
 348                 }\r
 349 \r
 350                 public void ReadInnerXml (XmlReader reader)\r
 351                 {\r
 352                         reader.Read ();\r
 353                         reader.Read ();\r
 354                         Assert.AreEqual (ReadState.Interactive, reader.ReadState, "initial.ReadState");\r
 355                         Assert.AreEqual (false, reader.EOF, "initial.EOF");\r
 356                         Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "initial.NodeType");\r
 357                         string s = reader.ReadInnerXml ();\r
 358                         Assert.AreEqual ("test of <b>mixed</b> string.", s, "read_all");\r
 359                         Assert.AreEqual ("bar", reader.Name, "after.Name");\r
 360                         Assert.AreEqual (XmlNodeType.Element, reader.NodeType, "after.NodeType");\r
 361                 }\r
 362 \r
 363 \r
 364                 [Test]\r
 365                 public void EmptyElement ()\r
 366                 {\r
 367                         RunTest ("<foo/>", new TestMethod (EmptyElement));\r
 368                 }\r
 369                 \r
 370                 public void EmptyElement (XmlReader xmlReader)\r
 371                 {\r
 372 \r
 373                         AssertStartDocument (xmlReader);\r
 374 \r
 375                         AssertNode (\r
 376                                 xmlReader, // xmlReader\r
 377                                 XmlNodeType.Element, // nodeType\r
 378                                 0, // depth\r
 379                                 true, // isEmptyElement\r
 380                                 "foo", // name\r
 381                                 String.Empty, // prefix\r
 382                                 "foo", // localName\r
 383                                 String.Empty, // namespaceURI\r
 384                                 String.Empty, // value\r
 385                                 0 // attributeCount\r
 386                         );\r
 387 \r
 388                         AssertEndDocument (xmlReader);\r
 389                 }\r
 390 \r
 391                 [Test]\r
 392                 public void NestedEmptyTag ()\r
 393                 {\r
 394                         string xml = "<foo><bar/></foo>";\r
 395                         RunTest (xml, new TestMethod (NestedEmptyTag));\r
 396                 }\r
 397 \r
 398                 public void NestedEmptyTag (XmlReader xmlReader)\r
 399                 {\r
 400                         AssertStartDocument (xmlReader);\r
 401 \r
 402                         AssertNode (\r
 403                                 "#1",\r
 404                                 xmlReader, // xmlReader\r
 405                                 XmlNodeType.Element, // nodeType\r
 406                                 0, //depth\r
 407                                 false, // isEmptyElement\r
 408                                 "foo", // name\r
 409                                 String.Empty, // prefix\r
 410                                 "foo", // localName\r
 411                                 String.Empty, // namespaceURI\r
 412                                 String.Empty, // value\r
 413                                 0 // attributeCount\r
 414                         );\r
 415 \r
 416                         AssertNode (\r
 417                                 "#2",\r
 418                                 xmlReader, // xmlReader\r
 419                                 XmlNodeType.Element, // nodeType\r
 420                                 1, //depth\r
 421                                 true, // isEmptyElement\r
 422                                 "bar", // name\r
 423                                 String.Empty, // prefix\r
 424                                 "bar", // localName\r
 425                                 String.Empty, // namespaceURI\r
 426                                 String.Empty, // value\r
 427                                 0 // attributeCount\r
 428                         );\r
 429 \r
 430                         AssertNode (\r
 431                                 "#3",\r
 432                                 xmlReader, // xmlReader\r
 433                                 XmlNodeType.EndElement, // nodeType\r
 434                                 0, //depth\r
 435                                 false, // isEmptyElement\r
 436                                 "foo", // name\r
 437                                 String.Empty, // prefix\r
 438                                 "foo", // localName\r
 439                                 String.Empty, // namespaceURI\r
 440                                 String.Empty, // value\r
 441                                 0 // attributeCount\r
 442                         );\r
 443 \r
 444                         AssertEndDocument (xmlReader);\r
 445                 }\r
 446 \r
 447                 [Test]\r
 448                 public void NestedText ()\r
 449                 {\r
 450                         string xml = "<foo>bar</foo>";\r
 451                         RunTest (xml, new TestMethod (NestedText));\r
 452                 }\r
 453 \r
 454                 public void NestedText (XmlReader xmlReader)\r
 455                 {\r
 456                         AssertStartDocument (xmlReader);\r
 457 \r
 458                         AssertNode (\r
 459                                 xmlReader, // xmlReader\r
 460                                 XmlNodeType.Element, // nodeType\r
 461                                 0, //depth\r
 462                                 false, // isEmptyElement\r
 463                                 "foo", // name\r
 464                                 String.Empty, // prefix\r
 465                                 "foo", // localName\r
 466                                 String.Empty, // namespaceURI\r
 467                                 String.Empty, // value\r
 468                                 0 // attributeCount\r
 469                         );\r
 470 \r
 471                         AssertNode (\r
 472                                 xmlReader, // xmlReader\r
 473                                 XmlNodeType.Text, // nodeType\r
 474                                 1, //depth\r
 475                                 false, // isEmptyElement\r
 476                                 String.Empty, // name\r
 477                                 String.Empty, // prefix\r
 478                                 String.Empty, // localName\r
 479                                 String.Empty, // namespaceURI\r
 480                                 "bar", // value\r
 481                                 0 // attributeCount\r
 482                         );\r
 483 \r
 484                         AssertNode (\r
 485                                 xmlReader, // xmlReader\r
 486                                 XmlNodeType.EndElement, // nodeType\r
 487                                 0, //depth\r
 488                                 false, // isEmptyElement\r
 489                                 "foo", // name\r
 490                                 String.Empty, // prefix\r
 491                                 "foo", // localName\r
 492                                 String.Empty, // namespaceURI\r
 493                                 String.Empty, // value\r
 494                                 0 // attributeCount\r
 495                         );\r
 496 \r
 497                         AssertEndDocument (xmlReader);\r
 498                 }\r
 499 \r
 500                 [Test]\r
 501                 public void EmptyElementWithAttributes ()\r
 502                 {\r
 503                         string xml = @"<foo bar=""baz"" quux='quuux' x:foo='x-foo' xmlns:x = 'urn:xfoo' />";\r
 504                         RunTest (xml, new TestMethod (EmptyElementWithAttributes ));\r
 505                 }\r
 506 \r
 507                 public void EmptyElementWithAttributes (XmlReader xmlReader)\r
 508                 {\r
 509 \r
 510                         AssertStartDocument (xmlReader);\r
 511 \r
 512                         AssertNode (\r
 513                                 xmlReader, // xmlReader\r
 514                                 XmlNodeType.Element, // nodeType\r
 515                                 0, //depth\r
 516                                 true, // isEmptyElement\r
 517                                 "foo", // name\r
 518                                 String.Empty, // prefix\r
 519                                 "foo", // localName\r
 520                                 String.Empty, // namespaceURI\r
 521                                 String.Empty, // value\r
 522                                 4 // attributeCount\r
 523                         );\r
 524 \r
 525                         AssertAttribute (\r
 526                                 xmlReader, // xmlReader\r
 527                                 "bar", // name\r
 528                                 String.Empty, // prefix\r
 529                                 "bar", // localName\r
 530                                 String.Empty, // namespaceURI\r
 531                                 "baz" // value\r
 532                         );\r
 533 \r
 534                         AssertAttribute (\r
 535                                 xmlReader, // xmlReader\r
 536                                 "quux", // name\r
 537                                 String.Empty, // prefix\r
 538                                 "quux", // localName\r
 539                                 String.Empty, // namespaceURI\r
 540                                 "quuux" // value\r
 541                         );\r
 542 \r
 543                         AssertAttribute (\r
 544                                 xmlReader, // xmlReader\r
 545                                 "notexist", // name\r
 546                                 String.Empty, // prefix\r
 547                                 "notexist", // localName\r
 548                                 String.Empty, // namespaceURI\r
 549                                 null // value\r
 550                         );\r
 551 \r
 552                         AssertAttribute (\r
 553                                 xmlReader, // xmlReader\r
 554                                 "x:foo", // name\r
 555                                 "x", // prefix\r
 556                                 "foo", // localName\r
 557                                 "urn:xfoo", // namespaceURI\r
 558                                 "x-foo" // value\r
 559                         );\r
 560 \r
 561                         AssertAttribute (\r
 562                                 xmlReader, // xmlReader\r
 563                                 "x:bar", // name\r
 564                                 "x", // prefix\r
 565                                 "bar", // localName\r
 566                                 "urn:xfoo", // namespaceURI\r
 567                                 null // value\r
 568                         );\r
 569 \r
 570                         AssertEndDocument (xmlReader);\r
 571                 }\r
 572 \r
 573                 [Test]\r
 574                 public void ProcessingInstructionBeforeDocumentElement ()\r
 575                 {\r
 576                         string xml = "<?foo bar?><baz/>";\r
 577                         RunTest (xml, new TestMethod (ProcessingInstructionBeforeDocumentElement));\r
 578                 }\r
 579 \r
 580                 public void ProcessingInstructionBeforeDocumentElement (XmlReader xmlReader)\r
 581                 {\r
 582                         AssertStartDocument (xmlReader);\r
 583 \r
 584                         AssertNode (\r
 585                                 xmlReader, // xmlReader\r
 586                                 XmlNodeType.ProcessingInstruction, // nodeType\r
 587                                 0, //depth\r
 588                                 false, // isEmptyElement\r
 589                                 "foo", // name\r
 590                                 String.Empty, // prefix\r
 591                                 "foo", // localName\r
 592                                 String.Empty, // namespaceURI\r
 593                                 "bar", // value\r
 594                                 0 // attributeCount\r
 595                         );\r
 596 \r
 597                         AssertNode (\r
 598                                 xmlReader, // xmlReader\r
 599                                 XmlNodeType.Element, // nodeType\r
 600                                 0, //depth\r
 601                                 true, // isEmptyElement\r
 602                                 "baz", // name\r
 603                                 String.Empty, // prefix\r
 604                                 "baz", // localName\r
 605                                 String.Empty, // namespaceURI\r
 606                                 String.Empty, // value\r
 607                                 0 // attributeCount\r
 608                         );\r
 609 \r
 610                         AssertEndDocument (xmlReader);\r
 611                 }\r
 612 \r
 613                 [Test]\r
 614                 public void CommentBeforeDocumentElement ()\r
 615                 {\r
 616                         string xml = "<!--foo--><bar/>";\r
 617                         RunTest (xml, new TestMethod (CommentBeforeDocumentElement));\r
 618                 }\r
 619 \r
 620                 public void CommentBeforeDocumentElement (XmlReader xmlReader)\r
 621                 {\r
 622                         AssertStartDocument (xmlReader);\r
 623 \r
 624                         AssertNode (\r
 625                                 xmlReader, // xmlReader\r
 626                                 XmlNodeType.Comment, // nodeType\r
 627                                 0, //depth\r
 628                                 false, // isEmptyElement\r
 629                                 String.Empty, // name\r
 630                                 String.Empty, // prefix\r
 631                                 String.Empty, // localName\r
 632                                 String.Empty, // namespaceURI\r
 633                                 "foo", // value\r
 634                                 0 // attributeCount\r
 635                         );\r
 636 \r
 637                         AssertNode (\r
 638                                 xmlReader, // xmlReader\r
 639                                 XmlNodeType.Element, // nodeType\r
 640                                 0, //depth\r
 641                                 true, // isEmptyElement\r
 642                                 "bar", // name\r
 643                                 String.Empty, // prefix\r
 644                                 "bar", // localName\r
 645                                 String.Empty, // namespaceURI\r
 646                                 String.Empty, // value\r
 647                                 0 // attributeCount\r
 648                         );\r
 649 \r
 650                         AssertEndDocument (xmlReader);\r
 651                 }\r
 652 \r
 653                 [Test]\r
 654                 public void PredefinedEntities ()\r
 655                 {\r
 656                         string xml = "<foo>&lt;&gt;&amp;&apos;&quot;</foo>";\r
 657                         RunTest (xml, new TestMethod (PredefinedEntities));\r
 658                 }\r
 659 \r
 660                 public void PredefinedEntities (XmlReader xmlReader)\r
 661                 {\r
 662                         AssertStartDocument (xmlReader);\r
 663 \r
 664                         AssertNode (\r
 665                                 xmlReader, // xmlReader\r
 666                                 XmlNodeType.Element, // nodeType\r
 667                                 0, //depth\r
 668                                 false, // isEmptyElement\r
 669                                 "foo", // name\r
 670                                 String.Empty, // prefix\r
 671                                 "foo", // localName\r
 672                                 String.Empty, // namespaceURI\r
 673                                 String.Empty, // value\r
 674                                 0 // attributeCount\r
 675                         );\r
 676 \r
 677                         AssertNode (\r
 678                                 xmlReader, // xmlReader\r
 679                                 XmlNodeType.Text, // nodeType\r
 680                                 1, //depth\r
 681                                 false, // isEmptyElement\r
 682                                 String.Empty, // name\r
 683                                 String.Empty, // prefix\r
 684                                 String.Empty, // localName\r
 685                                 String.Empty, // namespaceURI\r
 686                                 "<>&'\"", // value\r
 687                                 0 // attributeCount\r
 688                         );\r
 689 \r
 690                         AssertNode (\r
 691                                 xmlReader, // xmlReader\r
 692                                 XmlNodeType.EndElement, // nodeType\r
 693                                 0, //depth\r
 694                                 false, // isEmptyElement\r
 695                                 "foo", // name\r
 696                                 String.Empty, // prefix\r
 697                                 "foo", // localName\r
 698                                 String.Empty, // namespaceURI\r
 699                                 String.Empty, // value\r
 700                                 0 // attributeCount\r
 701                         );\r
 702 \r
 703                         AssertEndDocument (xmlReader);\r
 704                 }\r
 705 \r
 706                 [Test]\r
 707                 public void CharacterReferences ()\r
 708                 {\r
 709                         string xml = "<foo>&#70;&#x4F;&#x4f;</foo>";\r
 710                         RunTest (xml, new TestMethod (CharacterReferences));\r
 711                 }\r
 712 \r
 713                 public void CharacterReferences (XmlReader xmlReader)\r
 714                 {\r
 715                         AssertStartDocument (xmlReader);\r
 716 \r
 717                         AssertNode (\r
 718                                 xmlReader, // xmlReader\r
 719                                 XmlNodeType.Element, // nodeType\r
 720                                 0, //depth\r
 721                                 false, // isEmptyElement\r
 722                                 "foo", // name\r
 723                                 String.Empty, // prefix\r
 724                                 "foo", // localName\r
 725                                 String.Empty, // namespaceURI\r
 726                                 String.Empty, // value\r
 727                                 0 // attributeCount\r
 728                         );\r
 729 \r
 730                         AssertNode (\r
 731                                 xmlReader, // xmlReader\r
 732                                 XmlNodeType.Text, // nodeType\r
 733                                 1, //depth\r
 734                                 false, // isEmptyElement\r
 735                                 String.Empty, // name\r
 736                                 String.Empty, // prefix\r
 737                                 String.Empty, // localName\r
 738                                 String.Empty, // namespaceURI\r
 739                                 "FOO", // value\r
 740                                 0 // attributeCount\r
 741                         );\r
 742 \r
 743                         AssertNode (\r
 744                                 xmlReader, // xmlReader\r
 745                                 XmlNodeType.EndElement, // nodeType\r
 746                                 0, //depth\r
 747                                 false, // isEmptyElement\r
 748                                 "foo", // name\r
 749                                 String.Empty, // prefix\r
 750                                 "foo", // localName\r
 751                                 String.Empty, // namespaceURI\r
 752                                 String.Empty, // value\r
 753                                 0 // attributeCount\r
 754                         );\r
 755 \r
 756                         AssertEndDocument (xmlReader);\r
 757                 }\r
 758 \r
 759                 [Test]\r
 760                 public void PredefinedEntitiesInAttribute ()\r
 761                 {\r
 762                         string xml = "<foo bar='&lt;&gt;&amp;&apos;&quot;'/>";\r
 763                         RunTest (xml, new TestMethod (PredefinedEntitiesInAttribute ));\r
 764                 }\r
 765 \r
 766                 public void PredefinedEntitiesInAttribute (XmlReader xmlReader)\r
 767                 {\r
 768                         AssertStartDocument (xmlReader);\r
 769 \r
 770                         AssertNode (\r
 771                                 xmlReader, // xmlReader\r
 772                                 XmlNodeType.Element, // nodeType\r
 773                                 0, //depth\r
 774                                 true, // isEmptyElement\r
 775                                 "foo", // name\r
 776                                 String.Empty, // prefix\r
 777                                 "foo", // localName\r
 778                                 String.Empty, // namespaceURI\r
 779                                 String.Empty, // value\r
 780                                 1 // attributeCount\r
 781                         );\r
 782 \r
 783                         AssertAttribute (\r
 784                                 xmlReader, // xmlReader\r
 785                                 "bar", // name\r
 786                                 String.Empty, // prefix\r
 787                                 "bar", // localName\r
 788                                 String.Empty, // namespaceURI\r
 789                                 "<>&'\"" // value\r
 790                         );\r
 791 \r
 792                         AssertEndDocument (xmlReader);\r
 793                 }\r
 794 \r
 795                 [Test]\r
 796                 public void CharacterReferencesInAttribute ()\r
 797                 {\r
 798                         string xml = "<foo bar='&#70;&#x4F;&#x4f;'/>";\r
 799                         RunTest (xml, new TestMethod (CharacterReferencesInAttribute));\r
 800                 }\r
 801 \r
 802                 public void CharacterReferencesInAttribute (XmlReader xmlReader)\r
 803                 {\r
 804                         AssertStartDocument (xmlReader);\r
 805 \r
 806                         AssertNode (\r
 807                                 xmlReader, // xmlReader\r
 808                                 XmlNodeType.Element, // nodeType\r
 809                                 0, //depth\r
 810                                 true, // isEmptyElement\r
 811                                 "foo", // name\r
 812                                 String.Empty, // prefix\r
 813                                 "foo", // localName\r
 814                                 String.Empty, // namespaceURI\r
 815                                 String.Empty, // value\r
 816                                 1 // attributeCount\r
 817                         );\r
 818 \r
 819                         AssertAttribute (\r
 820                                 xmlReader, // xmlReader\r
 821                                 "bar", // name\r
 822                                 String.Empty, // prefix\r
 823                                 "bar", // localName\r
 824                                 String.Empty, // namespaceURI\r
 825                                 "FOO" // value\r
 826                         );\r
 827 \r
 828                         AssertEndDocument (xmlReader);\r
 829                 }\r
 830 \r
 831                 [Test]\r
 832                 public void CDATA ()\r
 833                 {\r
 834                         string xml = "<foo><![CDATA[<>&]]></foo>";\r
 835                         RunTest (xml, new TestMethod (CDATA));\r
 836                 }\r
 837 \r
 838                 public void CDATA (XmlReader xmlReader)\r
 839                 {\r
 840                         AssertStartDocument (xmlReader);\r
 841 \r
 842                         AssertNode (\r
 843                                 xmlReader, // xmlReader\r
 844                                 XmlNodeType.Element, // nodeType\r
 845                                 0, //depth\r
 846                                 false, // isEmptyElement\r
 847                                 "foo", // name\r
 848                                 String.Empty, // prefix\r
 849                                 "foo", // localName\r
 850                                 String.Empty, // namespaceURI\r
 851                                 String.Empty, // value\r
 852                                 0 // attributeCount\r
 853                         );\r
 854 \r
 855                         AssertNode (\r
 856                                 xmlReader, // xmlReader\r
 857                                 XmlNodeType.CDATA, // nodeType\r
 858                                 1, //depth\r
 859                                 false, // isEmptyElement\r
 860                                 String.Empty, // name\r
 861                                 String.Empty, // prefix\r
 862                                 String.Empty, // localName\r
 863                                 String.Empty, // namespaceURI\r
 864                                 "<>&", // value\r
 865                                 0 // attributeCount\r
 866                         );\r
 867 \r
 868                         AssertNode (\r
 869                                 xmlReader, // xmlReader\r
 870                                 XmlNodeType.EndElement, // nodeType\r
 871                                 0, //depth\r
 872                                 false, // isEmptyElement\r
 873                                 "foo", // name\r
 874                                 String.Empty, // prefix\r
 875                                 "foo", // localName\r
 876                                 String.Empty, // namespaceURI\r
 877                                 String.Empty, // value\r
 878                                 0 // attributeCount\r
 879                         );\r
 880 \r
 881                         AssertEndDocument (xmlReader);\r
 882                 }\r
 883 \r
 884                 [Test]\r
 885                 public void EmptyElementInDefaultNamespace ()\r
 886                 {\r
 887                         string xml = @"<foo xmlns='http://foo/' />";\r
 888                         RunTest (xml, new TestMethod (EmptyElementInDefaultNamespace));\r
 889                 }\r
 890 \r
 891                 public void EmptyElementInDefaultNamespace (XmlReader xmlReader)\r
 892                 {\r
 893                         AssertStartDocument (xmlReader);\r
 894 \r
 895                         AssertNode (\r
 896                                 xmlReader, // xmlReader\r
 897                                 XmlNodeType.Element, // nodeType\r
 898                                 0, // depth\r
 899                                 true, // isEmptyElement\r
 900                                 "foo", // name\r
 901                                 String.Empty, // prefix\r
 902                                 "foo", // localName\r
 903                                 "http://foo/", // namespaceURI\r
 904                                 String.Empty, // value\r
 905                                 1 // attributeCount\r
 906                         );\r
 907 \r
 908                         AssertAttribute (\r
 909                                 xmlReader, // xmlReader\r
 910                                 "xmlns", // name\r
 911                                 String.Empty, // prefix\r
 912                                 "xmlns", // localName\r
 913                                 "http://www.w3.org/2000/xmlns/", // namespaceURI\r
 914                                 "http://foo/" // value\r
 915                         );\r
 916 \r
 917                         Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace (String.Empty));\r
 918 \r
 919                         AssertEndDocument (xmlReader);\r
 920                 }\r
 921 \r
 922                 [Test]\r
 923                 public void ChildElementInNamespace ()\r
 924                 {\r
 925                         string xml = @"<foo:bar xmlns:foo='http://foo/'><baz:quux xmlns:baz='http://baz/' /></foo:bar>";\r
 926                         RunTest (xml, new TestMethod (ChildElementInNamespace));\r
 927                 }\r
 928 \r
 929                 public void ChildElementInNamespace (XmlReader xmlReader)\r
 930                 {\r
 931                         AssertStartDocument (xmlReader);\r
 932 \r
 933                         AssertNode (\r
 934                                 xmlReader, // xmlReader\r
 935                                 XmlNodeType.Element, // nodeType\r
 936                                 0, // depth\r
 937                                 false, // isEmptyElement\r
 938                                 "foo:bar", // name\r
 939                                 "foo", // prefix\r
 940                                 "bar", // localName\r
 941                                 "http://foo/", // namespaceURI\r
 942                                 String.Empty, // value\r
 943                                 1 // attributeCount\r
 944                         );\r
 945 \r
 946                         AssertAttribute (\r
 947                                 xmlReader, // xmlReader\r
 948                                 "xmlns:foo", // name\r
 949                                 "xmlns", // prefix\r
 950                                 "foo", // localName\r
 951                                 "http://www.w3.org/2000/xmlns/", // namespaceURI\r
 952                                 "http://foo/" // value\r
 953                         );\r
 954 \r
 955                         Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
 956 \r
 957                         AssertNode (\r
 958                                 xmlReader, // xmlReader\r
 959                                 XmlNodeType.Element, // nodeType\r
 960                                 1, // depth\r
 961                                 true, // isEmptyElement\r
 962                                 "baz:quux", // name\r
 963                                 "baz", // prefix\r
 964                                 "quux", // localName\r
 965                                 "http://baz/", // namespaceURI\r
 966                                 String.Empty, // value\r
 967                                 1 // attributeCount\r
 968                         );\r
 969 \r
 970                         AssertAttribute (\r
 971                                 xmlReader, // xmlReader\r
 972                                 "xmlns:baz", // name\r
 973                                 "xmlns", // prefix\r
 974                                 "baz", // localName\r
 975                                 "http://www.w3.org/2000/xmlns/", // namespaceURI\r
 976                                 "http://baz/" // value\r
 977                         );\r
 978 \r
 979                         Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
 980                         Assert.AreEqual ("http://baz/", xmlReader.LookupNamespace ("baz"));\r
 981 \r
 982                         AssertNode (\r
 983                                 xmlReader, // xmlReader\r
 984                                 XmlNodeType.EndElement, // nodeType\r
 985                                 0, // depth\r
 986                                 false, // isEmptyElement\r
 987                                 "foo:bar", // name\r
 988                                 "foo", // prefix\r
 989                                 "bar", // localName\r
 990                                 "http://foo/", // namespaceURI\r
 991                                 String.Empty, // value\r
 992                                 0 // attributeCount\r
 993                         );\r
 994 \r
 995                         Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
 996                         Assert.IsNull (xmlReader.LookupNamespace ("baz"));\r
 997 \r
 998                         AssertEndDocument (xmlReader);\r
 999                 }\r
1000 \r
1001                 [Test]\r
1002                 public void ChildElementInDefaultNamespace ()\r
1003                 {\r
1004                         string xml = @"<foo:bar xmlns:foo='http://foo/'><baz xmlns='http://baz/' /></foo:bar>";\r
1005                         RunTest (xml, new TestMethod (ChildElementInDefaultNamespace));\r
1006                 }\r
1007 \r
1008                 public void ChildElementInDefaultNamespace (XmlReader xmlReader)\r
1009                 {\r
1010                         AssertStartDocument (xmlReader);\r
1011 \r
1012                         AssertNode (\r
1013                                 xmlReader, // xmlReader\r
1014                                 XmlNodeType.Element, // nodeType\r
1015                                 0, // depth\r
1016                                 false, // isEmptyElement\r
1017                                 "foo:bar", // name\r
1018                                 "foo", // prefix\r
1019                                 "bar", // localName\r
1020                                 "http://foo/", // namespaceURI\r
1021                                 String.Empty, // value\r
1022                                 1 // attributeCount\r
1023                         );\r
1024 \r
1025                         AssertAttribute (\r
1026                                 xmlReader, // xmlReader\r
1027                                 "xmlns:foo", // name\r
1028                                 "xmlns", // prefix\r
1029                                 "foo", // localName\r
1030                                 "http://www.w3.org/2000/xmlns/", // namespaceURI\r
1031                                 "http://foo/" // value\r
1032                         );\r
1033 \r
1034                         Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
1035 \r
1036                         AssertNode (\r
1037                                 xmlReader, // xmlReader\r
1038                                 XmlNodeType.Element, // nodeType\r
1039                                 1, // depth\r
1040                                 true, // isEmptyElement\r
1041                                 "baz", // name\r
1042                                 String.Empty, // prefix\r
1043                                 "baz", // localName\r
1044                                 "http://baz/", // namespaceURI\r
1045                                 String.Empty, // value\r
1046                                 1 // attributeCount\r
1047                         );\r
1048 \r
1049                         AssertAttribute (\r
1050                                 xmlReader, // xmlReader\r
1051                                 "xmlns", // name\r
1052                                 String.Empty, // prefix\r
1053                                 "xmlns", // localName\r
1054                                 "http://www.w3.org/2000/xmlns/", // namespaceURI\r
1055                                 "http://baz/" // value\r
1056                         );\r
1057 \r
1058                         Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
1059                         Assert.AreEqual ("http://baz/", xmlReader.LookupNamespace (String.Empty));\r
1060 \r
1061                         AssertNode (\r
1062                                 xmlReader, // xmlReader\r
1063                                 XmlNodeType.EndElement, // nodeType\r
1064                                 0, // depth\r
1065                                 false, // isEmptyElement\r
1066                                 "foo:bar", // name\r
1067                                 "foo", // prefix\r
1068                                 "bar", // localName\r
1069                                 "http://foo/", // namespaceURI\r
1070                                 String.Empty, // value\r
1071                                 0 // attributeCount\r
1072                         );\r
1073 \r
1074                         Assert.AreEqual ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
1075 \r
1076                         AssertEndDocument (xmlReader);\r
1077                 }\r
1078 \r
1079                 [Test]\r
1080                 public void AttributeInNamespace ()\r
1081                 {\r
1082                         string xml = @"<foo bar:baz='quux' xmlns:bar='http://bar/' />";\r
1083                         RunTest (xml, new TestMethod (AttributeInNamespace));\r
1084                 }\r
1085 \r
1086                 public void AttributeInNamespace (XmlReader xmlReader)\r
1087                 {\r
1088                         AssertStartDocument (xmlReader);\r
1089 \r
1090                         AssertNode (\r
1091                                 xmlReader, // xmlReader\r
1092                                 XmlNodeType.Element, // nodeType\r
1093                                 0, // depth\r
1094                                 true, // isEmptyElement\r
1095                                 "foo", // name\r
1096                                 String.Empty, // prefix\r
1097                                 "foo", // localName\r
1098                                 String.Empty, // namespaceURI\r
1099                                 String.Empty, // value\r
1100                                 2 // attributeCount\r
1101                         );\r
1102 \r
1103                         AssertAttribute (\r
1104                                 xmlReader, // xmlReader\r
1105                                 "bar:baz", // name\r
1106                                 "bar", // prefix\r
1107                                 "baz", // localName\r
1108                                 "http://bar/", // namespaceURI\r
1109                                 "quux" // value\r
1110                         );\r
1111 \r
1112                         AssertAttribute (\r
1113                                 xmlReader, // xmlReader\r
1114                                 "xmlns:bar", // name\r
1115                                 "xmlns", // prefix\r
1116                                 "bar", // localName\r
1117                                 "http://www.w3.org/2000/xmlns/", // namespaceURI\r
1118                                 "http://bar/" // value\r
1119                         );\r
1120 \r
1121                         Assert.AreEqual ("http://bar/", xmlReader.LookupNamespace ("bar"));\r
1122 \r
1123                         AssertEndDocument (xmlReader);\r
1124                 }\r
1125 \r
1126                 [Test]\r
1127                 public void MoveToElementFromAttribute ()\r
1128                 {\r
1129                         string xml = @"<foo bar=""baz"" />";\r
1130                         RunTest (xml, new TestMethod (MoveToElementFromAttribute));\r
1131                 }\r
1132 \r
1133                 public void MoveToElementFromAttribute (XmlReader xmlReader)\r
1134                 {\r
1135                         Assert.IsTrue (xmlReader.Read ());\r
1136                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1137                         Assert.IsTrue (xmlReader.MoveToFirstAttribute ());\r
1138                         Assert.AreEqual (XmlNodeType.Attribute, xmlReader.NodeType);\r
1139                         Assert.IsTrue (xmlReader.MoveToElement ());\r
1140                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1141                 }\r
1142 \r
1143                 [Test]\r
1144                 public void MoveToElementFromElement ()\r
1145                 {\r
1146                         string xml = @"<foo bar=""baz"" />";\r
1147                         RunTest (xml, new TestMethod (MoveToElementFromElement));\r
1148                 }\r
1149 \r
1150                 public void MoveToElementFromElement (XmlReader xmlReader)\r
1151                 {\r
1152                         Assert.IsTrue (xmlReader.Read ());\r
1153                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1154                         Assert.IsTrue (!xmlReader.MoveToElement ());\r
1155                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1156                 }\r
1157 \r
1158                 [Test]\r
1159                 public void MoveToFirstAttributeWithNoAttributes ()\r
1160                 {\r
1161                         string xml = @"<foo />";\r
1162                         RunTest (xml, new TestMethod (MoveToFirstAttributeWithNoAttributes));\r
1163                 }\r
1164 \r
1165                 public void MoveToFirstAttributeWithNoAttributes (XmlReader xmlReader)\r
1166                 {\r
1167                         Assert.IsTrue (xmlReader.Read ());\r
1168                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1169                         Assert.IsTrue (!xmlReader.MoveToFirstAttribute ());\r
1170                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1171                 }\r
1172 \r
1173                 [Test]\r
1174                 public void MoveToNextAttributeWithNoAttributes ()\r
1175                 {\r
1176                         string xml = @"<foo />";\r
1177                         RunTest (xml, new TestMethod (MoveToNextAttributeWithNoAttributes));\r
1178                 }\r
1179 \r
1180                 public void MoveToNextAttributeWithNoAttributes (XmlReader xmlReader)\r
1181                 {\r
1182                         Assert.IsTrue (xmlReader.Read ());\r
1183                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1184                         Assert.IsTrue (!xmlReader.MoveToNextAttribute ());\r
1185                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1186                 }\r
1187 \r
1188                 [Test]\r
1189                 public void MoveToNextAttribute()\r
1190                 {\r
1191                         string xml = @"<foo bar=""baz"" quux='quuux'/>";\r
1192                         RunTest (xml, new TestMethod (MoveToNextAttribute));\r
1193                 }\r
1194 \r
1195                 public void MoveToNextAttribute (XmlReader xmlReader)\r
1196                 {\r
1197                         AssertStartDocument (xmlReader);\r
1198 \r
1199                         AssertNode (\r
1200                                 xmlReader, // xmlReader\r
1201                                 XmlNodeType.Element, // nodeType\r
1202                                 0, //depth\r
1203                                 true, // isEmptyElement\r
1204                                 "foo", // name\r
1205                                 String.Empty, // prefix\r
1206                                 "foo", // localName\r
1207                                 String.Empty, // namespaceURI\r
1208                                 String.Empty, // value\r
1209                                 2 // attributeCount\r
1210                         );\r
1211 \r
1212                         AssertAttribute (\r
1213                                 xmlReader, // xmlReader\r
1214                                 "bar", // name\r
1215                                 String.Empty, // prefix\r
1216                                 "bar", // localName\r
1217                                 String.Empty, // namespaceURI\r
1218                                 "baz" // value\r
1219                         );\r
1220 \r
1221                         AssertAttribute (\r
1222                                 xmlReader, // xmlReader\r
1223                                 "quux", // name\r
1224                                 String.Empty, // prefix\r
1225                                 "quux", // localName\r
1226                                 String.Empty, // namespaceURI\r
1227                                 "quuux" // value\r
1228                         );\r
1229 \r
1230                         Assert.IsTrue (xmlReader.MoveToNextAttribute ());\r
1231                         Assert.AreEqual ("bar", xmlReader.Name);\r
1232                         Assert.AreEqual ("baz", xmlReader.Value);\r
1233 \r
1234                         Assert.IsTrue (xmlReader.MoveToNextAttribute ());\r
1235                         Assert.AreEqual ("quux", xmlReader.Name);\r
1236                         Assert.AreEqual ("quuux", xmlReader.Value);\r
1237 \r
1238                         Assert.IsTrue (!xmlReader.MoveToNextAttribute ());\r
1239 \r
1240                         Assert.IsTrue (xmlReader.MoveToElement ());\r
1241 \r
1242                         AssertNodeValues (\r
1243                                 "#1",\r
1244                                 xmlReader, // xmlReader\r
1245                                 XmlNodeType.Element, // nodeType\r
1246                                 0, //depth\r
1247                                 true, // isEmptyElement\r
1248                                 "foo", // name\r
1249                                 String.Empty, // prefix\r
1250                                 "foo", // localName\r
1251                                 String.Empty, // namespaceURI\r
1252                                 String.Empty, // value\r
1253                                 2 // attributeCount\r
1254                         );\r
1255 \r
1256                         AssertEndDocument (xmlReader);\r
1257                 }\r
1258 \r
1259                 [Test]\r
1260 //              [Category ("NotDotNet")] // MS XmlNodeReader never moves to xml declaration.\r
1261                 [Ignore ("Too inconsistent reference implementations to determine which is correct behavior.")]\r
1262                 public void MoveToXmlDeclAttributes ()\r
1263                 {\r
1264                         string xml = "<?xml version=\"1.0\" standalone=\"yes\"?><root/>";\r
1265                         RunTest (xml, new TestMethod (MoveToXmlDeclAttributes));\r
1266                 }\r
1267 \r
1268                 public void MoveToXmlDeclAttributes (XmlReader xmlReader)\r
1269                 {\r
1270                         xmlReader.Read ();\r
1271                         this.AssertNodeValues ("#1", xmlReader, \r
1272                                 XmlNodeType.XmlDeclaration,\r
1273                                 0,\r
1274                                 false,\r
1275                                 "xml",\r
1276                                 String.Empty,\r
1277                                 "xml",\r
1278                                 String.Empty,\r
1279                                 "version=\"1.0\" standalone=\"yes\"",\r
1280                                 2);\r
1281                         Assert.IsTrue (xmlReader.MoveToFirstAttribute (), "MoveToFirstAttribute");\r
1282                         this.AssertNodeValues ("#2", xmlReader, \r
1283                                 XmlNodeType.Attribute,\r
1284                                 0, // FIXME: might be 1\r
1285                                 false,\r
1286                                 "version",\r
1287                                 String.Empty,\r
1288                                 "version",\r
1289                                 String.Empty,\r
1290                                 "1.0",\r
1291                                 2);\r
1292                         xmlReader.ReadAttributeValue ();\r
1293                         this.AssertNodeValues ("#3", xmlReader, \r
1294                                 XmlNodeType.Text,\r
1295                                 1, // FIXME might be 2\r
1296                                 false,\r
1297                                 String.Empty,\r
1298                                 null, // FIXME: should be String.Empty,\r
1299                                 String.Empty,\r
1300                                 null, // FIXME: should be String.Empty,\r
1301                                 "1.0",\r
1302                                 2);\r
1303                         xmlReader.MoveToNextAttribute ();\r
1304                         this.AssertNodeValues ("#4", xmlReader, \r
1305                                 XmlNodeType.Attribute,\r
1306                                 0, // FIXME: might be 1\r
1307                                 false,\r
1308                                 "standalone",\r
1309                                 String.Empty,\r
1310                                 "standalone",\r
1311                                 String.Empty,\r
1312                                 "yes",\r
1313                                 2);\r
1314                         xmlReader.ReadAttributeValue ();\r
1315                         this.AssertNodeValues ("#5", xmlReader, \r
1316                                 XmlNodeType.Text,\r
1317                                 1, // FIXME: might be 2\r
1318                                 false,\r
1319                                 String.Empty,\r
1320                                 null, // FIXME: should be String.Empty,\r
1321                                 String.Empty,\r
1322                                 null, // FIXME: should be String.Empty,\r
1323                                 "yes",\r
1324                                 2);\r
1325                 }\r
1326 \r
1327                 [Test]\r
1328                 public void AttributeOrder ()\r
1329                 {\r
1330                         string xml = @"<foo _1='1' _2='2' _3='3' />";\r
1331                         RunTest (xml, new TestMethod (AttributeOrder));\r
1332                 }\r
1333 \r
1334                 public void AttributeOrder (XmlReader xmlReader)\r
1335                 {\r
1336                         Assert.IsTrue (xmlReader.Read ());\r
1337                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1338 \r
1339                         Assert.IsTrue (xmlReader.MoveToFirstAttribute ());\r
1340                         Assert.AreEqual ("_1", xmlReader.Name);\r
1341                         Assert.IsTrue (xmlReader.MoveToNextAttribute ());\r
1342                         Assert.AreEqual ("_2", xmlReader.Name);\r
1343                         Assert.IsTrue (xmlReader.MoveToNextAttribute ());\r
1344                         Assert.AreEqual ("_3", xmlReader.Name);\r
1345 \r
1346                         Assert.IsTrue (!xmlReader.MoveToNextAttribute ());\r
1347                 }\r
1348 \r
1349                 [Test]\r
1350                 [Category ("NotDotNet")]\r
1351                 public void IndexerAndAttributes ()\r
1352                 {\r
1353                         string xml = @"<?xml version='1.0' standalone='no'?><foo _1='1' _2='2' _3='3' />";\r
1354                         RunTest (xml, new TestMethod (IndexerAndAttributes));\r
1355                 }\r
1356 \r
1357                 public void IndexerAndAttributes (XmlReader xmlReader)\r
1358                 {\r
1359                         Assert.IsTrue (xmlReader.Read ());\r
1360                         Assert.AreEqual ("1.0", xmlReader ["version"]);\r
1361                         Assert.AreEqual ("1.0", xmlReader.GetAttribute ("version"));\r
1362                         // .NET 1.1 BUG. XmlTextReader returns null, while XmlNodeReader returns "".\r
1363                         Assert.AreEqual (null, xmlReader ["encoding"]);\r
1364                         Assert.AreEqual (null, xmlReader.GetAttribute ("encoding"));\r
1365                         Assert.AreEqual ("no", xmlReader ["standalone"]);\r
1366                         Assert.AreEqual ("no", xmlReader.GetAttribute ("standalone"));\r
1367                         Assert.AreEqual ("1.0", xmlReader [0]);\r
1368                         Assert.AreEqual ("1.0", xmlReader.GetAttribute (0));\r
1369                         Assert.AreEqual ("no", xmlReader [1]);\r
1370                         Assert.AreEqual ("no", xmlReader.GetAttribute (1));\r
1371 \r
1372                         Assert.IsTrue (xmlReader.Read ());\r
1373                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1374                         Assert.AreEqual ("1", xmlReader ["_1"]);\r
1375 \r
1376                         Assert.IsTrue (xmlReader.MoveToFirstAttribute ());\r
1377                         Assert.AreEqual ("_1", xmlReader.Name);\r
1378                         Assert.AreEqual ("1", xmlReader ["_1"]);\r
1379                         Assert.IsTrue (xmlReader.MoveToNextAttribute ());\r
1380                         Assert.AreEqual ("_2", xmlReader.Name);\r
1381                         Assert.AreEqual ("1", xmlReader ["_1"]);\r
1382                         Assert.IsTrue (xmlReader.MoveToNextAttribute ());\r
1383                         Assert.AreEqual ("_3", xmlReader.Name);\r
1384                         Assert.AreEqual ("1", xmlReader ["_1"]);\r
1385 \r
1386                         Assert.IsTrue (!xmlReader.MoveToNextAttribute ());\r
1387                 }\r
1388 \r
1389                 [Test]\r
1390                 public void ProhibitedMultipleAttributes ()\r
1391                 {\r
1392                         string xml = @"<foo _1='1' _1='1' />";\r
1393                         try {\r
1394                                 RunTest (xml, new TestMethod (ReadAll));\r
1395                         } catch (XmlException) {\r
1396                         }\r
1397                         xml = @"<foo _1='1' _1='2' />";\r
1398                         try {\r
1399                                 RunTest (xml, new TestMethod (ReadAll));\r
1400                         } catch (XmlException) {\r
1401                         }\r
1402                 }\r
1403 \r
1404                 public void ReadAll (XmlReader xmlReader)\r
1405                 {\r
1406                         while (!xmlReader.EOF)\r
1407                                 xmlReader.Read ();\r
1408                 }\r
1409 \r
1410                 [Test]\r
1411                 public void SurrogatePairContent ()\r
1412                 {\r
1413                         string xml = "<root xmlns='&#x10100;'/>";\r
1414                         RunTest (xml, new TestMethod (SurrogatePairContent));\r
1415                 }\r
1416 \r
1417                 public void SurrogatePairContent (XmlReader xmlReader)\r
1418                 {\r
1419                         xmlReader.Read ();\r
1420                         Assert.AreEqual (true, xmlReader.MoveToAttribute ("xmlns"));\r
1421                         Assert.AreEqual ("xmlns", xmlReader.Name);\r
1422                         Assert.AreEqual (2, xmlReader.Value.Length);\r
1423                         Assert.AreEqual (0xD800, (int) xmlReader.Value [0]);\r
1424                         Assert.AreEqual (0xDD00, (int) xmlReader.Value [1]);\r
1425                 }\r
1426 \r
1427                 [Test]\r
1428                 public void ReadOuterXmlOnEndElement ()\r
1429                 {\r
1430                         string xml = "<root><foo></foo></root>";\r
1431                         RunTest (xml, new TestMethod (ReadOuterXmlOnEndElement));\r
1432                 }\r
1433 \r
1434                 public void ReadOuterXmlOnEndElement (XmlReader xmlReader)\r
1435                 {\r
1436                         xmlReader.Read ();\r
1437                         xmlReader.Read ();\r
1438                         xmlReader.Read ();\r
1439                         Assert.AreEqual (String.Empty, xmlReader.ReadOuterXml ());\r
1440                 }\r
1441 \r
1442                 [Test]\r
1443                 public void ReadInnerXmlOnEndElement ()\r
1444                 {\r
1445                         string xml = "<root><foo></foo></root>";\r
1446                         RunTest (xml, new TestMethod (ReadInnerXmlOnEndElement));\r
1447                 }\r
1448 \r
1449                 private void ReadInnerXmlOnEndElement (XmlReader xmlReader)\r
1450                 {\r
1451                         xmlReader.Read ();\r
1452                         xmlReader.Read ();\r
1453                         xmlReader.Read ();\r
1454                         Assert.AreEqual (String.Empty, xmlReader.ReadInnerXml ());\r
1455                 }\r
1456 \r
1457                 [Test]\r
1458                 public void LookupEmptyPrefix ()\r
1459                 {\r
1460                         string xml = "<root><foo></foo></root>";\r
1461                         RunTest (xml, new TestMethod (LookupEmptyPrefix));\r
1462                 }\r
1463 \r
1464                 void LookupEmptyPrefix (XmlReader xmlReader)\r
1465                 {\r
1466                         xmlReader.Read ();\r
1467                         Assert.IsNull (xmlReader.LookupNamespace (String.Empty));\r
1468                 }\r
1469 \r
1470                 [Test]\r
1471                 public void ReadStartElement ()\r
1472                 {\r
1473                         string xml = "<root>test</root>";\r
1474                         RunTest (xml, new TestMethod (ReadStartElement));\r
1475                 }\r
1476 \r
1477                 void ReadStartElement (XmlReader xr)\r
1478                 {\r
1479                         xr.Read ();\r
1480                         xr.ReadStartElement ();\r
1481                         // consume Element node.\r
1482                         Assert.AreEqual (XmlNodeType.Text, xr.NodeType);\r
1483                 }\r
1484 \r
1485                 [Test]\r
1486                 public void LookupNamespaceAtEndElement ()\r
1487                 {\r
1488                         string xml = "<root xmlns:x='urn:foo'><foo/></root>";\r
1489                         RunTest (xml, new TestMethod (LookupNamespaceAtEndElement));\r
1490                 }\r
1491 \r
1492                 void LookupNamespaceAtEndElement (XmlReader reader)\r
1493                 {\r
1494                         reader.Read ();\r
1495                         Assert.AreEqual ("urn:foo", reader.LookupNamespace ("x"), "#1");\r
1496                         reader.Read ();\r
1497                         Assert.AreEqual ("urn:foo", reader.LookupNamespace ("x"), "#2");\r
1498                         reader.Read ();\r
1499                         Assert.AreEqual ("urn:foo", reader.LookupNamespace ("x"), "#3");\r
1500                 }\r
1501 \r
1502                 [Test]\r
1503                 public void ReadClosedReader ()\r
1504                 {\r
1505                         string xml = "<fin>aaa</fin>";\r
1506                         RunTest (xml, new TestMethod (ReadClosedReader));\r
1507                 }\r
1508 \r
1509                 void ReadClosedReader (XmlReader reader)\r
1510                 {\r
1511                         reader.Read ();\r
1512                         reader.Close();\r
1513                         reader.Read (); // silently returns false\r
1514                 }\r
1515 \r
1516 #if NET_2_0\r
1517                 [Test]\r
1518                 public void CreateSimple ()\r
1519                 {\r
1520                         XmlReaderSettings s = new XmlReaderSettings ();\r
1521                         s.ProhibitDtd = false;\r
1522                         XmlReader xr = XmlReader.Create ("Test/XmlFiles/nested-dtd-test.xml", s);\r
1523                         xr.Read ();\r
1524                         Assert.AreEqual (XmlNodeType.DocumentType, xr.NodeType, "#1");\r
1525                         xr.Read ();\r
1526                         Assert.AreEqual (XmlNodeType.Whitespace, xr.NodeType, "#2");\r
1527                         xr.Read ();\r
1528                         Assert.AreEqual (XmlNodeType.Element, xr.NodeType, "#3");\r
1529                 }\r
1530 \r
1531                 [Test]\r
1532                 [ExpectedException (typeof (XmlException))]\r
1533                 public void CreateSimpleProhibitDtd ()\r
1534                 {\r
1535                         XmlReader xr = XmlReader.Create ("Test/XmlFiles/nested-dtd-test.xml");\r
1536                         xr.Read ();\r
1537                 }\r
1538 \r
1539                 [Test]\r
1540                 // a bit revised version of bug #78706\r
1541                 public void CreateFromUrlClose ()\r
1542                 {\r
1543                         string file = Path.Combine (Path.GetTempPath (), "78706.xml");\r
1544                         try {\r
1545                                 if (!File.Exists (file))\r
1546                                         File.Create (file).Close ();\r
1547                                 XmlReaderSettings s = new XmlReaderSettings ();\r
1548                                 s.CloseInput = false; // explicitly\r
1549                                 XmlReader r = XmlReader.Create (file, s);\r
1550                                 r.Close ();\r
1551                                 XmlTextWriter w = new XmlTextWriter (file, null);\r
1552                                 w.Close ();\r
1553                         } finally {\r
1554                                 if (File.Exists (file))\r
1555                                         File.Delete (file);\r
1556                         }\r
1557                 }\r
1558 \r
1559                 [Test]\r
1560                 // a bit revised version of bug #385638\r
1561                 public void CreateFromUrlClose2 ()\r
1562                 {\r
1563                         string file = Path.Combine (Path.GetTempPath (), "385638.xml");\r
1564                         try {\r
1565                                 if (File.Exists (file))\r
1566                                         File.Delete (file);\r
1567                                 using (TextWriter tw = File.CreateText (file))\r
1568                                         tw.Write ("<xml />");\r
1569                                 XmlReaderSettings s = new XmlReaderSettings ();\r
1570                                 s.IgnoreWhitespace = true; // this results in XmlFilterReader, which is the key for this bug.\r
1571                                 XmlReader r = XmlReader.Create (file, s);\r
1572                                 r.Close ();\r
1573                                 XmlTextWriter w = new XmlTextWriter (file, null);\r
1574                                 w.Close ();\r
1575                         } finally {\r
1576                                 if (File.Exists (file))\r
1577                                         File.Delete (file);\r
1578                         }\r
1579                 }\r
1580 \r
1581                 [Test]\r
1582                 [ExpectedException (typeof (ArgumentException))]\r
1583                 public void Create_String_Empty ()\r
1584                 {\r
1585                         XmlReader.Create (String.Empty);\r
1586                 }\r
1587 \r
1588                 [Test]\r
1589                 public void ReadToDescendant ()\r
1590                 {\r
1591                         string xml = @"<root><foo/><bar/><foo> test text <bar><bar></bar></bar></foo></root>";\r
1592                         RunTest (xml, new TestMethod (ReadToDescendant));\r
1593                 }\r
1594 \r
1595                 void ReadToDescendant (XmlReader xmlReader)\r
1596                 {\r
1597                         // move to first <bar/>\r
1598                         Assert.IsTrue (xmlReader.ReadToDescendant ("bar"), "#1");\r
1599                         // no children in <bar/>. It is empty.\r
1600                         Assert.IsTrue (!xmlReader.ReadToDescendant ("bar"), "#2");\r
1601                         Assert.AreEqual ("bar", xmlReader.Name, "#2-2");\r
1602 \r
1603                         // move to the second <foo>\r
1604                         xmlReader.Read ();\r
1605                         // move to the second <bar>\r
1606                         Assert.IsTrue (xmlReader.ReadToDescendant ("bar"), "#3");\r
1607                         // move to <bar> inside <bar>...</bar>\r
1608                         Assert.IsTrue (xmlReader.ReadToDescendant ("bar"), "#4");\r
1609                         // the next is EndElement of </bar>, so no move.\r
1610                         Assert.IsTrue (!xmlReader.ReadToDescendant ("bar"), "#5");\r
1611                         Assert.AreEqual (XmlNodeType.EndElement, xmlReader.NodeType, "#5-2");\r
1612                 }\r
1613 \r
1614                 [Test]\r
1615                 public void ReadToDescepdant2 ()\r
1616                 {\r
1617                         string xml = "<root/>";\r
1618                         RunTest (xml, new TestMethod (ReadToDescendant2));\r
1619                 }\r
1620 \r
1621                 void ReadToDescendant2 (XmlReader xmlReader)\r
1622                 {\r
1623                         // make sure that it works when the reader is at Initial state.\r
1624                         Assert.IsTrue (xmlReader.ReadToDescendant ("root"));\r
1625                 }\r
1626 \r
1627                 [Test]\r
1628                 public void ReadToFollowing ()\r
1629                 {\r
1630                         string xml = @"<root><foo/><bar/><foo><bar><bar></bar></bar></foo></root>";\r
1631                         RunTest (xml, new TestMethod (ReadToFollowing));\r
1632                 }\r
1633 \r
1634                 public void ReadToFollowing (XmlReader xmlReader)\r
1635                 {\r
1636                         Assert.IsTrue (xmlReader.ReadToFollowing ("bar"), "#1");\r
1637                         Assert.IsTrue (xmlReader.ReadToFollowing ("bar"), "#2");\r
1638                         Assert.AreEqual (2, xmlReader.Depth, "#2-2");\r
1639                         Assert.IsTrue (xmlReader.ReadToFollowing ("bar"), "#3");\r
1640                         Assert.AreEqual (3, xmlReader.Depth, "#3-2");\r
1641                         Assert.IsTrue (!xmlReader.ReadToFollowing ("bar"), "#4");\r
1642                 }\r
1643 \r
1644                 [Test]\r
1645                 [Category ("NotDotNet")]\r
1646                 public void ReadToNextSiblingAtInitialState ()\r
1647                 {\r
1648                         string xml = @"<root></root>";\r
1649                         RunTest (xml, new TestMethod (ReadToNextSiblingAtInitialState ));\r
1650                 }\r
1651 \r
1652                 void ReadToNextSiblingAtInitialState (XmlReader xmlReader)\r
1653                 {\r
1654                         Assert.IsTrue (!xmlReader.ReadToNextSibling ("bar"), "#1");\r
1655                         Assert.IsTrue (!xmlReader.ReadToNextSibling ("root"), "#2");\r
1656                 }\r
1657 \r
1658                 [Test]\r
1659                 public void ReadToNextSibling ()\r
1660                 {\r
1661                         string xml = @"<root><foo/><bar attr='value'/><foo><pooh/><bar></bar><foo></foo><bar/></foo></root>";\r
1662                         RunTest (xml, new TestMethod (ReadToNextSibling));\r
1663                 }\r
1664 \r
1665                 void ReadToNextSibling (XmlReader xmlReader)\r
1666                 {\r
1667                         // It is funky, but without it MS.NET results in an infinite loop.\r
1668                         xmlReader.Read (); // root\r
1669 \r
1670                         xmlReader.Read (); // foo\r
1671                         Assert.IsTrue (xmlReader.ReadToNextSibling ("bar"), "#3");\r
1672 \r
1673                         Assert.AreEqual ("value", xmlReader.GetAttribute ("attr"), "#3-2");\r
1674                         xmlReader.Read (); // foo\r
1675                         xmlReader.Read (); // pooh\r
1676                         Assert.IsTrue (xmlReader.ReadToNextSibling ("bar"), "#4");\r
1677                         Assert.IsTrue (!xmlReader.IsEmptyElement, "#4-2");\r
1678                         Assert.IsTrue (xmlReader.ReadToNextSibling ("bar"), "#5");\r
1679                         Assert.IsTrue (xmlReader.IsEmptyElement, "#5-2");\r
1680                         Assert.IsTrue (xmlReader.Read (), "#6"); // /foo\r
1681 \r
1682                         AssertNodeValues ("#7", xmlReader,\r
1683                                 XmlNodeType.EndElement,\r
1684                                 1,              // Depth\r
1685                                 false,          // IsEmptyElement\r
1686                                 "foo",          // Name\r
1687                                 String.Empty,   // Prefix\r
1688                                 "foo",          // LocalName\r
1689                                 String.Empty,   // NamespaceURI\r
1690                                 String.Empty,   // Value\r
1691                                 false,          // HasValue\r
1692                                 0,              // AttributeCount\r
1693                                 false);         // HasAttributes\r
1694                 }\r
1695 \r
1696                 // bug #81451\r
1697                 [Test]\r
1698                 public void ReadToNextSibling2 ()\r
1699                 {\r
1700                         string xml = @"<root><baz><bar><foo attr='value'/></bar><foo attr='value2'><bar><foo /></bar></foo></baz></root>";\r
1701                         RunTest (xml, new TestMethod (ReadToNextSibling2));\r
1702                 }\r
1703 \r
1704                 void ReadToNextSibling2 (XmlReader r)\r
1705                 {\r
1706                         r.MoveToContent (); // ->root\r
1707                         r.Read (); // root->baz\r
1708                         r.Read (); // baz->bar\r
1709                         Assert.IsTrue (r.ReadToNextSibling ("foo"), "#1");\r
1710                         Assert.AreEqual ("value2", r.GetAttribute ("attr"), "#2");\r
1711                         r.Read (); // foo[@value='value2']->bar\r
1712                         Assert.IsTrue (!r.ReadToNextSibling ("foo"), "#3");\r
1713                         Assert.AreEqual (XmlNodeType.EndElement, r.NodeType, "#4");\r
1714                         Assert.AreEqual ("foo", r.LocalName, "#5");\r
1715                 }\r
1716 \r
1717                 // bug #347768\r
1718                 [Test]\r
1719                 public void ReadToNextSibling3 ()\r
1720                 {\r
1721                         string xml = @" <books> <book> <name>Happy C Sharp</name> </book> </books>";\r
1722                         XmlReader reader = XmlReader.Create (new StringReader (xml));\r
1723 \r
1724                         reader.MoveToContent ();\r
1725 \r
1726                         while (reader.Read ())\r
1727                                 reader.ReadToNextSibling ("book"); // should not result in an infinite loop\r
1728                 }\r
1729 \r
1730                 // bug #676020\r
1731                 [Test]\r
1732                 public void ReadToNextSibling4 ()\r
1733                 {\r
1734                         string xml = @"<SerializableStringDictionary>\r
1735 <SerializableStringDictionary>\r
1736 <DictionaryEntry Key=""Key1"" Value=""Value1""/>\r
1737 <DictionaryEntry Key=""Key2"" Value=""Value2""/>\r
1738 <DictionaryEntry Key=""Key3"" Value=""Value3""/>\r
1739 </SerializableStringDictionary>\r
1740 </SerializableStringDictionary>";\r
1741 \r
1742                         var reader = XmlReader.Create (new StringReader (xml));\r
1743 \r
1744                         Assert.IsTrue (reader.ReadToDescendant ("SerializableStringDictionary"), "#1");\r
1745                         Assert.IsTrue (reader.ReadToDescendant ("DictionaryEntry"), "#2");\r
1746 \r
1747                         int count = 0;\r
1748                         do {\r
1749                                 reader.MoveToAttribute ("Key");\r
1750                                 var key = reader.ReadContentAsString ();\r
1751                                 reader.MoveToAttribute ("Value");\r
1752                                 var value = reader.ReadContentAsString ();\r
1753                                 count++;\r
1754                         }\r
1755                         while (reader.ReadToNextSibling ("DictionaryEntry"));\r
1756                         Assert.AreEqual (3, count, "#3");\r
1757                 }\r
1758 \r
1759                 [Test]\r
1760                 public void ReadSubtree ()\r
1761                 {\r
1762                         string xml = @"<root><foo/><bar attr='value'></bar></root>";\r
1763                         RunTest (xml, new TestMethod (ReadSubtree));\r
1764                 }\r
1765 \r
1766                 void ReadSubtree (XmlReader reader)\r
1767                 {\r
1768                         reader.MoveToContent (); // root\r
1769                         reader.Read (); // foo\r
1770                         XmlReader st = reader.ReadSubtree (); // <foo/>\r
1771 \r
1772                         // MS bug: IsEmptyElement should be false here.\r
1773                         /*\r
1774                         AssertNodeValues ("#1", st,\r
1775                                 XmlNodeType.None,\r
1776                                 0,              // Depth\r
1777                                 false,          // IsEmptyElement\r
1778                                 String.Empty,   // Name\r
1779                                 String.Empty,   // Prefix\r
1780                                 String.Empty,   // LocalName\r
1781                                 String.Empty,   // NamespaceURI\r
1782                                 String.Empty,   // Value\r
1783                                 false,          // HasValue\r
1784                                 0,              // AttributeCount\r
1785                                 false);         // HasAttributes\r
1786                         */\r
1787                         Assert.AreEqual (XmlNodeType.None, st.NodeType, "#1");\r
1788 \r
1789                         st.Read ();\r
1790                         AssertNodeValues ("#2", st,\r
1791                                 XmlNodeType.Element,\r
1792                                 0,\r
1793                                 true,           // IsEmptyElement\r
1794                                 "foo",          // Name\r
1795                                 String.Empty,   // Prefix\r
1796                                 "foo",          // LocalName\r
1797                                 String.Empty,   // NamespaceURI\r
1798                                 String.Empty,   // Value\r
1799                                 false,          // HasValue\r
1800                                 0,              // AttributeCount\r
1801                                 false);         // HasAttributes\r
1802 \r
1803                         Assert.IsTrue (!st.Read (), "#3");\r
1804 \r
1805                         // At this state, reader is not positioned on <bar> yet\r
1806                         AssertNodeValues ("#3-2", reader,\r
1807                                 XmlNodeType.Element,\r
1808                                 1,              // Depth. It is 1 for main tree.\r
1809                                 true,           // IsEmptyElement\r
1810                                 "foo",          // Name\r
1811                                 String.Empty,   // Prefix\r
1812                                 "foo",          // LocalName\r
1813                                 String.Empty,   // NamespaceURI\r
1814                                 String.Empty,   // Value\r
1815                                 false,          // HasValue\r
1816                                 0,              // AttributeCount\r
1817                                 false);         // HasAttributes\r
1818 \r
1819                         reader.Read ();\r
1820 \r
1821                         AssertNodeValues ("#4", reader,\r
1822                                 XmlNodeType.Element,\r
1823                                 1,              // Depth. It is 1 for main tree.\r
1824                                 false,          // IsEmptyElement\r
1825                                 "bar",          // Name\r
1826                                 String.Empty,   // Prefix\r
1827                                 "bar",          // LocalName\r
1828                                 String.Empty,   // NamespaceURI\r
1829                                 String.Empty,   // Value\r
1830                                 false,          // HasValue\r
1831                                 1,              // AttributeCount\r
1832                                 true);          // HasAttributes\r
1833 \r
1834                         st = reader.ReadSubtree ();\r
1835                         st.Read (); // Initial -> Interactive\r
1836                         AssertNodeValues ("#5", st,\r
1837                                 XmlNodeType.Element,\r
1838                                 0,              // Depth. It is 0 for subtree.\r
1839                                 false,          // IsEmptyElement\r
1840                                 "bar",          // Name\r
1841                                 String.Empty,   // Prefix\r
1842                                 "bar",          // LocalName\r
1843                                 String.Empty,   // NamespaceURI\r
1844                                 String.Empty,   // Value\r
1845                                 false,          // HasValue\r
1846                                 1,              // AttributeCount\r
1847                                 true);          // HasAttributes\r
1848 \r
1849                         st.Read ();\r
1850                         AssertNodeValues ("#6-1", st,\r
1851                                 XmlNodeType.EndElement,\r
1852                                 0,              // Depth. It is 0 for subtree.\r
1853                                 false,          // IsEmptyElement\r
1854                                 "bar",          // Name\r
1855                                 String.Empty,   // Prefix\r
1856                                 "bar",          // LocalName\r
1857                                 String.Empty,   // NamespaceURI\r
1858                                 String.Empty,   // Value\r
1859                                 false,          // HasValue\r
1860                                 0,              // AttributeCount\r
1861                                 false);         // HasAttributes\r
1862 \r
1863                         AssertNodeValues ("#6-2", st,\r
1864                                 XmlNodeType.EndElement,\r
1865                                 0,              // Depth. It is 0 for subtree.\r
1866                                 false,          // IsEmptyElement\r
1867                                 "bar",          // Name\r
1868                                 String.Empty,   // Prefix\r
1869                                 "bar",          // LocalName\r
1870                                 String.Empty,   // NamespaceURI\r
1871                                 String.Empty,   // Value\r
1872                                 false,          // HasValue\r
1873                                 0,              // AttributeCount\r
1874                                 false);         // HasAttributes\r
1875 \r
1876                         Assert.IsTrue (!st.Read (), "#7");\r
1877                 }\r
1878 \r
1879                 [Test]\r
1880                 public void ReadInteger ()\r
1881                 {\r
1882                         string xml1 = "<root>1</root>";\r
1883                         XmlReader xr;\r
1884                         \r
1885                         xr = XmlReader.Create (new StringReader (xml1));\r
1886                         xr.Read ();\r
1887                         Assert.AreEqual ("1", xr.ReadElementContentAsString (), "#1");\r
1888 \r
1889                         AssertNodeValues ("#1-2", xr,\r
1890                                 XmlNodeType.None,\r
1891                                 0,              // Depth. It is 0 for subtree.\r
1892                                 false,          // IsEmptyElement\r
1893                                 String.Empty,   // Name\r
1894                                 String.Empty,   // Prefix\r
1895                                 String.Empty,   // LocalName\r
1896                                 String.Empty,   // NamespaceURI\r
1897                                 String.Empty,   // Value\r
1898                                 false,          // HasValue\r
1899                                 0,              // AttributeCount\r
1900                                 false);         // HasAttributes\r
1901 \r
1902                         xr = XmlReader.Create (new StringReader (xml1));\r
1903                         xr.Read ();\r
1904                         // this XmlReader has no schema, thus the value is untyped\r
1905                         Assert.AreEqual ("1", xr.ReadElementContentAsObject (), "#2");\r
1906 \r
1907                         xr = XmlReader.Create (new StringReader (xml1));\r
1908                         xr.Read ();\r
1909                         xr.Read ();\r
1910                         Assert.AreEqual ("1", xr.ReadContentAsString (), "#3");\r
1911 \r
1912                         xr = XmlReader.Create (new StringReader (xml1));\r
1913                         xr.Read ();\r
1914                         Assert.AreEqual (1, xr.ReadElementContentAsInt (), "#4");\r
1915 \r
1916                         xr = XmlReader.Create (new StringReader (xml1));\r
1917                         xr.Read ();\r
1918                         Assert.AreEqual (1, xr.ReadElementContentAs (typeof (int), null), "#5");\r
1919                 }\r
1920 \r
1921                 [Test]\r
1922                 [ExpectedException (typeof (XmlException))]\r
1923                 public void ReadContentAsIntFail ()\r
1924                 {\r
1925                         XmlReader xr = XmlReader.Create (\r
1926                                 new StringReader ("<doc>1.0</doc>"));\r
1927                         xr.Read ();\r
1928                         xr.ReadElementContentAsInt ();\r
1929                 }\r
1930 \r
1931                 [Test]\r
1932                 public void ReadDateTime ()\r
1933                 {\r
1934                         DateTime time = new DateTime (2006, 1, 2, 3, 4, 56);\r
1935                         string xml1 = "<root>2006-01-02T03:04:56</root>";\r
1936                         XmlReader xr;\r
1937 \r
1938                         xr = XmlReader.Create (new StringReader (xml1));\r
1939                         xr.Read ();\r
1940                         // this XmlReader has no schema, thus the value is untyped\r
1941                         Assert.AreEqual ("2006-01-02T03:04:56", xr.ReadElementContentAsString (), "#1");\r
1942 \r
1943                         xr = XmlReader.Create (new StringReader (xml1));\r
1944                         xr.Read ();\r
1945                         xr.Read ();\r
1946                         Assert.AreEqual (time, xr.ReadContentAsDateTime (), "#2");\r
1947 \r
1948                         xr = XmlReader.Create (new StringReader (xml1));\r
1949                         xr.Read ();\r
1950                         Assert.AreEqual (time, xr.ReadElementContentAsDateTime (), "#3");\r
1951 \r
1952                         xr = XmlReader.Create (new StringReader (xml1));\r
1953                         xr.Read ();\r
1954                         Assert.AreEqual (time, xr.ReadElementContentAs (typeof (DateTime), null), "#4");\r
1955                 }\r
1956 \r
1957                 [Test]\r
1958                 [ExpectedException (typeof (XmlException))]\r
1959                 public void ReadContentAsDateTimeFail ()\r
1960                 {\r
1961                         XmlReader xr = XmlReader.Create (\r
1962                                 new StringReader ("<doc>P1Y2M3D</doc>"));\r
1963                         xr.Read ();\r
1964                         xr.ReadElementContentAsDateTime ();\r
1965                 }\r
1966 \r
1967                 [Test]\r
1968                 public void ReadContentAs_QNameEmptyNSResolver ()\r
1969                 {\r
1970                         XmlReader xr = XmlReader.Create (\r
1971                                 new StringReader ("<doc xmlns:x='urn:foo'>x:el</doc>"));\r
1972                         xr.Read ();\r
1973                         object o = xr.ReadElementContentAs (\r
1974                                 typeof (XmlQualifiedName), null);\r
1975                         // without IXmlNamespaceResolver, it still resolves\r
1976                         // x:el as valid QName.\r
1977                         Assert.IsNotNull (o, "#1");\r
1978                         XmlQualifiedName q = o as XmlQualifiedName;\r
1979                         Assert.AreEqual (new XmlQualifiedName ("el", "urn:foo"), q, "#2 : " + o.GetType ());\r
1980                 }\r
1981 \r
1982                 [Test]\r
1983                 [ExpectedException (typeof (InvalidOperationException))]\r
1984                 public void ReadContentStringOnElementFail ()\r
1985                 {\r
1986                         XmlReader xr = XmlReader.Create (new StringReader ("<a>test</a>"));\r
1987                         xr.Read ();\r
1988                         xr.ReadContentAsString ();\r
1989                 }\r
1990 \r
1991                 [Test]\r
1992                 public void ReadContentStringOnEndElement ()\r
1993                 {\r
1994                         XmlReader xr = XmlReader.Create (new StringReader ("<a>test</a>"));\r
1995                         xr.Read ();\r
1996                         xr.Read ();\r
1997                         xr.Read ();\r
1998                         Assert.AreEqual (String.Empty, xr.ReadContentAsString ()); // does not fail, unlike at Element!\r
1999                 }\r
2000 \r
2001                 [Test]\r
2002                 public void ReadContentStringOnPI ()\r
2003                 {\r
2004                         XmlReader xr = XmlReader.Create (new StringReader ("<?pi ?><a>test</a>"));\r
2005                         xr.Read ();\r
2006                         Assert.AreEqual (String.Empty, xr.ReadContentAsString ());\r
2007                 }\r
2008 \r
2009                 [Test]\r
2010                 [ExpectedException (typeof (InvalidOperationException))] // unlike ReadContentAsString()\r
2011                 public void ReadElementContentStringOnPI ()\r
2012                 {\r
2013                         XmlReader xr = XmlReader.Create (new StringReader ("<?pi ?><a>test</a>"));\r
2014                         xr.Read ();\r
2015                         Assert.AreEqual (XmlNodeType.ProcessingInstruction, xr.NodeType);\r
2016                         xr.ReadElementContentAsString ();\r
2017                 }\r
2018 \r
2019                 [Test]\r
2020                 [ExpectedException (typeof (XmlException))]\r
2021                 public void ReadElementContentStringMixedContent ()\r
2022                 {\r
2023                         XmlReader xr = XmlReader.Create (\r
2024                                 new StringReader ("<doc>123<child>456</child>789</doc>"));\r
2025                         xr.Read ();\r
2026                         // "child" is regarded as an invalid node.\r
2027                         string s = xr.ReadElementContentAsString ();\r
2028                 }\r
2029 \r
2030                 [Test]\r
2031                 public void ReadContentStringMixedContent ()\r
2032                 {\r
2033                         XmlReader xr = XmlReader.Create (\r
2034                                 new StringReader ("<doc>123<child>456</child>789</doc>"));\r
2035                         xr.Read ();\r
2036                         xr.Read (); // from Text "123"\r
2037                         string s = xr.ReadContentAsString ();\r
2038                         Assert.AreEqual ("123", s, "#1");\r
2039                         Assert.AreEqual (XmlNodeType.Element, xr.NodeType, "#2");\r
2040                 }\r
2041 \r
2042                 [Test]\r
2043                 public void ReadElementContentAsString ()\r
2044                 {\r
2045                         XmlTextReader r = new XmlTextReader (\r
2046                                 "<root/>", XmlNodeType.Document, null);\r
2047                         r.Read ();\r
2048                         Assert.AreEqual (String.Empty, r.ReadElementContentAsString (), "#1");\r
2049                         Assert.AreEqual (XmlNodeType.None, r.NodeType, "#2");\r
2050                 }\r
2051 \r
2052                 [Test]\r
2053                 public void ReadElementContentAs ()\r
2054                 {\r
2055                         // as System.Object\r
2056 \r
2057                         XmlTextReader r = new XmlTextReader (\r
2058                                 "<root/>", XmlNodeType.Document, null);\r
2059                         r.Read ();\r
2060                         Assert.AreEqual (String.Empty, r.ReadElementContentAs (typeof (object), null), "#1");\r
2061                         Assert.AreEqual (XmlNodeType.None, r.NodeType, "#2");\r
2062 \r
2063                         // regardless of its value, the return value is string.\r
2064                         r = new XmlTextReader ("<root>1</root>", XmlNodeType.Document, null);\r
2065                         r.Read ();\r
2066                         Assert.AreEqual ("1", r.ReadElementContentAs (typeof (object), null), "#3");\r
2067                         Assert.AreEqual (XmlNodeType.None, r.NodeType, "#4");\r
2068                 }\r
2069 \r
2070                 [Test]\r
2071                 public void ReadContentStringOnAttribute ()\r
2072                 {\r
2073                         string xml = @"<root id='myId'><child /></root>";\r
2074                         RunTest (xml, new TestMethod (ReadContentStringOnAttribute));\r
2075                 }\r
2076 \r
2077                 void ReadContentStringOnAttribute (XmlReader reader)\r
2078                 {\r
2079                         reader.Read ();\r
2080                         Assert.IsTrue (reader.MoveToAttribute ("id"));\r
2081                         Assert.AreEqual ("myId", reader.ReadContentAsString ());\r
2082                 }\r
2083 \r
2084                 [Test]\r
2085                 public void ReadElementContentAsStringEmpty ()\r
2086                 {\r
2087                         string xml = "<root><sample/></root>";\r
2088                         RunTest (xml, new TestMethod (ReadElementContentAsStringEmpty));\r
2089                 }\r
2090 \r
2091                 void ReadElementContentAsStringEmpty (XmlReader reader)\r
2092                 {\r
2093                         reader.MoveToContent ();\r
2094                         reader.Read ();\r
2095                         Assert.AreEqual (String.Empty, reader.ReadElementContentAsString ("sample", ""));\r
2096                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType);\r
2097                 }\r
2098 \r
2099                 [Test]\r
2100                 public void ReadSubtreeClose ()\r
2101                 {\r
2102                         // bug #334752\r
2103                         string xml = @"<root><item-list><item id='a'/><item id='b'/></item-list></root>";\r
2104                         RunTest (xml, new TestMethod (ReadSubtreeClose));\r
2105                 }\r
2106 \r
2107                 void ReadSubtreeClose (XmlReader reader)\r
2108                 {\r
2109                         reader.ReadToFollowing ("item-list");\r
2110                         XmlReader sub = reader.ReadSubtree ();\r
2111                         sub.ReadToDescendant ("item");\r
2112                         sub.Close ();\r
2113                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#1");\r
2114                         Assert.AreEqual ("item-list", reader.Name, "#2");\r
2115                 }\r
2116 \r
2117                 [Test]\r
2118                 [ExpectedException (typeof (InvalidOperationException))]\r
2119                 public void ReadSubtreeOnNonElement ()\r
2120                 {\r
2121                         string xml = @"<x> <y/></x>";\r
2122                         XmlReader r = XmlReader.Create (new StringReader (xml));\r
2123                         r.Read (); // x\r
2124                         r.Read (); // ws\r
2125                         r.ReadSubtree ();\r
2126                 }\r
2127 \r
2128                 [Test]\r
2129                 [ExpectedException (typeof (InvalidOperationException))]\r
2130                 public void ReadSubtreeOnNonElement2 ()\r
2131                 {\r
2132                         string xml = @"<x> <y/></x>";\r
2133                         XmlReader r = XmlReader.Create (new StringReader (xml));\r
2134                         r.ReadSubtree ();\r
2135                 }\r
2136 \r
2137                 [Test]\r
2138                 public void ReadSubtreeEmptyElement ()\r
2139                 {\r
2140                         string xml = @"<x/>";\r
2141                         XmlReader r = XmlReader.Create (new StringReader (xml));\r
2142                         r.Read ();\r
2143                         XmlReader s = r.ReadSubtree ();\r
2144                         Assert.IsTrue (s.Read (), "#1");\r
2145                         Assert.AreEqual (XmlNodeType.Element, s.NodeType, "#2");\r
2146                         Assert.IsTrue (!s.Read (), "#3");\r
2147                         Assert.AreEqual (XmlNodeType.None, s.NodeType, "#4");\r
2148                 }\r
2149 \r
2150                 [Test]\r
2151                 public void ReadSubtreeEmptyElementWithAttribute ()\r
2152                 {\r
2153                         string xml = @"<root><x a='b'/></root>";\r
2154                         XmlReader r = XmlReader.Create (new StringReader (xml));\r
2155                         r.Read ();\r
2156                         r.Read ();\r
2157                         XmlReader r2 = r.ReadSubtree ();\r
2158                         Console.WriteLine ("X");\r
2159                         r2.Read ();\r
2160                         XmlReader r3 = r2.ReadSubtree ();\r
2161                         r2.MoveToFirstAttribute ();\r
2162                         Assert.IsTrue (!r.IsEmptyElement, "#1");\r
2163                         Assert.IsTrue (!r2.IsEmptyElement, "#2");\r
2164                         r3.Close ();\r
2165                         Assert.IsTrue (r.IsEmptyElement, "#3");\r
2166                         Assert.IsTrue (r2.IsEmptyElement, "#4");\r
2167                         r2.Close ();\r
2168                         Assert.IsTrue (r.IsEmptyElement, "#5");\r
2169                         Assert.IsTrue (r2.IsEmptyElement, "#6");\r
2170                 }\r
2171 \r
2172                 [Test]\r
2173                 public void ReadContentAsBase64 ()\r
2174                 {\r
2175                         byte[] randomData = new byte[24];\r
2176                         for (int i = 0; i < randomData.Length; i++)\r
2177                                 randomData [i] = (byte) i;\r
2178 \r
2179                         string xmlString = "<?xml version=\"1.0\"?><data>" +\r
2180                         Convert.ToBase64String (randomData) + "</data>";\r
2181                         TextReader textReader = new StringReader (xmlString);\r
2182                         XmlReader xmlReader = XmlReader.Create (textReader);\r
2183                         xmlReader.ReadToFollowing ("data");\r
2184 \r
2185                         int readBytes = 0;\r
2186                         byte[] buffer = new byte [24];\r
2187 \r
2188                         xmlReader.ReadStartElement ();\r
2189                         readBytes = xmlReader.ReadContentAsBase64 (buffer, 0, buffer.Length);\r
2190                         Assert.AreEqual (24, readBytes, "#1");\r
2191                         Assert.AreEqual (0, xmlReader.ReadContentAsBase64 (buffer, 0, buffer.Length), "#2");\r
2192                         StringWriter sw = new StringWriter ();\r
2193                         foreach (byte b in buffer) sw.Write ("{0:X02}", b);\r
2194                         Assert.AreEqual ("000102030405060708090A0B0C0D0E0F1011121314151617", sw.ToString (), "#3");\r
2195                 }\r
2196 \r
2197                 [Test]\r
2198                 public void ReadContentAsBase64_2 () // bug #480066\r
2199                 {\r
2200                         StringReader readerString = new StringReader ("<root><b64>TWFu</b64><b64>TWFu</b64>\r\n\t<b64>TWFu</b64><b64>TWFu</b64></root>");\r
2201                         XmlReaderSettings settingsXml = new XmlReaderSettings ();\r
2202                         settingsXml.XmlResolver = null;\r
2203                         using (var readerXml = XmlReader.Create (readerString, settingsXml)) {\r
2204                                 readerXml.MoveToContent ();\r
2205                                 readerXml.Read ();\r
2206                                 readerXml.ReadStartElement ("b64");\r
2207                                 const int bufferLength = 1024;\r
2208                                 byte [] buffer = new byte [bufferLength];\r
2209                                 readerXml.ReadContentAsBase64 (buffer, 0, bufferLength);\r
2210                                 Assert.AreEqual (XmlNodeType.EndElement, readerXml.NodeType, "#1");\r
2211                                 readerXml.Read ();\r
2212                                 Assert.AreEqual (XmlNodeType.Element, readerXml.NodeType, "#2");\r
2213                         }\r
2214                 }\r
2215                 \r
2216                 [Test]\r
2217                 public void ReadContentAsBase64_3 () // bug #543332                     \r
2218                 {\r
2219                         byte [] fakeState = new byte[25];\r
2220                         byte [] fixedSizeBuffer = new byte [25];\r
2221                         byte [] readDataBuffer = new byte [25];\r
2222                         var ms = new MemoryStream ();\r
2223                         var xw = XmlWriter.Create (ms);\r
2224                         xw.WriteStartElement ("root");\r
2225                         xw.WriteBase64 (fakeState, 0, fakeState.Length);\r
2226                         xw.WriteEndElement ();\r
2227                         xw.Close ();\r
2228                         var reader = XmlReader.Create (new MemoryStream (ms.ToArray ()));\r
2229                         reader.MoveToContent ();\r
2230                         // we cannot completely trust the length read to indicate the end.\r
2231                         int bytesRead;\r
2232                         bytesRead = reader.ReadElementContentAsBase64 (fixedSizeBuffer, 0, fixedSizeBuffer.Length);\r
2233                         Assert.AreEqual (25, bytesRead, "#1");\r
2234                         Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#2");\r
2235                         bytesRead = reader.ReadElementContentAsBase64 (fixedSizeBuffer, 0, fixedSizeBuffer.Length);\r
2236                         Assert.AreEqual (0, bytesRead, "#3");\r
2237                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#4");\r
2238                 }\r
2239 \r
2240                 [Test]\r
2241                 public void ReadElementContentAsQNameDefaultNS ()\r
2242                 {\r
2243                         var sw = new StringWriter ();\r
2244                         var xw = XmlWriter.Create (sw);\r
2245                         xw.WriteStartElement ("", "foo", "urn:foo");\r
2246                         xw.WriteValue (new XmlQualifiedName ("x", "urn:foo"));\r
2247                         xw.WriteEndElement ();\r
2248                         xw.Close ();\r
2249                         var xr = XmlReader.Create (new StringReader (sw.ToString ()));\r
2250                         xr.MoveToContent ();\r
2251                         var q = (XmlQualifiedName) xr.ReadElementContentAs (typeof (XmlQualifiedName), xr as IXmlNamespaceResolver);\r
2252                         Assert.AreEqual ("urn:foo", q.Namespace, "#1");\r
2253                 }\r
2254 \r
2255                 [Test]\r
2256                 public void ReadElementContentAsArray ()\r
2257                 {\r
2258                         var sw = new StringWriter ();\r
2259                         var xw = XmlWriter.Create (sw);\r
2260                         xw.WriteStartElement ("root");\r
2261                         xw.WriteAttributeString ("xmlns", "b", "http://www.w3.org/2000/xmlns/", "urn:bar");\r
2262                         var arr = new XmlQualifiedName [] { new XmlQualifiedName ("foo"), new XmlQualifiedName ("bar", "urn:bar") };\r
2263                         xw.WriteValue (arr);\r
2264                         xw.Close ();\r
2265                         var xr = XmlReader.Create (new StringReader (sw.ToString ()));\r
2266                         xr.MoveToContent ();\r
2267                         var ret = xr.ReadElementContentAs (typeof (XmlQualifiedName []), null) as XmlQualifiedName [];\r
2268                         Assert.IsNotNull (ret, "#1");\r
2269                         Assert.AreEqual (arr [0], ret [0], "#2");\r
2270                         Assert.AreEqual (arr [1], ret [1], "#3");\r
2271                 }\r
2272 \r
2273                 [Test]\r
2274                 public void ReadContentAs ()\r
2275                 {\r
2276                         var xr = XmlReader.Create (new StringReader ("<doc a=' 1 '/>"));\r
2277                         xr.Read ();\r
2278                         xr.MoveToAttribute ("a");\r
2279 \r
2280                         Assert.AreEqual ((Byte) 1, xr.ReadContentAs (typeof (Byte), null), "#1");\r
2281                         Assert.AreEqual ((SByte) 1, xr.ReadContentAs (typeof (SByte), null), "#2");\r
2282                         Assert.AreEqual ((Int16) 1, xr.ReadContentAs (typeof (Int16), null), "#3");\r
2283                         Assert.AreEqual ((UInt16) 1, xr.ReadContentAs (typeof (UInt16), null), "#4");\r
2284                         Assert.AreEqual ((Int32) 1, xr.ReadContentAs (typeof (Int32), null), "#5");\r
2285                         Assert.AreEqual ((UInt32) 1, xr.ReadContentAs (typeof (UInt32), null), "#6");\r
2286                         Assert.AreEqual ((Int64) 1, xr.ReadContentAs (typeof (Int64), null), "#7");\r
2287                         Assert.AreEqual ((UInt64) 1, xr.ReadContentAs (typeof (UInt64), null), "#8");\r
2288                 }\r
2289 \r
2290 #if NET_4_5\r
2291                 [Test]\r
2292                 [ExpectedException(typeof(InvalidOperationException))]\r
2293                 public void MustSetAsyncFlag ()\r
2294                 {\r
2295                         var r = XmlReader.Create (new StringReader ("<root/>"));\r
2296                         r.ReadAsync ();\r
2297                 }\r
2298 \r
2299                 Exception RunAsync (Action action)\r
2300                 {\r
2301                         var task = Task<Exception>.Run (async () => {\r
2302                                 try {\r
2303                                         action ();\r
2304                                         return null;\r
2305                                 } catch (Exception ex) {\r
2306                                         return ex;\r
2307                                 }\r
2308                         });\r
2309                         task.Wait ();\r
2310                         Assert.That (task.IsCompleted);\r
2311                         return task.Result;\r
2312                 }\r
2313 \r
2314                 [Test]\r
2315                 public void SimpleAsync ()\r
2316                 {\r
2317                         var xml = "<root test=\"monkey\"/>";\r
2318                         var task = Task<Exception>.Run (async () => {\r
2319                                 try {\r
2320                                         var s = new XmlReaderSettings ();\r
2321                                         s.Async = true;\r
2322                                         var r = XmlReader.Create (new StringReader (xml), s);\r
2323 \r
2324                                         Assert.That (await r.ReadAsync ());\r
2325                                         Assert.That (r.MoveToFirstAttribute ());\r
2326 \r
2327                                         Assert.AreEqual (await r.GetValueAsync (), "monkey");\r
2328                                         r.Close ();\r
2329                                         return null;\r
2330                                 } catch (Exception ex) {\r
2331                                         return ex;\r
2332                                 }\r
2333                         });\r
2334                         task.Wait ();\r
2335                         Assert.That (task.IsCompleted);\r
2336                         if (task.Result != null)\r
2337                                 throw task.Result;\r
2338                 }\r
2339 #endif\r
2340 #endif\r
2341         }\r
2342 }\r