The Tor Browser: comparison dom/workers/test/promise_worker.js

comparison: dom/workers/test/promise_worker.js

dom/workers/test/promise_worker.js

branch: TOR_BUG_9701
changeset 15: b8a032363ba2

equal deleted inserted replaced

--1:000000000000
+:c23aad3e21ac
+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();
+}