Remove tabs and trailing whitspace in LayoutTests/dom/.../*.js

LayoutTests/dom/xhtml/level2/events/selfxhtml.js

 /*
-Copyright (c) 2001-2005 World Wide Web Consortium, 
-(Massachusetts Institute of Technology, European Research Consortium 
-for Informatics and Mathematics, Keio University). All 
-Rights Reserved. This work is distributed under the W3C(r) Software License [1] in the 
-hope that it will be useful, but WITHOUT ANY WARRANTY; without even 
-the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
+Copyright (c) 2001-2005 World Wide Web Consortium,
+(Massachusetts Institute of Technology, European Research Consortium
+for Informatics and Mathematics, Keio University). All
+Rights Reserved. This work is distributed under the W3C(r) Software License [1] in the
+hope that it will be useful, but WITHOUT ANY WARRANTY; without even
+the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
 [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
 */
 
   function assertSize(descr, expected, actual) {
     var actualSize;
     assertNotNull(descr, actual);
     actualSize = actual.length;
     assertEquals(descr, expected, actualSize);
   }
 
   function assertEqualsAutoCase(context, descr, expected, actual) {
-        if (builder.contentType == "text/html") {
-            if(context == "attribute") {
-                assertEquals(descr, expected.toLowerCase(), actual.toLowerCase());
-            } else {
-                assertEquals(descr, expected.toUpperCase(), actual);
-            }
-        } else {
-                assertEquals(descr, expected, actual); 
-        }
+      if (builder.contentType == "text/html") {
+          if(context == "attribute") {
+              assertEquals(descr, expected.toLowerCase(), actual.toLowerCase());
+          } else {
+              assertEquals(descr, expected.toUpperCase(), actual);
+          }
+      } else {
+          assertEquals(descr, expected, actual);
+      }
   }
-  
 
   function assertEqualsCollectionAutoCase(context, descr, expected, actual) {
     //
     //  if they aren't the same size, they aren't equal
     assertEquals(descr, expected.length, actual.length);
-    
+
     //
     //  if there length is the same, then every entry in the expected list
     //     must appear once and only once in the actual list
     var expectedLen = expected.length;
     var expectedValue;
     var actualLen = actual.length;
     var i;
     var j;
     var matches;
     for(i = 0; i < expectedLen; i++) {
         matches = 0;
         expectedValue = expected[i];
         for(j = 0; j < actualLen; j++) {
-                if (builder.contentType == "text/html") {
-                        if (context == "attribute") {
-                                if (expectedValue.toLowerCase() == actual[j].toLowerCase()) {
-                                        matches++;
-                                }
-                        } else {
-                                if (expectedValue.toUpperCase() == actual[j]) {
-                                        matches++;
-                                }
-                        }
-                } else {
-                if(expectedValue == actual[j]) {
-                        matches++;
+            if (builder.contentType == "text/html") {
+                if (context == "attribute") {
+                    if (expectedValue.toLowerCase() == actual[j].toLowerCase()) {
+                        matches++;
+                    }
+                } else {
+                    if (expectedValue.toUpperCase() == actual[j]) {
+                        matches++;
+                    }
+                }
+            } else {
+                if(expectedValue == actual[j]) {
+                    matches++;
                 }
             }
         }
         if(matches == 0) {
             assert(descr + ": No match found for " + expectedValue,false);
         }
         if(matches > 1) {
             assert(descr + ": Multiple matches found for " + expectedValue, false);
         }
     }
@@ skipping 22 matching lines @@
         }
         if(matches == 0) {
             assert(descr + ": No match found for " + expectedValue,false);
         }
         if(matches > 1) {
             assert(descr + ": Multiple matches found for " + expectedValue, false);
         }
     }
   }
 
-
   function assertEqualsListAutoCase(context, descr, expected, actual) {
-        var minLength = expected.length;
-        if (actual.length < minLength) {
-            minLength = actual.length;
-        }
+    var minLength = expected.length;
+    if (actual.length < minLength) {
+        minLength = actual.length;
+    }
     //
     for(var i = 0; i < minLength; i++) {
-                assertEqualsAutoCase(context, descr, expected[i], actual[i]);
+        assertEqualsAutoCase(context, descr, expected[i], actual[i]);
     }
     //
     //  if they aren't the same size, they aren't equal
     assertEquals(descr, expected.length, actual.length);
   }
 
