e07e5207073e1009c760e7e82328feed1f7ea3ac
[WebKit-https.git] / LayoutTests / dom / html / level2 / events / selfhtml.js
1 /*
2 Copyright (c) 2001-2004 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 getSuffix(contentType) {
246         return ".html";
247 }
248
249 function equalsAutoCase(context, expected, actual) {
250         if (builder.contentType == "text/html") {
251                 if (context == "attribute") {
252                         return expected.toLowerCase() == actual;
253                 }
254                 return expected.toUpperCase() == actual;
255         }
256         return expected == actual;
257 }
258
259 function createTempURI(scheme) {
260    if (scheme == "http") {
261           return "http://localhost:8080/webdav/tmp" + Math.floor(Math.random() * 100000) + ".xml";
262    }
263    return "file:///tmp/domts" + Math.floor(Math.random() * 100000) + ".xml";
264 }
265
266
267
268 function EventMonitor() {
269   this.atEvents = new Array();
270   this.bubbledEvents = new Array();
271   this.capturedEvents = new Array();
272   this.allEvents = new Array();
273 }
274
275 EventMonitor.prototype.handleEvent = function(evt) {
276     switch(evt.eventPhase) {
277        case 1:
278        monitor.capturedEvents[monitor.capturedEvents.length] = evt;
279        break;
280        
281        case 2:
282        monitor.atEvents[monitor.atEvents.length] = evt;
283        break;
284
285        case 3:
286        monitor.bubbledEvents[monitor.bubbledEvents.length] = evt;
287        break;
288     }
289     monitor.allEvents[monitor.allEvents.length] = evt;
290 }
291
292 function DOMErrorImpl(err) {
293   this.severity = err.severity;
294   this.message = err.message;
295   this.type = err.type;
296   this.relatedException = err.relatedException;
297   this.relatedData = err.relatedData;
298   this.location = err.location;
299 }
300
301
302
303 function DOMErrorMonitor() {
304   this.allErrors = new Array();
305 }
306
307 DOMErrorMonitor.prototype.handleError = function(err) {
308     errorMonitor.allErrors[errorMonitor.allErrors.length] = new DOMErrorImpl(err);
309 }
310
311 DOMErrorMonitor.prototype.assertLowerSeverity = function(id, severity) {
312     var i;
313     for (i = 0; i < this.allErrors.length; i++) {
314         if (this.allErrors[i].severity >= severity) {
315            assertEquals(id, severity - 1, this.allErrors[i].severity);
316         }
317     }
318 }
319
320 function UserDataNotification(operation, key, data, src, dst) {
321     this.operation = operation;
322     this.key = key;
323     this.data = data;
324     this.src = src;
325     this.dst = dst;
326 }
327
328 function UserDataMonitor() {
329         this.allNotifications = new Array();
330 }
331
332 UserDataMonitor.prototype.handle = function(operation, key, data, src, dst) {
333     userDataMonitor.allNotifications[userDataMonitor.allNotifications.length] =
334          new UserDataNotification(operation, key, data, src, dst);
335 }
336
337
338
339 function HTMLBuilder() {
340     this.contentType = "text/html";
341     this.supportedContentTypes = [ "text/html" ];
342
343     this.supportsAsyncChange = false;
344     this.async = false;
345     this.fixedAttributeNames = [
346         "validating",  "expandEntityReferences", "coalescing", 
347         "signed", "hasNullString", "ignoringElementContentWhitespace", "namespaceAware", "ignoringComments", "schemaValidating"];
348
349     this.fixedAttributeValues = [false,  true, false, true, true , false, false, false, false ];
350     this.configurableAttributeNames = [ ];
351     this.configurableAttributeValues = [ ];
352     this.initializationError = null;
353     this.initializationFatalError = null;
354     this.skipIncompatibleTests = true;
355     this.documentURLs = new Array();
356     this.documentVarnames = new Array();
357 }
358
359 HTMLBuilder.prototype.hasFeature = function(feature, version) {
360     return document.implementation.hasFeature(feature, version);
361 }
362
363 HTMLBuilder.prototype.getImplementation = function() {
364   return document.implementation;
365 }
366
367 HTMLBuilder.prototype.preload = function(frame, varname, url) {
368   var i;
369   this.documentVarnames[this.documentVarnames.length] = varname;
370   this.documentURLs[this.documentURLs.length] = url;
371   if (this.documentURLs.length > 1) {
372      //
373      //   if all the urls are not the same
374      //
375      for (i = 1; i < this.documentURLs.length; i++) {
376          if (this.documentURLs[i] != this.documentURLs[0]) {
377              throw "Tests with multiple loads of different documents are not currently supported";
378          }
379      }
380   }
381   return 1;
382 }
383
384 HTMLBuilder.prototype.load = function(frame, varname, url) {
385   if (this.documentVarnames[0] == varname) {
386         return document;
387   }
388   return document.cloneNode(true);
389 }
390
391 HTMLBuilder.prototype.getImplementationAttribute = function(attr) {
392     for (var i = 0; i < this.fixedAttributeNames.length; i++) {
393         if (this.fixedAttributeNames[i] == attr) {
394             return this.fixedAttributeValues[i];
395         }
396     }
397     throw "Unrecognized implementation attribute: " + attr;
398 }
399
400
401 HTMLBuilder.prototype.setImplementationAttribute = function(attribute, value) {
402     var supported = this.getImplementationAttribute(attribute);
403     if (supported != value) {
404         this.initializationError = "HTML loader does not support " + attribute + "=" + value;
405     }
406 }
407
408 HTMLBuilder.prototype.canSetImplementationAttribute = function(attribute, value) {
409     var supported = this.getImplementationAttribute(attribute);
410     return (supported == value);
411 }
412
413
414
415
416 function createConfiguredBuilder() {
417     return new HTMLBuilder();
418 }
419
420 function catchInitializationError(buildr, ex) {
421    buildr.initializationError = ex;
422    buildr.initializationFatalError = ex;
423 }
424
425 function toLowerArray(src) {
426    var newArray = new Array();
427    var i;
428    for (i = 0; i < src.length; i++) {
429       newArray[i] = src[i].toLowerCase();
430    }
431    return newArray;
432 }
433
434
435 function checkFeature(feature, version)
436 {
437   if (!builder.hasFeature(feature, version))
438   {
439     //
440     //   don't throw exception so that users can select to ignore the precondition
441     //
442     builder.initializationError = "builder does not support feature " + feature + " version " + version;
443   }
444 }
445
446 function setResult(resultType, message) {
447    var testName = getTargetURI();
448    document.open();
449    document.writeln("<html><head>");
450    document.writeln("<meta HTTP-EQUIV='Content-Type' CONTENT='text/html; CHARSET=utf-8'>");    
451    document.write("<title>");
452    document.write(testName + ":" + resultType);
453    document.write("</title></head><body><table width='100%' border='1' style='color:");
454    if (resultType == null) {
455       document.writeln("green'><tr><td>Test:</td><td>" + testName + "</td></tr><tr><td>Status:</td><td>Success</td></tr>");
456    } else {
457       if (resultType == "skip") {
458         document.writeln("blue'><tr><td>Test:</td><td>" + testName + "</td></tr><tr><td>Status:</td><td>Skipped</td></tr>");
459       } else {
460         document.writeln("red'><tr><td>Test:</td><td>" + testName + "</td><td></tr><tr><td>Status:</td><td>" + resultType + "</td></tr>");
461       }
462    }
463    if (message != null) {
464                 document.writeln("<tr><td>Detail:</td><td>" + message + "</td></tr>");
465    }
466    document.write("</table></body></html>");
467    document.close();
468    if (parent != window) {
469        parent.setResult(testName, resultType, message);
470    }
471 }
472
473 function checkInitialization(buildr, testname) {
474    return buildr.initializationError;
475 }
476
477 function preload(docRef, varname, href) {
478    return builder.preload(docRef, varname, href);
479 }
480
481
482 function load(docRef, varname, href) {
483    return builder.load(docRef, varname, href);
484 }
485
486
487 function getImplementationAttribute(attr) {
488     return builder.getImplementationAttribute(attr);
489 }
490
491
492 function setImplementationAttribute(attribute, value) {
493     builder.setImplementationAttribute(attribute, value);
494 }
495
496 function createXPathEvaluator(doc) {
497     try {
498         return doc.getFeature("XPath", null);
499     }
500     catch(ex) {
501     }
502     return doc;
503 }
504
505
506 function getImplementation() {
507     return builder.getImplementation();
508 }
509
510 function assertEquals(id, expected, actual) {
511    var myActual;
512    if (expected != actual) {
513        myActual = actual;
514        if (actual == null) {
515           myActual = "null";
516        }
517        throw "failure:" + id + ": assertEquals failed, actual " + myActual + ", expected " + expected + "."; 
518    }
519 }
520
521 function assertNull(id, actual) {
522    if (actual != null) {
523        throw "failure:" + id + ": assertNull failed, actual " + actual;
524    }
525 }
526
527
528 function assertTrue(id, actual) {
529    if (!actual) {
530        throw "failure:" + id + ": assertTrue failed";
531    }
532 }
533
534
535 function assertFalse(id, actual) {
536    if (actual) {
537        throw "failure:" + id +  ": assertTrue failed";
538    }
539 }
540
541 function assertNotNull(id, actual) {
542    if (actual == null) {
543        throw "failure:" + id + ": assertNotNull failed";
544    }
545 }
546
547 function fail(id) {
548     throw "failure:" + id +  ": fail";
549 }
550
551
552 function startTest() {
553         //
554         //   invoke test setup
555         //
556         setUpPage();
557
558         try {
559             runTest();
560             if (builder.initializationError == null) {
561                setResult(null, null);
562             } else {
563                setResult("skip", builder.initializationError);
564             }
565         } catch(ex) {
566             if (typeof(ex.substring) != 'undefined' && ex.substring(0, 8) == "failure:") {
567             setResult("failure", ex.substring(8));
568         } else {
569             setResult("error", ex);
570         }
571     }
572 }