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