-
   function assertEqualsList(descr, expected, actual) {
-        var minLength = expected.length;
-        if (actual.length < minLength) {
-            minLength = actual.length;
-        }
+    var minLength = expected.length;
+    if (actual.length < minLength) {
+        minLength = actual.length;
+    }
     //
     for(var i = 0; i < minLength; i++) {
         if(expected[i] != actual[i]) {
-                        assertEquals(descr, expected[i], actual[i]);
+            assertEquals(descr, expected[i], actual[i]);
         }
     }
     //
     //  if they aren't the same size, they aren't equal
     assertEquals(descr, expected.length, actual.length);
   }
 
   function assertInstanceOf(descr, type, obj) {
     if(type == "Attr") {
         assertEquals(descr,2,obj.nodeType);
@@ skipping 80 matching lines @@
             }
             assertEquals(assertID, name, actualName);
         }
     }
 
     if(isAbsolute != null) {
         assertEquals(assertID, isAbsolute, actualPath.substring(0,1) == "/");
     }
   }
 
-
 // size() used by assertSize element
 function size(collection)
 {
   return collection.length;
 }
 
 function same(expected, actual)
 {
   return expected === actual;
 }
 
 function equalsAutoCase(context, expected, actual) {
-        if (builder.contentType == "text/html") {
-                if (context == "attribute") {
-                        return expected.toLowerCase() == actual;
-                }
-                return expected.toUpperCase() == actual;
-        }
-        return expected == actual;
+    if (builder.contentType == "text/html") {
+        if (context == "attribute") {
+            return expected.toLowerCase() == actual;
+        }
+        return expected.toUpperCase() == actual;
+    }
+    return expected == actual;
 }
 
 function toLowerArray(src) {
    var newArray = new Array();
    var i;
    for (i = 0; i < src.length; i++) {
       newArray[i] = src[i].toLowerCase();
    }
    return newArray;
 }
 
 function createTempURI(scheme) {
    if (scheme == "http") {
-          return "http://localhost:8080/webdav/tmp" + Math.floor(Math.random() * 100000) + ".xml";
+         return "http://localhost:8080/webdav/tmp" + Math.floor(Math.random() * 100000) + ".xml";
    }
    return "file:///tmp/domts" + Math.floor(Math.random() * 100000) + ".xml";
 }
 
-
-
 function EventMonitor() {
   this.atEvents = new Array();
   this.bubbledEvents = new Array();
   this.capturedEvents = new Array();
   this.allEvents = new Array();
 }
 
 EventMonitor.prototype.handleEvent = function(evt) {
     switch(evt.eventPhase) {
        case 1:
        monitor.capturedEvents[monitor.capturedEvents.length] = evt;
        break;
-       
+
        case 2:
        monitor.atEvents[monitor.atEvents.length] = evt;
        break;
 
        case 3:
        monitor.bubbledEvents[monitor.bubbledEvents.length] = evt;
        break;
     }
     monitor.allEvents[monitor.allEvents.length] = evt;
 }
 
 function DOMErrorImpl(err) {
   this.severity = err.severity;
   this.message = err.message;
   this.type = err.type;
   this.relatedException = err.relatedException;
   this.relatedData = err.relatedData;
   this.location = err.location;
 }
 
-
-
 function DOMErrorMonitor() {
   this.allErrors = new Array();
 }
 
 DOMErrorMonitor.prototype.handleError = function(err) {
     errorMonitor.allErrors[errorMonitor.allErrors.length] = new DOMErrorImpl(err);
 }
 
 DOMErrorMonitor.prototype.assertLowerSeverity = function(id, severity) {
     var i;
     for (i = 0; i < this.allErrors.length; i++) {
         if (this.allErrors[i].severity >= severity) {
            assertEquals(id, severity - 1, this.allErrors[i].severity);
         }
     }
 }
 
 function UserDataNotification(operation, key, data, src, dst) {
     this.operation = operation;
     this.key = key;
     this.data = data;
     this.src = src;
     this.dst = dst;
 }
 
 function UserDataMonitor() {
-        this.allNotifications = new Array();
+    this.allNotifications = new Array();
 }
 
 UserDataMonitor.prototype.handle = function(operation, key, data, src, dst) {
     userDataMonitor.allNotifications[userDataMonitor.allNotifications.length] =
          new UserDataNotification(operation, key, data, src, dst);
 }
 
