The Tor Browser: toolkit/modules/tests/xpcshell/test_Promise.js@6474c204b198 (annotated)

toolkit/modules/tests/xpcshell/test_Promise.js@6474c204b198 (annotated)

toolkit/modules/tests/xpcshell/test_Promise.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* 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);
 }