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 #if NET_2_0\r
 756                         // under .NET 2.0, an error is raised here.\r
 757                         // under .NET 1.1, the error is thrown on the next read.\r
 758                         try {\r
 759                                 dvr.ResolveEntity ();\r
 760                                 Assert.Fail ("Attempt to resolve undeclared entity should fail.");\r
 761                         } catch (XmlException) {\r
 762                         }\r
 763 #else\r
 764                         // ent3 does not exist in this dtd.\r
 765                         dvr.ResolveEntity ();\r
 766                         Assert.AreEqual (XmlNodeType.EntityReference, dvr.NodeType);\r
 767                         try {\r
 768                                 dvr.Read ();\r
 769                                 Assert.Fail ("Attempt to resolve undeclared entity should fail.");\r
 770                         } catch (XmlException) {\r
 771                         }\r
 772 #endif\r
 773                 }\r
 774 \r
 775                 [Test]\r
 776                 [ExpectedException (typeof (XmlException))]\r
 777                 public void ResolveEntityWithoutDTD ()\r
 778                 {\r
 779                         string xml = "<root>&ent;&ent2;</root>";\r
 780                         dvr = new XmlValidatingReader (xml, XmlNodeType.Document, null);\r
 781                         dvr.Read ();    // root\r
 782                         dvr.Read ();    // &ent;\r
 783                 }\r
 784 \r
 785                 [Test]\r
 786                 public void ResolveEntityReadAttributeValue ()\r
 787                 {\r
 788                         string dtd = "<!DOCTYPE root [<!ELEMENT root (#PCDATA)*><!ATTLIST root attr CDATA #REQUIRED><!ENTITY ent 'entity string'>]>";\r
 789                         string xml = dtd + "<root attr='&ent; text'>&ent;</root>";\r
 790                         dvr = new XmlValidatingReader (xml, XmlNodeType.Document, null);\r
 791                         dvr.Read (); // doctype\r
 792                         dvr.Read (); // root\r
 793                         dvr.MoveToAttribute (0); // attr\r
 794                         Assert.IsTrue (dvr.ReadAttributeValue ()); // Should read expanded text\r
 795                         Assert.AreEqual (XmlNodeType.Text, dvr.NodeType); // not EntityReference\r
 796                         Assert.AreEqual ("entity string text", dvr.Value);\r
 797                         Assert.IsTrue (!dvr.ReadAttributeValue ());\r
 798                 }\r
 799 \r
 800                 [Test]\r
 801                 public void ResolveEntitySequentialText ()\r
 802                 {\r
 803                         string xml = @"<!DOCTYPE doc [\r
 804                                 <!ELEMENT doc ANY>\r
 805                                 <!ELEMENT foo  ANY>\r
 806                                 <!ENTITY ref1 '<![CDATA[cdata]]>test'>\r
 807                                 ]>\r
 808                                 <doc><foo>&ref1; test </foo></doc>";\r
 809                         string refOut = "<doc><foo><![CDATA[cdata]]>test test </foo></doc>";\r
 810 \r
 811                         XmlTextReader xtr = new XmlTextReader (xml, XmlNodeType.Document, null);\r
 812                         XmlValidatingReader r = new XmlValidatingReader (xtr);\r
 813                         r.Read ();\r
 814                         r.Read ();\r
 815                         r.Read ();\r
 816                         Assert.AreEqual (refOut, r.ReadOuterXml ());\r
 817                 }\r
 818 \r
 819                 [Test]\r
 820                 // imported testcase from sys.security which had regression.\r
 821                 public void ResolveEntityAndBaseURI ()\r
 822                 {\r
 823                         string world = Path.Combine (Path.GetTempPath (), "world.txt");\r
 824                         string dtd = Path.Combine (Path.GetTempPath (), "doc.dtd");\r
 825                         try {\r
 826                                 using (TextWriter w = File.CreateText (world)) {\r
 827                                         w.WriteLine ("world");\r
 828                                 }\r
 829                                 using (TextWriter w = File.CreateText (dtd)) {\r
 830                                         w.WriteLine ("<!-- dummy -->");\r
 831                                 }\r
 832 \r
 833                                 string xml = String.Format ("<!DOCTYPE doc SYSTEM \"{1}\" [\n" +\r
 834                                         "<!ATTLIST doc attrExtEnt ENTITY #IMPLIED>\n" +\r
 835                                         "<!ENTITY ent1 \"Hello\">\n" +\r
 836                                         "<!ENTITY ent2 SYSTEM \"{0}\">\n" +\r
 837                                         "<!ENTITY entExt SYSTEM \"earth.gif\" NDATA gif>\n" +\r
 838                                         "<!NOTATION gif SYSTEM \"viewgif.exe\">\n" +\r
 839                                         "]>\n" +\r
 840                                         "<doc attrExtEnt=\"entExt\">\n" +\r
 841                                         "   &ent1;, &ent2;!\n" +\r
 842                                         "</doc>\n" +\r
 843                                         "\n" +\r
 844                                         "<!-- Let world.txt contain \"world\" (excluding the quotes) -->\n",\r
 845                                         world, dtd);\r
 846 \r
 847                                 XmlValidatingReader xvr =\r
 848                                         new XmlValidatingReader (\r
 849                                         xml, XmlNodeType.Document, null);\r
 850                                 xvr.ValidationType = ValidationType.None;\r
 851                                 xvr.EntityHandling =\r
 852                                         EntityHandling.ExpandCharEntities;\r
 853                                 XmlDocument doc = new XmlDocument ();\r
 854                                 doc.Load (xvr);\r
 855 \r
 856                         } finally {\r
 857                                 if (File.Exists (world))\r
 858                                         File.Delete (world);\r
 859                                 if (File.Exists (dtd))\r
 860                                         File.Delete (dtd);\r
 861                         }\r
 862                 }\r
 863 \r
 864                 [Test]\r
 865                 //[NotWorking ("default namespace seems null, not String.Empty")]\r
 866 #if NET_2_0\r
 867 #else\r
 868                 // MS.NET 1.x does not consider cases that xmlns* attributes\r
 869                 // could be declared as default.\r
 870                 [Category ("NotDotNet")]\r
 871 #endif\r
 872                 public void DefaultXmlnsAttributeLookup ()\r
 873                 {\r
 874                         string xml = @"<!DOCTYPE X [\r
 875                         <!ELEMENT X (Y)+>\r
 876                         <!ENTITY baz 'urn:baz'>\r
 877                         <!ATTLIST X\r
 878                                 xmlns CDATA 'urn:foo'\r
 879                                 xmlns:bar CDATA 'urn:bar'\r
 880                                 xmlns:baz CDATA #IMPLIED\r
 881                                 dummy CDATA 'dummy'\r
 882                                 baz:dummy CDATA 'dummy'>\r
 883                         <!ELEMENT Y (#PCDATA)*>\r
 884                         <!ATTLIST Y\r
 885                                 xmlns CDATA #IMPLIED\r
 886                                 xmlns:bar CDATA #IMPLIED>\r
 887                         ]>\r
 888                         <X xmlns:baz='&baz;'><Y/><Y>text.</Y><Y xmlns='' xmlns:bar='urn:hoge'>text.</Y></X>";\r
 889                         XmlValidatingReader xvr = new XmlValidatingReader (\r
 890                                 xml, XmlNodeType.Document, null);\r
 891                         xvr.Read (); // DTD\r
 892                         xvr.Read (); // whitespace\r
 893                         xvr.Read ();\r
 894                         Assert.AreEqual ("urn:foo", xvr.LookupNamespace (String.Empty), "#1-1");\r
 895                         Assert.AreEqual ("urn:bar", xvr.LookupNamespace ("bar"), "#1-2");\r
 896 \r
 897                         Assert.AreEqual ("urn:baz", xvr.LookupNamespace ("baz"), "#1-a");\r
 898                         Assert.IsTrue (xvr.MoveToAttribute ("baz:dummy"), "#1-b");\r
 899                         Assert.AreEqual ("urn:baz", xvr.NamespaceURI, "#1-c");\r
 900 \r
 901                         Assert.IsTrue (xvr.MoveToAttribute ("dummy"), "#1-d");\r
 902                         Assert.AreEqual (String.Empty, xvr.NamespaceURI, "#1-e");\r
 903 \r
 904                         xvr.Read (); // first Y, empty element\r
 905                         Assert.AreEqual ("urn:foo", xvr.LookupNamespace (String.Empty), "#2-1");\r
 906                         Assert.AreEqual ("urn:bar", xvr.LookupNamespace ("bar"), "#2-2");\r
 907                         xvr.Read (); // second Y, start element\r
 908                         Assert.AreEqual ("urn:foo", xvr.LookupNamespace (String.Empty), "#3-1");\r
 909                         Assert.AreEqual ("urn:bar", xvr.LookupNamespace ("bar"), "#3-2");\r
 910                         xvr.Read (); // inside normal Y. Check inheritance\r
 911                         Assert.AreEqual ("urn:foo", xvr.LookupNamespace (String.Empty), "#4-1");\r
 912                         Assert.AreEqual ("urn:bar", xvr.LookupNamespace ("bar"), "#4-2");\r
 913                         xvr.Read (); // second Y, end element\r
 914                         Assert.AreEqual ("urn:foo", xvr.LookupNamespace (String.Empty), "#5-1");\r
 915                         Assert.AreEqual ("urn:bar", xvr.LookupNamespace ("bar"), "#5-2");\r
 916                         xvr.Read (); // third Y, suppresses default namespaces\r
 917                         Assert.AreEqual (null, xvr.LookupNamespace (String.Empty), "#6-1");\r
 918                         Assert.AreEqual ("urn:hoge", xvr.LookupNamespace ("bar"), "#6-2");\r
 919                         xvr.Read (); // inside suppressing Y. Check inheritance\r
 920                         Assert.AreEqual (null, xvr.LookupNamespace (String.Empty), "#7-1");\r
 921                         Assert.AreEqual ("urn:hoge", xvr.LookupNamespace ("bar"), "#7-2");\r
 922                         xvr.Read (); // end of suppressing element\r
 923                         Assert.AreEqual (null, xvr.LookupNamespace (String.Empty), "#8-1");\r
 924                         Assert.AreEqual ("urn:hoge", xvr.LookupNamespace ("bar"), "#8-2");\r
 925                 }\r
 926 \r
 927 #if NET_2_0\r
 928                 [Test]\r
 929                 [ExpectedException (typeof (XmlSchemaException))]\r
 930                 public void Bug80231 ()\r
 931                 {\r
 932                         string xml = "<!DOCTYPE file [<!ELEMENT file EMPTY><!ATTLIST file name CDATA #REQUIRED>]><file name=\"foo\" bar=\"baz\" />";\r
 933                         XmlReaderSettings settings = new XmlReaderSettings ();\r
 934                         settings.ProhibitDtd = false;\r
 935                         settings.ValidationType = ValidationType.DTD;\r
 936                         XmlReader r = XmlReader.Create (new StringReader (xml), settings);\r
 937                         while (!r.EOF)\r
 938                                 r.Read ();\r
 939                 }\r
 940 #endif\r
 941 \r
 942 #if NET_2_0             \r
 943                 [Test]          \r
 944                 public void Bug501814 ()\r
 945                 {\r
 946                         string xsd = @"\r
 947                         <xs:schema id='Layout'\r
 948                                 targetNamespace='foo'\r
 949                                 elementFormDefault='qualified'\r
 950                                 xmlns='foo'                  \r
 951                                 xmlns:xs='http://www.w3.org/2001/XMLSchema'>\r
 952 \r
 953                                 <xs:element name='Layout' type='Layout' />\r
 954 \r
 955                                 <xs:complexType name='Layout'>\r
 956                                         <xs:group ref='AnyLayoutElement' minOccurs='0' maxOccurs='unbounded' />\r
 957                                 </xs:complexType>\r
 958 \r
 959                                 <xs:group name='AnyLayoutElement'>\r
 960                                         <xs:choice>                     \r
 961                                                 <xs:element name='Label' type='Label' />                        \r
 962                                         </xs:choice>\r
 963                                 </xs:group>\r
 964         \r
 965                                 <xs:complexType name='LayoutElement' abstract='true'>\r
 966                                         <xs:attribute name='id' type='xs:ID' use='optional' />\r
 967                                         <xs:attribute name='visible' type='xs:boolean' use='optional' default='true' />\r
 968                                 </xs:complexType>\r
 969         \r
 970                                 <xs:complexType name='Label'>\r
 971                                         <xs:complexContent mixed='true'>\r
 972                                                 <xs:extension base='LayoutElement'>\r
 973                                                 <xs:attribute name='bold' type='xs:boolean' use='required'/>\r
 974                                                 </xs:extension>\r
 975                                         </xs:complexContent>\r
 976                                         </xs:complexType>\r
 977                         </xs:schema>";\r
 978                         \r
 979                         XmlDocument doc = new XmlDocument ();\r
 980                         \r
 981                         XmlSchema schema = XmlSchema.Read (XmlReader.Create (new StringReader (xsd)), null);                    \r
 982                         \r
 983                         doc.LoadXml (@"\r
 984                                 <Layout xmlns='foo'>\r
 985                     <Label bold='false'>Text inside label</Label>\r
 986                 </Layout>");\r
 987                         doc.Schemas.Add (schema);\r
 988                         doc.Validate (null);\r
 989                 }\r
 990 #endif\r
 991                 \r
 992 #if NET_2_0\r
 993                 [Test]          \r
 994                 public void Bug502168 ()\r
 995                 {\r
 996                         string xsd = @"<xs:schema id='Layout'\r
 997                                 targetNamespace='foo'\r
 998                                 elementFormDefault='qualified'\r
 999                                 xmlns='foo'                  \r
1000                                 xmlns:xs='http://www.w3.org/2001/XMLSchema'>\r
1001 \r
1002                                 <xs:element name='Layout' type='Layout' />\r
1003                                 \r
1004                                  <xs:complexType name='Layout'>\r
1005                                   <xs:group ref='AnyLayoutElement' minOccurs='0' maxOccurs='unbounded' />\r
1006                                  </xs:complexType>\r
1007                                 \r
1008                                  <xs:group name='AnyLayoutElement'>\r
1009                                   <xs:choice>\r
1010                                    <xs:element name='Layout' type='Layout' />   \r
1011                                    <xs:element name='ImageContainer' type='ImageContainer' />\r
1012                                    <xs:element name='VideoInstance' type='VideoInstance'/>\r
1013                                   </xs:choice>\r
1014                                  </xs:group>\r
1015                                 \r
1016                                  <xs:complexType name='ImageDummy'>\r
1017                                  </xs:complexType>\r
1018                                 \r
1019                                  <xs:complexType name='LayoutElement' abstract='true'>  \r
1020                                  </xs:complexType>\r
1021                                 \r
1022                                  <xs:group name='AnyImageElement'>\r
1023                                   <xs:choice>\r
1024                                    <xs:element name='ImageDummy' type='ImageDummy' />\r
1025                                   </xs:choice>\r
1026                                  </xs:group>\r
1027                                 \r
1028                                  <xs:complexType name='ImageContainer'>\r
1029                                   <xs:complexContent>\r
1030                                    <xs:extension base='LayoutElement'>\r
1031                                     <xs:choice minOccurs='1' maxOccurs='1'>\r
1032                                      <xs:element name='Content' type='SingleImage' minOccurs='1' maxOccurs='1'\r
1033                                 nillable='false'/>\r
1034                                     </xs:choice>    \r
1035                                    </xs:extension>\r
1036                                   </xs:complexContent>\r
1037                                  </xs:complexType>\r
1038                                 \r
1039                                  <xs:complexType name='SingleImage'>\r
1040                                   <xs:group ref='AnyImageElement' minOccurs='1' maxOccurs='1'/>\r
1041                                  </xs:complexType>\r
1042                                 \r
1043                                  <xs:complexType name='VideoApplicationFile'>\r
1044                                   <xs:complexContent>\r
1045                                    <xs:extension base='VideoInstance'>\r
1046                                     <xs:attribute name='fileName' type='xs:string' use='optional'/>\r
1047                                    </xs:extension>\r
1048                                   </xs:complexContent>\r
1049                                  </xs:complexType>\r
1050                                 \r
1051                                  <xs:complexType abstract='true' name='Video'>\r
1052                                   <xs:complexContent>\r
1053                                    <xs:extension base='LayoutElement'>\r
1054                                     <xs:group ref='AnyImageElement' minOccurs='0' maxOccurs='1'/>    \r
1055                                    </xs:extension>\r
1056                                   </xs:complexContent>\r
1057                                  </xs:complexType>\r
1058                                 \r
1059                                  <xs:complexType abstract='true' name='VideoInstance'>\r
1060                                   <xs:complexContent>\r
1061                                    <xs:extension base='Video'>\r
1062                                     <xs:attribute name='name' type='xs:string' use='optional'/>\r
1063                                    </xs:extension>\r
1064                                   </xs:complexContent>\r
1065                                  </xs:complexType>\r
1066                                 </xs:schema>";\r
1067 \r
1068 \r
1069                         XmlDocument doc = new XmlDocument ();\r
1070                         XmlSchema schema = XmlSchema.Read (XmlReader.Create (new StringReader (xsd)), null);\r
1071                         doc.LoadXml (@"<Layout xmlns='foo' />");\r
1072                         doc.Schemas.Add(schema);\r
1073                         doc.Validate(null);\r
1074                 }\r
1075 #endif          \r
1076         }\r
1077 }\r