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

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