The Tor Browser: comparison toolkit/modules/tests/xpcshell/test_Promise.js

comparison: toolkit/modules/tests/xpcshell/test_Promise.js

toolkit/modules/tests/xpcshell/test_Promise.js

changeset 0: 6474c204b198

equal deleted inserted replaced

--1:000000000000
+:f3db090ab692
+/* Any copyright is dedicated to the Public Domain.
+* http://creativecommons.org/publicdomain/zero/1.0/ */
+"use strict";
+Components.utils.import("resource://gre/modules/Promise.jsm");
+Components.utils.import("resource://gre/modules/Services.jsm");
+Components.utils.import("resource://gre/modules/Task.jsm");
+// Deactivate the standard xpcshell observer, as it turns uncaught
+// rejections into failures, which we don't want here.
+Promise.Debugging.clearUncaughtErrorObservers();
+////////////////////////////////////////////////////////////////////////////////
+//// Test runner
+let run_promise_tests = function run_promise_tests(tests, cb) {
+let loop = function loop(index) {
+if (index >= tests.length) {
+if (cb) {
+cb.call();
+}
+return;
+}
+do_print("Launching test " + (index + 1) + "/" + tests.length);
+let test = tests[index];
+// Execute from an empty stack
+let next = function next() {
+do_print("Test " + (index + 1) + "/" + tests.length + " complete");
+do_execute_soon(function() {
+loop(index + 1);
+});
+};
+let result = test();
+result.then(next, next);
+};
+return loop(0);
+};
+let make_promise_test = function(test) {
+return function runtest() {
+do_print("Test starting: " + test.name);
+try {
+let result = test();
+if (result && "promise" in result) {
+result = result.promise;
+}
+if (!result || !("then" in result)) {
+let exn;
+try {
+do_throw("Test " + test.name + " did not return a promise: " + result);
+} catch (x) {
+exn = x;
+}
+return Promise.reject(exn);
+}
+// The test returns a promise
+result = result.then(
+// Test complete
+function onResolve() {
+do_print("Test complete: " + test.name);
+},
+// The test failed with an unexpected error
+function onReject(err) {
+let detail;
+if (err && typeof err == "object" && "stack" in err) {
+detail = err.stack;
+} else {
+detail = "(no stack)";
+}
+do_throw("Test " + test.name + " rejected with the following reason: "
++ err + detail);
+});
+return result;
+} catch (x) {
+// The test failed because of an error outside of a promise
+do_throw("Error in body of test " + test.name + ": " + x + " at " + x.stack);
+return Promise.reject();
+}
+};
+};
+////////////////////////////////////////////////////////////////////////////////
+//// Tests
+let tests = [];
+// Utility function to observe an failures in a promise
+// This function is useful if the promise itself is
+// not returned.
+let observe_failures = function observe_failures(promise) {
+promise.catch(function onReject(reason) {
+test.do_throw("Observed failure in test " + test + ": " + reason);
+});
+};
+// Test that all observers are notified
+tests.push(make_promise_test(
+function notification(test) {
+// The size of the test
+const SIZE = 10;
+const RESULT = "this is an arbitrary value";
+// Number of observers that yet need to be notified
+let expected = SIZE;
+// |true| once an observer has been notified
+let notified = [];
+// The promise observed
+let source = Promise.defer();
+let result = Promise.defer();
+let install_observer = function install_observer(i) {
+observe_failures(source.promise.then(
+function onSuccess(value) {
+do_check_true(!notified[i], "Ensuring that observer is notified at most once");
+notified[i] = true;
+do_check_eq(value, RESULT, "Ensuring that the observed value is correct");
+if (--expected == 0) {
+result.resolve();
+}
+}));
+};
+// Install a number of observers before resolving
+let i;
+for (i = 0; i < SIZE/2; ++i) {
+install_observer(i);
+}
+source.resolve(RESULT);
+// Install remaining observers
+for(;i < SIZE; ++i) {
+install_observer(i);
+}
+return result;
+}));
+// Test that observers get the correct "this" value in strict mode.
+tests.push(
+make_promise_test(function handlers_this_value(test) {
+return Promise.resolve().then(
+function onResolve() {
+// Since this file is in strict mode, the correct value is "undefined".
+do_check_eq(this, undefined);
+throw "reject";
+}
+).then(
+null,
+function onReject() {
+// Since this file is in strict mode, the correct value is "undefined".
+do_check_eq(this, undefined);
+}
+);
+}));
+// Test that observers registered on a pending promise are notified in order.
+tests.push(
+make_promise_test(function then_returns_before_callbacks(test) {
+let deferred = Promise.defer();
+let promise = deferred.promise;
+let order = 0;
+promise.then(
+function onResolve() {
+do_check_eq(order, 0);
+order++;
+}
+);
+promise.then(
+function onResolve() {
+do_check_eq(order, 1);
+order++;
+}
+);
+let newPromise = promise.then(
+function onResolve() {
+do_check_eq(order, 2);
+}
+);
+deferred.resolve();
+// This test finishes after the last handler succeeds.
+return newPromise;
+}));
+// Test that observers registered on a resolved promise are notified in order.
+tests.push(
+make_promise_test(function then_returns_before_callbacks(test) {
+let promise = Promise.resolve();
+let order = 0;
+promise.then(
+function onResolve() {
+do_check_eq(order, 0);
+order++;
+}
+);
+promise.then(
+function onResolve() {
+do_check_eq(order, 1);
+order++;
+}
+);
+// This test finishes after the last handler succeeds.
+return promise.then(
+function onResolve() {
+do_check_eq(order, 2);
+}
+);
+}));
+// Test that all observers are notified at most once, even if source
+// is resolved/rejected several times
+tests.push(make_promise_test(
+function notification_once(test) {
+// The size of the test
+const SIZE = 10;
+const RESULT = "this is an arbitrary value";
+// Number of observers that yet need to be notified
+let expected = SIZE;
+// |true| once an observer has been notified
+let notified = [];
+// The promise observed
+let observed = Promise.defer();
+let result = Promise.defer();
+let install_observer = function install_observer(i) {
+observe_failures(observed.promise.then(
+function onSuccess(value) {
+do_check_true(!notified[i], "Ensuring that observer is notified at most once");
+notified[i] = true;
+do_check_eq(value, RESULT, "Ensuring that the observed value is correct");
+if (--expected == 0) {
+result.resolve();
+}
+}));
+};
+// Install a number of observers before resolving
+let i;
+for (i = 0; i < SIZE/2; ++i) {
+install_observer(i);
+}
+observed.resolve(RESULT);
+// Install remaining observers
+for(;i < SIZE; ++i) {
+install_observer(i);
+}
+// Resolve some more
+for (i = 0; i < 10; ++i) {
+observed.resolve(RESULT);
+observed.reject();
+}
+return result;
+}));
+// Test that throwing an exception from a onResolve listener
+// does not prevent other observers from receiving the notification
+// of success.
+tests.push(
+make_promise_test(function exceptions_do_not_stop_notifications(test)  {
+let source = Promise.defer();
+let exception_thrown = false;
+let exception_content = new Error("Boom!");
+let observer_1 = source.promise.then(
+function onResolve() {
+exception_thrown = true;
+throw exception_content;
+});
+let observer_2 = source.promise.then(
+function onResolve() {
+do_check_true(exception_thrown, "Second observer called after first observer has thrown");
+}
+);
+let result = observer_1.then(
+function onResolve() {
+do_throw("observer_1 should not have resolved");
+},
+function onReject(reason) {
+do_check_true(reason == exception_content, "Obtained correct rejection");
+}
+);
+source.resolve();
+return result;
+}
+));
+// Test that, once a promise is resolved, further resolve/reject
+// are ignored.
+tests.push(
+make_promise_test(function subsequent_resolves_are_ignored(test) {
+let deferred = Promise.defer();
+deferred.resolve(1);
+deferred.resolve(2);
+deferred.reject(3);
+let result = deferred.promise.then(
+function onResolve(value) {
+do_check_eq(value, 1, "Resolution chose the first value");
+},
+function onReject(reason) {
+do_throw("Obtained a rejection while the promise was already resolved");
+}
+);
+return result;
+}));
+// Test that, once a promise is rejected, further resolve/reject
+// are ignored.
+tests.push(
+make_promise_test(function subsequent_rejects_are_ignored(test) {
+let deferred = Promise.defer();
+deferred.reject(1);
+deferred.reject(2);
+deferred.resolve(3);
+let result = deferred.promise.then(
+function onResolve() {
+do_throw("Obtained a resolution while the promise was already rejected");
+},
+function onReject(reason) {
+do_check_eq(reason, 1, "Rejection chose the first value");
+}
+);
+return result;
+}));
+// Test that returning normally from a rejection recovers from the error
+// and that listeners are informed of a success.
+tests.push(
+make_promise_test(function recovery(test) {
+let boom = new Error("Boom!");
+let deferred = Promise.defer();
+const RESULT = "An arbitrary value";
+let promise = deferred.promise.then(
+function onResolve() {
+do_throw("A rejected promise should not resolve");
+},
+function onReject(reason) {
+do_check_true(reason == boom, "Promise was rejected with the correct error");
+return RESULT;
+}
+);
+promise = promise.then(
+function onResolve(value) {
+do_check_eq(value, RESULT, "Promise was recovered with the correct value");
+}
+);
+deferred.reject(boom);
+return promise;
+}));
+// Test that returning a resolved promise from a onReject causes a resolution
+// (recovering from the error) and that returning a rejected promise
+// from a onResolve listener causes a rejection (raising an error).
+tests.push(
+make_promise_test(function recovery_with_promise(test) {
+let boom = new Error("Arbitrary error");
+let deferred = Promise.defer();
+const RESULT = "An arbitrary value";
+const boom2 = new Error("Another arbitrary error");
+// return a resolved promise from a onReject listener
+let promise = deferred.promise.then(
+function onResolve() {
+do_throw("A rejected promise should not resolve");
+},
+function onReject(reason) {
+do_check_true(reason == boom, "Promise was rejected with the correct error");
+return Promise.resolve(RESULT);
+}
+);
+// return a rejected promise from a onResolve listener
+promise = promise.then(
+function onResolve(value) {
+do_check_eq(value, RESULT, "Promise was recovered with the correct value");
+return Promise.reject(boom2);
+}
+);
+promise = promise.catch(
+function onReject(reason) {
+do_check_eq(reason, boom2, "Rejection was propagated with the correct " +
+"reason, through a promise");
+}
+);
+deferred.reject(boom);
+return promise;
+}));
+// Test that we can resolve with promises of promises
+tests.push(
+make_promise_test(function test_propagation(test) {
+const RESULT = "Yet another arbitrary value";
+let d1 = Promise.defer();
+let d2 = Promise.defer();
+let d3 = Promise.defer();
+d3.resolve(d2.promise);
+d2.resolve(d1.promise);
+d1.resolve(RESULT);
+return d3.promise.then(
+function onSuccess(value) {
+do_check_eq(value, RESULT, "Resolution with a promise eventually yielded "
++ " the correct result");
+}
+);
+}));
+// Test sequences of |then| and |catch|
+tests.push(
+make_promise_test(function test_chaining(test) {
+let error_1 = new Error("Error 1");
+let error_2 = new Error("Error 2");
+let result_1 = "First result";
+let result_2 = "Second result";
+let result_3 = "Third result";
+let source = Promise.defer();
+let promise = source.promise.then().then();
+source.resolve(result_1);
+// Check that result_1 is correctly propagated
+promise = promise.then(
+function onSuccess(result) {
+do_check_eq(result, result_1, "Result was propagated correctly through " +
+" several applications of |then|");
+return result_2;
+}
+);
+// Check that returning from the promise produces a resolution
+promise = promise.catch(
+function onReject() {
+do_throw("Incorrect rejection");
+}
+);
+// ... and that the check did not alter the value
+promise = promise.then(
+function onResolve(value) {
+do_check_eq(value, result_2, "Result was propagated correctly once again");
+}
+);
+// Now the same kind of tests for rejections
+promise = promise.then(
+function onResolve() {
+throw error_1;
+}
+);
+promise = promise.then(
+function onResolve() {
+do_throw("Incorrect resolution: the exception should have caused a rejection");
+}
+);
+promise = promise.catch(
+function onReject(reason) {
+do_check_true(reason == error_1, "Reason was propagated correctly");
+throw error_2;
+}
+);
+promise = promise.catch(
+function onReject(reason) {
+do_check_true(reason == error_2, "Throwing an error altered the reason " +
+"as expected");
+return result_3;
+}
+);
+promise = promise.then(
+function onResolve(result) {
+do_check_eq(result, result_3, "Error was correctly recovered");
+}
+);
+return promise;
+}));
+// Test that resolving with a rejected promise actually rejects
+tests.push(
+make_promise_test(function resolve_to_rejected(test) {
+let source = Promise.defer();
+let error = new Error("Boom");
+let promise = source.promise.then(
+function onResolve() {
+do_throw("Incorrect call to onResolve listener");
+},
+function onReject(reason) {
+do_check_eq(reason, error, "Rejection lead to the expected reason");
+}
+);
+source.resolve(Promise.reject(error));
+return promise;
+}));
+// Test that Promise.resolve resolves as expected
+tests.push(
+make_promise_test(function test_resolve(test) {
+const RESULT = "arbitrary value";
+let p1 = Promise.resolve(RESULT);
+let p2 = Promise.resolve(p1);
+do_check_eq(p1, p2, "Promise.resolve used on a promise just returns the promise");
+return p1.then(
+function onResolve(result) {
+do_check_eq(result, RESULT, "Promise.resolve propagated the correct result");
+}
+);
+}));
+// Test that Promise.resolve throws when its argument is an async function.
+tests.push(
+make_promise_test(function test_promise_resolve_throws_with_async_function(test) {
+Assert.throws(() => Promise.resolve(Task.async(function* () {})),
+/Cannot resolve a promise with an async function/);
+return Promise.resolve();
+}));
+// Test that the code after "then" is always executed before the callbacks
+tests.push(
+make_promise_test(function then_returns_before_callbacks(test) {
+let promise = Promise.resolve();
+let thenExecuted = false;
+promise = promise.then(
+function onResolve() {
+thenExecuted = true;
+}
+);
+do_check_false(thenExecuted);
+return promise;
+}));
+// Test that chaining promises does not generate long stack traces
+tests.push(
+make_promise_test(function chaining_short_stack(test) {
+let source = Promise.defer();
+let promise = source.promise;
+const NUM_ITERATIONS = 100;
+for (let i = 0; i < NUM_ITERATIONS; i++) {
+promise = promise.then(
+function onResolve(result) {
+return result + ".";
+}
+);
+}
+promise = promise.then(
+function onResolve(result) {
+// Check that the execution went as expected.
+let expectedString = new Array(1 + NUM_ITERATIONS).join(".");
+do_check_true(result == expectedString);
+// Check that we didn't generate one or more stack frames per iteration.
+let stackFrameCount = 0;
+let stackFrame = Components.stack;
+while (stackFrame) {
+stackFrameCount++;
+stackFrame = stackFrame.caller;
+}
+do_check_true(stackFrameCount < NUM_ITERATIONS);
+}
+);
+source.resolve("");
+return promise;
+}));
+// Test that the values of the promise return by Promise.all() are kept in the
+// given order even if the given promises are resolved in arbitrary order
+tests.push(
+make_promise_test(function all_resolve(test) {
+let d1 = Promise.defer();
+let d2 = Promise.defer();
+let d3 = Promise.defer();
+d3.resolve(4);
+d2.resolve(2);
+do_execute_soon(() => d1.resolve(1));
+let promises = [d1.promise, d2.promise, 3, d3.promise];
+return Promise.all(promises).then(
+function onResolve([val1, val2, val3, val4]) {
+do_check_eq(val1, 1);
+do_check_eq(val2, 2);
+do_check_eq(val3, 3);
+do_check_eq(val4, 4);
+}
+);
+}));
+// Test that rejecting one of the promises passed to Promise.all()
+// rejects the promise return by Promise.all()
+tests.push(
+make_promise_test(function all_reject(test) {
+let error = new Error("Boom");
+let d1 = Promise.defer();
+let d2 = Promise.defer();
+let d3 = Promise.defer();
+d3.resolve(3);
+d2.resolve(2);
+do_execute_soon(() => d1.reject(error));
+let promises = [d1.promise, d2.promise, d3.promise];
+return Promise.all(promises).then(
+function onResolve() {
+do_throw("Incorrect call to onResolve listener");
+},
+function onReject(reason) {
+do_check_eq(reason, error, "Rejection lead to the expected reason");
+}
+);
+}));
+// Test that passing only values (not promises) to Promise.all()
+// forwards them all as resolution values.
+tests.push(
+make_promise_test(function all_resolve_no_promises(test) {
+try {
+Promise.all(null);
+do_check_true(false, "all() should only accept iterables");
+} catch (e) {
+do_check_true(true, "all() fails when first the arg is not an iterable");
+}
+let p1 = Promise.all([]).then(
+function onResolve(val) {
+do_check_true(Array.isArray(val) && val.length == 0);
+}
+);
+let p2 = Promise.all([1, 2, 3]).then(
+function onResolve([val1, val2, val3]) {
+do_check_eq(val1, 1);
+do_check_eq(val2, 2);
+do_check_eq(val3, 3);
+}
+);
+return Promise.all([p1, p2]);
+}));
+// Test that Promise.all() handles non-array iterables
+tests.push(
+make_promise_test(function all_iterable(test) {
+function* iterable() {
+yield 1;
+yield 2;
+yield 3;
+}
+return Promise.all(iterable()).then(
+function onResolve([val1, val2, val3]) {
+do_check_eq(val1, 1);
+do_check_eq(val2, 2);
+do_check_eq(val3, 3);
+},
+function onReject() {
+do_throw("all() unexpectedly rejected");
+}
+);
+}));
+// Test that throwing from the iterable passed to Promise.all() rejects the
+// promise returned by Promise.all()
+tests.push(
+make_promise_test(function all_iterable_throws(test) {
+function* iterable() {
+throw 1;
+}
+return Promise.all(iterable()).then(
+function onResolve() {
+do_throw("all() unexpectedly resolved");
+},
+function onReject(reason) {
+do_check_eq(reason, 1, "all() rejects when the iterator throws");
+}
+);
+}));
+// Test that Promise.race() resolves with the first available resolution value
+tests.push(
+make_promise_test(function race_resolve(test) {
+let p1 = Promise.resolve(1);
+let p2 = Promise.resolve().then(() => 2);
+return Promise.race([p1, p2]).then(
+function onResolve(value) {
+do_check_eq(value, 1);
+}
+);
+}));
+// Test that passing only values (not promises) to Promise.race() works
+tests.push(
+make_promise_test(function race_resolve_no_promises(test) {
+try {
+Promise.race(null);
+do_check_true(false, "race() should only accept iterables");
+} catch (e) {
+do_check_true(true, "race() fails when first the arg is not an iterable");
+}
+return Promise.race([1, 2, 3]).then(
+function onResolve(value) {
+do_check_eq(value, 1);
+}
+);
+}));
+// Test that Promise.race() never resolves when passed an empty iterable
+tests.push(
+make_promise_test(function race_resolve_never(test) {
+return new Promise(resolve => {
+Promise.race([]).then(
+function onResolve() {
+do_throw("race() unexpectedly resolved");
+},
+function onReject() {
+do_throw("race() unexpectedly rejected");
+}
+);
+// Approximate "never" so we don't have to solve the halting problem.
+do_timeout(200, resolve);
+});
+}));
+// Test that Promise.race() handles non-array iterables.
+tests.push(
+make_promise_test(function race_iterable(test) {
+function* iterable() {
+yield 1;
+yield 2;
+yield 3;
+}
+return Promise.race(iterable()).then(
+function onResolve(value) {
+do_check_eq(value, 1);
+},
+function onReject() {
+do_throw("race() unexpectedly rejected");
+}
+);
+}));
+// Test that throwing from the iterable passed to Promise.race() rejects the
+// promise returned by Promise.race()
+tests.push(
+make_promise_test(function race_iterable_throws(test) {
+function* iterable() {
+throw 1;
+}
+return Promise.race(iterable()).then(
+function onResolve() {
+do_throw("race() unexpectedly resolved");
+},
+function onReject(reason) {
+do_check_eq(reason, 1, "race() rejects when the iterator throws");
+}
+);
+}));
+// Test that rejecting one of the promises passed to Promise.race() rejects the
+// promise returned by Promise.race()
+tests.push(
+make_promise_test(function race_reject(test) {
+let p1 = Promise.reject(1);
+let p2 = Promise.resolve(2);
+let p3 = Promise.resolve(3);
+return Promise.race([p1, p2, p3]).then(
+function onResolve() {
+do_throw("race() unexpectedly resolved");
+},
+function onReject(reason) {
+do_check_eq(reason, 1, "race() rejects when given a rejected promise");
+}
+);
+}));
+// Test behavior of the Promise constructor.
+tests.push(
+make_promise_test(function test_constructor(test) {
+try {
+new Promise(null);
+do_check_true(false, "Constructor should fail when not passed a function");
+} catch (e) {
+do_check_true(true, "Constructor fails when not passed a function");
+}
+let executorRan = false;
+let promise = new Promise(
+function executor(resolve, reject) {
+executorRan = true;
+do_check_eq(this, undefined);
+do_check_eq(typeof resolve, "function",
+"resolve function should be passed to the executor");
+do_check_eq(typeof reject, "function",
+"reject function should be passed to the executor");
+}
+);
+do_check_instanceof(promise, Promise);
+do_check_true(executorRan, "Executor should execute synchronously");
+// resolve a promise from the executor
+let resolvePromise = new Promise(
+function executor(resolve) {
+resolve(1);
+}
+).then(
+function onResolve(value) {
+do_check_eq(value, 1, "Executor resolved with correct value");
+},
+function onReject() {
+do_throw("Executor unexpectedly rejected");
+}
+);
+// reject a promise from the executor
+let rejectPromise = new Promise(
+function executor(_, reject) {
+reject(1);
+}
+).then(
+function onResolve() {
+do_throw("Executor unexpectedly resolved");
+},
+function onReject(reason) {
+do_check_eq(reason, 1, "Executor rejected with correct value");
+}
+);
+// throw from the executor, causing a rejection
+let throwPromise = new Promise(
+function executor() {
+throw 1;
+}
+).then(
+function onResolve() {
+do_throw("Throwing inside an executor should not resolve the promise");
+},
+function onReject(reason) {
+do_check_eq(reason, 1, "Executor rejected with correct value");
+}
+);
+return Promise.all([resolvePromise, rejectPromise, throwPromise]);
+}));
+// Test deadlock in Promise.jsm with nested event loops
+// The scenario being tested is:
+// promise_1.then({
+//   do some work that will asynchronously signal done
+//   start an event loop waiting for the done signal
+// }
+// where the async work uses resolution of a second promise to
+// trigger the "done" signal. While this would likely work in a
+// naive implementation, our constant-stack implementation needs
+// a special case to avoid deadlock. Note that this test is
+// sensitive to the implementation-dependent order in which then()
+// clauses for two different promises are executed, so it is
+// possible for other implementations to pass this test and still
+// have similar deadlocks.
+tests.push(
+make_promise_test(function promise_nested_eventloop_deadlock(test) {
+// Set up a (long enough to be noticeable) timeout to
+// exit the nested event loop and throw if the test run is hung
+let shouldExitNestedEventLoop = false;
+function event_loop() {
+let thr = Services.tm.mainThread;
+while(!shouldExitNestedEventLoop) {
+thr.processNextEvent(true);
+}
+}
+// I wish there was a way to cancel xpcshell do_timeout()s
+do_timeout(2000, () => {
+if (!shouldExitNestedEventLoop) {
+shouldExitNestedEventLoop = true;
+do_throw("Test timed out");
+}
+});
+let promise1 = Promise.resolve(1);
+let promise2 = Promise.resolve(2);
+do_print("Setting wait for first promise");
+promise1.then(value => {
+do_print("Starting event loop");
+event_loop();
+}, null);
+do_print("Setting wait for second promise");
+return promise2.catch(error => {return 3;})
+.then(
+count => {
+shouldExitNestedEventLoop = true;
+});
+}));
+function wait_for_uncaught(aMustAppear, aTimeout = undefined) {
+let remaining = new Set();
+for (let k of aMustAppear) {
+remaining.add(k);
+}
+let deferred = Promise.defer();
+let print = do_print;
+let execute_soon = do_execute_soon;
+let observer = function({message, stack}) {
+let data = message + stack;
+print("Observing " + message + ", looking for " + aMustAppear.join(", "));
+for (let expected of remaining) {
+if (data.indexOf(expected) != -1) {
+print("I found " + expected);
+remaining.delete(expected);
+}
+if (remaining.size == 0 && observer) {
+Promise.Debugging.removeUncaughtErrorObserver(observer);
+observer = null;
+deferred.resolve();
+}
+}
+};
+Promise.Debugging.addUncaughtErrorObserver(observer);
+if (aTimeout) {
+do_timeout(aTimeout, function timeout() {
+if (observer) {
+Promise.Debugging.removeUncaughtErrorObserver(observer);
+observer = null;
+}
+deferred.reject(new Error("Timeout"));
+});
+}
+return deferred.promise;
+}
+// Test that uncaught errors are reported as uncaught
+(function() {
+let make_string_rejection = function make_string_rejection() {
+let salt = (Math.random() * ( Math.pow(2, 24) - 1 ));
+let string = "This is an uncaught rejection " + salt;
+// Our error is not Error-like nor an nsIException, so the stack will
+// include the closure doing the actual rejection.
+return {mustFind: ["test_rejection_closure", string], error: string};
+};
+let make_num_rejection = function make_num_rejection() {
+let salt = (Math.random() * ( Math.pow(2, 24) - 1 ));
+// Our error is not Error-like nor an nsIException, so the stack will
+// include the closure doing the actual rejection.
+return {mustFind: ["test_rejection_closure", salt], error: salt};
+};
+let make_undefined_rejection = function make_undefined_rejection() {
+// Our error is not Error-like nor an nsIException, so the stack will
+// include the closure doing the actual rejection.
+return {mustFind: ["test_rejection_closure"], error: undefined};
+};
+let make_error_rejection = function make_error_rejection() {
+let salt = (Math.random() * ( Math.pow(2, 24) - 1 ));
+let error = new Error("This is an uncaught error " + salt);
+return {
+mustFind: [error.message, error.fileName, error.lineNumber, error.stack],
+error: error
+};
+};
+let make_exception_rejection = function make_exception_rejection() {
+let salt = (Math.random() * ( Math.pow(2, 24) - 1 ));
+let exn = new Components.Exception("This is an uncaught exception " + salt,
+Components.results.NS_ERROR_NOT_AVAILABLE);
+return {
+mustFind: [exn.message, exn.filename, exn.lineNumber, exn.location.toString()],
+error: exn
+};
+};
+for (let make_rejection of [make_string_rejection,
+make_num_rejection,
+make_undefined_rejection,
+make_error_rejection,
+make_exception_rejection]) {
+let {mustFind, error} = make_rejection();
+let name = make_rejection.name;
+tests.push(make_promise_test(function test_uncaught_is_reported() {
+do_print("Testing with rejection " + name);
+let promise = wait_for_uncaught(mustFind);
+(function test_rejection_closure() {
+// For the moment, we cannot be absolutely certain that a value is
+// garbage-collected, even if it is not referenced anymore, due to
+// the conservative stack-scanning algorithm.
+//
+// To be _almost_ certain that a value will be garbage-collected, we
+// 1. isolate that value in an anonymous closure;
+// 2. allocate 100 values instead of 1 (gc-ing a single value from
+//    these is sufficient for the test);
+// 3. place everything in a loop, as the JIT typically reuses memory;
+// 4. call all the GC methods we can.
+//
+// Unfortunately, we might still have intermittent failures,
+// materialized as timeouts.
+//
+for (let i = 0; i < 100; ++i) {
+Promise.reject(error);
+}
+})();
+do_print("Posted all rejections");
+Components.utils.forceGC();
+Components.utils.forceCC();
+Components.utils.forceShrinkingGC();
+return promise;
+}));
+}
+})();
+// Test that caught errors are not reported as uncaught
+tests.push(
+make_promise_test(function test_caught_is_not_reported() {
+let salt = (Math.random() * ( Math.pow(2, 24) - 1 ));
+let promise = wait_for_uncaught([salt], 500);
+(function() {
+let uncaught = Promise.reject("This error, on the other hand, is caught " + salt);
+uncaught.catch(function() { /* ignore rejection */});
+uncaught = null;
+})();
+// Isolate this in a function to increase likelihood that the gc will
+// realise that |uncaught| has remained uncaught.
+Components.utils.forceGC();
+return promise.then(function onSuccess() {
+throw new Error("This error was caught and should not have been reported");
+}, function onError() {
+do_print("The caught error was not reported, all is fine");
+}
+);
+}));
+function run_test()
+{
+do_test_pending();
+run_promise_tests(tests, do_test_finished);
+}