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 : Assertion\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 (xmlReader.ReadState == ReadState.Initial);\r
  45                         Assert (xmlReader.NodeType == XmlNodeType.None);\r
  46                         Assert (xmlReader.Depth == 0);\r
  47                         Assert (!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 (label + " Read() return value", xmlReader.Read ());\r
  81                         Assert (label + " ReadState", xmlReader.ReadState == ReadState.Interactive);\r
  82                         Assert (label + " !EOF", !xmlReader.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                         AssertEquals (label + ": NodeType", nodeType, xmlReader.NodeType);\r
 125                         AssertEquals (label + ": IsEmptyElement", isEmptyElement, xmlReader.IsEmptyElement);\r
 126 \r
 127                         AssertEquals (label + ": name", name, xmlReader.Name);\r
 128 \r
 129                         AssertEquals (label + ": prefix", prefix, xmlReader.Prefix);\r
 130 \r
 131                         AssertEquals (label + ": localName", localName, xmlReader.LocalName);\r
 132 \r
 133                         AssertEquals (label + ": namespaceURI", namespaceURI, xmlReader.NamespaceURI);\r
 134 \r
 135                         AssertEquals (label + ": Depth", depth, xmlReader.Depth);\r
 136 \r
 137                         AssertEquals (label + ": hasValue", hasValue, xmlReader.HasValue);\r
 138 \r
 139                         AssertEquals (label + ": Value", value, xmlReader.Value);\r
 140 \r
 141                         AssertEquals (label + ": hasAttributes", hasAttributes, xmlReader.HasAttributes);\r
 142 \r
 143                         AssertEquals (label + ": attributeCount", attributeCount, xmlReader.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                         AssertEquals ("value", value, xmlReader [name]);\r
 155 \r
 156                         Assert (xmlReader.GetAttribute (name) == value);\r
 157 \r
 158                         if (namespaceURI != String.Empty) {\r
 159                                 Assert (xmlReader[localName, namespaceURI] == value);\r
 160                                 Assert (xmlReader.GetAttribute (localName, namespaceURI) == value);\r
 161                         }\r
 162                 }\r
 163 \r
 164                 private void AssertEndDocument (XmlReader xmlReader)\r
 165                 {\r
 166                         Assert ("could read", !xmlReader.Read ());\r
 167                         AssertEquals ("NodeType is not XmlNodeType.None", XmlNodeType.None, xmlReader.NodeType);\r
 168                         AssertEquals ("Depth is not 0", 0, xmlReader.Depth);\r
 169                         AssertEquals ("ReadState is not ReadState.EndOfFile",  ReadState.EndOfFile, xmlReader.ReadState);\r
 170                         Assert ("not EOF", xmlReader.EOF);\r
 171 \r
 172                         xmlReader.Close ();\r
 173                         AssertEquals ("ReadState is not ReadState.Cosed", ReadState.Closed, xmlReader.ReadState);\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                         AssertEquals ("Depth", 0, reader.Depth);\r
 223                         AssertEquals ("EOF", false, reader.EOF);\r
 224                         AssertEquals ("HasValue", false, reader.HasValue);\r
 225                         AssertEquals ("IsEmptyElement", false, reader.IsEmptyElement);\r
 226                         AssertEquals ("LocalName", String.Empty, reader.LocalName);\r
 227                         AssertEquals ("NodeType", XmlNodeType.None, reader.NodeType);\r
 228                         AssertEquals ("ReadState", ReadState.Initial, reader.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                         AssertEquals ("<root>.NodeType", XmlNodeType.Element, reader.NodeType);\r
 241                         AssertEquals ("<root>.Name", "root", reader.Name);\r
 242                         AssertEquals ("<root>.ReadState", ReadState.Interactive, reader.ReadState);\r
 243                         AssertEquals ("<root>.Depth", 0, reader.Depth);\r
 244 \r
 245                         // move to 'child'\r
 246                         reader.Read ();\r
 247                         AssertEquals ("<child/>.Depth", 1, reader.Depth);\r
 248                         AssertEquals ("<child/>.NodeType", XmlNodeType.Element, reader.NodeType);\r
 249                         AssertEquals ("<child/>.Name", "child", reader.Name);\r
 250 \r
 251                         reader.Read ();\r
 252                         AssertEquals ("</root>.Depth", 0, reader.Depth);\r
 253                         AssertEquals ("</root>.NodeType", XmlNodeType.EndElement, reader.NodeType);\r
 254                         AssertEquals ("</root>.Name", "root", reader.Name);\r
 255 \r
 256                         reader.Read ();\r
 257                         AssertEquals ("end.EOF", true, reader.EOF);\r
 258                         AssertEquals ("end.NodeType", XmlNodeType.None, reader.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 (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 (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 (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                         AssertEquals (false, reader.IsEmptyElement);\r
 299                         reader.Read (); // foo\r
 300                         AssertEquals ("foo", reader.Name);\r
 301                         AssertEquals (true, reader.IsEmptyElement);\r
 302                         reader.Read (); // bar\r
 303                         AssertEquals ("bar", reader.Name);\r
 304                         AssertEquals (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                         AssertEquals ("readString.1.ret_val", "  test of ", s);\r
 324                         AssertEquals ("readString.1.Name", "b", reader.Name);\r
 325                         s = reader.ReadString ();\r
 326                         AssertEquals ("readString.2.ret_val", "mixed", s);\r
 327                         AssertEquals ("readString.2.NodeType", XmlNodeType.EndElement, reader.NodeType);\r
 328                         s = reader.ReadString ();       // never proceeds.\r
 329                         AssertEquals ("readString.3.ret_val", String.Empty, s);\r
 330                         AssertEquals ("readString.3.NodeType", XmlNodeType.EndElement, reader.NodeType);\r
 331                         reader.Read ();\r
 332                         AssertEquals ("readString.4.NodeType", XmlNodeType.Text, reader.NodeType);\r
 333                         AssertEquals ("readString.4.Value", " string.", reader.Value);\r
 334                         s = reader.ReadString ();       // reads the same Text node.\r
 335                         AssertEquals ("readString.5.ret_val", " string. cdata string.", s);\r
 336                         AssertEquals ("readString.5.NodeType", XmlNodeType.EndElement, reader.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                         AssertEquals ("initial.ReadState", ReadState.Interactive, reader.ReadState);\r
 351                         AssertEquals ("initial.EOF", false, reader.EOF);\r
 352                         AssertEquals ("initial.NodeType", XmlNodeType.Element, reader.NodeType);\r
 353                         string s = reader.ReadInnerXml ();\r
 354                         AssertEquals ("read_all", "test of <b>mixed</b> string.", s);\r
 355                         AssertEquals ("after.Name", "bar", reader.Name);\r
 356                         AssertEquals ("after.NodeType", XmlNodeType.Element, reader.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                         AssertEquals ("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                         AssertEquals ("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                         AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
 976                         AssertEquals ("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                         AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
 992                         AssertNull (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                         AssertEquals ("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                         AssertEquals ("http://foo/", xmlReader.LookupNamespace ("foo"));\r
1055                         AssertEquals ("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                         AssertEquals ("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                         AssertEquals ("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 (xmlReader.Read ());\r
1132                         AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
1133                         Assert (xmlReader.MoveToFirstAttribute ());\r
1134                         AssertEquals (XmlNodeType.Attribute, xmlReader.NodeType);\r
1135                         Assert (xmlReader.MoveToElement ());\r
1136                         AssertEquals (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 (xmlReader.Read ());\r
1149                         AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
1150                         Assert (!xmlReader.MoveToElement ());\r
1151                         AssertEquals (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 (xmlReader.Read ());\r
1164                         AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
1165                         Assert (!xmlReader.MoveToFirstAttribute ());\r
1166                         AssertEquals (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 (xmlReader.Read ());\r
1179                         AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
1180                         Assert (!xmlReader.MoveToNextAttribute ());\r
1181                         AssertEquals (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 (xmlReader.MoveToNextAttribute ());\r
1227                         AssertEquals ("bar", xmlReader.Name);\r
1228                         AssertEquals ("baz", xmlReader.Value);\r
1229 \r
1230                         Assert (xmlReader.MoveToNextAttribute ());\r
1231                         AssertEquals ("quux", xmlReader.Name);\r
1232                         AssertEquals ("quuux", xmlReader.Value);\r
1233 \r
1234                         Assert (!xmlReader.MoveToNextAttribute ());\r
1235 \r
1236                         Assert (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 ("MoveToFirstAttribute",\r
1278                                 xmlReader.MoveToFirstAttribute ());\r
1279                         this.AssertNodeValues ("#2", xmlReader, \r
1280                                 XmlNodeType.Attribute,\r
1281                                 0, // FIXME: might be 1\r
1282                                 false,\r
1283                                 "version",\r
1284                                 String.Empty,\r
1285                                 "version",\r
1286                                 String.Empty,\r
1287                                 "1.0",\r
1288                                 2);\r
1289                         xmlReader.ReadAttributeValue ();\r
1290                         this.AssertNodeValues ("#3", xmlReader, \r
1291                                 XmlNodeType.Text,\r
1292                                 1, // FIXME might be 2\r
1293                                 false,\r
1294                                 String.Empty,\r
1295                                 null, // FIXME: should be String.Empty,\r
1296                                 String.Empty,\r
1297                                 null, // FIXME: should be String.Empty,\r
1298                                 "1.0",\r
1299                                 2);\r
1300                         xmlReader.MoveToNextAttribute ();\r
1301                         this.AssertNodeValues ("#4", xmlReader, \r
1302                                 XmlNodeType.Attribute,\r
1303                                 0, // FIXME: might be 1\r
1304                                 false,\r
1305                                 "standalone",\r
1306                                 String.Empty,\r
1307                                 "standalone",\r
1308                                 String.Empty,\r
1309                                 "yes",\r
1310                                 2);\r
1311                         xmlReader.ReadAttributeValue ();\r
1312                         this.AssertNodeValues ("#5", xmlReader, \r
1313                                 XmlNodeType.Text,\r
1314                                 1, // FIXME: might be 2\r
1315                                 false,\r
1316                                 String.Empty,\r
1317                                 null, // FIXME: should be String.Empty,\r
1318                                 String.Empty,\r
1319                                 null, // FIXME: should be String.Empty,\r
1320                                 "yes",\r
1321                                 2);\r
1322                 }\r
1323 \r
1324                 [Test]\r
1325                 public void AttributeOrder ()\r
1326                 {\r
1327                         string xml = @"<foo _1='1' _2='2' _3='3' />";\r
1328                         RunTest (xml, new TestMethod (AttributeOrder));\r
1329                 }\r
1330 \r
1331                 public void AttributeOrder (XmlReader xmlReader)\r
1332                 {\r
1333                         Assert (xmlReader.Read ());\r
1334                         AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
1335 \r
1336                         Assert (xmlReader.MoveToFirstAttribute ());\r
1337                         AssertEquals ("_1", xmlReader.Name);\r
1338                         Assert (xmlReader.MoveToNextAttribute ());\r
1339                         AssertEquals ("_2", xmlReader.Name);\r
1340                         Assert (xmlReader.MoveToNextAttribute ());\r
1341                         AssertEquals ("_3", xmlReader.Name);\r
1342 \r
1343                         Assert (!xmlReader.MoveToNextAttribute ());\r
1344                 }\r
1345 \r
1346                 [Test]\r
1347                 [Category ("NotDotNet")]\r
1348                 public void IndexerAndAttributes ()\r
1349                 {\r
1350                         string xml = @"<?xml version='1.0' standalone='no'?><foo _1='1' _2='2' _3='3' />";\r
1351                         RunTest (xml, new TestMethod (IndexerAndAttributes));\r
1352                 }\r
1353 \r
1354                 public void IndexerAndAttributes (XmlReader xmlReader)\r
1355                 {\r
1356                         Assert (xmlReader.Read ());\r
1357                         AssertEquals ("1.0", xmlReader ["version"]);\r
1358                         AssertEquals ("1.0", xmlReader.GetAttribute ("version"));\r
1359                         // .NET 1.1 BUG. XmlTextReader returns null, while XmlNodeReader returns "".\r
1360                         AssertEquals (null, xmlReader ["encoding"]);\r
1361                         AssertEquals (null, xmlReader.GetAttribute ("encoding"));\r
1362                         AssertEquals ("no", xmlReader ["standalone"]);\r
1363                         AssertEquals ("no", xmlReader.GetAttribute ("standalone"));\r
1364                         AssertEquals ("1.0", xmlReader [0]);\r
1365                         AssertEquals ("1.0", xmlReader.GetAttribute (0));\r
1366                         AssertEquals ("no", xmlReader [1]);\r
1367                         AssertEquals ("no", xmlReader.GetAttribute (1));\r
1368 \r
1369                         Assert (xmlReader.Read ());\r
1370                         AssertEquals (XmlNodeType.Element, xmlReader.NodeType);\r
1371                         AssertEquals ("1", xmlReader ["_1"]);\r
1372 \r
1373                         Assert (xmlReader.MoveToFirstAttribute ());\r
1374                         AssertEquals ("_1", xmlReader.Name);\r
1375                         AssertEquals ("1", xmlReader ["_1"]);\r
1376                         Assert (xmlReader.MoveToNextAttribute ());\r
1377                         AssertEquals ("_2", xmlReader.Name);\r
1378                         AssertEquals ("1", xmlReader ["_1"]);\r
1379                         Assert (xmlReader.MoveToNextAttribute ());\r
1380                         AssertEquals ("_3", xmlReader.Name);\r
1381                         AssertEquals ("1", xmlReader ["_1"]);\r
1382 \r
1383                         Assert (!xmlReader.MoveToNextAttribute ());\r
1384                 }\r
1385 \r
1386                 [Test]\r
1387                 public void ProhibitedMultipleAttributes ()\r
1388                 {\r
1389                         string xml = @"<foo _1='1' _1='1' />";\r
1390                         try {\r
1391                                 RunTest (xml, new TestMethod (ReadAll));\r
1392                         } catch (XmlException) {\r
1393                         }\r
1394                         xml = @"<foo _1='1' _1='2' />";\r
1395                         try {\r
1396                                 RunTest (xml, new TestMethod (ReadAll));\r
1397                         } catch (XmlException) {\r
1398                         }\r
1399                 }\r
1400 \r
1401                 public void ReadAll (XmlReader xmlReader)\r
1402                 {\r
1403                         while (!xmlReader.EOF)\r
1404                                 xmlReader.Read ();\r
1405                 }\r
1406 \r
1407                 [Test]\r
1408                 public void SurrogatePairContent ()\r
1409                 {\r
1410                         string xml = "<root xmlns='&#x10100;'/>";\r
1411                         RunTest (xml, new TestMethod (SurrogatePairContent));\r
1412                 }\r
1413 \r
1414                 public void SurrogatePairContent (XmlReader xmlReader)\r
1415                 {\r
1416                         xmlReader.Read ();\r
1417                         AssertEquals (true, xmlReader.MoveToAttribute ("xmlns"));\r
1418                         AssertEquals ("xmlns", xmlReader.Name);\r
1419                         AssertEquals (2, xmlReader.Value.Length);\r
1420                         AssertEquals (0xD800, (int) xmlReader.Value [0]);\r
1421                         AssertEquals (0xDD00, (int) xmlReader.Value [1]);\r
1422                 }\r
1423 \r
1424                 [Test]\r
1425                 public void ReadOuterXmlOnEndElement ()\r
1426                 {\r
1427                         string xml = "<root><foo></foo></root>";\r
1428                         RunTest (xml, new TestMethod (ReadOuterXmlOnEndElement));\r
1429                 }\r
1430 \r
1431                 public void ReadOuterXmlOnEndElement (XmlReader xmlReader)\r
1432                 {\r
1433                         xmlReader.Read ();\r
1434                         xmlReader.Read ();\r
1435                         xmlReader.Read ();\r
1436                         AssertEquals (String.Empty, xmlReader.ReadOuterXml ());\r
1437                 }\r
1438 \r
1439                 [Test]\r
1440                 public void ReadInnerXmlOnEndElement ()\r
1441                 {\r
1442                         string xml = "<root><foo></foo></root>";\r
1443                         RunTest (xml, new TestMethod (ReadInnerXmlOnEndElement));\r
1444                 }\r
1445 \r
1446                 private void ReadInnerXmlOnEndElement (XmlReader xmlReader)\r
1447                 {\r
1448                         xmlReader.Read ();\r
1449                         xmlReader.Read ();\r
1450                         xmlReader.Read ();\r
1451                         AssertEquals (String.Empty, xmlReader.ReadInnerXml ());\r
1452                 }\r
1453 \r
1454                 [Test]\r
1455                 public void LookupEmptyPrefix ()\r
1456                 {\r
1457                         string xml = "<root><foo></foo></root>";\r
1458                         RunTest (xml, new TestMethod (LookupEmptyPrefix));\r
1459                 }\r
1460 \r
1461                 void LookupEmptyPrefix (XmlReader xmlReader)\r
1462                 {\r
1463                         xmlReader.Read ();\r
1464                         AssertNull (xmlReader.LookupNamespace (String.Empty));\r
1465                 }\r
1466 \r
1467                 [Test]\r
1468                 public void ReadStartElement ()\r
1469                 {\r
1470                         string xml = "<root>test</root>";\r
1471                         RunTest (xml, new TestMethod (ReadStartElement));\r
1472                 }\r
1473 \r
1474                 void ReadStartElement (XmlReader xr)\r
1475                 {\r
1476                         xr.Read ();\r
1477                         xr.ReadStartElement ();\r
1478                         // consume Element node.\r
1479                         AssertEquals (XmlNodeType.Text, xr.NodeType);\r
1480                 }\r
1481 \r
1482                 [Test]\r
1483                 public void LookupNamespaceAtEndElement ()\r
1484                 {\r
1485                         string xml = "<root xmlns:x='urn:foo'><foo/></root>";\r
1486                         RunTest (xml, new TestMethod (LookupNamespaceAtEndElement));\r
1487                 }\r
1488 \r
1489                 void LookupNamespaceAtEndElement (XmlReader reader)\r
1490                 {\r
1491                         reader.Read ();\r
1492                         AssertEquals ("#1", "urn:foo", reader.LookupNamespace ("x"));\r
1493                         reader.Read ();\r
1494                         AssertEquals ("#2", "urn:foo", reader.LookupNamespace ("x"));\r
1495                         reader.Read ();\r
1496                         AssertEquals ("#3", "urn:foo", reader.LookupNamespace ("x"));\r
1497                 }\r
1498 \r
1499 #if NET_2_0\r
1500                 [Test]\r
1501                 public void CreateSimple ()\r
1502                 {\r
1503                         XmlReaderSettings s = new XmlReaderSettings ();\r
1504                         s.ProhibitDtd = false;\r
1505                         XmlReader xr = XmlReader.Create ("Test/XmlFiles/nested-dtd-test.xml", s);\r
1506                         xr.Read ();\r
1507                         AssertEquals ("#1", XmlNodeType.DocumentType, xr.NodeType);\r
1508                         xr.Read ();\r
1509                         AssertEquals ("#2", XmlNodeType.Whitespace, xr.NodeType);\r
1510                         xr.Read ();\r
1511                         AssertEquals ("#3", XmlNodeType.Element, xr.NodeType);\r
1512                 }\r
1513 \r
1514                 [Test]\r
1515                 [ExpectedException (typeof (XmlException))]\r
1516                 public void CreateSimpleProhibitDtd ()\r
1517                 {\r
1518                         XmlReader xr = XmlReader.Create ("Test/XmlFiles/nested-dtd-test.xml");\r
1519                         xr.Read ();\r
1520                 }\r
1521 \r
1522                 [Test]\r
1523                 // a bit revised version of bug #78706\r
1524                 public void CreateFromUrlClose ()\r
1525                 {\r
1526                         string file = "Test/XmlFiles/78706.xml";\r
1527                         try {\r
1528                                 if (!File.Exists (file))\r
1529                                         File.Create (file).Close ();\r
1530                                 XmlReaderSettings s = new XmlReaderSettings ();\r
1531                                 s.CloseInput = false; // explicitly\r
1532                                 XmlReader r = XmlReader.Create (file, s);\r
1533                                 r.Close ();\r
1534                                 XmlTextWriter w = new XmlTextWriter (file, null);\r
1535                                 w.Close ();\r
1536                         } finally {\r
1537                                 if (File.Exists (file))\r
1538                                         File.Delete (file);\r
1539                         }\r
1540                 }\r
1541 \r
1542                 [Test]\r
1543                 public void ReadToDescendant ()\r
1544                 {\r
1545                         string xml = @"<root><foo/><bar/><foo> test text <bar><bar></bar></bar></foo></root>";\r
1546                         RunTest (xml, new TestMethod (ReadToDescendant));\r
1547                 }\r
1548 \r
1549                 void ReadToDescendant (XmlReader xmlReader)\r
1550                 {\r
1551                         // move to first <bar/>\r
1552                         Assert ("#1", xmlReader.ReadToDescendant ("bar"));\r
1553                         // no children in <bar/>. It is empty.\r
1554                         Assert ("#2", !xmlReader.ReadToDescendant ("bar"));\r
1555                         AssertEquals ("#2-2", "bar", xmlReader.Name);\r
1556 \r
1557                         // move to the second <foo>\r
1558                         xmlReader.Read ();\r
1559                         // move to the second <bar>\r
1560                         Assert ("#3", xmlReader.ReadToDescendant ("bar"));\r
1561                         // move to <bar> inside <bar>...</bar>\r
1562                         Assert ("#4", xmlReader.ReadToDescendant ("bar"));\r
1563                         // the next is EndElement of </bar>, so no move.\r
1564                         Assert ("#5", !xmlReader.ReadToDescendant ("bar"));\r
1565                         AssertEquals ("#5-2", XmlNodeType.EndElement, xmlReader.NodeType);\r
1566                 }\r
1567 \r
1568                 [Test]\r
1569                 public void ReadToDescepdant2 ()\r
1570                 {\r
1571                         string xml = "<root/>";\r
1572                         RunTest (xml, new TestMethod (ReadToDescendant2));\r
1573                 }\r
1574 \r
1575                 void ReadToDescendant2 (XmlReader xmlReader)\r
1576                 {\r
1577                         // make sure that it works when the reader is at Initial state.\r
1578                         Assert (xmlReader.ReadToDescendant ("root"));\r
1579                 }\r
1580 \r
1581                 [Test]\r
1582                 public void ReadToFollowing ()\r
1583                 {\r
1584                         string xml = @"<root><foo/><bar/><foo><bar><bar></bar></bar></foo></root>";\r
1585                         RunTest (xml, new TestMethod (ReadToFollowing));\r
1586                 }\r
1587 \r
1588                 public void ReadToFollowing (XmlReader xmlReader)\r
1589                 {\r
1590                         Assert ("#1", xmlReader.ReadToFollowing ("bar"));\r
1591                         Assert ("#2", xmlReader.ReadToFollowing ("bar"));\r
1592                         AssertEquals ("#2-2", 2, xmlReader.Depth);\r
1593                         Assert ("#3", xmlReader.ReadToFollowing ("bar"));\r
1594                         AssertEquals ("#3-2", 3, xmlReader.Depth);\r
1595                         Assert ("#4", !xmlReader.ReadToFollowing ("bar"));\r
1596                 }\r
1597 \r
1598                 [Test]\r
1599                 [Category ("NotDotNet")]\r
1600                 public void ReadToNextSiblingAtInitialState ()\r
1601                 {\r
1602                         string xml = @"<root></root>";\r
1603                         RunTest (xml, new TestMethod (ReadToNextSiblingAtInitialState ));\r
1604                 }\r
1605 \r
1606                 void ReadToNextSiblingAtInitialState (XmlReader xmlReader)\r
1607                 {\r
1608                         Assert ("#1", !xmlReader.ReadToNextSibling ("bar"));\r
1609                         Assert ("#2", !xmlReader.ReadToNextSibling ("root"));\r
1610                 }\r
1611 \r
1612                 [Test]\r
1613                 public void ReadToNextSibling ()\r
1614                 {\r
1615                         string xml = @"<root><foo/><bar attr='value'/><foo><pooh/><bar></bar><foo></foo><bar/></foo></root>";\r
1616                         RunTest (xml, new TestMethod (ReadToNextSibling));\r
1617                 }\r
1618 \r
1619                 void ReadToNextSibling (XmlReader xmlReader)\r
1620                 {\r
1621                         // It is funky, but without it MS.NET results in an infinite loop.\r
1622                         xmlReader.Read (); // root\r
1623 \r
1624                         xmlReader.Read (); // foo\r
1625                         Assert ("#3", xmlReader.ReadToNextSibling ("bar"));\r
1626 \r
1627                         AssertEquals ("#3-2", "value", xmlReader.GetAttribute ("attr"));\r
1628                         xmlReader.Read (); // foo\r
1629                         xmlReader.Read (); // pooh\r
1630                         Assert ("#4", xmlReader.ReadToNextSibling ("bar"));\r
1631                         Assert ("#4-2", !xmlReader.IsEmptyElement);\r
1632                         Assert ("#5", xmlReader.ReadToNextSibling ("bar"));\r
1633                         Assert ("#5-2", xmlReader.IsEmptyElement);\r
1634                         Assert ("#6", xmlReader.Read ()); // /foo\r
1635 \r
1636                         AssertNodeValues ("#7", xmlReader,\r
1637                                 XmlNodeType.EndElement,\r
1638                                 1,              // Depth\r
1639                                 false,          // IsEmptyElement\r
1640                                 "foo",          // Name\r
1641                                 String.Empty,   // Prefix\r
1642                                 "foo",          // LocalName\r
1643                                 String.Empty,   // NamespaceURI\r
1644                                 String.Empty,   // Value\r
1645                                 false,          // HasValue\r
1646                                 0,              // AttributeCount\r
1647                                 false);         // HasAttributes\r
1648                 }\r
1649 \r
1650                 [Test]\r
1651                 public void ReadSubtree ()\r
1652                 {\r
1653                         string xml = @"<root><foo/><bar attr='value'></bar></root>";\r
1654                         RunTest (xml, new TestMethod (ReadSubtree));\r
1655                 }\r
1656 \r
1657                 void ReadSubtree (XmlReader reader)\r
1658                 {\r
1659                         reader.MoveToContent (); // root\r
1660                         reader.Read (); // foo\r
1661                         XmlReader st = reader.ReadSubtree (); // <foo/>\r
1662 \r
1663                         // MS bug: IsEmptyElement should be false here.\r
1664                         /*\r
1665                         AssertNodeValues ("#1", st,\r
1666                                 XmlNodeType.None,\r
1667                                 0,              // Depth\r
1668                                 false,          // IsEmptyElement\r
1669                                 String.Empty,   // Name\r
1670                                 String.Empty,   // Prefix\r
1671                                 String.Empty,   // LocalName\r
1672                                 String.Empty,   // NamespaceURI\r
1673                                 String.Empty,   // Value\r
1674                                 false,          // HasValue\r
1675                                 0,              // AttributeCount\r
1676                                 false);         // HasAttributes\r
1677                         */\r
1678                         AssertEquals ("#1", XmlNodeType.None, st.NodeType);\r
1679 \r
1680                         st.Read ();\r
1681                         AssertNodeValues ("#2", st,\r
1682                                 XmlNodeType.Element,\r
1683                                 0,\r
1684                                 true,           // IsEmptyElement\r
1685                                 "foo",          // Name\r
1686                                 String.Empty,   // Prefix\r
1687                                 "foo",          // LocalName\r
1688                                 String.Empty,   // NamespaceURI\r
1689                                 String.Empty,   // Value\r
1690                                 false,          // HasValue\r
1691                                 0,              // AttributeCount\r
1692                                 false);         // HasAttributes\r
1693 \r
1694                         Assert ("#3", !st.Read ());\r
1695 \r
1696                         // At this state, reader is not positioned on <bar> yet\r
1697                         AssertNodeValues ("#3-2", reader,\r
1698                                 XmlNodeType.Element,\r
1699                                 1,              // Depth. It is 1 for main tree.\r
1700                                 true,           // IsEmptyElement\r
1701                                 "foo",          // Name\r
1702                                 String.Empty,   // Prefix\r
1703                                 "foo",          // LocalName\r
1704                                 String.Empty,   // NamespaceURI\r
1705                                 String.Empty,   // Value\r
1706                                 false,          // HasValue\r
1707                                 0,              // AttributeCount\r
1708                                 false);         // HasAttributes\r
1709 \r
1710                         reader.Read ();\r
1711 \r
1712                         AssertNodeValues ("#4", reader,\r
1713                                 XmlNodeType.Element,\r
1714                                 1,              // Depth. It is 1 for main tree.\r
1715                                 false,          // IsEmptyElement\r
1716                                 "bar",          // Name\r
1717                                 String.Empty,   // Prefix\r
1718                                 "bar",          // LocalName\r
1719                                 String.Empty,   // NamespaceURI\r
1720                                 String.Empty,   // Value\r
1721                                 false,          // HasValue\r
1722                                 1,              // AttributeCount\r
1723                                 true);          // HasAttributes\r
1724 \r
1725                         st = reader.ReadSubtree ();\r
1726                         st.Read (); // Initial -> Interactive\r
1727                         AssertNodeValues ("#5", st,\r
1728                                 XmlNodeType.Element,\r
1729                                 0,              // Depth. It is 0 for subtree.\r
1730                                 false,          // IsEmptyElement\r
1731                                 "bar",          // Name\r
1732                                 String.Empty,   // Prefix\r
1733                                 "bar",          // LocalName\r
1734                                 String.Empty,   // NamespaceURI\r
1735                                 String.Empty,   // Value\r
1736                                 false,          // HasValue\r
1737                                 1,              // AttributeCount\r
1738                                 true);          // HasAttributes\r
1739 \r
1740                         st.Read ();\r
1741                         AssertNodeValues ("#6-1", st,\r
1742                                 XmlNodeType.EndElement,\r
1743                                 0,              // Depth. It is 0 for subtree.\r
1744                                 false,          // IsEmptyElement\r
1745                                 "bar",          // Name\r
1746                                 String.Empty,   // Prefix\r
1747                                 "bar",          // LocalName\r
1748                                 String.Empty,   // NamespaceURI\r
1749                                 String.Empty,   // Value\r
1750                                 false,          // HasValue\r
1751                                 0,              // AttributeCount\r
1752                                 false);         // HasAttributes\r
1753 \r
1754                         AssertNodeValues ("#6-2", st,\r
1755                                 XmlNodeType.EndElement,\r
1756                                 0,              // Depth. It is 0 for subtree.\r
1757                                 false,          // IsEmptyElement\r
1758                                 "bar",          // Name\r
1759                                 String.Empty,   // Prefix\r
1760                                 "bar",          // LocalName\r
1761                                 String.Empty,   // NamespaceURI\r
1762                                 String.Empty,   // Value\r
1763                                 false,          // HasValue\r
1764                                 0,              // AttributeCount\r
1765                                 false);         // HasAttributes\r
1766 \r
1767                         Assert ("#7", !st.Read ());\r
1768                 }\r
1769 \r
1770                 [Test]\r
1771                 public void ReadInteger ()\r
1772                 {\r
1773                         string xml1 = "<root>1</root>";\r
1774                         XmlReader xr;\r
1775                         \r
1776                         xr = XmlReader.Create (new StringReader (xml1));\r
1777                         xr.Read ();\r
1778                         AssertEquals ("#1", "1", xr.ReadElementContentAsString ());\r
1779 \r
1780                         AssertNodeValues ("#1-2", xr,\r
1781                                 XmlNodeType.None,\r
1782                                 0,              // Depth. It is 0 for subtree.\r
1783                                 false,          // IsEmptyElement\r
1784                                 String.Empty,   // Name\r
1785                                 String.Empty,   // Prefix\r
1786                                 String.Empty,   // LocalName\r
1787                                 String.Empty,   // NamespaceURI\r
1788                                 String.Empty,   // Value\r
1789                                 false,          // HasValue\r
1790                                 0,              // AttributeCount\r
1791                                 false);         // HasAttributes\r
1792 \r
1793                         xr = XmlReader.Create (new StringReader (xml1));\r
1794                         xr.Read ();\r
1795                         // this XmlReader has no schema, thus the value is untyped\r
1796                         AssertEquals ("#2", "1", xr.ReadElementContentAsObject ());\r
1797 \r
1798                         xr = XmlReader.Create (new StringReader (xml1));\r
1799                         xr.Read ();\r
1800                         xr.Read ();\r
1801                         AssertEquals ("#3", "1", xr.ReadContentAsString ());\r
1802 \r
1803                         xr = XmlReader.Create (new StringReader (xml1));\r
1804                         xr.Read ();\r
1805                         AssertEquals ("#4", 1, xr.ReadElementContentAsInt ());\r
1806 \r
1807                         xr = XmlReader.Create (new StringReader (xml1));\r
1808                         xr.Read ();\r
1809                         AssertEquals ("#5", 1, xr.ReadElementContentAs (typeof (int), null));\r
1810                 }\r
1811 \r
1812                 [Test]\r
1813                 [ExpectedException (typeof (XmlException))]\r
1814                 public void ReadContentAsIntFail ()\r
1815                 {\r
1816                         XmlReader xr = XmlReader.Create (\r
1817                                 new StringReader ("<doc>1.0</doc>"));\r
1818                         xr.Read ();\r
1819                         xr.ReadElementContentAsInt ();\r
1820                 }\r
1821 \r
1822                 [Test]\r
1823                 public void ReadDateTime ()\r
1824                 {\r
1825                         DateTime time = new DateTime (2006, 1, 2, 3, 4, 56);\r
1826                         string xml1 = "<root>2006-01-02T03:04:56</root>";\r
1827                         XmlReader xr;\r
1828 \r
1829                         xr = XmlReader.Create (new StringReader (xml1));\r
1830                         xr.Read ();\r
1831                         // this XmlReader has no schema, thus the value is untyped\r
1832                         AssertEquals ("#1", "2006-01-02T03:04:56",\r
1833                                 xr.ReadElementContentAsString ());\r
1834 \r
1835                         xr = XmlReader.Create (new StringReader (xml1));\r
1836                         xr.Read ();\r
1837                         xr.Read ();\r
1838                         AssertEquals ("#2", time, xr.ReadContentAsDateTime ());\r
1839 \r
1840                         xr = XmlReader.Create (new StringReader (xml1));\r
1841                         xr.Read ();\r
1842                         AssertEquals ("#3", time, xr.ReadElementContentAsDateTime ());\r
1843 \r
1844                         xr = XmlReader.Create (new StringReader (xml1));\r
1845                         xr.Read ();\r
1846                         AssertEquals ("#4", time, xr.ReadElementContentAs (typeof (DateTime), null));\r
1847                 }\r
1848 \r
1849                 [Test]\r
1850                 [ExpectedException (typeof (XmlException))]\r
1851                 public void ReadContentAsDateTimeFail ()\r
1852                 {\r
1853                         XmlReader xr = XmlReader.Create (\r
1854                                 new StringReader ("<doc>P1Y2M3D</doc>"));\r
1855                         xr.Read ();\r
1856                         xr.ReadElementContentAsDateTime ();\r
1857                 }\r
1858 \r
1859                 [Test]\r
1860                 public void ReadContentAs_QNameEmptyNSResolver ()\r
1861                 {\r
1862                         XmlReader xr = XmlReader.Create (\r
1863                                 new StringReader ("<doc xmlns:x='urn:foo'>x:el</doc>"));\r
1864                         xr.Read ();\r
1865                         object o = xr.ReadElementContentAs (\r
1866                                 typeof (XmlQualifiedName), null);\r
1867                         // without IXmlNamespaceResolver, it still resolves\r
1868                         // x:el as valid QName.\r
1869                         AssertNotNull ("#1", o);\r
1870                         XmlQualifiedName q = o as XmlQualifiedName;\r
1871                         AssertEquals ("#2 : " + o.GetType (),\r
1872                                 new XmlQualifiedName ("el", "urn:foo"), q);\r
1873                 }\r
1874 \r
1875                 [Test]\r
1876                 [ExpectedException (typeof (InvalidOperationException))]\r
1877                 public void ReadContentStringOnElementFail ()\r
1878                 {\r
1879                         XmlReader xr = XmlReader.Create (new StringReader ("<a>test</a>"));\r
1880                         xr.Read ();\r
1881                         xr.ReadContentAsString ();\r
1882                 }\r
1883 \r
1884                 [Test]\r
1885                 [ExpectedException (typeof (XmlException))]\r
1886                 public void ReadElementContentStringMixedContent ()\r
1887                 {\r
1888                         XmlReader xr = XmlReader.Create (\r
1889                                 new StringReader ("<doc>123<child>456</child>789</doc>"));\r
1890                         xr.Read ();\r
1891                         // "child" is regarded as an invalid node.\r
1892                         string s = xr.ReadElementContentAsString ();\r
1893                 }\r
1894 \r
1895                 [Test]\r
1896                 public void ReadContentStringMixedContent ()\r
1897                 {\r
1898                         XmlReader xr = XmlReader.Create (\r
1899                                 new StringReader ("<doc>123<child>456</child>789</doc>"));\r
1900                         xr.Read ();\r
1901                         xr.Read (); // from Text "123"\r
1902                         string s = xr.ReadContentAsString ();\r
1903                         AssertEquals ("#1", "123", s);\r
1904                         AssertEquals ("#2", XmlNodeType.Element, xr.NodeType);\r
1905                 }\r
1906 \r
1907                 [Test]\r
1908                 public void ReadElementContentAsString ()\r
1909                 {\r
1910                         XmlTextReader r = new XmlTextReader (\r
1911                                 "<root/>", XmlNodeType.Document, null);\r
1912                         r.Read ();\r
1913                         AssertEquals ("#1",\r
1914                                 String.Empty, r.ReadElementContentAsString ());\r
1915                         AssertEquals ("#2",\r
1916                                 XmlNodeType.None, r.NodeType);\r
1917                 }\r
1918 \r
1919                 [Test]\r
1920                 public void ReadElementContentAs ()\r
1921                 {\r
1922                         // as System.Object\r
1923 \r
1924                         XmlTextReader r = new XmlTextReader (\r
1925                                 "<root/>", XmlNodeType.Document, null);\r
1926                         r.Read ();\r
1927                         AssertEquals ("#1",\r
1928                                 String.Empty, r.ReadElementContentAs (typeof (object), null));\r
1929                         AssertEquals ("#2",\r
1930                                 XmlNodeType.None, r.NodeType);\r
1931 \r
1932                         // regardless of its value, the return value is string.\r
1933                         r = new XmlTextReader ("<root>1</root>", XmlNodeType.Document, null);\r
1934                         r.Read ();\r
1935                         AssertEquals ("#3",\r
1936                                 "1", r.ReadElementContentAs (typeof (object), null));\r
1937                         AssertEquals ("#4",\r
1938                                 XmlNodeType.None, r.NodeType);\r
1939                 }\r
1940 \r
1941                 [Test]\r
1942                 public void ReadContentStringOnAttribute ()\r
1943                 {\r
1944                         string xml = @"<root id='myId'><child /></root>";\r
1945                         RunTest (xml, new TestMethod (ReadContentStringOnAttribute));\r
1946                 }\r
1947 \r
1948                 void ReadContentStringOnAttribute (XmlReader reader)\r
1949                 {\r
1950                         reader.Read ();\r
1951                         Assert (reader.MoveToAttribute ("id"));\r
1952                         AssertEquals ("myId", reader.ReadContentAsString ());\r
1953                 }\r
1954 #endif\r
1955         }\r
1956 }\r