summaryrefslogtreecommitdiffstats
path: root/dom/bindings/test/test_async_iterable.html
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-19 00:47:55 +0000
commit26a029d407be480d791972afb5975cf62c9360a6 (patch)
treef435a8308119effd964b339f76abb83a57c29483 /dom/bindings/test/test_async_iterable.html
parentInitial commit. (diff)
downloadfirefox-upstream/124.0.1.tar.xz
firefox-upstream/124.0.1.zip
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/bindings/test/test_async_iterable.html')
-rw-r--r--dom/bindings/test/test_async_iterable.html300
1 files changed, 300 insertions, 0 deletions
diff --git a/dom/bindings/test/test_async_iterable.html b/dom/bindings/test/test_async_iterable.html
new file mode 100644
index 0000000000..8f1f04aea7
--- /dev/null
+++ b/dom/bindings/test/test_async_iterable.html
@@ -0,0 +1,300 @@
+<!-- Any copyright is dedicated to the Public Domain.
+- http://creativecommons.org/publicdomain/zero/1.0/ -->
+<!DOCTYPE HTML>
+<html>
+ <head>
+ <title>Test Async Iterable Interface</title>
+ <script src="/tests/SimpleTest/SimpleTest.js"></script>
+ <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+ </head>
+ <body>
+ <script class="testbody" type="application/javascript">
+
+add_task(async function init() {
+ await SpecialPowers.pushPrefEnv({set: [["dom.expose_test_interfaces", true]]});
+});
+
+const singleValues = Array(10).fill(0).map((_, i) => i * 9 % 7);
+
+async function check_single_result_values(values, multiplier = 1) {
+ is(values.length, 10, `AsyncIterableSingle: should return 10 elements`);
+ for (let i = 0; i < 10; i++) {
+ let expected = singleValues[i] * multiplier;
+ is(values[i], expected,
+ `AsyncIterableSingle: should be ${expected}, get ${values[i]}`);
+ }
+}
+
+async function check_single_result(itr, multiplier = 1) {
+ let values = [];
+ for await (let v of itr) {
+ values.push(v);
+ }
+ check_single_result_values(values, multiplier);
+}
+
+async function test_data_single() {
+ info(`AsyncIterableSingle: Testing simple iterable creation and functionality`);
+
+ // eslint-disable-next-line no-undef
+ let itr = new TestInterfaceAsyncIterableSingle({ failToInit: true });
+ let initFailed = false;
+ try {
+ itr.values();
+ } catch (e) {
+ initFailed = true;
+ }
+ ok(initFailed,
+ "AsyncIterableSingle: A failure in asynchronous iterator initialization " +
+ "steps should propagate to the caller of the asynchronous iterator's " +
+ "constructor.");
+
+ // eslint-disable-next-line no-undef
+ itr = new TestInterfaceAsyncIterableSingle();
+ is(itr.values, itr[Symbol.asyncIterator],
+ `AsyncIterableSingle: Should be using @@asyncIterator for 'values'`);
+
+ await check_single_result(itr);
+ await check_single_result(itr.values());
+
+ // eslint-disable-next-line no-undef
+ itr = new TestInterfaceAsyncIterableSingleWithArgs();
+ is(itr.values, itr[Symbol.asyncIterator],
+ `AsyncIterableSingleWithArgs: Should be using @@asyncIterator for 'values'`);
+
+ await check_single_result(itr, 1);
+ await check_single_result(itr.values({ multiplier: 2 }), 2);
+
+ // eslint-disable-next-line no-undef
+ itr = new TestInterfaceAsyncIterableSingle();
+ let itrValues = itr.values();
+ let values = [];
+ for (let i = 0; i < 10; ++i) {
+ values.push(itrValues.next());
+ }
+ check_single_result_values(await Promise.all(values).then(v => v.map(w => w.value)));
+
+ // Test that there is only one ongoing promise at a time.
+ // Async iterables return a promise that is then resolved with the iterator
+ // value. We create an array of unresolved promises here, one promise for
+ // every result that we expect from the iterator. We pass that array of
+ // promises to the .value() method of the
+ // TestInterfaceAsyncIterableSingleWithArgs, and it will chain the resolving
+ // of each resulting iterator value on the corresponding promise from this
+ // array. We then resolve the promises in the array one by one in reverse
+ // order. This tries to make sure that the iterator always resolves the
+ // promises in the order of iteration.
+ let unblockers = [];
+ let blockingPromises = [];
+ for (let i = 0; i < 10; ++i) {
+ let unblocker;
+ let promise = new Promise((resolve, reject) => {
+ unblocker = resolve;
+ });
+ unblockers.push(unblocker);
+ blockingPromises.push(promise);
+ }
+
+ // eslint-disable-next-line no-undef
+ itr = new TestInterfaceAsyncIterableSingleWithArgs();
+ itrValues = itr.values({ blockingPromises });
+ values = [];
+ for (let i = 0; i < 10; ++i) {
+ values.push(itrValues.next());
+ }
+ unblockers.reverse();
+ for (let unblocker of unblockers) {
+ unblocker();
+ }
+
+ check_single_result_values(await Promise.all(values).then(v => v.map(w => w.value)));
+
+ // eslint-disable-next-line no-undef
+ itr = new TestInterfaceAsyncIterableSingleWithArgs();
+
+ let callCount = itr.returnCallCount;
+
+ let i = 0;
+ for await (let v of itr) {
+ if (++i > 1) {
+ break;
+ }
+ values.push(v);
+ }
+
+ is(itr.returnCallCount, callCount + 1,
+ `AsyncIterableSingle: breaking out of for-await-of loop should call "return"`);
+ is(itr.returnLastCalledWith, undefined,
+ `AsyncIterableSingleWithArgs: the asynchronous iterator return algorithm should be called with the argument that was passed in.`);
+
+ // eslint-disable-next-line no-undef
+ itr = new TestInterfaceAsyncIterableSingleWithArgs();
+
+ async function * yieldFromIterator () {
+ yield * itr
+ }
+
+ let yieldingIterator = yieldFromIterator();
+
+ let result = await yieldingIterator.next();
+ is(result.value, singleValues[0],
+ `AsyncIterableSingle: should be ${singleValues[0]}, get ${result.value}`);
+ result = await yieldingIterator.next();
+ is(result.value, singleValues[1],
+ `AsyncIterableSingle: should be ${singleValues[1]}, get ${result.value}`);
+
+ result = await yieldingIterator.return("abcd");
+ is(typeof result, "object",
+ `AsyncIterableSingleWithArgs: "return("abcd")" should return { done: true, value: "abcd" }`);
+ is(result.done, true,
+ `AsyncIterableSingleWithArgs: "return("abcd")" should return { done: true, value: "abcd" }`);
+ is(result.value, "abcd",
+ `AsyncIterableSingleWithArgs: "return("abcd")" should return { done: true, value: "abcd" }`);
+ is(itr.returnLastCalledWith, "abcd",
+ `AsyncIterableSingleWithArgs: the asynchronous iterator return algorithm should be called with the argument that was passed in.`);
+
+ result = await yieldingIterator.return("efgh");
+ is(typeof result, "object",
+ `AsyncIterableSingleWithArgs: "return("efgh")" should return { done: true, value: "efgh" }`);
+ is(result.done, true,
+ `AsyncIterableSingleWithArgs: "return("efgh")" should return { done: true, value: "efgh" }`);
+ is(result.value, "efgh",
+ `AsyncIterableSingleWithArgs: "return("efgh")" should return { done: true, value: "efgh" }`);
+ is(itr.returnLastCalledWith, "abcd",
+ `AsyncIterableSingleWithArgs: the asynchronous iterator return algorithm shouldn't be called if the iterator's 'is finished' flag is true already.`);
+
+ // eslint-disable-next-line no-undef
+ itr = new TestInterfaceAsyncIterableSingleWithArgs();
+ itrValues = itr.values({ failNextAfter: 1 });
+ await itrValues.next().then(({ value, done }) => {
+ is(value, singleValues[0], "First value is correct");
+ ok(!done, "Expecting more values");
+ return itrValues.next();
+ }).then(() => {
+ ok(false, "Second call to next() should convert failure to a rejected promise.");
+ return itrValues.next();
+ }).catch(() => {
+ ok(true, "Second call to next() should convert failure to a rejected promise.");
+ return itrValues.next();
+ }).then(({ done }) => {
+ ok(done, "An earlier failure in next() should set the async iterator's 'is finished' flag to true.");
+ }).catch(() => {
+ ok(false, "An earlier failure in next() shouldn't cause subsequent calls to return a rejected promise.");
+ });
+
+ // eslint-disable-next-line no-undef
+ itr = new TestInterfaceAsyncIterableSingleWithArgs();
+ itrValues = itr.values({ throwFromNext: true });
+ await itrValues.next().then(() => {
+ ok(false, "Should have rejected from the exception");
+ }).catch(() => {
+ ok(true, "Should have rejected from the exception");
+ });
+
+ // eslint-disable-next-line no-undef
+ itr = new TestInterfaceAsyncIterableSingleWithArgs();
+ itrValues = itr.values({ throwFromReturn: () => { throw new DOMException("Throw from return", "InvalidStateError"); } });
+ await itrValues.return().then(() => {
+ ok(false, "Should have rejected from the exception");
+ }).catch(() => {
+ ok(true, "Should have rejected from the exception");
+ });
+}
+
+async function test_data_double() {
+ info(`AsyncIterableDouble: Testing simple iterable creation and functionality`);
+
+ // eslint-disable-next-line no-undef
+ let itr = new TestInterfaceAsyncIterableDouble();
+ is(itr.entries, itr[Symbol.asyncIterator],
+ `AsyncIterableDouble: Should be using @@asyncIterator for 'entries'`);
+
+ let elements = [["a", "b"], ["c", "d"], ["e", "f"]];
+ let key_itr = itr.keys();
+ let value_itr = itr.values();
+ let entries_itr = itr.entries();
+ let key = await key_itr.next();
+ let value = await value_itr.next();
+ let entry = await entries_itr.next();
+ for (let i = 0; i < 3; ++i) {
+ is(key.value, elements[i][0], `AsyncIterableDouble: Key.value should be ${elements[i][0]}, got ${key.value}`);
+ is(key.done, false, `AsyncIterableDouble: Key.done should be false, got ${key.done}`);
+ is(value.value, elements[i][1], `AsyncIterableDouble: Value.value should be ${elements[i][1]}, got ${value.value}`);
+ is(value.done, false, `AsyncIterableDouble: Value.done should be false, got ${value.done}`);
+ is(entry.value[0], elements[i][0], `AsyncIterableDouble: Entry.value[0] should be ${elements[i][0]}, got ${entry.value[0]}`);
+ is(entry.value[1], elements[i][1], `AsyncIterableDouble: Entry.value[1] should be ${elements[i][1]}, got ${entry.value[1]}`);
+ is(entry.done, false, `AsyncIterableDouble: Entry.done should be false, got ${entry.done}`);
+
+ key = await key_itr.next();
+ value = await value_itr.next();
+ entry = await entries_itr.next();
+ }
+ is(key.value, undefined, `AsyncIterableDouble: Key.value should be ${undefined}, got ${key.value}`);
+ is(key.done, true, `AsyncIterableDouble: Key.done should be true, got ${key.done}`);
+ is(value.value, undefined, `AsyncIterableDouble: Value.value should be ${undefined}, got ${value.value}`);
+ is(value.done, true, `AsyncIterableDouble: Value.done should be true, got ${value.done}`);
+ is(entry.value, undefined, `AsyncIterableDouble: Entry.value should be ${undefined}, got ${entry.value}`);
+ is(entry.done, true, `AsyncIterableDouble: Entry.done should be true, got ${entry.done}`);
+
+ let idx = 0;
+ for await (let [itrkey, itrvalue] of itr) {
+ is(itrkey, elements[idx][0], `AsyncIterableDouble: Looping at ${idx} should have key ${elements[idx][0]}, got ${key}`);
+ is(itrvalue, elements[idx][1], `AsyncIterableDouble: Looping at ${idx} should have value ${elements[idx][1]}, got ${value}`);
+ ++idx;
+ }
+ is(idx, 3, `AsyncIterableDouble: Should have 3 loops of for-await-of, got ${idx}`);
+}
+
+async function test_data_double_union() {
+ info(`AsyncIterableDoubleUnion: Testing simple iterable creation and functionality`);
+
+ // eslint-disable-next-line no-undef
+ let itr = new TestInterfaceAsyncIterableDoubleUnion();
+ is(itr.entries, itr[Symbol.asyncIterator],
+ `AsyncIterableDoubleUnion: Should be using @@asyncIterator for 'entries'`);
+
+ let elements = [["long", 1], ["string", "a"]];
+ let key_itr = itr.keys();
+ let value_itr = itr.values();
+ let entries_itr = itr.entries();
+ let key = await key_itr.next();
+ let value = await value_itr.next();
+ let entry = await entries_itr.next();
+ for (let i = 0; i < 2; ++i) {
+ is(key.value, elements[i][0], `AsyncIterableDoubleUnion: Key.value should be ${elements[i][0]}, got ${key.value}`);
+ is(key.done, false, `AsyncIterableDoubleUnion: Key.done should be false, got ${key.done}`);
+ is(value.value, elements[i][1], `AsyncIterableDoubleUnion: Value.value should be ${elements[i][1]}, got ${value.value}`);
+ is(value.done, false, `AsyncIterableDoubleUnion: Value.done should be false, got ${value.done}`);
+ is(entry.value[0], elements[i][0], `AsyncIterableDoubleUnion: Entry.value[0] should be ${elements[i][0]}, got ${entry.value[0]}`);
+ is(entry.value[1], elements[i][1], `AsyncIterableDoubleUnion: Entry.value[1] should be ${elements[i][1]}, got ${entry.value[1]}`);
+ is(entry.done, false, `AsyncIterableDoubleUnion: Entry.done should be false, got ${entry.done}`);
+
+ key = await key_itr.next();
+ value = await value_itr.next();
+ entry = await entries_itr.next();
+ }
+ is(key.value, undefined, `AsyncIterableDoubleUnion: Key.value should be ${undefined}, got ${key.value}`);
+ is(key.done, true, `AsyncIterableDoubleUnion: Key.done should be true, got ${key.done}`);
+ is(value.value, undefined, `AsyncIterableDoubleUnion: Value.value should be ${undefined}, got ${value.value}`);
+ is(value.done, true, `AsyncIterableDoubleUnion: Value.done should be true, got ${value.done}`);
+ is(entry.value, undefined, `AsyncIterableDoubleUnion: Entry.value should be ${undefined}, got ${entry.value}`);
+ is(entry.done, true, `AsyncIterableDoubleUnion: Entry.done should be true, got ${entry.done}`);
+
+ let idx = 0;
+ for await (let [itrkey, itrvalue] of itr) {
+ is(itrkey, elements[idx][0], `AsyncIterableDoubleUnion: Looping at ${idx} should have key ${elements[idx][0]}, got ${key}`);
+ is(itrvalue, elements[idx][1], `AsyncIterableDoubleUnion: Looping at ${idx} should have value ${elements[idx][1]}, got ${value}`);
+ ++idx;
+ }
+ is(idx, 2, `AsyncIterableDoubleUnion: Should have 2 loops of for-await-of, got ${idx}`);
+}
+
+add_task(async function do_tests() {
+ await test_data_single();
+ await test_data_double();
+ await test_data_double_union();
+});
+
+ </script>
+ </body>
+</html>
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-12 05:05:59 +0000