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