-
-
 function HTMLBuilder() {
     this.contentType = "application/xhtml+xml";
     this.supportedContentTypes = [ "application/xhtml+xml" ];
 
     this.supportsAsyncChange = false;
     this.async = false;
     this.fixedAttributeNames = [
-        "validating",  "expandEntityReferences", "coalescing", 
+        "validating",  "expandEntityReferences", "coalescing",
         "signed", "hasNullString", "ignoringElementContentWhitespace", "namespaceAware", "ignoringComments", "schemaValidating"];
 
     this.fixedAttributeValues = [false,  true, false, true, true , false, true, false, false ];
     this.configurableAttributeNames = [ ];
     this.configurableAttributeValues = [ ];
     this.initializationError = null;
     this.initializationFatalError = null;
     this.skipIncompatibleTests = true;
     this.documentURLs = new Array();
     this.documentVarnames = new Array();
@@ skipping 38 matching lines @@
       }
       var srcChild = srcNode.firstChild;
       while(srcChild != null) {
          var cloneChild = this.cloneNode(srcChild, doc);
          if (cloneChild != null) {
              clone.appendChild(cloneChild);
          }
          srcChild = srcChild.nextSibling;
       }
       break;
-      
+
       case 3:
       clone = doc.createTextNode(srcNode.nodeValue);
       break;
-      
+
       case 4:
       clone = doc.createCDATASection(srcNode.nodeValue);
       break;
-      
+
       case 5:
       clone = doc.createEntityReference(srcNode.nodeName);
       break;
-                  
+
       case 7:
       clone = doc.createProcessingInstruction(srcNode.target, srcNode.data);
       break;
-      
+
       case 8:
       clone = doc.createComment(srcNode.nodeValue);
       break;
    }
    return clone;
-      
+
 }
 
-
 HTMLBuilder.prototype.load = function(frame, varname, url) {
   if (this.documentVarnames[0] == varname) {
-        return document;
+      return document;
   }
   //
   //
   //  not a perfect way to do this
   //    Document.cloneNode is implementation dependent but exists in L1
   //       and implemented in IE.  The alternative brute force copy
   //       only works in L2 or higher implementations and can't copy
   //       entity and notation definitions, etc.
   var clone = null;
   try {
       clone = document.cloneNode(true);
   } catch(ex) {
   }
   if (clone == null) {
       clone = document.implementation.createDocument(
           document.documentElement.namespaceURI,
           document.documentElement.nodeName,
           null);
       //
       //   Work-around since
-      //   Safari does not create document element 
-      //      create document.      
+      //   Safari does not create document element
+      //      create document.
       if (clone.documentElement == null) {
            clone.appendChild(clone.createElementNS(
-              document.documentElement.namespaceURI, 
+              document.documentElement.namespaceURI,
               document.documentElement.nodeName));
       }
       var attrs = document.documentElement.attributes;
       for(var i = 0; i < attrs.length; i++) {
           var srcAttr = attrs.item(i);
           clone.documentElement.setAttributeNS(
              srcAttr.namespaceURI, srcAttr.nodeName, srcAttr.nodeValue);
       }
 
       var srcNode = document.firstChild;
       while(srcNode != null && srcNode.nodeType != 1) {
           if (srcNode.nodeType != 10) {
-                 var cloneNode = this.cloneNode(srcNode, clone);
+               var cloneNode = this.cloneNode(srcNode, clone);
              clone.insertBefore(cloneNode, clone.documentElement);
            }
-           srcNode = srcNode.nextSibling; 
+           srcNode = srcNode.nextSibling;
       }
       srcNode = document.documentElement.nextSibling;
       while(srcNode != null) {
           var cloneNode = this.cloneNode(srcNode, clone);
           clone.appendChild(cloneNode);
           srcNode = srcNode.nextSibling;
       }
       srcNode = document.documentElement.firstChild;
       while(srcNode != null) {
           var cloneNode = this.cloneNode(srcNode, clone);
           if (cloneNode != null) {
              clone.documentElement.appendChild(cloneNode);
           }
           srcNode = srcNode.nextSibling;
       }
   }
   return clone;
 }
 
 HTMLBuilder.prototype.getImplementationAttribute = function(attr) {
     for (var i = 0; i < this.fixedAttributeNames.length; i++) {
         if (this.fixedAttributeNames[i] == attr) {
             return this.fixedAttributeValues[i];
         }
     }
     throw "Unrecognized implementation attribute: " + attr;
 }
 
