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                 static readonly string end_of_line = "\r\n";
  25
  26                 XmlDocument doc;
  27                 XslTransform xslt;
  28                 XmlDocument result;
  29
  30                 [SetUp]
  31                 public void GetReady()
  32                 {
  33                         doc = new XmlDocument ();
  34                         xslt = new XslTransform ();
  35                         result = new XmlDocument ();
  36                 }
  37
  38                 [Test]
  39                 public void TestBasicTransform ()
  40                 {
  41                         string output = Path.Combine (Path.GetTempPath (), "result.xml");
  42                         doc.LoadXml ("<root/>");
  43                         xslt.Load ("Test/XmlFiles/xsl/empty.xsl");
  44                         xslt.Transform ("Test/XmlFiles/xsl/empty.xsl", output);
  45                         result.Load (output);
  46                         Assert.AreEqual (2, result.ChildNodes.Count, "count");
  47                 }
  48
  49                 [Test]
  50                 [ExpectedException (typeof (XsltCompileException))]
  51                 public void InvalidStylesheet ()
  52                 {
  53                         XmlDocument doc = new XmlDocument ();
  54                         doc.LoadXml ("<xsl:element xmlns:xsl='http://www.w3.org/1999/XSL/Transform' />");
  55                         XslTransform t = new XslTransform ();
  56                         t.Load (doc);
  57                 }
  58
  59                 [Test]
  60                 [ExpectedException (typeof (XsltCompileException))]
  61                 public void EmptyStylesheet ()
  62                 {
  63                         XmlDocument doc = new XmlDocument ();
  64                         XslTransform t = new XslTransform ();
  65                         t.Load (doc);
  66                 }
  67
  68                 [Test]
  69                 [ExpectedException (typeof (XsltCompileException))]
  70                 public void InvalidStylesheet2 ()
  71                 {
  72                         string xsl = @"<xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0'>
  73 <xsl:template match='/root'>
  74         <xsl:call-template name='foo'>
  75                 <xsl:with-param name='name' value='text()' />
  76         </xsl:call-template>
  77 </xsl:template>
  78 <xsl:template name='foo'>
  79         <xsl:param name='name' />
  80         <result>
  81                 <xsl:if test='1'>
  82                         <xsl:variable name='last' value='text()' />
  83                         <xsl:value-of select='$last' />
  84                 </xsl:if>
  85         </result>
  86 </xsl:template>
  87 </xsl:stylesheet>
  88 ";
  89                         XslTransform xslt = new XslTransform ();
  90                         xslt.Load (new XPathDocument (new XmlTextReader (xsl, XmlNodeType.Document, null)));
  91                 }
  92
  93                 [Test]
  94             [Category ("MobileNotWorking")]
  95                 public void MsxslTest() {
  96                         string _styleSheet = @"
  97                         <xslt:stylesheet xmlns:xslt=""http://www.w3.org/1999/XSL/Transform"" version=""1.0""
  98 xmlns:msxsl=""urn:schemas-microsoft-com:xslt"" xmlns:stringutils=""urn:schemas-sourceforge.net-blah"">
  99 <xslt:output method=""text"" />
 100 <msxsl:script language=""C#"" implements-prefix=""stringutils"">
 101         <![CDATA[
 102                 string PadRight( string str, int padding) {
 103                         return str.PadRight(padding);
 104                 }
 105         ]]>
 106 </msxsl:script>
 107 <xslt:template match=""test"">
 108         <xslt:value-of select=""stringutils:PadRight(@name, 20)"" />
 109 </xslt:template>
 110 </xslt:stylesheet>";
 111
 112                         StringReader stringReader = new StringReader(_styleSheet);
 113
 114                         XslTransform transform = new XslTransform();
 115                         XmlTextReader reader = new XmlTextReader(stringReader);
 116                         transform.Load(reader, new XmlUrlResolver(), AppDomain.CurrentDomain.Evidence);
 117
 118                         StringBuilder sb = new StringBuilder();
 119                         StringWriter writer = new StringWriter(sb, CultureInfo.InvariantCulture);
 120                         XsltArgumentList arguments = new XsltArgumentList();
 121
 122                         XmlDocument xmlDoc = new XmlDocument();
 123                         xmlDoc.LoadXml("<test name=\"test\" />");
 124
 125                         // Do transformation
 126                         transform.Transform(xmlDoc, new XsltArgumentList(), writer, new XmlUrlResolver());
 127
 128                         Assert.AreEqual ("test".PadRight(20), sb.ToString());
 129                 }
 130
 131                 [Test]
 132                 public void MSXslNodeSet ()
 133                 {
 134                         string xsl = @"<xsl:stylesheet version='1.0'
 135 xmlns:xsl='http://www.w3.org/1999/XSL/Transform' xmlns:msxsl='urn:schemas-microsoft-com:xslt'>
 136 <xsl:template match='/'>
 137         <root>
 138                 <xsl:variable name='var'>
 139                         <xsl:copy-of select='root/foo' />
 140                 </xsl:variable>
 141                 <xsl:for-each select='msxsl:node-set($var)/foo'>
 142                         <xsl:value-of select='name(.)' />: <xsl:value-of select='@attr' />
 143                 </xsl:for-each>
 144         </root>
 145 </xsl:template>
 146 </xsl:stylesheet>";
 147                         StringWriter sw = new StringWriter ();
 148                         XslTransform t = new XslTransform ();
 149                         t.Load (new XPathDocument (new StringReader (xsl)));
 150                         t.Transform (new XPathDocument (new XmlTextReader (new StringReader ("<root><foo attr='A'/><foo attr='B'/><foo attr='C'/></root>"))), null, sw);
 151                         Assert.AreEqual (@"<?xml version=""1.0"" encoding=""utf-16""?><root xmlns:msxsl=""urn:schemas-microsoft-com:xslt"">foo: Afoo: Bfoo: C</root>", sw.ToString ());
 152                 }
 153
 154                 [Test]
 155                 [ExpectedException (typeof (XPathException))]
 156                 public void MSXslNodeSetRejectsNodeSet ()
 157                 {
 158                         string xsl = @"<xsl:stylesheet version='1.0'
 159 xmlns:xsl='http://www.w3.org/1999/XSL/Transform' xmlns:msxsl='urn:schemas-microsoft-com:xslt'>
 160 <xsl:template match='/'>
 161         <root>
 162                 <!-- msxsl:node-set() does not accept a node set -->
 163                 <xsl:for-each select='msxsl:node-set(root/foo)'>
 164                         <xsl:value-of select='name(.)' />: <xsl:value-of select='@attr' />
 165                 </xsl:for-each>
 166         </root>
 167 </xsl:template>
 168 </xsl:stylesheet>";
 169                         StringWriter sw = new StringWriter ();
 170                         XslTransform t = new XslTransform ();
 171                         t.Load (new XPathDocument (new StringReader (xsl)));
 172                         t.Transform (new XPathDocument (new XmlTextReader (new StringReader ("<root><foo attr='A'/><foo attr='B'/><foo attr='C'/></root>"))), null, sw);
 173                 }
 174
 175                 [Test]
 176                 [Category ("MobileNotWorking")]
 177                 public void MSXslFormatDate ()
 178                 {
 179                         var arguments = new XsltArgumentList();
 180                         arguments.AddParam("date", "", new DateTime (2010, 11, 22, 5, 4, 3));
 181
 182                         string xsl = @"
 183 <xsl:stylesheet version=""1.0"" xmlns=""http://www.w3.org/1999/xhtml"" xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" xmlns:msxsl=""urn:schemas-microsoft-com:xslt"" exclude-result-prefixes=""msxsl"">
 184 <xsl:param name='date'/>
 185 <xsl:template match='/'>
 186         <root>
 187                 <p>The current date is <xsl:value-of select=""msxsl:format-date($date, 'd MMMM yyyy')""/> and current time is <xsl:value-of select=""msxsl:format-time($date, 'HH:mm')""/>.</p>
 188         </root>
 189 </xsl:template>
 190 </xsl:stylesheet>";
 191
 192                         StringWriter sw = new StringWriter ();
 193                         var t = new XslCompiledTransform ();
 194                         t.Load (new XPathDocument (new StringReader (xsl)));
 195
 196                         t.Transform (new XPathDocument (new XmlTextReader (new StringReader ("<root></root>"))), arguments, sw);
 197
 198                         Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?><root xmlns=\"http://www.w3.org/1999/xhtml\"><p>The current date is 22 November 2010 and current time is 05:04.</p></root>", sw.ToString ());
 199                 }
 200
 201
 202                 [Test]
 203                 public void EvaluateEmptyVariableAsBoolean ()
 204                 {
 205                         string xsl = @"<xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0'>
 206 <xsl:template match='/'>
 207         <xsl:variable name='var'><empty /></xsl:variable>
 208         <root><xsl:if test='$var'>true</xsl:if></root>
 209 </xsl:template>
 210 </xsl:stylesheet>";
 211                         XslTransform t = new XslTransform ();
 212                         t.Load (new XPathDocument (new StringReader (xsl)));
 213                         StringWriter sw = new StringWriter ();
 214                         t.Transform (
 215                                 new XPathDocument (new StringReader ("<root/>")),
 216                                 null,
 217                                 sw);
 218                         Assert.IsTrue (sw.ToString ().IndexOf ("true") > 0);
 219                 }
 220
 221                 [Test]
 222                 [ExpectedException (typeof (XsltCompileException))]
 223                 public void NotAllowedPatternAxis ()
 224                 {
 225                         string xsl = @"<xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0'>
 226 <xsl:template match='/descendant-or-self::node()/elem'>
 227         <ERROR/>
 228 </xsl:template>
 229 </xsl:stylesheet>";
 230                         new XslTransform ().Load (new XPathDocument (
 231                                 new StringReader (xsl)));
 232                 }
 233
 234                 [Test]
 235                 [ExpectedException (typeof (XsltCompileException))]
 236                 public void ImportIncorrectlyLocated ()
 237                 {
 238                         string xsl = @"<xsl:transform xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0'>
 239 <xsl:template match='/'></xsl:template>
 240         <xsl:import href='dummy.xsl' />
 241 </xsl:transform>";
 242                         new XslTransform ().Load (new XPathDocument (
 243                                 new StringReader (xsl)));
 244                 }
 245
 246                 private WeakReference StylesheetLoad (XslTransform t, string xsl)
 247                 {
 248                         XPathDocument doc = new XPathDocument (
 249                                 new StringReader (xsl));
 250                         WeakReference wr = new WeakReference (doc);
 251                         t.Load (doc);
 252                         return wr;
 253                 }
 254
 255                 private WeakReference StylesheetTransform (XslTransform t, string xml)
 256                 {
 257                         XPathDocument doc = new XPathDocument (
 258                                 new StringReader (xml));
 259                         WeakReference wr = new WeakReference (doc);
 260                         t.Transform (doc, null, TextWriter.Null, null);
 261                         return wr;
 262                 }
 263
 264                 [Test]
 265                 // bug #75663.
 266                 public void ErrorOnDocumentResolution ()
 267                 {
 268                         // XslTransform recovers from errors on document resolution.
 269                         string xslText = @"<xsl:stylesheet
 270                                 xmlns:xsl='http://www.w3.org/1999/XSL/Transform'
 271                                 version='1.0'>
 272                                 <xsl:variable name='n'
 273                                         select='document(""notexist.xml"")' />
 274                                 <xsl:template match='/'>xx</xsl:template>
 275                                 </xsl:stylesheet>";
 276                         string xmlText = @"<root />";
 277                         XslTransform transform = new XslTransform ();
 278                         XPathDocument doc = new XPathDocument (
 279                                 new XmlTextReader ("a.xsl", new StringReader (xslText)));
 280                         transform.Load (doc);
 281                         XPathDocument xmlDocument = new XPathDocument (new StringReader (xmlText));
 282
 283                         StringWriter sw = new StringWriter ();
 284                         transform.Transform (xmlDocument, null, sw);
 285
 286                         Assert.AreEqual (
 287                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 288                                 "xx", sw.ToString ());
 289                 }
 290
 291                 // bug #76046
 292                 [Test]
 293                 public void LoadStyleFromNonRoot ()
 294                 {
 295                         XmlDocument doc = new XmlDocument ();
 296                         XslTransform xslt = new XslTransform ();
 297                         doc.LoadXml ("<root><dummy /><xsl:transform xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0' /></root>");
 298                         XmlNode node = doc.ChildNodes [0].ChildNodes [1];
 299                         xslt.Load (node, null, null);
 300                 }
 301
 302                 [Test]
 303                 public void ReturnEmptyResultsAsXmlReader ()
 304                 {
 305                         // bug #76115
 306                         XmlDocument doc = new XmlDocument ();
 307                         doc.LoadXml ("<xsl:transform xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0' />");
 308                         XslTransform xslt = new XslTransform ();
 309                         xslt.Load (doc, null, null);
 310                         XmlReader reader = xslt.Transform(doc, null, new XmlUrlResolver ());
 311                         reader.Read ();
 312
 313                         // another case - with xsl:output standalone='yes'
 314                         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>");
 315                         xslt = new XslTransform ();
 316                         xslt.Load (doc, null, null);
 317                         reader = xslt.Transform (doc, null, new XmlUrlResolver ());
 318                         while (!reader.EOF)
 319                                 reader.Read (); // btw no XMLdecl output.
 320                 }
 321
 322                 [Test] // bug #76530
 323                 // http://www.w3.org/TR/xslt#section-Creating-Elements-with-xsl:element
 324                 // "If the namespace attribute is not present then the QName
 325                 // is expanded into an expanded-name using the namespace
 326                 // declarations in effect for the xsl:element element,
 327                 // including any default namespace declaration."
 328                 public void LREDefaultNamespace ()
 329                 {
 330                         string xsl = @"<xsl:stylesheet version='1.0' xmlns='urn:foo' xmlns:xsl='http://www.w3.org/1999/XSL/Transform'>
 331                                 <xsl:template match='/*'>
 332                                         <xsl:element name='{local-name()}' />
 333                                 </xsl:template>
 334                         </xsl:stylesheet>";
 335                         string xml = "<root/>";
 336                         XslTransform t = new XslTransform ();
 337                         t.Load (new XPathDocument (new StringReader (xsl)));
 338                         StringWriter sw = new StringWriter ();
 339                         XmlTextWriter xw = new XmlTextWriter (sw);
 340                         t.Transform (
 341                                 new XPathDocument (new StringReader (xml)),
 342                                 null, xw);
 343                         Assert.AreEqual ("<root xmlns=\"urn:foo\" />",
 344                                 sw.ToString ());
 345
 346                         string xsl2 = @"<xsl:stylesheet version='1.0' xmlns:xsl='http://www.w3.org/1999/XSL/Transform' xmlns='urn:foo'>
 347                                 <xsl:template match='/*'>
 348                                         <root>
 349                                                 <xsl:element name='{local-name()}' />
 350                                         </root>
 351                                 </xsl:template>
 352                         </xsl:stylesheet>";
 353                         string xml2 = "<page/>";
 354                         t.Load (new XPathDocument (new StringReader (xsl2)));
 355                         sw = new StringWriter ();
 356                         xw = new XmlTextWriter (sw);
 357                         t.Transform (
 358                                 new XPathDocument (new StringReader (xml2)),
 359                                 null, xw);
 360                         Assert.AreEqual ("<root xmlns=\"urn:foo\"><page /></root>",
 361                                 sw.ToString ());
 362                 }
 363
 364                 [Test]
 365                 // http://lists.ximian.com/pipermail/mono-devel-list/2005-November/015812.html
 366                 public void WhitespaceHandling ()
 367                 {
 368                         string ref_out = @"XML
 369         Extensible Markup language
 370          Great stuffs
 371     XSLT
 372         Extensible Markup language
 373          Great stuffs
 374     XPATH
 375         Extensible Markup language
 376          Great stuffs
 377     XSD
 378         Extensible Markup language
 379          Great stuffs
 380     ";
 381
 382                         XmlDocument d = new XmlDocument ();
 383                         d.Load ("Test/XmlFiles/xsl/91834.xml");
 384
 385                         XslTransform t = new XslTransform ();
 386                         t.Load ("Test/XmlFiles/xsl/91834.xsl");
 387
 388                         StringWriter sw_raw = new StringWriter ();
 389                         t.Transform (d, null, sw_raw);
 390
 391                         Assert.AreEqual (ref_out.Replace ("\r\n", "\n"), sw_raw.ToString ().Replace ("\r\n", "\n"));
 392                 }
 393
 394                 // http://support.microsoft.com/default.aspx?scid=kb;en-us;829014
 395                 [Test]
 396                 public void EmptyNodeSetSort ()
 397                 {
 398                         string xmlFragment = @"<?xml version=""1.0"" encoding=""utf-8""?>
 399                                 <EMPLOYEES>
 400                                         <EMPLOYEE>
 401                                                 <NAME>Steve</NAME>
 402                                                 <DEPT>IT</DEPT>
 403                                                 <SKILL>C++</SKILL>
 404                                                 <SKILL>C#</SKILL>
 405                                         </EMPLOYEE>
 406                                         <EMPLOYEE>
 407                                                 <NAME>John</NAME>
 408                                                 <DEPT>IT</DEPT>
 409                                                 <SKILL>VB.NET</SKILL>
 410                                                 <SKILL>SQl Server</SKILL>
 411                                         </EMPLOYEE>
 412                                 </EMPLOYEES>";
 413
 414                         string xsltFragment = @"<?xml version=""1.0""?>
 415                                 <xsl:stylesheet version=""1.0"" xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"">
 416                                         <xsl:output omit-xml-declaration=""yes"" />
 417                                         <xsl:preserve-space elements=""*"" />
 418                                         <xsl:template match=""/EMPLOYEES"">
 419                                                 <xsl:for-each select=""EMPLOYEE[DEPT='Finance']"">
 420                                                         <xsl:sort select=""NAME""/>
 421                                                         <xsl:value-of select=""NAME""/>
 422                                                 </xsl:for-each>
 423                                         </xsl:template>
 424                                 </xsl:stylesheet>";
 425
 426                         XmlTextReader xmlRdr = new XmlTextReader (new StringReader (xmlFragment));
 427                         XmlTextReader xsltRdr = new XmlTextReader (new StringReader (xsltFragment));
 428
 429                         XslTransform stylesheet = new XslTransform ();
 430                         stylesheet.Load (xsltRdr, new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 431
 432                         StringWriter sw = new StringWriter ();
 433
 434                         stylesheet.Transform (new XPathDocument (xmlRdr), new XsltArgumentList (),
 435                                 sw, new XmlUrlResolver ());
 436
 437                         Assert.AreEqual (0, sw.ToString ().Length);
 438                 }
 439
 440                 // http://support.microsoft.com/default.aspx?scid=kb;en-us;834667
 441                 [Test]
 442                 //[Category ("NotDotNet")]
 443                 public void LocalParameter ()
 444                 {
 445                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 446                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 447                                         <xsl:param name=""param1"" select=""'global-param1-default'"" />
 448                                         <xsl:param name=""param2"" select=""'global-param2-default'"" />
 449                                         <xsl:output method=""text"" encoding=""ascii"" />
 450                                         <xsl:template match=""/"">
 451                                                 <xsl:call-template name=""Test"">
 452                                                         <xsl:with-param name=""param1"" select=""'local-param1-arg'"" />
 453                                                         <xsl:with-param name=""param2"" select=""'local-param2-arg'"" />
 454                                                 </xsl:call-template>
 455                                         </xsl:template>
 456                                         <xsl:template name=""Test"">
 457                                                 <xsl:param name=""param1"" select=""'local-param1-default'"" />
 458                                                 <xsl:param name=""param2"" select=""'local-param2-default'"" />
 459                                                 <xsl:value-of select=""$param1"" /><xsl:text>/</xsl:text><xsl:value-of select=""$param2"" />
 460                                         </xsl:template>
 461                                 </xsl:stylesheet>";
 462
 463                         XmlDocument xmlDoc = new XmlDocument ();
 464                         xmlDoc.LoadXml ("<dummy />");
 465
 466                         XslTransform xsltProcessor = new XslTransform ();
 467                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 468                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 469
 470                         StringWriter sw = new StringWriter ();
 471
 472                         XsltArgumentList xsltArgs = new XsltArgumentList ();
 473                         xsltArgs.AddParam ("param1", string.Empty, "global-param1-arg");
 474                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 475
 476                         Assert.AreEqual ("local-param1-arg/local-param2-arg", sw.ToString ());
 477                 }
 478
 479                 [Test]
 480                 public void Output_Standalone ()
 481                 {
 482                         StringWriter sw = null;
 483                         XsltArgumentList xsltArgs = new XsltArgumentList ();
 484                         XslTransform xsltProcessor = new XslTransform ();
 485
 486                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 487                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 488                                         <xsl:output {0} />
 489                                         <xsl:template match=""/"">
 490                                                 <root />
 491                                         </xsl:template>
 492                                 </xsl:stylesheet>";
 493
 494                         XmlDocument xmlDoc = new XmlDocument ();
 495                         xmlDoc.LoadXml ("<dummy />");
 496
 497                         sw = new StringWriter ();
 498                         xsltProcessor.Load (new XmlTextReader (new StringReader (
 499                                 string.Format(xsltFragment, "standalone=\"yes\""))),
 500                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 501                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 502
 503                         Assert.AreEqual (
 504                                 "<?xml version=\"1.0\" encoding=\"utf-16\"" +
 505                                 " standalone=\"yes\"?><root />", sw.ToString (), "#1");
 506
 507                         sw = new StringWriter ();
 508                         xsltProcessor.Load (new XmlTextReader (new StringReader (
 509                                 string.Format (xsltFragment, "standalone=\"no\""))),
 510                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 511                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 512
 513                         Assert.AreEqual (
 514                                 "<?xml version=\"1.0\" encoding=\"utf-16\"" +
 515                                 " standalone=\"no\"?><root />", sw.ToString (), "#2");
 516
 517                         sw = new StringWriter ();
 518                         xsltProcessor.Load (new XmlTextReader (new StringReader (
 519                                 string.Format (xsltFragment, ""))),
 520                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 521                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 522
 523                         Assert.AreEqual (
 524                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 525                                 "<root />", sw.ToString (), "#3");
 526                 }
 527
 528                 [Test]
 529                 [ExpectedException (typeof (XsltCompileException))]
 530                 public void Output_Standalone_Invalid ()
 531                 {
 532                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 533                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 534                                         <xsl:output standalone=""Yes"" />
 535                                 </xsl:stylesheet>";
 536                         XslTransform xsltProcessor = new XslTransform ();
 537                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 538                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 539                 }
 540
 541                 [Test]
 542                 public void Output_Standalone_ForwardsCompatible ()
 543                 {
 544                         StringWriter sw = new StringWriter ();
 545                         XsltArgumentList xsltArgs = new XsltArgumentList ();
 546                         XslTransform xsltProcessor = new XslTransform ();
 547                         XmlDocument xmlDoc = new XmlDocument ();
 548                         xmlDoc.LoadXml ("<dummy />");
 549
 550                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 551                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.5"">
 552                                         <xsl:output standalone=""{0}"" />
 553                                         <xsl:template match=""/"">
 554                                                 <root />
 555                                         </xsl:template>
 556                                 </xsl:stylesheet>";
 557
 558                         // standalone is "Yes"
 559                         xsltProcessor.Load (new XmlTextReader (new StringReader (
 560                                 string.Format (xsltFragment, "Yes"))),
 561                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 562                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 563
 564                         Assert.AreEqual (
 565                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 566                                 "<root />", sw.ToString (), "#1");
 567
 568                         // standalone is empty
 569                         sw.GetStringBuilder ().Length = 0;
 570                         xsltProcessor.Load (new XmlTextReader (new StringReader (
 571                                 string.Format (xsltFragment, ""))),
 572                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 573                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 574
 575                         Assert.AreEqual (
 576                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 577                                 "<root />", sw.ToString (), "#2");
 578                 }
 579
 580                 [Test]
 581                 [ExpectedException (typeof (XsltCompileException))]
 582                 public void Output_Standalone_Empty ()
 583                 {
 584                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 585                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 586                                         <xsl:output standalone="""" />
 587                                 </xsl:stylesheet>";
 588                         XslTransform xsltProcessor = new XslTransform ();
 589                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 590                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 591                 }
 592
 593                 [Test]
 594                 public void Output_OmitXmlDeclaration ()
 595                 {
 596                         StringWriter sw = null;
 597                         XsltArgumentList xsltArgs = new XsltArgumentList ();
 598                         XslTransform xsltProcessor = new XslTransform ();
 599
 600                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 601                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 602                                         <xsl:output {0} />
 603                                         <xsl:template match=""/"">
 604                                                 <root />
 605                                         </xsl:template>
 606                                 </xsl:stylesheet>";
 607
 608                         XmlDocument xmlDoc = new XmlDocument ();
 609                         xmlDoc.LoadXml ("<dummy />");
 610
 611                         sw = new StringWriter ();
 612                         xsltProcessor.Load (new XmlTextReader (new StringReader (
 613                                 string.Format (xsltFragment, "omit-xml-declaration=\"yes\""))),
 614                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 615                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 616
 617                         Assert.AreEqual ("<root />", sw.ToString (), "#1");
 618
 619                         sw.GetStringBuilder ().Length = 0;
 620                         xsltProcessor.Load (new XmlTextReader (new StringReader (
 621                                 string.Format (xsltFragment, "omit-xml-declaration=\"no\""))),
 622                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 623                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 624
 625                         Assert.AreEqual (
 626                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 627                                 "<root />", sw.ToString (), "#2");
 628                 }
 629
 630                 [Test]
 631                 [ExpectedException (typeof (XsltCompileException))]
 632                 public void Output_OmitXmlDeclaration_Invalid ()
 633                 {
 634                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 635                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 636                                         <xsl:output omit-xml-declaration=""Yes"" />
 637                                 </xsl:stylesheet>";
 638                         XslTransform xsltProcessor = new XslTransform ();
 639                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 640                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 641                 }
 642
 643                 [Test]
 644                 [ExpectedException (typeof (XsltCompileException))]
 645                 public void Output_OmitXmlDeclaration_Empty ()
 646                 {
 647                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 648                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 649                                         <xsl:output omit-xml-declaration="""" />
 650                                 </xsl:stylesheet>";
 651                         XslTransform xsltProcessor = new XslTransform ();
 652                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 653                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 654                 }
 655
 656                 [Test]
 657                 public void Output_OmitXmlDeclaration_ForwardsCompatible ()
 658                 {
 659                         StringWriter sw = new StringWriter ();
 660                         XsltArgumentList xsltArgs = new XsltArgumentList ();
 661                         XslTransform xsltProcessor = new XslTransform ();
 662                         XmlDocument xmlDoc = new XmlDocument ();
 663                         xmlDoc.LoadXml ("<dummy />");
 664
 665                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 666                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.5"">
 667                                         <xsl:output omit-xml-declaration=""{0}"" />
 668                                         <xsl:template match=""/"">
 669                                                 <root />
 670                                         </xsl:template>
 671                                 </xsl:stylesheet>";
 672
 673                         // omit-xml-declaration is "Yes"
 674                         xsltProcessor.Load (new XmlTextReader (new StringReader (
 675                                 string.Format (xsltFragment, "Yes"))),
 676                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 677                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 678
 679                         Assert.AreEqual (
 680                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 681                                 "<root />", sw.ToString (), "#1");
 682
 683                         // omit-xml-declaration is empty
 684                         sw.GetStringBuilder ().Length = 0;
 685                         xsltProcessor.Load (new XmlTextReader (new StringReader (
 686                                 string.Format (xsltFragment, ""))),
 687                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 688                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 689
 690                         Assert.AreEqual (
 691                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 692                                 "<root />", sw.ToString (), "#2");
 693                 }
 694
 695                 [Test]
 696                 public void Output_DocType_Xml ()
 697                 {
 698                         XsltArgumentList xsltArgs = new XsltArgumentList ();
 699                         XslTransform xsltProcessor = new XslTransform ();
 700
 701                         // set both doctype-system and doctype-public
 702                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 703                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 704                                         <xsl:output
 705                                                 doctype-public=""-//W3C//DTD XHTML 1.0 Strict//EN""
 706                                                 doctype-system=""http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"" />
 707                                         <xsl:template match=""/"">
 708                                                 <xsl:element name=""test"">
 709                                                         <xsl:element name=""abc"" />
 710                                                 </xsl:element>
 711                                         </xsl:template>
 712                                 </xsl:stylesheet>";
 713
 714                         XmlDocument xmlDoc = new XmlDocument ();
 715                         xmlDoc.LoadXml ("<dummy />");
 716
 717                         StringWriter sw = new StringWriter ();
 718                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 719                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 720                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 721
 722                         Assert.AreEqual (
 723                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 724                                 "<!DOCTYPE test PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">" +
 725                                 "<test><abc /></test>", sw.ToString (), "#1");
 726
 727                         // only set doctype-public
 728                         xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 729                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 730                                         <xsl:output
 731                                                 doctype-public=""-//W3C//DTD XHTML 1.0 Strict//EN"" />
 732                                         <xsl:template match=""/"">
 733                                                 <xsl:element name=""test"">
 734                                                         <xsl:element name=""abc"" />
 735                                                 </xsl:element>
 736                                         </xsl:template>
 737                                 </xsl:stylesheet>";
 738
 739                         sw.GetStringBuilder ().Length = 0;
 740                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 741                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 742                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 743
 744                         Assert.AreEqual (
 745                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 746                                 "<test><abc /></test>", sw.ToString (), "#2");
 747
 748                         // only set doctype-system
 749                         xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 750                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 751                                         <xsl:output
 752                                                 indent=""no""
 753                                                 doctype-system=""http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"" />
 754                                         <xsl:template match=""/"">
 755                                                 <xsl:element name=""test"">
 756                                                         <xsl:element name=""abc"" />
 757                                                 </xsl:element>
 758                                         </xsl:template>
 759                                 </xsl:stylesheet>";
 760
 761                         sw.GetStringBuilder ().Length = 0;
 762                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 763                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 764                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 765
 766                         Assert.AreEqual (
 767                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 768                                 "<!DOCTYPE test SYSTEM \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">" +
 769                                 "<test><abc /></test>", sw.ToString (), "#3");
 770
 771                         // set empty doctype-public and empty doctype-system
 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                                                 doctype-public=""""
 776                                                 doctype-system="""" />
 777                                         <xsl:template match=""/"">
 778                                                 <xsl:element name=""test"">
 779                                                         <xsl:element name=""abc"" />
 780                                                 </xsl:element>
 781                                         </xsl:template>
 782                                 </xsl:stylesheet>";
 783
 784                         sw.GetStringBuilder ().Length = 0;
 785                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 786                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 787                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 788
 789                         Assert.AreEqual (
 790                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 791                                 "<!DOCTYPE test PUBLIC \"\" \"\">" +
 792                                 "<test><abc /></test>", sw.ToString (), "#4");
 793
 794                         // set empty doctype-public
 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                                                 indent=""no""
 799                                                 doctype-public="""" />
 800                                         <xsl:template match=""/"">
 801                                                 <xsl:element name=""test"">
 802                                                         <xsl:element name=""abc"" />
 803                                                 </xsl:element>
 804                                         </xsl:template>
 805                                 </xsl:stylesheet>";
 806
 807                         sw.GetStringBuilder ().Length = 0;
 808                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 809                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 810                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 811
 812                         Assert.AreEqual (
 813                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 814                                 "<test><abc /></test>", sw.ToString (), "#5");
 815
 816                         // set empty doctype-system
 817                         xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 818                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 819                                         <xsl:output
 820                                                 doctype-system="""" />
 821                                         <xsl:template match=""/"">
 822                                                 <xsl:element name=""test"">
 823                                                         <xsl:element name=""abc"" />
 824                                                 </xsl:element>
 825                                         </xsl:template>
 826                                 </xsl:stylesheet>";
 827
 828                         sw.GetStringBuilder ().Length = 0;
 829                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 830                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 831                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 832
 833                         Assert.AreEqual (
 834                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
 835                                 "<!DOCTYPE test SYSTEM \"\">" +
 836                                 "<test><abc /></test>", sw.ToString (), "#6");
 837                 }
 838
 839                 [Test]
 840                 public void Output_DocType_Html ()
 841                 {
 842                         XsltArgumentList xsltArgs = new XsltArgumentList ();
 843                         XslTransform xsltProcessor = new XslTransform ();
 844
 845                         // set both doctype-system and doctype-public
 846                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 847                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 848                                         <xsl:output
 849                                                 method=""html""
 850                                                 indent=""no""
 851                                                 doctype-public=""-//W3C//DTD XHTML 1.0 Strict//EN""
 852                                                 doctype-system=""http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"" />
 853                                         <xsl:template match=""/"">
 854                                                 <xsl:element name=""test"">
 855                                                         <xsl:element name=""abc"" />
 856                                                 </xsl:element>
 857                                         </xsl:template>
 858                                 </xsl:stylesheet>";
 859
 860                         XmlDocument xmlDoc = new XmlDocument ();
 861                         xmlDoc.LoadXml ("<dummy />");
 862
 863                         StringWriter sw = new StringWriter ();
 864                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 865                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 866                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 867
 868                         Assert.AreEqual (
 869                                 "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">" +
 870                                 "<test><abc></abc></test>", sw.ToString (), "#1");
 871
 872                         // only set doctype-public
 873                         xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 874                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 875                                         <xsl:output
 876                                                 method=""html""
 877                                                 indent=""no""
 878                                                 doctype-public=""-//W3C//DTD XHTML 1.0 Strict//EN"" />
 879                                         <xsl:template match=""/"">
 880                                                 <xsl:element name=""test"">
 881                                                         <xsl:element name=""abc"" />
 882                                                 </xsl:element>
 883                                         </xsl:template>
 884                                 </xsl:stylesheet>";
 885
 886                         sw.GetStringBuilder ().Length = 0;
 887                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 888                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 889                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 890
 891                         Assert.AreEqual (
 892                                 "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" >" +
 893                                 "<test><abc></abc></test>", sw.ToString (), "#2");
 894
 895                         // only set doctype-system
 896                         xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 897                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 898                                         <xsl:output
 899                                                 method=""html""
 900                                                 indent=""no""
 901                                                 doctype-system=""http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"" />
 902                                         <xsl:template match=""/"">
 903                                                 <xsl:element name=""test"">
 904                                                         <xsl:element name=""abc"" />
 905                                                 </xsl:element>
 906                                         </xsl:template>
 907                                 </xsl:stylesheet>";
 908
 909                         sw.GetStringBuilder ().Length = 0;
 910                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 911                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 912                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 913
 914                         Assert.AreEqual (
 915                                 "<!DOCTYPE html SYSTEM \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">" +
 916                                 "<test><abc></abc></test>", sw.ToString (), "#3");
 917
 918                         // set empty doctype-public and empty doctype-system
 919                         xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 920                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 921                                         <xsl:output
 922                                                 method=""html""
 923                                                 indent=""no""
 924                                                 doctype-public="""" doctype-system="""" />
 925                                         <xsl:template match=""/"">
 926                                                 <xsl:element name=""test"">
 927                                                         <xsl:element name=""abc"" />
 928                                                 </xsl:element>
 929                                         </xsl:template>
 930                                 </xsl:stylesheet>";
 931
 932                         sw.GetStringBuilder ().Length = 0;
 933                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 934                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 935                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 936
 937                         Assert.AreEqual (
 938                                 "<!DOCTYPE html PUBLIC \"\" \"\">" +
 939                                 "<test><abc></abc></test>", sw.ToString (), "#4");
 940
 941                         // set empty doctype-public
 942                         xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 943                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 944                                         <xsl:output
 945                                                 method=""html""
 946                                                 indent=""no""
 947                                                 doctype-public="""" />
 948                                         <xsl:template match=""/"">
 949                                                 <xsl:element name=""test"">
 950                                                         <xsl:element name=""abc"" />
 951                                                 </xsl:element>
 952                                         </xsl:template>
 953                                 </xsl:stylesheet>";
 954
 955                         sw.GetStringBuilder ().Length = 0;
 956                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 957                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 958                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 959
 960                         Assert.AreEqual (
 961                                 "<!DOCTYPE html PUBLIC \"\" >" +
 962                                 "<test><abc></abc></test>", sw.ToString (), "#5");
 963
 964                         // set empty doctype-system
 965                         xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 966                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 967                                         <xsl:output
 968                                                 method=""html""
 969                                                 indent=""no""
 970                                                 doctype-system="""" />
 971                                         <xsl:template match=""/"">
 972                                                 <xsl:element name=""test"">
 973                                                         <xsl:element name=""abc"" />
 974                                                 </xsl:element>
 975                                         </xsl:template>
 976                                 </xsl:stylesheet>";
 977
 978                         sw.GetStringBuilder ().Length = 0;
 979                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
 980                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
 981                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
 982
 983                         Assert.AreEqual (
 984                                 "<!DOCTYPE html SYSTEM \"\">" +
 985                                 "<test><abc></abc></test>", sw.ToString (), "#6");
 986                 }
 987
 988                 [Test]
 989                 public void Output_Indent_Xml_DocType ()
 990                 {
 991                         XsltArgumentList xsltArgs = new XsltArgumentList ();
 992                         XslTransform xsltProcessor = new XslTransform ();
 993
 994                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
 995                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
 996                                         <xsl:output
 997                                                 doctype-public=""-//W3C//DTD XHTML 1.0 Strict//EN""
 998                                                 doctype-system=""http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd""
 999                                                 {0} />
1000                                         <xsl:template match=""/"">
1001                                                 <xsl:element name=""test"">
1002                                                         <xsl:element name=""something"">
1003                                                                 <xsl:element name=""else"" />
1004                                                         </xsl:element>
1005                                                 </xsl:element>
1006                                         </xsl:template>
1007                                 </xsl:stylesheet>";
1008
1009                         XmlDocument xmlDoc = new XmlDocument ();
1010                         xmlDoc.LoadXml ("<dummy />");
1011
1012                         // set indent to yes
1013                         StringWriter sw = new StringWriter ();
1014                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1015                                 string.Format (xsltFragment, "indent=\"yes\""))),
1016                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1017                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1018
1019                         Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
1020                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" +
1021                                 "<!DOCTYPE test PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">{0}" +
1022                                 "<test>{0}" +
1023                                 "  <something>{0}" +
1024                                 "    <else />{0}" +
1025                                 "  </something>{0}" +
1026                                 "</test>", end_of_line), sw.ToString (), "#1");
1027
1028                         // set indent to no
1029                         sw.GetStringBuilder ().Length = 0;
1030                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1031                                 string.Format (xsltFragment, "indent=\"no\""))),
1032                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1033                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1034
1035                         Assert.AreEqual (
1036                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1037                                 "<!DOCTYPE test PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">" +
1038                                 "<test><something><else /></something></test>", sw.ToString (),
1039                                 "#2");
1040
1041                         // indent not set
1042                         sw.GetStringBuilder ().Length = 0;
1043                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1044                                 string.Format (xsltFragment, ""))),
1045                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1046                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1047
1048                         Assert.AreEqual (
1049                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1050                                 "<!DOCTYPE test PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">" +
1051                                 "<test><something><else /></something></test>", sw.ToString (),
1052                                 "#3");
1053                 }
1054
1055                 [Test]
1056                 public void Output_Indent_Html_DocType ()
1057                 {
1058                         XsltArgumentList xsltArgs = new XsltArgumentList ();
1059                         XslTransform xsltProcessor = new XslTransform ();
1060
1061                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1062                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1063                                         <xsl:output
1064                                                 method=""html""
1065                                                 doctype-public=""-//W3C//DTD XHTML 1.0 Strict//EN""
1066                                                 doctype-system=""http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd""
1067                                                 {0} />
1068                                         <xsl:template match=""/"">
1069                                                 <xsl:element name=""test"">
1070                                                         <xsl:element name=""something"">
1071                                                                 <xsl:element name=""else"" />
1072                                                         </xsl:element>
1073                                                 </xsl:element>
1074                                         </xsl:template>
1075                                 </xsl:stylesheet>";
1076
1077                         XmlDocument xmlDoc = new XmlDocument ();
1078                         xmlDoc.LoadXml ("<dummy />");
1079
1080                         // set indent to yes
1081                         StringWriter sw = new StringWriter ();
1082                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1083                                 string.Format (xsltFragment, "indent=\"yes\""))),
1084                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1085                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1086
1087                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1088                                 "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">{0}" +
1089                                 "<test>{0}" +
1090                                 "  <something>{0}" +
1091                                 "    <else>{0}" +
1092                                 "    </else>{0}" +
1093                                 "  </something>{0}" +
1094                                 "</test>", end_of_line), sw.ToString (), "#1");
1095
1096                         // set indent to no
1097                         sw.GetStringBuilder ().Length = 0;
1098                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1099                                 string.Format (xsltFragment, "indent=\"no\""))),
1100                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1101                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1102
1103                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1104                                 "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">" +
1105                                 "<test><something><else></else></something></test>",
1106                                 Environment.NewLine), sw.ToString (), "#2");
1107
1108                         // indent not set
1109                         sw.GetStringBuilder ().Length = 0;
1110                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1111                                 string.Format (xsltFragment, ""))),
1112                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1113                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1114
1115                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1116                                 "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">{0}" +
1117                                 "<test>{0}" +
1118                                 "  <something>{0}" +
1119                                 "    <else>{0}" +
1120                                 "    </else>{0}" +
1121                                 "  </something>{0}" +
1122                                 "</test>", end_of_line), sw.ToString (), "#3");
1123                 }
1124
1125                 [Test]
1126                 public void Output_Indent_Xml ()
1127                 {
1128                         XsltArgumentList xsltArgs = new XsltArgumentList ();
1129                         XslTransform xsltProcessor = new XslTransform ();
1130
1131                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1132                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1133                                         <xsl:output
1134                                                 {0} />
1135                                         <xsl:template match=""/"">
1136                                                 <xsl:element name=""test"">
1137                                                         <xsl:element name=""something"">
1138                                                                 <xsl:element name=""else"" />
1139                                                         </xsl:element>
1140                                                 </xsl:element>
1141                                         </xsl:template>
1142                                 </xsl:stylesheet>";
1143
1144                         XmlDocument xmlDoc = new XmlDocument ();
1145                         xmlDoc.LoadXml ("<dummy />");
1146
1147                         // set indent to yes
1148                         StringWriter sw = new StringWriter ();
1149                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1150                                 string.Format (xsltFragment, "indent=\"yes\""))),
1151                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1152                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1153
1154                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1155                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" +
1156                                 "<test>{0}" +
1157                                 "  <something>{0}" +
1158                                 "    <else />{0}" +
1159                                 "  </something>{0}" +
1160                                 "</test>", end_of_line), sw.ToString (), "#1");
1161
1162                         // set indent to no
1163                         sw.GetStringBuilder ().Length = 0;
1164                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1165                                 string.Format (xsltFragment, "indent=\"no\""))),
1166                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1167                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1168
1169                         Assert.AreEqual (
1170                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1171                                 "<test><something><else /></something></test>", sw.ToString (),
1172                                 "#2");
1173
1174                         // indent not set
1175                         sw.GetStringBuilder ().Length = 0;
1176                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1177                                 string.Format (xsltFragment, ""))),
1178                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1179                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1180
1181                         Assert.AreEqual (
1182                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1183                                 "<test><something><else /></something></test>", sw.ToString (),
1184                                 "#3");
1185                 }
1186
1187                 [Test]
1188                 public void Output_Indent_Html ()
1189                 {
1190                         XsltArgumentList xsltArgs = new XsltArgumentList ();
1191                         XslTransform xsltProcessor = new XslTransform ();
1192
1193                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1194                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1195                                         <xsl:output
1196                                                 method=""html""
1197                                                 {0} />
1198                                         <xsl:template match=""/"">
1199                                                 <xsl:element name=""html"">
1200                                                         <xsl:element name=""body"">
1201                                                                 <xsl:element name=""p"" />
1202                                                                 <xsl:element name=""p"">
1203                                                                         <xsl:text>something</xsl:text>
1204                                                                 </xsl:element>
1205                                                                 <xsl:element name=""p"">
1206                                                                         <xsl:element name=""div"" />
1207                                                                 </xsl:element>
1208                                                                 <xsl:element name=""p"">
1209                                                                         <xsl:element name=""whatever"" />
1210                                                                 </xsl:element>
1211                                                         </xsl:element>
1212                                                 </xsl:element>
1213                                         </xsl:template>
1214                                 </xsl:stylesheet>";
1215
1216                         XmlDocument xmlDoc = new XmlDocument ();
1217                         xmlDoc.LoadXml ("<dummy />");
1218
1219                         // set indent to yes
1220                         StringWriter sw = new StringWriter ();
1221                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1222                                 string.Format (xsltFragment, "indent=\"yes\""))),
1223                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1224                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1225
1226                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1227                                 "<html>{0}" +
1228                                 "  <body>{0}" +
1229                                 "    <p>{0}" +
1230                                 "    </p>{0}" +
1231                                 "    <p>something</p>{0}" +
1232                                 "    <p>{0}" +
1233                                 "      <div>{0}" +
1234                                 "      </div>{0}" +
1235                                 "    </p>{0}" +
1236                                 "    <p>{0}" +
1237                                 "      <whatever>{0}" +
1238                                 "      </whatever>{0}" +
1239                                 "    </p>{0}" +
1240                                 "  </body>{0}" +
1241                                 "</html>", end_of_line), sw.ToString (), "#1");
1242
1243                         // set indent to no
1244                         sw.GetStringBuilder ().Length = 0;
1245                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1246                                 string.Format (xsltFragment, "indent=\"no\""))),
1247                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1248                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1249
1250                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1251                                 "<html><body><p></p><p>something</p><p><div></div></p>" +
1252                                 "<p><whatever></whatever></p></body></html>",
1253                                 Environment.NewLine), sw.ToString (), "#2");
1254
1255                         // indent not set
1256                         sw.GetStringBuilder ().Length = 0;
1257                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1258                                 string.Format (xsltFragment, ""))),
1259                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1260                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1261
1262                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1263                                 "<html>{0}" +
1264                                 "  <body>{0}" +
1265                                 "    <p>{0}" +
1266                                 "    </p>{0}" +
1267                                 "    <p>something</p>{0}" +
1268                                 "    <p>{0}" +
1269                                 "      <div>{0}" +
1270                                 "      </div>{0}" +
1271                                 "    </p>{0}" +
1272                                 "    <p>{0}" +
1273                                 "      <whatever>{0}" +
1274                                 "      </whatever>{0}" +
1275                                 "    </p>{0}" +
1276                                 "  </body>{0}" +
1277                                 "</html>", end_of_line), sw.ToString (), "#3");
1278                 }
1279
1280                 [Test]
1281                 [ExpectedException (typeof (XsltCompileException))]
1282                 public void Output_Indent_Invalid ()
1283                 {
1284                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1285                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1286                                         <xsl:output indent=""Yes"" />
1287                                 </xsl:stylesheet>";
1288                         XslTransform xsltProcessor = new XslTransform ();
1289                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
1290                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1291                 }
1292
1293                 [Test]
1294                 [ExpectedException (typeof (XsltCompileException))]
1295                 public void Output_Indent_Empty ()
1296                 {
1297                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1298                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1299                                         <xsl:output indent="""" />
1300                                 </xsl:stylesheet>";
1301                         XslTransform xsltProcessor = new XslTransform ();
1302                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
1303                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1304                 }
1305
1306                 [Test]
1307                 public void Output_Indent_ForwardsCompatible ()
1308                 {
1309                         StringWriter sw = new StringWriter ();
1310                         XsltArgumentList xsltArgs = new XsltArgumentList ();
1311                         XslTransform xsltProcessor = new XslTransform ();
1312                         XmlDocument xmlDoc = new XmlDocument ();
1313                         xmlDoc.LoadXml ("<dummy />");
1314
1315                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1316                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.5"">
1317                                         <xsl:output indent=""{0}"" />
1318                                         <xsl:template match=""/"">
1319                                                 <root />
1320                                         </xsl:template>
1321                                 </xsl:stylesheet>";
1322
1323                         // indent is "Yes"
1324                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1325                                 string.Format (xsltFragment, "Yes"))),
1326                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1327                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1328
1329                         Assert.AreEqual (
1330                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1331                                 "<root />", sw.ToString (), "#1");
1332
1333                         // indent is empty
1334                         sw.GetStringBuilder ().Length = 0;
1335                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1336                                 string.Format (xsltFragment, ""))),
1337                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1338                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1339
1340                         Assert.AreEqual (
1341                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1342                                 "<root />", sw.ToString (), "#2");
1343                 }
1344
1345                 [Test]
1346                 public void Output_MediaType ()
1347                 {
1348                         StringWriter sw = null;
1349                         XsltArgumentList xsltArgs = new XsltArgumentList ();
1350                         XslTransform xsltProcessor = new XslTransform ();
1351
1352                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1353                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1354                                         <xsl:output media-type=""whatever"" />
1355                                         <xsl:template match=""/"">
1356                                                 <root />
1357                                         </xsl:template>
1358                                 </xsl:stylesheet>";
1359
1360                         XmlDocument xmlDoc = new XmlDocument ();
1361                         xmlDoc.LoadXml ("<dummy />");
1362
1363                         sw = new StringWriter ();
1364                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
1365                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1366                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1367
1368                         Assert.AreEqual (
1369                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1370                                 "<root />", sw.ToString ());
1371                 }
1372
1373                 [Test]
1374                 public void Output_Encoding_TextWriter ()
1375                 {
1376                         StringWriter sw = null;
1377                         XsltArgumentList xsltArgs = new XsltArgumentList ();
1378                         XslTransform xsltProcessor = new XslTransform ();
1379
1380                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1381                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1382                                         <xsl:output {0} />
1383                                         <xsl:template match=""/"">
1384                                                 <root />
1385                                         </xsl:template>
1386                                 </xsl:stylesheet>";
1387
1388                         XmlDocument xmlDoc = new XmlDocument ();
1389                         xmlDoc.LoadXml ("<dummy />");
1390
1391                         // no encoding
1392                         sw = new StringWriter ();
1393                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1394                                 string.Format (xsltFragment, string.Empty))),
1395                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1396                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1397
1398                         Assert.AreEqual (
1399                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1400                                 "<root />", sw.ToString (), "#1");
1401
1402                         // valid encoding
1403                         sw.GetStringBuilder ().Length = 0;
1404                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1405                                 string.Format(xsltFragment, "encoding=\"iso-8859-1\""))),
1406                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1407                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1408
1409                         Assert.AreEqual (
1410                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1411                                 "<root />", sw.ToString (), "#1");
1412
1413                         // invalid encoding
1414                         sw.GetStringBuilder ().Length = 0;
1415                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1416                                 string.Format (xsltFragment, "encoding=\"doesnotexist\""))),
1417                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1418                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1419
1420                         Assert.AreEqual (
1421                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1422                                 "<root />", sw.ToString (), "#2");
1423
1424                         // empty encoding
1425                         sw.GetStringBuilder ().Length = 0;
1426                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1427                                 string.Format (xsltFragment, "encoding=\"\""))),
1428                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1429                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1430
1431                         Assert.AreEqual (
1432                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1433                                 "<root />", sw.ToString (), "#3");
1434                 }
1435
1436                 [Test]
1437                 public void Output_Encoding_Stream ()
1438                 {
1439                         MemoryStream ms = null;
1440                         string result = null;
1441                         XsltArgumentList xsltArgs = new XsltArgumentList ();
1442                         XslTransform xsltProcessor = new XslTransform ();
1443
1444                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1445                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1446                                         <xsl:output {0} />
1447                                         <xsl:template match=""/"">
1448                                                 <root />
1449                                         </xsl:template>
1450                                 </xsl:stylesheet>";
1451
1452                         XmlDocument xmlDoc = new XmlDocument ();
1453                         xmlDoc.LoadXml ("<dummy />");
1454
1455                         // no encoding
1456                         ms = new MemoryStream ();
1457                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1458                                 string.Format (xsltFragment, string.Empty))),
1459                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1460                         xsltProcessor.Transform (xmlDoc, xsltArgs, ms, new XmlUrlResolver ());
1461                         ms.Position = 0;
1462                         using (StreamReader sr = new StreamReader (ms, true)) {
1463                                 result = sr.ReadToEnd ();
1464                         }
1465
1466                         Assert.AreEqual (
1467                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
1468                                 "<root />", result, "#1");
1469
1470                         // valid encoding
1471                         ms = new MemoryStream ();
1472                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1473                                 string.Format (xsltFragment, "encoding=\"iso-8859-1\""))),
1474                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1475                         xsltProcessor.Transform (xmlDoc, xsltArgs, ms, new XmlUrlResolver ());
1476                         ms.Position = 0;
1477                         using (StreamReader sr = new StreamReader (ms, true)) {
1478                                 result = sr.ReadToEnd ();
1479                         }
1480
1481                         Assert.AreEqual (
1482                                 "<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>" +
1483                                 "<root />", result, "#2");
1484
1485                         // invalid encoding
1486                         ms = new MemoryStream ();
1487                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1488                                 string.Format (xsltFragment, "encoding=\"doesnotexist\""))),
1489                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1490                         xsltProcessor.Transform (xmlDoc, xsltArgs, ms, new XmlUrlResolver ());
1491                         ms.Position = 0;
1492                         using (StreamReader sr = new StreamReader (ms, true)) {
1493                                 result = sr.ReadToEnd ();
1494                         }
1495
1496                         Assert.AreEqual (
1497                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
1498                                 "<root />", result, "#3");
1499
1500                         // empty encoding
1501                         ms = new MemoryStream ();
1502                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1503                                 string.Format (xsltFragment, "encoding=\"\""))),
1504                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1505                         xsltProcessor.Transform (xmlDoc, xsltArgs, ms, new XmlUrlResolver ());
1506                         ms.Position = 0;
1507                         using (StreamReader sr = new StreamReader (ms, true)) {
1508                                 result = sr.ReadToEnd ();
1509                         }
1510
1511                         Assert.AreEqual (
1512                                 "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
1513                                 "<root />", result, "#4");
1514                 }
1515
1516                 [Test]
1517                 public void Output_Version ()
1518                 {
1519                         StringWriter sw = null;
1520                         XsltArgumentList xsltArgs = new XsltArgumentList ();
1521                         XslTransform xsltProcessor = new XslTransform ();
1522
1523                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1524                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1525                                         <xsl:output version=""{0}"" />
1526                                         <xsl:template match=""/"">
1527                                                 <root />
1528                                         </xsl:template>
1529                                 </xsl:stylesheet>";
1530
1531                         XmlDocument xmlDoc = new XmlDocument ();
1532                         xmlDoc.LoadXml ("<dummy />");
1533
1534                         // version 1.0
1535                         sw = new StringWriter ();
1536                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1537                                 string.Format (xsltFragment, "1.0"))),
1538                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1539                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1540
1541                         Assert.AreEqual (
1542                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1543                                 "<root />", sw.ToString (), "#1");
1544
1545                         // version 2.0
1546                         sw.GetStringBuilder ().Length = 0;
1547                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1548                                 string.Format (xsltFragment, "2.0"))),
1549                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1550                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1551
1552                         Assert.AreEqual (
1553                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1554                                 "<root />", sw.ToString (), "#2");
1555
1556                         // version BLABLA
1557                         sw.GetStringBuilder ().Length = 0;
1558                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1559                                 string.Format (xsltFragment, "BLABLA"))),
1560                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1561                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1562
1563                         Assert.AreEqual (
1564                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1565                                 "<root />", sw.ToString (), "#3");
1566                 }
1567
1568                 [Test]
1569                 public void Output_Method_Html_TextWriter ()
1570                 {
1571                         string options = null;
1572                         StringWriter sw = null;
1573                         XsltArgumentList xsltArgs = new XsltArgumentList ();
1574                         XslTransform xsltProcessor = new XslTransform ();
1575
1576                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1577                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1578                                         <xsl:output method=""html"" {0} />
1579                                         <xsl:template match=""/"">
1580                                                 <xsl:element name=""html"">
1581                                                         <xsl:element name=""head"">
1582                                                                 <xsl:element name=""title"">Output Test</xsl:element>
1583                                                         </xsl:element>
1584                                                         <xsl:element name=""Body"">
1585                                                                 <xsl:element name=""BR"" />
1586                                                         </xsl:element>
1587                                                 </xsl:element>
1588                                         </xsl:template>
1589                                 </xsl:stylesheet>";
1590
1591                         XmlDocument xmlDoc = new XmlDocument ();
1592                         xmlDoc.LoadXml ("<dummy />");
1593
1594                         // indent not set, media-type not set
1595                         sw = new StringWriter ();
1596                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1597                                 string.Format (xsltFragment, string.Empty))),
1598                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1599                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1600
1601                         Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
1602                                 "<html>{0}" +
1603                                 "{1}<head>{0}" +
1604                                 "{1}{1}<META http-equiv=\"Content-Type\" content=\"text/html; charset=utf-16\">{0}" +
1605                                 "{1}{1}<title>Output Test</title>{0}" +
1606                                 "{1}</head>{0}" +
1607                                 "{1}<Body>{0}" +
1608                                 "{1}{1}<BR>{0}" +
1609                                 "{1}</Body>{0}" +
1610                                 "</html>", end_of_line, "  "), sw.ToString (), "#1");
1611
1612                         // indent no, media-type not set
1613                         options = "indent=\"no\"";
1614                         sw.GetStringBuilder ().Length = 0;
1615                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1616                                 string.Format (xsltFragment, options))),
1617                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1618                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1619
1620                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1621                                 "<html>{0}" +
1622                                 "{1}<head>{0}" +
1623                                 "{1}{1}<META http-equiv=\"Content-Type\" content=\"text/html; charset=utf-16\">{0}" +
1624                                 "{1}{1}<title>Output Test</title>{0}" +
1625                                 "{1}</head>{0}" +
1626                                 "{1}<Body>{0}" +
1627                                 "{1}{1}<BR>{0}" +
1628                                 "{1}</Body>{0}" +
1629                                 "</html>", string.Empty, string.Empty), sw.ToString (), "#2");
1630
1631                         // indent yes, media-type "bla", omit-xml-declaration "no"
1632                         options = "indent=\"yes\" media-type=\"bla\"" +
1633                                                 " encoding=\"iso-8859-1\" omit-xml-declaration=\"no\"";
1634                         sw.GetStringBuilder ().Length = 0;
1635                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1636                                 string.Format (xsltFragment, options))),
1637                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1638                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1639
1640                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1641                                 "<html>{0}" +
1642                                 "{1}<head>{0}" +
1643                                 "{1}{1}<META http-equiv=\"Content-Type\" content=\"bla; charset=utf-16\">{0}" +
1644                                 "{1}{1}<title>Output Test</title>{0}" +
1645                                 "{1}</head>{0}" +
1646                                 "{1}<Body>{0}" +
1647                                 "{1}{1}<BR>{0}" +
1648                                 "{1}</Body>{0}" +
1649                                 "</html>", end_of_line, "  "), sw.ToString (), "#3");
1650                 }
1651
1652                 [Test]
1653                 public void Output_Method_Html_Stream ()
1654                 {
1655                         string options = null;
1656                         MemoryStream ms = null;
1657                         string result = null;
1658                         XsltArgumentList xsltArgs = new XsltArgumentList ();
1659                         XslTransform xsltProcessor = new XslTransform ();
1660
1661                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1662                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1663                                         <xsl:output method=""html"" {0} />
1664                                         <xsl:template match=""/"">
1665                                                 <xsl:element name=""html"">
1666                                                         <xsl:element name=""head"">
1667                                                                 <xsl:element name=""title"">Output Test</xsl:element>
1668                                                         </xsl:element>
1669                                                         <xsl:element name=""Body"">
1670                                                                 <xsl:element name=""BR"" />
1671                                                         </xsl:element>
1672                                                 </xsl:element>
1673                                         </xsl:template>
1674                                 </xsl:stylesheet>";
1675
1676                         XmlDocument xmlDoc = new XmlDocument ();
1677                         xmlDoc.LoadXml ("<dummy />");
1678
1679                         // indent not set, media-type not set
1680                         ms = new MemoryStream ();
1681                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1682                                 string.Format (xsltFragment, string.Empty))),
1683                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1684                         xsltProcessor.Transform (xmlDoc, xsltArgs, ms, new XmlUrlResolver ());
1685                         ms.Position = 0;
1686                         using (StreamReader sr = new StreamReader (ms, true)) {
1687                                 result = sr.ReadToEnd ();
1688                         }
1689
1690                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1691                                 "<html>{0}" +
1692                                 "{1}<head>{0}" +
1693                                 "{1}{1}<META http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">{0}" +
1694                                 "{1}{1}<title>Output Test</title>{0}" +
1695                                 "{1}</head>{0}" +
1696                                 "{1}<Body>{0}" +
1697                                 "{1}{1}<BR>{0}" +
1698                                 "{1}</Body>{0}" +
1699                                 "</html>", end_of_line, "  "), result, "#1");
1700
1701                         // indent no, media-type not set
1702                         options = "indent=\"no\"";
1703                         ms = new MemoryStream ();
1704                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1705                                 string.Format (xsltFragment, options))),
1706                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1707                         xsltProcessor.Transform (xmlDoc, xsltArgs, ms, new XmlUrlResolver ());
1708                         ms.Position = 0;
1709                         using (StreamReader sr = new StreamReader (ms, true)) {
1710                                 result = sr.ReadToEnd ();
1711                         }
1712
1713                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1714                                 "<html>{0}" +
1715                                 "{1}<head>{0}" +
1716                                 "{1}{1}<META http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\">{0}" +
1717                                 "{1}{1}<title>Output Test</title>{0}" +
1718                                 "{1}</head>{0}" +
1719                                 "{1}<Body>{0}" +
1720                                 "{1}{1}<BR>{0}" +
1721                                 "{1}</Body>{0}" +
1722                                 "</html>", string.Empty, string.Empty), result, "#2");
1723
1724                         // indent yes, media-type "bla", omit-xml-declaration "no"
1725                         options = "indent=\"yes\" media-type=\"bla\"" +
1726                                                 " encoding=\"iso-8859-1\" omit-xml-declaration=\"no\"";
1727                         ms = new MemoryStream ();
1728                         xsltProcessor.Load (new XmlTextReader (new StringReader (
1729                                 string.Format (xsltFragment, options))),
1730                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1731                         xsltProcessor.Transform (xmlDoc, xsltArgs, ms, new XmlUrlResolver ());
1732                         ms.Position = 0;
1733                         using (StreamReader sr = new StreamReader (ms, true)) {
1734                                 result = sr.ReadToEnd ();
1735                         }
1736
1737                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1738                                 "<html>{0}" +
1739                                 "{1}<head>{0}" +
1740                                 "{1}{1}<META http-equiv=\"Content-Type\" content=\"bla; charset=iso-8859-1\">{0}" +
1741                                 "{1}{1}<title>Output Test</title>{0}" +
1742                                 "{1}</head>{0}" +
1743                                 "{1}<Body>{0}" +
1744                                 "{1}{1}<BR>{0}" +
1745                                 "{1}</Body>{0}" +
1746                                 "</html>", end_of_line, "  "), result, "#3");
1747                 }
1748
1749                 [Test]
1750                 [ExpectedException (typeof (XsltCompileException))]
1751                 public void Output_Unknown_Attribute ()
1752                 {
1753                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1754                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.0"">
1755                                         <xsl:output whatever="""" />
1756                                 </xsl:stylesheet>";
1757                         XslTransform xsltProcessor = new XslTransform ();
1758                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
1759                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1760                 }
1761
1762                 [Test]
1763                 public void Output_Unknown_Attribute_ForwardsCompatible ()
1764                 {
1765                         StringWriter sw = new StringWriter ();
1766                         XsltArgumentList xsltArgs = new XsltArgumentList ();
1767                         XslTransform xsltProcessor = new XslTransform ();
1768                         XmlDocument xmlDoc = new XmlDocument ();
1769                         xmlDoc.LoadXml ("<dummy />");
1770
1771                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1772                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" version=""1.5"">
1773                                         <xsl:output whatever="""" />
1774                                         <xsl:template match=""/"">
1775                                                 <root />
1776                                         </xsl:template>
1777                                 </xsl:stylesheet>";
1778
1779                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
1780                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1781                         xsltProcessor.Transform (xmlDoc, xsltArgs, sw, new XmlUrlResolver ());
1782
1783                         Assert.AreEqual (
1784                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
1785                                 "<root />", sw.ToString (), "#1");
1786                 }
1787
1788                 [Test]
1789                 public void Output_Unknown_Attribute_NonDefaultNamespace ()
1790                 {
1791                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8"" ?>
1792                                 <xsl:stylesheet xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"" xmlns:tst=""something"" version=""1.0"">
1793                                         <xsl:output tst:whatever="""" />
1794                                 </xsl:stylesheet>";
1795                         XslTransform xsltProcessor = new XslTransform ();
1796                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
1797                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1798                 }
1799
1800                 // http://support.microsoft.com/kb/832757/en-us
1801                 [Test]
1802                 public void FormatNumber_KB_832757 ()
1803                 {
1804                         string xsltFragment = @"<?xml version=""1.0"" encoding=""UTF-8""?>
1805                                 <xsl:stylesheet version=""1.0"" xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"">
1806                                         <xsl:output method=""xml"" version=""1.0"" encoding=""UTF-8"" indent=""yes"" />
1807                                         <xsl:template match=""/"">
1808                                                 <table>
1809                                                         <xsl:apply-templates />
1810                                                 </table>
1811                                         </xsl:template>
1812                                         <xsl:template match=""number"">
1813                                                 <tr><td><xsl:value-of select=""format-number(.,'#,##0;(#,##0)')""/></td></tr>
1814                                         </xsl:template>
1815                                 </xsl:stylesheet>";
1816
1817                         XmlDocument xmlDoc = new XmlDocument ();
1818                         xmlDoc.LoadXml ("<root><number>1000</number></root>");
1819
1820                         StringWriter sw = new StringWriter ();
1821                         XslTransform xsltProcessor = new XslTransform ();
1822                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
1823                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1824                         xsltProcessor.Transform (xmlDoc, new XsltArgumentList (), sw,
1825                                 new XmlUrlResolver ());
1826
1827                         Assert.AreEqual (string.Format(CultureInfo.InvariantCulture,
1828                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" +
1829                                 "<table>{0}" +
1830                                 "  <tr>{0}" +
1831                                 "    <td>1,000</td>{0}" +
1832                                 "  </tr>{0}" +
1833                                 "</table>", end_of_line), sw.ToString ());
1834                 }
1835
1836                 // http://support.microsoft.com/kb/293469/en-us
1837                 [Test]
1838                 public void FormatNumber_KB_293469 ()
1839                 {
1840                         string xsltFragment = @"<?xml version=""1.0""?>
1841                                 <xsl:stylesheet version=""1.0"" xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"">
1842                                         <xsl:output method=""xml"" indent=""yes"" />
1843                                         <xsl:decimal-format name=""european"" decimal-separator="","" grouping-separator=""."" />
1844                                         <xsl:template match=""/"">
1845                                                 <xsl:element name=""html"">
1846                                                         <xsl:element name=""body"">
1847                                                                 <xsl:apply-templates select=""root/amount"" />
1848                                                         </xsl:element>
1849                                                 </xsl:element>
1850                                         </xsl:template>
1851                                         <xsl:template match=""amount"">
1852                                                 <xsl:value-of select=""format-number(., '###.###,00', 'european')""/>
1853                                         </xsl:template>
1854                                 </xsl:stylesheet>";
1855
1856                         XmlDocument xmlDoc = new XmlDocument ();
1857                         xmlDoc.LoadXml ("<root><amount currency='USD'>44442.7</amount></root>");
1858
1859                         StringWriter sw = new StringWriter ();
1860                         XslTransform xsltProcessor = new XslTransform ();
1861                         xsltProcessor.Load (new XmlTextReader (new StringReader (xsltFragment)),
1862                                 new XmlUrlResolver (), AppDomain.CurrentDomain.Evidence);
1863                         xsltProcessor.Transform (xmlDoc, new XsltArgumentList (), sw,
1864                                 new XmlUrlResolver ());
1865
1866                         Assert.AreEqual (string.Format (CultureInfo.InvariantCulture,
1867                                 "<?xml version=\"1.0\" encoding=\"utf-16\"?>{0}" +
1868                                 "<html>{0}" +
1869                                 "  <body>44.442,70</body>{0}" +
1870                                 "</html>", end_of_line), sw.ToString ());
1871                 }
1872
1873                 [Test]
1874                 [Category ("NotDotNet")]
1875                 // MS bug: the output must be well-formed XML general entity
1876                 // (doctype must not appear after text nodes).
1877                 public void DocTypeAfterText ()
1878                 {
1879                         string xsl = @"
1880 <xsl:stylesheet version='1.0' xmlns:xsl='http://www.w3.org/1999/XSL/Transform'>
1881     <xsl:output doctype-system='system'/>
1882     <xsl:template match='/'>
1883         <xsl:text xml:space='preserve'> a </xsl:text>
1884         <foo/>
1885     </xsl:template>
1886 </xsl:stylesheet>";
1887                         XslTransform t = new XslTransform ();
1888                         t.Load (new XmlTextReader (xsl, XmlNodeType.Document, null));
1889                         XmlDocument doc = new XmlDocument ();
1890                         try {
1891                                 t.Transform (new XPathDocument (
1892                                              new StringReader ("<root/>")),
1893                                              null, TextWriter.Null);
1894                                 Assert.Fail ("should fail; doctype is not allowed after whitespace. See XSLT 1.0 section 16.1.");
1895                         } catch {
1896                         }
1897                 }
1898
1899                 [Test]
1900                 public void StripSpace ()
1901                 {
1902                         string result = @"
1903 MonoDevelop
1904 ProjectTemplates
1905 FileTemplates
1906 IDE
1907 StartupHandlers
1908 FileTemplateTypes
1909 Workspace
1910 Applications
1911 Services
1912 ";
1913
1914                         XslTransform t = new XslTransform ();
1915                         t.Load ("Test/XmlFiles/xsl/stripspace.xsl");
1916                         XPathDocument d = new XPathDocument (
1917                                 "Test/XmlFiles/xsl/stripspace.xml", XmlSpace.Preserve);
1918                         StringWriter sw = new StringWriter ();
1919                         t.Transform (d, null, sw);
1920                         Assert.AreEqual (result, sw.ToString ());
1921                 }
1922
1923                 [Test]
1924                 public void CurrentInSelect ()
1925                 {
1926                         XslTransform t = new XslTransform ();
1927                         t.Load ("Test/XmlFiles/xsl/current-in-select.xsl");
1928                         XPathDocument d = new XPathDocument (
1929                                 "Test/XmlFiles/xsl/current-in-select.xml", XmlSpace.Preserve);
1930                         StringWriter sw = new StringWriter ();
1931                         t.Transform (d, null, sw);
1932                         using (StreamReader sr = File.OpenText (
1933                                "Test/XmlFiles/xsl/current-in-select.ref")) {
1934                                 string s = sr.ReadToEnd ();
1935                                 Assert.AreEqual (s, sw.ToString ());
1936                         }
1937                 }
1938
1939                 [Test]
1940                 public void CallTemplateSignificantWhitespace ()
1941                 {
1942                         // bug #82357
1943                         string xsl = @"<xsl:stylesheet version='1.0' xmlns:xsl='http://www.w3.org/1999/XSL/Transform'>
1944   <xsl:template name='foo' xml:space='preserve'>
1945     <xsl:call-template name='bar'>
1946       <xsl:with-param name='hoge' select='hoge' />
1947     </xsl:call-template>
1948   </xsl:template>
1949
1950   <xsl:template name='bar'>
1951   </xsl:template>
1952 </xsl:stylesheet>";
1953                         XslTransform t = new XslTransform ();
1954                         t.Load (new XmlTextReader (new StringReader (xsl)));
1955                         t.Transform (new XPathDocument (new StringReader ("<dummy/>")), null, new XmlTextWriter (TextWriter.Null));
1956                 }
1957
1958                 [Test]
1959                 public void Bug82493 ()
1960                 {
1961                         XslTransform transformationObj = new XslTransform ();
1962                         transformationObj.Load ("Test/XmlFiles/xsl/82493.xsl");
1963                         XmlDocument doc = new XmlDocument ();
1964                         doc.Load ("Test/XmlFiles/xsl/82493.xml");
1965                         XslExtensionClass GetCalculation = new XslExtensionClass ("a4");
1966                         XsltArgumentList xslExtensionArgList = new XsltArgumentList ();
1967                         xslExtensionArgList.AddExtensionObject ("urn:e", GetCalculation);
1968                         XmlTextWriter writer = new XmlTextWriter (TextWriter.Null);
1969                         transformationObj.Transform (doc, xslExtensionArgList, writer, null);
1970
1971                 }
1972
1973                 [Test]
1974                 public void BugNovell325482 ()
1975                 {
1976                         XmlDocument doc = new XmlDocument ();
1977                         doc.Load ("Test/XmlFiles/xsl/325482.xml");
1978                         XslTransform xt = new XslTransform ();
1979                         xt.Load ("Test/XmlFiles/xsl/325482.xsl");
1980                         xt.Transform (doc, null, TextWriter.Null);
1981                 }
1982
1983                 public class XslExtensionClass
1984                 {
1985                         private string paperType = String.Empty;
1986
1987                         public XslExtensionClass (string paperType)
1988                         {
1989                                 this.paperType = paperType;
1990                         }
1991
1992                         public int GetPageDimensions ()
1993                         {
1994                                 switch (this.paperType) {
1995                                 case "a4":
1996                                         return 210297;
1997                                 case "letter":
1998                                         return 216279;
1999                                 default:
2000                                         throw new ArgumentException ("Unknown page size type: " + this.paperType);
2001                                 }
2002                         }
2003                 }
2004
2005                 [Test] // bug #348786
2006                 public void ValueOfContainsExternalElements ()
2007                 {
2008                         string xsl = @"
2009 <xsl:stylesheet version=""1.0"" xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"">
2010   <xsl:template match=""x"">
2011     <y>
2012       <xsl:value-of select=""@bar"">
2013         <!-- enter comment here -->
2014       </xsl:value-of>
2015     </y>
2016   </xsl:template>
2017 </xsl:stylesheet>";
2018                         new XslTransform ().Load (new XmlTextReader (xsl, XmlNodeType.Document, null));
2019                 }
2020
2021                 [Test] // bug #349035
2022                 public void CompareRTFAsStringNotNodeset ()
2023                 {
2024                         XslTransform xslt = new XslTransform ();
2025                         xslt.Load (new XmlTextReader (new StringReader (@"
2026 <xsl:stylesheet version=""1.0""
2027   xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"">
2028   <xsl:template name=""foo"">
2029     <xsl:param name=""bar""/>
2030     <xsl:if test=""$bar!=''"">
2031       <bar>bar is not empty:'<xsl:value-of select=""$bar""/>'</bar>
2032     </xsl:if>
2033     <xsl:if test=""$bar=''"">
2034       <bar>bar is empty</bar>
2035     </xsl:if>
2036   </xsl:template>
2037   <xsl:template match=""zap"">
2038     <xsl:call-template name=""foo"">
2039       <xsl:with-param name=""bar"">
2040         <xsl:for-each select=""@bar"">
2041           <xsl:value-of select="".""/>
2042         </xsl:for-each>
2043       </xsl:with-param>
2044     </xsl:call-template>
2045   </xsl:template>
2046 </xsl:stylesheet>"
2047                         )));
2048                         XPathDocument input = new XPathDocument (new StringReader (
2049                         @"<root>
2050         <zap bar=""HaHa""/>
2051         <zap/>
2052 </root>"
2053                 ));
2054                         StringWriter sw = new StringWriter ();
2055                         XmlTextWriter xtw = new XmlTextWriter (sw);
2056                         xslt.Transform (input, null, xtw);
2057                         string expected = "<bar>bar is not empty:'HaHa'</bar><bar>bar is empty</bar>";
2058                         Assert.AreEqual (expected, sw.ToString ());
2059                 }
2060
2061                 [Test]
2062                 public void Bug349111 ()
2063                 {
2064                         XslTransform xslt = new XslTransform ();
2065                         xslt.Load (new XmlTextReader (new StringReader (@"
2066 <xsl:stylesheet version=""1.0"" xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"">
2067   <xsl:template match=""book"">
2068     <xsl:for-each select=""child::node()[position()]"">
2069       <yyy>
2070         <xsl:value-of select="".""/>
2071       </yyy>
2072     </xsl:for-each>
2073   </xsl:template>
2074 </xsl:stylesheet>"
2075                                 )));
2076                         XPathDocument input = new XPathDocument (new StringReader (@"
2077 <bookstore>
2078   <book> <title lang=""eng"">Harry Potter</title> <price>29.99</price> </book>
2079 </bookstore>"
2080                                 ));
2081                         StringWriter sw = new StringWriter ();
2082                         xslt.Transform (input, null, new XmlTextWriter (sw));
2083                         string expected = "<yyy>Harry Potter</yyy><yyy>29.99</yyy>";
2084                         Assert.AreEqual (expected, sw.ToString ());
2085                 }
2086
2087                 [Test]
2088                 public void Bug351939 ()
2089                 {
2090                         XslTransform xslt = new XslTransform ();
2091                         xslt.Load (new XmlTextReader (new StringReader (
2092 @"<xsl:stylesheet version=""1.0""
2093   xmlns:xsl=""http://www.w3.org/1999/XSL/Transform"">
2094   <xsl:key name=""thekey"" match=""aa"" use=""''""/>
2095   <xsl:key name=""thekey"" match=""ab"" use=""''""/>
2096   <xsl:template match=""root"">
2097     <x>
2098       <foo><xsl:value-of select=""key('thekey','')[1]""/></foo>
2099       <bar><xsl:value-of select=""key('thekey','')[2]""/></bar>
2100       <baz><xsl:value-of select=""key('thekey','')[3]""/></baz>
2101       <tem><xsl:value-of select=""key('thekey','')[4]""/></tem>
2102     </x>
2103   </xsl:template>
2104 </xsl:stylesheet>")));
2105                         StringWriter sw = new StringWriter ();
2106                         xslt.Transform (new XPathDocument (new StringReader (
2107 @"<?xml version=""1.0""?>
2108 <root>
2109   <a>
2110     <aa>1</aa>
2111     <ab>2</ab>
2112   </a>
2113   <a>
2114     <aa>3</aa>
2115     <ab>4</ab>
2116   </a>
2117 </root>")), null, new XmlTextWriter (sw));
2118                         Assert.AreEqual ("<x><foo>1</foo><bar>2</bar><baz>3</baz><tem>4</tem></x>", sw.ToString ());
2119                 }
2120
2121                 [Test]
2122                 public void CopyOfIXPathNavigable ()
2123                 {
2124                         string xsl = @"
2125 <xsl:stylesheet version='1.0' xmlns:xsl='http://www.w3.org/1999/XSL/Transform'
2126   xmlns:foo='urn:Foo'>
2127   <xsl:template match='/'>
2128     <xsl:copy-of select='foo:MyCustomFunction()'/>
2129   </xsl:template>
2130 </xsl:stylesheet>";
2131                         string xml = @"
2132 <family>
2133   <person>
2134     <given-name age='10'>
2135       <name>Fred</name>
2136       <nick-name>Freddy</nick-name>
2137     </given-name>
2138     <family-name>Smith</family-name>
2139   </person>
2140   <person>
2141     <given-name age='10'>
2142       <name>Robert</name>
2143       <nick-name>Bob</nick-name>
2144     </given-name>
2145     <family-name>Smith</family-name>
2146   </person>
2147 </family>";
2148                         XslTransform t = new XslTransform ();
2149                         t.Load (new XPathDocument (new StringReader (xsl)));
2150                         XsltArgumentList args = new XsltArgumentList();
2151                         args.AddExtensionObject ("urn:Foo", new CopyOfIXPathNavigableClass ());
2152                         StringWriter sw = new StringWriter ();
2153                         t.Transform (new XPathDocument (new StringReader (xml)), args, new XmlTextWriter (sw));
2154                         Assert.AreEqual ("<root><child0 /><child1 /></root>", sw.ToString ());
2155                 }
2156
2157                 public class CopyOfIXPathNavigableClass
2158                 {
2159                         public object MyCustomFunction ()
2160                         {
2161                                 XmlDocument doc = new XmlDocument ();
2162                                 doc .LoadXml ("<root><child0 /><child1 /></root>");
2163                                 return doc.DocumentElement;
2164                         }
2165                 }
2166
2167                 [Test] // bug #316238
2168                 public void ResolveVariableInXsltArgumentList ()
2169                 {
2170                         ResolveVariableInXsltArgumentList ("Test/XmlFiles/xsl/316238-1.xsl");
2171                         ResolveVariableInXsltArgumentList ("Test/XmlFiles/xsl/316238-2.xsl");
2172                 }
2173
2174                 void ResolveVariableInXsltArgumentList (string file)
2175                 {
2176                         XmlDocument doc = new XmlDocument ();
2177                         doc.LoadXml ("<doc><element id=\"test\">this is a test</element></doc>");
2178                         XslTransform transform = new XslTransform ();
2179                         transform.Load (file);
2180                         //Stream outputStream = Console.OpenStandardOutput();
2181                         XsltArgumentList xsltArgs = new XsltArgumentList ();
2182                         xsltArgs.AddParam ("test", "", "test");
2183                         xsltArgs.AddParam ("doc", "", doc.CreateNavigator().Select ("*"));
2184                         transform.Transform (new XmlDocument (), xsltArgs, TextWriter.Null);
2185                 }
2186
2187                 [Test] // bug #378239
2188                 public void WhitespaceEntityInStylesheet ()
2189                 {
2190                         string xslt = @"<?xml version='1.0' encoding='UTF-8'?>
2191 <!DOCTYPE xsl:stylesheet [
2192 <!ENTITY nl '
2193 '>
2194 ]>
2195 <xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0'>
2196 <xsl:output method='text' omit-xml-declaration='yes'/>
2197
2198 <xsl:template match='/'>
2199 <xsl:text>&nl;Hello&nl;World</xsl:text>
2200 </xsl:template>
2201 </xsl:stylesheet>";
2202                         string expected = @"
2203 Hello
2204 World";
2205                         XslTransform t = new XslTransform ();
2206                         t.Load (new XPathDocument (new StringReader (xslt)));
2207                         StringWriter sw = new StringWriter ();
2208                         t.Transform (new XPathDocument (new StringReader ("<test/>")), null, sw);
2209                         Assert.AreEqual (expected, sw.ToString ());
2210                 }
2211
2212                 [Test] // bug #556619
2213                 public void RejectCurrencySymbolAsNumber ()
2214                 {
2215                         XslTransform xslt = new XslTransform ();
2216                         StringWriter sw = new StringWriter ();
2217                         string s =
2218 @"<?xml version=""1.0""?>
2219
2220 <xsl:stylesheet
2221   version=""1.0""
2222   xmlns:xsl=""http://www.w3.org/1999/XSL/Transform""
2223   >
2224
2225   <xsl:template name=""F"">
2226     <xsl:param name=""p""/>
2227     <xsl:choose>
2228       <xsl:when test=""number($p)"">
2229 YES <xsl:value-of select=""number($p)""/>
2230       </xsl:when>
2231       <xsl:otherwise>
2232 NO
2233       </xsl:otherwise>
2234     </xsl:choose>
2235   </xsl:template>
2236   <xsl:template match=""/"">
2237     <xsl:call-template name=""F"">
2238       <xsl:with-param name=""p"">$4$2</xsl:with-param>
2239     </xsl:call-template>
2240   </xsl:template>
2241
2242 </xsl:stylesheet>";
2243                         xslt.Load (new XmlTextReader (new StringReader (s)));
2244                         xslt.Transform (new XPathDocument (new StringReader (
2245 @"<?xml version=""1.0""?>
2246 <root>
2247 </root>")), null, sw);
2248                         Assert.IsTrue (sw.ToString ().IndexOf ("NO") > 0);
2249                 }
2250
2251                 [Test] // bug #349375
2252                 public void PreserveWhitespace ()
2253                 {
2254                         XslCompiledTransform xslt = new XslCompiledTransform ();
2255                         xslt.Load (new XmlTextReader (new StringReader (@"
2256 <xsl:stylesheet
2257   version=""1.0""
2258   xmlns:xsl=""http://www.w3.org/1999/XSL/Transform""
2259   >
2260   <xsl:output omit-xml-declaration='yes' />
2261   <xsl:strip-space elements='*'/>
2262   <xsl:preserve-space elements='p span'/>
2263
2264   <xsl:template name='foo'>
2265     <xsl:for-each select='node()'>
2266         <xsl:attribute name='yes-one-node'/>
2267         <xsl:value-of select='.'/>
2268     </xsl:for-each>
2269     <xsl:if test='not(node())'>
2270         <xsl:attribute name='not-node'/>
2271         <xsl:value-of select='.'/>
2272     </xsl:if>
2273   </xsl:template>
2274
2275   <xsl:template match='p'>
2276     <y>
2277       <xsl:for-each select='child::node()[position()]'>
2278         <xsl:choose>
2279           <xsl:when test='name()=""span""'>
2280               <t>
2281                 <xsl:call-template name='foo'/>
2282               </t>
2283           </xsl:when>
2284         </xsl:choose>
2285       </xsl:for-each>
2286     </y>
2287   </xsl:template>
2288
2289 </xsl:stylesheet>")));
2290                         StringWriter sw = new StringWriter ();
2291                         xslt.Transform (new XmlTextReader (new StringReader (@"
2292 <root>
2293   <l0>
2294     <p>
2295       <span>1</span>
2296       <span> </span>
2297     </p>
2298   </l0>
2299 </root>")), null, sw);
2300                         Assert.AreEqual (@"<y><t yes-one-node="""">1</t><t yes-one-node=""""> </t></y>", sw.ToString ());
2301                 }
2302
2303                 [Test] // reverse case of #349375
2304             [Category ("MobileNotWorking")]
2305                 public void PreserveWhitespace2 ()
2306                 {
2307                         XslCompiledTransform xslt = new XslCompiledTransform ();
2308                         xslt.Load (new XmlTextReader (new StringReader (@"
2309 <xsl:stylesheet
2310   version=""1.0""
2311   xmlns:xsl=""http://www.w3.org/1999/XSL/Transform""
2312   >
2313   <xsl:output omit-xml-declaration='yes' />
2314   <xsl:preserve-space elements='*'/>
2315   <xsl:strip-space elements='p span'/>
2316
2317   <xsl:template name='foo'>
2318     <xsl:for-each select='node()'>
2319         <xsl:attribute name='yes-one-node'/>
2320         <xsl:value-of select='.'/>
2321     </xsl:for-each>
2322     <xsl:if test='not(node())'>
2323         <xsl:attribute name='not-node'/>
2324         <xsl:value-of select='.'/>
2325     </xsl:if>
2326   </xsl:template>
2327
2328   <xsl:template match='p'>
2329     <y>
2330       <xsl:for-each select='child::node()[position()]'>
2331         <xsl:choose>
2332           <xsl:when test='name()=""span""'>
2333               <t>
2334                 <xsl:call-template name='foo'/>
2335               </t>
2336           </xsl:when>
2337         </xsl:choose>
2338       </xsl:for-each>
2339     </y>
2340   </xsl:template>
2341
2342 </xsl:stylesheet>")));
2343                         StringWriter sw = new StringWriter ();
2344                         xslt.Transform (new XmlTextReader (new StringReader (@"
2345 <root>
2346   <l0>
2347     <p>
2348       <span>1</span>
2349       <span> </span>
2350     </p>
2351   </l0>
2352 </root>")), null, sw);
2353 //                      Assert.AreEqual (@"<y><t yes-one-node="""">1</t><t not-node=""""></t></y>", sw.ToString ());
2354                         Assert.AreEqual ("\r\n  \r\n    <y><t yes-one-node=\"\">1</t><t not-node=\"\"></t></y>\r\n  \r\n".Replace ("\r\n", Environment.NewLine), sw.ToString ());
2355                 }
2356
2357                 [Test]
2358                 public void CompiledTransform_Fragment () // bug #391424
2359                 {
2360                         XslCompiledTransform xslTransform = new XslCompiledTransform ();
2361                         XsltSettings settings = new XsltSettings ();
2362                         settings.EnableDocumentFunction = true;
2363                         xslTransform.Load ("Test/XmlFiles/xsl/391424.xsl", settings, new XmlUrlResolver ());
2364                         StringWriter sw = new StringWriter ();
2365                         xslTransform.Transform (new XPathDocument ("Test/XmlFiles/xsl/391424.xml", XmlSpace.Preserve), null, sw);
2366                         Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?>Document found", sw.ToString ());
2367                 }
2368
2369                 [Test]
2370                 public void XslTextElement_PreservesWhitespace () // bug 450797
2371                 {
2372                         XslCompiledTransform xslt = new XslCompiledTransform ();
2373                         xslt.Load (new XmlTextReader (new StringReader (@"
2374 <xsl:stylesheet
2375   xmlns:xsl=""http://www.w3.org/1999/XSL/Transform""
2376   version=""1.0"">
2377   <xsl:output method='text' omit-xml-declaration='yes'/>
2378   <xsl:template match='foo'>
2379     <xsl:text> </xsl:text>
2380   </xsl:template>
2381 </xsl:stylesheet>")));
2382                         StringWriter sw = new StringWriter ();
2383                         xslt.Transform (new XmlTextReader (new StringReader (@"<foo>bar</foo>")), null, sw);
2384                         Assert.AreEqual (" ", sw.ToString ());
2385                 }
2386
2387                 [Test]
2388             [Category ("MobileNotWorking")]
2389                 public void Bug487065 ()
2390                 {
2391                         using (XmlReader input = GetInput ()) {
2392                                 using (XmlWriter output = XmlWriter.Create (Path.Combine(Path.GetTempPath(), "out.xml"))) {
2393                                         PreProcess (input, output);
2394                                         Assert.IsTrue (valueHasBeenSet, "#1");
2395                                 }
2396                         }
2397                 }
2398
2399                 private static XmlReader GetInput ()
2400                 {
2401                         return XmlReader.Create (new StringReader ("<cb:config-template xmlns:cb=\"urn:ccnet.config.builder\"><cb:define name=\"var1\">value1</cb:define></cb:config-template>"));
2402                 }
2403
2404                 private void PreProcess (XmlReader input, XmlWriter output)
2405                 {
2406                         var xsltsettings = new XsltSettings (true, true);
2407                         var xsltpreprocess = new XslCompiledTransform (true);
2408
2409                         var stream =
2410                                 new StringReader (@"
2411 <xsl:stylesheet version='1.0' xmlns:xsl='http://www.w3.org/1999/XSL/Transform'
2412  xmlns:msxsl='urn:schemas-microsoft-com:xslt'
2413  xmlns:cb='urn:ccnet.config.builder'
2414  xmlns:env='environment'
2415  xmlns:exsl='http://exslt.org/common'
2416  exclude-result-prefixes='msxsl cb env exsl'>
2417   <xsl:template match='cb:define[not(*) and @name]'>
2418     <xsl:for-each select='env:define_text_constant(@name,.)'/>
2419   </xsl:template>
2420 </xsl:stylesheet>");
2421
2422                         using (XmlReader xsltreader = XmlReader.Create (stream))
2423                                 xsltpreprocess.Load (xsltreader, xsltsettings, new XmlUrlResolver());
2424
2425                         var xsltargs = new XsltArgumentList ();
2426
2427                         // The XSLT calls extension functions in _current_env.
2428                         xsltargs.AddExtensionObject ("environment", this);
2429                         xsltpreprocess.Transform (input, xsltargs, output, null);
2430                 }
2431
2432                 public void define_text_constant (string name, string value)
2433                 {
2434                         Assert.AreEqual("var1", name, "#a1");
2435                         Assert.AreEqual("value1", value, "#a2");
2436                         valueHasBeenSet = true;
2437                 }
2438
2439                 private bool valueHasBeenSet;
2440
2441                 [Test] // bug #4434
2442                 public void IncludeProcessStylesheet ()
2443                 {
2444                         string includedXsl = @"<?xml version='1.0' ?>
2445 <xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' xmlns:doc='http://nwalsh.com/xsl/documentation/1.0' exclude-result-prefixes='doc' version='1.0'>
2446         <doc:template name='foo' />
2447         <xsl:template name='foo'>
2448                 <foo />
2449         </xsl:template>
2450 </xsl:stylesheet>";
2451                         string file = Path.Combine (Path.GetTempPath (), "include.xsl");
2452                         StreamWriter includedWriter = new StreamWriter (file);
2453                         includedWriter.WriteLine (includedXsl);
2454                         includedWriter.Close ();
2455                         XslCompiledTransform transform = new XslCompiledTransform ();
2456                         string xsl = @"<?xml version='1.0' ?>
2457 <xsl:stylesheet xmlns:xsl='http://www.w3.org/1999/XSL/Transform' version='1.0'>
2458         <xsl:include href='include.xsl' />
2459         <xsl:template match='/'>
2460                 <xsl:call-template name='foo' />
2461         </xsl:template>
2462 </xsl:stylesheet>".Replace ("include.xsl", file);
2463                         XmlReader xslReader = XmlReader.Create (new StringReader (xsl));
2464                         transform.Load (xslReader);
2465                         XmlReader inputReader = XmlReader.Create (new StringReader ("<bar />"));
2466                         var sw = new StringWriter ();
2467                         XmlWriter outputWriter = XmlWriter.Create (sw);
2468                         transform.Transform (inputReader, outputWriter);
2469                         outputWriter.Close ();
2470                         Assert.AreEqual ("<?xml version=\"1.0\" encoding=\"utf-16\"?><foo />", sw.ToString (), "#1");
2471                 }
2472         }
2473 }