be63623236ededf6b35a1d7ee5629009ce39b5ec
[WebKit-https.git] / LayoutTests / dom / html / level2 / html / selfhtml.js
1 /*
2 Copyright (c) 2001-2005 World Wide Web Consortium, 
3 (Massachusetts Institute of Technology, European Research Consortium 
4 for Informatics and Mathematics, Keio University). All 
5 Rights Reserved. This work is distributed under the W3C(r) Software License [1] in the 
6 hope that it will be useful, but WITHOUT ANY WARRANTY; without even 
7 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
8
9 [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
10 */
11
12 if (window.layoutTestController)
13     layoutTestController.dumpAsText();
14
15   function assertSize(descr, expected, actual) {
16     var actualSize;
17     assertNotNull(descr, actual);
18     actualSize = actual.length;
19     assertEquals(descr, expected, actualSize);
20   }
21
22   function assertEqualsAutoCase(context, descr, expected, actual) {
23         if (builder.contentType == "text/html") {
24             if(context == "attribute") {
25                 assertEquals(descr, expected.toLowerCase(), actual.toLowerCase());
26             } else {
27                 assertEquals(descr, expected.toUpperCase(), actual);
28             }
29         } else {
30                 assertEquals(descr, expected, actual); 
31         }
32   }
33   
34
35   function assertEqualsCollectionAutoCase(context, descr, expected, actual) {
36     //
37     //  if they aren't the same size, they aren't equal
38     assertEquals(descr, expected.length, actual.length);
39     
40     //
41     //  if there length is the same, then every entry in the expected list
42     //     must appear once and only once in the actual list
43     var expectedLen = expected.length;
44     var expectedValue;
45     var actualLen = actual.length;
46     var i;
47     var j;
48     var matches;
49     for(i = 0; i < expectedLen; i++) {
50         matches = 0;
51         expectedValue = expected[i];
52         for(j = 0; j < actualLen; j++) {
53                 if (builder.contentType == "text/html") {
54                         if (context == "attribute") {
55                                 if (expectedValue.toLowerCase() == actual[j].toLowerCase()) {
56                                         matches++;
57                                 }
58                         } else {
59                                 if (expectedValue.toUpperCase() == actual[j]) {
60                                         matches++;
61                                 }
62                         }
63                 } else {
64                 if(expectedValue == actual[j]) {
65                         matches++;
66                 }
67             }
68         }
69         if(matches == 0) {
70             assert(descr + ": No match found for " + expectedValue,false);
71         }
72         if(matches > 1) {
73             assert(descr + ": Multiple matches found for " + expectedValue, false);
74         }
75     }
76   }
77
78   function assertEqualsCollection(descr, expected, actual) {
79     //
80     //  if they aren't the same size, they aren't equal
81     assertEquals(descr, expected.length, actual.length);
82     //
83     //  if there length is the same, then every entry in the expected list
84     //     must appear once and only once in the actual list
85     var expectedLen = expected.length;
86     var expectedValue;
87     var actualLen = actual.length;
88     var i;
89     var j;
90     var matches;
91     for(i = 0; i < expectedLen; i++) {
92         matches = 0;
93         expectedValue = expected[i];
94         for(j = 0; j < actualLen; j++) {
95             if(expectedValue == actual[j]) {
96                 matches++;
97             }
98         }
99         if(matches == 0) {
100             assert(descr + ": No match found for " + expectedValue,false);
101         }
102         if(matches > 1) {
103             assert(descr + ": Multiple matches found for " + expectedValue, false);
104         }
105     }
106   }
107
108
109   function assertEqualsListAutoCase(context, descr, expected, actual) {
110         var minLength = expected.length;
111         if (actual.length < minLength) {
112             minLength = actual.length;
113         }
114     //
115     for(var i = 0; i < minLength; i++) {
116                 assertEqualsAutoCase(context, descr, expected[i], actual[i]);
117     }
118     //
119     //  if they aren't the same size, they aren't equal
120     assertEquals(descr, expected.length, actual.length);
121   }
122
123
124   function assertEqualsList(descr, expected, actual) {
125         var minLength = expected.length;
126         if (actual.length < minLength) {
127             minLength = actual.length;
128         }
129     //
130     for(var i = 0; i < minLength; i++) {
131         if(expected[i] != actual[i]) {
132                         assertEquals(descr, expected[i], actual[i]);
133         }
134     }
135     //
136     //  if they aren't the same size, they aren't equal
137     assertEquals(descr, expected.length, actual.length);
138   }
139
140   function assertInstanceOf(descr, type, obj) {
141     if(type == "Attr") {
142         assertEquals(descr,2,obj.nodeType);
143         var specd = obj.specified;
144     }
145   }
146
147   function assertSame(descr, expected, actual) {
148     if(expected != actual) {
149         assertEquals(descr, expected.nodeType, actual.nodeType);
150         assertEquals(descr, expected.nodeValue, actual.nodeValue);
151     }
152   }
153
154   function assertURIEquals(assertID, scheme, path, host, file, name, query, fragment, isAbsolute, actual) {
155     //
156     //  URI must be non-null
157     assertNotNull(assertID, actual);
158
159     var uri = actual;
160
161     var lastPound = actual.lastIndexOf("#");
162     var actualFragment = "";
163     if(lastPound != -1) {
164         //
165         //   substring before pound
166         //
167         uri = actual.substring(0,lastPound);
168         actualFragment = actual.substring(lastPound+1);
169     }
170     if(fragment != null) assertEquals(assertID,fragment, actualFragment);
171
172     var lastQuestion = uri.lastIndexOf("?");
173     var actualQuery = "";
174     if(lastQuestion != -1) {
175         //
176         //   substring before pound
177         //
178         uri = actual.substring(0,lastQuestion);
179         actualQuery = actual.substring(lastQuestion+1);
180     }
181     if(query != null) assertEquals(assertID, query, actualQuery);
182
183     var firstColon = uri.indexOf(":");
184     var firstSlash = uri.indexOf("/");
185     var actualPath = uri;
186     var actualScheme = "";
187     if(firstColon != -1 && firstColon < firstSlash) {
188         actualScheme = uri.substring(0,firstColon);
189         actualPath = uri.substring(firstColon + 1);
190     }
191
192     if(scheme != null) {
193         assertEquals(assertID, scheme, actualScheme);
194     }
195
196     if(path != null) {
197         assertEquals(assertID, path, actualPath);
198     }
199
200     if(host != null) {
201         var actualHost = "";
202         if(actualPath.substring(0,2) == "//") {
203             var termSlash = actualPath.substring(2).indexOf("/") + 2;
204             actualHost = actualPath.substring(0,termSlash);
205         }
206         assertEquals(assertID, host, actualHost);
207     }
208
209     if(file != null || name != null) {
210         var actualFile = actualPath;
211         var finalSlash = actualPath.lastIndexOf("/");
212         if(finalSlash != -1) {
213             actualFile = actualPath.substring(finalSlash+1);
214         }
215         if (file != null) {
216             assertEquals(assertID, file, actualFile);
217         }
218         if (name != null) {
219             var actualName = actualFile;
220             var finalDot = actualFile.lastIndexOf(".");
221             if (finalDot != -1) {
222                 actualName = actualName.substring(0, finalDot);
223             }
224             assertEquals(assertID, name, actualName);
225         }
226     }
227
228     if(isAbsolute != null) {
229         assertEquals(assertID, isAbsolute, actualPath.substring(0,1) == "/");
230     }
231   }
232
233
234 // size() used by assertSize element
235 function size(collection)
236 {
237   return collection.length;
238 }
239
240 function same(expected, actual)
241 {
242   return expected === actual;
243 }
244
245 function equalsAutoCase(context, expected, actual) {
246         if (builder.contentType == "text/html") {
247                 if (context == "attribute") {
248                         return expected.toLowerCase() == actual;
249                 }
250                 return expected.toUpperCase() == actual;
251         }
252         return expected == actual;
253 }
254
255 function createTempURI(scheme) {
256    if (scheme == "http") {
257           return "http://localhost:8080/webdav/tmp" + Math.floor(Math.random() * 100000) + ".xml";
258    }
259    return "file:///tmp/domts" + Math.floor(Math.random() * 100000) + ".xml";
260 }
261
262
263
264 function EventMonitor() {
265   this.atEvents = new Array();
266   this.bubbledEvents = new Array();
267   this.capturedEvents = new Array();
268   this.allEvents = new Array();
269 }
270
271 EventMonitor.prototype.handleEvent = function(evt) {
272     switch(evt.eventPhase) {
273        case 1:
274        monitor.capturedEvents[monitor.capturedEvents.length] = evt;
275        break;
276        
277        case 2:
278        monitor.atEvents[monitor.atEvents.length] = evt;
279        break;
280
281        case 3:
282        monitor.bubbledEvents[monitor.bubbledEvents.length] = evt;
283        break;
284     }
285     monitor.allEvents[monitor.allEvents.length] = evt;
286 }
287
288 function DOMErrorImpl(err) {
289   this.severity = err.severity;
290   this.message = err.message;
291   this.type = err.type;
292   this.relatedException = err.relatedException;
293   this.relatedData = err.relatedData;
294   this.location = err.location;
295 }
296
297
298
299 function DOMErrorMonitor() {
300   this.allErrors = new Array();
301 }
302
303 DOMErrorMonitor.prototype.handleError = function(err) {
304     errorMonitor.allErrors[errorMonitor.allErrors.length] = new DOMErrorImpl(err);
305 }
306
307 DOMErrorMonitor.prototype.assertLowerSeverity = function(id, severity) {
308     var i;
309     for (i = 0; i < this.allErrors.length; i++) {
310         if (this.allErrors[i].severity >= severity) {
311            assertEquals(id, severity - 1, this.allErrors[i].severity);
312         }
313     }
314 }
315
316 function UserDataNotification(operation, key, data, src, dst) {
317     this.operation = operation;
318     this.key = key;
319     this.data = data;
320     this.src = src;
321     this.dst = dst;
322 }
323
324 function UserDataMonitor() {
325         this.allNotifications = new Array();
326 }
327
328 UserDataMonitor.prototype.handle = function(operation, key, data, src, dst) {
329     userDataMonitor.allNotifications[userDataMonitor.allNotifications.length] =
330          new UserDataNotification(operation, key, data, src, dst);
331 }
332
333
334
335 function HTMLBuilder() {
336     this.contentType = "text/html";
337     this.supportedContentTypes = [ "text/html" ];
338
339     this.supportsAsyncChange = false;
340     this.async = false;
341     this.fixedAttributeNames = [
342         "validating",  "expandEntityReferences", "coalescing", 
343         "signed", "hasNullString", "ignoringElementContentWhitespace", "namespaceAware", "ignoringComments", "schemaValidating"];
344
345     this.fixedAttributeValues = [false,  true, false, true, true , false, false, false, false ];
346     this.configurableAttributeNames = [ ];
347     this.configurableAttributeValues = [ ];
348     this.initializationError = null;
349     this.initializationFatalError = null;
350     this.skipIncompatibleTests = true;
351     this.documentURLs = new Array();
352     this.documentVarnames = new Array();
353 }
354
355 HTMLBuilder.prototype.hasFeature = function(feature, version) {
356     return document.implementation.hasFeature(feature, version);
357 }
358
359 HTMLBuilder.prototype.getImplementation = function() {
360   return document.implementation;
361 }
362
363 HTMLBuilder.prototype.preload = function(frame, varname, url) {
364   var i;
365   this.documentVarnames[this.documentVarnames.length] = varname;
366   this.documentURLs[this.documentURLs.length] = url;
367   if (this.documentURLs.length > 1) {
368      //
369      //   if all the urls are not the same
370      //
371      for (i = 1; i < this.documentURLs.length; i++) {
372          if (this.documentURLs[i] != this.documentURLs[0]) {
373              throw "Tests with multiple loads of different documents are not currently supported";
374          }
375      }
376   }
377   return 1;
378 }
379
380 HTMLBuilder.prototype.load = function(frame, varname, url) {
381   if (this.documentVarnames[0] == varname) {
382         return document;
383   }
384   return document.cloneNode(true);
385 }
386
387 HTMLBuilder.prototype.getImplementationAttribute = function(attr) {
388     for (var i = 0; i < this.fixedAttributeNames.length; i++) {
389         if (this.fixedAttributeNames[i] == attr) {
390             return this.fixedAttributeValues[i];
391         }
392     }
393     throw "Unrecognized implementation attribute: " + attr;
394 }
395
396
397 HTMLBuilder.prototype.setImplementationAttribute = function(attribute, value) {
398     var supported = this.getImplementationAttribute(attribute);
399     if (supported != value) {
400         this.initializationError = "HTML loader does not support " + attribute + "=" + value;
401     }
402 }
403
404 HTMLBuilder.prototype.canSetImplementationAttribute = function(attribute, value) {
405     var supported = this.getImplementationAttribute(attribute);
406     return (supported == value);
407 }
408
409
410
411
412 function createConfiguredBuilder() {
413     return new HTMLBuilder();
414 }
415
416 function catchInitializationError(buildr, ex) {
417    buildr.initializationError = ex;
418    buildr.initializationFatalError = ex;
419 }
420
421 function toLowerArray(src) {
422    var newArray = new Array();
423    var i;
424    for (i = 0; i < src.length; i++) {
425       newArray[i] = src[i].toLowerCase();
426    }
427    return newArray;
428 }
429
430
431 function checkFeature(feature, version)
432 {
433   if (!builder.hasFeature(feature, version))
434   {
435     //
436     //   don't throw exception so that users can select to ignore the precondition
437     //
438     builder.initializationError = "builder does not support feature " + feature + " version " + version;
439   }
440 }
441
442 function setResult(resultType, message) {
443    var testName = getTargetURI();
444    document.open();
445    document.writeln("<html><head>");
446    document.writeln("<meta HTTP-EQUIV='Content-Type' CONTENT='text/html; CHARSET=utf-8'>");    
447    document.write("<title>");
448    document.write(testName + ":" + resultType);
449    document.write("</title></head><body><table width='100%' border='1' style='color:");
450    if (resultType == null) {
451       document.writeln("green'><tr><td>Test:</td><td>" + testName + "</td></tr><tr><td>Status:</td><td>Success</td></tr>");
452    } else {
453       if (resultType == "skip") {
454         document.writeln("blue'><tr><td>Test:</td><td>" + testName + "</td></tr><tr><td>Status:</td><td>Skipped</td></tr>");
455       } else {
456         document.writeln("red'><tr><td>Test:</td><td>" + testName + "</td><td></tr><tr><td>Status:</td><td>" + resultType + "</td></tr>");
457       }
458    }
459    if (message != null) {
460                 document.writeln("<tr><td>Detail:</td><td>" + message + "</td></tr>");
461    }
462    document.write("</table></body></html>");
463    document.close();
464    if (parent != window) {
465        parent.setResult(testName, resultType, message);
466    }
467 }
468
469 function checkInitialization(buildr, testname) {
470    return buildr.initializationError;
471 }
472
473 function preload(docRef, varname, href) {
474    return builder.preload(docRef, varname, href);
475 }
476
477
478 function load(docRef, varname, href) {
479    return builder.load(docRef, varname, href);
480 }
481
482
483 function getImplementationAttribute(attr) {
484     return builder.getImplementationAttribute(attr);
485 }
486
487
488 function setImplementationAttribute(attribute, value) {
489     builder.setImplementationAttribute(attribute, value);
490 }
491
492 function createXPathEvaluator(doc) {
493     try {
494         return doc.getFeature("XPath", null);
495     }
496     catch(ex) {
497     }
498     return doc;
499 }
500
501
502 function getImplementation() {
503     return builder.getImplementation();
504 }
505
506 function assertEquals(id, expected, actual) {
507    var myActual;
508    if (expected != actual) {
509        myActual = actual;
510        if (actual == null) {
511           myActual = "null";
512        }
513        throw "failure:" + id + ": assertEquals failed, actual " + myActual + ", expected " + expected + "."; 
514    }
515 }
516
517 function assertNull(id, actual) {
518    if (actual != null) {
519        throw "failure:" + id + ": assertNull failed, actual " + actual;
520    }
521 }
522
523
524 function assertTrue(id, actual) {
525    if (!actual) {
526        throw "failure:" + id + ": assertTrue failed";
527    }
528 }
529
530
531 function assertFalse(id, actual) {
532    if (actual) {
533        throw "failure:" + id +  ": assertTrue failed";
534    }
535 }
536
537 function assertNotNull(id, actual) {
538    if (actual == null) {
539        throw "failure:" + id + ": assertNotNull failed";
540    }
541 }
542
543 function fail(id) {
544     throw "failure:" + id +  ": fail";
545 }
546
547
548
549 function getSuffix(contentType) {
550     switch(contentType) {
551         case "text/xml":
552         return ".xml";
553
554         case "application/xhtml+xml":
555         return ".xhtml";
556
557         case "image/svg+xml":
558         return ".svg";
559
560         case "text/mathml":
561         return ".mml";
562     }
563     return ".html";
564 }
565
566
567 function getResourceURI(name, scheme, contentType) {
568     var base = document.documentURI;
569     if (base == null) {
570        base = "";
571     } else {
572            base = base.substring(0, base.lastIndexOf('/') + 1) + "files/";
573     }
574     return base + name + getSuffix(contentType);
575 }
576
577
578
579 function startTest() {
580         //
581         //   invoke test setup
582         //
583         setUpPage();
584
585         try {
586             runTest();
587             if (builder.initializationError == null) {
588                setResult(null, null);
589             } else {
590                setResult("skip", builder.initializationError);
591             }
592         } catch(ex) {
593             if (typeof(ex.substring) != 'undefined' && ex.substring(0, 8) == "failure:") {
594             setResult("failure", ex.substring(8));
595         } else {
596             setResult("error", ex);
597         }
598     }
599 }