The Tor Browser / file revision

 /* -*- js-indent-level: 2; tab-width: 2; indent-tabs-mode: nil -*- */

 // Test timeout (seconds)

 var gTimeoutSeconds = 45;

 var gConfig;

 if (Cc === undefined) {

   var Cc = Components.classes;

   var Ci = Components.interfaces;

   var Cu = Components.utils;

 }

 Cu.import("resource://gre/modules/XPCOMUtils.jsm");

 Cu.import("resource://gre/modules/Task.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "Services",

   "resource://gre/modules/Services.jsm");

 XPCOMUtils.defineLazyModuleGetter(this, "BrowserNewTabPreloader",

   "resource:///modules/BrowserNewTabPreloader.jsm", "BrowserNewTabPreloader");

 XPCOMUtils.defineLazyModuleGetter(this, "CustomizationTabPreloader",

   "resource:///modules/CustomizationTabPreloader.jsm", "CustomizationTabPreloader");

 const SIMPLETEST_OVERRIDES =

   ["ok", "is", "isnot", "ise", "todo", "todo_is", "todo_isnot", "info", "expectAssertions"];

 window.addEventListener("load", testOnLoad, false);

 function testOnLoad() {

   window.removeEventListener("load", testOnLoad, false);

   gConfig = readConfig();

   if (gConfig.testRoot == "browser" ||

       gConfig.testRoot == "metro" ||

       gConfig.testRoot == "webapprtChrome") {

     // Make sure to launch the test harness for the first opened window only

     var prefs = Services.prefs;

     if (prefs.prefHasUserValue("testing.browserTestHarness.running"))

       return;

     prefs.setBoolPref("testing.browserTestHarness.running", true);

     if (prefs.prefHasUserValue("testing.browserTestHarness.timeout"))

       gTimeoutSeconds = prefs.getIntPref("testing.browserTestHarness.timeout");

     var sstring = Cc["@mozilla.org/supports-string;1"].

                   createInstance(Ci.nsISupportsString);

     sstring.data = location.search;

     Services.ww.openWindow(window, "chrome://mochikit/content/browser-harness.xul", "browserTest",

                            "chrome,centerscreen,dialog=no,resizable,titlebar,toolbar=no,width=800,height=600", sstring);

   } else {

     // This code allows us to redirect without requiring specialpowers for chrome and a11y tests.

     let messageHandler = function(m) {

       messageManager.removeMessageListener("chromeEvent", messageHandler);

       var url = m.json.data;

       // Window is the [ChromeWindow] for messageManager, so we need content.window 

       // Currently chrome tests are run in a content window instead of a ChromeWindow

       var webNav = content.window.QueryInterface(Components.interfaces.nsIInterfaceRequestor)

                          .getInterface(Components.interfaces.nsIWebNavigation);

       webNav.loadURI(url, null, null, null, null);

     };

     var listener = 'data:,function doLoad(e) { var data=e.detail&&e.detail.data;removeEventListener("contentEvent", function (e) { doLoad(e); }, false, true);sendAsyncMessage("chromeEvent", {"data":data}); };addEventListener("contentEvent", function (e) { doLoad(e); }, false, true);';

     messageManager.loadFrameScript(listener, true);

     messageManager.addMessageListener("chromeEvent", messageHandler);

   }

   if (gConfig.e10s) {

     e10s_init();

   }

 }

 function Tester(aTests, aDumper, aCallback) {

   this.dumper = aDumper;

   this.tests = aTests;

   this.callback = aCallback;

   this.openedWindows = {};

   this.openedURLs = {};

   this._scriptLoader = Services.scriptloader;

   this._scriptLoader.loadSubScript("chrome://mochikit/content/tests/SimpleTest/EventUtils.js", this.EventUtils);

   var simpleTestScope = {};

   this._scriptLoader.loadSubScript("chrome://mochikit/content/tests/SimpleTest/specialpowersAPI.js", simpleTestScope);

   this._scriptLoader.loadSubScript("chrome://mochikit/content/tests/SimpleTest/SpecialPowersObserverAPI.js", simpleTestScope);

   this._scriptLoader.loadSubScript("chrome://mochikit/content/tests/SimpleTest/ChromePowers.js", simpleTestScope);

   this._scriptLoader.loadSubScript("chrome://mochikit/content/tests/SimpleTest/SimpleTest.js", simpleTestScope);

   this._scriptLoader.loadSubScript("chrome://mochikit/content/tests/SimpleTest/MemoryStats.js", simpleTestScope);

   this._scriptLoader.loadSubScript("chrome://mochikit/content/chrome-harness.js", simpleTestScope);

   this.SimpleTest = simpleTestScope.SimpleTest;

   this.MemoryStats = simpleTestScope.MemoryStats;

   this.Task = Task;

   this.Promise = Components.utils.import("resource://gre/modules/Promise.jsm", null).Promise;

   this.Assert = Components.utils.import("resource://testing-common/Assert.jsm", null).Assert;

   this.SimpleTestOriginal = {};

   SIMPLETEST_OVERRIDES.forEach(m => {

     this.SimpleTestOriginal[m] = this.SimpleTest[m];

   });

   this._uncaughtErrorObserver = function({message, date, fileName, stack, lineNumber}) {

     let text = "Once bug 991040 has landed, THIS ERROR WILL CAUSE A TEST FAILURE.\n" + message;

     let error = text;

     if (fileName || lineNumber) {

       error = {

         fileName: fileName,

         lineNumber: lineNumber,

         message: text,

         toString: function() {

           return text;

         }

       };

     }

     this.currentTest.addResult(

       new testResult(

 	/*success*/ true,

         /*name*/"A promise chain failed to handle a rejection",

         /*error*/error,

         /*known*/true,

         /*stack*/stack));

     }.bind(this);

 }

 Tester.prototype = {

   EventUtils: {},

   SimpleTest: {},

   Task: null,

   Promise: null,

   Assert: null,

   repeat: 0,

   runUntilFailure: false,

   checker: null,

   currentTestIndex: -1,

   lastStartTime: null,

   openedWindows: null,

   lastAssertionCount: 0,

   get currentTest() {

     return this.tests[this.currentTestIndex];

   },

   get done() {

     return this.currentTestIndex == this.tests.length - 1;

   },

   start: function Tester_start() {

     // Check whether this window is ready to run tests.

     if (window.BrowserChromeTest) {

       BrowserChromeTest.runWhenReady(this.actuallyStart.bind(this));

       return;

     }

     this.actuallyStart();

   },

   actuallyStart: function Tester_actuallyStart() {

     //if testOnLoad was not called, then gConfig is not defined

     if (!gConfig)

       gConfig = readConfig();

     if (gConfig.runUntilFailure)

       this.runUntilFailure = true;

     if (gConfig.repeat)

       this.repeat = gConfig.repeat;

     this.dumper.dump("*** Start BrowserChrome Test Results ***\n");

     Services.console.registerListener(this);

     Services.obs.addObserver(this, "chrome-document-global-created", false);

     Services.obs.addObserver(this, "content-document-global-created", false);

     this._globalProperties = Object.keys(window);

     this._globalPropertyWhitelist = [

       "navigator", "constructor", "top",

       "Application",

       "__SS_tabsToRestore", "__SSi",

       "webConsoleCommandController",

     ];

     this.Promise.Debugging.clearUncaughtErrorObservers();

     this.Promise.Debugging.addUncaughtErrorObserver(this._uncaughtErrorObserver);

     if (this.tests.length)

       this.nextTest();

     else

       this.finish();

   },

   waitForWindowsState: function Tester_waitForWindowsState(aCallback) {

     let timedOut = this.currentTest && this.currentTest.timedOut;

     let baseMsg = timedOut ? "Found a {elt} after previous test timed out"

                            : this.currentTest ? "Found an unexpected {elt} at the end of test run"

                                               : "Found an unexpected {elt}";

     // Remove stale tabs

     if (this.currentTest && window.gBrowser && gBrowser.tabs.length > 1) {

       while (gBrowser.tabs.length > 1) {

         let lastTab = gBrowser.tabContainer.lastChild;

         let msg = baseMsg.replace("{elt}", "tab") +

                   ": " + lastTab.linkedBrowser.currentURI.spec;

         this.currentTest.addResult(new testResult(false, msg, "", false));

         gBrowser.removeTab(lastTab);

       }

     }

     // Replace the last tab with a fresh one

     if (window.gBrowser) {

       gBrowser.addTab("about:blank", { skipAnimation: true });

       gBrowser.removeCurrentTab();

       gBrowser.stop();

     }

     // Remove stale windows

     this.dumper.dump("TEST-INFO | checking window state\n");

     let windowsEnum = Services.wm.getEnumerator(null);

     while (windowsEnum.hasMoreElements()) {

       let win = windowsEnum.getNext();

       if (win != window && !win.closed &&

           win.document.documentElement.getAttribute("id") != "browserTestHarness") {

         let type = win.document.documentElement.getAttribute("windowtype");

         switch (type) {

         case "navigator:browser":

           type = "browser window";

           break;

         case null:

           type = "unknown window";

           break;

         }

         let msg = baseMsg.replace("{elt}", type);

         if (this.currentTest)

           this.currentTest.addResult(new testResult(false, msg, "", false));

         else

           this.dumper.dump("TEST-UNEXPECTED-FAIL | (browser-test.js) | " + msg + "\n");

         win.close();

       }

     }

     // Make sure the window is raised before each test.

     this.SimpleTest.waitForFocus(aCallback);

   },

   finish: function Tester_finish(aSkipSummary) {

     this.Promise.Debugging.flushUncaughtErrors();

     var passCount = this.tests.reduce(function(a, f) a + f.passCount, 0);

     var failCount = this.tests.reduce(function(a, f) a + f.failCount, 0);

     var todoCount = this.tests.reduce(function(a, f) a + f.todoCount, 0);

     if (this.repeat > 0) {

       --this.repeat;

       this.currentTestIndex = -1;

       this.nextTest();

     }

     else{

       Services.console.unregisterListener(this);

       Services.obs.removeObserver(this, "chrome-document-global-created");

       Services.obs.removeObserver(this, "content-document-global-created");

       this.Promise.Debugging.clearUncaughtErrorObservers();

       this.dumper.dump("\nINFO TEST-START | Shutdown\n");

       if (this.tests.length) {

         this.dumper.dump("Browser Chrome Test Summary\n");

         this.dumper.dump("\tPassed: " + passCount + "\n" +

                          "\tFailed: " + failCount + "\n" +

                          "\tTodo: " + todoCount + "\n");

       } else {

         this.dumper.dump("TEST-UNEXPECTED-FAIL | (browser-test.js) | " +

                          "No tests to run. Did you pass an invalid --test-path?\n");

       }

       this.dumper.dump("\n*** End BrowserChrome Test Results ***\n");

       this.dumper.done();

       // Tests complete, notify the callback and return

       this.callback(this.tests);

       this.callback = null;

       this.tests = null;

       this.openedWindows = null;

     }

   },

   haltTests: function Tester_haltTests() {

     // Do not run any further tests

     this.currentTestIndex = this.tests.length - 1;

     this.repeat = 0;

   },

   observe: function Tester_observe(aSubject, aTopic, aData) {

     if (!aTopic) {

       this.onConsoleMessage(aSubject);

     } else if (this.currentTest) {

       this.onDocumentCreated(aSubject);

     }

   },

   onDocumentCreated: function Tester_onDocumentCreated(aWindow) {

     let utils = aWindow.QueryInterface(Ci.nsIInterfaceRequestor)

                        .getInterface(Ci.nsIDOMWindowUtils);

     let outerID = utils.outerWindowID;

     let innerID = utils.currentInnerWindowID;

     if (!(outerID in this.openedWindows)) {

       this.openedWindows[outerID] = this.currentTest;

     }

     this.openedWindows[innerID] = this.currentTest;

     let url = aWindow.location.href || "about:blank";

     this.openedURLs[outerID] = this.openedURLs[innerID] = url;

   },

   onConsoleMessage: function Tester_onConsoleMessage(aConsoleMessage) {

     // Ignore empty messages.

     if (!aConsoleMessage.message)

       return;

     try {

       var msg = "Console message: " + aConsoleMessage.message;

       if (this.currentTest)

         this.currentTest.addResult(new testMessage(msg));

       else

         this.dumper.dump("TEST-INFO | (browser-test.js) | " + msg.replace(/\n$/, "") + "\n");

     } catch (ex) {

       // Swallow exception so we don't lead to another error being reported,

       // throwing us into an infinite loop

     }

   },

   nextTest: Task.async(function*() {

     if (this.currentTest) {

       // Run cleanup functions for the current test before moving on to the

       // next one.

       let testScope = this.currentTest.scope;

       while (testScope.__cleanupFunctions.length > 0) {

         let func = testScope.__cleanupFunctions.shift();

         try {

           yield func.apply(testScope);

         }

         catch (ex) {

           this.currentTest.addResult(new testResult(false, "Cleanup function threw an exception", ex, false));

         }

       };

       this.Promise.Debugging.flushUncaughtErrors();

       let winUtils = window.QueryInterface(Ci.nsIInterfaceRequestor)

                            .getInterface(Ci.nsIDOMWindowUtils);

       if (winUtils.isTestControllingRefreshes) {

         this.currentTest.addResult(new testResult(false, "test left refresh driver under test control", "", false));

         winUtils.restoreNormalRefresh();

       }

       if (this.SimpleTest.isExpectingUncaughtException()) {

         this.currentTest.addResult(new testResult(false, "expectUncaughtException was called but no uncaught exception was detected!", "", false));

       }

       Object.keys(window).forEach(function (prop) {

         if (parseInt(prop) == prop) {

           // This is a string which when parsed as an integer and then

           // stringified gives the original string.  As in, this is in fact a

           // string representation of an integer, so an index into

           // window.frames.  Skip those.

           return;

         }

         if (this._globalProperties.indexOf(prop) == -1) {

           this._globalProperties.push(prop);

           if (this._globalPropertyWhitelist.indexOf(prop) == -1)

             this.currentTest.addResult(new testResult(false, "leaked window property: " + prop, "", false));

         }

       }, this);

       // Clear document.popupNode.  The test could have set it to a custom value

       // for its own purposes, nulling it out it will go back to the default

       // behavior of returning the last opened popup.

       document.popupNode = null;

       // Notify a long running test problem if it didn't end up in a timeout.

       if (this.currentTest.unexpectedTimeouts && !this.currentTest.timedOut) {

         let msg = "This test exceeded the timeout threshold. It should be " +

                   "rewritten or split up. If that's not possible, use " +

                   "requestLongerTimeout(N), but only as a last resort.";

         this.currentTest.addResult(new testResult(false, msg, "", false));

       }

       // If we're in a debug build, check assertion counts.  This code

       // is similar to the code in TestRunner.testUnloaded in

       // TestRunner.js used for all other types of mochitests.

       let debugsvc = Cc["@mozilla.org/xpcom/debug;1"].getService(Ci.nsIDebug2);

       if (debugsvc.isDebugBuild) {

         let newAssertionCount = debugsvc.assertionCount;

         let numAsserts = newAssertionCount - this.lastAssertionCount;

         this.lastAssertionCount = newAssertionCount;

         let max = testScope.__expectedMaxAsserts;

         let min = testScope.__expectedMinAsserts;

         if (numAsserts > max) {

           let msg = "Assertion count " + numAsserts +

                     " is greater than expected range " +

                     min + "-" + max + " assertions.";

           // TEST-UNEXPECTED-FAIL (TEMPORARILY TEST-KNOWN-FAIL)

           //this.currentTest.addResult(new testResult(false, msg, "", false));

           this.currentTest.addResult(new testResult(true, msg, "", true));

         } else if (numAsserts < min) {

           let msg = "Assertion count " + numAsserts +

                     " is less than expected range " +

                     min + "-" + max + " assertions.";

           // TEST-UNEXPECTED-PASS

           this.currentTest.addResult(new testResult(false, msg, "", true));

         } else if (numAsserts > 0) {

           let msg = "Assertion count " + numAsserts +

                     " is within expected range " +

                     min + "-" + max + " assertions.";

           // TEST-KNOWN-FAIL

           this.currentTest.addResult(new testResult(true, msg, "", true));

         }

       }

       // Dump memory stats for main thread.

       if (Cc["@mozilla.org/xre/runtime;1"]

           .getService(Ci.nsIXULRuntime)

           .processType == Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT)

       {

         this.MemoryStats.dump((l) => { this.dumper.dump(l + "\n"); },

                               this.currentTestIndex,

                               this.currentTest.path,

                               gConfig.dumpOutputDirectory,

                               gConfig.dumpAboutMemoryAfterTest,

                               gConfig.dumpDMDAfterTest);

       }

       // Note the test run time

       let time = Date.now() - this.lastStartTime;

       this.dumper.dump("INFO TEST-END | " + this.currentTest.path + " | finished in " + time + "ms\n");

       this.currentTest.setDuration(time);

       if (this.runUntilFailure && this.currentTest.failCount > 0) {

         this.haltTests();

       }

       // Restore original SimpleTest methods to avoid leaks.

       SIMPLETEST_OVERRIDES.forEach(m => {

         this.SimpleTest[m] = this.SimpleTestOriginal[m];

       });

       testScope.destroy();

       this.currentTest.scope = null;

     }

     // Check the window state for the current test before moving to the next one.

     // This also causes us to check before starting any tests, since nextTest()

     // is invoked to start the tests.

     this.waitForWindowsState((function () {

       if (this.done) {

         // Uninitialize a few things explicitly so that they can clean up

         // frames and browser intentionally kept alive until shutdown to

         // eliminate false positives.

         if (gConfig.testRoot == "browser") {

           // Replace the document currently loaded in the browser's sidebar.

           // This will prevent false positives for tests that were the last

           // to touch the sidebar. They will thus not be blamed for leaking

           // a document.

           let sidebar = document.getElementById("sidebar");

           sidebar.setAttribute("src", "data:text/html;charset=utf-8,");

           sidebar.docShell.createAboutBlankContentViewer(null);

           sidebar.setAttribute("src", "about:blank");

           // Do the same for the social sidebar.

           let socialSidebar = document.getElementById("social-sidebar-browser");

           socialSidebar.setAttribute("src", "data:text/html;charset=utf-8,");

           socialSidebar.docShell.createAboutBlankContentViewer(null);

           socialSidebar.setAttribute("src", "about:blank");

           // Destroy BackgroundPageThumbs resources.

           let {BackgroundPageThumbs} =

             Cu.import("resource://gre/modules/BackgroundPageThumbs.jsm", {});

           BackgroundPageThumbs._destroy();

           BrowserNewTabPreloader.uninit();

           CustomizationTabPreloader.uninit();

           SocialFlyout.unload();

           SocialShare.uninit();

           TabView.uninit();

         }

         // Simulate memory pressure so that we're forced to free more resources

         // and thus get rid of more false leaks like already terminated workers.

         Services.obs.notifyObservers(null, "memory-pressure", "heap-minimize");

         // Schedule GC and CC runs before finishing in order to detect

         // DOM windows leaked by our tests or the tested code. Note that we

         // use a shrinking GC so that the JS engine will discard JIT code and

         // JIT caches more aggressively.

         let checkForLeakedGlobalWindows = aCallback => {

           Cu.schedulePreciseShrinkingGC(() => {

             let analyzer = new CCAnalyzer();

             analyzer.run(() => {

               let results = [];

               for (let obj of analyzer.find("nsGlobalWindow ")) {

                 let m = obj.name.match(/^nsGlobalWindow #(\d+)/);

                 if (m && m[1] in this.openedWindows)

                   results.push({ name: obj.name, url: m[1] });

               }

               aCallback(results);

             });

           });

         };

         let reportLeaks = aResults => {

           for (let result of aResults) {

             let test = this.openedWindows[result.url];

             let msg = "leaked until shutdown [" + result.name +

                       " " + (this.openedURLs[result.url] || "NULL") + "]";

             test.addResult(new testResult(false, msg, "", false));

           }

         };

         checkForLeakedGlobalWindows(aResults => {

           if (aResults.length == 0) {

             this.finish();

             return;

           }

           // After the first check, if there are reported leaked windows, sleep

           // for a while, to allow off-main-thread work to complete and free up

           // main-thread objects.  Then check again.

           setTimeout(() => {

             checkForLeakedGlobalWindows(aResults => {

               reportLeaks(aResults);

               this.finish();

             });

           }, 1000);

         });

         return;

       }

       this.currentTestIndex++;

       this.execTest();

     }).bind(this));

   }),

   execTest: function Tester_execTest() {

     this.dumper.dump("TEST-START | " + this.currentTest.path + "\n");

     this.SimpleTest.reset();

     // Load the tests into a testscope

     let currentScope = this.currentTest.scope = new testScope(this, this.currentTest);

     let currentTest = this.currentTest;

     // Import utils in the test scope.

     this.currentTest.scope.EventUtils = this.EventUtils;

     this.currentTest.scope.SimpleTest = this.SimpleTest;

     this.currentTest.scope.gTestPath = this.currentTest.path;

     this.currentTest.scope.Task = this.Task;

     this.currentTest.scope.Promise = this.Promise;

     // Pass a custom report function for mochitest style reporting.

     this.currentTest.scope.Assert = new this.Assert(function(err, message, stack) {

       let res;

       if (err) {

         res = new testResult(false, err.message, err.stack, false, err.stack);

       } else {

         res = new testResult(true, message, "", false, stack);

       }

       currentTest.addResult(res);

     });

     // Allow Assert.jsm methods to be tacked to the current scope.

     this.currentTest.scope.export_assertions = function() {

       for (let func in this.Assert) {

         this[func] = this.Assert[func].bind(this.Assert);

       }

     };

     // Override SimpleTest methods with ours.

     SIMPLETEST_OVERRIDES.forEach(function(m) {

       this.SimpleTest[m] = this[m];

     }, this.currentTest.scope);

     //load the tools to work with chrome .jar and remote

     try {

       this._scriptLoader.loadSubScript("chrome://mochikit/content/chrome-harness.js", this.currentTest.scope);

     } catch (ex) { /* no chrome-harness tools */ }

     // Import head.js script if it exists.

     var currentTestDirPath =

       this.currentTest.path.substr(0, this.currentTest.path.lastIndexOf("/"));

     var headPath = currentTestDirPath + "/head.js";

     try {

       this._scriptLoader.loadSubScript(headPath, this.currentTest.scope);

     } catch (ex) {

       // Ignore if no head.js exists, but report all other errors.  Note this

       // will also ignore an existing head.js attempting to import a missing

       // module - see bug 755558 for why this strategy is preferred anyway.

       if (ex.toString() != 'Error opening input stream (invalid filename?)') {

        this.currentTest.addResult(new testResult(false, "head.js import threw an exception", ex, false));

       }

     }

     // Import the test script.

     try {

       this._scriptLoader.loadSubScript(this.currentTest.path,

                                        this.currentTest.scope);

       this.Promise.Debugging.flushUncaughtErrors();

       // Run the test

       this.lastStartTime = Date.now();

       if (this.currentTest.scope.__tasks) {

         // This test consists of tasks, added via the `add_task()` API.

         if ("test" in this.currentTest.scope) {

           throw "Cannot run both a add_task test and a normal test at the same time.";

         }

         this.Task.spawn(function() {

           let task;

           while ((task = this.__tasks.shift())) {

             this.SimpleTest.info("Entering test " + task.name);

             try {

               yield task();

             } catch (ex) {

               let isExpected = !!this.SimpleTest.isExpectingUncaughtException();

               let stack = (typeof ex == "object" && "stack" in ex)?ex.stack:null;

               let name = "Uncaught exception";

               let result = new testResult(isExpected, name, ex, false, stack);

               currentTest.addResult(result);

             }

             this.Promise.Debugging.flushUncaughtErrors();

             this.SimpleTest.info("Leaving test " + task.name);

           }

           this.finish();

         }.bind(currentScope));

       } else if ("generatorTest" in this.currentTest.scope) {

         if ("test" in this.currentTest.scope) {

           throw "Cannot run both a generator test and a normal test at the same time.";

         }

         // This test is a generator. It will not finish immediately.

         this.currentTest.scope.waitForExplicitFinish();

         var result = this.currentTest.scope.generatorTest();

         this.currentTest.scope.__generator = result;

         result.next();

       } else {

         this.currentTest.scope.test();

       }

     } catch (ex) {

       let isExpected = !!this.SimpleTest.isExpectingUncaughtException();

       if (!this.SimpleTest.isIgnoringAllUncaughtExceptions()) {

         this.currentTest.addResult(new testResult(isExpected, "Exception thrown", ex, false));

         this.SimpleTest.expectUncaughtException(false);

       } else {

         this.currentTest.addResult(new testMessage("Exception thrown: " + ex));

       }

       this.currentTest.scope.finish();

     }

     // If the test ran synchronously, move to the next test, otherwise the test

     // will trigger the next test when it is done.

     if (this.currentTest.scope.__done) {

       this.nextTest();

     }

     else {

       var self = this;

       this.currentTest.scope.__waitTimer = setTimeout(function timeoutFn() {

         if (--self.currentTest.scope.__timeoutFactor > 0) {

           // We were asked to wait a bit longer.

           self.currentTest.scope.info(

             "Longer timeout required, waiting longer...  Remaining timeouts: " +

             self.currentTest.scope.__timeoutFactor);

           self.currentTest.scope.__waitTimer =

             setTimeout(timeoutFn, gTimeoutSeconds * 1000);

           return;

         }

         // If the test is taking longer than expected, but it's not hanging,

         // mark the fact, but let the test continue.  At the end of the test,

         // if it didn't timeout, we will notify the problem through an error.

         // To figure whether it's an actual hang, compare the time of the last

         // result or message to half of the timeout time.

         // Though, to protect against infinite loops, limit the number of times

         // we allow the test to proceed.

         const MAX_UNEXPECTED_TIMEOUTS = 10;

         if (Date.now() - self.currentTest.lastOutputTime < (gTimeoutSeconds / 2) * 1000 &&

             ++self.currentTest.unexpectedTimeouts <= MAX_UNEXPECTED_TIMEOUTS) {

             self.currentTest.scope.__waitTimer =

               setTimeout(timeoutFn, gTimeoutSeconds * 1000);

           return;

         }

         self.currentTest.addResult(new testResult(false, "Test timed out", "", false));

         self.currentTest.timedOut = true;

         self.currentTest.scope.__waitTimer = null;

         self.nextTest();

       }, gTimeoutSeconds * 1000);

     }

   },

   QueryInterface: function(aIID) {

     if (aIID.equals(Ci.nsIConsoleListener) ||

         aIID.equals(Ci.nsISupports))

       return this;

     throw Components.results.NS_ERROR_NO_INTERFACE;

   }

 };

 function testResult(aCondition, aName, aDiag, aIsTodo, aStack) {

   this.msg = aName || "";

   this.info = false;

   this.pass = !!aCondition;

   this.todo = aIsTodo;

   if (this.pass) {

     if (aIsTodo)

       this.result = "TEST-KNOWN-FAIL";

     else

       this.result = "TEST-PASS";

   } else {

     if (aDiag) {

       if (typeof aDiag == "object" && "fileName" in aDiag) {

         // we have an exception - print filename and linenumber information

         this.msg += " at " + aDiag.fileName + ":" + aDiag.lineNumber;

       }

       this.msg += " - " + aDiag;

     }

     if (aStack) {

       this.msg += "\nStack trace:\n";

       var frame = aStack;

       while (frame) {

         this.msg += "    " + frame + "\n";

         frame = frame.caller;

       }

     }

     if (aIsTodo)

       this.result = "TEST-UNEXPECTED-PASS";

     else

       this.result = "TEST-UNEXPECTED-FAIL";

     if (gConfig.debugOnFailure) {

       // You've hit this line because you requested to break into the

       // debugger upon a testcase failure on your test run.

       debugger;

     }

   }

 }

 function testMessage(aName) {

   this.msg = aName || "";

   this.info = true;

   this.result = "TEST-INFO";

 }

 // Need to be careful adding properties to this object, since its properties

 // cannot conflict with global variables used in tests.

 function testScope(aTester, aTest) {

   this.__tester = aTester;

   var self = this;

   this.ok = function test_ok(condition, name, diag, stack) {

     aTest.addResult(new testResult(condition, name, diag, false,

                                    stack ? stack : Components.stack.caller));

   };

   this.is = function test_is(a, b, name) {

     self.ok(a == b, name, "Got " + a + ", expected " + b, false,

             Components.stack.caller);

   };

   this.isnot = function test_isnot(a, b, name) {

     self.ok(a != b, name, "Didn't expect " + a + ", but got it", false,

             Components.stack.caller);

   };

   this.ise = function test_ise(a, b, name) {

     self.ok(a === b, name, "Got " + a + ", strictly expected " + b, false,

             Components.stack.caller);

   };

   this.todo = function test_todo(condition, name, diag, stack) {

     aTest.addResult(new testResult(!condition, name, diag, true,

                                    stack ? stack : Components.stack.caller));

   };

   this.todo_is = function test_todo_is(a, b, name) {

     self.todo(a == b, name, "Got " + a + ", expected " + b,

               Components.stack.caller);

   };

   this.todo_isnot = function test_todo_isnot(a, b, name) {

     self.todo(a != b, name, "Didn't expect " + a + ", but got it",

               Components.stack.caller);

   };

   this.info = function test_info(name) {

     aTest.addResult(new testMessage(name));

   };

   this.executeSoon = function test_executeSoon(func) {

     Services.tm.mainThread.dispatch({

       run: function() {

         func();

       }

     }, Ci.nsIThread.DISPATCH_NORMAL);

   };

   this.nextStep = function test_nextStep(arg) {

     if (self.__done) {

       aTest.addResult(new testResult(false, "nextStep was called too many times", "", false));

       return;

     }

     if (!self.__generator) {

       aTest.addResult(new testResult(false, "nextStep called with no generator", "", false));

       self.finish();

       return;

     }

     try {

       self.__generator.send(arg);

     } catch (ex if ex instanceof StopIteration) {

       // StopIteration means test is finished.

       self.finish();

     } catch (ex) {

       var isExpected = !!self.SimpleTest.isExpectingUncaughtException();

       if (!self.SimpleTest.isIgnoringAllUncaughtExceptions()) {

         aTest.addResult(new testResult(isExpected, "Exception thrown", ex, false));

         self.SimpleTest.expectUncaughtException(false);

       } else {

         aTest.addResult(new testMessage("Exception thrown: " + ex));

       }

       self.finish();

     }

   };

   this.waitForExplicitFinish = function test_waitForExplicitFinish() {

     self.__done = false;

   };

   this.waitForFocus = function test_waitForFocus(callback, targetWindow, expectBlankPage) {

     self.SimpleTest.waitForFocus(callback, targetWindow, expectBlankPage);

   };

   this.waitForClipboard = function test_waitForClipboard(expected, setup, success, failure, flavor) {

     self.SimpleTest.waitForClipboard(expected, setup, success, failure, flavor);

   };

   this.registerCleanupFunction = function test_registerCleanupFunction(aFunction) {

     self.__cleanupFunctions.push(aFunction);

   };

   this.requestLongerTimeout = function test_requestLongerTimeout(aFactor) {

     self.__timeoutFactor = aFactor;

   };

   this.copyToProfile = function test_copyToProfile(filename) {

     self.SimpleTest.copyToProfile(filename);

   };

   this.expectUncaughtException = function test_expectUncaughtException(aExpecting) {

     self.SimpleTest.expectUncaughtException(aExpecting);

   };

   this.ignoreAllUncaughtExceptions = function test_ignoreAllUncaughtExceptions(aIgnoring) {

     self.SimpleTest.ignoreAllUncaughtExceptions(aIgnoring);

   };

   this.expectAssertions = function test_expectAssertions(aMin, aMax) {

     let min = aMin;

     let max = aMax;

     if (typeof(max) == "undefined") {

       max = min;

     }

     if (typeof(min) != "number" || typeof(max) != "number" ||

         min < 0 || max < min) {

       throw "bad parameter to expectAssertions";

     }

     self.__expectedMinAsserts = min;

     self.__expectedMaxAsserts = max;

   };

   this.finish = function test_finish() {

     self.__done = true;

     if (self.__waitTimer) {

       self.executeSoon(function() {

         if (self.__done && self.__waitTimer) {

           clearTimeout(self.__waitTimer);

           self.__waitTimer = null;

           self.__tester.nextTest();

         }

       });

     }

   };

 }

 testScope.prototype = {

   __done: true,

   __generator: null,

   __tasks: null,

   __waitTimer: null,

   __cleanupFunctions: [],

   __timeoutFactor: 1,

   __expectedMinAsserts: 0,

   __expectedMaxAsserts: 0,

   EventUtils: {},

   SimpleTest: {},

   Task: null,

   Promise: null,

   Assert: null,

   /**

    * Add a test function which is a Task function.

    *

    * Task functions are functions fed into Task.jsm's Task.spawn(). They are

    * generators that emit promises.

    *

    * If an exception is thrown, an assertion fails, or if a rejected

    * promise is yielded, the test function aborts immediately and the test is

    * reported as a failure. Execution continues with the next test function.

    *

    * To trigger premature (but successful) termination of the function, simply

    * return or throw a Task.Result instance.

    *

    * Example usage:

    *

    * add_task(function test() {

    *   let result = yield Promise.resolve(true);

    *

    *   ok(result);

    *

    *   let secondary = yield someFunctionThatReturnsAPromise(result);

    *   is(secondary, "expected value");

    * });

    *

    * add_task(function test_early_return() {

    *   let result = yield somethingThatReturnsAPromise();

    *

    *   if (!result) {

    *     // Test is ended immediately, with success.

    *     return;

    *   }

    *

    *   is(result, "foo");

    * });

    */

   add_task: function(aFunction) {

     if (!this.__tasks) {

       this.waitForExplicitFinish();

       this.__tasks = [];

     }

     this.__tasks.push(aFunction.bind(this));

   },

   destroy: function test_destroy() {

     for (let prop in this)

       delete this[prop];

   }

 };