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'`);
// eslint-disable-next-line no-undef
itr = new TestInterfaceAsyncIterableSingleWithArgs();
is(itr.values, itr[Symbol.asyncIterator],
`AsyncIterableSingleWithArgs: Should be using @@asyncIterator for 'values'`);
// 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) => {
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();
}
// 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}`);
}
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