-
 HTMLBuilder.prototype.setImplementationAttribute = function(attribute, value) {
     var supported = this.getImplementationAttribute(attribute);
     if (supported != value) {
         this.initializationError = "HTML loader does not support " + attribute + "=" + value;
     }
 }
 
 HTMLBuilder.prototype.canSetImplementationAttribute = function(attribute, value) {
     var supported = this.getImplementationAttribute(attribute);
     return (supported == value);
 }
 
-
-
-
 function createConfiguredBuilder() {
     return new HTMLBuilder();
 }
 
 function catchInitializationError(buildr, ex) {
    buildr.initializationError = ex;
    buildr.initializationFatalError = ex;
 }
 
-
 function checkFeature(feature, version)
 {
   if (!builder.hasFeature(feature, version))
   {
     //
     //   don't throw exception so that users can select to ignore the precondition
     //
     builder.initializationError = "builder does not support feature " + feature + " version " + version;
   }
 }
 
 function setResult(resultType, message) {
    var testName = getTargetURI();
    document.title = testName + ":" + resultType;
-   var xhtmlNS = "http://www.w3.org/1999/xhtml"; 
+   var xhtmlNS = "http://www.w3.org/1999/xhtml";
    var newBody = document.createElementNS(xhtmlNS, "body");
    var newTable = document.createElementNS(xhtmlNS, "table");
    newTable.width = "100%";
    newTable.border = "1";
    newBody.appendChild(newTable);
    var testRow = newTable.insertRow(-1);
    var testDiv1 = testRow.insertCell(-1);
    testDiv1.appendChild(document.createTextNode("Test"));
    var testDiv2 = testRow.insertCell(-1);
    testDiv2.appendChild(document.createTextNode(testName));
    var statusRow = newTable.insertRow(-1);
    var statusDiv1 = statusRow.insertCell(-1);
    statusDiv1.appendChild(document.createTextNode("Status"));
    var statusDiv2 = statusRow.insertCell(-1);
    var style = "color:green";
    if (resultType == null) {
-                statusDiv2.appendChild(document.createTextNode("Success"));
+           statusDiv2.appendChild(document.createTextNode("Success"));
    } else {
-                statusDiv2.appendChild(document.createTextNode(resultType));
-                if (resultType == "skip") {
-                    style = "color:blue";
-                } else {
-                    style = "color:red";
-                }
+           statusDiv2.appendChild(document.createTextNode(resultType));
+           if (resultType == "skip") {
+               style = "color:blue";
+           } else {
+               style = "color:red";
+           }
    }
    newTable.setAttributeNS(null, "style", style);
    if (message != null) {
       var messageRow = newTable.insertRow(-1);
-          var messageDiv1 = messageRow.insertCell(-1);
+         var messageDiv1 = messageRow.insertCell(-1);
       messageDiv1.appendChild(document.createTextNode("Message"));
       var messageDiv2 = messageRow.insertCell(-1);
       messageDiv2.appendChild(document.createTextNode(message));
    }
    var oldBody = document.getElementsByTagName("body")[0];
    oldBody.parentNode.replaceChild(newBody, oldBody);
    if (parent != window && typeof(parent.setResult) != 'undefined') {
        parent.setResult(testName, resultType, message);
    }
 }
 
 function checkInitialization(buildr, testname) {
    return buildr.initializationError;
 }
 
 function preload(docRef, varname, href) {
    return builder.preload(docRef, varname, href);
 }
 
