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                 [Ignore ("Bug in Microsoft referencesource")]\r
1350                 public void IndexerAndAttributes ()\r
1351                 {\r
1352                         string xml = @"<?xml version='1.0' standalone='no'?><foo _1='1' _2='2' _3='3' />";\r
1353                         RunTest (xml, new TestMethod (IndexerAndAttributes));\r
1354                 }\r
1355 \r
1356                 public void IndexerAndAttributes (XmlReader xmlReader)\r
1357                 {\r
1358                         Assert.IsTrue (xmlReader.Read ());\r
1359                         Assert.AreEqual ("1.0", xmlReader ["version"]);\r
1360                         Assert.AreEqual ("1.0", xmlReader.GetAttribute ("version"));\r
1361                         // .NET 1.1 BUG. XmlTextReader returns null, while XmlNodeReader returns "".\r
1362                         Assert.AreEqual (null, xmlReader ["encoding"]);\r
1363                         Assert.AreEqual (null, xmlReader.GetAttribute ("encoding"));\r
1364                         Assert.AreEqual ("no", xmlReader ["standalone"]);\r
1365                         Assert.AreEqual ("no", xmlReader.GetAttribute ("standalone"));\r
1366                         Assert.AreEqual ("1.0", xmlReader [0]);\r
1367                         Assert.AreEqual ("1.0", xmlReader.GetAttribute (0));\r
1368                         Assert.AreEqual ("no", xmlReader [1]);\r
1369                         Assert.AreEqual ("no", xmlReader.GetAttribute (1));\r
1370 \r
1371                         Assert.IsTrue (xmlReader.Read ());\r
1372                         Assert.AreEqual (XmlNodeType.Element, xmlReader.NodeType);\r
1373                         Assert.AreEqual ("1", xmlReader ["_1"]);\r
1374 \r
1375                         Assert.IsTrue (xmlReader.MoveToFirstAttribute ());\r
1376                         Assert.AreEqual ("_1", xmlReader.Name);\r
1377                         Assert.AreEqual ("1", xmlReader ["_1"]);\r
1378                         Assert.IsTrue (xmlReader.MoveToNextAttribute ());\r
1379                         Assert.AreEqual ("_2", xmlReader.Name);\r
1380                         Assert.AreEqual ("1", xmlReader ["_1"]);\r
1381                         Assert.IsTrue (xmlReader.MoveToNextAttribute ());\r
1382                         Assert.AreEqual ("_3", xmlReader.Name);\r
1383                         Assert.AreEqual ("1", xmlReader ["_1"]);\r
1384 \r
1385                         Assert.IsTrue (!xmlReader.MoveToNextAttribute ());\r
1386                 }\r
1387 \r
1388                 [Test]\r
1389                 public void ProhibitedMultipleAttributes ()\r
1390                 {\r
1391                         string xml = @"<foo _1='1' _1='1' />";\r
1392                         try {\r
1393                                 RunTest (xml, new TestMethod (ReadAll));\r
1394                         } catch (XmlException) {\r
1395                         }\r
1396                         xml = @"<foo _1='1' _1='2' />";\r
1397                         try {\r
1398                                 RunTest (xml, new TestMethod (ReadAll));\r
1399                         } catch (XmlException) {\r
1400                         }\r
1401                 }\r
1402 \r
1403                 public void ReadAll (XmlReader xmlReader)\r
1404                 {\r
1405                         while (!xmlReader.EOF)\r
1406                                 xmlReader.Read ();\r
1407                 }\r
1408 \r
1409                 [Test]\r
1410                 public void SurrogatePairContent ()\r
1411                 {\r
1412                         string xml = "<root xmlns='&#x10100;'/>";\r
1413                         RunTest (xml, new TestMethod (SurrogatePairContent));\r
1414                 }\r
1415 \r
1416                 public void SurrogatePairContent (XmlReader xmlReader)\r
1417                 {\r
1418                         xmlReader.Read ();\r
1419                         Assert.AreEqual (true, xmlReader.MoveToAttribute ("xmlns"));\r
1420                         Assert.AreEqual ("xmlns", xmlReader.Name);\r
1421                         Assert.AreEqual (2, xmlReader.Value.Length);\r
1422                         Assert.AreEqual (0xD800, (int) xmlReader.Value [0]);\r
1423                         Assert.AreEqual (0xDD00, (int) xmlReader.Value [1]);\r
1424                 }\r
1425 \r
1426                 [Test]\r
1427                 public void ReadOuterXmlOnEndElement ()\r
1428                 {\r
1429                         string xml = "<root><foo></foo></root>";\r
1430                         RunTest (xml, new TestMethod (ReadOuterXmlOnEndElement));\r
1431                 }\r
1432 \r
1433                 public void ReadOuterXmlOnEndElement (XmlReader xmlReader)\r
1434                 {\r
1435                         xmlReader.Read ();\r
1436                         xmlReader.Read ();\r
1437                         xmlReader.Read ();\r
1438                         Assert.AreEqual (String.Empty, xmlReader.ReadOuterXml ());\r
1439                 }\r
1440 \r
1441                 [Test]\r
1442                 public void ReadInnerXmlOnEndElement ()\r
1443                 {\r
1444                         string xml = "<root><foo></foo></root>";\r
1445                         RunTest (xml, new TestMethod (ReadInnerXmlOnEndElement));\r
1446                 }\r
1447 \r
1448                 private void ReadInnerXmlOnEndElement (XmlReader xmlReader)\r
1449                 {\r
1450                         xmlReader.Read ();\r
1451                         xmlReader.Read ();\r
1452                         xmlReader.Read ();\r
1453                         Assert.AreEqual (String.Empty, xmlReader.ReadInnerXml ());\r
1454                 }\r
1455 \r
1456                 [Test]\r
1457                 public void LookupEmptyPrefix ()\r
1458                 {\r
1459                         string xml = "<root><foo></foo></root>";\r
1460                         RunTest (xml, new TestMethod (LookupEmptyPrefix));\r
1461                 }\r
1462 \r
1463                 void LookupEmptyPrefix (XmlReader xmlReader)\r
1464                 {\r
1465                         xmlReader.Read ();\r
1466                         Assert.IsNull (xmlReader.LookupNamespace (String.Empty));\r
1467                 }\r
1468 \r
1469                 [Test]\r
1470                 public void ReadStartElement ()\r
1471                 {\r
1472                         string xml = "<root>test</root>";\r
1473                         RunTest (xml, new TestMethod (ReadStartElement));\r
1474                 }\r
1475 \r
1476                 void ReadStartElement (XmlReader xr)\r
1477                 {\r
1478                         xr.Read ();\r
1479                         xr.ReadStartElement ();\r
1480                         // consume Element node.\r
1481                         Assert.AreEqual (XmlNodeType.Text, xr.NodeType);\r
1482                 }\r
1483 \r
1484                 [Test]\r
1485                 public void LookupNamespaceAtEndElement ()\r
1486                 {\r
1487                         string xml = "<root xmlns:x='urn:foo'><foo/></root>";\r
1488                         RunTest (xml, new TestMethod (LookupNamespaceAtEndElement));\r
1489                 }\r
1490 \r
1491                 void LookupNamespaceAtEndElement (XmlReader reader)\r
1492                 {\r
1493                         reader.Read ();\r
1494                         Assert.AreEqual ("urn:foo", reader.LookupNamespace ("x"), "#1");\r
1495                         reader.Read ();\r
1496                         Assert.AreEqual ("urn:foo", reader.LookupNamespace ("x"), "#2");\r
1497                         reader.Read ();\r
1498                         Assert.AreEqual ("urn:foo", reader.LookupNamespace ("x"), "#3");\r
1499                 }\r
1500 \r
1501                 [Test]\r
1502                 public void ReadClosedReader ()\r
1503                 {\r
1504                         string xml = "<fin>aaa</fin>";\r
1505                         RunTest (xml, new TestMethod (ReadClosedReader));\r
1506                 }\r
1507 \r
1508                 void ReadClosedReader (XmlReader reader)\r
1509                 {\r
1510                         reader.Read ();\r
1511                         reader.Close();\r
1512                         reader.Read (); // silently returns false\r
1513                 }\r
1514 \r
1515                 [Test]\r
1516                 public void CreateSimple ()\r
1517                 {\r
1518                         XmlReaderSettings s = new XmlReaderSettings ();\r
1519                         s.ProhibitDtd = false;\r
1520                         XmlReader xr = XmlReader.Create ("Test/XmlFiles/nested-dtd-test.xml", s);\r
1521                         xr.Read ();\r
1522                         Assert.AreEqual (XmlNodeType.DocumentType, xr.NodeType, "#1");\r
1523                         xr.Read ();\r
1524                         Assert.AreEqual (XmlNodeType.Whitespace, xr.NodeType, "#2");\r
1525                         xr.Read ();\r
1526                         Assert.AreEqual (XmlNodeType.Element, xr.NodeType, "#3");\r
1527                 }\r
1528 \r
1529                 [Test]\r
1530                 [ExpectedException (typeof (XmlException))]\r
1531                 public void CreateSimpleProhibitDtd ()\r
1532                 {\r
1533                         XmlReader xr = XmlReader.Create ("Test/XmlFiles/nested-dtd-test.xml");\r
1534                         xr.Read ();\r
1535                 }\r
1536 \r
1537                 [Test]\r
1538                 // a bit revised version of bug #78706\r
1539                 public void CreateFromUrlClose ()\r
1540                 {\r
1541                         string file = Path.Combine (Path.GetTempPath (), "78706.xml");\r
1542                         try {\r
1543                                 if (!File.Exists (file))\r
1544                                         File.Create (file).Close ();\r
1545                                 XmlReaderSettings s = new XmlReaderSettings ();\r
1546                                 s.CloseInput = false; // explicitly\r
1547                                 XmlReader r = XmlReader.Create (file, s);\r
1548                                 r.Close ();\r
1549                                 XmlTextWriter w = new XmlTextWriter (file, null);\r
1550                                 w.Close ();\r
1551                         } finally {\r
1552                                 if (File.Exists (file))\r
1553                                         File.Delete (file);\r
1554                         }\r
1555                 }\r
1556 \r
1557                 [Test]\r
1558                 // a bit revised version of bug #385638\r
1559                 public void CreateFromUrlClose2 ()\r
1560                 {\r
1561                         string file = Path.Combine (Path.GetTempPath (), "385638.xml");\r
1562                         try {\r
1563                                 if (File.Exists (file))\r
1564                                         File.Delete (file);\r
1565                                 using (TextWriter tw = File.CreateText (file))\r
1566                                         tw.Write ("<xml />");\r
1567                                 XmlReaderSettings s = new XmlReaderSettings ();\r
1568                                 s.IgnoreWhitespace = true; // this results in XmlFilterReader, which is the key for this bug.\r
1569                                 XmlReader r = XmlReader.Create (file, s);\r
1570                                 r.Close ();\r
1571                                 XmlTextWriter w = new XmlTextWriter (file, null);\r
1572                                 w.Close ();\r
1573                         } finally {\r
1574                                 if (File.Exists (file))\r
1575                                         File.Delete (file);\r
1576                         }\r
1577                 }\r
1578 \r
1579                 [Test]\r
1580                 [ExpectedException (typeof (ArgumentException))]\r
1581                 public void Create_String_Empty ()\r
1582                 {\r
1583                         XmlReader.Create (String.Empty);\r
1584                 }\r
1585 \r
1586                 [Test]\r
1587                 public void ReadToDescendant ()\r
1588                 {\r
1589                         string xml = @"<root><foo/><bar/><foo> test text <bar><bar></bar></bar></foo></root>";\r
1590                         RunTest (xml, new TestMethod (ReadToDescendant));\r
1591                 }\r
1592 \r
1593                 void ReadToDescendant (XmlReader xmlReader)\r
1594                 {\r
1595                         // move to first <bar/>\r
1596                         Assert.IsTrue (xmlReader.ReadToDescendant ("bar"), "#1");\r
1597                         // no children in <bar/>. It is empty.\r
1598                         Assert.IsTrue (!xmlReader.ReadToDescendant ("bar"), "#2");\r
1599                         Assert.AreEqual ("bar", xmlReader.Name, "#2-2");\r
1600 \r
1601                         // move to the second <foo>\r
1602                         xmlReader.Read ();\r
1603                         // move to the second <bar>\r
1604                         Assert.IsTrue (xmlReader.ReadToDescendant ("bar"), "#3");\r
1605                         // move to <bar> inside <bar>...</bar>\r
1606                         Assert.IsTrue (xmlReader.ReadToDescendant ("bar"), "#4");\r
1607                         // the next is EndElement of </bar>, so no move.\r
1608                         Assert.IsTrue (!xmlReader.ReadToDescendant ("bar"), "#5");\r
1609                         Assert.AreEqual (XmlNodeType.EndElement, xmlReader.NodeType, "#5-2");\r
1610                 }\r
1611 \r
1612                 [Test]\r
1613                 public void ReadToDescepdant2 ()\r
1614                 {\r
1615                         string xml = "<root/>";\r
1616                         RunTest (xml, new TestMethod (ReadToDescendant2));\r
1617                 }\r
1618 \r
1619                 void ReadToDescendant2 (XmlReader xmlReader)\r
1620                 {\r
1621                         // make sure that it works when the reader is at Initial state.\r
1622                         Assert.IsTrue (xmlReader.ReadToDescendant ("root"));\r
1623                 }\r
1624 \r
1625                 [Test]\r
1626                 public void ReadToFollowing ()\r
1627                 {\r
1628                         string xml = @"<root><foo/><bar/><foo><bar><bar></bar></bar></foo></root>";\r
1629                         RunTest (xml, new TestMethod (ReadToFollowing));\r
1630                 }\r
1631 \r
1632                 public void ReadToFollowing (XmlReader xmlReader)\r
1633                 {\r
1634                         Assert.IsTrue (xmlReader.ReadToFollowing ("bar"), "#1");\r
1635                         Assert.IsTrue (xmlReader.ReadToFollowing ("bar"), "#2");\r
1636                         Assert.AreEqual (2, xmlReader.Depth, "#2-2");\r
1637                         Assert.IsTrue (xmlReader.ReadToFollowing ("bar"), "#3");\r
1638                         Assert.AreEqual (3, xmlReader.Depth, "#3-2");\r
1639                         Assert.IsTrue (!xmlReader.ReadToFollowing ("bar"), "#4");\r
1640                 }\r
1641 \r
1642                 [Test]\r
1643                 [Category ("NotDotNet")]\r
1644                 public void ReadToNextSiblingAtInitialState ()\r
1645                 {\r
1646                         string xml = @"<root></root>";\r
1647                         RunTest (xml, new TestMethod (ReadToNextSiblingAtInitialState ));\r
1648                 }\r
1649 \r
1650                 void ReadToNextSiblingAtInitialState (XmlReader xmlReader)\r
1651                 {\r
1652                         Assert.IsTrue (!xmlReader.ReadToNextSibling ("bar"), "#1");\r
1653                         Assert.IsTrue (!xmlReader.ReadToNextSibling ("root"), "#2");\r
1654                 }\r
1655 \r
1656                 [Test]\r
1657                 public void ReadToNextSibling ()\r
1658                 {\r
1659                         string xml = @"<root><foo/><bar attr='value'/><foo><pooh/><bar></bar><foo></foo><bar/></foo></root>";\r
1660                         RunTest (xml, new TestMethod (ReadToNextSibling));\r
1661                 }\r
1662 \r
1663                 void ReadToNextSibling (XmlReader xmlReader)\r
1664                 {\r
1665                         // It is funky, but without it MS.NET results in an infinite loop.\r
1666                         xmlReader.Read (); // root\r
1667 \r
1668                         xmlReader.Read (); // foo\r
1669                         Assert.IsTrue (xmlReader.ReadToNextSibling ("bar"), "#3");\r
1670 \r
1671                         Assert.AreEqual ("value", xmlReader.GetAttribute ("attr"), "#3-2");\r
1672                         xmlReader.Read (); // foo\r
1673                         xmlReader.Read (); // pooh\r
1674                         Assert.IsTrue (xmlReader.ReadToNextSibling ("bar"), "#4");\r
1675                         Assert.IsTrue (!xmlReader.IsEmptyElement, "#4-2");\r
1676                         Assert.IsTrue (xmlReader.ReadToNextSibling ("bar"), "#5");\r
1677                         Assert.IsTrue (xmlReader.IsEmptyElement, "#5-2");\r
1678                         Assert.IsTrue (xmlReader.Read (), "#6"); // /foo\r
1679 \r
1680                         AssertNodeValues ("#7", xmlReader,\r
1681                                 XmlNodeType.EndElement,\r
1682                                 1,              // Depth\r
1683                                 false,          // IsEmptyElement\r
1684                                 "foo",          // Name\r
1685                                 String.Empty,   // Prefix\r
1686                                 "foo",          // LocalName\r
1687                                 String.Empty,   // NamespaceURI\r
1688                                 String.Empty,   // Value\r
1689                                 false,          // HasValue\r
1690                                 0,              // AttributeCount\r
1691                                 false);         // HasAttributes\r
1692                 }\r
1693 \r
1694                 // bug #81451\r
1695                 [Test]\r
1696                 public void ReadToNextSibling2 ()\r
1697                 {\r
1698                         string xml = @"<root><baz><bar><foo attr='value'/></bar><foo attr='value2'><bar><foo /></bar></foo></baz></root>";\r
1699                         RunTest (xml, new TestMethod (ReadToNextSibling2));\r
1700                 }\r
1701 \r
1702                 void ReadToNextSibling2 (XmlReader r)\r
1703                 {\r
1704                         r.MoveToContent (); // ->root\r
1705                         r.Read (); // root->baz\r
1706                         r.Read (); // baz->bar\r
1707                         Assert.IsTrue (r.ReadToNextSibling ("foo"), "#1");\r
1708                         Assert.AreEqual ("value2", r.GetAttribute ("attr"), "#2");\r
1709                         r.Read (); // foo[@value='value2']->bar\r
1710                         Assert.IsTrue (!r.ReadToNextSibling ("foo"), "#3");\r
1711                         Assert.AreEqual (XmlNodeType.EndElement, r.NodeType, "#4");\r
1712                         Assert.AreEqual ("foo", r.LocalName, "#5");\r
1713                 }\r
1714 \r
1715                 // bug #347768\r
1716                 [Test]\r
1717                 public void ReadToNextSibling3 ()\r
1718                 {\r
1719                         string xml = @" <books> <book> <name>Happy C Sharp</name> </book> </books>";\r
1720                         XmlReader reader = XmlReader.Create (new StringReader (xml));\r
1721 \r
1722                         reader.MoveToContent ();\r
1723 \r
1724                         while (reader.Read ())\r
1725                                 reader.ReadToNextSibling ("book"); // should not result in an infinite loop\r
1726                 }\r
1727 \r
1728                 // bug #676020\r
1729                 [Test]\r
1730                 public void ReadToNextSibling4 ()\r
1731                 {\r
1732                         string xml = @"<SerializableStringDictionary>\r
1733 <SerializableStringDictionary>\r
1734 <DictionaryEntry Key=""Key1"" Value=""Value1""/>\r
1735 <DictionaryEntry Key=""Key2"" Value=""Value2""/>\r
1736 <DictionaryEntry Key=""Key3"" Value=""Value3""/>\r
1737 </SerializableStringDictionary>\r
1738 </SerializableStringDictionary>";\r
1739 \r
1740                         var reader = XmlReader.Create (new StringReader (xml));\r
1741 \r
1742                         Assert.IsTrue (reader.ReadToDescendant ("SerializableStringDictionary"), "#1");\r
1743                         Assert.IsTrue (reader.ReadToDescendant ("DictionaryEntry"), "#2");\r
1744 \r
1745                         int count = 0;\r
1746                         do {\r
1747                                 reader.MoveToAttribute ("Key");\r
1748                                 var key = reader.ReadContentAsString ();\r
1749                                 reader.MoveToAttribute ("Value");\r
1750                                 var value = reader.ReadContentAsString ();\r
1751                                 count++;\r
1752                         }\r
1753                         while (reader.ReadToNextSibling ("DictionaryEntry"));\r
1754                         Assert.AreEqual (3, count, "#3");\r
1755                 }\r
1756 \r
1757                 [Test, Category("NotWorking")]\r
1758                 public void ReadToNextSiblingInInitialReadState ()\r
1759                 {\r
1760                         var xml = "<Text name=\"hello\"><Something></Something></Text>";\r
1761                         var ms = new MemoryStream(Encoding.Default.GetBytes(xml));\r
1762                         var xtr = XmlReader.Create(ms);\r
1763 \r
1764                         Assert.AreEqual(xtr.ReadState, ReadState.Initial);\r
1765                         xtr.ReadToNextSibling("Text");\r
1766 \r
1767                         Assert.AreEqual("hello", xtr.GetAttribute("name"));\r
1768                 }\r
1769 \r
1770                 [Test]\r
1771                 public void ReadSubtree ()\r
1772                 {\r
1773                         string xml = @"<root><foo/><bar attr='value'></bar></root>";\r
1774                         RunTest (xml, new TestMethod (ReadSubtree));\r
1775                 }\r
1776 \r
1777                 void ReadSubtree (XmlReader reader)\r
1778                 {\r
1779                         reader.MoveToContent (); // root\r
1780                         reader.Read (); // foo\r
1781                         XmlReader st = reader.ReadSubtree (); // <foo/>\r
1782 \r
1783                         // MS bug: IsEmptyElement should be false here.\r
1784                         /*\r
1785                         AssertNodeValues ("#1", st,\r
1786                                 XmlNodeType.None,\r
1787                                 0,              // Depth\r
1788                                 false,          // IsEmptyElement\r
1789                                 String.Empty,   // Name\r
1790                                 String.Empty,   // Prefix\r
1791                                 String.Empty,   // LocalName\r
1792                                 String.Empty,   // NamespaceURI\r
1793                                 String.Empty,   // Value\r
1794                                 false,          // HasValue\r
1795                                 0,              // AttributeCount\r
1796                                 false);         // HasAttributes\r
1797                         */\r
1798                         Assert.AreEqual (XmlNodeType.None, st.NodeType, "#1");\r
1799 \r
1800                         st.Read ();\r
1801                         AssertNodeValues ("#2", st,\r
1802                                 XmlNodeType.Element,\r
1803                                 0,\r
1804                                 true,           // IsEmptyElement\r
1805                                 "foo",          // Name\r
1806                                 String.Empty,   // Prefix\r
1807                                 "foo",          // LocalName\r
1808                                 String.Empty,   // NamespaceURI\r
1809                                 String.Empty,   // Value\r
1810                                 false,          // HasValue\r
1811                                 0,              // AttributeCount\r
1812                                 false);         // HasAttributes\r
1813 \r
1814                         Assert.IsTrue (!st.Read (), "#3");\r
1815 \r
1816                         // At this state, reader is not positioned on <bar> yet\r
1817                         AssertNodeValues ("#3-2", reader,\r
1818                                 XmlNodeType.Element,\r
1819                                 1,              // Depth. It is 1 for main tree.\r
1820                                 true,           // IsEmptyElement\r
1821                                 "foo",          // Name\r
1822                                 String.Empty,   // Prefix\r
1823                                 "foo",          // LocalName\r
1824                                 String.Empty,   // NamespaceURI\r
1825                                 String.Empty,   // Value\r
1826                                 false,          // HasValue\r
1827                                 0,              // AttributeCount\r
1828                                 false);         // HasAttributes\r
1829 \r
1830                         reader.Read ();\r
1831 \r
1832                         AssertNodeValues ("#4", reader,\r
1833                                 XmlNodeType.Element,\r
1834                                 1,              // Depth. It is 1 for main tree.\r
1835                                 false,          // IsEmptyElement\r
1836                                 "bar",          // Name\r
1837                                 String.Empty,   // Prefix\r
1838                                 "bar",          // LocalName\r
1839                                 String.Empty,   // NamespaceURI\r
1840                                 String.Empty,   // Value\r
1841                                 false,          // HasValue\r
1842                                 1,              // AttributeCount\r
1843                                 true);          // HasAttributes\r
1844 \r
1845                         st = reader.ReadSubtree ();\r
1846                         st.Read (); // Initial -> Interactive\r
1847                         AssertNodeValues ("#5", st,\r
1848                                 XmlNodeType.Element,\r
1849                                 0,              // Depth. It is 0 for subtree.\r
1850                                 false,          // IsEmptyElement\r
1851                                 "bar",          // Name\r
1852                                 String.Empty,   // Prefix\r
1853                                 "bar",          // LocalName\r
1854                                 String.Empty,   // NamespaceURI\r
1855                                 String.Empty,   // Value\r
1856                                 false,          // HasValue\r
1857                                 1,              // AttributeCount\r
1858                                 true);          // HasAttributes\r
1859 \r
1860                         st.Read ();\r
1861                         AssertNodeValues ("#6-1", st,\r
1862                                 XmlNodeType.EndElement,\r
1863                                 0,              // Depth. It is 0 for subtree.\r
1864                                 false,          // IsEmptyElement\r
1865                                 "bar",          // Name\r
1866                                 String.Empty,   // Prefix\r
1867                                 "bar",          // LocalName\r
1868                                 String.Empty,   // NamespaceURI\r
1869                                 String.Empty,   // Value\r
1870                                 false,          // HasValue\r
1871                                 0,              // AttributeCount\r
1872                                 false);         // HasAttributes\r
1873 \r
1874                         AssertNodeValues ("#6-2", st,\r
1875                                 XmlNodeType.EndElement,\r
1876                                 0,              // Depth. It is 0 for subtree.\r
1877                                 false,          // IsEmptyElement\r
1878                                 "bar",          // Name\r
1879                                 String.Empty,   // Prefix\r
1880                                 "bar",          // LocalName\r
1881                                 String.Empty,   // NamespaceURI\r
1882                                 String.Empty,   // Value\r
1883                                 false,          // HasValue\r
1884                                 0,              // AttributeCount\r
1885                                 false);         // HasAttributes\r
1886 \r
1887                         Assert.IsTrue (!st.Read (), "#7");\r
1888                 }\r
1889 \r
1890                 [Test]\r
1891                 public void ReadInteger ()\r
1892                 {\r
1893                         string xml1 = "<root>1</root>";\r
1894                         XmlReader xr;\r
1895                         \r
1896                         xr = XmlReader.Create (new StringReader (xml1));\r
1897                         xr.Read ();\r
1898                         Assert.AreEqual ("1", xr.ReadElementContentAsString (), "#1");\r
1899 \r
1900                         AssertNodeValues ("#1-2", xr,\r
1901                                 XmlNodeType.None,\r
1902                                 0,              // Depth. It is 0 for subtree.\r
1903                                 false,          // IsEmptyElement\r
1904                                 String.Empty,   // Name\r
1905                                 String.Empty,   // Prefix\r
1906                                 String.Empty,   // LocalName\r
1907                                 String.Empty,   // NamespaceURI\r
1908                                 String.Empty,   // Value\r
1909                                 false,          // HasValue\r
1910                                 0,              // AttributeCount\r
1911                                 false);         // HasAttributes\r
1912 \r
1913                         xr = XmlReader.Create (new StringReader (xml1));\r
1914                         xr.Read ();\r
1915                         // this XmlReader has no schema, thus the value is untyped\r
1916                         Assert.AreEqual ("1", xr.ReadElementContentAsObject (), "#2");\r
1917 \r
1918                         xr = XmlReader.Create (new StringReader (xml1));\r
1919                         xr.Read ();\r
1920                         xr.Read ();\r
1921                         Assert.AreEqual ("1", xr.ReadContentAsString (), "#3");\r
1922 \r
1923                         xr = XmlReader.Create (new StringReader (xml1));\r
1924                         xr.Read ();\r
1925                         Assert.AreEqual (1, xr.ReadElementContentAsInt (), "#4");\r
1926 \r
1927                         xr = XmlReader.Create (new StringReader (xml1));\r
1928                         xr.Read ();\r
1929                         Assert.AreEqual (1, xr.ReadElementContentAs (typeof (int), null), "#5");\r
1930                 }\r
1931 \r
1932                 [Test]\r
1933                 [ExpectedException (typeof (XmlException))]\r
1934                 public void ReadContentAsIntFail ()\r
1935                 {\r
1936                         XmlReader xr = XmlReader.Create (\r
1937                                 new StringReader ("<doc>1.0</doc>"));\r
1938                         xr.Read ();\r
1939                         xr.ReadElementContentAsInt ();\r
1940                 }\r
1941 \r
1942                 [Test]\r
1943                 public void ReadDateTime ()\r
1944                 {\r
1945                         DateTime time = new DateTime (2006, 1, 2, 3, 4, 56);\r
1946                         string xml1 = "<root>2006-01-02T03:04:56</root>";\r
1947                         XmlReader xr;\r
1948 \r
1949                         xr = XmlReader.Create (new StringReader (xml1));\r
1950                         xr.Read ();\r
1951                         // this XmlReader has no schema, thus the value is untyped\r
1952                         Assert.AreEqual ("2006-01-02T03:04:56", xr.ReadElementContentAsString (), "#1");\r
1953 \r
1954                         xr = XmlReader.Create (new StringReader (xml1));\r
1955                         xr.Read ();\r
1956                         xr.Read ();\r
1957                         Assert.AreEqual (time, xr.ReadContentAsDateTime (), "#2");\r
1958 \r
1959                         xr = XmlReader.Create (new StringReader (xml1));\r
1960                         xr.Read ();\r
1961                         Assert.AreEqual (time, xr.ReadElementContentAsDateTime (), "#3");\r
1962 \r
1963                         xr = XmlReader.Create (new StringReader (xml1));\r
1964                         xr.Read ();\r
1965                         Assert.AreEqual (time, xr.ReadElementContentAs (typeof (DateTime), null), "#4");\r
1966                 }\r
1967 \r
1968                 [Test]\r
1969                 [ExpectedException (typeof (XmlException))]\r
1970                 public void ReadContentAsDateTimeFail ()\r
1971                 {\r
1972                         XmlReader xr = XmlReader.Create (\r
1973                                 new StringReader ("<doc>P1Y2M3D</doc>"));\r
1974                         xr.Read ();\r
1975                         xr.ReadElementContentAsDateTime ();\r
1976                 }\r
1977 \r
1978                 [Test]\r
1979                 public void ReadContentAs_QNameEmptyNSResolver ()\r
1980                 {\r
1981                         XmlReader xr = XmlReader.Create (\r
1982                                 new StringReader ("<doc xmlns:x='urn:foo'>x:el</doc>"));\r
1983                         xr.Read ();\r
1984                         object o = xr.ReadElementContentAs (\r
1985                                 typeof (XmlQualifiedName), null);\r
1986                         // without IXmlNamespaceResolver, it still resolves\r
1987                         // x:el as valid QName.\r
1988                         Assert.IsNotNull (o, "#1");\r
1989                         XmlQualifiedName q = o as XmlQualifiedName;\r
1990                         Assert.AreEqual (new XmlQualifiedName ("el", "urn:foo"), q, "#2 : " + o.GetType ());\r
1991                 }\r
1992 \r
1993                 [Test]\r
1994                 [ExpectedException (typeof (InvalidOperationException))]\r
1995                 public void ReadContentStringOnElementFail ()\r
1996                 {\r
1997                         XmlReader xr = XmlReader.Create (new StringReader ("<a>test</a>"));\r
1998                         xr.Read ();\r
1999                         xr.ReadContentAsString ();\r
2000                 }\r
2001 \r
2002                 [Test]\r
2003                 public void ReadContentStringOnEndElement ()\r
2004                 {\r
2005                         XmlReader xr = XmlReader.Create (new StringReader ("<a>test</a>"));\r
2006                         xr.Read ();\r
2007                         xr.Read ();\r
2008                         xr.Read ();\r
2009                         Assert.AreEqual (String.Empty, xr.ReadContentAsString ()); // does not fail, unlike at Element!\r
2010                 }\r
2011 \r
2012                 [Test]\r
2013                 public void ReadContentStringOnPI ()\r
2014                 {\r
2015                         XmlReader xr = XmlReader.Create (new StringReader ("<?pi ?><a>test</a>"));\r
2016                         xr.Read ();\r
2017                         Assert.AreEqual (String.Empty, xr.ReadContentAsString ());\r
2018                 }\r
2019 \r
2020                 [Test]\r
2021                 [ExpectedException (typeof (InvalidOperationException))] // unlike ReadContentAsString()\r
2022                 public void ReadElementContentStringOnPI ()\r
2023                 {\r
2024                         XmlReader xr = XmlReader.Create (new StringReader ("<?pi ?><a>test</a>"));\r
2025                         xr.Read ();\r
2026                         Assert.AreEqual (XmlNodeType.ProcessingInstruction, xr.NodeType);\r
2027                         xr.ReadElementContentAsString ();\r
2028                 }\r
2029 \r
2030                 [Test]\r
2031                 [ExpectedException (typeof (XmlException))]\r
2032                 public void ReadElementContentStringMixedContent ()\r
2033                 {\r
2034                         XmlReader xr = XmlReader.Create (\r
2035                                 new StringReader ("<doc>123<child>456</child>789</doc>"));\r
2036                         xr.Read ();\r
2037                         // "child" is regarded as an invalid node.\r
2038                         string s = xr.ReadElementContentAsString ();\r
2039                 }\r
2040 \r
2041                 [Test]\r
2042                 public void ReadContentStringMixedContent ()\r
2043                 {\r
2044                         XmlReader xr = XmlReader.Create (\r
2045                                 new StringReader ("<doc>123<child>456</child>789</doc>"));\r
2046                         xr.Read ();\r
2047                         xr.Read (); // from Text "123"\r
2048                         string s = xr.ReadContentAsString ();\r
2049                         Assert.AreEqual ("123", s, "#1");\r
2050                         Assert.AreEqual (XmlNodeType.Element, xr.NodeType, "#2");\r
2051                 }\r
2052 \r
2053                 [Test]\r
2054                 public void ReadElementContentAsString ()\r
2055                 {\r
2056                         XmlTextReader r = new XmlTextReader (\r
2057                                 "<root/>", XmlNodeType.Document, null);\r
2058                         r.Read ();\r
2059                         Assert.AreEqual (String.Empty, r.ReadElementContentAsString (), "#1");\r
2060                         Assert.AreEqual (XmlNodeType.None, r.NodeType, "#2");\r
2061                 }\r
2062 \r
2063                 [Test]\r
2064                 public void ReadElementContentAs ()\r
2065                 {\r
2066                         // as System.Object\r
2067 \r
2068                         XmlTextReader r = new XmlTextReader (\r
2069                                 "<root/>", XmlNodeType.Document, null);\r
2070                         r.Read ();\r
2071                         Assert.AreEqual (String.Empty, r.ReadElementContentAs (typeof (object), null), "#1");\r
2072                         Assert.AreEqual (XmlNodeType.None, r.NodeType, "#2");\r
2073 \r
2074                         // regardless of its value, the return value is string.\r
2075                         r = new XmlTextReader ("<root>1</root>", XmlNodeType.Document, null);\r
2076                         r.Read ();\r
2077                         Assert.AreEqual ("1", r.ReadElementContentAs (typeof (object), null), "#3");\r
2078                         Assert.AreEqual (XmlNodeType.None, r.NodeType, "#4");\r
2079                 }\r
2080 \r
2081                 [Test]\r
2082                 public void ReadContentStringOnAttribute ()\r
2083                 {\r
2084                         string xml = @"<root id='myId'><child /></root>";\r
2085                         RunTest (xml, new TestMethod (ReadContentStringOnAttribute));\r
2086                 }\r
2087 \r
2088                 void ReadContentStringOnAttribute (XmlReader reader)\r
2089                 {\r
2090                         reader.Read ();\r
2091                         Assert.IsTrue (reader.MoveToAttribute ("id"));\r
2092                         Assert.AreEqual ("myId", reader.ReadContentAsString ());\r
2093                 }\r
2094 \r
2095                 [Test]\r
2096                 public void ReadElementContentAsStringEmpty ()\r
2097                 {\r
2098                         string xml = "<root><sample/></root>";\r
2099                         RunTest (xml, new TestMethod (ReadElementContentAsStringEmpty));\r
2100                 }\r
2101 \r
2102                 void ReadElementContentAsStringEmpty (XmlReader reader)\r
2103                 {\r
2104                         reader.MoveToContent ();\r
2105                         reader.Read ();\r
2106                         Assert.AreEqual (String.Empty, reader.ReadElementContentAsString ("sample", ""));\r
2107                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType);\r
2108                 }\r
2109 \r
2110                 [Test]\r
2111                 public void ReadSubtreeClose ()\r
2112                 {\r
2113                         // bug #334752\r
2114                         string xml = @"<root><item-list><item id='a'/><item id='b'/></item-list></root>";\r
2115                         RunTest (xml, new TestMethod (ReadSubtreeClose));\r
2116                 }\r
2117 \r
2118                 void ReadSubtreeClose (XmlReader reader)\r
2119                 {\r
2120                         reader.ReadToFollowing ("item-list");\r
2121                         XmlReader sub = reader.ReadSubtree ();\r
2122                         sub.ReadToDescendant ("item");\r
2123                         sub.Close ();\r
2124                         Assert.AreEqual (XmlNodeType.EndElement, reader.NodeType, "#1");\r
2125                         Assert.AreEqual ("item-list", reader.Name, "#2");\r
2126                 }\r
2127 \r
2128                 [Test]\r
2129                 [ExpectedException (typeof (InvalidOperationException))]\r
2130                 public void ReadSubtreeOnNonElement ()\r
2131                 {\r
2132                         string xml = @"<x> <y/></x>";\r
2133                         XmlReader r = XmlReader.Create (new StringReader (xml));\r
2134                         r.Read (); // x\r
2135                         r.Read (); // ws\r
2136                         r.ReadSubtree ();\r
2137                 }\r
2138 \r
2139                 [Test]\r
2140                 [ExpectedException (typeof (InvalidOperationException))]\r
2141                 public void ReadSubtreeOnNonElement2 ()\r
2142                 {\r
2143                         string xml = @"<x> <y/></x>";\r
2144                         XmlReader r = XmlReader.Create (new StringReader (xml));\r
2145                         r.ReadSubtree ();\r
2146                 }\r
2147 \r
2148                 [Test]\r
2149                 public void ReadSubtreeEmptyElement ()\r
2150                 {\r
2151                         string xml = @"<x/>";\r
2152                         XmlReader r = XmlReader.Create (new StringReader (xml));\r
2153                         r.Read ();\r
2154                         XmlReader s = r.ReadSubtree ();\r
2155                         Assert.IsTrue (s.Read (), "#1");\r
2156                         Assert.AreEqual (XmlNodeType.Element, s.NodeType, "#2");\r
2157                         Assert.IsTrue (!s.Read (), "#3");\r
2158                         Assert.AreEqual (XmlNodeType.None, s.NodeType, "#4");\r
2159                 }\r
2160 \r
2161                 [Test]\r
2162                 public void ReadSubtreeEmptyElementWithAttribute ()\r
2163                 {\r
2164                         string xml = @"<root><x a='b'/></root>";\r
2165                         XmlReader r = XmlReader.Create (new StringReader (xml));\r
2166                         r.Read ();\r
2167                         r.Read ();\r
2168                         XmlReader r2 = r.ReadSubtree ();\r
2169                         Console.WriteLine ("X");\r
2170                         r2.Read ();\r
2171                         XmlReader r3 = r2.ReadSubtree ();\r
2172                         r2.MoveToFirstAttribute ();\r
2173                         Assert.IsTrue (!r.IsEmptyElement, "#1");\r
2174                         Assert.IsTrue (!r2.IsEmptyElement, "#2");\r
2175                         r3.Close ();\r
2176                         Assert.IsTrue (r.IsEmptyElement, "#3");\r
2177                         Assert.IsTrue (r2.IsEmptyElement, "#4");\r
2178                         r2.Close ();\r
2179                         Assert.IsTrue (r.IsEmptyElement, "#5");\r
2180                         Assert.IsTrue (r2.IsEmptyElement, "#6");\r
2181                 }\r
2182 \r
2183                 [Test]\r
2184                 public void ReadContentAsBase64 ()\r
2185                 {\r
2186                         byte[] randomData = new byte[24];\r
2187                         for (int i = 0; i < randomData.Length; i++)\r
2188                                 randomData [i] = (byte) i;\r
2189 \r
2190                         string xmlString = "<?xml version=\"1.0\"?><data>" +\r
2191                         Convert.ToBase64String (randomData) + "</data>";\r
2192                         TextReader textReader = new StringReader (xmlString);\r
2193                         XmlReader xmlReader = XmlReader.Create (textReader);\r
2194                         xmlReader.ReadToFollowing ("data");\r
2195 \r
2196                         int readBytes = 0;\r
2197                         byte[] buffer = new byte [24];\r
2198 \r
2199                         xmlReader.ReadStartElement ();\r
2200                         readBytes = xmlReader.ReadContentAsBase64 (buffer, 0, buffer.Length);\r
2201                         Assert.AreEqual (24, readBytes, "#1");\r
2202                         Assert.AreEqual (0, xmlReader.ReadContentAsBase64 (buffer, 0, buffer.Length), "#2");\r
2203                         StringWriter sw = new StringWriter ();\r
2204                         foreach (byte b in buffer) sw.Write ("{0:X02}", b);\r
2205                         Assert.AreEqual ("000102030405060708090A0B0C0D0E0F1011121314151617", sw.ToString (), "#3");\r
2206                 }\r
2207 \r
2208                 [Test]\r
2209                 public void ReadContentAsBase64_2 () // bug #480066\r
2210                 {\r
2211                         StringReader readerString = new StringReader ("<root><b64>TWFu</b64><b64>TWFu</b64>\r\n\t<b64>TWFu</b64><b64>TWFu</b64></root>");\r
2212                         XmlReaderSettings settingsXml = new XmlReaderSettings ();\r
2213                         settingsXml.XmlResolver = null;\r
2214                         using (var readerXml = XmlReader.Create (readerString, settingsXml)) {\r
2215                                 readerXml.MoveToContent ();\r
2216                                 readerXml.Read ();\r
2217                                 readerXml.ReadStartElement ("b64");\r
2218                                 const int bufferLength = 1024;\r
2219                                 byte [] buffer = new byte [bufferLength];\r
2220                                 readerXml.ReadContentAsBase64 (buffer, 0, bufferLength);\r
2221                                 Assert.AreEqual (XmlNodeType.EndElement, readerXml.NodeType, "#1");\r
2222                                 readerXml.Read ();\r
2223                                 Assert.AreEqual (XmlNodeType.Element, readerXml.NodeType, "#2");\r
2224                         }\r
2225                 }\r
2226                 \r
2227                 [Test]\r
2228                 public void ReadContentAsBase64_3 () // bug #543332                     \r
2229                 {\r
2230                         byte [] fakeState = new byte[25];\r
2231                         byte [] fixedSizeBuffer = new byte [25];\r
2232                         byte [] readDataBuffer = new byte [25];\r
2233                         var ms = new MemoryStream ();\r
2234                         var xw = XmlWriter.Create (ms);\r
2235                         xw.WriteStartElement ("root");\r
2236                         xw.WriteBase64 (fakeState, 0, fakeState.Length);\r
2237                         xw.WriteEndElement ();\r
2238                         xw.Close ();\r
2239                         var reader = XmlReader.Create (new MemoryStream (ms.ToArray ()));\r
2240                         reader.MoveToContent ();\r
2241                         // we cannot completely trust the length read to indicate the end.\r
2242                         int bytesRead;\r
2243                         bytesRead = reader.ReadElementContentAsBase64 (fixedSizeBuffer, 0, fixedSizeBuffer.Length);\r
2244                         Assert.AreEqual (25, bytesRead, "#1");\r
2245                         Assert.AreEqual (XmlNodeType.Text, reader.NodeType, "#2");\r
2246                         bytesRead = reader.ReadElementContentAsBase64 (fixedSizeBuffer, 0, fixedSizeBuffer.Length);\r
2247                         Assert.AreEqual (0, bytesRead, "#3");\r
2248                         Assert.AreEqual (XmlNodeType.None, reader.NodeType, "#4");\r
2249                 }\r
2250 \r
2251                 [Test]\r
2252                 public void ReadElementContentAsQNameDefaultNS ()\r
2253                 {\r
2254                         var sw = new StringWriter ();\r
2255                         var xw = XmlWriter.Create (sw);\r
2256                         xw.WriteStartElement ("", "foo", "urn:foo");\r
2257                         xw.WriteValue (new XmlQualifiedName ("x", "urn:foo"));\r
2258                         xw.WriteEndElement ();\r
2259                         xw.Close ();\r
2260                         var xr = XmlReader.Create (new StringReader (sw.ToString ()));\r
2261                         xr.MoveToContent ();\r
2262                         var q = (XmlQualifiedName) xr.ReadElementContentAs (typeof (XmlQualifiedName), xr as IXmlNamespaceResolver);\r
2263                         Assert.AreEqual ("urn:foo", q.Namespace, "#1");\r
2264                 }\r
2265 \r
2266                 [Test]\r
2267                 public void ReadElementContentAsArray ()\r
2268                 {\r
2269                         var sw = new StringWriter ();\r
2270                         var xw = XmlWriter.Create (sw);\r
2271                         xw.WriteStartElement ("root");\r
2272                         xw.WriteAttributeString ("xmlns", "b", "http://www.w3.org/2000/xmlns/", "urn:bar");\r
2273                         var arr = new XmlQualifiedName [] { new XmlQualifiedName ("foo"), new XmlQualifiedName ("bar", "urn:bar") };\r
2274                         xw.WriteValue (arr);\r
2275                         xw.Close ();\r
2276                         var xr = XmlReader.Create (new StringReader (sw.ToString ()));\r
2277                         xr.MoveToContent ();\r
2278                         var ret = xr.ReadElementContentAs (typeof (XmlQualifiedName []), null) as XmlQualifiedName [];\r
2279                         Assert.IsNotNull (ret, "#1");\r
2280                         Assert.AreEqual (arr [0], ret [0], "#2");\r
2281                         Assert.AreEqual (arr [1], ret [1], "#3");\r
2282                 }\r
2283 \r
2284                 [Test]\r
2285                 public void ReadContentAs ()\r
2286                 {\r
2287                         var xr = XmlReader.Create (new StringReader ("<doc a=' 1 '/>"));\r
2288                         xr.Read ();\r
2289                         xr.MoveToAttribute ("a");\r
2290 \r
2291                         Assert.AreEqual ((Byte) 1, xr.ReadContentAs (typeof (Byte), null), "#1");\r
2292                         Assert.AreEqual ((SByte) 1, xr.ReadContentAs (typeof (SByte), null), "#2");\r
2293                         Assert.AreEqual ((Int16) 1, xr.ReadContentAs (typeof (Int16), null), "#3");\r
2294                         Assert.AreEqual ((UInt16) 1, xr.ReadContentAs (typeof (UInt16), null), "#4");\r
2295                         Assert.AreEqual ((Int32) 1, xr.ReadContentAs (typeof (Int32), null), "#5");\r
2296                         Assert.AreEqual ((UInt32) 1, xr.ReadContentAs (typeof (UInt32), null), "#6");\r
2297                         Assert.AreEqual ((Int64) 1, xr.ReadContentAs (typeof (Int64), null), "#7");\r
2298                         Assert.AreEqual ((UInt64) 1, xr.ReadContentAs (typeof (UInt64), null), "#8");\r
2299                 }\r
2300 \r
2301 #if NET_4_5\r
2302                 [Test]\r
2303                 [ExpectedException(typeof(InvalidOperationException))]\r
2304                 public void MustSetAsyncFlag ()\r
2305                 {\r
2306                         var r = XmlReader.Create (new StringReader ("<root/>"));\r
2307                         r.ReadAsync ();\r
2308                 }\r
2309 \r
2310                 Exception RunAsync (Action action)\r
2311                 {\r
2312                         var task = Task<Exception>.Run (async () => {\r
2313                                 try {\r
2314                                         action ();\r
2315                                         return null;\r
2316                                 } catch (Exception ex) {\r
2317                                         return ex;\r
2318                                 }\r
2319                         });\r
2320                         task.Wait ();\r
2321                         Assert.That (task.IsCompleted);\r
2322                         return task.Result;\r
2323                 }\r
2324 \r
2325                 [Test]\r
2326                 public void SimpleAsync ()\r
2327                 {\r
2328                         var xml = "<root test=\"monkey\"/>";\r
2329                         var task = Task<Exception>.Run (async () => {\r
2330                                 try {\r
2331                                         var s = new XmlReaderSettings ();\r
2332                                         s.Async = true;\r
2333                                         var r = XmlReader.Create (new StringReader (xml), s);\r
2334 \r
2335                                         Assert.That (await r.ReadAsync ());\r
2336                                         Assert.That (r.MoveToFirstAttribute ());\r
2337 \r
2338                                         Assert.AreEqual (await r.GetValueAsync (), "monkey");\r
2339                                         r.Close ();\r
2340                                         return null;\r
2341                                 } catch (Exception ex) {\r
2342                                         return ex;\r
2343                                 }\r
2344                         });\r
2345                         task.Wait ();\r
2346                         Assert.That (task.IsCompleted);\r
2347                         if (task.Result != null)\r
2348                                 throw task.Result;\r
2349                 }\r
2350 #endif\r
2351         }\r
2352 }\r