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

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