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\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                                 Assert.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                                 Assert.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                                 Assert.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                                 Assert.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                                 Assert.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                                 Assert.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                                 Assert.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                                 Assert.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                                 Assert.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                                 Assert.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                                 Assert.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                                 Assert.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                                 Assert.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                                 Assert.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                                 Assert.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                         Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);\r
 368                         Assert.AreEqual ("root", dvr.Name);\r
 369                         Assert.AreEqual (2, dvr.AttributeCount);\r
 370                         // foo\r
 371                         Assert.IsTrue (dvr.MoveToFirstAttribute ());\r
 372                         Assert.AreEqual ("foo", dvr.Name);\r
 373                         Assert.AreEqual ("foo-def", dvr ["foo"]);\r
 374                         Assert.IsNotNull (dvr ["bar"]);\r
 375                         Assert.AreEqual ("foo-def", dvr.Value);\r
 376                         Assert.IsTrue (dvr.ReadAttributeValue ());\r
 377                         Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
 378                         Assert.AreEqual (String.Empty, dvr.Name);\r
 379                         Assert.AreEqual ("foo-def", dvr.Value);\r
 380                         // bar\r
 381                         Assert.IsTrue (dvr.MoveToNextAttribute ());\r
 382                         Assert.AreEqual ("bar", dvr.Name);\r
 383                         Assert.AreEqual ("foo-def", dvr ["foo"]);\r
 384                         Assert.IsNotNull (dvr ["bar"]);\r
 385                         Assert.AreEqual ("bar-def", dvr.Value);\r
 386                         Assert.IsTrue (dvr.ReadAttributeValue ());\r
 387                         Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
 388                         Assert.AreEqual (String.Empty, dvr.Name);\r
 389                         Assert.AreEqual ("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                         Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);\r
 403                         Assert.AreEqual ("root", dvr.Name);\r
 404                         Assert.IsTrue (dvr.MoveToFirstAttribute ());\r
 405                         Assert.AreEqual ("foo", dvr.Name);\r
 406                         Assert.AreEqual ("entity string", dvr.Value);\r
 407                         Assert.IsTrue (dvr.MoveToNextAttribute ());\r
 408                         Assert.AreEqual ("bar", dvr.Name);\r
 409                         Assert.AreEqual ("internal entity string value", dvr.Value);\r
 410                         Assert.AreEqual ("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                         Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);\r
 420                         Assert.AreEqual ("root", dvr.Name);\r
 421 \r
 422                         Assert.IsTrue (dvr.MoveToFirstAttribute ());\r
 423                         Assert.AreEqual ("foo", dvr.Name);\r
 424                         Assert.AreEqual ("entity string", dvr.Value);\r
 425 \r
 426                         Assert.IsTrue (dvr.MoveToNextAttribute ());\r
 427                         Assert.AreEqual ("bar", dvr.Name);\r
 428                         Assert.AreEqual ("internal entity string value", dvr.Value);\r
 429                         Assert.AreEqual ("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                         Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);\r
 443                         Assert.AreEqual ("root", dvr.Name);\r
 444                         Assert.IsTrue (dvr.MoveToFirstAttribute ());\r
 445                         Assert.AreEqual ("foo", dvr.Name);\r
 446                         // MS BUG: it returns "entity string", however, entity should not be exanded.\r
 447                         //  ReadAttributeValue()\r
 448                         Assert.IsTrue (dvr.ReadAttributeValue ());\r
 449                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
 450                         Assert.AreEqual ("ent", dvr.Name);\r
 451                         Assert.AreEqual (String.Empty, dvr.Value);\r
 452                         Assert.IsTrue (!dvr.ReadAttributeValue ());\r
 453 \r
 454                         // bar\r
 455                         Assert.IsTrue (dvr.MoveToNextAttribute ());\r
 456                         Assert.AreEqual ("bar", dvr.Name);\r
 457                         //  ReadAttributeValue()\r
 458                         Assert.IsTrue (dvr.ReadAttributeValue ());\r
 459                         Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
 460                         Assert.AreEqual (String.Empty, dvr.Name);\r
 461                         Assert.AreEqual ("internal ", dvr.Value);\r
 462                         Assert.IsTrue (dvr.ReadAttributeValue ());\r
 463                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
 464                         Assert.AreEqual ("ent", dvr.Name);\r
 465                         Assert.AreEqual (String.Empty, dvr.Value);\r
 466                         Assert.IsTrue (dvr.ReadAttributeValue ());\r
 467                         Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
 468                         Assert.AreEqual (String.Empty, dvr.Name);\r
 469                         Assert.AreEqual (" 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                         Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);\r
 479                         Assert.AreEqual ("root", dvr.Name);\r
 480 \r
 481                         // foo\r
 482                         Assert.IsTrue (dvr.MoveToFirstAttribute ());\r
 483                         Assert.AreEqual ("foo", dvr.Name);\r
 484                         //  ReadAttributeValue()\r
 485                         Assert.IsTrue (dvr.ReadAttributeValue ());\r
 486                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
 487                         Assert.AreEqual ("ent", dvr.Name);\r
 488                         Assert.AreEqual (String.Empty, dvr.Value);\r
 489                         Assert.IsTrue (!dvr.ReadAttributeValue ());\r
 490 \r
 491                         // bar\r
 492                         Assert.IsTrue (dvr.MoveToNextAttribute ());\r
 493                         Assert.AreEqual ("bar", dvr.Name);\r
 494                         //  ReadAttributeValue()\r
 495                         Assert.IsTrue (dvr.ReadAttributeValue ());\r
 496                         Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
 497                         Assert.AreEqual (String.Empty, dvr.Name);\r
 498                         Assert.AreEqual ("internal ", dvr.Value);\r
 499                         Assert.IsTrue (dvr.ReadAttributeValue ());\r
 500                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
 501                         Assert.AreEqual ("ent", dvr.Name);\r
 502                         Assert.AreEqual (String.Empty, dvr.Value);\r
 503                         Assert.IsTrue (dvr.ReadAttributeValue ());\r
 504                         Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
 505                         Assert.AreEqual (String.Empty, dvr.Name);\r
 506                         Assert.AreEqual (" 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                         Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);\r
 521                         Assert.AreEqual ("root", dvr.Name);\r
 522                         Assert.IsTrue (dvr.MoveToFirstAttribute ());\r
 523                         Assert.AreEqual ("foo", dvr.Name);\r
 524                         Assert.AreEqual ("entity string", dvr.Value);\r
 525                         //  ReadAttributeValue()\r
 526                         Assert.IsTrue (dvr.ReadAttributeValue ());\r
 527                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
 528                         Assert.AreEqual ("ent", dvr.Name);\r
 529                         Assert.AreEqual (String.Empty, dvr.Value);\r
 530                         Assert.IsTrue (!dvr.ReadAttributeValue ());\r
 531 \r
 532                         // bar\r
 533                         Assert.IsTrue (dvr.MoveToNextAttribute ());\r
 534                         Assert.AreEqual ("bar", dvr.Name);\r
 535                         Assert.AreEqual ("internal entity string value", dvr.Value);\r
 536                         //  ReadAttributeValue()\r
 537                         Assert.IsTrue (dvr.ReadAttributeValue ());\r
 538                         Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
 539                         Assert.AreEqual (String.Empty, dvr.Name);\r
 540                         Assert.AreEqual ("internal ", dvr.Value);\r
 541                         Assert.IsTrue (dvr.ReadAttributeValue ());\r
 542                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
 543                         Assert.AreEqual ("ent", dvr.Name);\r
 544                         Assert.AreEqual (String.Empty, dvr.Value);\r
 545                         Assert.IsTrue (dvr.ReadAttributeValue ());\r
 546                         Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
 547                         Assert.AreEqual (String.Empty, dvr.Name);\r
 548                         Assert.AreEqual (" 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                         Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);\r
 558                         Assert.AreEqual ("root", dvr.Name);\r
 559 \r
 560                         // foo\r
 561                         Assert.IsTrue (dvr.MoveToFirstAttribute ());\r
 562                         Assert.AreEqual ("foo", dvr.Name);\r
 563                         Assert.AreEqual ("entity string", dvr.Value);\r
 564                         //  ReadAttributeValue()\r
 565                         Assert.IsTrue (dvr.ReadAttributeValue ());\r
 566                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
 567                         Assert.AreEqual ("ent", dvr.Name);\r
 568                         Assert.AreEqual (String.Empty, dvr.Value);\r
 569                         Assert.IsTrue (!dvr.ReadAttributeValue ());\r
 570 \r
 571                         // bar\r
 572                         Assert.IsTrue (dvr.MoveToNextAttribute ());\r
 573                         Assert.AreEqual ("bar", dvr.Name);\r
 574                         Assert.AreEqual ("internal entity string value", dvr.Value);\r
 575                         //  ReadAttributeValue()\r
 576                         Assert.IsTrue (dvr.ReadAttributeValue ());\r
 577                         Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
 578                         Assert.AreEqual (String.Empty, dvr.Name);\r
 579                         Assert.AreEqual ("internal ", dvr.Value);\r
 580                         Assert.IsTrue (dvr.ReadAttributeValue ());\r
 581                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
 582                         Assert.AreEqual ("ent", dvr.Name);\r
 583                         Assert.AreEqual (String.Empty, dvr.Value);\r
 584                         Assert.IsTrue (dvr.ReadAttributeValue ());\r
 585                         Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
 586                         Assert.AreEqual (String.Empty, dvr.Name);\r
 587                         Assert.AreEqual (" 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                         Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);\r
 606                         Assert.AreEqual ("root", dvr.Name);\r
 607                         Assert.IsTrue (dvr.MoveToFirstAttribute ());\r
 608                         Assert.AreEqual ("foo", dvr.Name);\r
 609                         Assert.AreEqual ("id1", dvr.Value);\r
 610                         Assert.IsTrue (dvr.MoveToNextAttribute ());\r
 611                         Assert.AreEqual ("bar", dvr.Name);\r
 612                         Assert.AreEqual ("nameToken", dvr.Value);\r
 613                         Assert.IsTrue (dvr.MoveToNextAttribute ());\r
 614                         Assert.AreEqual ("baz", dvr.Name);\r
 615                         Assert.AreEqual ("list of name token", dvr.Value);\r
 616                         Assert.IsTrue (dvr.MoveToNextAttribute ());\r
 617                         Assert.AreEqual ("quux", dvr.Name);\r
 618                         Assert.AreEqual (" 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.IsTrue (dvr.Read ());    // invalid foo\r
 633                         Assert.IsTrue (eventFired);\r
 634                         Assert.AreEqual ("foo", dvr.Name);\r
 635                         Assert.IsTrue (dvr.Read ());    // invalid bar\r
 636                         Assert.AreEqual ("bar", dvr.Name);\r
 637                         Assert.IsTrue (dvr.MoveToFirstAttribute ());    // att\r
 638                         Assert.AreEqual ("att", dvr.Name);\r
 639                         Assert.IsTrue (dvr.Read ());    // invalid end foo\r
 640                         Assert.AreEqual ("foo", dvr.Name);\r
 641                         Assert.AreEqual (XmlNodeType.EndElement, dvr.NodeType);\r
 642                         Assert.IsTrue (!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.IsTrue (dvr.Read ());    // invalid foo\r
 651                         Assert.IsTrue (!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                                 Assert.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                                 Assert.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                                 Assert.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                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
 716                         Assert.AreEqual (1, dvr.Depth);\r
 717                         dvr.ResolveEntity ();\r
 718                         // It is still entity reference.\r
 719                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
 720                         dvr.Read ();\r
 721                         Assert.AreEqual (XmlNodeType.Text, dvr.NodeType);\r
 722                         Assert.AreEqual (2, dvr.Depth);\r
 723                         Assert.AreEqual ("entity string", dvr.Value);\r
 724                         dvr.Read ();\r
 725                         Assert.AreEqual (XmlNodeType.EndEntity, dvr.NodeType);\r
 726                         Assert.AreEqual (1, dvr.Depth);\r
 727                         Assert.AreEqual (String.Empty, dvr.Value);\r
 728 \r
 729                         dvr.Read ();    // &ent2;\r
 730                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
 731                         Assert.AreEqual (1, dvr.Depth);\r
 732                         dvr.ResolveEntity ();\r
 733                         // It is still entity reference.\r
 734                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
 735                         // It now became element node.\r
 736                         dvr.Read ();\r
 737                         Assert.AreEqual (XmlNodeType.Element, dvr.NodeType);\r
 738                         Assert.AreEqual (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                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\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                                 Assert.Fail ("Attempt to resolve undeclared entity should fail.");\r
 760                         } catch (XmlException) {\r
 761                         }\r
 762                 }\r
 763 \r
 764                 [Test]\r
 765                 [ExpectedException (typeof (XmlException))]\r
 766                 public void ResolveEntityWithoutDTD ()\r
 767                 {\r
 768                         string xml = "<root>&ent;&ent2;</root>";\r
 769                         dvr = new XmlValidatingReader (xml, XmlNodeType.Document, null);\r
 770                         dvr.Read ();    // root\r
 771                         dvr.Read ();    // &ent;\r
 772                 }\r
 773 \r
 774                 [Test]\r
 775                 public void ResolveEntityReadAttributeValue ()\r
 776                 {\r
 777                         string dtd = "<!DOCTYPE root [<!ELEMENT root (#PCDATA)*><!ATTLIST root attr CDATA #REQUIRED><!ENTITY ent 'entity string'>]>";\r
 778                         string xml = dtd + "<root attr='&ent; text'>&ent;</root>";\r
 779                         dvr = new XmlValidatingReader (xml, XmlNodeType.Document, null);\r
 780                         dvr.Read (); // doctype\r
 781                         dvr.Read (); // root\r
 782                         dvr.MoveToAttribute (0); // attr\r
 783                         Assert.IsTrue (dvr.ReadAttributeValue ()); // Should read expanded text\r
 784                         Assert.AreEqual (XmlNodeType.Text, dvr.NodeType); // not EntityReference\r
 785                         Assert.AreEqual ("entity string text", dvr.Value);\r
 786                         Assert.IsTrue (!dvr.ReadAttributeValue ());\r
 787                 }\r
 788 \r
 789                 [Test]\r
 790                 public void ResolveEntitySequentialText ()\r
 791                 {\r
 792                         string xml = @"<!DOCTYPE doc [\r
 793                                 <!ELEMENT doc ANY>\r
 794                                 <!ELEMENT foo  ANY>\r
 795                                 <!ENTITY ref1 '<![CDATA[cdata]]>test'>\r
 796                                 ]>\r
 797                                 <doc><foo>&ref1; test </foo></doc>";\r
 798                         string refOut = "<doc><foo><![CDATA[cdata]]>test test </foo></doc>";\r
 799 \r
 800                         XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);\r
 801                         XmlValidatingReader r = new XmlValidatingReader (xtr);\r
 802                         r.Read ();\r
 803                         r.Read ();\r
 804                         r.Read ();\r
 805                         Assert.AreEqual (refOut, r.ReadOuterXml ());\r
 806                 }\r
 807 \r
 808                 [Test]\r
 809                 // imported testcase from sys.security which had regression.\r
 810                 public void ResolveEntityAndBaseURI ()\r
 811                 {\r
 812                         string world = Path.Combine (Path.GetTempPath (), "world.txt");\r
 813                         string dtd = Path.Combine (Path.GetTempPath (), "doc.dtd");\r
 814                         try {\r
 815                                 using (TextWriter w = File.CreateText (world)) {\r
 816                                         w.WriteLine ("world");\r
 817                                 }\r
 818                                 using (TextWriter w = File.CreateText (dtd)) {\r
 819                                         w.WriteLine ("<!-- dummy -->");\r
 820                                 }\r
 821 \r
 822                                 string xml = String.Format ("<!DOCTYPE doc SYSTEM \"{1}\" [\n" +\r
 823                                         "<!ATTLIST doc attrExtEnt ENTITY #IMPLIED>\n" +\r
 824                                         "<!ENTITY ent1 \"Hello\">\n" +\r
 825                                         "<!ENTITY ent2 SYSTEM \"{0}\">\n" +\r
 826                                         "<!ENTITY entExt SYSTEM \"earth.gif\" NDATA gif>\n" +\r
 827                                         "<!NOTATION gif SYSTEM \"viewgif.exe\">\n" +\r
 828                                         "]>\n" +\r
 829                                         "<doc attrExtEnt=\"entExt\">\n" +\r
 830                                         "   &ent1;, &ent2;!\n" +\r
 831                                         "</doc>\n" +\r
 832                                         "\n" +\r
 833                                         "<!-- Let world.txt contain \"world\" (excluding the quotes) -->\n",\r
 834                                         world, dtd);\r
 835 \r
 836                                 XmlValidatingReader xvr =\r
 837                                         new XmlValidatingReader (\r
 838                                         xml, XmlNodeType.Document, null);\r
 839                                 xvr.ValidationType = ValidationType.None;\r
 840                                 xvr.EntityHandling =\r
 841                                         EntityHandling.ExpandCharEntities;\r
 842                                 XmlDocument doc = new XmlDocument ();\r
 843                                 doc.Load (xvr);\r
 844 \r
 845                         } finally {\r
 846                                 if (File.Exists (world))\r
 847                                         File.Delete (world);\r
 848                                 if (File.Exists (dtd))\r
 849                                         File.Delete (dtd);\r
 850                         }\r
 851                 }\r
 852 \r
 853                 [Test]\r
 854                 //[NotWorking ("default namespace seems null, not String.Empty")]\r
 855                 public void DefaultXmlnsAttributeLookup ()\r
 856                 {\r
 857                         string xml = @"<!DOCTYPE X [\r
 858                         <!ELEMENT X (Y)+>\r
 859                         <!ENTITY baz 'urn:baz'>\r
 860                         <!ATTLIST X\r
 861                                 xmlns CDATA 'urn:foo'\r
 862                                 xmlns:bar CDATA 'urn:bar'\r
 863                                 xmlns:baz CDATA #IMPLIED\r
 864                                 dummy CDATA 'dummy'\r
 865                                 baz:dummy CDATA 'dummy'>\r
 866                         <!ELEMENT Y (#PCDATA)*>\r
 867                         <!ATTLIST Y\r
 868                                 xmlns CDATA #IMPLIED\r
 869                                 xmlns:bar CDATA #IMPLIED>\r
 870                         ]>\r
 871                         <X xmlns:baz='&baz;'><Y/><Y>text.</Y><Y xmlns='' xmlns:bar='urn:hoge'>text.</Y></X>";\r
 872                         XmlValidatingReader xvr = new XmlValidatingReader (\r
 873                                 xml, XmlNodeType.Document, null);\r
 874                         xvr.Read (); // DTD\r
 875                         xvr.Read (); // whitespace\r
 876                         xvr.Read ();\r
 877                         Assert.AreEqual ("urn:foo", xvr.LookupNamespace (String.Empty), "#1-1");\r
 878                         Assert.AreEqual ("urn:bar", xvr.LookupNamespace ("bar"), "#1-2");\r
 879 \r
 880                         Assert.AreEqual ("urn:baz", xvr.LookupNamespace ("baz"), "#1-a");\r
 881                         Assert.IsTrue (xvr.MoveToAttribute ("baz:dummy"), "#1-b");\r
 882                         Assert.AreEqual ("urn:baz", xvr.NamespaceURI, "#1-c");\r
 883 \r
 884                         Assert.IsTrue (xvr.MoveToAttribute ("dummy"), "#1-d");\r
 885                         Assert.AreEqual (String.Empty, xvr.NamespaceURI, "#1-e");\r
 886 \r
 887                         xvr.Read (); // first Y, empty element\r
 888                         Assert.AreEqual ("urn:foo", xvr.LookupNamespace (String.Empty), "#2-1");\r
 889                         Assert.AreEqual ("urn:bar", xvr.LookupNamespace ("bar"), "#2-2");\r
 890                         xvr.Read (); // second Y, start element\r
 891                         Assert.AreEqual ("urn:foo", xvr.LookupNamespace (String.Empty), "#3-1");\r
 892                         Assert.AreEqual ("urn:bar", xvr.LookupNamespace ("bar"), "#3-2");\r
 893                         xvr.Read (); // inside normal Y. Check inheritance\r
 894                         Assert.AreEqual ("urn:foo", xvr.LookupNamespace (String.Empty), "#4-1");\r
 895                         Assert.AreEqual ("urn:bar", xvr.LookupNamespace ("bar"), "#4-2");\r
 896                         xvr.Read (); // second Y, end element\r
 897                         Assert.AreEqual ("urn:foo", xvr.LookupNamespace (String.Empty), "#5-1");\r
 898                         Assert.AreEqual ("urn:bar", xvr.LookupNamespace ("bar"), "#5-2");\r
 899                         xvr.Read (); // third Y, suppresses default namespaces\r
 900                         Assert.AreEqual (null, xvr.LookupNamespace (String.Empty), "#6-1");\r
 901                         Assert.AreEqual ("urn:hoge", xvr.LookupNamespace ("bar"), "#6-2");\r
 902                         xvr.Read (); // inside suppressing Y. Check inheritance\r
 903                         Assert.AreEqual (null, xvr.LookupNamespace (String.Empty), "#7-1");\r
 904                         Assert.AreEqual ("urn:hoge", xvr.LookupNamespace ("bar"), "#7-2");\r
 905                         xvr.Read (); // end of suppressing element\r
 906                         Assert.AreEqual (null, xvr.LookupNamespace (String.Empty), "#8-1");\r
 907                         Assert.AreEqual ("urn:hoge", xvr.LookupNamespace ("bar"), "#8-2");\r
 908                 }\r
 909 \r
 910                 [Test]\r
 911                 [ExpectedException (typeof (XmlSchemaException))]\r
 912                 public void Bug80231 ()\r
 913                 {\r
 914                         string xml = "<!DOCTYPE file [<!ELEMENT file EMPTY><!ATTLIST file name CDATA #REQUIRED>]><file name=\"foo\" bar=\"baz\" />";\r
 915                         XmlReaderSettings settings = new XmlReaderSettings ();\r
 916                         settings.ProhibitDtd = false;\r
 917                         settings.ValidationType = ValidationType.DTD;\r
 918                         XmlReader r = XmlReader.Create (new StringReader (xml), settings);\r
 919                         while (!r.EOF)\r
 920                                 r.Read ();\r
 921                 }\r
 922 \r
 923                 [Test]          \r
 924                 public void Bug501814 ()\r
 925                 {\r
 926                         string xsd = @"\r
 927                         <xs:schema id='Layout'\r
 928                                 targetNamespace='foo'\r
 929                                 elementFormDefault='qualified'\r
 930                                 xmlns='foo'                  \r
 931                                 xmlns:xs='http://www.w3.org/2001/XMLSchema'>\r
 932 \r
 933                                 <xs:element name='Layout' type='Layout' />\r
 934 \r
 935                                 <xs:complexType name='Layout'>\r
 936                                         <xs:group ref='AnyLayoutElement' minOccurs='0' maxOccurs='unbounded' />\r
 937                                 </xs:complexType>\r
 938 \r
 939                                 <xs:group name='AnyLayoutElement'>\r
 940                                         <xs:choice>                     \r
 941                                                 <xs:element name='Label' type='Label' />                        \r
 942                                         </xs:choice>\r
 943                                 </xs:group>\r
 944         \r
 945                                 <xs:complexType name='LayoutElement' abstract='true'>\r
 946                                         <xs:attribute name='id' type='xs:ID' use='optional' />\r
 947                                         <xs:attribute name='visible' type='xs:boolean' use='optional' default='true' />\r
 948                                 </xs:complexType>\r
 949         \r
 950                                 <xs:complexType name='Label'>\r
 951                                         <xs:complexContent mixed='true'>\r
 952                                                 <xs:extension base='LayoutElement'>\r
 953                                                 <xs:attribute name='bold' type='xs:boolean' use='required'/>\r
 954                                                 </xs:extension>\r
 955                                         </xs:complexContent>\r
 956                                         </xs:complexType>\r
 957                         </xs:schema>";\r
 958                         \r
 959                         XmlDocument doc = new XmlDocument ();\r
 960                         \r
 961                         XmlSchema schema = XmlSchema.Read (XmlReader.Create (new StringReader (xsd)), null);                    \r
 962                         \r
 963                         doc.LoadXml (@"\r
 964                                 <Layout xmlns='foo'>\r
 965                     <Label bold='false'>Text inside label</Label>\r
 966                 </Layout>");\r
 967                         doc.Schemas.Add (schema);\r
 968                         doc.Validate (null);\r
 969                 }\r
 970                 \r
 971                 [Test]          \r
 972                 public void Bug502168 ()\r
 973                 {\r
 974                         string xsd = @"<xs:schema id='Layout'\r
 975                                 targetNamespace='foo'\r
 976                                 elementFormDefault='qualified'\r
 977                                 xmlns='foo'                  \r
 978                                 xmlns:xs='http://www.w3.org/2001/XMLSchema'>\r
 979 \r
 980                                 <xs:element name='Layout' type='Layout' />\r
 981                                 \r
 982                                  <xs:complexType name='Layout'>\r
 983                                   <xs:group ref='AnyLayoutElement' minOccurs='0' maxOccurs='unbounded' />\r
 984                                  </xs:complexType>\r
 985                                 \r
 986                                  <xs:group name='AnyLayoutElement'>\r
 987                                   <xs:choice>\r
 988                                    <xs:element name='Layout' type='Layout' />   \r
 989                                    <xs:element name='ImageContainer' type='ImageContainer' />\r
 990                                    <xs:element name='VideoInstance' type='VideoInstance'/>\r
 991                                   </xs:choice>\r
 992                                  </xs:group>\r
 993                                 \r
 994                                  <xs:complexType name='ImageDummy'>\r
 995                                  </xs:complexType>\r
 996                                 \r
 997                                  <xs:complexType name='LayoutElement' abstract='true'>  \r
 998                                  </xs:complexType>\r
 999                                 \r
1000                                  <xs:group name='AnyImageElement'>\r
1001                                   <xs:choice>\r
1002                                    <xs:element name='ImageDummy' type='ImageDummy' />\r
1003                                   </xs:choice>\r
1004                                  </xs:group>\r
1005                                 \r
1006                                  <xs:complexType name='ImageContainer'>\r
1007                                   <xs:complexContent>\r
1008                                    <xs:extension base='LayoutElement'>\r
1009                                     <xs:choice minOccurs='1' maxOccurs='1'>\r
1010                                      <xs:element name='Content' type='SingleImage' minOccurs='1' maxOccurs='1'\r
1011                                 nillable='false'/>\r
1012                                     </xs:choice>    \r
1013                                    </xs:extension>\r
1014                                   </xs:complexContent>\r
1015                                  </xs:complexType>\r
1016                                 \r
1017                                  <xs:complexType name='SingleImage'>\r
1018                                   <xs:group ref='AnyImageElement' minOccurs='1' maxOccurs='1'/>\r
1019                                  </xs:complexType>\r
1020                                 \r
1021                                  <xs:complexType name='VideoApplicationFile'>\r
1022                                   <xs:complexContent>\r
1023                                    <xs:extension base='VideoInstance'>\r
1024                                     <xs:attribute name='fileName' type='xs:string' use='optional'/>\r
1025                                    </xs:extension>\r
1026                                   </xs:complexContent>\r
1027                                  </xs:complexType>\r
1028                                 \r
1029                                  <xs:complexType abstract='true' name='Video'>\r
1030                                   <xs:complexContent>\r
1031                                    <xs:extension base='LayoutElement'>\r
1032                                     <xs:group ref='AnyImageElement' minOccurs='0' maxOccurs='1'/>    \r
1033                                    </xs:extension>\r
1034                                   </xs:complexContent>\r
1035                                  </xs:complexType>\r
1036                                 \r
1037                                  <xs:complexType abstract='true' name='VideoInstance'>\r
1038                                   <xs:complexContent>\r
1039                                    <xs:extension base='Video'>\r
1040                                     <xs:attribute name='name' type='xs:string' use='optional'/>\r
1041                                    </xs:extension>\r
1042                                   </xs:complexContent>\r
1043                                  </xs:complexType>\r
1044                                 </xs:schema>";\r
1045 \r
1046 \r
1047                         XmlDocument doc = new XmlDocument ();\r
1048                         XmlSchema schema = XmlSchema.Read (XmlReader.Create (new StringReader (xsd)), null);\r
1049                         doc.LoadXml (@"<Layout xmlns='foo' />");\r
1050                         doc.Schemas.Add(schema);\r
1051                         doc.Validate(null);\r
1052                 }\r
1053         }\r
1054 }\r