LayoutTests/fast/xsl/xslt-processor.html

   1 <html>
   2 <head>
   3 <STYLE>
   4 pre { border:1px solid blue }
   5 span { font-weight: bold }
   6 .success { color: green; }
   7 .failure { color: red; }
   8 </STYLE>
   9 </head>
  10 <body id="body">
  11
  12 <script>
  13 if (window.layoutTestController)
  14         layoutTestController.dumpAsText();
  15
  16 var requester = new XMLHttpRequest();
  17 var processor = new XSLTProcessor();
  18 var serializer = new XMLSerializer();
  19
  20 var sectionId = 0;
  21 var testId = 0;
  22
  23 function addSectionHeader(name) {
  24         sectionId++;
  25         document.writeln("<br><span>" + sectionId + ".0 " + name + ":</span><br><br>");
  26         testId = 0;
  27 }
  28
  29 function addResultExpectException(name, func) {
  30         try {
  31                 var result = func();
  32                 addStringResult(testname, "****Failure**** (expected exception, instead got result: \"" + result + "\")", "failure");
  33         } catch (e) {
  34                 // FIXME: probably should check exception type
  35                 addSuccessResult(testname);
  36         }
  37 }
  38
  39 function addResultExpectValueWhenSerialized(name, value, expectedValue) {
  40         var serializedValue;
  41         if (value)
  42                 serializedValue = serializer.serializeToString(value);
  43         if (serializedValue == expectedValue)
  44                 addSuccessResult(name);
  45         else
  46                 addFailureResult(name, expectedValue, serializedValue);
  47 }
  48
  49 function addResultExpectValue(name, value, expectedValue) {
  50         if (value == expectedValue)
  51                 addSuccessResult(name);
  52         else
  53                 addFailureResult(name, expectedValue, value);
  54 }
  55
  56 function getXMLDocument(name)
  57 {
  58         requester.open("GET", name, false);
  59         requester.send(null);
  60         return requester.responseXML;
  61 }
  62
  63 function addStringResult(name, result, cssClass)
  64 {
  65         testId++;
  66         var testNumberString = "" + sectionId + "." + testId
  67         var testIdString = "id" + testNumberString;
  68         document.writeln("<span>" + testNumberString + " " + name + ":</span>");
  69         document.writeln("<pre id=\"" + testIdString + "\" class=\"" + cssClass + "\">@@NO VALUE@@</pre>");
  70         document.getElementById(testIdString).firstChild.nodeValue = result;
  71 }
  72
  73 function addFailureResult(name, expectedValue, actual)
  74 {
  75         addStringResult(name, "****Failure**** (expected: \"" + expectedValue + "\" actual: \"" + actual + "\")", "failure");
  76 }
  77
  78 function addSuccessResult(name)
  79 {
  80         addStringResult(name, "Success", "success");
  81 }
  82
  83 function addXMLResult(name, result)
  84 {
  85         var str;
  86         if (result)
  87                 str = serializer.serializeToString(result);
  88         addStringResult(name, str);
  89 }
  90
  91 var xml = getXMLDocument("xslt-text.xml");
  92 addXMLResult("original xml", xml);
  93 var xsl1 = getXMLDocument("xslt-text.xsl");
  94 addXMLResult("xsl1", xsl1);
  95 var xsl2 = getXMLDocument("resources/xslt-enc.xsl");
  96 addXMLResult("xsl2", xsl2);
  97
  98
  99
 100 // 1.0 void importStylesheet(in DOMNode style);
 101 addSectionHeader("void importStylesheet(in DOMNode style)");
 102 // 1.1 Import two different stylesheets (last one wins)
 103
 104 processor.importStylesheet(xsl1);
 105 processor.importStylesheet(xsl2);
 106 var newXML = processor.transformToDocument(xml);
 107 addXMLResult("Import two different stylesheets", newXML);
 108
 109 // 1.2 Import same stylesheet twice
 110
 111 processor.reset();
 112 processor.importStylesheet(xsl1);
 113 processor.importStylesheet(xsl1);
 114
 115 var newXML = processor.transformToDocument(xml);
 116 addXMLResult("Import same stylesheet twice", newXML);
 117
 118 // 1.3 Import undefined stylesheet
 119
 120 processor.reset();
 121 var testname = "Import undefined stylesheet";
 122 addResultExpectException(testname, function () { return processor.importStylesheet(undefined); } );
 123
 124 // 1.4 Import invalid stylesheet (not wellformed xlst)
 125
 126 processor.reset();
 127 var testName = "Import invalid stylesheet";
 128 addResultExpectException(testname, function () { return processor.importStylesheet(xml); } );
 129
 130 // 1.5 Don't import stylesheet
 131
 132 processor.reset();
 133 var newXML = processor.transformToDocument(xml);
 134 addResultExpectValueWhenSerialized("Don't import stylesheet", newXML, undefined);
 135
 136
 137
 138 // 2.0 DOMDocumentFragment transformToFragment(in DOMNode source, in DOMDocument output);
 139 addSectionHeader("DOMDocumentFragment transformToFragment(in DOMNode source, in DOMDocument output)");
 140 // 2.1 fragment with undefined source
 141
 142 processor.reset();
 143 processor.importStylesheet(xsl1);
 144 var ownerDocument = document.implementation.createDocument("", "test", null);
 145 var testname = "fragment with undefined source";
 146 addResultExpectException(testname, function () { return processor.transformToFragment(undefined, ownerDocument); } );
 147
 148 // 2.2 fragment with undefined output document
 149
 150 ownerDocument = document.implementation.createDocument("", "test", null);
 151 newFragment = processor.transformToFragment(xml, undefined);
 152 addResultExpectValueWhenSerialized("fragment with undefined output document", newFragment, undefined);
 153
 154 // 2.3 use non-DOMDocument output parameter
 155
 156 var testname = "use non-DOMDocument output parameter";
 157 addResultExpectException(testname, function () { return processor.transformToFragment(xml, "error"); } );
 158
 159 // 2.4 transform to same fragment twice
 160
 161 ownerDocument = document.implementation.createDocument("", "test", null);
 162 var secondDocument = document.implementation.createDocument("", "test", null);
 163 newFragment = processor.transformToFragment(xml, ownerDocument);
 164 var secondFragment = processor.transformToFragment(xml, secondDocument);
 165 addResultExpectValueWhenSerialized("transform to same fragment twice", secondFragment, serializer.serializeToString(newFragment));
 166
 167
 168 // 2.5 transform to text
 169 // 2.6 fragment using passed parameters
 170 var paramXSL = getXMLDocument("resources/xslt-param.xsl");
 171 var paramXML = getXMLDocument("resources/xslt-param.xml");
 172
 173 var paramProcessor = new XSLTProcessor;
 174 paramProcessor.importStylesheet(paramXSL);
 175 paramProcessor.setParameter(null, "param", "SUCCESS");
 176
 177 var ownerDocument = document.implementation.createDocument("", "test", null);
 178 var fragment = paramProcessor.transformToFragment(paramXML, ownerDocument);
 179 addResultExpectValueWhenSerialized("transformed fragment containing only text", fragment, "SUCCESS");
 180 addResultExpectValue("fragment using passed parameters", fragment.firstChild.nodeValue, "SUCCESS");
 181
 182
 183
 184 // 3.0 DOMDocument transformToDocument(in DOMNode source);
 185 addSectionHeader("DOMDocument transformToDocument(in DOMNode source)");
 186
 187 // 3.1 document from undefined source
 188
 189 processor.reset();
 190 processor.importStylesheet(xsl1);
 191 addResultExpectException("document from undefined source", function () { return processor.transformToDocument(undefined); } );
 192
 193 // 3.2 transform twice
 194
 195 processor.reset();
 196 processor.importStylesheet(xsl1);
 197 var newXML = processor.transformToDocument(xml);
 198 var newerXML = processor.transformToDocument(xml);
 199 addResultExpectValueWhenSerialized("transform twice", newXML, serializer.serializeToString(newerXML));
 200
 201
 202
 203
 204 // 4.0 void setParameter(in DOMString namespaceURI, in DOMString localName, in Value value);
 205 addSectionHeader("void setParameter(in DOMString namespaceURI, in DOMString localName, in Value value)");
 206 processor.reset();
 207
 208 // 4.1 pass setParameter same localname, different namespaces
 209 processor.setParameter("foo", "foo", "Success");
 210 processor.setParameter("bar", "foo", "Failure");
 211 var testname = "pass setParameter same localname, different namespaces";
 212 addResultExpectValue(testname, processor.getParameter("foo", "foo"), "Success");
 213
 214 // 4.2 pass undefined namespace
 215
 216 processor.setParameter(undefined, "foo", "Success");
 217 addResultExpectValue("pass undefined namespace", processor.getParameter(undefined, "foo"), "Success");
 218
 219 // 4.3 pass setParameter an undefined name
 220
 221 var testname = "pass setParameter an undefined name";
 222 addResultExpectException(testname, function () { return processor.setParameter(undefined, undefined , "Success"); } );
 223
 224 // 4.4 pass undefined value
 225
 226 processor.setParameter(undefined, "foo", undefined);
 227 var testname = "pass undefined value";
 228
 229
 230 // 4.5 pass unsupported value to setParameter (object, for instance?)
 231
 232 var testname = "pass unsupported value to setParameter";
 233 addResultExpectException(testname, function () { return processor.setParameter(undefined, "invalid" , new Array()); } );
 234
 235
 236 // 5.0 Value getParameter(in DOMString namespaceURI, in DOMString localName);
 237 addSectionHeader("Value getParameter(in DOMString namespaceURI, in DOMString localName)");
 238
 239 // 5.1 pass undefined name
 240
 241 var testname = "pass getParameter an undefined name";
 242 addResultExpectException(testname, function () { return processor.getParameter(undefined, undefined); } );
 243
 244 // 5.2 pass getParameter a name which has not been set
 245
 246 var testname = "pass getParameter a name which has not been set";
 247 addResultExpectValue(testname, processor.getParameter(undefined, "hasnotbeenset"), undefined);
 248
 249 // 5.3 verify getParameter actually gets (and set sets)
 250 processor.setParameter(null, "test", "testValue");
 251 var testname = "verify getParameter actually gets (and set sets)";
 252 addResultExpectValue(testname, processor.getParameter(null, "test"), "testValue");
 253
 254
 255
 256 // 6.0 void removeParameter(in DOMString namespaceURI, in DOMString localName);
 257 addSectionHeader("void removeParameter(in DOMString namespaceURI, in DOMString localName)");
 258 // 6.1 pass removeParameter same localname, different namespaces
 259
 260 processor.setParameter("foo", "foo", "Success");
 261 processor.setParameter("bar", "foo", "Failure");
 262 var testname = "pass removeParameter same localname, different namespaces";
 263 addResultExpectValue(testname, processor.getParameter("foo", "foo"), "Success");
 264
 265 // 6.2 pass undefined namespace
 266
 267 processor.setParameter(undefined, "test", "testValue");
 268 processor.removeParameter(undefined, "test");
 269 var testname = "verify removeParameter actually removes using undefined namespace";
 270 addResultExpectValue(testname, processor.getParameter(null, "test"), undefined);
 271
 272 // 6.3 pass removeParameter undefined name
 273
 274 processor.setParameter(undefined, "undefined", "Success");
 275 processor.removeParameter(undefined, undefined);
 276 var testname = "pass removeParameter undefined name";
 277 addResultExpectValue(testname, processor.getParameter(undefined, "undefined"), "Success");
 278
 279 // 6.4 pass removeParameter a name which has not been set
 280
 281 processor.removeParameter(undefined, "neverbeensetforremove");
 282 addResultExpectValue("pass removeParameter a name which has not been set", "Success", "Success");
 283
 284 // 6.5 verify removeParameter actually removes
 285 processor.setParameter(null, "test", "testValue");
 286 processor.removeParameter(null, "test");
 287 var testname = "verify removeParameter actually removes";
 288 addResultExpectValue(testname, processor.getParameter(null, "test"), undefined);
 289
 290
 291
 292 // 7.0 void clearParameters();
 293 addSectionHeader("void clearParameters()");
 294
 295 // 7.1 call, verify that parameters have been cleared
 296 processor.setParameter(null, "test", "testValue");
 297 processor.clearParameters();
 298 var testname = "verify that clearParameters does";
 299 addResultExpectValue(testname, processor.getParameter(null, "test"), undefined);
 300
 301
 302 // 8.0 void reset();
 303 addSectionHeader("void reset()");
 304 processor = new XSLTProcessor();
 305 processor.importStylesheet(xsl1);
 306 processor.setParameter(null, "test", "testValue");
 307 processor.reset();
 308
 309 // 8.1 call, verify that parameters are cleared after reset()
 310 var testname = "verify that parameters have been cleared";
 311 addResultExpectValue(testname, processor.getParameter(null, "test"), undefined);
 312
 313 // 8.2 call, verify that stylesheet has been cleared after reset()
 314 var testname = "verify that stylesheet has been cleared";
 315 var resultDocument = processor.transformToDocument(xml);
 316 addResultExpectValueWhenSerialized(testname, resultDocument, undefined);
 317
 318 </script>
 319
 320 </body>
 321 </html>