-
 function load(docRef, varname, href) {
    return builder.load(docRef, varname, href);
 }
 
-
 function getImplementationAttribute(attr) {
     return builder.getImplementationAttribute(attr);
 }
 
-
 function setImplementationAttribute(attribute, value) {
     builder.setImplementationAttribute(attribute, value);
 }
 
 function createXPathEvaluator(doc) {
     try {
         return doc.getFeature("XPath", null);
     }
     catch(ex) {
     }
     return doc;
 }
 
-
 function getImplementation() {
     return builder.getImplementation();
 }
 
 function assertEquals(id, expected, actual) {
    var myActual;
    if (expected != actual) {
        myActual = actual;
        if (actual == null) {
           myActual = "null";
        }
-       throw "failure:" + id + ": assertEquals failed, actual " + myActual + ", expected " + expected + "."; 
+       throw "failure:" + id + ": assertEquals failed, actual " + myActual + ", expected " + expected + ".";
    }
 }
 
 function assertNull(id, actual) {
    if (actual != null) {
        throw "failure:" + id + ": assertNull failed, actual " + actual;
    }
 }
 
-
 function assertTrue(id, actual) {
    if (!actual) {
        throw "failure:" + id + ": assertTrue failed";
    }
 }
 
-
 function assertFalse(id, actual) {
    if (actual) {
        throw "failure:" + id +  ": assertTrue failed";
    }
 }
 
 function assertNotNull(id, actual) {
    if (actual == null) {
        throw "failure:" + id + ": assertNotNull failed";
    }
 }
 
 function fail(id) {
     throw "failure:" + id +  ": fail";
 }
 
-
-
 function getSuffix(contentType) {
     switch(contentType) {
         case "text/html":
         return ".html";
 
         case "text/xml":
         return ".xml";
 
         case "image/svg+xml":
         return ".svg";
 
         case "text/mathml":
         return ".mml";
     }
     return ".xhtml";
 }
 
-
 function getResourceURI(name, scheme, contentType) {
     var base = document.documentURI;
     if (base == null) {
        base = "";
     } else {
-           base = base.substring(0, base.lastIndexOf('/') + 1) + "files/";
+       base = base.substring(0, base.lastIndexOf('/') + 1) + "files/";
     }
     return base + name + getSuffix(contentType);
 }
 
-
-
 function startTest() {
 
 //
 //  WebKit modification: 18-August-2005
 //
 //  Inform the test controller that this test has a text-format result and so should
 //  be dumped as text, and also that the dump should not occur automatically.
 //
 if (window.testRunner) {
     testRunner.dumpAsText();
     testRunner.waitUntilDone();
 }
 //
 //  End WebKit modification
 //
 
-        //
-        //   invoke test setup
-        //
-        setUpPage();
-        try {
-            runTest();
-            if (builder.initializationError == null) {
-               setResult(null, null);
-            } else {
-               setResult("skip", builder.initializationError);
-            }
-        } catch(ex) {
-            if (typeof(ex.substring) != 'undefined' && ex.substring(0, 8) == "failure:") {
+    //
+    //   invoke test setup
+    //
+    setUpPage();
+    try {
+        runTest();
+        if (builder.initializationError == null) {
+           setResult(null, null);
+        } else {
+           setResult("skip", builder.initializationError);
+        }
+    } catch(ex) {
+        if (typeof(ex.substring) != 'undefined' && ex.substring(0, 8) == "failure:") {
             setResult("failure", ex.substring(8));
         } else {
             setResult("error", ex);
         }
     }
 
 //
 //  WebKit modification: 18-August-2005
 //
 //  Inform the test controller that this test is complete, so it's time to dump.
 //
     if (window.testRunner) {
         testRunner.notifyDone();
     }
 //
 //  End WebKit modification
-//      
+//
 
 }