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

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