gecko/dom/promise/tests/test_promise_utils.html

320 lines
8.6 KiB
HTML

<!--
Any copyright is dedicated to the Public Domain.
http://creativecommons.org/publicdomain/zero/1.0/
-->
<html>
<head>
<title>Test for Promise.all, Promise.race</title>
<script type="application/javascript" 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 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 promiseAllEmptyArray() {
var p = Promise.all([]);
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, 0, "Resolved array length should match iterable's length.");
runTest();
}, function() {
ok(false, "Promise.all shouldn't fail when iterable has no rejected Promises.");
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 promiseAllIterable() {
function* promiseGen() {
var i = 3;
while (--i) {
yield Promise.resolve(i);
}
yield new Promise(function(resolve) {
setTimeout(resolve, 10);
});
}
Promise.all(promiseGen()).then(function(values) {
is(values.length, 3, "Resolved array length should match iterable's length.");
is(values[0], 2, "Array values should match.");
is(values[1], 1, "Array values should match.");
is(values[2], undefined, "Array values should match.");
runTest();
}, function(e) {
ok(false, "Promise.all shouldn't fail when an iterable is passed.");
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 promiseAllCastError() {
var p = Promise.all([Promise.resolve(2), { then: function() { foo(); } }]);
ok(p instanceof Promise, "Should cast to a Promise.");
p.then(function(v) {
ok(false, "promiseAllCastError: should've rejected.");
runTest();
}, function(e) {
ok(e instanceof ReferenceError, "promiseCastThenableError");
runTest();
});
}
// Check that the resolved array is enumerable.
function promiseAllEnumerable() {
var p = Promise.all([1, new Date(), Promise.resolve("firefox")]);
p.then(function(v) {
var count = 0;
for (key in v) {
++count;
ok(v[key] === 1 || v[key] instanceof Date || v[key] === "firefox",
"Enumerated properties don't match.");
}
is(count, 3, "Resolved array from Promise.all should be enumerable");
runTest();
}, function(e) {
ok(false, "promiseAllEnumerable: should've resolved.");
runTest();
});
}
function promiseRaceEmpty() {
var p = Promise.race([]);
ok(p instanceof Promise, "Should return a Promise.");
p.then(function() {
ok(false, "Should not resolve");
}, function() {
ok(false, "Should not reject");
});
// Per spec, An empty race never resolves or rejects.
setTimeout(function() {
ok(true);
runTest();
}, 50);
}
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() {
function timeoutPromise(n) {
return new Promise(function(resolve) {
setTimeout(function() {
resolve(n);
}, n);
});
}
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 promiseRaceIterable() {
function* participants() {
yield new Promise(function(resolve) {
setTimeout(resolve, 10, 10);
});
yield new Promise(function(resolve) {
setTimeout(resolve, 20, 20);
});
}
Promise.race(participants()).then(function(winner) {
is(winner, 10, "Winner should be the one that finished earlier.");
runTest();
}, function(e) {
ok(false, "Promise.race shouldn't throw when an iterable is passed!");
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();
});
}
var tests = [
promiseUtilitiesDefined,
promiseAllEmptyArray,
promiseAllArray,
promiseAllIterable,
promiseAllWaitsForAllPromises,
promiseAllRejectFails,
promiseAllCastError,
promiseAllEnumerable,
promiseRaceEmpty,
promiseRaceValuesArray,
promiseRacePromiseArray,
promiseRaceIterable,
promiseRaceReject,
promiseRaceThrow,
];
function runTest() {
if (!tests.length) {
SimpleTest.finish();
return;
}
var test = tests.shift();
test();
}
SimpleTest.waitForExplicitFinish();
runTest();
// -->
</script>
</pre>
</body>
</html>