Source code
Revision control
Copy as Markdown
Other Tools
Test Info:
- Manifest: dom/promise/tests/mochitest.toml
<!--
Any copyright is dedicated to the Public Domain.
-->
<html>
<head>
<title>Basic Promise Test</title>
<script src="/tests/SimpleTest/SimpleTest.js"></script>
<link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css"/>
</head>
<body>
<p id="display"></p>
<div id="content" style="display: none">
</div>
<pre id="test">
<script type="application/javascript"><!--
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);
});
promise.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();
});
promise.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 promiseReject() {
var promise = new Promise(function(resolve, reject) {
reject(42);
});
promise.then(function() {
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 promiseRejectNoHandler() {
// This test only checks that the code that reports unhandled errors in the
// Promises implementation does not crash or leak.
new Promise(function() {
// eslint-disable-next-line no-undef
noSuchMethod();
});
runTest();
}
function promiseRejectNoArg() {
var promise = new Promise(function(resolve, reject) {
reject();
});
promise.then(function() {
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() {
// eslint-disable-next-line no-throw-literal
throw 42;
});
promise.then(function() {
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 promiseGC() {
var resolve;
var promise = new Promise(function(r1) {
resolve = r1;
});
promise.then(function() {
ok(true, "Then - promise is still alive");
runTest();
});
promise = null;
SpecialPowers.gc();
SpecialPowers.forceGC();
SpecialPowers.forceCC();
resolve(42);
}
function promiseAsync_TimeoutResolveThen() {
var handlerExecuted = false;
setTimeout(function() {
ok(handlerExecuted, "Handler should have been called before the timeout.");
// Allow other assertions to run so the test could fail before the next one.
setTimeout(runTest, 0);
}, 0);
Promise.resolve().then(function() {
handlerExecuted = true;
});
ok(!handlerExecuted, "Handlers are not called before 'then' returns.");
}
function promiseAsync_ResolveTimeoutThen() {
var handlerExecuted = false;
var promise = Promise.resolve();
setTimeout(function() {
ok(handlerExecuted, "Handler should have been called before the timeout.");
// Allow other assertions to run so the test could fail before the next one.
setTimeout(runTest, 0);
}, 0);
promise.then(function() {
handlerExecuted = true;
});
ok(!handlerExecuted, "Handlers are not called before 'then' returns.");
}
function promiseAsync_ResolveThenTimeout() {
var handlerExecuted = false;
Promise.resolve().then(function() {
handlerExecuted = true;
});
setTimeout(function() {
ok(handlerExecuted, "Handler should have been called before the timeout.");
// Allow other assertions to run so the test could fail before the next one.
setTimeout(runTest, 0);
}, 0);
ok(!handlerExecuted, "Handlers are not called before 'then' returns.");
}
function promiseAsync_SyncXHR() {
var handlerExecuted = false;
Promise.resolve().then(function() {
handlerExecuted = true;
// Allow other assertions to run so the test could fail before the next one.
setTimeout(runTest, 0);
});
ok(!handlerExecuted, "Handlers are not called until the next microtask.");
var xhr = new XMLHttpRequest();
xhr.open("GET", "testXHR.txt", false);
xhr.send(null);
ok(!handlerExecuted, "Sync XHR should not trigger microtask execution.");
}
function promiseDoubleThen() {
var steps = 0;
var promise = new Promise(function(r1) {
r1(42);
});
promise.then(function(what) {
ok(true, "Then.resolve has been called");
is(what, 42, "Value == 42");
steps++;
}, function() {
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() {
ok(false, "Then.reject has been called");
});
}
function promiseThenException() {
var promise = new Promise(function(resolve) {
resolve(42);
});
promise.then(function() {
ok(true, "Then.resolve has been called");
// eslint-disable-next-line no-throw-literal
throw "booh";
}).catch(function() {
ok(true, "window.onerror has been called!");
runTest();
});
}
function promiseThenCatchThen() {
var promise = new Promise(function(resolve) {
resolve(42);
});
var promise2 = promise.then(function(what) {
ok(true, "Then.resolve has been called");
is(what, 42, "Value == 42");
return what + 1;
}, function() {
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() {
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() {
ok(false, "Then.reject has been called");
});
}
function promiseThenNoArg() {
var promise = new Promise(function(resolve) {
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 promiseRejectThenCatchThen() {
var promise = new Promise(function(resolve, reject) {
reject(42);
});
var promise2 = promise.then(function() {
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() {
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() {
ok(false, "Then.resolve has been called");
}, function(what) {
ok(true, "Then.reject has been called");
is(what, 42, "Value == 42");
// eslint-disable-next-line no-throw-literal
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) {
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 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) {
resolve(new Promise(function(res) {
ok(true, "Nested promise is executed");
res(42);
}));
}).then(function(value) {
is(value, 42, "Nested promise is executed and then == 42");
runTest();
});
}
function promiseNestedNestedPromise() {
new Promise(function(resolve) {
resolve(new Promise(function(res) {
ok(true, "Nested promise is executed");
res(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) {
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() {
ok(false, "This is wrong");
});
}
function promiseLoop() {
new Promise(function(resolve) {
resolve(new Promise(function(res) {
ok(true, "Nested promise is executed");
res(new Promise(function(resInner) {
ok(true, "Nested nested promise is executed");
resInner(42);
}));
}));
}).then(function(value) {
is(value, 42, "Nested nested promise is executed and then == 42");
runTest();
}, function() {
ok(false, "This is wrong");
});
}
function promiseStaticReject() {
var promise = Promise.reject(42);
promise.then(function() {
ok(false, "This should not be called");
}, function(what) {
is(what, 42, "Value == 42");
runTest();
});
}
function promiseStaticResolve() {
var promise = Promise.resolve(42);
promise.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) {
ok(true, "Nested promise is executed");
r(42);
}, function() {
ok(false, "This should not be called");
}));
promise.then(function(what) {
is(what, 42, "Value == 42");
runTest();
}, function() {
ok(false, "This should not be called");
});
}
function promiseSimpleThenableResolve() {
var thenable = { then(resolve) { resolve(5); } };
var promise = new Promise(function(resolve) {
resolve(thenable);
});
promise.then(function(v) {
ok(v === 5, "promiseSimpleThenableResolve");
runTest();
}, function() {
ok(false, "promiseSimpleThenableResolve: Should not reject");
});
}
function promiseSimpleThenableReject() {
var thenable = { then(resolve, reject) { reject(5); } };
var promise = new Promise(function(resolve) {
resolve(thenable);
});
promise.then(function() {
ok(false, "promiseSimpleThenableReject: Should not resolve");
runTest();
}, function(e) {
ok(e === 5, "promiseSimpleThenableReject");
runTest();
});
}
function promiseThenableThrowsBeforeCallback() {
var thenable = { then(resolve) {
throw new TypeError("Hi there");
// eslint-disable-next-line no-unreachable
resolve(5);
}};
var promise = Promise.resolve(thenable);
promise.then(function() {
ok(false, "promiseThenableThrowsBeforeCallback: Should've rejected");
runTest();
}, function(e) {
ok(e instanceof TypeError, "promiseThenableThrowsBeforeCallback");
runTest();
});
}
function promiseThenableThrowsAfterCallback() {
var thenable = { then(resolve) {
resolve(5);
throw new TypeError("Hi there");
}};
var promise = Promise.resolve(thenable);
promise.then(function(v) {
ok(v === 5, "promiseThenableThrowsAfterCallback");
runTest();
}, function() {
ok(false, "promiseThenableThrowsAfterCallback: Should've resolved");
runTest();
});
}
function promiseThenableRejectThenResolve() {
var thenable = { then(resolve, reject) {
reject(new TypeError("Hi there"));
resolve(5);
}};
var promise = Promise.resolve(thenable);
promise.then(function() {
ok(false, "promiseThenableRejectThenResolve should have rejected");
runTest();
}, function(e) {
ok(e instanceof TypeError, "promiseThenableRejectThenResolve");
runTest();
});
}
function promiseWithThenReplaced() {
// Ensure that we call the 'then' on the promise and not the internal then.
var promise = new Promise(function(resolve) {
resolve(5);
});
// Rogue `then` always rejects.
promise.then = function(onFulfill, onReject) {
onReject(new TypeError("Foo"));
};
var promise2 = Promise.resolve(promise);
promise2.then(function() {
ok(false, "promiseWithThenReplaced: Should've rejected");
runTest();
}, function(e) {
ok(e instanceof TypeError, "promiseWithThenReplaced");
runTest();
});
}
function promiseStrictHandlers() {
var promise = Promise.resolve(5);
promise.then(function() {
"use strict";
ok(this === undefined, "Strict mode callback should have this === undefined.");
runTest();
});
}
function promiseStrictExecutorThisArg() {
new Promise(function() {
"use strict";
ok(this === undefined, "thisArg should be undefined.");
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(onFulfill) { onFulfill(2); } });
ok(p instanceof Promise, "Should cast to a Promise.");
p.then(function(v) {
is(v, 2, "Should resolve to 2.");
runTest();
}, function() {
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();
});
}
// Ensure that thenables are run on a clean stack asynchronously.
// Test case adopted from
function promiseResolveThenableCleanStack() {
function immed(s) { x++; s(); }
function incX() { x++; }
var x = 0;
var thenable = { then: immed };
var results = [];
var p = Promise.resolve(thenable).then(incX);
results.push(x);
// check what happens after all "next cycle" steps
// have had a chance to complete
setTimeout(function() {
// Result should be [0, 2] since `thenable` will be called async.
is(results[0], 0, "Expected thenable to be called asynchronously");
p.then(function() {
results.push(x);
is(results[1], 2, "Expected thenable to be called asynchronously");
runTest();
});
}, 1000);
}
// The bug was that the callbacks passed to a thenable would resolve the
// promise synchronously when the fulfill handler returned a non-thenable.
//
// For example:
// var p = new Promise(function(resolve) {
// resolve(5);
// });
// var m = Promise.resolve(p);
//
// At this point `m` is a Promise that is resolved with a thenable `p`, so it
// calls `p.then()` with two callbacks, both of which would synchronously resolve
// `m` when `p` invoked them (on account of itself being resolved, possibly
// synchronously. A chain of these 'Promise resolved by a Promise' would lead to
// stack overflow.
function promiseTestAsyncThenableResolution() {
var k = 3000;
Promise.resolve().then(function next() {
k--;
if (k > 0) return Promise.resolve().then(next);
return undefined;
}).then(function() {
ok(true, "Resolution of a chain of thenables should not be synchronous.");
runTest();
});
}
function promiseWrapperAsyncResolution() {
var p = new Promise(function(resolve) {
resolve();
});
var results = [];
var q = p.then(function() {
results.push("1-1");
}).then(function() {
results.push("1-2");
}).then(function() {
results.push("1-3");
});
var r = p.then(function() {
results.push("2-1");
}).then(function() {
results.push("2-2");
}).then(function() {
results.push("2-3");
});
Promise.all([q, r]).then(function() {
var match = results[0] == "1-1" &&
results[1] == "2-1" &&
results[2] == "1-2" &&
results[3] == "2-2" &&
results[4] == "1-3" &&
results[5] == "2-3";
info(results);
ok(match, "Chained promises should resolve asynchronously.");
runTest();
}, function() {
ok(false, "promiseWrapperAsyncResolution: One of the promises failed.");
runTest();
});
}
var tests = [ promiseResolve, promiseReject,
promiseException, promiseGC,
promiseAsync_TimeoutResolveThen,
promiseAsync_ResolveTimeoutThen,
promiseAsync_ResolveThenTimeout,
promiseAsync_SyncXHR,
promiseDoubleThen, promiseThenException,
promiseThenCatchThen, promiseRejectThenCatchThen,
promiseRejectThenCatchThen2,
promiseRejectThenCatchExceptionThen,
promiseThenCatchOrderingResolve,
promiseThenCatchOrderingReject,
promiseNestedPromise, promiseNestedNestedPromise,
promiseWrongNestedPromise, promiseLoop,
promiseStaticReject, promiseStaticResolve,
promiseResolveNestedPromise,
promiseResolveNoArg,
promiseRejectNoArg,
promiseThenNoArg,
promiseThenUndefinedResolveFunction,
promiseThenNullResolveFunction,
promiseCatchNoArg,
promiseRejectNoHandler,
promiseSimpleThenableResolve,
promiseSimpleThenableReject,
promiseThenableThrowsBeforeCallback,
promiseThenableThrowsAfterCallback,
promiseThenableRejectThenResolve,
promiseWithThenReplaced,
promiseStrictHandlers,
promiseStrictExecutorThisArg,
promiseResolveArray,
promiseResolveThenable,
promiseResolvePromise,
promiseResolveThenableCleanStack,
promiseTestAsyncThenableResolution,
promiseWrapperAsyncResolution,
];
function runTest() {
if (!tests.length) {
SimpleTest.finish();
return;
}
var test = tests.shift();
test();
}
SimpleTest.waitForExplicitFinish();
SimpleTest.requestFlakyTimeout("untriaged");
runTest();
// -->
</script>
</pre>
</body>
</html>