LayoutTests/resources/js-test.js onerror tweak.

LayoutTests/resources/js-test.js

 // svg/dynamic-updates tests set enablePixelTesting=true, as we want to dump text + pixel results
 if (self.testRunner) {
     if (self.enablePixelTesting)
         testRunner.dumpAsTextWithPixelResults();
     else
         testRunner.dumpAsText();
 }
 
-var description, debug, successfullyParsed, errorMessage;
+var description, debug, successfullyParsed;
+
+var expectingError; // set by shouldHaveError()
+var expectedErrorMessage; // set by onerror when expectingError is true
+var unexpectedErrorMessage; // set by onerror when expectingError is not true
 
 (function() {
 
     function getOrCreate(id, tagName)
     {
         var element = document.getElementById(id);
         if (element)
             return element;
 
         element = document.createElement(tagName);
@@ skipping 67 matching lines @@
     }
 
     if (!isWorker()) {
         window.addEventListener('DOMContentLoaded', handleTestFinished, false);
         insertStyleSheet();
     }
 
     if (!self.isOnErrorTest) {
         self.onerror = function(message)
         {
-            errorMessage = message;
+            if (self.expectingError) {
+                self.expectedErrorMessage = message;
+                self.expectingError = false;
+                return;
+            }
+            self.unexpectedErrorMessage = message;
+            if (self.jsTestIsAsync) {
+                self.testFailed("Unexpected error: " + message);
+                setTimeout(finishJSTest, 0);

[ojan, 2013/11/11 20:22:29]

Why the setTimeout?

[pwnall-personal, 2013/11/11 22:45:34]

As I was debugging failed tests on the last patch, I saw that when the
setTimeout is in place, I get the ERROR messages from the console in the text
output. If I call finishJSTest right away, I don't. I like all the help I can
get in debugging my failures, so I thought this is useful.

OTOH, I'm pretty new to the codebase, and I haven't looked at the test shell. I
can get rid of setTimeout if you don't like it.

[ojan, 2013/11/11 23:30:41]

Don't you get the same error message from the testFailed call one line up?
setTimeout often leads to test flakiness. We try to avoid it whenever possible.

+            }
         };
     }
 })();
 
 function isWorker()
 {
     // It's conceivable that someone would stub out 'document' in a worker so
     // also check for childNodes, an arbitrary DOM-related object that is
     // meaningless in a WorkerContext.
     return (typeof document === 'undefined' || typeof document.childNodes === 'undefined') && !!self.importScripts;
@@ skipping 439 matching lines @@
     if (typeof _e == "undefined" || exception == _ev)
       testPassed(_a + " threw exception " + exception + ".");
     else
       testFailed(_a + " should throw " + (typeof _e == "undefined" ? "an exception" : _ev) + ". Threw exception " + exception + ".");
   } else if (typeof _av == "undefined")
     testFailed(_a + " should throw " + (typeof _e == "undefined" ? "an exception" : _ev) + ". Was undefined.");
   else
     testFailed(_a + " should throw " + (typeof _e == "undefined" ? "an exception" : _ev) + ". Was " + _av + ".");
 }
 
+function expectError()
+{
+    if (expectingError) {
+        testFailed("shouldHaveError() called twice before an error occurred!");
+    }
+    expectingError = true;
+}
+
 function shouldHaveHadError(message)
 {
-    if (errorMessage) {
+    if (expectingError) {
+        testFailed("No error thrown between expectError() and shouldHaveHadError()");
+        return;
+    }
+
+    if (expectedErrorMessage) {
         if (!message)
             testPassed("Got expected error");
-        else if (errorMessage.indexOf(message) !== -1)
+        else if (expectedErrorMessage.indexOf(message) !== -1)
             testPassed("Got expected error: '" + message + "'");
         else
-            testFailed("Unexpexted error '" + message + "'");
-    } else
-        testFailed("Missing expexted error");
-    errorMessage = undefined;
+            testFailed("Unexpected error '" + message + "'");
+        expectedErrorMessage = undefined;
+        return;
+    }
+
+    testFailed("expectError() not called before shouldHaveHadError()");
 }
 
 function gc() {
     if (typeof GCController !== "undefined")
         GCController.collect();
     else {
         var gcRec = function (n) {
             if (n < 1)
                 return {};
             var temp = {i: "ab" + i + (i / 100000)};
             temp += "foo";
             gcRec(n-1);
         };
         for (var i = 0; i < 1000; i++)
             gcRec(10)
     }
 }
 
 function minorGC() {
     if (typeof GCController !== "undefined")
         GCController.minorCollect();
     else
         testFailed("Minor GC is available only when you enable the --expose-gc option in V8.");
 }
 
 function isSuccessfullyParsed()
 {
     // FIXME: Remove this and only report unexpected syntax errors.
-    if (!errorMessage)
-        successfullyParsed = true;
+    successfullyParsed = !unexpectedErrorMessage;
     shouldBeTrue("successfullyParsed");
     debug('<br /><span class="pass">TEST COMPLETE</span>');
 }
 
 // It's possible for an async test to call finishJSTest() before js-test-post.js
 // has been parsed.
 function finishJSTest()
 {
     wasFinishJSTestCalled = true;
     if (!self.wasPostTestScriptParsed)
@@ skipping 76 matching lines @@
     testPassed = function(msg) {
         workerPort.postMessage('PASS:' + msg);
     }
     finishJSTest = function() {
         workerPort.postMessage('DONE:');
     }
     debug = function(msg) {
         workerPort.postMessage(msg);
     }
 }