The Tor Browser: dom/workers/test/promise_worker.js@925c144e1f1f (annotated)

dom/workers/test/promise_worker.js@925c144e1f1f (annotated)

dom/workers/test/promise_worker.js

Fri, 16 Jan 2015 18:13:44 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Fri, 16 Jan 2015 18:13:44 +0100
branch: TOR_BUG_9701
changeset 14: 925c144e1f1f
permissions: -rw-r--r--

Integrate suggestion from review to improve consistency with existing code.

 function ok(a, msg) {
   dump("OK: " + !!a + "  =>  " + a + " " + msg + "\n");
   postMessage({type: 'status', status: !!a, msg: a + ": " + msg });
 }
 function is(a, b, msg) {
   dump("IS: " + (a===b) + "  =>  " + a + " | " + b + " " + msg + "\n");
   postMessage({type: 'status', status: a === b, msg: a + " === " + b + ": " + msg });
 }
 function isnot(a, b, msg) {
   dump("ISNOT: " + (a!==b) + "  =>  " + a + " | " + b + " " + msg + "\n");
   postMessage({type: 'status', status: a !== b, msg: a + " !== " + b + ": " + msg });
 }
 function promiseResolve() {
   ok(Promise, "Promise object should exist");
   var promise = new Promise(function(resolve, reject) {
     ok(resolve, "Promise.resolve exists");
     ok(reject, "Promise.reject exists");
     resolve(42);
   }).then(function(what) {
     ok(true, "Then - resolveCb has been called");
     is(what, 42, "ResolveCb received 42");
     runTest();
   }, function() {
     ok(false, "Then - rejectCb has been called");
     runTest();
   });
 }
 function promiseResolveNoArg() {
   var promise = new Promise(function(resolve, reject) {
     ok(resolve, "Promise.resolve exists");
     ok(reject, "Promise.reject exists");
     resolve();
   }).then(function(what) {
     ok(true, "Then - resolveCb has been called");
     is(what, undefined, "ResolveCb received undefined");
     runTest();
   }, function() {
     ok(false, "Then - rejectCb has been called");
     runTest();
   });
 }
 function promiseRejectNoHandler() {
   // This test only checks that the code that reports unhandled errors in the
   // Promises implementation does not crash or leak.
   var promise = new Promise(function(res, rej) {
     noSuchMethod();
   });
   runTest();
 }
 function promiseReject() {
   var promise = new Promise(function(resolve, reject) {
     reject(42);
   }).then(function(what) {
     ok(false, "Then - resolveCb has been called");
     runTest();
   }, function(what) {
     ok(true, "Then - rejectCb has been called");
     is(what, 42, "RejectCb received 42");
     runTest();
   });
 }
 function promiseRejectNoArg() {
   var promise = new Promise(function(resolve, reject) {
     reject();
   }).then(function(what) {
     ok(false, "Then - resolveCb has been called");
     runTest();
   }, function(what) {
     ok(true, "Then - rejectCb has been called");
     is(what, undefined, "RejectCb received undefined");
     runTest();
   });
 }
 function promiseException() {
   var promise = new Promise(function(resolve, reject) {
     throw 42;
   }).then(function(what) {
     ok(false, "Then - resolveCb has been called");
     runTest();
   }, function(what) {
     ok(true, "Then - rejectCb has been called");
     is(what, 42, "RejectCb received 42");
     runTest();
   });
 }
 function promiseAsync() {
   var global = "foo";
   var f = new Promise(function(r1, r2) {
     is(global, "foo", "Global should be foo");
     r1(42);
     is(global, "foo", "Global should still be foo");
     setTimeout(function() {
       is(global, "bar", "Global should still be bar!");
       runTest();
     }, 0);
   }).then(function() {
     global = "bar";
   });
   is(global, "foo", "Global should still be foo (2)");
 }
 function promiseDoubleThen() {
   var steps = 0;
   var promise = new Promise(function(r1, r2) {
     r1(42);
   });
   promise.then(function(what) {
     ok(true, "Then.resolve has been called");
     is(what, 42, "Value == 42");
     steps++;
   }, function(what) {
     ok(false, "Then.reject has been called");
   });
   promise.then(function(what) {
     ok(true, "Then.resolve has been called");
     is(steps, 1, "Then.resolve - step == 1");
     is(what, 42, "Value == 42");
     runTest();
   }, function(what) {
     ok(false, "Then.reject has been called");
   });
 }
 function promiseThenException() {
   var promise = new Promise(function(resolve, reject) {
     resolve(42);
   });
   promise.then(function(what) {
     ok(true, "Then.resolve has been called");
     throw "booh";
   }).catch(function(e) {
     ok(true, "Catch has been called!");
     runTest();
   });
 }
 function promiseThenCatchThen() {
   var promise = new Promise(function(resolve, reject) {
     resolve(42);
   });
   var promise2 = promise.then(function(what) {
     ok(true, "Then.resolve has been called");
     is(what, 42, "Value == 42");
     return what + 1;
   }, function(what) {
     ok(false, "Then.reject has been called");
   });
   isnot(promise, promise2, "These 2 promise objs are different");
   promise2.then(function(what) {
     ok(true, "Then.resolve has been called");
     is(what, 43, "Value == 43");
     return what + 1;
   }, function(what) {
     ok(false, "Then.reject has been called");
   }).catch(function() {
     ok(false, "Catch has been called");
   }).then(function(what) {
     ok(true, "Then.resolve has been called");
     is(what, 44, "Value == 44");
     runTest();
   }, function(what) {
     ok(false, "Then.reject has been called");
   });
 }
 function promiseRejectThenCatchThen() {
   var promise = new Promise(function(resolve, reject) {
     reject(42);
   });
   var promise2 = promise.then(function(what) {
     ok(false, "Then.resolve has been called");
   }, function(what) {
     ok(true, "Then.reject has been called");
     is(what, 42, "Value == 42");
     return what + 1;
   });
   isnot(promise, promise2, "These 2 promise objs are different");
   promise2.then(function(what) {
     ok(true, "Then.resolve has been called");
     is(what, 43, "Value == 43");
     return what+1;
   }).catch(function(what) {
     ok(false, "Catch has been called");
   }).then(function(what) {
     ok(true, "Then.resolve has been called");
     is(what, 44, "Value == 44");
     runTest();
   });
 }
 function promiseRejectThenCatchThen2() {
   var promise = new Promise(function(resolve, reject) {
     reject(42);
   });
   promise.then(function(what) {
     ok(true, "Then.resolve has been called");
     is(what, 42, "Value == 42");
     return what+1;
   }).catch(function(what) {
     is(what, 42, "Value == 42");
     ok(true, "Catch has been called");
     return what+1;
   }).then(function(what) {
     ok(true, "Then.resolve has been called");
     is(what, 43, "Value == 43");
     runTest();
   });
 }
 function promiseRejectThenCatchExceptionThen() {
   var promise = new Promise(function(resolve, reject) {
     reject(42);
   });
   promise.then(function(what) {
     ok(false, "Then.resolve has been called");
   }, function(what) {
     ok(true, "Then.reject has been called");
     is(what, 42, "Value == 42");
     throw(what + 1);
   }).catch(function(what) {
     ok(true, "Catch has been called");
     is(what, 43, "Value == 43");
     return what + 1;
   }).then(function(what) {
     ok(true, "Then.resolve has been called");
     is(what, 44, "Value == 44");
     runTest();
   });
 }
 function promiseThenCatchOrderingResolve() {
   var global = 0;
   var f = new Promise(function(r1, r2) {
     r1(42);
   });
   f.then(function() {
     f.then(function() {
       global++;
     });
     f.catch(function() {
       global++;
     });
     f.then(function() {
       global++;
     });
     setTimeout(function() {
       is(global, 2, "Many steps... should return 2");
       runTest();
     }, 0);
   });
 }
 function promiseThenCatchOrderingReject() {
   var global = 0;
   var f = new Promise(function(r1, r2) {
     r2(42);
   })
   f.then(function() {}, function() {
     f.then(function() {
       global++;
     });
     f.catch(function() {
       global++;
     });
     f.then(function() {}, function() {
       global++;
     });
     setTimeout(function() {
       is(global, 2, "Many steps... should return 2");
       runTest();
     }, 0);
   });
 }
 function promiseThenNoArg() {
   var promise = new Promise(function(resolve, reject) {
     resolve(42);
   });
   var clone = promise.then();
   isnot(promise, clone, "These 2 promise objs are different");
   promise.then(function(v) {
     clone.then(function(cv) {
       is(v, cv, "Both resolve to the same value");
       runTest();
     });
   });
 }
 function promiseThenUndefinedResolveFunction() {
   var promise = new Promise(function(resolve, reject) {
     reject(42);
   });
   try {
     promise.then(undefined, function(v) {
       is(v, 42, "Promise rejected with 42");
       runTest();
     });
   } catch (e) {
     ok(false, "then should not throw on undefined resolve function");
   }
 }
 function promiseThenNullResolveFunction() {
   var promise = new Promise(function(resolve, reject) {
     reject(42);
   });
   try {
     promise.then(null, function(v) {
       is(v, 42, "Promise rejected with 42");
       runTest();
     });
   } catch (e) {
     ok(false, "then should not throw on null resolve function");
   }
 }
 function promiseCatchNoArg() {
   var promise = new Promise(function(resolve, reject) {
     reject(42);
   });
   var clone = promise.catch();
   isnot(promise, clone, "These 2 promise objs are different");
   promise.catch(function(v) {
     clone.catch(function(cv) {
       is(v, cv, "Both reject to the same value");
       runTest();
     });
   });
 }
 function promiseNestedPromise() {
   new Promise(function(resolve, reject) {
     resolve(new Promise(function(resolve, reject) {
       ok(true, "Nested promise is executed");
       resolve(42);
     }));
   }).then(function(value) {
     is(value, 42, "Nested promise is executed and then == 42");
     runTest();
   });
 }
 function promiseNestedNestedPromise() {
   new Promise(function(resolve, reject) {
     resolve(new Promise(function(resolve, reject) {
       ok(true, "Nested promise is executed");
       resolve(42);
     }).then(function(what) { return what+1; }));
   }).then(function(value) {
     is(value, 43, "Nested promise is executed and then == 43");
     runTest();
   });
 }
 function promiseWrongNestedPromise() {
   new Promise(function(resolve, reject) {
     resolve(new Promise(function(r, r2) {
       ok(true, "Nested promise is executed");
       r(42);
     }));
     reject(42);
   }).then(function(value) {
     is(value, 42, "Nested promise is executed and then == 42");
     runTest();
   }, function(value) {
      ok(false, "This is wrong");
   });
 }
 function promiseLoop() {
   new Promise(function(resolve, reject) {
     resolve(new Promise(function(r1, r2) {
       ok(true, "Nested promise is executed");
       r1(new Promise(function(r1, r2) {
         ok(true, "Nested nested promise is executed");
         r1(42);
       }));
     }));
   }).then(function(value) {
     is(value, 42, "Nested nested promise is executed and then == 42");
     runTest();
   }, function(value) {
      ok(false, "This is wrong");
   });
 }
 function promiseStaticReject() {
   var promise = Promise.reject(42).then(function(what) {
     ok(false, "This should not be called");
   }, function(what) {
     is(what, 42, "Value == 42");
     runTest();
   });
 }
 function promiseStaticResolve() {
   var promise = Promise.resolve(42).then(function(what) {
     is(what, 42, "Value == 42");
     runTest();
   }, function() {
     ok(false, "This should not be called");
   });
 }
 function promiseResolveNestedPromise() {
   var promise = Promise.resolve(new Promise(function(r, r2) {
     ok(true, "Nested promise is executed");
     r(42);
   }, function() {
     ok(false, "This should not be called");
   })).then(function(what) {
     is(what, 42, "Value == 42");
     runTest();
   }, function() {
     ok(false, "This should not be called");
   });
 }
 function promiseRejectNoHandler() {
   // This test only checks that the code that reports unhandled errors in the
   // Promises implementation does not crash or leak.
   var promise = new Promise(function(res, rej) {
     noSuchMethod();
   });
   runTest();
 }
 function promiseUtilitiesDefined() {
   ok(Promise.all, "Promise.all must be defined when Promise is enabled.");
   ok(Promise.race, "Promise.race must be defined when Promise is enabled.");
   runTest();
 }
 function promiseAllArray() {
   var p = Promise.all([1, new Date(), Promise.resolve("firefox")]);
   ok(p instanceof Promise, "Return value of Promise.all should be a Promise.");
   p.then(function(values) {
     ok(Array.isArray(values), "Resolved value should be an array.");
     is(values.length, 3, "Resolved array length should match iterable's length.");
     is(values[0], 1, "Array values should match.");
     ok(values[1] instanceof Date, "Array values should match.");
     is(values[2], "firefox", "Array values should match.");
     runTest();
   }, function() {
     ok(false, "Promise.all shouldn't fail when iterable has no rejected Promises.");
     runTest();
   });
 }
 function promiseAllWaitsForAllPromises() {
   var arr = [
     new Promise(function(resolve) {
       setTimeout(resolve.bind(undefined, 1), 50);
     }),
     new Promise(function(resolve) {
       setTimeout(resolve.bind(undefined, 2), 10);
     }),
     new Promise(function(resolve) {
       setTimeout(resolve.bind(undefined, new Promise(function(resolve2) {
         resolve2(3);
       })), 10);
     }),
     new Promise(function(resolve) {
       setTimeout(resolve.bind(undefined, 4), 20);
     })
   ];
   var p = Promise.all(arr);
   p.then(function(values) {
     ok(Array.isArray(values), "Resolved value should be an array.");
     is(values.length, 4, "Resolved array length should match iterable's length.");
     is(values[0], 1, "Array values should match.");
     is(values[1], 2, "Array values should match.");
     is(values[2], 3, "Array values should match.");
     is(values[3], 4, "Array values should match.");
     runTest();
   }, function() {
     ok(false, "Promise.all shouldn't fail when iterable has no rejected Promises.");
     runTest();
   });
 }
 function promiseAllRejectFails() {
   var arr = [
     new Promise(function(resolve) {
       setTimeout(resolve.bind(undefined, 1), 50);
     }),
     new Promise(function(resolve, reject) {
       setTimeout(reject.bind(undefined, 2), 10);
     }),
     new Promise(function(resolve) {
       setTimeout(resolve.bind(undefined, 3), 10);
     }),
     new Promise(function(resolve) {
       setTimeout(resolve.bind(undefined, 4), 20);
     })
   ];
   var p = Promise.all(arr);
   p.then(function(values) {
     ok(false, "Promise.all shouldn't resolve when iterable has rejected Promises.");
     runTest();
   }, function(e) {
     ok(true, "Promise.all should reject when iterable has rejected Promises.");
     is(e, 2, "Rejection value should match.");
     runTest();
   });
 }
 function promiseRaceEmpty() {
   var p = Promise.race([]);
   ok(p instanceof Promise, "Should return a Promise.");
   // An empty race never resolves!
   runTest();
 }
 function promiseRaceValuesArray() {
   var p = Promise.race([true, new Date(), 3]);
   ok(p instanceof Promise, "Should return a Promise.");
   p.then(function(winner) {
     is(winner, true, "First value should win.");
     runTest();
   }, function(err) {
     ok(false, "Should not fail " + err + ".");
     runTest();
   });
 }
 function promiseRacePromiseArray() {
   var arr = [
     new Promise(function(resolve) {
       resolve("first");
     }),
     Promise.resolve("second"),
     new Promise(function() {}),
     new Promise(function(resolve) {
       setTimeout(function() {
         setTimeout(function() {
           resolve("fourth");
         }, 0);
       }, 0);
     }),
   ];
   var p = Promise.race(arr);
   p.then(function(winner) {
     is(winner, "first", "First queued resolution should win the race.");
     runTest();
   });
 }
 function promiseRaceReject() {
   var p = Promise.race([
     Promise.reject(new Error("Fail bad!")),
     new Promise(function(resolve) {
       setTimeout(resolve, 0);
     })
   ]);
   p.then(function() {
     ok(false, "Should not resolve when winning Promise rejected.");
     runTest();
   }, function(e) {
     ok(true, "Should be rejected");
     ok(e instanceof Error, "Should reject with Error.");
     ok(e.message == "Fail bad!", "Message should match.");
     runTest();
   });
 }
 function promiseRaceThrow() {
   var p = Promise.race([
     new Promise(function(resolve) {
       nonExistent();
     }),
     new Promise(function(resolve) {
       setTimeout(resolve, 0);
     })
   ]);
   p.then(function() {
     ok(false, "Should not resolve when winning Promise had an error.");
     runTest();
   }, function(e) {
     ok(true, "Should be rejected");
     ok(e instanceof ReferenceError, "Should reject with ReferenceError for function nonExistent().");
     runTest();
   });
 }
 function promiseResolveArray() {
   var p = Promise.resolve([1,2,3]);
   ok(p instanceof Promise, "Should return a Promise.");
   p.then(function(v) {
     ok(Array.isArray(v), "Resolved value should be an Array");
     is(v.length, 3, "Length should match");
     is(v[0], 1, "Resolved value should match original");
     is(v[1], 2, "Resolved value should match original");
     is(v[2], 3, "Resolved value should match original");
     runTest();
   });
 }
 function promiseResolveThenable() {
   var p = Promise.resolve({ then: function(onFulfill, onReject) { onFulfill(2); } });
   ok(p instanceof Promise, "Should cast to a Promise.");
   p.then(function(v) {
     is(v, 2, "Should resolve to 2.");
     runTest();
   }, function(e) {
     ok(false, "promiseResolveThenable should've resolved");
     runTest();
   });
 }
 function promiseResolvePromise() {
   var original = Promise.resolve(true);
   var cast = Promise.resolve(original);
   ok(cast instanceof Promise, "Should cast to a Promise.");
   is(cast, original, "Should return original Promise.");
   cast.then(function(v) {
     is(v, true, "Should resolve to true.");
     runTest();
   });
 }
 var tests = [
     promiseResolve,
     promiseReject,
     promiseException,
     promiseAsync,
     promiseDoubleThen,
     promiseThenException,
     promiseThenCatchThen,
     promiseRejectThenCatchThen,
     promiseRejectThenCatchThen2,
     promiseRejectThenCatchExceptionThen,
     promiseThenCatchOrderingResolve,
     promiseThenCatchOrderingReject,
     promiseNestedPromise,
     promiseNestedNestedPromise,
     promiseWrongNestedPromise,
     promiseLoop,
     promiseStaticReject,
     promiseStaticResolve,
     promiseResolveNestedPromise,
     promiseResolveNoArg,
     promiseRejectNoArg,
     promiseThenNoArg,
     promiseThenUndefinedResolveFunction,
     promiseThenNullResolveFunction,
     promiseCatchNoArg,
     promiseRejectNoHandler,
     promiseUtilitiesDefined,
     promiseAllArray,
     promiseAllWaitsForAllPromises,
     promiseAllRejectFails,
     promiseRaceEmpty,
     promiseRaceValuesArray,
     promiseRacePromiseArray,
     promiseRaceReject,
     promiseRaceThrow,
     promiseResolveArray,
     promiseResolveThenable,
     promiseResolvePromise,
 ];
 function runTest() {
   if (!tests.length) {
     postMessage({ type: 'finish' });
     return;
   }
   var test = tests.shift();
   test();
 }
 onmessage = function() {
   runTest();
 }