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