The Tor Browser: comparison testing/mochitest/browser-test.js

comparison: testing/mochitest/browser-test.js

testing/mochitest/browser-test.js

changeset 0: 6474c204b198

equal deleted inserted replaced

--1:000000000000
+:1215bacff173
+/* -*- 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];
+}
+};