Import wpt@306326cfe973b6c7019c50879ad03b02825c7539

third_party/WebKit/LayoutTests/imported/wpt/html/dom/original-harness.js

 var ReflectionHarness = {};
 
 // @private
 ReflectionHarness.passed = document.getElementById("passed");
 ReflectionHarness.failed = document.getElementById("failed");
 
 /**
- * Should we report a failure for unexpected exceptions, or just rethrow them?
- * The original test framework reports an exception, but testharness.js doesn't
- * want that.
- *
- * @public
+ * In conformance testing mode, all tests will be run.  Otherwise, we'll skip
+ * tests for attributes that have an entirely incorrect type.
  */
-ReflectionHarness.catchUnexpectedExceptions = true;
+ReflectionHarness.conformanceTesting = false;
 
 /**
  * Returns a string representing val.  Basically just adds quotes for strings,
  * and passes through other recognized types literally.
  *
  * @public
  */
 ReflectionHarness.stringRep = function(val) {
   if (val === null) {
     // typeof is object, so the switch isn't useful
@@ skipping 54 matching lines @@
   }
 }
 
 /**
  * An object representing info about the current test, used for printing out
  * nice messages and so forth.
  */
 ReflectionHarness.currentTestInfo = {};
 
 /**
- * This is called when we want to test a single element/attribute combination.
- * For the original harness, it does nothing special (just calls the function),
- * but for testharness.js, it can wrap everything in a test() call.
+ * .test() sets this, and it's used by .assertEquals()/.assertThrows().
+ * Calling .test() recursively is an error.
  */
-ReflectionHarness.testWrapper = function(fn) {
-  fn();
+ReflectionHarness.currentTestDescription = null;
+
+/**
+ * Run a group of one or more assertions.  If any exceptions are thrown, catch
+ * them and report a failure.
+ */
+ReflectionHarness.test = function(fn, description) {
+  if (this.currentTestDescription) {
+    throw "TEST BUG: test() may not be called recursively!";
+  }
+  this.currentTestDescription = description;
+  try {
+    fn();
+    // Not throwing is a success
+    this.success();
+  } catch(err) {
+    this.failure("Exception thrown during tests with " + description);
+  }
+  this.currentTestDescription = null;
 }
 
 /**
  * If question === answer, output a success, else report a failure with the
  * given description.  Currently success and failure both increment counters,
  * and failures output a message to a <ul>.  Which <ul> is decided by the type
  * parameter -- different attribute types are separated for readability.
  *
  * @public
  */
-ReflectionHarness.test = function(expected, actual, description) {
+ReflectionHarness.assertEquals = function(expected, actual, description) {
   // Special-case -0 yay!
   if (expected === 0 && actual === 0 && 1/expected === 1/actual) {
     this.increment(this.passed);
-    return true;
   } else if (expected === actual) {
     this.increment(this.passed);
-    return true;
   } else {
     this.increment(this.failed);
-    this.reportFailure(description + ' (expected ' + this.stringRep(actual) + ', got ' + this.stringRep(expected) + ')');
-    return false;
-  }
-}
-
-ReflectionHarness.run = function(fun, description) {
-  try {
-    fun();
-  } catch (err) {
-    ReflectionHarness.failure(description);
+    this.reportFailure(this.currentTestDescription +
+        (description ? " followed by " + description : "") +
+        ' (expected ' + this.stringRep(actual) + ', got ' +
+        this.stringRep(expected) + ')');
   }
 }
 
 /**
  * If calling fn causes a DOMException of the type given by the string
- * exceptionName (e.g., "INDEX_SIZE_ERR"), output a success.  Otherwise, report
- * a failure with the given description.
+ * exceptionName (e.g., "IndexSizeError"), output a success.  Otherwise, report
+ * a failure.
  *
  * @public
  */
-ReflectionHarness.testException = function(exceptionName, fn, description) {
+ReflectionHarness.assertThrows = function(exceptionName, fn) {
   try {
     fn();
   } catch (e) {
     if (e instanceof DOMException && e.code == DOMException[exceptionName]) {
       this.increment(this.passed);
       return true;
     }
   }
   this.increment(this.failed);
-  this.reportFailure(description);
+  this.reportFailure(this.currentTestDescription + " must throw " +
+      exceptionName);
   return false;
 }
 
 /**
  * Get a description of the current type, e.g., "a.href".
  */
 ReflectionHarness.getTypeDescription = function() {
   var domNode = this.currentTestInfo.domObj.tagName.toLowerCase();
   var idlNode = this.currentTestInfo.idlObj.nodeName.toLowerCase();
   var domName = this.currentTestInfo.domName;
@@ skipping 85 matching lines @@
   }
 
   if (type == "undefined") {
     ul.innerHTML += "<li>" + typeDesc;
   } else {
     ul.innerHTML += "<li><span class=\"type\">" + typeDesc + "</span>: <span class=\"desc\">" + description + "</span>";
   }
 }
 
 /**
- * Shorthand function for when we have a failure outside of test().  Generally
- * used when the failure is an exception thrown unexpectedly or such, something
- * not equality-based.
+ * Shorthand function for when we have a failure outside of
+ * assertEquals()/assertThrows().  Generally used when the failure is an
+ * exception thrown unexpectedly or such, something not equality-based.
  *
  * @public
  */
 ReflectionHarness.failure = function(message) {
   this.increment(this.failed);
   this.reportFailure(message);
 }
 
 /**
- * Shorthand function for when we have a success outside of test().  Only
- * called if catchUnexpectedExceptions is true.
+ * Shorthand function for when we have a success outside of
+ * assertEquals()/assertThrows().
  *
  * @public
  */
 ReflectionHarness.success = function() {
   this.increment(this.passed);
 }
 
 /**
  * Increment the count in either "passed" or "failed".  el should always be one
  * of those two variables.  The implementation of this function amuses me.
@@ skipping 48 matching lines @@
       continue;
     }
 
     if (key in elements) {
       elements[key] = elements[key].concat(src[key]);
     } else {
       elements[key] = src[key];
     }
   }
 }