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

   1 //\r
   2 // MonoTests.System.Xml.XmlValidatingReaderTests.cs\r
   3 //\r
   4 // Author:\r
   5 //      Atsushi Enomoto <ginga@kit.hi-ho.ne.jp>\r
   6 //\r
   7 // (C)2003 Atsushi Enomoto\r
   8 //\r
   9 using System;\r
  10 using System.IO;\r
  11 using System.Xml;\r
  12 using System.Xml.Schema;\r
  13 using NUnit.Framework;\r
  14 \r
  15 namespace MonoTests.System.Xml\r
  16 {\r
  17         [TestFixture]\r
  18         public class XmlValidatingReaderTests : Assertion\r
  19         {\r
  20                 public XmlValidatingReaderTests ()\r
  21                 {\r
  22                 }\r
  23 \r
  24                 XmlValidatingReader dvr;\r
  25 \r
  26                 private XmlValidatingReader PrepareXmlReader (string xml)\r
  27                 {\r
  28                         XmlReader reader = new XmlTextReader (xml, XmlNodeType.Document, null);\r
  29 //                      XmlDocument doc = new XmlDocument ();\r
  30 //                      doc.LoadXml (xml);\r
  31 //                      XmlReader reader = new XmlNodeReader (doc);\r
  32 \r
  33                         return new XmlValidatingReader (reader);\r
  34                 }\r
  35 \r
  36                 [Test]\r
  37                 public void TestSingleElement ()\r
  38                 {\r
  39                         string intSubset = "<!ELEMENT root EMPTY>";\r
  40                         string dtd = "<!DOCTYPE root [" + intSubset + "]>";\r
  41                         string xml = dtd + "<root />";\r
  42                         dvr = PrepareXmlReader (xml);\r
  43                         dvr.Read ();    // DTD\r
  44                         dvr.Read ();\r
  45 \r
  46                         xml = dtd + "<invalid />";\r
  47                         dvr = PrepareXmlReader (xml);\r
  48                         dvr.Read ();    // DTD\r
  49                         try {\r
  50                                 dvr.Read ();    // invalid element.\r
  51                                 Fail ("should be failed.");\r
  52                         } catch (XmlSchemaException) {\r
  53                         }\r
  54 \r
  55                         xml = dtd + "<root>invalid PCDATA.</root>";\r
  56                         dvr = PrepareXmlReader (xml);\r
  57                         dvr.Read ();    // DTD\r
  58                         dvr.Read ();    // root\r
  59                         try {\r
  60                                 dvr.Read ();    // invalid text\r
  61                                 Fail ("should be failed.");\r
  62                         } catch (XmlSchemaException) {\r
  63                         }\r
  64 \r
  65                         xml = dtd + "<root><invalid_child /></root>";\r
  66                         dvr = PrepareXmlReader (xml);\r
  67                         dvr.Read ();    // DTD\r
  68                         dvr.Read ();    // root\r
  69                         try {\r
  70                                 dvr.Read ();    // invalid child\r
  71                                 Fail ("should be failed.");\r
  72                         } catch (XmlSchemaException) {\r
  73                         }\r
  74                 }\r
  75 \r
  76                 [Test]\r
  77                 public void TestElementContent ()\r
  78                 {\r
  79                         string intSubset = "<!ELEMENT root (foo)><!ELEMENT foo EMPTY>";\r
  80                         string dtd = "<!DOCTYPE root [" + intSubset + "]>";\r
  81                         string xml = dtd + "<root />";\r
  82                         dvr = PrepareXmlReader (xml);\r
  83                         dvr.Read ();    // DTD\r
  84                         try {\r
  85                                 dvr.Read ();    // root: invalid end\r
  86                                 Fail ("should be failed.");\r
  87                         } catch (XmlSchemaException) {\r
  88                         }\r
  89 \r
  90                         xml = dtd + "<root>Test.</root>";\r
  91                         dvr = PrepareXmlReader (xml);\r
  92                         dvr.Read ();    // DTD\r
  93                         dvr.Read ();    // root\r
  94                         try {\r
  95                                 dvr.Read ();    // invalid end\r
  96                                 Fail ("should be failed.");\r
  97                         } catch (XmlSchemaException) {\r
  98                         }\r
  99 \r
 100                         xml = dtd + "<root><foo /></root>";\r
 101                         dvr = PrepareXmlReader (xml);\r
 102                         dvr.Read ();    // DTD\r
 103                         dvr.Read ();    // root\r
 104                         dvr.Read ();    // foo\r
 105 \r
 106                         xml = dtd + "<root><bar /></root>";\r
 107                         dvr = PrepareXmlReader (xml);\r
 108                         dvr.Read ();    // DTD\r
 109                         dvr.Read ();    // root\r
 110                         try {\r
 111                                 dvr.Read ();    // invalid element\r
 112                                 Fail ("should be failed.");\r
 113                         } catch (XmlSchemaException) {\r
 114                         }\r
 115                 }\r
 116 \r
 117                 [Test]\r
 118                 public void TestMixedContent ()\r
 119                 {\r
 120                         string intSubset = "<!ELEMENT root (#PCDATA | foo)*><!ELEMENT foo EMPTY>";\r
 121                         string dtd = "<!DOCTYPE root [" + intSubset + "]>";\r
 122                         string xml = dtd + "<root />";\r
 123                         dvr = PrepareXmlReader (xml);\r
 124                         dvr.Read ();    // DTD\r
 125                         dvr.Read ();    // root\r
 126                         dvr.Read ();    // end\r
 127 \r
 128                         xml = dtd + "<root>Test.</root>";\r
 129                         dvr = PrepareXmlReader (xml);\r
 130                         dvr.Read ();    // DTD\r
 131                         dvr.Read ();    // root\r
 132                         dvr.Read ();    // valid PCDATA\r
 133                         dvr.Read ();    // endelement root\r
 134 \r
 135                         xml = dtd + "<root><foo/>Test.<foo></foo></root>";\r
 136                         dvr = PrepareXmlReader (xml);\r
 137                         dvr.Read ();    // DTD\r
 138                         dvr.Read ();    // root\r
 139                         dvr.Read ();    // valid foo\r
 140                         dvr.Read ();    // valid #PCDATA\r
 141                         dvr.Read ();    // valid foo\r
 142                         dvr.Read ();    // valid endElement foo\r
 143                         dvr.Read ();    // valid endElement root\r
 144 \r
 145                         xml = dtd + "<root>Test.<bar /></root>";\r
 146                         dvr = PrepareXmlReader (xml);\r
 147                         dvr.Read ();    // DTD\r
 148                         dvr.Read ();    // root\r
 149                         dvr.Read ();    // valid #PCDATA\r
 150                         try {\r
 151                                 dvr.Read ();    // invalid element\r
 152                                 Fail ("should be failed.");\r
 153                         } catch (XmlSchemaException) {\r
 154                         }\r
 155                 }\r
 156 \r
 157                 [Test]\r
 158                 public void TestSequence ()\r
 159                 {\r
 160                         string intSubset = "<!ELEMENT root (foo, bar)><!ELEMENT foo EMPTY><!ELEMENT bar EMPTY>";\r
 161                         string dtd = "<!DOCTYPE root [" + intSubset + "]>";\r
 162                         string xml = dtd + "<root><foo/><bar/></root>";\r
 163                         dvr = PrepareXmlReader (xml);\r
 164                         dvr.Read ();    // DTD\r
 165                         dvr.Read ();    // root\r
 166                         dvr.Read ();    // foo\r
 167                         dvr.Read ();    // bar\r
 168                         dvr.Read ();    // end root\r
 169 \r
 170                         xml = dtd + "<root><foo/></root>";\r
 171                         dvr = PrepareXmlReader (xml);\r
 172                         dvr.Read ();    // DTD\r
 173                         dvr.Read ();    // root\r
 174                         dvr.Read ();    // foo\r
 175                         try {\r
 176                                 dvr.Read ();    // invalid end root\r
 177                                 Fail ("should be failed.");\r
 178                         } catch (XmlSchemaException) {\r
 179                         }\r
 180 \r
 181                         xml = dtd + "<root><bar/></root>";\r
 182                         dvr = PrepareXmlReader (xml);\r
 183                         dvr.Read ();    // DTD\r
 184                         dvr.Read ();    // root\r
 185                         try {\r
 186                                 dvr.Read ();    // invalid element bar\r
 187                                 Fail ("should be failed.");\r
 188                         } catch (XmlSchemaException) {\r
 189                         }\r
 190                 }\r
 191 \r
 192                 [Test]\r
 193                 public void TestChoice ()\r
 194                 {\r
 195                         string intSubset = "<!ELEMENT root (foo|bar)><!ELEMENT foo EMPTY><!ELEMENT bar EMPTY>";\r
 196                         string dtd = "<!DOCTYPE root [" + intSubset + "]>";\r
 197                         string xml = dtd + "<root><foo/><bar/></root>";\r
 198                         dvr = PrepareXmlReader (xml);\r
 199                         dvr.Read ();    // DTD\r
 200                         dvr.Read ();    // root\r
 201                         dvr.Read ();    // foo\r
 202                         try {\r
 203                                 dvr.Read ();    // invalid element bar\r
 204                                 Fail ("should be failed.");\r
 205                         } catch (XmlSchemaException) {\r
 206                         }\r
 207 \r
 208                         xml = dtd + "<root><foo/></root>";\r
 209                         dvr = PrepareXmlReader (xml);\r
 210                         dvr.Read ();    // DTD\r
 211                         dvr.Read ();    // root\r
 212                         dvr.Read ();    // foo\r
 213                         dvr.Read ();    // end root\r
 214 \r
 215                         xml = dtd + "<root><bar/></root>";\r
 216                         dvr = PrepareXmlReader (xml);\r
 217                         dvr.Read ();    // DTD\r
 218                         dvr.Read ();    // root\r
 219                         dvr.Read ();    // bar\r
 220                         dvr.Read ();    // end root\r
 221 \r
 222                         xml = dtd + "<root><foo/>text.<bar/></root>";\r
 223                         dvr = PrepareXmlReader (xml);\r
 224                         dvr.Read ();    // DTD\r
 225                         dvr.Read ();    // root\r
 226                         dvr.Read ();    // foo\r
 227                         try {\r
 228                                 dvr.Read ();    // invalid text\r
 229                                 Fail ("should be failed.");\r
 230                         } catch (XmlSchemaException) {\r
 231                         }\r
 232                 }\r
 233 \r
 234                 [Test]\r
 235                 public void TestAny ()\r
 236                 {\r
 237                         string intSubset = "<!ELEMENT root ANY><!ELEMENT foo EMPTY>";\r
 238                         string dtd = "<!DOCTYPE root [" + intSubset + "]>";\r
 239                         string xml = dtd + "<root />";\r
 240                         dvr = PrepareXmlReader (xml);\r
 241                         dvr.Read ();    // DTD\r
 242                         dvr.Read ();    // empty root.\r
 243                         dvr.Read ();    // end of document.\r
 244 \r
 245                         xml = dtd + "<root><foo/></root>";\r
 246                         dvr = PrepareXmlReader (xml);\r
 247                         dvr.Read ();    // DTD\r
 248                         dvr.Read ();    // root\r
 249                         dvr.Read ();    // foo\r
 250                         dvr.Read ();    // end root\r
 251 \r
 252                         xml = dtd + "<root><foo /><foo></foo><foo/></root>";\r
 253                         dvr = PrepareXmlReader (xml);\r
 254                         dvr.Read ();    // DTD\r
 255                         dvr.Read ();    // root\r
 256                         dvr.Read ();    // foo\r
 257                         dvr.Read ();    // foo\r
 258                         dvr.Read ();    // foo\r
 259                         dvr.Read ();    // end root\r
 260 \r
 261                         xml = dtd + "<root><bar /></root>";\r
 262                         dvr = PrepareXmlReader (xml);\r
 263                         dvr.Read ();    // DTD\r
 264                         dvr.Read ();    // root\r
 265                         try {\r
 266                                 dvr.Read ();    // bar: invalid (undeclared) element\r
 267                                 Fail ("should be failed.");\r
 268                         } catch (XmlSchemaException) {\r
 269                         }\r
 270                 }\r
 271 \r
 272                 [Test]\r
 273                 [Category ("NotDotNet")]\r
 274                 // MS fails to validate nondeterministic content validation.\r
 275                 public void TestNonDeterministicContent ()\r
 276                 {\r
 277                         string intSubset = "<!ELEMENT root ((foo, bar)|(foo,baz))><!ELEMENT foo EMPTY><!ELEMENT bar EMPTY><!ELEMENT baz EMPTY>";\r
 278                         string dtd = "<!DOCTYPE root [" + intSubset + "]>";\r
 279                         string xml = dtd + "<root><foo/><bar/></root>";\r
 280                         dvr = PrepareXmlReader (xml);\r
 281                         dvr.Read ();    // DTD\r
 282                         dvr.Read ();    // root\r
 283                         dvr.Read ();    // foo\r
 284                         dvr.Read ();    // bar\r
 285                         dvr.Read ();    // end root\r
 286 \r
 287                         xml = dtd + "<root><foo/><baz/></root>";\r
 288                         dvr = PrepareXmlReader (xml);\r
 289                         dvr.Read ();    // DTD\r
 290                         dvr.Read ();    // root\r
 291                         dvr.Read ();    // foo\r
 292                         dvr.Read ();    // end root\r
 293                 }\r
 294 \r
 295                 [Test]\r
 296                 [Category ("NotDotNet")]\r
 297                 public void TestAttributes ()\r
 298                 {\r
 299                         // simple content and attributes are required\r
 300                         string intSubset = "<!ELEMENT root (foo)><!ELEMENT foo EMPTY><!ATTLIST root foo CDATA #REQUIRED bar CDATA #IMPLIED>";\r
 301                         string dtd = "<!DOCTYPE root [" + intSubset + "]>";\r
 302                         string xml = dtd + "<root><foo/></root>";\r
 303                         dvr = PrepareXmlReader (xml);\r
 304                         dvr.ValidationType = ValidationType.DTD;\r
 305                         dvr.Read ();    // DTD\r
 306                         try {\r
 307                                 dvr.Read ();    // missing attributes\r
 308                                 Fail ("should be failed."); // MS.NET fails to fail this test.\r
 309                         } catch (XmlSchemaException) {\r
 310                         }\r
 311 \r
 312                         // empty element but attributes are required\r
 313                         intSubset = "<!ELEMENT root EMPTY><!ATTLIST root foo CDATA #REQUIRED bar CDATA #IMPLIED>";\r
 314                         dtd = "<!DOCTYPE root [" + intSubset + "]>";\r
 315                         xml = dtd + "<root />";\r
 316                         dvr = PrepareXmlReader (xml);\r
 317                         dvr.ValidationType = ValidationType.DTD;\r
 318                         dvr.Read ();    // DTD\r
 319                         try {\r
 320                                 dvr.Read ();    // missing attributes\r
 321                                 Fail ("should be failed.");\r
 322                         } catch (XmlSchemaException) {\r
 323                         }\r
 324 \r
 325                         xml = dtd + "<root foo='value' />";\r
 326                         dvr = PrepareXmlReader (xml);\r
 327                         dvr.Read ();    // DTD\r
 328                         dvr.Read ();    // root\r
 329                         dvr.Read ();    // end of document\r
 330 \r
 331                         xml = dtd + "<root foo='value' bar='2nd' />";\r
 332                         dvr = PrepareXmlReader (xml);\r
 333                         dvr.Read ();    // DTD\r
 334                         dvr.Read ();    // root\r
 335                         dvr.Read ();    // end of document\r
 336 \r
 337                         xml = dtd + "<root foo='value' bar='2nd' baz='3rd' />";\r
 338                         dvr = PrepareXmlReader (xml);\r
 339                         dvr.Read ();    // DTD\r
 340                         try {\r
 341                                 dvr.Read ();    // undeclared attribute baz\r
 342                                 Fail ("should be failed.");\r
 343                         } catch (XmlSchemaException) {\r
 344                         }\r
 345                 }\r
 346 \r
 347                 [Test]\r
 348                 public void TestAttributeDefaultContribution ()\r
 349                 {\r
 350                         string intSubset = "<!ELEMENT root EMPTY><!ATTLIST root foo CDATA 'foo-def' bar CDATA 'bar-def'>";\r
 351                         string dtd = "<!DOCTYPE root [" + intSubset + "]>";\r
 352                         string xml = dtd + "<root />";\r
 353 \r
 354                         dvr = PrepareXmlReader (xml);\r
 355                         dvr.ValidationType = ValidationType.DTD;\r
 356                         this.TestAttributeDefaultContributionInternal (dvr);\r
 357 \r
 358                         dvr = PrepareXmlReader (xml);\r
 359                         dvr.ValidationType = ValidationType.None;\r
 360                         this.TestAttributeDefaultContributionInternal (dvr);\r
 361                 }\r
 362 \r
 363                 private void TestAttributeDefaultContributionInternal (XmlReader dvr)\r
 364                 {\r
 365                         dvr.Read ();    // DTD\r
 366                         dvr.Read ();\r
 367                         AssertEquals (XmlNodeType.Element, dvr.NodeType);\r
 368                         AssertEquals ("root", dvr.Name);\r
 369                         AssertEquals (2, dvr.AttributeCount);\r
 370                         // foo\r
 371                         Assert (dvr.MoveToFirstAttribute ());\r
 372                         AssertEquals ("foo", dvr.Name);\r
 373                         AssertEquals ("foo-def", dvr ["foo"]);\r
 374                         AssertNotNull (dvr ["bar"]);\r
 375                         AssertEquals ("foo-def", dvr.Value);\r
 376                         Assert (dvr.ReadAttributeValue ());\r
 377                         AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
 378                         AssertEquals (String.Empty, dvr.Name);\r
 379                         AssertEquals ("foo-def", dvr.Value);\r
 380                         // bar\r
 381                         Assert (dvr.MoveToNextAttribute ());\r
 382                         AssertEquals ("bar", dvr.Name);\r
 383                         AssertEquals ("foo-def", dvr ["foo"]);\r
 384                         AssertNotNull (dvr ["bar"]);\r
 385                         AssertEquals ("bar-def", dvr.Value);\r
 386                         Assert (dvr.ReadAttributeValue ());\r
 387                         AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
 388                         AssertEquals (String.Empty, dvr.Name);\r
 389                         AssertEquals ("bar-def", dvr.Value);\r
 390                 }\r
 391 \r
 392                 [Test]\r
 393                 public void TestExpandEntity ()\r
 394                 {\r
 395                         string intSubset = "<!ELEMENT root (#PCDATA)><!ATTLIST root foo CDATA 'foo-def' bar CDATA 'bar-def'><!ENTITY ent 'entity string'>";\r
 396                         string dtd = "<!DOCTYPE root [" + intSubset + "]>";\r
 397                         string xml = dtd + "<root foo='&ent;' bar='internal &ent; value'>&ent;</root>";\r
 398                         dvr = PrepareXmlReader (xml);\r
 399                         dvr.EntityHandling = EntityHandling.ExpandEntities;\r
 400                         dvr.Read ();    // DTD\r
 401                         dvr.Read ();\r
 402                         AssertEquals (XmlNodeType.Element, dvr.NodeType);\r
 403                         AssertEquals ("root", dvr.Name);\r
 404                         Assert (dvr.MoveToFirstAttribute ());\r
 405                         AssertEquals ("foo", dvr.Name);\r
 406                         AssertEquals ("entity string", dvr.Value);\r
 407                         Assert (dvr.MoveToNextAttribute ());\r
 408                         AssertEquals ("bar", dvr.Name);\r
 409                         AssertEquals ("internal entity string value", dvr.Value);\r
 410                         AssertEquals ("entity string", dvr.ReadString ());\r
 411 \r
 412                         // ValidationType = None\r
 413 \r
 414                         dvr = PrepareXmlReader (xml);\r
 415                         dvr.EntityHandling = EntityHandling.ExpandEntities;\r
 416                         dvr.ValidationType = ValidationType.None;\r
 417                         dvr.Read ();    // DTD\r
 418                         dvr.Read ();\r
 419                         AssertEquals (XmlNodeType.Element, dvr.NodeType);\r
 420                         AssertEquals ("root", dvr.Name);\r
 421 \r
 422                         Assert (dvr.MoveToFirstAttribute ());\r
 423                         AssertEquals ("foo", dvr.Name);\r
 424                         AssertEquals ("entity string", dvr.Value);\r
 425 \r
 426                         Assert (dvr.MoveToNextAttribute ());\r
 427                         AssertEquals ("bar", dvr.Name);\r
 428                         AssertEquals ("internal entity string value", dvr.Value);\r
 429                         AssertEquals ("entity string", dvr.ReadString ());\r
 430                 }\r
 431 \r
 432                 [Test]\r
 433                 public void TestPreserveEntity ()\r
 434                 {\r
 435                         string intSubset = "<!ELEMENT root EMPTY><!ATTLIST root foo CDATA 'foo-def' bar CDATA 'bar-def'><!ENTITY ent 'entity string'>";\r
 436                         string dtd = "<!DOCTYPE root [" + intSubset + "]>";\r
 437                         string xml = dtd + "<root foo='&ent;' bar='internal &ent; value' />";\r
 438                         dvr = PrepareXmlReader (xml);\r
 439                         dvr.EntityHandling = EntityHandling.ExpandCharEntities;\r
 440                         dvr.Read ();    // DTD\r
 441                         dvr.Read ();\r
 442                         AssertEquals (XmlNodeType.Element, dvr.NodeType);\r
 443                         AssertEquals ("root", dvr.Name);\r
 444                         Assert (dvr.MoveToFirstAttribute ());\r
 445                         AssertEquals ("foo", dvr.Name);\r
 446                         // MS BUG: it returns "entity string", however, entity should not be exanded.\r
 447                         //  ReadAttributeValue()\r
 448                         Assert (dvr.ReadAttributeValue ());\r
 449                         AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
 450                         AssertEquals ("ent", dvr.Name);\r
 451                         AssertEquals (String.Empty, dvr.Value);\r
 452                         Assert (!dvr.ReadAttributeValue ());\r
 453 \r
 454                         // bar\r
 455                         Assert (dvr.MoveToNextAttribute ());\r
 456                         AssertEquals ("bar", dvr.Name);\r
 457                         //  ReadAttributeValue()\r
 458                         Assert (dvr.ReadAttributeValue ());\r
 459                         AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
 460                         AssertEquals (String.Empty, dvr.Name);\r
 461                         AssertEquals ("internal ", dvr.Value);\r
 462                         Assert (dvr.ReadAttributeValue ());\r
 463                         AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
 464                         AssertEquals ("ent", dvr.Name);\r
 465                         AssertEquals (String.Empty, dvr.Value);\r
 466                         Assert (dvr.ReadAttributeValue ());\r
 467                         AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
 468                         AssertEquals (String.Empty, dvr.Name);\r
 469                         AssertEquals (" value", dvr.Value);\r
 470 \r
 471                         // ValidationType = None\r
 472 \r
 473                         dvr = PrepareXmlReader (xml);\r
 474                         dvr.EntityHandling = EntityHandling.ExpandCharEntities;\r
 475                         dvr.ValidationType = ValidationType.None;\r
 476                         dvr.Read ();    // DTD\r
 477                         dvr.Read ();\r
 478                         AssertEquals (XmlNodeType.Element, dvr.NodeType);\r
 479                         AssertEquals ("root", dvr.Name);\r
 480 \r
 481                         // foo\r
 482                         Assert (dvr.MoveToFirstAttribute ());\r
 483                         AssertEquals ("foo", dvr.Name);\r
 484                         //  ReadAttributeValue()\r
 485                         Assert (dvr.ReadAttributeValue ());\r
 486                         AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
 487                         AssertEquals ("ent", dvr.Name);\r
 488                         AssertEquals (String.Empty, dvr.Value);\r
 489                         Assert (!dvr.ReadAttributeValue ());\r
 490 \r
 491                         // bar\r
 492                         Assert (dvr.MoveToNextAttribute ());\r
 493                         AssertEquals ("bar", dvr.Name);\r
 494                         //  ReadAttributeValue()\r
 495                         Assert (dvr.ReadAttributeValue ());\r
 496                         AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
 497                         AssertEquals (String.Empty, dvr.Name);\r
 498                         AssertEquals ("internal ", dvr.Value);\r
 499                         Assert (dvr.ReadAttributeValue ());\r
 500                         AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
 501                         AssertEquals ("ent", dvr.Name);\r
 502                         AssertEquals (String.Empty, dvr.Value);\r
 503                         Assert (dvr.ReadAttributeValue ());\r
 504                         AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
 505                         AssertEquals (String.Empty, dvr.Name);\r
 506                         AssertEquals (" value", dvr.Value);\r
 507                 }\r
 508 \r
 509                 [Test]\r
 510                 // it used to be regarded as MS bug but it was not really.\r
 511                 public void TestPreserveEntityNotOnDotNet ()\r
 512                 {\r
 513                         string intSubset = "<!ELEMENT root EMPTY><!ATTLIST root foo CDATA 'foo-def' bar CDATA 'bar-def'><!ENTITY ent 'entity string'>";\r
 514                         string dtd = "<!DOCTYPE root [" + intSubset + "]>";\r
 515                         string xml = dtd + "<root foo='&ent;' bar='internal &ent; value' />";\r
 516                         dvr = PrepareXmlReader (xml);\r
 517                         dvr.EntityHandling = EntityHandling.ExpandCharEntities;\r
 518                         dvr.Read ();    // DTD\r
 519                         dvr.Read ();\r
 520                         AssertEquals (XmlNodeType.Element, dvr.NodeType);\r
 521                         AssertEquals ("root", dvr.Name);\r
 522                         Assert (dvr.MoveToFirstAttribute ());\r
 523                         AssertEquals ("foo", dvr.Name);\r
 524                         AssertEquals ("entity string", dvr.Value);\r
 525                         //  ReadAttributeValue()\r
 526                         Assert (dvr.ReadAttributeValue ());\r
 527                         AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
 528                         AssertEquals ("ent", dvr.Name);\r
 529                         AssertEquals (String.Empty, dvr.Value);\r
 530                         Assert (!dvr.ReadAttributeValue ());\r
 531 \r
 532                         // bar\r
 533                         Assert (dvr.MoveToNextAttribute ());\r
 534                         AssertEquals ("bar", dvr.Name);\r
 535                         AssertEquals ("internal entity string value", dvr.Value);\r
 536                         //  ReadAttributeValue()\r
 537                         Assert (dvr.ReadAttributeValue ());\r
 538                         AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
 539                         AssertEquals (String.Empty, dvr.Name);\r
 540                         AssertEquals ("internal ", dvr.Value);\r
 541                         Assert (dvr.ReadAttributeValue ());\r
 542                         AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
 543                         AssertEquals ("ent", dvr.Name);\r
 544                         AssertEquals (String.Empty, dvr.Value);\r
 545                         Assert (dvr.ReadAttributeValue ());\r
 546                         AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
 547                         AssertEquals (String.Empty, dvr.Name);\r
 548                         AssertEquals (" value", dvr.Value);\r
 549 \r
 550                         // ValidationType = None\r
 551 \r
 552                         dvr = PrepareXmlReader (xml);\r
 553                         dvr.EntityHandling = EntityHandling.ExpandCharEntities;\r
 554                         dvr.ValidationType = ValidationType.None;\r
 555                         dvr.Read ();    // DTD\r
 556                         dvr.Read ();\r
 557                         AssertEquals (XmlNodeType.Element, dvr.NodeType);\r
 558                         AssertEquals ("root", dvr.Name);\r
 559 \r
 560                         // foo\r
 561                         Assert (dvr.MoveToFirstAttribute ());\r
 562                         AssertEquals ("foo", dvr.Name);\r
 563                         AssertEquals ("entity string", dvr.Value);\r
 564                         //  ReadAttributeValue()\r
 565                         Assert (dvr.ReadAttributeValue ());\r
 566                         AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
 567                         AssertEquals ("ent", dvr.Name);\r
 568                         AssertEquals (String.Empty, dvr.Value);\r
 569                         Assert (!dvr.ReadAttributeValue ());\r
 570 \r
 571                         // bar\r
 572                         Assert (dvr.MoveToNextAttribute ());\r
 573                         AssertEquals ("bar", dvr.Name);\r
 574                         AssertEquals ("internal entity string value", dvr.Value);\r
 575                         //  ReadAttributeValue()\r
 576                         Assert (dvr.ReadAttributeValue ());\r
 577                         AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
 578                         AssertEquals (String.Empty, dvr.Name);\r
 579                         AssertEquals ("internal ", dvr.Value);\r
 580                         Assert (dvr.ReadAttributeValue ());\r
 581                         AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
 582                         AssertEquals ("ent", dvr.Name);\r
 583                         AssertEquals (String.Empty, dvr.Value);\r
 584                         Assert (dvr.ReadAttributeValue ());\r
 585                         AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
 586                         AssertEquals (String.Empty, dvr.Name);\r
 587                         AssertEquals (" value", dvr.Value);\r
 588                 }\r
 589 \r
 590                 [Test]\r
 591                 public void TestNormalization ()\r
 592                 {\r
 593                         string intSubset = "<!ELEMENT root EMPTY>"\r
 594                                 + "<!ATTLIST root foo ID #REQUIRED"\r
 595                                 + " bar NMTOKEN #IMPLIED "\r
 596                                 + " baz NMTOKENS #IMPLIED "\r
 597                                 + " quux CDATA #IMPLIED >";\r
 598                         string dtd = "<!DOCTYPE root [" + intSubset + "]>";\r
 599                         string xml = dtd + "<root foo=' id1 ' bar='  nameToken  ' baz=' list  of\r\nname token' quux=' quuux\tquuux\t ' />";\r
 600                         dvr = PrepareXmlReader (xml);\r
 601                         ((XmlTextReader) dvr.Reader).Normalization = true;\r
 602                         dvr.EntityHandling = EntityHandling.ExpandEntities;\r
 603                         dvr.Read ();    // DTD\r
 604                         dvr.Read ();\r
 605                         AssertEquals (XmlNodeType.Element, dvr.NodeType);\r
 606                         AssertEquals ("root", dvr.Name);\r
 607                         Assert (dvr.MoveToFirstAttribute ());\r
 608                         AssertEquals ("foo", dvr.Name);\r
 609                         AssertEquals ("id1", dvr.Value);\r
 610                         Assert (dvr.MoveToNextAttribute ());\r
 611                         AssertEquals ("bar", dvr.Name);\r
 612                         AssertEquals ("nameToken", dvr.Value);\r
 613                         Assert (dvr.MoveToNextAttribute ());\r
 614                         AssertEquals ("baz", dvr.Name);\r
 615                         AssertEquals ("list of name token", dvr.Value);\r
 616                         Assert (dvr.MoveToNextAttribute ());\r
 617                         AssertEquals ("quux", dvr.Name);\r
 618                         AssertEquals (" quuux quuux  ", dvr.Value);\r
 619                 }\r
 620 \r
 621                 [Test]\r
 622                 public void TestValidationEvent ()\r
 623                 {\r
 624                         string intSubset = "<!ELEMENT root EMPTY><!ATTLIST root foo CDATA 'foo-def' bar CDATA 'bar-def'>";\r
 625                         string dtd = "<!DOCTYPE root [" + intSubset + "]>";\r
 626                         string xml = dtd + "<foo><bar att='val' /></foo>";\r
 627                         eventFired = false;\r
 628                         dvr = PrepareXmlReader (xml);\r
 629                         dvr.ValidationEventHandler += new ValidationEventHandler (OnInvalidityFound);\r
 630                         dvr.ValidationType = ValidationType.DTD;\r
 631                         dvr.Read ();    // DTD\r
 632                         Assert (dvr.Read ());   // invalid foo\r
 633                         Assert (eventFired);\r
 634                         AssertEquals ("foo", dvr.Name);\r
 635                         Assert (dvr.Read ());   // invalid bar\r
 636                         AssertEquals ("bar", dvr.Name);\r
 637                         Assert (dvr.MoveToFirstAttribute ());   // att\r
 638                         AssertEquals ("att", dvr.Name);\r
 639                         Assert (dvr.Read ());   // invalid end foo\r
 640                         AssertEquals ("foo", dvr.Name);\r
 641                         AssertEquals (XmlNodeType.EndElement, dvr.NodeType);\r
 642                         Assert (!dvr.Read ());\r
 643 \r
 644                         // When ValidationType is None, event should not be fired,\r
 645                         eventFired = false;\r
 646                         dvr = PrepareXmlReader (xml);\r
 647                         dvr.ValidationEventHandler += new ValidationEventHandler (OnInvalidityFound);\r
 648                         dvr.ValidationType = ValidationType.None;\r
 649                         dvr.Read ();    // DTD\r
 650                         Assert (dvr.Read ());   // invalid foo\r
 651                         Assert (!eventFired);\r
 652                 }\r
 653 \r
 654                 private bool eventFired;\r
 655                 private void OnInvalidityFound (object o, ValidationEventArgs e)\r
 656                 {\r
 657                         eventFired = true;\r
 658                 }\r
 659 \r
 660                 [Test]\r
 661                 public void TestIdentityConstraints ()\r
 662                 {\r
 663                         string intSubset = "<!ELEMENT root (c)+><!ELEMENT c EMPTY><!ATTLIST root foo ID #REQUIRED>";\r
 664                         string dtd = "<!DOCTYPE root [" + intSubset + "]>";\r
 665                         string xml = dtd + "<root><c foo='val' /><c foo='val'></root>";\r
 666                         dvr = PrepareXmlReader (xml);\r
 667                         dvr.ValidationType = ValidationType.DTD;\r
 668                         dvr.Read ();    // DTD\r
 669                         try {\r
 670                                 dvr.Read ();    // root misses attribute foo\r
 671                                 Fail ();\r
 672                         } catch (XmlSchemaException) {\r
 673                         }\r
 674 \r
 675                         intSubset = "<!ELEMENT root (c)+><!ELEMENT c EMPTY><!ATTLIST c foo ID #REQUIRED bar IDREF #IMPLIED baz IDREFS #IMPLIED>";\r
 676                         dtd = "<!DOCTYPE root [" + intSubset + "]>";\r
 677                         xml = dtd + "<root><c foo='val' /><c foo='val'></root>";\r
 678                         dvr = PrepareXmlReader (xml);\r
 679                         dvr.ValidationType = ValidationType.DTD;\r
 680                         dvr.Read ();    // DTD\r
 681                         dvr.Read ();    // root\r
 682                         dvr.Read ();    // c[1]\r
 683                         try {\r
 684                                 dvr.Read ();    // c[2]\r
 685                                 Fail ();\r
 686                         } catch (XmlSchemaException) {\r
 687                         }\r
 688 \r
 689                         xml = dtd + "<root><c foo='val' /><c baz='val val val 1 2 3'></root>";\r
 690                         dvr = PrepareXmlReader (xml);\r
 691                         dvr.Read ();    // DTD\r
 692                         dvr.Read ();    // root\r
 693                         dvr.Read ();    // c[1]\r
 694                         try {\r
 695                                 dvr.Read ();    // c[2]\r
 696                                 Fail ();\r
 697                         } catch (XmlSchemaException) {\r
 698                         }\r
 699                 }\r
 700 \r
 701                 // Entity tests are almost copied from XmlNodeReaderTests.\r
 702                 [Test]\r
 703                 public void ResolveEntity ()\r
 704                 {\r
 705                         string ent1 = "<!ENTITY ent 'entity string'>";\r
 706                         string ent2 = "<!ENTITY ent2 '<foo/><foo/>'>]>";\r
 707                         string dtd = "<!DOCTYPE root[<!ELEMENT root (#PCDATA|foo)*>" + ent1 + ent2;\r
 708                         string xml = dtd + "<root>&ent;&ent2;</root>";\r
 709                         dvr = new XmlValidatingReader (xml, XmlNodeType.Document, null);\r
 710                         dvr.ValidationType = ValidationType.None;\r
 711                         dvr.EntityHandling = EntityHandling.ExpandCharEntities;\r
 712                         dvr.Read ();    // DTD\r
 713                         dvr.Read ();    // root\r
 714                         dvr.Read ();    // &ent;\r
 715                         AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
 716                         AssertEquals (1, dvr.Depth);\r
 717                         dvr.ResolveEntity ();\r
 718                         // It is still entity reference.\r
 719                         AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
 720                         dvr.Read ();\r
 721                         AssertEquals (XmlNodeType.Text, dvr.NodeType);\r
 722                         AssertEquals (2, dvr.Depth);\r
 723                         AssertEquals ("entity string", dvr.Value);\r
 724                         dvr.Read ();\r
 725                         AssertEquals (XmlNodeType.EndEntity, dvr.NodeType);\r
 726                         AssertEquals (1, dvr.Depth);\r
 727                         AssertEquals (String.Empty, dvr.Value);\r
 728 \r
 729                         dvr.Read ();    // &ent2;\r
 730                         AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
 731                         AssertEquals (1, dvr.Depth);\r
 732                         dvr.ResolveEntity ();\r
 733                         // It is still entity reference.\r
 734                         AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
 735                         // It now became element node.\r
 736                         dvr.Read ();\r
 737                         AssertEquals (XmlNodeType.Element, dvr.NodeType);\r
 738                         AssertEquals (2, dvr.Depth);\r
 739                 }\r
 740 \r
 741                 [Test]\r
 742                 public void ResolveEntity2 ()\r
 743                 {\r
 744                         string ent1 = "<!ENTITY ent 'entity string'>";\r
 745                         string ent2 = "<!ENTITY ent2 '<foo/><foo/>'>]>";\r
 746                         string dtd = "<!DOCTYPE root[<!ELEMENT root (#PCDATA|foo)*>" + ent1 + ent2;\r
 747                         string xml = dtd + "<root>&ent3;&ent2;</root>";\r
 748                         dvr = new XmlValidatingReader (xml, XmlNodeType.Document, null);\r
 749                         dvr.ValidationType = ValidationType.None;\r
 750                         dvr.EntityHandling = EntityHandling.ExpandCharEntities;\r
 751                         dvr.Read ();    // DTD\r
 752                         dvr.Read ();    // root\r
 753                         dvr.Read ();    // &ent3;\r
 754                         AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
 755 #if NET_2_0\r
 756                         // under .NET 2.0, an error is raised here.\r
 757                         // under .NET 1.1, the error is thrown on the next read.\r
 758                         try {\r
 759                                 dvr.ResolveEntity ();\r
 760                                 Fail ("Attempt to resolve undeclared entity should fail.");\r
 761                         } catch (XmlException) {\r
 762                         }\r
 763 #else\r
 764                         // ent3 does not exist in this dtd.\r
 765                         dvr.ResolveEntity ();\r
 766                         AssertEquals (XmlNodeType.EntityReference, dvr.NodeType);\r
 767                         try {\r
 768                                 dvr.Read ();\r
 769                                 Fail ("Attempt to resolve undeclared entity should fail.");\r
 770                         } catch (XmlException) {\r
 771                         }\r
 772 #endif\r
 773                 }\r
 774 \r
 775                 [Test]\r
 776                 [ExpectedException (typeof (XmlException))]\r
 777                 public void ResolveEntityWithoutDTD ()\r
 778                 {\r
 779                         string xml = "<root>&ent;&ent2;</root>";\r
 780                         dvr = new XmlValidatingReader (xml, XmlNodeType.Document, null);\r
 781                         dvr.Read ();    // root\r
 782                         dvr.Read ();    // &ent;\r
 783                 }\r
 784 \r
 785                 [Test]\r
 786                 public void ResolveEntityReadAttributeValue ()\r
 787                 {\r
 788                         string dtd = "<!DOCTYPE root [<!ELEMENT root (#PCDATA)*><!ATTLIST root attr CDATA #REQUIRED><!ENTITY ent 'entity string'>]>";\r
 789                         string xml = dtd + "<root attr='&ent; text'>&ent;</root>";\r
 790                         dvr = new XmlValidatingReader (xml, XmlNodeType.Document, null);\r
 791                         dvr.Read (); // doctype\r
 792                         dvr.Read (); // root\r
 793                         dvr.MoveToAttribute (0); // attr\r
 794                         Assert (dvr.ReadAttributeValue ()); // Should read expanded text\r
 795                         AssertEquals (XmlNodeType.Text, dvr.NodeType); // not EntityReference\r
 796                         AssertEquals ("entity string text", dvr.Value);\r
 797                         Assert (!dvr.ReadAttributeValue ());\r
 798                 }\r
 799 \r
 800                 [Test]\r
 801                 public void ResolveEntitySequentialText ()\r
 802                 {\r
 803                         string xml = @"<!DOCTYPE doc [\r
 804                                 <!ELEMENT doc ANY>\r
 805                                 <!ELEMENT foo  ANY>\r
 806                                 <!ENTITY ref1 '<![CDATA[cdata]]>test'>\r
 807                                 ]>\r
 808                                 <doc><foo>&ref1; test </foo></doc>";\r
 809                         string refOut = "<doc><foo><![CDATA[cdata]]>test test </foo></doc>";\r
 810 \r
 811                         XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);\r
 812                         XmlValidatingReader r = new XmlValidatingReader (xtr);\r
 813                         r.Read ();\r
 814                         r.Read ();\r
 815                         r.Read ();\r
 816                         AssertEquals (refOut, r.ReadOuterXml ());\r
 817                 }\r
 818 \r
 819                 [Test]\r
 820                 // imported testcase from sys.security which had regression.\r
 821                 public void ResolveEntityAndBaseURI ()\r
 822                 {\r
 823                         try {\r
 824                                 using (TextWriter w = File.CreateText ("world.txt")) {\r
 825                                         w.WriteLine ("world");\r
 826                                 }\r
 827                                 using (TextWriter w = File.CreateText ("doc.dtd")) {\r
 828                                         w.WriteLine ("<!-- dummy -->");\r
 829                                 }\r
 830 \r
 831                                 string xml =  "<!DOCTYPE doc SYSTEM \"doc.dtd\" [\n" +\r
 832                                         "<!ATTLIST doc attrExtEnt ENTITY #IMPLIED>\n" +\r
 833                                         "<!ENTITY ent1 \"Hello\">\n" +\r
 834                                         "<!ENTITY ent2 SYSTEM \"world.txt\">\n" +\r
 835                                         "<!ENTITY entExt SYSTEM \"earth.gif\" NDATA gif>\n" +\r
 836                                         "<!NOTATION gif SYSTEM \"viewgif.exe\">\n" +\r
 837                                         "]>\n" +\r
 838                                         "<doc attrExtEnt=\"entExt\">\n" +\r
 839                                         "   &ent1;, &ent2;!\n" +\r
 840                                         "</doc>\n" +\r
 841                                         "\n" +\r
 842                                         "<!-- Let world.txt contain \"world\" (excluding the quotes) -->\n";\r
 843 \r
 844                                 XmlValidatingReader xvr =\r
 845                                         new XmlValidatingReader (\r
 846                                         xml, XmlNodeType.Document, null);\r
 847                                 xvr.ValidationType = ValidationType.None;\r
 848                                 xvr.EntityHandling =\r
 849                                         EntityHandling.ExpandCharEntities;\r
 850                                 XmlDocument doc = new XmlDocument ();\r
 851                                 doc.Load (xvr);\r
 852 \r
 853                         } finally {\r
 854                                 if (File.Exists ("world.txt"))\r
 855                                         File.Delete ("world.txt");\r
 856                                 if (File.Exists ("doc.dtd"))\r
 857                                         File.Delete ("doc.dtd");\r
 858                         }\r
 859                 }\r
 860 \r
 861                 [Test]\r
 862                 //[NotWorking ("default namespace seems null, not String.Empty")]\r
 863 #if NET_2_0\r
 864 #else\r
 865                 // MS.NET 1.x does not consider cases that xmlns* attributes\r
 866                 // could be declared as default.\r
 867                 [Category ("NotDotNet")]\r
 868 #endif\r
 869                 public void DefaultXmlnsAttributeLookup ()\r
 870                 {\r
 871                         string xml = @"<!DOCTYPE X [\r
 872                         <!ELEMENT X (Y)+>\r
 873                         <!ENTITY baz 'urn:baz'>\r
 874                         <!ATTLIST X\r
 875                                 xmlns CDATA 'urn:foo'\r
 876                                 xmlns:bar CDATA 'urn:bar'\r
 877                                 xmlns:baz CDATA #IMPLIED\r
 878                                 dummy CDATA 'dummy'\r
 879                                 baz:dummy CDATA 'dummy'>\r
 880                         <!ELEMENT Y (#PCDATA)*>\r
 881                         <!ATTLIST Y\r
 882                                 xmlns CDATA #IMPLIED\r
 883                                 xmlns:bar CDATA #IMPLIED>\r
 884                         ]>\r
 885                         <X xmlns:baz='&baz;'><Y/><Y>text.</Y><Y xmlns='' xmlns:bar='urn:hoge'>text.</Y></X>";\r
 886                         XmlValidatingReader xvr = new XmlValidatingReader (\r
 887                                 xml, XmlNodeType.Document, null);\r
 888                         xvr.Read (); // DTD\r
 889                         xvr.Read (); // whitespace\r
 890                         xvr.Read ();\r
 891                         AssertEquals ("#1-1", "urn:foo", xvr.LookupNamespace (String.Empty));\r
 892                         AssertEquals ("#1-2", "urn:bar", xvr.LookupNamespace ("bar"));\r
 893 \r
 894                         AssertEquals ("#1-a", "urn:baz", xvr.LookupNamespace ("baz"));\r
 895                         Assert ("#1-b", xvr.MoveToAttribute ("baz:dummy"));\r
 896                         AssertEquals ("#1-c", "urn:baz", xvr.NamespaceURI);\r
 897 \r
 898                         Assert ("#1-d", xvr.MoveToAttribute ("dummy"));\r
 899                         AssertEquals ("#1-e", String.Empty, xvr.NamespaceURI);\r
 900 \r
 901                         xvr.Read (); // first Y, empty element\r
 902                         AssertEquals ("#2-1", "urn:foo", xvr.LookupNamespace (String.Empty));\r
 903                         AssertEquals ("#2-2", "urn:bar", xvr.LookupNamespace ("bar"));\r
 904                         xvr.Read (); // second Y, start element\r
 905                         AssertEquals ("#3-1", "urn:foo", xvr.LookupNamespace (String.Empty));\r
 906                         AssertEquals ("#3-2", "urn:bar", xvr.LookupNamespace ("bar"));\r
 907                         xvr.Read (); // inside normal Y. Check inheritance\r
 908                         AssertEquals ("#4-1", "urn:foo", xvr.LookupNamespace (String.Empty));\r
 909                         AssertEquals ("#4-2", "urn:bar", xvr.LookupNamespace ("bar"));\r
 910                         xvr.Read (); // second Y, end element\r
 911                         AssertEquals ("#5-1", "urn:foo", xvr.LookupNamespace (String.Empty));\r
 912                         AssertEquals ("#5-2", "urn:bar", xvr.LookupNamespace ("bar"));\r
 913                         xvr.Read (); // third Y, suppresses default namespaces\r
 914                         AssertEquals ("#6-1", null, xvr.LookupNamespace (String.Empty));\r
 915                         AssertEquals ("#6-2", "urn:hoge", xvr.LookupNamespace ("bar"));\r
 916                         xvr.Read (); // inside suppressing Y. Check inheritance\r
 917                         AssertEquals ("#7-1", null, xvr.LookupNamespace (String.Empty));\r
 918                         AssertEquals ("#7-2", "urn:hoge", xvr.LookupNamespace ("bar"));\r
 919                         xvr.Read (); // end of suppressing element\r
 920                         AssertEquals ("#8-1", null, xvr.LookupNamespace (String.Empty));\r
 921                         AssertEquals ("#8-2", "urn:hoge", xvr.LookupNamespace ("bar"));\r
 922                 }\r
 923         }\r
 924 }\r