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                 [Test]\r
1500                 public void ReadClosedReader ()\r
1501                 {\r
1502                         string xml = "<fin>aaa</fin>";\r
1503                         RunTest (xml, new TestMethod (ReadClosedReader));\r
1504                 }\r
1505 \r
1506                 void ReadClosedReader (XmlReader reader)\r
1507                 {\r
1508                         reader.Read ();\r
1509                         reader.Close();\r
1510                         reader.Read (); // silently returns false\r
1511                 }\r
1512 \r
1513 #if NET_2_0\r
1514                 [Test]\r
1515                 public void CreateSimple ()\r
1516                 {\r
1517                         XmlReaderSettings s = new XmlReaderSettings ();\r
1518                         s.ProhibitDtd = false;\r
1519                         XmlReader xr = XmlReader.Create ("Test/XmlFiles/nested-dtd-test.xml", s);\r
1520                         xr.Read ();\r
1521                         AssertEquals ("#1", XmlNodeType.DocumentType, xr.NodeType);\r
1522                         xr.Read ();\r
1523                         AssertEquals ("#2", XmlNodeType.Whitespace, xr.NodeType);\r
1524                         xr.Read ();\r
1525                         AssertEquals ("#3", XmlNodeType.Element, xr.NodeType);\r
1526                 }\r
1527 \r
1528                 [Test]\r
1529                 [ExpectedException (typeof (XmlException))]\r
1530                 public void CreateSimpleProhibitDtd ()\r
1531                 {\r
1532                         XmlReader xr = XmlReader.Create ("Test/XmlFiles/nested-dtd-test.xml");\r
1533                         xr.Read ();\r
1534                 }\r
1535 \r
1536                 [Test]\r
1537                 // a bit revised version of bug #78706\r
1538                 public void CreateFromUrlClose ()\r
1539                 {\r
1540                         string file = "Test/XmlFiles/78706.xml";\r
1541                         try {\r
1542                                 if (!File.Exists (file))\r
1543                                         File.Create (file).Close ();\r
1544                                 XmlReaderSettings s = new XmlReaderSettings ();\r
1545                                 s.CloseInput = false; // explicitly\r
1546                                 XmlReader r = XmlReader.Create (file, s);\r
1547                                 r.Close ();\r
1548                                 XmlTextWriter w = new XmlTextWriter (file, null);\r
1549                                 w.Close ();\r
1550                         } finally {\r
1551                                 if (File.Exists (file))\r
1552                                         File.Delete (file);\r
1553                         }\r
1554                 }\r
1555 \r
1556                 [Test]\r
1557                 // a bit revised version of bug #385638\r
1558                 public void CreateFromUrlClose2 ()\r
1559                 {\r
1560                         string file = "Test/XmlFiles/385638.xml";\r
1561                         try {\r
1562                                 if (File.Exists (file))\r
1563                                         File.Delete (file);\r
1564                                 using (TextWriter tw = File.CreateText (file))\r
1565                                         tw.Write ("<xml />");\r
1566                                 XmlReaderSettings s = new XmlReaderSettings ();\r
1567                                 s.IgnoreWhitespace = true; // this results in XmlFilterReader, which is the key for this bug.\r
1568                                 XmlReader r = XmlReader.Create (file, s);\r
1569                                 r.Close ();\r
1570                                 XmlTextWriter w = new XmlTextWriter (file, null);\r
1571                                 w.Close ();\r
1572                         } finally {\r
1573                                 if (File.Exists (file))\r
1574                                         File.Delete (file);\r
1575                         }\r
1576                 }\r
1577 \r
1578                 [Test]\r
1579                 public void ReadToDescendant ()\r
1580                 {\r
1581                         string xml = @"<root><foo/><bar/><foo> test text <bar><bar></bar></bar></foo></root>";\r
1582                         RunTest (xml, new TestMethod (ReadToDescendant));\r
1583                 }\r
1584 \r
1585                 void ReadToDescendant (XmlReader xmlReader)\r
1586                 {\r
1587                         // move to first <bar/>\r
1588                         Assert ("#1", xmlReader.ReadToDescendant ("bar"));\r
1589                         // no children in <bar/>. It is empty.\r
1590                         Assert ("#2", !xmlReader.ReadToDescendant ("bar"));\r
1591                         AssertEquals ("#2-2", "bar", xmlReader.Name);\r
1592 \r
1593                         // move to the second <foo>\r
1594                         xmlReader.Read ();\r
1595                         // move to the second <bar>\r
1596                         Assert ("#3", xmlReader.ReadToDescendant ("bar"));\r
1597                         // move to <bar> inside <bar>...</bar>\r
1598                         Assert ("#4", xmlReader.ReadToDescendant ("bar"));\r
1599                         // the next is EndElement of </bar>, so no move.\r
1600                         Assert ("#5", !xmlReader.ReadToDescendant ("bar"));\r
1601                         AssertEquals ("#5-2", XmlNodeType.EndElement, xmlReader.NodeType);\r
1602                 }\r
1603 \r
1604                 [Test]\r
1605                 public void ReadToDescepdant2 ()\r
1606                 {\r
1607                         string xml = "<root/>";\r
1608                         RunTest (xml, new TestMethod (ReadToDescendant2));\r
1609                 }\r
1610 \r
1611                 void ReadToDescendant2 (XmlReader xmlReader)\r
1612                 {\r
1613                         // make sure that it works when the reader is at Initial state.\r
1614                         Assert (xmlReader.ReadToDescendant ("root"));\r
1615                 }\r
1616 \r
1617                 [Test]\r
1618                 public void ReadToFollowing ()\r
1619                 {\r
1620                         string xml = @"<root><foo/><bar/><foo><bar><bar></bar></bar></foo></root>";\r
1621                         RunTest (xml, new TestMethod (ReadToFollowing));\r
1622                 }\r
1623 \r
1624                 public void ReadToFollowing (XmlReader xmlReader)\r
1625                 {\r
1626                         Assert ("#1", xmlReader.ReadToFollowing ("bar"));\r
1627                         Assert ("#2", xmlReader.ReadToFollowing ("bar"));\r
1628                         AssertEquals ("#2-2", 2, xmlReader.Depth);\r
1629                         Assert ("#3", xmlReader.ReadToFollowing ("bar"));\r
1630                         AssertEquals ("#3-2", 3, xmlReader.Depth);\r
1631                         Assert ("#4", !xmlReader.ReadToFollowing ("bar"));\r
1632                 }\r
1633 \r
1634                 [Test]\r
1635                 [Category ("NotDotNet")]\r
1636                 public void ReadToNextSiblingAtInitialState ()\r
1637                 {\r
1638                         string xml = @"<root></root>";\r
1639                         RunTest (xml, new TestMethod (ReadToNextSiblingAtInitialState ));\r
1640                 }\r
1641 \r
1642                 void ReadToNextSiblingAtInitialState (XmlReader xmlReader)\r
1643                 {\r
1644                         Assert ("#1", !xmlReader.ReadToNextSibling ("bar"));\r
1645                         Assert ("#2", !xmlReader.ReadToNextSibling ("root"));\r
1646                 }\r
1647 \r
1648                 [Test]\r
1649                 public void ReadToNextSibling ()\r
1650                 {\r
1651                         string xml = @"<root><foo/><bar attr='value'/><foo><pooh/><bar></bar><foo></foo><bar/></foo></root>";\r
1652                         RunTest (xml, new TestMethod (ReadToNextSibling));\r
1653                 }\r
1654 \r
1655                 void ReadToNextSibling (XmlReader xmlReader)\r
1656                 {\r
1657                         // It is funky, but without it MS.NET results in an infinite loop.\r
1658                         xmlReader.Read (); // root\r
1659 \r
1660                         xmlReader.Read (); // foo\r
1661                         Assert ("#3", xmlReader.ReadToNextSibling ("bar"));\r
1662 \r
1663                         AssertEquals ("#3-2", "value", xmlReader.GetAttribute ("attr"));\r
1664                         xmlReader.Read (); // foo\r
1665                         xmlReader.Read (); // pooh\r
1666                         Assert ("#4", xmlReader.ReadToNextSibling ("bar"));\r
1667                         Assert ("#4-2", !xmlReader.IsEmptyElement);\r
1668                         Assert ("#5", xmlReader.ReadToNextSibling ("bar"));\r
1669                         Assert ("#5-2", xmlReader.IsEmptyElement);\r
1670                         Assert ("#6", xmlReader.Read ()); // /foo\r
1671 \r
1672                         AssertNodeValues ("#7", xmlReader,\r
1673                                 XmlNodeType.EndElement,\r
1674                                 1,              // Depth\r
1675                                 false,          // IsEmptyElement\r
1676                                 "foo",          // Name\r
1677                                 String.Empty,   // Prefix\r
1678                                 "foo",          // LocalName\r
1679                                 String.Empty,   // NamespaceURI\r
1680                                 String.Empty,   // Value\r
1681                                 false,          // HasValue\r
1682                                 0,              // AttributeCount\r
1683                                 false);         // HasAttributes\r
1684                 }\r
1685 \r
1686                 // bug #81451\r
1687                 [Test]\r
1688                 public void ReadToNextSibling2 ()\r
1689                 {\r
1690                         string xml = @"<root><baz><bar><foo attr='value'/></bar><foo attr='value2'><bar><foo /></bar></foo></baz></root>";\r
1691                         RunTest (xml, new TestMethod (ReadToNextSibling2));\r
1692                 }\r
1693 \r
1694                 void ReadToNextSibling2 (XmlReader r)\r
1695                 {\r
1696                         r.MoveToContent (); // ->root\r
1697                         r.Read (); // root->baz\r
1698                         r.Read (); // baz->bar\r
1699                         Assert ("#1", r.ReadToNextSibling ("foo"));\r
1700                         AssertEquals ("#2", "value2", r.GetAttribute ("attr"));\r
1701                         r.Read (); // foo[@value='value2']->bar\r
1702                         Assert ("#3", !r.ReadToNextSibling ("foo"));\r
1703                         AssertEquals ("#4", XmlNodeType.EndElement, r.NodeType);\r
1704                         AssertEquals ("#5", "foo", r.LocalName);\r
1705                 }\r
1706 \r
1707                 // bug #347768\r
1708                 [Test]\r
1709                 public void ReadToNextSibling3 ()\r
1710                 {\r
1711                         string xml = @" <books> <book> <name>Happy C Sharp</name> </book> </books>";\r
1712                         XmlReader reader = XmlReader.Create (new StringReader (xml));\r
1713 \r
1714                         reader.MoveToContent ();\r
1715 \r
1716                         while (reader.Read ())\r
1717                                 reader.ReadToNextSibling ("book"); // should not result in an infinite loop\r
1718                 }\r
1719 \r
1720                 [Test]\r
1721                 public void ReadSubtree ()\r
1722                 {\r
1723                         string xml = @"<root><foo/><bar attr='value'></bar></root>";\r
1724                         RunTest (xml, new TestMethod (ReadSubtree));\r
1725                 }\r
1726 \r
1727                 void ReadSubtree (XmlReader reader)\r
1728                 {\r
1729                         reader.MoveToContent (); // root\r
1730                         reader.Read (); // foo\r
1731                         XmlReader st = reader.ReadSubtree (); // <foo/>\r
1732 \r
1733                         // MS bug: IsEmptyElement should be false here.\r
1734                         /*\r
1735                         AssertNodeValues ("#1", st,\r
1736                                 XmlNodeType.None,\r
1737                                 0,              // Depth\r
1738                                 false,          // IsEmptyElement\r
1739                                 String.Empty,   // Name\r
1740                                 String.Empty,   // Prefix\r
1741                                 String.Empty,   // LocalName\r
1742                                 String.Empty,   // NamespaceURI\r
1743                                 String.Empty,   // Value\r
1744                                 false,          // HasValue\r
1745                                 0,              // AttributeCount\r
1746                                 false);         // HasAttributes\r
1747                         */\r
1748                         AssertEquals ("#1", XmlNodeType.None, st.NodeType);\r
1749 \r
1750                         st.Read ();\r
1751                         AssertNodeValues ("#2", st,\r
1752                                 XmlNodeType.Element,\r
1753                                 0,\r
1754                                 true,           // IsEmptyElement\r
1755                                 "foo",          // Name\r
1756                                 String.Empty,   // Prefix\r
1757                                 "foo",          // LocalName\r
1758                                 String.Empty,   // NamespaceURI\r
1759                                 String.Empty,   // Value\r
1760                                 false,          // HasValue\r
1761                                 0,              // AttributeCount\r
1762                                 false);         // HasAttributes\r
1763 \r
1764                         Assert ("#3", !st.Read ());\r
1765 \r
1766                         // At this state, reader is not positioned on <bar> yet\r
1767                         AssertNodeValues ("#3-2", reader,\r
1768                                 XmlNodeType.Element,\r
1769                                 1,              // Depth. It is 1 for main tree.\r
1770                                 true,           // IsEmptyElement\r
1771                                 "foo",          // Name\r
1772                                 String.Empty,   // Prefix\r
1773                                 "foo",          // LocalName\r
1774                                 String.Empty,   // NamespaceURI\r
1775                                 String.Empty,   // Value\r
1776                                 false,          // HasValue\r
1777                                 0,              // AttributeCount\r
1778                                 false);         // HasAttributes\r
1779 \r
1780                         reader.Read ();\r
1781 \r
1782                         AssertNodeValues ("#4", reader,\r
1783                                 XmlNodeType.Element,\r
1784                                 1,              // Depth. It is 1 for main tree.\r
1785                                 false,          // IsEmptyElement\r
1786                                 "bar",          // Name\r
1787                                 String.Empty,   // Prefix\r
1788                                 "bar",          // LocalName\r
1789                                 String.Empty,   // NamespaceURI\r
1790                                 String.Empty,   // Value\r
1791                                 false,          // HasValue\r
1792                                 1,              // AttributeCount\r
1793                                 true);          // HasAttributes\r
1794 \r
1795                         st = reader.ReadSubtree ();\r
1796                         st.Read (); // Initial -> Interactive\r
1797                         AssertNodeValues ("#5", st,\r
1798                                 XmlNodeType.Element,\r
1799                                 0,              // Depth. It is 0 for subtree.\r
1800                                 false,          // IsEmptyElement\r
1801                                 "bar",          // Name\r
1802                                 String.Empty,   // Prefix\r
1803                                 "bar",          // LocalName\r
1804                                 String.Empty,   // NamespaceURI\r
1805                                 String.Empty,   // Value\r
1806                                 false,          // HasValue\r
1807                                 1,              // AttributeCount\r
1808                                 true);          // HasAttributes\r
1809 \r
1810                         st.Read ();\r
1811                         AssertNodeValues ("#6-1", st,\r
1812                                 XmlNodeType.EndElement,\r
1813                                 0,              // Depth. It is 0 for subtree.\r
1814                                 false,          // IsEmptyElement\r
1815                                 "bar",          // Name\r
1816                                 String.Empty,   // Prefix\r
1817                                 "bar",          // LocalName\r
1818                                 String.Empty,   // NamespaceURI\r
1819                                 String.Empty,   // Value\r
1820                                 false,          // HasValue\r
1821                                 0,              // AttributeCount\r
1822                                 false);         // HasAttributes\r
1823 \r
1824                         AssertNodeValues ("#6-2", st,\r
1825                                 XmlNodeType.EndElement,\r
1826                                 0,              // Depth. It is 0 for subtree.\r
1827                                 false,          // IsEmptyElement\r
1828                                 "bar",          // Name\r
1829                                 String.Empty,   // Prefix\r
1830                                 "bar",          // LocalName\r
1831                                 String.Empty,   // NamespaceURI\r
1832                                 String.Empty,   // Value\r
1833                                 false,          // HasValue\r
1834                                 0,              // AttributeCount\r
1835                                 false);         // HasAttributes\r
1836 \r
1837                         Assert ("#7", !st.Read ());\r
1838                 }\r
1839 \r
1840                 [Test]\r
1841                 public void ReadInteger ()\r
1842                 {\r
1843                         string xml1 = "<root>1</root>";\r
1844                         XmlReader xr;\r
1845                         \r
1846                         xr = XmlReader.Create (new StringReader (xml1));\r
1847                         xr.Read ();\r
1848                         AssertEquals ("#1", "1", xr.ReadElementContentAsString ());\r
1849 \r
1850                         AssertNodeValues ("#1-2", xr,\r
1851                                 XmlNodeType.None,\r
1852                                 0,              // Depth. It is 0 for subtree.\r
1853                                 false,          // IsEmptyElement\r
1854                                 String.Empty,   // Name\r
1855                                 String.Empty,   // Prefix\r
1856                                 String.Empty,   // LocalName\r
1857                                 String.Empty,   // NamespaceURI\r
1858                                 String.Empty,   // Value\r
1859                                 false,          // HasValue\r
1860                                 0,              // AttributeCount\r
1861                                 false);         // HasAttributes\r
1862 \r
1863                         xr = XmlReader.Create (new StringReader (xml1));\r
1864                         xr.Read ();\r
1865                         // this XmlReader has no schema, thus the value is untyped\r
1866                         AssertEquals ("#2", "1", xr.ReadElementContentAsObject ());\r
1867 \r
1868                         xr = XmlReader.Create (new StringReader (xml1));\r
1869                         xr.Read ();\r
1870                         xr.Read ();\r
1871                         AssertEquals ("#3", "1", xr.ReadContentAsString ());\r
1872 \r
1873                         xr = XmlReader.Create (new StringReader (xml1));\r
1874                         xr.Read ();\r
1875                         AssertEquals ("#4", 1, xr.ReadElementContentAsInt ());\r
1876 \r
1877                         xr = XmlReader.Create (new StringReader (xml1));\r
1878                         xr.Read ();\r
1879                         AssertEquals ("#5", 1, xr.ReadElementContentAs (typeof (int), null));\r
1880                 }\r
1881 \r
1882                 [Test]\r
1883                 [ExpectedException (typeof (XmlException))]\r
1884                 public void ReadContentAsIntFail ()\r
1885                 {\r
1886                         XmlReader xr = XmlReader.Create (\r
1887                                 new StringReader ("<doc>1.0</doc>"));\r
1888                         xr.Read ();\r
1889                         xr.ReadElementContentAsInt ();\r
1890                 }\r
1891 \r
1892                 [Test]\r
1893                 public void ReadDateTime ()\r
1894                 {\r
1895                         DateTime time = new DateTime (2006, 1, 2, 3, 4, 56);\r
1896                         string xml1 = "<root>2006-01-02T03:04:56</root>";\r
1897                         XmlReader xr;\r
1898 \r
1899                         xr = XmlReader.Create (new StringReader (xml1));\r
1900                         xr.Read ();\r
1901                         // this XmlReader has no schema, thus the value is untyped\r
1902                         AssertEquals ("#1", "2006-01-02T03:04:56",\r
1903                                 xr.ReadElementContentAsString ());\r
1904 \r
1905                         xr = XmlReader.Create (new StringReader (xml1));\r
1906                         xr.Read ();\r
1907                         xr.Read ();\r
1908                         AssertEquals ("#2", time, xr.ReadContentAsDateTime ());\r
1909 \r
1910                         xr = XmlReader.Create (new StringReader (xml1));\r
1911                         xr.Read ();\r
1912                         AssertEquals ("#3", time, xr.ReadElementContentAsDateTime ());\r
1913 \r
1914                         xr = XmlReader.Create (new StringReader (xml1));\r
1915                         xr.Read ();\r
1916                         AssertEquals ("#4", time, xr.ReadElementContentAs (typeof (DateTime), null));\r
1917                 }\r
1918 \r
1919                 [Test]\r
1920                 [ExpectedException (typeof (XmlException))]\r
1921                 public void ReadContentAsDateTimeFail ()\r
1922                 {\r
1923                         XmlReader xr = XmlReader.Create (\r
1924                                 new StringReader ("<doc>P1Y2M3D</doc>"));\r
1925                         xr.Read ();\r
1926                         xr.ReadElementContentAsDateTime ();\r
1927                 }\r
1928 \r
1929                 [Test]\r
1930                 public void ReadContentAs_QNameEmptyNSResolver ()\r
1931                 {\r
1932                         XmlReader xr = XmlReader.Create (\r
1933                                 new StringReader ("<doc xmlns:x='urn:foo'>x:el</doc>"));\r
1934                         xr.Read ();\r
1935                         object o = xr.ReadElementContentAs (\r
1936                                 typeof (XmlQualifiedName), null);\r
1937                         // without IXmlNamespaceResolver, it still resolves\r
1938                         // x:el as valid QName.\r
1939                         AssertNotNull ("#1", o);\r
1940                         XmlQualifiedName q = o as XmlQualifiedName;\r
1941                         AssertEquals ("#2 : " + o.GetType (),\r
1942                                 new XmlQualifiedName ("el", "urn:foo"), q);\r
1943                 }\r
1944 \r
1945                 [Test]\r
1946                 [ExpectedException (typeof (InvalidOperationException))]\r
1947                 public void ReadContentStringOnElementFail ()\r
1948                 {\r
1949                         XmlReader xr = XmlReader.Create (new StringReader ("<a>test</a>"));\r
1950                         xr.Read ();\r
1951                         xr.ReadContentAsString ();\r
1952                 }\r
1953 \r
1954                 [Test]\r
1955                 [ExpectedException (typeof (XmlException))]\r
1956                 public void ReadElementContentStringMixedContent ()\r
1957                 {\r
1958                         XmlReader xr = XmlReader.Create (\r
1959                                 new StringReader ("<doc>123<child>456</child>789</doc>"));\r
1960                         xr.Read ();\r
1961                         // "child" is regarded as an invalid node.\r
1962                         string s = xr.ReadElementContentAsString ();\r
1963                 }\r
1964 \r
1965                 [Test]\r
1966                 public void ReadContentStringMixedContent ()\r
1967                 {\r
1968                         XmlReader xr = XmlReader.Create (\r
1969                                 new StringReader ("<doc>123<child>456</child>789</doc>"));\r
1970                         xr.Read ();\r
1971                         xr.Read (); // from Text "123"\r
1972                         string s = xr.ReadContentAsString ();\r
1973                         AssertEquals ("#1", "123", s);\r
1974                         AssertEquals ("#2", XmlNodeType.Element, xr.NodeType);\r
1975                 }\r
1976 \r
1977                 [Test]\r
1978                 public void ReadElementContentAsString ()\r
1979                 {\r
1980                         XmlTextReader r = new XmlTextReader (\r
1981                                 "<root/>", XmlNodeType.Document, null);\r
1982                         r.Read ();\r
1983                         AssertEquals ("#1",\r
1984                                 String.Empty, r.ReadElementContentAsString ());\r
1985                         AssertEquals ("#2",\r
1986                                 XmlNodeType.None, r.NodeType);\r
1987                 }\r
1988 \r
1989                 [Test]\r
1990                 public void ReadElementContentAs ()\r
1991                 {\r
1992                         // as System.Object\r
1993 \r
1994                         XmlTextReader r = new XmlTextReader (\r
1995                                 "<root/>", XmlNodeType.Document, null);\r
1996                         r.Read ();\r
1997                         AssertEquals ("#1",\r
1998                                 String.Empty, r.ReadElementContentAs (typeof (object), null));\r
1999                         AssertEquals ("#2",\r
2000                                 XmlNodeType.None, r.NodeType);\r
2001 \r
2002                         // regardless of its value, the return value is string.\r
2003                         r = new XmlTextReader ("<root>1</root>", XmlNodeType.Document, null);\r
2004                         r.Read ();\r
2005                         AssertEquals ("#3",\r
2006                                 "1", r.ReadElementContentAs (typeof (object), null));\r
2007                         AssertEquals ("#4",\r
2008                                 XmlNodeType.None, r.NodeType);\r
2009                 }\r
2010 \r
2011                 [Test]\r
2012                 public void ReadContentStringOnAttribute ()\r
2013                 {\r
2014                         string xml = @"<root id='myId'><child /></root>";\r
2015                         RunTest (xml, new TestMethod (ReadContentStringOnAttribute));\r
2016                 }\r
2017 \r
2018                 void ReadContentStringOnAttribute (XmlReader reader)\r
2019                 {\r
2020                         reader.Read ();\r
2021                         Assert (reader.MoveToAttribute ("id"));\r
2022                         AssertEquals ("myId", reader.ReadContentAsString ());\r
2023                 }\r
2024 \r
2025                 [Test]\r
2026                 public void ReadElementContentAsStringEmpty ()\r
2027                 {\r
2028                         string xml = "<root><sample/></root>";\r
2029                         RunTest (xml, new TestMethod (ReadElementContentAsStringEmpty));\r
2030                 }\r
2031 \r
2032                 void ReadElementContentAsStringEmpty (XmlReader reader)\r
2033                 {\r
2034                         reader.MoveToContent ();\r
2035                         reader.Read ();\r
2036                         AssertEquals (String.Empty, reader.ReadElementContentAsString ("sample", ""));\r
2037                         AssertEquals (XmlNodeType.EndElement, reader.NodeType);\r
2038                 }\r
2039 \r
2040                 [Test]\r
2041                 public void ReadSubtreeClose ()\r
2042                 {\r
2043                         // bug #334752\r
2044                         string xml = @"<root><item-list><item id='a'/><item id='b'/></item-list></root>";\r
2045                         RunTest (xml, new TestMethod (ReadSubtreeClose));\r
2046                 }\r
2047 \r
2048                 void ReadSubtreeClose (XmlReader reader)\r
2049                 {\r
2050                         reader.ReadToFollowing ("item-list");\r
2051                         XmlReader sub = reader.ReadSubtree ();\r
2052                         sub.ReadToDescendant ("item");\r
2053                         sub.Close ();\r
2054                         AssertEquals ("#1", XmlNodeType.EndElement, reader.NodeType);\r
2055                         AssertEquals ("#2", "item-list", reader.Name);\r
2056                 }\r
2057 #endif\r
2058         }\r
2059 }\r