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