mcs/class/System.XML/Test/System.Xml.Xsl/XslTransformTests.cs

   1 //
   2 // System.Xml.Xsl.XslTransformTests.cs
   3 //
   4 // Author:
   5 //   Atsushi Enomoto <ginga@kit.hi-ho.ne.jp>
   6 //
   7 // (C) 2002 Atsushi Enomoto
   8 //
   9
  10 using System;
  11 using System.Globalization;
  12 using System.IO;
  13 using System.Text;
  14 using System.Xml;
  15 using System.Xml.XPath;
  16 using System.Xml.Xsl;
  17 using NUnit.Framework;
  18
  19 namespace MonoTests.System.Xml.Xsl
  20 {
  21         [TestFixture]
  22         public class XslTransformTests
  23         {
  24                 XmlDocument doc;
  25                 XslTransform xslt;
  26                 XmlDocument result;
  27
  28                 [SetUp]
  29                 public void GetReady()
  30                 {
  31                         doc = new XmlDocument ();
  32                         xslt = new XslTransform ();
  33                         result = new XmlDocument ();
  34                 }
  35
  36                 [Test]
  37                 public void TestBasicTransform ()
  38                 {
  39                         doc.LoadXml ("<root/>");
  40                         xslt.Load ("Test/XmlFiles/xsl/empty.xsl");
  41                         xslt.Transform ("Test/XmlFiles/xsl/empty.xsl", "Test/XmlFiles/xsl/result.xml");
  42                         result.Load ("Test/XmlFiles/xsl/result.xml");
  43                         Assert.AreEqual (2, result.ChildNodes.Count, "count");
  44                 }
  45
  46                 [Test]
  47                 [ExpectedException (typeof (XsltCompileException))]
  48                 public void InvalidStylesheet ()
  49                 {
  50                         XmlDocument doc = new XmlDocument ();
  51                         doc.LoadXml ("<xsl:element xmlns:xsl='http://www.w3.org/1999/XSL/Transform' />");
  52                         XslTransform t = new XslTransform ();
  53                         t.Load (doc);
  54                 }
  55
  56                 [Test]
  57                 [ExpectedException (typeof (XsltCompileException))]
  58                 public void EmptyStylesheet ()
  59                 {
  60                         XmlDocument doc = new XmlDocument ();
  61                         XslTransform t = new XslTransform ();
  62                         t.Load (doc);
  63                 }
  64
  65                 [Test]
  66                 [ExpectedException (typeof (XsltCompileException))]
  67                 public void InvalidStylesheet2 ()
  68                 {
  69                         string xsl = @"<xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0'>
  70 <xsl:template match='/root'>
  71         <xsl:call-template name='foo'>
  72                 <xsl:with-param name='name' value='text()' />
  73         </xsl:call-template>
  74 </xsl:template>
  75 <xsl:template name='foo'>
  76         <xsl:param name='name' />
  77         <result>
  78                 <xsl:if test='1'>
  79                         <xsl:variable name='last' value='text()' />
  80                         <xsl:value-of select='$last' />
  81                 </xsl:if>
  82         </result>
  83 </xsl:template>
  84 </xsl:stylesheet>
  85 ";
  86                         XslTransform xslt = new XslTransform ();
  87                         xslt.Load (new XPathDocument (new XmlTextReader (xsl, XmlNodeType.Document, null)));
  88                 }
  89
  90                 [Test()]
  91                 [Category ("NotWorking")] // it depends on "mcs" existence
  92                 public void MsxslTest() {
  93                         string _styleSheet = @"
  94                         <xslt:stylesheet xmlns:xslt=""http://www.w3.org/1999/XSL/Transform"" version=""1.0""
  95 xmlns:msxsl=""urn:schemas-microsoft-com:xslt"" xmlns:stringutils=""urn:schemas-sourceforge.net-blah"">
  96 <xslt:output method=""text"" />
  97 <msxsl:script language=""C#"" implements-prefix=""stringutils"">
  98         <![CDATA[
  99                 string PadRight( string str, int padding) {
 100                         return str.PadRight(padding);
 101                 }
 102         ]]>
 103 </msxsl:script>
 104 <xslt:template match=""test"">
 105         <xslt:value-of select=""stringutils:PadRight(@name, 20)"" />
 106 </xslt:template>
 107 </xslt:stylesheet>";
 108
 109                         StringReader stringReader = new StringReader(_styleSheet);
 110
 111                         XslTransform transform = new XslTransform();
 112                         XmlTextReader reader = new XmlTextReader(stringReader);
 113                         transform.Load(reader, new XmlUrlResolver(), AppDomain.CurrentDomain.Evidence);
 114
 115                         StringBuilder sb = new StringBuilder();
 116                         StringWriter writer = new StringWriter(sb, CultureInfo.InvariantCulture);
 117                         XsltArgumentList arguments = new XsltArgumentList();
 118
 119                         XmlDocument xmlDoc = new XmlDocument();
 120                         xmlDoc.LoadXml("<test name=\"test\" />");
 121
 122                         // Do transformation
 123                         transform.Transform(xmlDoc, new XsltArgumentList(), writer, new XmlUrlResolver());
 124
 125                         Assert.AreEqual ("test".PadRight(20), sb.ToString());
 126                 }
 127
 128                 [Test]
 129                 public void MSXslNodeSet ()
 130                 {
 131                         string xsl = @"<xsl:stylesheet version='1.0'
 132 xmlns:xsl='http://www.w3.org/1999/XSL/Transform' xmlns:msxsl='urn:schemas-microsoft-com:xslt'>
 133 <xsl:template match='/'>
 134         <root>
 135                 <xsl:variable name='var'>
 136                         <xsl:copy-of select='root/foo' />
 137                 </xsl:variable>
 138                 <xsl:for-each select='msxsl:node-set($var)/foo'>
 139                         <xsl:value-of select='name(.)' />: <xsl:value-of select='@attr' />
 140                 </xsl:for-each>
 141         </root>
 142 </xsl:template>
 143 </xsl:stylesheet>";
 144                         StringWriter sw = new StringWriter ();
 145                         XslTransform t = new XslTransform ();
 146                         t.Load (new XPathDocument (new StringReader (xsl)));
 147                         t.Transform (new XPathDocument (new XmlTextReader (new StringReader ("<root><foo attr='A'/><foo attr='B'/><foo attr='C'/></root>"))), null, sw);
 148                         Assert.AreEqual (@"<?xml version=""1.0"" encoding=""utf-16""?><root xmlns:msxsl=""urn:schemas-microsoft-com:xslt"">foo: Afoo: Bfoo: C</root>", sw.ToString ());
 149                 }
 150
 151                 [Test]
 152                 [Category ("NotDotNet")]
 153                 // Actually MS.NET here throws XsltException, but Mono returns
 154                 // XPathException (since XPath evaluation engine generally
 155                 // catches (should catch) static error. It is implementation
 156                 // dependent matter.
 157                 [ExpectedException (typeof (XPathException))]
 158                 public void MSXslNodeSetRejectsNodeSet ()
 159                 {
 160                         string xsl = @"<xsl:stylesheet version='1.0'
 161 xmlns:xsl='http://www.w3.org/1999/XSL/Transform' xmlns:msxsl='urn:schemas-microsoft-com:xslt'>
 162 <xsl:template match='/'>
 163         <root>
 164                 <!-- msxsl:node-set() does not accept a node set -->
 165                 <xsl:for-each select='msxsl:node-set(root/foo)'>
 166                         <xsl:value-of select='name(.)' />: <xsl:value-of select='@attr' />
 167                 </xsl:for-each>
 168         </root>
 169 </xsl:template>
 170 </xsl:stylesheet>";
 171                         StringWriter sw = new StringWriter ();
 172                         XslTransform t = new XslTransform ();
 173                         t.Load (new XPathDocument (new StringReader (xsl)));
 174                         t.Transform (new XPathDocument (new XmlTextReader (new StringReader ("<root><foo attr='A'/><foo attr='B'/><foo attr='C'/></root>"))), null, sw);
 175                 }
 176
 177                 [Test]
 178                 public void EvaluateEmptyVariableAsBoolean ()
 179                 {
 180                         string xsl = @"<xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0'>
 181 <xsl:template match='/'>
 182         <xsl:variable name='var'><empty /></xsl:variable>
 183         <root><xsl:if test='$var'>true</xsl:if></root>
 184 </xsl:template>
 185 </xsl:stylesheet>";
 186                         XslTransform t = new XslTransform ();
 187                         t.Load (new XPathDocument (new StringReader (xsl)));
 188                         StringWriter sw = new StringWriter ();
 189                         t.Transform (
 190                                 new XPathDocument (new StringReader ("<root/>")),
 191                                 null,
 192                                 sw);
 193                         Assert.IsTrue (sw.ToString ().IndexOf ("true") > 0);
 194                 }
 195
 196                 [Test]
 197                 [ExpectedException (typeof (XsltCompileException))]
 198                 public void NotAllowedPatternAxis ()
 199                 {
 200                         string xsl = @"<xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0'>
 201 <xsl:template match='/descendant-or-self::node()/elem'>
 202         <ERROR/>
 203 </xsl:template>
 204 </xsl:stylesheet>";
 205                         new XslTransform ().Load (new XPathDocument (
 206                                 new StringReader (xsl)));
 207                 }
 208
 209                 [Test]
 210                 [ExpectedException (typeof (XsltCompileException))]
 211                 public void ImportIncorrectlyLocated ()
 212                 {
 213                         string xsl = @"<xsl:transform xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0'>
 214 <xsl:template match='/'></xsl:template>
 215         <xsl:import href='dummy.xsl' />
 216 </xsl:transform>";
 217                         new XslTransform ().Load (new XPathDocument (
 218                                 new StringReader (xsl)));
 219                 }
 220
 221                 private WeakReference StylesheetLoad (XslTransform t, string xsl)
 222                 {
 223                         XPathDocument doc = new XPathDocument (
 224                                 new StringReader (xsl));
 225                         WeakReference wr = new WeakReference (doc);
 226                         t.Load (doc);
 227                         return wr;
 228                 }
 229
 230                 private WeakReference StylesheetTransform (XslTransform t, string xml)
 231                 {
 232                         XPathDocument doc = new XPathDocument (
 233                                 new StringReader (xml));
 234                         WeakReference wr = new WeakReference (doc);
 235                         t.Transform (doc, null, TextWriter.Null, null);
 236                         return wr;
 237                 }
 238
 239                 [Test]
 240                 // bug #75663.
 241                 public void ErrorOnDocumentResolution ()
 242                 {
 243                         // XslTransform recovers from errors on document resolution.
 244                         string xslText = @"<xsl:stylesheet
 245                                 xmlns:xsl='http://www.w3.org/1999/XSL/Transform'
 246                                 version='1.0'>
 247                                 <xsl:variable name='n'
 248                                         select='document(""notexist.xml"")' />
 249                                 <xsl:template match='/'>xx</xsl:template>
 250                                 </xsl:stylesheet>";
 251                         string xmlText = @"<root />";
 252                         XslTransform transform = new XslTransform ();
 253                         XPathDocument doc = new XPathDocument (
 254                                 new XmlTextReader ("a.xsl", new StringReader (xslText)));
 255                         transform.Load (doc);
 256                         XPathDocument xmlDocument = new XPathDocument (new StringReader (xmlText));
 257
 258                         StringWriter sw = new StringWriter ();
 259                         transform.Transform (xmlDocument, null, sw);
 260
 261                         Assert.AreEqual (
 262                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 263                                 "xx", sw.ToString ());
 264                 }
 265
 266                 // bug #76046
 267                 [Test]
 268                 public void LoadStyleFromNonRoot ()
 269                 {
 270                         XmlDocument doc = new XmlDocument ();
 271                         XslTransform xslt = new XslTransform ();
 272                         doc.LoadXml ("<root><dummy /><xsl:transform xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0' /></root>");
 273                         XmlNode node = doc.ChildNodes [0].ChildNodes [1];
 274                         xslt.Load (node, null, null);
 275                 }
 276
 277                 [Test]
 278                 public void ReturnEmptyResultsAsXmlReader ()
 279                 {
 280                         // bug #76115
 281                         XmlDocument doc = new XmlDocument ();
 282                         doc.LoadXml ("<xsl:transform xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0' />");
 283                         XslTransform xslt = new XslTransform ();
 284                         xslt.Load (doc, null, null);
 285                         XmlReader reader = xslt.Transform(doc, null, new XmlUrlResolver ());
 286                         reader.Read ();
 287
 288                         // another case - with xsl:output standalone='yes'
 289                         doc.LoadXml ("<xsl:transform xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0' ><xsl:output standalone='yes' indent='no'/><xsl:template match='/'><foo/></xsl:template></xsl:transform>");
 290                         xslt = new XslTransform ();
 291                         xslt.Load (doc, null, null);
 292                         reader = xslt.Transform (doc, null, new XmlUrlResolver ());
 293                         while (!reader.EOF)
 294                                 reader.Read (); // btw no XMLdecl output.
 295                 }
 296
 297                 [Test] // bug #76530
 298                 // http://www.w3.org/TR/xslt#section-Creating-Elements-with-xsl:element
 299                 // "If the namespace attribute is not present then the QName
 300                 // is expanded into an expanded-name using the namespace
 301                 // declarations in effect for the xsl:element element,
 302                 // including any default namespace declaration."
 303                 public void LREDefaultNamespace ()
 304                 {
 305                         string xsl = @"<xsl:stylesheet version='1.0' xmlns='urn:foo' xmlns:xsl='http://www.w3.org/1999/XSL/Transform'>
 306                                 <xsl:template match='/*'>
 307                                         <xsl:element name='{local-name()}' />
 308                                 </xsl:template>
 309                         </xsl:stylesheet>";
 310                         string xml = "<root/>";
 311                         XslTransform t = new XslTransform ();
 312                         t.Load (new XPathDocument (new StringReader (xsl)));
 313                         StringWriter sw = new StringWriter ();
 314                         XmlTextWriter xw = new XmlTextWriter (sw);
 315                         t.Transform (
 316                                 new XPathDocument (new StringReader (xml)),
 317                                 null, xw);
 318                         Assert.AreEqual ("<root xmlns=\"urn:foo\" />",
 319                                 sw.ToString ());
 320
 321                         string xsl2 = @"<xsl:stylesheet version='1.0' xmlns:xsl='http://www.w3.org/1999/XSL/Transform' xmlns='urn:foo'>
 322                                 <xsl:template match='/*'>
 323                                         <root>
 324                                                 <xsl:element name='{local-name()}' />
 325                                         </root>
 326                                 </xsl:template>
 327                         </xsl:stylesheet>";
 328                         string xml2 = "<page/>";
 329                         t.Load (new XPathDocument (new StringReader (xsl2)));
 330                         sw = new StringWriter ();
 331                         xw = new XmlTextWriter (sw);
 332                         t.Transform (
 333                                 new XPathDocument (new StringReader (xml2)),
 334                                 null, xw);
 335                         Assert.AreEqual ("<root xmlns=\"urn:foo\"><page /></root>",
 336                                 sw.ToString ());
 337                 }
 338
 339                 [Test]
 340                 // http://lists.ximian.com/pipermail/mono-devel-list/2005-November/015812.html
 341                 public void WhitespaceHandling ()
 342                 {
 343                         string ref_out = @"XML
 344         Extensible Markup language
 345          Great stuffs
 346     XSLT
 347         Extensible Markup language
 348          Great stuffs
 349     XPATH
 350         Extensible Markup language
 351          Great stuffs
 352     XSD
 353         Extensible Markup language
 354          Great stuffs
 355     ";
 356
 357                         XmlDocument d = new XmlDocument ();
 358                         d.Load ("Test/XmlFiles/xsl/91834.xml");
 359
 360                         XslTransform t = new XslTransform ();
 361                         t.Load ("Test/XmlFiles/xsl/91834.xsl");
 362
 363                         StringWriter sw_raw = new StringWriter ();
 364                         t.Transform (d, null, sw_raw);
 365
 366                         Assert.AreEqual (ref_out, sw_raw.ToString ().Replace ("\r\n", "\n"));
 367                 }
 368
 369                 // http://support.microsoft.com/default.aspx?scid=kb;en-us;829014
 370                 [Test]
 371                 public void EmptyNodeSetSort ()
 372                 {
 373                         string xmlFragment = @"<?xml version=""1.0"" encoding=""utf-8""?>
 374                                 <EMPLOYEES>
 375                                         <EMPLOYEE>
 376                                                 <NAME>Steve</NAME>
 377                                                 <DEPT>IT</DEPT>
 378                                                 <SKILL>C++</SKILL>
 379                                                 <SKILL>C#</SKILL>
 380                                         </EMPLOYEE>
 381                                         <EMPLOYEE>
 382                                                 <NAME>John</NAME>
 383                                                 <DEPT>IT</DEPT>
 384                                                 <SKILL>VB.NET</SKILL>
 385                                                 <SKILL>SQl Server</SKILL>
 386                                         </EMPLOYEE>
 387                                 </EMPLOYEES>";
 388
 389                         string xsltFragment = @"<?xml version=""1.0""?>
 390                                 <xsl:stylesheet version=""1.0"" xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"">
 391                                         <xsl:output omit-xml-declaration=""yes"" />
 392                                         <xsl:preserve-space elements=""*"" />
 393                                         <xsl:template match=""/EMPLOYEES"">
 394                                                 <xsl:for-each select=""EMPLOYEE[DEPT='Finance']"">
 395                                                         <xsl:sort select=""NAME""/>
 396                                                         <xsl:value-of select=""NAME""/>
 397                                                 </xsl:for-each>
 398                                         </xsl:template>
 399                                 </xsl:stylesheet>";
 400
 401                         XmlTextReader xmlRdr = new XmlTextReader (new StringReader (xmlFragment));
 402                         XmlTextReader xsltRdr = new XmlTextReader (new StringReader (xsltFragment));
 403
 404                         XslTransform stylesheet = new XslTransform ();
 405                         stylesheet.Load (xsltRdr, new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 406
 407                         StringWriter sw = new StringWriter ();
 408
 409                         stylesheet.Transform (new XPathDocument (xmlRdr), new XsltArgumentList (),
 410                                 sw, new XmlUrlResolver ());
 411
 412                         Assert.AreEqual (0, sw.ToString ().Length);
 413                 }
 414
 415                 // http://support.microsoft.com/default.aspx?scid=kb;en-us;834667
 416                 [Test]
 417 #if NET_1_1
 418                 [Category ("NotDotNet")]
 419 #endif
 420                 public void LocalParameter ()
 421                 {
 422                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 423                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 424                                         <xsl:param name=""param1"" select=""'global-param1-default'"" />
 425                                         <xsl:param name=""param2"" select=""'global-param2-default'"" />
 426                                         <xsl:output method=""text"" encoding=""ascii"" />
 427                                         <xsl:template match=""/"">
 428                                                 <xsl:call-template name=""Test"">
 429                                                         <xsl:with-param name=""param1"" select=""'local-param1-arg'"" />
 430                                                         <xsl:with-param name=""param2"" select=""'local-param2-arg'"" />
 431                                                 </xsl:call-template>
 432                                         </xsl:template>
 433                                         <xsl:template name=""Test"">
 434                                                 <xsl:param name=""param1"" select=""'local-param1-default'"" />
 435                                                 <xsl:param name=""param2"" select=""'local-param2-default'"" />
 436                                                 <xsl:value-of select=""$param1"" /><xsl:text>/</xsl:text><xsl:value-of select=""$param2"" />
 437                                         </xsl:template>
 438                                 </xsl:stylesheet>";
 439
 440                         XmlDocument xmlDoc = new XmlDocument ();
 441                         xmlDoc.LoadXml ("<dummy />");
 442
 443                         XslTransform xsltProcessor = new XslTransform ();
 444                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 445                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 446
 447                         StringWriter sw = new StringWriter ();
 448
 449                         XsltArgumentList xsltArgs = new XsltArgumentList ();
 450                         xsltArgs.AddParam ("param1", string.Empty, "global-param1-arg");
 451                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 452
 453                         Assert.AreEqual ("local-param1-arg/local-param2-arg", sw.ToString ());
 454                 }
 455
 456                 [Test]
 457                 public void Output_Standalone ()
 458                 {
 459                         StringWriter sw = null;
 460                         XsltArgumentList xsltArgs = new XsltArgumentList ();
 461                         XslTransform xsltProcessor = new XslTransform ();
 462
 463                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 464                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 465                                         <xsl:output {0} />
 466                                         <xsl:template match=""/"">
 467                                                 <root />
 468                                         </xsl:template>
 469                                 </xsl:stylesheet>";
 470
 471                         XmlDocument xmlDoc = new XmlDocument ();
 472                         xmlDoc.LoadXml ("<dummy />");
 473
 474                         sw = new StringWriter ();
 475                         xsltProcessor.Load (new XmlTextReader (new StringReader (
 476                                 string.Format(xsltFragment, "standalone=\"yes\""))),
 477                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 478                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 479
 480                         Assert.AreEqual (
 481                                 "<?xml version=\"1.0\" encoding=\"utf-16\"" +
 482                                 " standalone=\"yes\"?><root />", sw.ToString (), "#1");
 483
 484                         sw = new StringWriter ();
 485                         xsltProcessor.Load (new XmlTextReader (new StringReader (
 486                                 string.Format (xsltFragment, "standalone=\"no\""))),
 487                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 488                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 489
 490                         Assert.AreEqual (
 491                                 "<?xml version=\"1.0\" encoding=\"utf-16\"" +
 492                                 " standalone=\"no\"?><root />", sw.ToString (), "#2");
 493
 494                         sw = new StringWriter ();
 495                         xsltProcessor.Load (new XmlTextReader (new StringReader (
 496                                 string.Format (xsltFragment, ""))),
 497                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 498                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 499
 500                         Assert.AreEqual (
 501                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 502                                 "<root />", sw.ToString (), "#3");
 503                 }
 504
 505                 [Test]
 506                 [ExpectedException (typeof (XsltCompileException))]
 507                 public void Output_Standalone_Invalid ()
 508                 {
 509                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 510                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 511                                         <xsl:output standalone=""Yes"" />
 512                                 </xsl:stylesheet>";
 513                         XslTransform xsltProcessor = new XslTransform ();
 514                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 515                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 516                 }
 517
 518                 [Test]
 519                 [ExpectedException (typeof (XsltCompileException))]
 520                 public void Output_Standalone_Empty ()
 521                 {
 522                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 523                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 524                                         <xsl:output standalone="""" />
 525                                 </xsl:stylesheet>";
 526                         XslTransform xsltProcessor = new XslTransform ();
 527                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 528                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 529                 }
 530
 531                 [Test]
 532                 public void Output_OmitXmlDeclaration ()
 533                 {
 534                         StringWriter sw = null;
 535                         XsltArgumentList xsltArgs = new XsltArgumentList ();
 536                         XslTransform xsltProcessor = new XslTransform ();
 537
 538                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 539                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 540                                         <xsl:output {0} />
 541                                         <xsl:template match=""/"">
 542                                                 <root />
 543                                         </xsl:template>
 544                                 </xsl:stylesheet>";
 545
 546                         XmlDocument xmlDoc = new XmlDocument ();
 547                         xmlDoc.LoadXml ("<dummy />");
 548
 549                         sw = new StringWriter ();
 550                         xsltProcessor.Load (new XmlTextReader (new StringReader (
 551                                 string.Format (xsltFragment, "omit-xml-declaration=\"yes\""))),
 552                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 553                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 554
 555                         Assert.AreEqual ("<root />", sw.ToString (), "#1");
 556
 557                         sw = new StringWriter ();
 558                         xsltProcessor.Load (new XmlTextReader (new StringReader (
 559                                 string.Format (xsltFragment, "omit-xml-declaration=\"no\""))),
 560                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 561                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 562
 563                         Assert.AreEqual (
 564                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 565                                 "<root />", sw.ToString (), "#2");
 566                 }
 567
 568                 [Test]
 569                 [ExpectedException (typeof (XsltCompileException))]
 570                 public void Output_OmitXmlDeclaration_Invalid ()
 571                 {
 572                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 573                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 574                                         <xsl:output omit-xml-declaration=""Yes"" />
 575                                 </xsl:stylesheet>";
 576                         XslTransform xsltProcessor = new XslTransform ();
 577                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 578                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 579                 }
 580
 581                 [Test]
 582                 [ExpectedException (typeof (XsltCompileException))]
 583                 public void Output_OmitXmlDeclaration_Empty ()
 584                 {
 585                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 586                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 587                                         <xsl:output omit-xml-declaration="""" />
 588                                 </xsl:stylesheet>";
 589                         XslTransform xsltProcessor = new XslTransform ();
 590                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 591                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 592                 }
 593
 594                 [Test]
 595                 public void Output_DocType_Xml ()
 596                 {
 597                         XsltArgumentList xsltArgs = new XsltArgumentList ();
 598                         XslTransform xsltProcessor = new XslTransform ();
 599
 600                         // set both doctype-system and doctype-public
 601                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 602                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 603                                         <xsl:output
 604                                                 doctype-public=""-//W3C//DTD XHTML 1.0 Strict//EN""
 605                                                 doctype-system=""http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"" />
 606                                         <xsl:template match=""/"">
 607                                                 <xsl:element name=""test"">
 608                                                         <xsl:element name=""abc"" />
 609                                                 </xsl:element>
 610                                         </xsl:template>
 611                                 </xsl:stylesheet>";
 612
 613                         XmlDocument xmlDoc = new XmlDocument ();
 614                         xmlDoc.LoadXml ("<dummy />");
 615
 616                         StringWriter sw = new StringWriter ();
 617                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 618                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 619                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 620
 621                         Assert.AreEqual (
 622                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 623                                 "<!DOCTYPE test PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">" +
 624                                 "<test><abc /></test>", sw.ToString (), "#1");
 625
 626                         // only set doctype-public
 627                         xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 628                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 629                                         <xsl:output
 630                                                 doctype-public=""-//W3C//DTD XHTML 1.0 Strict//EN"" />
 631                                         <xsl:template match=""/"">
 632                                                 <xsl:element name=""test"">
 633                                                         <xsl:element name=""abc"" />
 634                                                 </xsl:element>
 635                                         </xsl:template>
 636                                 </xsl:stylesheet>";
 637
 638                         sw.GetStringBuilder ().Length = 0;
 639                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 640                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 641                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 642
 643                         Assert.AreEqual (
 644                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 645                                 "<test><abc /></test>", sw.ToString (), "#2");
 646
 647                         // only set doctype-system
 648                         xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 649                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 650                                         <xsl:output
 651                                                 indent=""no""
 652                                                 doctype-system=""http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"" />
 653                                         <xsl:template match=""/"">
 654                                                 <xsl:element name=""test"">
 655                                                         <xsl:element name=""abc"" />
 656                                                 </xsl:element>
 657                                         </xsl:template>
 658                                 </xsl:stylesheet>";
 659
 660                         sw.GetStringBuilder ().Length = 0;
 661                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 662                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 663                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 664
 665                         Assert.AreEqual (
 666                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 667                                 "<!DOCTYPE test SYSTEM \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">" +
 668                                 "<test><abc /></test>", sw.ToString (), "#3");
 669
 670                         // set empty doctype-public and empty doctype-system
 671                         xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 672                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 673                                         <xsl:output
 674                                                 doctype-public=""""
 675                                                 doctype-system="""" />
 676                                         <xsl:template match=""/"">
 677                                                 <xsl:element name=""test"">
 678                                                         <xsl:element name=""abc"" />
 679                                                 </xsl:element>
 680                                         </xsl:template>
 681                                 </xsl:stylesheet>";
 682
 683                         sw.GetStringBuilder ().Length = 0;
 684                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 685                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 686                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 687
 688                         Assert.AreEqual (
 689                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 690                                 "<!DOCTYPE test PUBLIC \"\" \"\">" +
 691                                 "<test><abc /></test>", sw.ToString (), "#4");
 692
 693                         // set empty doctype-public
 694                         xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 695                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 696                                         <xsl:output
 697                                                 indent=""no""
 698                                                 doctype-public="""" />
 699                                         <xsl:template match=""/"">
 700                                                 <xsl:element name=""test"">
 701                                                         <xsl:element name=""abc"" />
 702                                                 </xsl:element>
 703                                         </xsl:template>
 704                                 </xsl:stylesheet>";
 705
 706                         sw.GetStringBuilder ().Length = 0;
 707                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 708                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 709                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 710
 711                         Assert.AreEqual (
 712                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 713                                 "<test><abc /></test>", sw.ToString (), "#5");
 714
 715                         // set empty doctype-system
 716                         xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 717                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 718                                         <xsl:output
 719                                                 doctype-system="""" />
 720                                         <xsl:template match=""/"">
 721                                                 <xsl:element name=""test"">
 722                                                         <xsl:element name=""abc"" />
 723                                                 </xsl:element>
 724                                         </xsl:template>
 725                                 </xsl:stylesheet>";
 726
 727                         sw.GetStringBuilder ().Length = 0;
 728                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 729                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 730                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 731
 732                         Assert.AreEqual (
 733                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 734                                 "<!DOCTYPE test SYSTEM \"\">" +
 735                                 "<test><abc /></test>", sw.ToString (), "#6");
 736                 }
 737
 738                 [Test]
 739                 public void Output_DocType_Html ()
 740                 {
 741                         XsltArgumentList xsltArgs = new XsltArgumentList ();
 742                         XslTransform xsltProcessor = new XslTransform ();
 743
 744                         // set both doctype-system and doctype-public
 745                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 746                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 747                                         <xsl:output
 748                                                 method=""html""
 749                                                 indent=""no""
 750                                                 doctype-public=""-//W3C//DTD XHTML 1.0 Strict//EN""
 751                                                 doctype-system=""http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"" />
 752                                         <xsl:template match=""/"">
 753                                                 <xsl:element name=""test"">
 754                                                         <xsl:element name=""abc"" />
 755                                                 </xsl:element>
 756                                         </xsl:template>
 757                                 </xsl:stylesheet>";
 758
 759                         XmlDocument xmlDoc = new XmlDocument ();
 760                         xmlDoc.LoadXml ("<dummy />");
 761
 762                         StringWriter sw = new StringWriter ();
 763                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 764                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 765                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 766
 767                         Assert.AreEqual (
 768                                 "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">" +
 769                                 "<test><abc></abc></test>", sw.ToString (), "#1");
 770
 771                         // only set doctype-public
 772                         xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 773                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 774                                         <xsl:output
 775                                                 method=""html""
 776                                                 indent=""no""
 777                                                 doctype-public=""-//W3C//DTD XHTML 1.0 Strict//EN"" />
 778                                         <xsl:template match=""/"">
 779                                                 <xsl:element name=""test"">
 780                                                         <xsl:element name=""abc"" />
 781                                                 </xsl:element>
 782                                         </xsl:template>
 783                                 </xsl:stylesheet>";
 784
 785                         sw.GetStringBuilder ().Length = 0;
 786                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 787                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 788                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 789
 790                         Assert.AreEqual (
 791                                 "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" >" +
 792                                 "<test><abc></abc></test>", sw.ToString (), "#2");
 793
 794                         // only set doctype-system
 795                         xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 796                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 797                                         <xsl:output
 798                                                 method=""html""
 799                                                 indent=""no""
 800                                                 doctype-system=""http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"" />
 801                                         <xsl:template match=""/"">
 802                                                 <xsl:element name=""test"">
 803                                                         <xsl:element name=""abc"" />
 804                                                 </xsl:element>
 805                                         </xsl:template>
 806                                 </xsl:stylesheet>";
 807
 808                         sw.GetStringBuilder ().Length = 0;
 809                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 810                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 811                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 812
 813                         Assert.AreEqual (
 814                                 "<!DOCTYPE html SYSTEM \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">" +
 815                                 "<test><abc></abc></test>", sw.ToString (), "#3");
 816
 817                         // set empty doctype-public and empty doctype-system
 818                         xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 819                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 820                                         <xsl:output
 821                                                 method=""html""
 822                                                 indent=""no""
 823                                                 doctype-public="""" doctype-system="""" />
 824                                         <xsl:template match=""/"">
 825                                                 <xsl:element name=""test"">
 826                                                         <xsl:element name=""abc"" />
 827                                                 </xsl:element>
 828                                         </xsl:template>
 829                                 </xsl:stylesheet>";
 830
 831                         sw.GetStringBuilder ().Length = 0;
 832                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 833                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 834                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 835
 836                         Assert.AreEqual (
 837                                 "<!DOCTYPE html PUBLIC \"\" \"\">" +
 838                                 "<test><abc></abc></test>", sw.ToString (), "#4");
 839
 840                         // set empty doctype-public
 841                         xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 842                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 843                                         <xsl:output
 844                                                 method=""html""
 845                                                 indent=""no""
 846                                                 doctype-public="""" />
 847                                         <xsl:template match=""/"">
 848                                                 <xsl:element name=""test"">
 849                                                         <xsl:element name=""abc"" />
 850                                                 </xsl:element>
 851                                         </xsl:template>
 852                                 </xsl:stylesheet>";
 853
 854                         sw.GetStringBuilder ().Length = 0;
 855                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 856                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 857                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 858
 859                         Assert.AreEqual (
 860                                 "<!DOCTYPE html PUBLIC \"\" >" +
 861                                 "<test><abc></abc></test>", sw.ToString (), "#5");
 862
 863                         // set empty doctype-system
 864                         xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 865                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 866                                         <xsl:output
 867                                                 method=""html""
 868                                                 indent=""no""
 869                                                 doctype-system="""" />
 870                                         <xsl:template match=""/"">
 871                                                 <xsl:element name=""test"">
 872                                                         <xsl:element name=""abc"" />
 873                                                 </xsl:element>
 874                                         </xsl:template>
 875                                 </xsl:stylesheet>";
 876
 877                         sw.GetStringBuilder ().Length = 0;
 878                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 879                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 880                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 881
 882                         Assert.AreEqual (
 883                                 "<!DOCTYPE html SYSTEM \"\">" +
 884                                 "<test><abc></abc></test>", sw.ToString (), "#6");
 885                 }
 886
 887                 [Test]
 888                 [Category ("NotWorking")] // bug #77082: mono does not output newline after xml declaration
 889                 public void Output_Indent_Xml ()
 890                 {
 891                         XsltArgumentList xsltArgs = new XsltArgumentList ();
 892                         XslTransform xsltProcessor = new XslTransform ();
 893
 894                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 895                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 896                                         <xsl:output
 897                                                 doctype-public=""-//W3C//DTD XHTML 1.0 Strict//EN""
 898                                                 doctype-system=""http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd""
 899                                                 {0} />
 900                                         <xsl:template match=""/"">
 901                                                 <xsl:element name=""test"">
 902                                                         <xsl:element name=""something"">
 903                                                                 <xsl:element name=""else"" />
 904                                                         </xsl:element>
 905                                                 </xsl:element>
 906                                         </xsl:template>
 907                                 </xsl:stylesheet>";
 908
 909                         XmlDocument xmlDoc = new XmlDocument ();
 910                         xmlDoc.LoadXml ("<dummy />");
 911
 912                         // set indent to yes
 913                         StringWriter sw = new StringWriter ();
 914                         xsltProcessor.Load (new XmlTextReader (new StringReader (
 915                                 string.Format (xsltFragment, "indent=\"yes\""))),
 916                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 917                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 918
 919                         Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
 920                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" +
 921                                 "<!DOCTYPE test PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">{0}" +
 922                                 "<test>{0}" +
 923                                 "  <something>{0}" +
 924                                 "    <else />{0}" +
 925                                 "  </something>{0}" +
 926                                 "</test>", Environment.NewLine), sw.ToString (), "#1");
 927
 928                         // set indent to no
 929                         sw.GetStringBuilder ().Length = 0;
 930                         xsltProcessor.Load (new XmlTextReader (new StringReader (
 931                                 string.Format (xsltFragment, "indent=\"no\""))),
 932                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 933                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 934
 935                         Assert.AreEqual (
 936                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 937                                 "<!DOCTYPE test PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">" +
 938                                 "<test><something><else /></something></test>", sw.ToString (),
 939                                 "#2");
 940
 941                         // indent not set
 942                         sw.GetStringBuilder ().Length = 0;
 943                         xsltProcessor.Load (new XmlTextReader (new StringReader (
 944                                 string.Format (xsltFragment, ""))),
 945                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 946                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 947
 948                         Assert.AreEqual (
 949                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 950                                 "<!DOCTYPE test PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">" +
 951                                 "<test><something><else /></something></test>", sw.ToString (),
 952                                 "#3");
 953                 }
 954
 955                 [Test]
 956                 [Category ("NotWorking")] // bug #77081: mono does not output newline and indentation for non-html elements
 957                 public void Output_Indent_Html ()
 958                 {
 959                         XsltArgumentList xsltArgs = new XsltArgumentList ();
 960                         XslTransform xsltProcessor = new XslTransform ();
 961
 962                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 963                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 964                                         <xsl:output
 965                                                 method=""html""
 966                                                 doctype-public=""-//W3C//DTD XHTML 1.0 Strict//EN""
 967                                                 doctype-system=""http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd""
 968                                                 {0} />
 969                                         <xsl:template match=""/"">
 970                                                 <xsl:element name=""test"">
 971                                                         <xsl:element name=""something"">
 972                                                                 <xsl:element name=""else"" />
 973                                                         </xsl:element>
 974                                                 </xsl:element>
 975                                         </xsl:template>
 976                                 </xsl:stylesheet>";
 977
 978                         XmlDocument xmlDoc = new XmlDocument ();
 979                         xmlDoc.LoadXml ("<dummy />");
 980
 981                         // set indent to yes
 982                         StringWriter sw = new StringWriter ();
 983                         xsltProcessor.Load (new XmlTextReader (new StringReader (
 984                                 string.Format (xsltFragment, "indent=\"yes\""))),
 985                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 986                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 987
 988                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
 989                                 "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">{0}" +
 990                                 "<test>{0}" +
 991                                 "  <something>{0}" +
 992                                 "    <else>{0}" +
 993                                 "    </else>{0}" +
 994                                 "  </something>{0}" +
 995                                 "</test>", Environment.NewLine), sw.ToString (), "#1");
 996
 997                         // set indent to no
 998                         sw.GetStringBuilder ().Length = 0;
 999                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1000                                 string.Format (xsltFragment, "indent=\"no\""))),
1001                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1002                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1003
1004                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1005                                 "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">" +
1006                                 "<test><something><else></else></something></test>",
1007                                 Environment.NewLine), sw.ToString (), "#2");
1008
1009                         // indent not set
1010                         sw.GetStringBuilder ().Length = 0;
1011                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1012                                 string.Format (xsltFragment, ""))),
1013                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1014                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1015
1016                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1017                                 "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">{0}" +
1018                                 "<test>{0}" +
1019                                 "  <something>{0}" +
1020                                 "    <else>{0}" +
1021                                 "    </else>{0}" +
1022                                 "  </something>{0}" +
1023                                 "</test>", Environment.NewLine), sw.ToString (), "#3");
1024                 }
1025
1026                 [Test]
1027                 [ExpectedException (typeof (XsltCompileException))]
1028                 public void Output_Indent_Invalid ()
1029                 {
1030                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1031                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1032                                         <xsl:output indent=""Yes"" />
1033                                 </xsl:stylesheet>";
1034                         XslTransform xsltProcessor = new XslTransform ();
1035                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
1036                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1037                 }
1038
1039                 [Test]
1040                 [ExpectedException (typeof (XsltCompileException))]
1041                 public void Output_Indent_Empty ()
1042                 {
1043                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1044                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1045                                         <xsl:output indent="""" />
1046                                 </xsl:stylesheet>";
1047                         XslTransform xsltProcessor = new XslTransform ();
1048                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
1049                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1050                 }
1051
1052                 [Test]
1053                 public void Output_MediaType ()
1054                 {
1055                         StringWriter sw = null;
1056                         XsltArgumentList xsltArgs = new XsltArgumentList ();
1057                         XslTransform xsltProcessor = new XslTransform ();
1058
1059                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1060                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1061                                         <xsl:output media-type=""whatever"" />
1062                                         <xsl:template match=""/"">
1063                                                 <root />
1064                                         </xsl:template>
1065                                 </xsl:stylesheet>";
1066
1067                         XmlDocument xmlDoc = new XmlDocument ();
1068                         xmlDoc.LoadXml ("<dummy />");
1069
1070                         sw = new StringWriter ();
1071                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
1072                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1073                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1074
1075                         Assert.AreEqual (
1076                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1077                                 "<root />", sw.ToString ());
1078                 }
1079
1080                 [Test]
1081                 public void Output_Encoding_TextWriter ()
1082                 {
1083                         StringWriter sw = null;
1084                         XsltArgumentList xsltArgs = new XsltArgumentList ();
1085                         XslTransform xsltProcessor = new XslTransform ();
1086
1087                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1088                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1089                                         <xsl:output {0} />
1090                                         <xsl:template match=""/"">
1091                                                 <root />
1092                                         </xsl:template>
1093                                 </xsl:stylesheet>";
1094
1095                         XmlDocument xmlDoc = new XmlDocument ();
1096                         xmlDoc.LoadXml ("<dummy />");
1097
1098                         // no encoding
1099                         sw = new StringWriter ();
1100                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1101                                 string.Format (xsltFragment, string.Empty))),
1102                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1103                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1104
1105                         Assert.AreEqual (
1106                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1107                                 "<root />", sw.ToString (), "#1");
1108
1109                         // valid encoding
1110                         sw.GetStringBuilder ().Length = 0;
1111                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1112                                 string.Format(xsltFragment, "encoding=\"iso-8859-1\""))),
1113                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1114                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1115
1116                         Assert.AreEqual (
1117                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1118                                 "<root />", sw.ToString (), "#1");
1119
1120                         // invalid encoding
1121                         sw.GetStringBuilder ().Length = 0;
1122                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1123                                 string.Format (xsltFragment, "encoding=\"doesnotexist\""))),
1124                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1125                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1126
1127                         Assert.AreEqual (
1128                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1129                                 "<root />", sw.ToString (), "#2");
1130
1131                         // empty encoding
1132                         sw.GetStringBuilder ().Length = 0;
1133                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1134                                 string.Format (xsltFragment, "encoding=\"\""))),
1135                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1136                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1137
1138                         Assert.AreEqual (
1139                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1140                                 "<root />", sw.ToString (), "#3");
1141                 }
1142
1143                 [Test]
1144                 public void Output_Encoding_Stream ()
1145                 {
1146                         MemoryStream ms = null;
1147                         string result = null;
1148                         XsltArgumentList xsltArgs = new XsltArgumentList ();
1149                         XslTransform xsltProcessor = new XslTransform ();
1150
1151                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1152                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1153                                         <xsl:output {0} />
1154                                         <xsl:template match=""/"">
1155                                                 <root />
1156                                         </xsl:template>
1157                                 </xsl:stylesheet>";
1158
1159                         XmlDocument xmlDoc = new XmlDocument ();
1160                         xmlDoc.LoadXml ("<dummy />");
1161
1162                         // no encoding
1163                         ms = new MemoryStream ();
1164                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1165                                 string.Format (xsltFragment, string.Empty))),
1166                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1167                         xsltProcessor.Transform (xmlDoc, xsltArgs, ms, new XmlUrlResolver ());
1168                         ms.Position = 0;
1169                         using (StreamReader sr = new StreamReader (ms, true)) {
1170                                 result = sr.ReadToEnd ();
1171                         }
1172
1173                         Assert.AreEqual (
1174                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
1175                                 "<root />", result, "#1");
1176
1177                         // valid encoding
1178                         ms = new MemoryStream ();
1179                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1180                                 string.Format (xsltFragment, "encoding=\"iso-8859-1\""))),
1181                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1182                         xsltProcessor.Transform (xmlDoc, xsltArgs, ms, new XmlUrlResolver ());
1183                         ms.Position = 0;
1184                         using (StreamReader sr = new StreamReader (ms, true)) {
1185                                 result = sr.ReadToEnd ();
1186                         }
1187
1188                         Assert.AreEqual (
1189                                 "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>" +
1190                                 "<root />", result, "#2");
1191
1192                         // invalid encoding
1193                         ms = new MemoryStream ();
1194                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1195                                 string.Format (xsltFragment, "encoding=\"doesnotexist\""))),
1196                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1197                         xsltProcessor.Transform (xmlDoc, xsltArgs, ms, new XmlUrlResolver ());
1198                         ms.Position = 0;
1199                         using (StreamReader sr = new StreamReader (ms, true)) {
1200                                 result = sr.ReadToEnd ();
1201                         }
1202
1203                         Assert.AreEqual (
1204                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
1205                                 "<root />", result, "#3");
1206
1207                         // empty encoding
1208                         ms = new MemoryStream ();
1209                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1210                                 string.Format (xsltFragment, "encoding=\"\""))),
1211                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1212                         xsltProcessor.Transform (xmlDoc, xsltArgs, ms, new XmlUrlResolver ());
1213                         ms.Position = 0;
1214                         using (StreamReader sr = new StreamReader (ms, true)) {
1215                                 result = sr.ReadToEnd ();
1216                         }
1217
1218                         Assert.AreEqual (
1219                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
1220                                 "<root />", result, "#4");
1221                 }
1222
1223                 [Test]
1224                 public void Output_Version ()
1225                 {
1226                         StringWriter sw = null;
1227                         XsltArgumentList xsltArgs = new XsltArgumentList ();
1228                         XslTransform xsltProcessor = new XslTransform ();
1229
1230                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1231                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1232                                         <xsl:output version=""{0}"" />
1233                                         <xsl:template match=""/"">
1234                                                 <root />
1235                                         </xsl:template>
1236                                 </xsl:stylesheet>";
1237
1238                         XmlDocument xmlDoc = new XmlDocument ();
1239                         xmlDoc.LoadXml ("<dummy />");
1240
1241                         // version 1.0
1242                         sw = new StringWriter ();
1243                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1244                                 string.Format (xsltFragment, "1.0"))),
1245                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1246                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1247
1248                         Assert.AreEqual (
1249                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1250                                 "<root />", sw.ToString (), "#1");
1251
1252                         // version 2.0
1253                         sw.GetStringBuilder ().Length = 0;
1254                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1255                                 string.Format (xsltFragment, "2.0"))),
1256                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1257                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1258
1259                         Assert.AreEqual (
1260                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1261                                 "<root />", sw.ToString (), "#2");
1262
1263                         // version BLABLA
1264                         sw.GetStringBuilder ().Length = 0;
1265                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1266                                 string.Format (xsltFragment, "BLABLA"))),
1267                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1268                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1269
1270                         Assert.AreEqual (
1271                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1272                                 "<root />", sw.ToString (), "#3");
1273                 }
1274
1275                 [Test]
1276                 public void Output_Method_Html_TextWriter ()
1277                 {
1278                         string options = null;
1279                         StringWriter sw = null;
1280                         XsltArgumentList xsltArgs = new XsltArgumentList ();
1281                         XslTransform xsltProcessor = new XslTransform ();
1282
1283                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1284                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1285                                         <xsl:output method=""html"" {0} />
1286                                         <xsl:template match=""/"">
1287                                                 <xsl:element name=""html"">
1288                                                         <xsl:element name=""head"">
1289                                                                 <xsl:element name=""title"">Output Test</xsl:element>
1290                                                         </xsl:element>
1291                                                         <xsl:element name=""Body"">
1292                                                                 <xsl:element name=""BR"" />
1293                                                         </xsl:element>
1294                                                 </xsl:element>
1295                                         </xsl:template>
1296                                 </xsl:stylesheet>";
1297
1298                         XmlDocument xmlDoc = new XmlDocument ();
1299                         xmlDoc.LoadXml ("<dummy />");
1300
1301                         // indent not set, media-type not set
1302                         sw = new StringWriter ();
1303                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1304                                 string.Format (xsltFragment, string.Empty))),
1305                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1306                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1307
1308                         Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
1309                                 "<html>{0}" +
1310                                 "{1}<head>{0}" +
1311                                 "{1}{1}<META http-equiv=\"Content-Type\" content=\"text/html; charset=utf-16\">{0}" +
1312                                 "{1}{1}<title>Output Test</title>{0}" +
1313                                 "{1}</head>{0}" +
1314                                 "{1}<Body>{0}" +
1315                                 "{1}{1}<BR>{0}" +
1316                                 "{1}</Body>{0}" +
1317                                 "</html>", Environment.NewLine, "  "), sw.ToString (), "#1");
1318
1319                         // indent no, media-type not set
1320                         options = "indent=\"no\"";
1321                         sw.GetStringBuilder ().Length = 0;
1322                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1323                                 string.Format (xsltFragment, options))),
1324                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1325                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1326
1327                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1328                                 "<html>{0}" +
1329                                 "{1}<head>{0}" +
1330                                 "{1}{1}<META http-equiv=\"Content-Type\" content=\"text/html; charset=utf-16\">{0}" +
1331                                 "{1}{1}<title>Output Test</title>{0}" +
1332                                 "{1}</head>{0}" +
1333                                 "{1}<Body>{0}" +
1334                                 "{1}{1}<BR>{0}" +
1335                                 "{1}</Body>{0}" +
1336                                 "</html>", string.Empty, string.Empty), sw.ToString (), "#2");
1337
1338                         // indent yes, media-type "bla", omit-xml-declaration "no"
1339                         options = "indent=\"yes\" media-type=\"bla\"" +
1340                                                 " encoding=\"iso-8859-1\" omit-xml-declaration=\"no\"";
1341                         sw.GetStringBuilder ().Length = 0;
1342                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1343                                 string.Format (xsltFragment, options))),
1344                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1345                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1346
1347                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1348                                 "<html>{0}" +
1349                                 "{1}<head>{0}" +
1350                                 "{1}{1}<META http-equiv=\"Content-Type\" content=\"bla; charset=utf-16\">{0}" +
1351                                 "{1}{1}<title>Output Test</title>{0}" +
1352                                 "{1}</head>{0}" +
1353                                 "{1}<Body>{0}" +
1354                                 "{1}{1}<BR>{0}" +
1355                                 "{1}</Body>{0}" +
1356                                 "</html>", Environment.NewLine, "  "), sw.ToString (), "#3");
1357                 }
1358
1359                 [Test]
1360                 public void Output_Method_Html_Stream ()
1361                 {
1362                         string options = null;
1363                         MemoryStream ms = null;
1364                         string result = null;
1365                         XsltArgumentList xsltArgs = new XsltArgumentList ();
1366                         XslTransform xsltProcessor = new XslTransform ();
1367
1368                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1369                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1370                                         <xsl:output method=""html"" {0} />
1371                                         <xsl:template match=""/"">
1372                                                 <xsl:element name=""html"">
1373                                                         <xsl:element name=""head"">
1374                                                                 <xsl:element name=""title"">Output Test</xsl:element>
1375                                                         </xsl:element>
1376                                                         <xsl:element name=""Body"">
1377                                                                 <xsl:element name=""BR"" />
1378                                                         </xsl:element>
1379                                                 </xsl:element>
1380                                         </xsl:template>
1381                                 </xsl:stylesheet>";
1382
1383                         XmlDocument xmlDoc = new XmlDocument ();
1384                         xmlDoc.LoadXml ("<dummy />");
1385
1386                         // indent not set, media-type not set
1387                         ms = new MemoryStream ();
1388                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1389                                 string.Format (xsltFragment, string.Empty))),
1390                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1391                         xsltProcessor.Transform (xmlDoc, xsltArgs, ms, new XmlUrlResolver ());
1392                         ms.Position = 0;
1393                         using (StreamReader sr = new StreamReader (ms, true)) {
1394                                 result = sr.ReadToEnd ();
1395                         }
1396
1397                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1398                                 "<html>{0}" +
1399                                 "{1}<head>{0}" +
1400                                 "{1}{1}<META http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">{0}" +
1401                                 "{1}{1}<title>Output Test</title>{0}" +
1402                                 "{1}</head>{0}" +
1403                                 "{1}<Body>{0}" +
1404                                 "{1}{1}<BR>{0}" +
1405                                 "{1}</Body>{0}" +
1406                                 "</html>", Environment.NewLine, "  "), result, "#1");
1407
1408                         // indent no, media-type not set
1409                         options = "indent=\"no\"";
1410                         ms = new MemoryStream ();
1411                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1412                                 string.Format (xsltFragment, options))),
1413                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1414                         xsltProcessor.Transform (xmlDoc, xsltArgs, ms, new XmlUrlResolver ());
1415                         ms.Position = 0;
1416                         using (StreamReader sr = new StreamReader (ms, true)) {
1417                                 result = sr.ReadToEnd ();
1418                         }
1419
1420                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1421                                 "<html>{0}" +
1422                                 "{1}<head>{0}" +
1423                                 "{1}{1}<META http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">{0}" +
1424                                 "{1}{1}<title>Output Test</title>{0}" +
1425                                 "{1}</head>{0}" +
1426                                 "{1}<Body>{0}" +
1427                                 "{1}{1}<BR>{0}" +
1428                                 "{1}</Body>{0}" +
1429                                 "</html>", string.Empty, string.Empty), result, "#2");
1430
1431                         // indent yes, media-type "bla", omit-xml-declaration "no"
1432                         options = "indent=\"yes\" media-type=\"bla\"" +
1433                                                 " encoding=\"iso-8859-1\" omit-xml-declaration=\"no\"";
1434                         ms = new MemoryStream ();
1435                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1436                                 string.Format (xsltFragment, options))),
1437                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1438                         xsltProcessor.Transform (xmlDoc, xsltArgs, ms, new XmlUrlResolver ());
1439                         ms.Position = 0;
1440                         using (StreamReader sr = new StreamReader (ms, true)) {
1441                                 result = sr.ReadToEnd ();
1442                         }
1443
1444                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1445                                 "<html>{0}" +
1446                                 "{1}<head>{0}" +
1447                                 "{1}{1}<META http-equiv=\"Content-Type\" content=\"bla; charset=iso-8859-1\">{0}" +
1448                                 "{1}{1}<title>Output Test</title>{0}" +
1449                                 "{1}</head>{0}" +
1450                                 "{1}<Body>{0}" +
1451                                 "{1}{1}<BR>{0}" +
1452                                 "{1}</Body>{0}" +
1453                                 "</html>", Environment.NewLine, "  "), result, "#3");
1454                 }
1455
1456                 [Test]
1457                 [ExpectedException (typeof (XsltCompileException))]
1458                 public void Output_Unknown_Attribute ()
1459                 {
1460                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1461                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1462                                         <xsl:output whatever="""" />
1463                                 </xsl:stylesheet>";
1464                         XslTransform xsltProcessor = new XslTransform ();
1465                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
1466                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1467                 }
1468
1469                 [Test]
1470                 public void Output_Unknown_Attribute_NonDefaultNamespace ()
1471                 {
1472                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1473                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" xmlns:tst=""something"" version=""1.0"">
1474                                         <xsl:output tst:whatever="""" />
1475                                 </xsl:stylesheet>";
1476                         XslTransform xsltProcessor = new XslTransform ();
1477                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
1478                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1479                 }
1480         }
1481 }