diff options
Diffstat (limited to 'js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype')
46 files changed, 2703 insertions, 0 deletions
diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/browser.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/browser.js new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/browser.js diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/absent-value-not-passed.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/absent-value-not-passed.js new file mode 100644 index 0000000000..ecba51e39c --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/absent-value-not-passed.js @@ -0,0 +1,38 @@ +// |reftest| async +// Copyright (C) 2020 Alexey Shvayka. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.next +description: > + `next` method does not pass absent `value`. +info: | + %AsyncFromSyncIteratorPrototype%.next ( value ) + + [...] + 5. If value is present, then + [...] + 6. Else, + a. Let result be IteratorNext(syncIteratorRecord). + [...] +flags: [async] +features: [async-iteration] +includes: [asyncHelpers.js] +---*/ + +var nextArgumentsLength; +var syncIterator = { + [Symbol.iterator]() { + return this; + }, + next() { + nextArgumentsLength = arguments.length; + return {done: true}; + }, +}; + +asyncTest(async function () { + for await (let _ of syncIterator); + + assert.sameValue(nextArgumentsLength, 0); +}); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/browser.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/browser.js new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/browser.js diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/for-await-iterator-next-rejected-promise-close.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/for-await-iterator-next-rejected-promise-close.js new file mode 100644 index 0000000000..27a06daace --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/for-await-iterator-next-rejected-promise-close.js @@ -0,0 +1,66 @@ +// |reftest| async +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.next +description: next() will reject promise if resolving result promise abrupt completes. +info: | + %AsyncFromSyncIteratorPrototype%.next ( value ) + ... + 3. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 4. Let syncIteratorRecord be O.[[SyncIteratorRecord]]. + 5. If value is present, then + ... + 6. Else, + a. Let result be IteratorNext(syncIteratorRecord). + 7. IfAbruptRejectPromise(result, promiseCapability). + 8. Return ! AsyncFromSyncIteratorContinuation(result, promiseCapability, syncIteratorRecord, true). + + AsyncFromSyncIteratorContinuation ( result, promiseCapability, syncIteratorRecord, closeOnRejection ) + 1. Let done be IteratorComplete(result). + 2. IfAbruptRejectPromise(done, promiseCapability). + 3. Let value be IteratorValue(result). + 4. IfAbruptRejectPromise(value, promiseCapability). + 5. Let valueWrapper be PromiseResolve(%Promise%, value). + 6. If valueWrapper is an abrupt completion, done is false, and closeOnRejection is true, then + a. Set valueWrapper to IteratorClose(syncIteratorRecord, valueWrapper). + ... + 12. If done is true, or if closeOnRejection is false, then + ... + 13. Else, + a. Let closeIterator be a new Abstract Closure with parameters (error) that captures syncIteratorRecord and performs the following steps when called: + i. Return ? IteratorClose(syncIteratorRecord, ThrowCompletion(error)). + b. Let onRejected be CreateBuiltinFunction(closeIterator, 1, "", « »). + c. NOTE: onRejected is used to close the Iterator when the "value" property of an IteratorResult object it yields is a rejected promise. + 14. Perform PerformPromiseThen(valueWrapper, onFulfilled, onRejected, promiseCapability). + 15. Return promiseCapability.[[Promise]]. + + +flags: [async] +features: [async-iteration] +includes: [asyncHelpers.js] +---*/ + +var finallyCount = 0; +var caught = false; + +function* iterator() { + try { + yield Promise.reject("reject"); + } finally { + finallyCount += 1; + } +} + +asyncTest(async () => { + try { + for await (const x of iterator()); + } catch (e) { + caught = true; + assert.sameValue(e, "reject"); + } + + assert.sameValue(finallyCount, 1); + assert(caught); +}); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/for-await-next-rejected-promise-close.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/for-await-next-rejected-promise-close.js new file mode 100644 index 0000000000..60d7674aa6 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/for-await-next-rejected-promise-close.js @@ -0,0 +1,71 @@ +// |reftest| async +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.next +description: next() will reject promise if resolving result promise abrupt completes. +info: | + %AsyncFromSyncIteratorPrototype%.next ( value ) + ... + 3. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 4. Let syncIteratorRecord be O.[[SyncIteratorRecord]]. + 5. If value is present, then + ... + 6. Else, + a. Let result be IteratorNext(syncIteratorRecord). + 7. IfAbruptRejectPromise(result, promiseCapability). + 8. Return ! AsyncFromSyncIteratorContinuation(result, promiseCapability, syncIteratorRecord, true). + + AsyncFromSyncIteratorContinuation ( result, promiseCapability, syncIteratorRecord, closeOnRejection ) + 1. Let done be IteratorComplete(result). + 2. IfAbruptRejectPromise(done, promiseCapability). + 3. Let value be IteratorValue(result). + 4. IfAbruptRejectPromise(value, promiseCapability). + 5. Let valueWrapper be PromiseResolve(%Promise%, value). + 6. If valueWrapper is an abrupt completion, done is false, and closeOnRejection is true, then + a. Set valueWrapper to IteratorClose(syncIteratorRecord, valueWrapper). + ... + 12. If done is true, or if closeOnRejection is false, then + ... + 13. Else, + a. Let closeIterator be a new Abstract Closure with parameters (error) that captures syncIteratorRecord and performs the following steps when called: + i. Return ? IteratorClose(syncIteratorRecord, ThrowCompletion(error)). + b. Let onRejected be CreateBuiltinFunction(closeIterator, 1, "", « »). + c. NOTE: onRejected is used to close the Iterator when the "value" property of an IteratorResult object it yields is a rejected promise. + 14. Perform PerformPromiseThen(valueWrapper, onFulfilled, onRejected, promiseCapability). + 15. Return promiseCapability.[[Promise]]. + + +flags: [async] +features: [async-iteration] +includes: [asyncHelpers.js] +---*/ + +var returnCount = 0; +var caught = false; + +const syncIterator = { + [Symbol.iterator]() { + return { + next() { + return { value: Promise.reject("reject"), done: false }; + }, + return() { + returnCount += 1; + } + }; + } +} + +asyncTest(async () => { + try { + for await (let _ of syncIterator); + } catch (e) { + caught = true; + assert.sameValue(e, "reject"); + } + + assert.sameValue(returnCount, 1); + assert(caught); +}); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/iterator-result-poisoned-done.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/iterator-result-poisoned-done.js new file mode 100644 index 0000000000..eb493bece9 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/iterator-result-poisoned-done.js @@ -0,0 +1,53 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.next +description: next() will reject promise if getter `done` abrupt completes +info: | + %AsyncFromSyncIteratorPrototype%.next ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let nextResult be IteratorNext(syncIteratorRecord, value). + 6. IfAbruptRejectPromise(nextResult, promiseCapability). + 7. Let nextDone be IteratorComplete(nextResult). + 8. IfAbruptRejectPromise(nextDone, promiseCapability). + ... + 18. Return promiseCapability.[[Promise]]. + +flags: [async] +features: [async-iteration] +---*/ + +var thrownError = new Error("Catch me."); + +var obj = { + [Symbol.iterator]() { + return { + next() { + return { + get done() { + throw thrownError; + }, + value: 1 + } + } + }; + } +}; + +async function* asyncg() { + yield* obj; +} + +asyncg().next().then( + function (result) { + throw new Test262Error("Promise should be rejected."); + }, + function (err) { + assert.sameValue(err, thrownError, "Promise should be rejected with thrown error"); + } +).then($DONE, $DONE); + diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/iterator-result-poisoned-value.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/iterator-result-poisoned-value.js new file mode 100644 index 0000000000..6a0e49439d --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/iterator-result-poisoned-value.js @@ -0,0 +1,55 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.next +description: next() will reject promise if getter `value` abrupt completes +info: | + %AsyncFromSyncIteratorPrototype%.next ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let nextResult be IteratorNext(syncIteratorRecord, value). + 6. IfAbruptRejectPromise(nextResult, promiseCapability). + 7. Let nextDone be IteratorComplete(nextResult). + 8. If AbruptRejectPromise(nextDone, promiseCapability). + 9. Let nextValue be IteratorValue(nextResult). + 10. IfAbruptRejectPromise(nextValue, promiseCapability). + ... + 18. Return promiseCapability.[[Promise]]. + +flags: [async] +features: [async-iteration] +---*/ + +var thrownError = new Error("Catch me."); + +var obj = { + [Symbol.iterator]() { + return { + next() { + return { + get value() { + throw thrownError; + }, + done: false + } + } + }; + } +}; + +async function* asyncg() { + yield* obj; +} + +asyncg().next().then( + function (result) { + throw new Test262Error("Promise should be rejected."); + }, + function (err) { + assert.sameValue(err, thrownError, "Promise should be rejected with thrown error"); + } +).then($DONE, $DONE); + diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/iterator-result-poisoned-wrapper.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/iterator-result-poisoned-wrapper.js new file mode 100644 index 0000000000..bbcd3f3a23 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/iterator-result-poisoned-wrapper.js @@ -0,0 +1,68 @@ +// |reftest| async +// Copyright (C) 2023 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.next +description: next() will reject promise if resolving result promise abrupt completes. +info: | + %AsyncFromSyncIteratorPrototype%.next ( value ) + ... + 3. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 4. Let syncIteratorRecord be O.[[SyncIteratorRecord]]. + 5. If value is present, then + ... + 6. Else, + a. Let result be IteratorNext(syncIteratorRecord). + 7. IfAbruptRejectPromise(result, promiseCapability). + 8. Return ! AsyncFromSyncIteratorContinuation(result, promiseCapability, syncIteratorRecord, true). + + AsyncFromSyncIteratorContinuation ( result, promiseCapability, syncIteratorRecord, closeOnRejection ) + 1. Let done be IteratorComplete(result). + 2. IfAbruptRejectPromise(done, promiseCapability). + 3. Let value be IteratorValue(result). + 4. IfAbruptRejectPromise(value, promiseCapability). + 5. Let valueWrapper be PromiseResolve(%Promise%, value). + 6. If valueWrapper is an abrupt completion, done is false, and closeOnRejection is true, then + a. Set valueWrapper to IteratorClose(syncIteratorRecord, valueWrapper). + 7. IfAbruptRejectPromise(valueWrapper, promiseCapability). + ... + + IfAbruptRejectPromise ( value, capability ) + 1. Assert: value is a Completion Record. + 2. If value is an abrupt completion, then + a. Perform ? Call(capability.[[Reject]], undefined, « value.[[Value]] »). + b. Return capability.[[Promise]]. + ... + +flags: [async] +features: [async-iteration] +includes: [asyncHelpers.js] +---*/ + +var finallyCount = 0; +function CatchError() {} +var thrownError = new CatchError(); + +function* gen() { + try { + const p = Promise.resolve('FAIL'); + Object.defineProperty(p, 'constructor', { + get() { + throw thrownError; + } + }); + yield p; + } finally { + finallyCount += 1; + } +} + +async function* iter() { + yield* gen(); +} + +asyncTest(async function () { + await assert.throwsAsync(CatchError, async () => iter().next(), "Promise should be rejected"); + assert.sameValue(finallyCount, 1, 'iterator closed properly'); +}) diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/iterator-result-prototype.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/iterator-result-prototype.js new file mode 100644 index 0000000000..d3f638e48e --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/iterator-result-prototype.js @@ -0,0 +1,43 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.next +description: next() returns a promise for an IteratorResult object +info: | + %AsyncFromSyncIteratorPrototype%.next ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let nextResult be IteratorNext(syncIteratorRecord, value). + 6. IfAbruptRejectPromise(nextResult, promiseCapability). + 7. Let nextDone be IteratorComplete(nextResult). + 8. If AbruptRejectPromise(nextDone, promiseCapability). + 9. Let nextValue be IteratorValue(nextResult). + 10. IfAbruptRejectPromise(nextValue, promiseCapability). + ... + 14. Let steps be the algorithm steps defined in Async-from-Sync Iterator Value Unwrap Functions. + + Async-from-Sync Iterator Value Unwrap Functions + 1. Return ! CreateIterResultObject(value, F.[[Done]]). + +flags: [async] +features: [async-iteration] +---*/ + +function* g() {} + +async function* asyncg() { + yield* g(); +} + +asyncg().next().then(function (result) { + assert( + Object.prototype.hasOwnProperty.call(result, 'value'), 'Has "own" property `value`' + ); + assert( + Object.prototype.hasOwnProperty.call(result, 'done'), 'Has "own" property `done`' + ); + assert.sameValue(Object.getPrototypeOf(result), Object.prototype); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/iterator-result-rejected.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/iterator-result-rejected.js new file mode 100644 index 0000000000..8a5f9bf14a --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/iterator-result-rejected.js @@ -0,0 +1,44 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.next +description: next() will reject promise if sync iterator next() function returns an aburpt completion +info: | + %AsyncFromSyncIteratorPrototype%.next ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let nextResult be IteratorNext(syncIteratorRecord, value). + 6. IfAbruptRejectPromise(nextResult, promiseCapability). + 7. Let nextDone be IteratorComplete(nextResult). + 8. If AbruptRejectPromise(nextDone, promiseCapability). + 9. Let nextValue be IteratorValue(nextResult). + 10. IfAbruptRejectPromise(nextValue, promiseCapability). + ... + 18. Return promiseCapability.[[Promise]]. + +flags: [async] +features: [async-iteration] +---*/ + +var thrownError = new Error("Catch me."); + +function* g() { + throw thrownError; +} + +async function* asyncg() { + yield* g(); +} + +asyncg().next().then( + function (result) { + throw new Test262Error("Promise should be rejected."); + }, + function (err) { + assert.sameValue(err, thrownError, "Promise should be rejected with thrown error"); + } +).then($DONE, $DONE); + diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/iterator-result-unwrap-promise.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/iterator-result-unwrap-promise.js new file mode 100644 index 0000000000..f77f3c2d96 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/iterator-result-unwrap-promise.js @@ -0,0 +1,44 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.next +description: next() will unwrap a Promise value return by the sync iterator +info: | + %AsyncFromSyncIteratorPrototype%.next ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let nextResult be IteratorNext(syncIteratorRecord, value). + 6. IfAbruptRejectPromise(nextResult, promiseCapability). + 7. Let nextDone be IteratorComplete(nextResult). + 8. If AbruptRejectPromise(nextDone, promiseCapability). + 9. Let nextValue be IteratorValue(nextResult). + 10. IfAbruptRejectPromise(nextValue, promiseCapability). + ... + 14. Let steps be the algorithm steps defined in Async-from-Sync Iterator Value Unwrap Functions. + + Async-from-Sync Iterator Value Unwrap Functions + An async-from-sync iterator value unwrap function is an anonymous built-in + function that is used by methods of %AsyncFromSyncIteratorPrototype% when + processing the value field of an IteratorResult object, in order to wait for + its value if it is a promise and re-package the result in a new "unwrapped" + IteratorResult object. Each async iterator value unwrap function has a + [[Done]] internal slot. + +flags: [async] +features: [async-iteration] +---*/ + +function* g() { + yield Promise.resolve(1); +} + +async function* asyncg() { + yield* g(); +} + +asyncg().next().then(function (result) { + assert.sameValue(result.value, 1, "result.value should be unwrapped promise, got: " + result.value) +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/next-result-poisoned-wrapper.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/next-result-poisoned-wrapper.js new file mode 100644 index 0000000000..f7b9c57549 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/next-result-poisoned-wrapper.js @@ -0,0 +1,73 @@ +// |reftest| async +// Copyright (C) 2023 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.next +description: next() will reject promise if resolving result promise abrupt completes. +info: | + %AsyncFromSyncIteratorPrototype%.next ( value ) + ... + 3. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 4. Let syncIteratorRecord be O.[[SyncIteratorRecord]]. + 5. If value is present, then + ... + 6. Else, + a. Let result be IteratorNext(syncIteratorRecord). + 7. IfAbruptRejectPromise(result, promiseCapability). + 8. Return ! AsyncFromSyncIteratorContinuation(result, promiseCapability, syncIteratorRecord, true). + + AsyncFromSyncIteratorContinuation ( result, promiseCapability, syncIteratorRecord, closeOnRejection ) + 1. Let done be IteratorComplete(result). + 2. IfAbruptRejectPromise(done, promiseCapability). + 3. Let value be IteratorValue(result). + 4. IfAbruptRejectPromise(value, promiseCapability). + 5. Let valueWrapper be PromiseResolve(%Promise%, value). + 6. If valueWrapper is an abrupt completion, done is false, and closeOnRejection is true, then + a. Set valueWrapper to IteratorClose(syncIteratorRecord, valueWrapper). + 7. IfAbruptRejectPromise(valueWrapper, promiseCapability). + ... + + IfAbruptRejectPromise ( value, capability ) + 1. Assert: value is a Completion Record. + 2. If value is an abrupt completion, then + a. Perform ? Call(capability.[[Reject]], undefined, « value.[[Value]] »). + b. Return capability.[[Promise]]. + ... + +flags: [async] +features: [async-iteration] +includes: [asyncHelpers.js] +---*/ + +var returnCount = 0; +function CatchError() {} +var thrownError = new CatchError(); + +const obj = { + [Symbol.iterator]() { + return { + next() { + const p = Promise.resolve('FAIL'); + Object.defineProperty(p, 'constructor', { + get() { + throw thrownError; + } + }); + return { value: p, done: false }; + }, + return() { + returnCount += 1; + } + }; + } +}; + +async function* iter() { + yield* obj; +} + +asyncTest(async function () { + await assert.throwsAsync(CatchError, async () => iter().next(), "Promise should be rejected"); + assert.sameValue(returnCount, 1, 'iterator closed properly'); +}) diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/return-promise.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/return-promise.js new file mode 100644 index 0000000000..4f6a112c45 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/return-promise.js @@ -0,0 +1,28 @@ +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.next +description: > + "next" returns a promise for an IteratorResult object +info: | + %AsyncFromSyncIteratorPrototype%.next ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 18. Return promiseCapability.[[Promise]]. + +features: [async-iteration] +---*/ + +function* g() { +} + +async function* asyncg() { + yield* g(); +} + +var result = asyncg().next(); +assert(result instanceof Promise) + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/shell.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/shell.js new file mode 100644 index 0000000000..ae18ad584d --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/shell.js @@ -0,0 +1,113 @@ +// GENERATED, DO NOT EDIT +// file: asyncHelpers.js +// Copyright (C) 2022 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + A collection of assertion and wrapper functions for testing asynchronous built-ins. +defines: [asyncTest] +---*/ + +function asyncTest(testFunc) { + if (!Object.hasOwn(globalThis, "$DONE")) { + throw new Test262Error("asyncTest called without async flag"); + } + if (typeof testFunc !== "function") { + $DONE(new Test262Error("asyncTest called with non-function argument")); + return; + } + try { + testFunc().then( + function () { + $DONE(); + }, + function (error) { + $DONE(error); + } + ); + } catch (syncError) { + $DONE(syncError); + } +} + +assert.throwsAsync = async function (expectedErrorConstructor, func, message) { + var innerThenable; + if (message === undefined) { + message = ""; + } else { + message += " "; + } + if (typeof func === "function") { + try { + innerThenable = func(); + if ( + innerThenable === null || + typeof innerThenable !== "object" || + typeof innerThenable.then !== "function" + ) { + message += + "Expected to obtain an inner promise that would reject with a" + + expectedErrorConstructor.name + + " but result was not a thenable"; + throw new Test262Error(message); + } + } catch (thrown) { + message += + "Expected a " + + expectedErrorConstructor.name + + " to be thrown asynchronously but an exception was thrown synchronously while obtaining the inner promise"; + throw new Test262Error(message); + } + } else { + message += + "assert.throwsAsync called with an argument that is not a function"; + throw new Test262Error(message); + } + + try { + return innerThenable.then( + function () { + message += + "Expected a " + + expectedErrorConstructor.name + + " to be thrown asynchronously but no exception was thrown at all"; + throw new Test262Error(message); + }, + function (thrown) { + var expectedName, actualName; + if (typeof thrown !== "object" || thrown === null) { + message += "Thrown value was not an object!"; + throw new Test262Error(message); + } else if (thrown.constructor !== expectedErrorConstructor) { + expectedName = expectedErrorConstructor.name; + actualName = thrown.constructor.name; + if (expectedName === actualName) { + message += + "Expected a " + + expectedName + + " but got a different error constructor with the same name"; + } else { + message += + "Expected a " + expectedName + " but got a " + actualName; + } + throw new Test262Error(message); + } + } + ); + } catch (thrown) { + if (typeof thrown !== "object" || thrown === null) { + message += + "Expected a " + + expectedErrorConstructor.name + + " to be thrown asynchronously but innerThenable synchronously threw a value that was not an object "; + } else { + message += + "Expected a " + + expectedErrorConstructor.name + + " to be thrown asynchronously but a " + + thrown.constructor.name + + " was thrown synchronously"; + } + throw new Test262Error(message); + } +}; diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/yield-iterator-next-rejected-promise-close.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/yield-iterator-next-rejected-promise-close.js new file mode 100644 index 0000000000..26c35b6312 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/yield-iterator-next-rejected-promise-close.js @@ -0,0 +1,63 @@ +// |reftest| async +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.next +description: next() will reject promise if resolving result promise abrupt completes. +info: | + %AsyncFromSyncIteratorPrototype%.next ( value ) + ... + 3. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 4. Let syncIteratorRecord be O.[[SyncIteratorRecord]]. + 5. If value is present, then + ... + 6. Else, + a. Let result be IteratorNext(syncIteratorRecord). + 7. IfAbruptRejectPromise(result, promiseCapability). + 8. Return ! AsyncFromSyncIteratorContinuation(result, promiseCapability, syncIteratorRecord, true). + + AsyncFromSyncIteratorContinuation ( result, promiseCapability, syncIteratorRecord, closeOnRejection ) + 1. Let done be IteratorComplete(result). + 2. IfAbruptRejectPromise(done, promiseCapability). + 3. Let value be IteratorValue(result). + 4. IfAbruptRejectPromise(value, promiseCapability). + 5. Let valueWrapper be PromiseResolve(%Promise%, value). + 6. If valueWrapper is an abrupt completion, done is false, and closeOnRejection is true, then + a. Set valueWrapper to IteratorClose(syncIteratorRecord, valueWrapper). + ... + 12. If done is true, or if closeOnRejection is false, then + ... + 13. Else, + a. Let closeIterator be a new Abstract Closure with parameters (error) that captures syncIteratorRecord and performs the following steps when called: + i. Return ? IteratorClose(syncIteratorRecord, ThrowCompletion(error)). + b. Let onRejected be CreateBuiltinFunction(closeIterator, 1, "", « »). + c. NOTE: onRejected is used to close the Iterator when the "value" property of an IteratorResult object it yields is a rejected promise. + 14. Perform PerformPromiseThen(valueWrapper, onFulfilled, onRejected, promiseCapability). + 15. Return promiseCapability.[[Promise]]. + + +flags: [async] +features: [async-iteration] +includes: [asyncHelpers.js] +---*/ + +var finallyCount = 0; +function Reject() {} + +function* iterator() { + try { + yield Promise.reject(new Reject()); + } finally { + finallyCount += 1; + } +} + +async function* asyncIterator() { + yield* iterator() +} + +asyncTest(async () => { + await assert.throwsAsync(Reject, async () => asyncIterator().next(), "Promise should be rejected"); + assert.sameValue(finallyCount, 1); +}); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/yield-next-rejected-promise-close.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/yield-next-rejected-promise-close.js new file mode 100644 index 0000000000..d747bce581 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/next/yield-next-rejected-promise-close.js @@ -0,0 +1,68 @@ +// |reftest| async +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.next +description: next() will reject promise if resolving result promise abrupt completes. +info: | + %AsyncFromSyncIteratorPrototype%.next ( value ) + ... + 3. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 4. Let syncIteratorRecord be O.[[SyncIteratorRecord]]. + 5. If value is present, then + ... + 6. Else, + a. Let result be IteratorNext(syncIteratorRecord). + 7. IfAbruptRejectPromise(result, promiseCapability). + 8. Return ! AsyncFromSyncIteratorContinuation(result, promiseCapability, syncIteratorRecord, true). + + AsyncFromSyncIteratorContinuation ( result, promiseCapability, syncIteratorRecord, closeOnRejection ) + 1. Let done be IteratorComplete(result). + 2. IfAbruptRejectPromise(done, promiseCapability). + 3. Let value be IteratorValue(result). + 4. IfAbruptRejectPromise(value, promiseCapability). + 5. Let valueWrapper be PromiseResolve(%Promise%, value). + 6. If valueWrapper is an abrupt completion, done is false, and closeOnRejection is true, then + a. Set valueWrapper to IteratorClose(syncIteratorRecord, valueWrapper). + ... + 12. If done is true, or if closeOnRejection is false, then + ... + 13. Else, + a. Let closeIterator be a new Abstract Closure with parameters (error) that captures syncIteratorRecord and performs the following steps when called: + i. Return ? IteratorClose(syncIteratorRecord, ThrowCompletion(error)). + b. Let onRejected be CreateBuiltinFunction(closeIterator, 1, "", « »). + c. NOTE: onRejected is used to close the Iterator when the "value" property of an IteratorResult object it yields is a rejected promise. + 14. Perform PerformPromiseThen(valueWrapper, onFulfilled, onRejected, promiseCapability). + 15. Return promiseCapability.[[Promise]]. + + +flags: [async] +features: [async-iteration] +includes: [asyncHelpers.js] +---*/ + +var returnCount = 0; +function Reject() {} + +const syncIterator = { + [Symbol.iterator]() { + return { + next() { + return { value: Promise.reject(new Reject()), done: false }; + }, + return() { + returnCount += 1; + } + }; + } +} + +async function* asyncIterator() { + yield* syncIterator; +} + +asyncTest(async () => { + await assert.throwsAsync(Reject, async () => asyncIterator().next(), "Promise should be rejected"); + assert.sameValue(returnCount, 1); +}); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/absent-value-not-passed.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/absent-value-not-passed.js new file mode 100644 index 0000000000..21686a8896 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/absent-value-not-passed.js @@ -0,0 +1,43 @@ +// |reftest| async +// Copyright (C) 2020 Alexey Shvayka. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.return +description: > + `return` method does not pass absent `value`. +info: | + %AsyncFromSyncIteratorPrototype%.return ( value ) + + [...] + 8. If value is present, then + [...] + 9. Else, + a. Let result be Call(return, syncIterator). + [...] +flags: [async] +features: [async-iteration] +includes: [asyncHelpers.js] +---*/ + +var returnArgumentsLength; +var syncIterator = { + [Symbol.iterator]() { + return this; + }, + next() { + return {done: false}; + }, + return() { + returnArgumentsLength = arguments.length; + return {done: true}; + }, +}; + +asyncTest(async function () { + for await (let _ of syncIterator) { + break; + } + + assert.sameValue(returnArgumentsLength, 0); +}); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/browser.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/browser.js new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/browser.js diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/iterator-result-poisoned-done.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/iterator-result-poisoned-done.js new file mode 100644 index 0000000000..de5639aa9d --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/iterator-result-poisoned-done.js @@ -0,0 +1,71 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.return +description: return() will reject promise if getter `done` abrupt completes +info: | + %AsyncFromSyncIteratorPrototype%.return ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let return be GetMethod(syncIterator, "return"). + ... + 8. Let returnResult be Call(return, syncIterator, « value »). + 9. IfAbruptRejectPromise(returnResult, promiseCapability). + ... + 11. Let returnDone be IteratorComplete(returnResult). + 12. IfAbruptRejectPromise(returnDone, promiseCapability). + 13. Let returnValue be IteratorValue(returnResult). + 14. IfAbruptRejectPromise(returnValue, promiseCapability). + ... + 22. Return promiseCapability.[[Promise]]. + +flags: [async] +features: [async-iteration] +---*/ + +var thrownError = new Error("Catch me."); + +var obj = { + [Symbol.iterator]() { + return { + next() { + return { value: 1, done: false }; + }, + return() { + return { + get done() { + throw thrownError; + }, + value: 1 + } + } + }; + } +}; + +async function* asyncg() { + yield* obj; +} + +var iter = asyncg(); + +iter.next().then(function(result) { + + iter.return().then( + function (result) { + throw new Test262Error("Promise should be rejected, got: " + result.value); + }, + function (err) { + assert.sameValue(err, thrownError, "Promise should be rejected with thrown error"); + + iter.next().then(({ done, value }) => { + assert.sameValue(done, true, 'the iterator is completed'); + assert.sameValue(value, undefined, 'value is undefined'); + }).then($DONE, $DONE); + } + ).catch($DONE); + +}).catch($DONE); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/iterator-result-poisoned-value.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/iterator-result-poisoned-value.js new file mode 100644 index 0000000000..369319f098 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/iterator-result-poisoned-value.js @@ -0,0 +1,71 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.return +description: return() will reject promise if getter `value` abrupt completes +info: | + %AsyncFromSyncIteratorPrototype%.return ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let return be GetMethod(syncIterator, "return"). + ... + 8. Let returnResult be Call(return, syncIterator, « value »). + 9. IfAbruptRejectPromise(returnResult, promiseCapability). + ... + 11. Let returnDone be IteratorComplete(returnResult). + 12. IfAbruptRejectPromise(returnDone, promiseCapability). + 13. Let returnValue be IteratorValue(returnResult). + 14. IfAbruptRejectPromise(returnValue, promiseCapability). + ... + 22. Return promiseCapability.[[Promise]]. + +flags: [async] +features: [async-iteration] +---*/ + + +var thrownError = new Error("Catch me."); +var obj = { + [Symbol.iterator]() { + return { + next() { + return { value: 1, done: false }; + }, + return() { + return { + get value() { + throw thrownError; + }, + done: false + } + } + }; + } +}; + +async function* asyncg() { + yield* obj; +} + +var iter = asyncg(); + +iter.next().then(function(result) { + + iter.return().then( + function (result) { + throw new Test262Error("Promise should be rejected, got: " + result.value); + }, + function (err) { + assert.sameValue(err, thrownError, "Promise should be rejected with thrown error"); + + iter.next().then(({ done, value }) => { + assert.sameValue(done, true, 'the iterator is completed'); + assert.sameValue(value, undefined, 'value is undefined'); + }).then($DONE, $DONE); + } + ).catch($DONE); + +}).catch($DONE); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/iterator-result-unwrap-promise.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/iterator-result-unwrap-promise.js new file mode 100644 index 0000000000..5d69a98f7f --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/iterator-result-unwrap-promise.js @@ -0,0 +1,65 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.return +description: return() will unwrap a Promise value return by the sync iterator +info: | + %AsyncFromSyncIteratorPrototype%.return ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let return be GetMethod(syncIterator, "return"). + ... + 17. Let steps be the algorithm steps defined in Async-from-Sync Iterator Value Unwrap Functions. + ... + 22. Return promiseCapability.[[Promise]]. + + Async-from-Sync Iterator Value Unwrap Functions + An async-from-sync iterator value unwrap function is an anonymous built-in + function that is used by methods of %AsyncFromSyncIteratorPrototype% when + processing the value field of an IteratorResult object, in order to wait for + its value if it is a promise and re-package the result in a new "unwrapped" + IteratorResult object. Each async iterator value unwrap function has a + [[Done]] internal slot. + +flags: [async] +features: [async-iteration] +---*/ + +var obj = { + [Symbol.iterator]() { + return { + next() { + return { value: 1, done: false }; + }, + return() { + return { + value: Promise.resolve(42), + done: true + }; + } + }; + } +}; + +async function* asyncg() { + yield* obj; +} + +let iter = asyncg(); + +iter.next().then(function (result) { + iter.return().then( + function (result) { + assert.sameValue(result.value, 42, "Result.value should be unwrapped, got: " + result.value); + + iter.next().then(({ done, value }) => { + assert.sameValue(done, true, 'the iterator is completed'); + assert.sameValue(value, undefined, 'value is undefined'); + }).then($DONE, $DONE); + } + ).catch($DONE); + +}).catch($DONE); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/iterator-result.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/iterator-result.js new file mode 100644 index 0000000000..38ac3eeaa5 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/iterator-result.js @@ -0,0 +1,56 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.return +description: return() will return a iterator result object when built-in sync throw is called +info: | + %AsyncFromSyncIteratorPrototype%.return ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let return be GetMethod(syncIterator, "return"). + ... + 8. Let returnResult be Call(return, syncIterator, « value »). + ... + 22. Return promiseCapability.[[Promise]]. + + Generator.prototype.return ( value ) + 1. Let g be the this value. + 2. Let C be Completion{[[Type]]: return, [[Value]]: value, [[Target]]: empty}. + 3. Return ? GeneratorResumeAbrupt(g, C). + +flags: [async] +features: [async-iteration] +---*/ + +function* g() { + yield 42; + throw new Test262Error('return closes iter'); + yield 43; +} + +async function* asyncg() { + yield* g(); +} + +var iter = asyncg(); +var val = 'some specific return value' + +iter.next().then(function(result) { + + // return will call sync generator prototype built-in function return + iter.return(val).then(function(result) { + + assert.sameValue(result.done, true, 'the iterator is completed'); + assert.sameValue(result.value, val, 'expect agrument to `return`'); + + iter.next().then(({ done, value }) => { + assert.sameValue(done, true, 'the iterator is completed'); + assert.sameValue(value, undefined, 'value is undefined'); + }).then($DONE, $DONE); + + }).catch($DONE); + +}).catch($DONE); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/poisoned-get-return.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/poisoned-get-return.js new file mode 100644 index 0000000000..c91a1954d5 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/poisoned-get-return.js @@ -0,0 +1,60 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.return +description: return() will return rejected promise if getter of `return` abrupt completes +info: | + %AsyncFromSyncIteratorPrototype%.return ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let return be GetMethod(syncIterator, "return"). + 6. IfAbruptRejectPromise(return, promiseCapability). + ... + 22. Return promiseCapability.[[Promise]]. + +flags: [async] +features: [async-iteration] +---*/ + +var thrownError = new Error("Catch me."); + +var obj = { + [Symbol.iterator]() { + return { + next() { + return { value: 1, done: false }; + }, + get return() { + throw thrownError; + } + } + } +}; + +async function* asyncg() { + yield* obj; +} + +var iter = asyncg(); + +iter.next().then(function(result) { + + iter.return().then( + function (result) { + throw new Test262Error("Promise should be rejected, got: " + result.value); + }, + function (err) { + assert.sameValue(err, thrownError, "Promise should be rejected with thrown error"); + + iter.next().then(({ done, value }) => { + assert.sameValue(done, true, 'the iterator is completed'); + assert.sameValue(value, undefined, 'value is undefined'); + }).then($DONE, $DONE); + } + ).catch($DONE); + +}).catch($DONE); + diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/poisoned-return.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/poisoned-return.js new file mode 100644 index 0000000000..19d2be92d8 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/poisoned-return.js @@ -0,0 +1,66 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.return +description: return() will return rejected promise if getter of `return` abrupt completes +info: | + %AsyncFromSyncIteratorPrototype%.return ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let return be GetMethod(syncIterator, "return"). + 6. IfAbruptRejectPromise(return, promiseCapability). + ... + 8. Let returnResult be Call(return, syncIterator, « value »). + ... + 10. If Type(returnResult) is not Object, + a. Perform ! Call(promiseCapability.[[Reject]], undefined, « a TypeError exception »). + b. Return promiseCapability.[[Promise]]. + ... + 22. Return promiseCapability.[[Promise]]. + +flags: [async] +features: [async-iteration] +---*/ + +var thrownError = new Error("Catch me."); + +var obj = { + [Symbol.iterator]() { + return { + next() { + return { value: 1, done: false }; + }, + return() { + throw thrownError; + } + }; + } +}; + +async function* asyncg() { + yield* obj; +} + +var iter = asyncg(); + +iter.next().then(function(result) { + + iter.return().then( + function (result) { + throw new Test262Error("Promise should be rejected, got: " + result.value); + }, + function (err) { + assert.sameValue(err, thrownError, "Promise should be rejected with thrown error"); + + iter.next().then(({ done, value }) => { + assert.sameValue(done, true, 'the iterator is completed'); + assert.sameValue(value, undefined, 'value is undefined'); + }).then($DONE, $DONE); + } + ).catch($DONE); + +}).catch($DONE); + diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/result-object-error.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/result-object-error.js new file mode 100644 index 0000000000..153ff47f41 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/result-object-error.js @@ -0,0 +1,65 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.return +description: return() will return rejected promise if getter of `return` abrupt completes +info: | + %AsyncFromSyncIteratorPrototype%.return ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let return be GetMethod(syncIterator, "return"). + 6. IfAbruptRejectPromise(return, promiseCapability). + ... + 8. Let returnResult be Call(return, syncIterator, « value »). + ... + 10. If Type(returnResult) is not Object, + a. Perform ! Call(promiseCapability.[[Reject]], undefined, « a TypeError exception »). + b. Return promiseCapability.[[Promise]]. + ... + 22. Return promiseCapability.[[Promise]]. + +flags: [async] +features: [async-iteration] +---*/ + +var obj = { + [Symbol.iterator]() { + return { + next() { + return { value: 1, done: false }; + }, + return() { + return 1; + } + }; + } +}; + +async function* asyncg() { + yield* obj; +} + +var iter = asyncg(); + +iter.next().then(function(result) { + + iter.return().then( + function (result) { + throw new Test262Error("Promise should be rejected, got: " + result.value); + }, + function (err) { + let typeerror = err instanceof TypeError; + assert(typeerror, "Expect TypeError, got: " + err); + + iter.next().then(({ done, value }) => { + assert.sameValue(done, true, 'the iterator is completed'); + assert.sameValue(value, undefined, 'value is undefined'); + }).then($DONE, $DONE); + } + ).catch($DONE); + +}).catch($DONE); + diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/return-null.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/return-null.js new file mode 100644 index 0000000000..50f94bba85 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/return-null.js @@ -0,0 +1,55 @@ +// |reftest| async +// Copyright (C) 2020 Alexey Shvayka. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.return +description: > + If syncIterator's "return" method is `null`, + a Promise resolved with `undefined` value is returned. +info: | + %AsyncFromSyncIteratorPrototype%.return ( value ) + + [...] + 5. Let return be GetMethod(syncIterator, "return"). + [...] + 7. If return is undefined, then + a. Let iterResult be ! CreateIterResultObject(value, true). + b. Perform ! Call(promiseCapability.[[Resolve]], undefined, « iterResult »). + c. Return promiseCapability.[[Promise]]. + + GetMethod ( V, P ) + + [...] + 2. Let func be ? GetV(V, P). + 3. If func is either undefined or null, return undefined. +flags: [async] +features: [async-iteration] +includes: [asyncHelpers.js] +---*/ + +var iterationCount = 0; +var returnGets = 0; + +var syncIterator = { + [Symbol.iterator]() { + return this; + }, + next() { + return {value: 1, done: false}; + }, + get return() { + returnGets += 1; + return null; + }, +}; + +asyncTest(async function() { + for await (let _ of syncIterator) { + iterationCount += 1; + break; + } + + assert.sameValue(iterationCount, 1); + assert.sameValue(returnGets, 1); +}); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/return-undefined.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/return-undefined.js new file mode 100644 index 0000000000..5e5e766288 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/return-undefined.js @@ -0,0 +1,55 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.throw +description: return() will return value undefined if sync `return` is undefined +info: | + %AsyncFromSyncIteratorPrototype%.return ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let return be GetMethod(syncIterator, "return"). + 6. IfAbruptRejectPromise(return, promiseCapability). + 7. If return is undefined, then + a. Let iterResult be ! CreateIterResultObject(value, true). + b. Perform ! Call(promiseCapability.[[Resolve]], undefined, « iterResult »). + c. Return promiseCapability.[[Promise]]. + +flags: [async] +features: [async-iteration] +---*/ + + +var obj = { + [Symbol.iterator]() { + return { + next() { + return { value: 1, done: false }; + } + }; + } +}; + +async function* asyncg() { + yield* obj; +} + +var iter = asyncg(); + +iter.next().then(function(result) { + + iter.return().then(function(result) { + + assert.sameValue(result.done, true, 'the iterator is completed'); + assert.sameValue(result.value, undefined, 'expect value to be undefined'); + + iter.next().then(({ done, value }) => { + assert.sameValue(done, true, 'the iterator is completed'); + assert.sameValue(value, undefined, 'value is undefined'); + }).then($DONE, $DONE); + + }).catch($DONE); + +}).catch($DONE); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/shell.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/shell.js new file mode 100644 index 0000000000..ae18ad584d --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return/shell.js @@ -0,0 +1,113 @@ +// GENERATED, DO NOT EDIT +// file: asyncHelpers.js +// Copyright (C) 2022 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + A collection of assertion and wrapper functions for testing asynchronous built-ins. +defines: [asyncTest] +---*/ + +function asyncTest(testFunc) { + if (!Object.hasOwn(globalThis, "$DONE")) { + throw new Test262Error("asyncTest called without async flag"); + } + if (typeof testFunc !== "function") { + $DONE(new Test262Error("asyncTest called with non-function argument")); + return; + } + try { + testFunc().then( + function () { + $DONE(); + }, + function (error) { + $DONE(error); + } + ); + } catch (syncError) { + $DONE(syncError); + } +} + +assert.throwsAsync = async function (expectedErrorConstructor, func, message) { + var innerThenable; + if (message === undefined) { + message = ""; + } else { + message += " "; + } + if (typeof func === "function") { + try { + innerThenable = func(); + if ( + innerThenable === null || + typeof innerThenable !== "object" || + typeof innerThenable.then !== "function" + ) { + message += + "Expected to obtain an inner promise that would reject with a" + + expectedErrorConstructor.name + + " but result was not a thenable"; + throw new Test262Error(message); + } + } catch (thrown) { + message += + "Expected a " + + expectedErrorConstructor.name + + " to be thrown asynchronously but an exception was thrown synchronously while obtaining the inner promise"; + throw new Test262Error(message); + } + } else { + message += + "assert.throwsAsync called with an argument that is not a function"; + throw new Test262Error(message); + } + + try { + return innerThenable.then( + function () { + message += + "Expected a " + + expectedErrorConstructor.name + + " to be thrown asynchronously but no exception was thrown at all"; + throw new Test262Error(message); + }, + function (thrown) { + var expectedName, actualName; + if (typeof thrown !== "object" || thrown === null) { + message += "Thrown value was not an object!"; + throw new Test262Error(message); + } else if (thrown.constructor !== expectedErrorConstructor) { + expectedName = expectedErrorConstructor.name; + actualName = thrown.constructor.name; + if (expectedName === actualName) { + message += + "Expected a " + + expectedName + + " but got a different error constructor with the same name"; + } else { + message += + "Expected a " + expectedName + " but got a " + actualName; + } + throw new Test262Error(message); + } + } + ); + } catch (thrown) { + if (typeof thrown !== "object" || thrown === null) { + message += + "Expected a " + + expectedErrorConstructor.name + + " to be thrown asynchronously but innerThenable synchronously threw a value that was not an object "; + } else { + message += + "Expected a " + + expectedErrorConstructor.name + + " to be thrown asynchronously but a " + + thrown.constructor.name + + " was thrown synchronously"; + } + throw new Test262Error(message); + } +}; diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/shell.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/shell.js new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/shell.js diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/browser.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/browser.js new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/browser.js diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/iterator-result-poisoned-done.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/iterator-result-poisoned-done.js new file mode 100644 index 0000000000..bab1bf956d --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/iterator-result-poisoned-done.js @@ -0,0 +1,70 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.throw +description: throw() will reject promise if getter `done` abrupt completes +info: | + %AsyncFromSyncIteratorPrototype%.throw ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let throw be GetMethod(syncIterator, "throw"). + ... + 8. Let throwResult be Call(throw, syncIterator, « value »). + ... + 11. Let throwDone be IteratorComplete(throwResult). + 12. IfAbruptRejectPromise(throwDone, promiseCapability). + 13. Let throwValue be IteratorValue(throwResult). + 14. IfAbruptRejectPromise(throwValue, promiseCapability). + ... + 20. Return promiseCapability.[[Promise]]. + +flags: [async] +features: [async-iteration] +---*/ + +var thrownError = new Error("Catch me."); + +var obj = { + [Symbol.iterator]() { + return { + next() { + return { value: 1, done: false }; + }, + throw() { + return { + get done() { + throw thrownError; + }, + value: 1 + }; + } + }; + } +}; + +async function* asyncg() { + yield* obj; +} + +var iter = asyncg(); + +iter.next().then(function(result) { + + iter.throw().then( + function (result) { + throw new Test262Error("Promise should be rejected, got: " + result.value); + }, + function (err) { + assert.sameValue(err, thrownError, "Promise should be rejected with thrown error"); + + iter.next().then(({ done, value }) => { + assert.sameValue(done, true, 'the iterator is completed'); + assert.sameValue(value, undefined, 'value is undefined'); + }).then($DONE, $DONE); + } + ).catch($DONE); + +}).catch($DONE); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/iterator-result-poisoned-value.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/iterator-result-poisoned-value.js new file mode 100644 index 0000000000..9745df52c1 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/iterator-result-poisoned-value.js @@ -0,0 +1,70 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.throw +description: throw() will reject promise if getter `value` abrupt completes +info: | + %AsyncFromSyncIteratorPrototype%.throw ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let throw be GetMethod(syncIterator, "throw"). + ... + 8. Let throwResult be Call(throw, syncIterator, « value »). + ... + 11. Let throwDone be IteratorComplete(throwResult). + 12. IfAbruptRejectPromise(throwDone, promiseCapability). + 13. Let throwValue be IteratorValue(throwResult). + 14. IfAbruptRejectPromise(throwValue, promiseCapability). + ... + 20. Return promiseCapability.[[Promise]]. + +flags: [async] +features: [async-iteration] +---*/ + +var thrownError = new Error("Catch me."); + +var obj = { + [Symbol.iterator]() { + return { + next() { + return { value: 1, done: false }; + }, + throw() { + return { + get value() { + throw thrownError; + }, + done: false + }; + } + } + } +}; + +async function* asyncg() { + yield* obj; +} + +var iter = asyncg(); + +iter.next().then(function(result) { + + iter.throw().then( + function (result) { + throw new Test262Error("Promise should be rejected, got: " + result.value); + }, + function (err) { + assert.sameValue(err, thrownError, "Promise should be rejected with thrown error"); + + iter.next().then(({ done, value }) => { + assert.sameValue(done, true, 'the iterator is completed'); + assert.sameValue(value, undefined, 'value is undefined'); + }).then($DONE, $DONE); + } + ).catch($DONE); + +}).catch($DONE); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/iterator-result-rejected-promise-close.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/iterator-result-rejected-promise-close.js new file mode 100644 index 0000000000..4d27039be8 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/iterator-result-rejected-promise-close.js @@ -0,0 +1,84 @@ +// |reftest| async +// Copyright (C) 2024 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.throw +description: throw() will reject promise if resolving result promise abrupt completes. +info: | + %AsyncFromSyncIteratorPrototype%.throw ( value ) + ... + 3. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 4. Let syncIteratorRecord be O.[[SyncIteratorRecord]]. + 5. Let syncIterator be syncIteratorRecord.[[Iterator]]. + 6. Let throw be GetMethod(syncIterator, "throw"). + ... + 9. If value is present, then + ... + 10. Else, + a. Let result be Call(throw,syncIterator). + ... + 13. Return ! AsyncFromSyncIteratorContinuation(result, promiseCapability, syncIteratorRecord, true). + + AsyncFromSyncIteratorContinuation ( result, promiseCapability, syncIteratorRecord, closeOnRejection ) + 1. Let done be IteratorComplete(result). + 2. IfAbruptRejectPromise(done, promiseCapability). + 3. Let value be IteratorValue(result). + 4. IfAbruptRejectPromise(value, promiseCapability). + 5. Let valueWrapper be PromiseResolve(%Promise%, value). + 6. If valueWrapper is an abrupt completion, done is false, and closeOnRejection is true, then + a. Set valueWrapper to IteratorClose(syncIteratorRecord, valueWrapper). + ... + 12. If done is true, or if closeOnRejection is false, then + ... + 13. Else, + a. Let closeIterator be a new Abstract Closure with parameters (error) that captures syncIteratorRecord and performs the following steps when called: + i. Return ? IteratorClose(syncIteratorRecord, ThrowCompletion(error)). + b. Let onRejected be CreateBuiltinFunction(closeIterator, 1, "", « »). + c. NOTE: onRejected is used to close the Iterator when the "value" property of an IteratorResult object it yields is a rejected promise. + 14. Perform PerformPromiseThen(valueWrapper, onFulfilled, onRejected, promiseCapability). + 15. Return promiseCapability.[[Promise]]. + +flags: [async] +features: [async-iteration] +includes: [asyncHelpers.js] +---*/ + +var returnCount = 0; +function Reject() {} + +var obj = { + [Symbol.iterator]() { + return { + next() { + return { value: 1, done: false }; + }, + throw() { + return { + value: Promise.reject(new Reject()), + done: false + }; + }, + return() { + returnCount += 1; + } + }; + } +}; + +async function* asyncg() { + return yield* obj; +} + +let iter = asyncg(); + +asyncTest(async function () { + await assert.throwsAsync(Reject, async () => { + await iter.next(); + return iter.throw(); + }, "Promise should be rejected"); + assert.sameValue(returnCount, 1); + const result = await iter.next(); + assert(result.done, "the iterator is completed"); + assert.sameValue(result.value, undefined, "value is undefined"); +}) diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/iterator-result-unwrap-promise.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/iterator-result-unwrap-promise.js new file mode 100644 index 0000000000..9542254c75 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/iterator-result-unwrap-promise.js @@ -0,0 +1,66 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.throw +description: throw() will unwrap a Promise value return by the sync iterator +info: | + %AsyncFromSyncIteratorPrototype%.throw ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let throw be GetMethod(syncIterator, "throw"). + ... + 17. Let steps be the algorithm steps defined in Async-from-Sync Iterator Value Unwrap Functions. + ... + 20. Return promiseCapability.[[Promise]]. + + Async-from-Sync Iterator Value Unwrap Functions + An async-from-sync iterator value unwrap function is an anonymous built-in + function that is used by methods of %AsyncFromSyncIteratorPrototype% when + processing the value field of an IteratorResult object, in order to wait for + its value if it is a promise and re-package the result in a new "unwrapped" + IteratorResult object. Each async iterator value unwrap function has a + [[Done]] internal slot. + +flags: [async] +features: [async-iteration] +---*/ + +var thrownError = new Error("Don't catch me.") + +var obj = { + [Symbol.iterator]() { + return { + next() { + return { value: 1, done: false }; + }, + throw() { + return { + value: Promise.resolve(42), + done: true + }; + } + }; + } +}; + +async function* asyncg() { + return yield* obj; +} + +let iter = asyncg(); + +iter.next().then(function (result) { + iter.throw(thrownError).then( + function (result) { + assert.sameValue(result.value, 42, "Result.value should be unwrapped, got: " + result.value); + + iter.next().then(({ done, value }) => { + assert.sameValue(done, true, 'the iterator is completed'); + assert.sameValue(value, undefined, 'value is undefined'); + }).then($DONE, $DONE); + } + ).catch($DONE); +}).catch($DONE); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/iterator-result.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/iterator-result.js new file mode 100644 index 0000000000..90b02da8c2 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/iterator-result.js @@ -0,0 +1,60 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.throw +description: throw() will call default sync throw +info: | + %AsyncFromSyncIteratorPrototype%.throw ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let throw be GetMethod(syncIterator, "throw"). + ... + 8. Let throwResult be Call(throw, syncIterator, « value ») + 9. IfAbruptRejectPromise(throwResult, promiseCapability). + ... + 22. Return promiseCapability.[[Promise]]. + + Generator.prototype.throw ( exception ) + 1. Let g be the this value. + 2. Let C be Completion{[[Type]]: throw, [[Value]]: exception, [[Target]]: empty}. + 3. Return ? GeneratorResumeAbrupt(g, C). + +flags: [async] +features: [async-iteration] +---*/ + +var thrownError = new Error("Catch me.") + +function* g() { + yield 42; + throw new Test262Error('throw closes iter'); + yield 43; +} + +async function* asyncg() { + yield* g(); +} + +var iter = asyncg(); + +iter.next().then(function(result) { + + // throw will call sync generator prototype built-in function throw + iter.throw(thrownError).then( + function(result) { + throw new Test262Error('throw should cause rejection of promise'); + }, + function(err) { + assert.sameValue(err, thrownError, "promise should be reject with custom error, got: " + err) + + iter.next().then(({ done, value }) => { + assert.sameValue(done, true, 'the iterator is completed'); + assert.sameValue(value, undefined, 'value is undefined'); + }).then($DONE, $DONE); + } + ).catch($DONE); + +}).catch($DONE); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/poisoned-get-throw.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/poisoned-get-throw.js new file mode 100644 index 0000000000..5a87c2e2ba --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/poisoned-get-throw.js @@ -0,0 +1,59 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.throw +description: throw() will return rejected promise if getter of `throw` abrupt completes +info: | + %AsyncFromSyncIteratorPrototype%.return ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let return be GetMethod(syncIterator, "throw"). + 6. IfAbruptRejectPromise(throw, promiseCapability). + ... + 22. Return promiseCapability.[[Promise]]. + +flags: [async] +features: [async-iteration] +---*/ + +var thrownError = new Error("Catch me."); + +var obj = { + [Symbol.iterator]() { + return { + next() { + return { value: 1, done: false }; + }, + get throw() { + throw thrownError; + } + }; + } +}; + +async function* asyncg() { + yield* obj; +} + +var iter = asyncg(); + +iter.next().then(function(result) { + + iter.throw().then( + function (result) { + throw new Test262Error("Promise should be rejected, got: " + result.value); + }, + function (err) { + assert.sameValue(err, thrownError, "Promise should be rejected with thrown error"); + + iter.next().then(({ done, value }) => { + assert.sameValue(done, true, 'the iterator is completed'); + assert.sameValue(value, undefined, 'value is undefined'); + }).then($DONE, $DONE); + } + ).catch($DONE); + +}).catch($DONE); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/poisoned-throw.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/poisoned-throw.js new file mode 100644 index 0000000000..15656dbff8 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/poisoned-throw.js @@ -0,0 +1,61 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.throw +description: throw() will return rejected promise if getter of `throw` abrupt completes +info: | + %AsyncFromSyncIteratorPrototype%.throw ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let throw be GetMethod(syncIterator, "throw"). + 6. IfAbruptRejectPromise(throw, promiseCapability). + ... + 8. Let throwResult be Call(throw, syncIterator, « value »). + 9. IfAbruptRejectPromise(throwResult, promiseCapability). + ... + 22. Return promiseCapability.[[Promise]]. + +flags: [async] +features: [async-iteration] +---*/ + +var thrownError = new Error("Catch me."); + +var obj = { + [Symbol.iterator]() { + return { + next() { + return { value: 1, done: false }; + }, + throw() { + throw thrownError; + } + }; + } +}; + +async function* asyncg() { + yield* obj; +} + +var iter = asyncg(); + +iter.next().then(function(result) { + + iter.throw().then( + function (result) { + throw new Test262Error("Promise should be rejected, got: " + result.value); + }, + function (err) { + assert.sameValue(err, thrownError, "Promise should be rejected with thrown error"); + + iter.next().then(({ done, value }) => { + assert.sameValue(done, true, 'the iterator is completed'); + assert.sameValue(value, undefined, 'value is undefined'); + }).then($DONE, $DONE); + } + ).catch($DONE); +}).catch($DONE); diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/result-object-error.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/result-object-error.js new file mode 100644 index 0000000000..f59d06cc8a --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/result-object-error.js @@ -0,0 +1,65 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.throw +description: throw() will return rejected promise if getter of `throw` abrupt completes +info: | + %AsyncFromSyncIteratorPrototype%.throw ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let throw be GetMethod(syncIterator, "throw"). + 6. IfAbruptRejectPromise(thow, promiseCapability). + ... + 8. Let throwResult be Call(throw, syncIterator, « value »). + ... + 10. If Type(throwResult) is not Object, + a. Perform ! Call(promiseCapability.[[Reject]], undefined, « a TypeError exception »). + b. Return promiseCapability.[[Promise]]. + +flags: [async] +features: [async-iteration] +---*/ + +var thrownError = new Error("Don't catch me.") + +var obj = { + [Symbol.iterator]() { + return { + next() { + return { value: 1, done: false }; + }, + throw() { + return 1; + } + }; + } +}; + +async function* asyncg() { + yield* obj; +} + +var iter = asyncg(); + +iter.next().then(function(result) { + + iter.throw(thrownError).then( + function (result) { + throw new Test262Error("Promise should be rejected, got: " + result.value); + }, + function (err) { + let typeerror = err instanceof TypeError; + assert(typeerror, "Expect TypeError, got: " + err); + + iter.next().then(({ done, value }) => { + assert.sameValue(done, true, 'the iterator is completed'); + assert.sameValue(value, undefined, 'value is undefined'); + }).then($DONE, $DONE); + } + ).catch($DONE); + +}).catch($DONE); + diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/shell.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/shell.js new file mode 100644 index 0000000000..ae18ad584d --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/shell.js @@ -0,0 +1,113 @@ +// GENERATED, DO NOT EDIT +// file: asyncHelpers.js +// Copyright (C) 2022 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: | + A collection of assertion and wrapper functions for testing asynchronous built-ins. +defines: [asyncTest] +---*/ + +function asyncTest(testFunc) { + if (!Object.hasOwn(globalThis, "$DONE")) { + throw new Test262Error("asyncTest called without async flag"); + } + if (typeof testFunc !== "function") { + $DONE(new Test262Error("asyncTest called with non-function argument")); + return; + } + try { + testFunc().then( + function () { + $DONE(); + }, + function (error) { + $DONE(error); + } + ); + } catch (syncError) { + $DONE(syncError); + } +} + +assert.throwsAsync = async function (expectedErrorConstructor, func, message) { + var innerThenable; + if (message === undefined) { + message = ""; + } else { + message += " "; + } + if (typeof func === "function") { + try { + innerThenable = func(); + if ( + innerThenable === null || + typeof innerThenable !== "object" || + typeof innerThenable.then !== "function" + ) { + message += + "Expected to obtain an inner promise that would reject with a" + + expectedErrorConstructor.name + + " but result was not a thenable"; + throw new Test262Error(message); + } + } catch (thrown) { + message += + "Expected a " + + expectedErrorConstructor.name + + " to be thrown asynchronously but an exception was thrown synchronously while obtaining the inner promise"; + throw new Test262Error(message); + } + } else { + message += + "assert.throwsAsync called with an argument that is not a function"; + throw new Test262Error(message); + } + + try { + return innerThenable.then( + function () { + message += + "Expected a " + + expectedErrorConstructor.name + + " to be thrown asynchronously but no exception was thrown at all"; + throw new Test262Error(message); + }, + function (thrown) { + var expectedName, actualName; + if (typeof thrown !== "object" || thrown === null) { + message += "Thrown value was not an object!"; + throw new Test262Error(message); + } else if (thrown.constructor !== expectedErrorConstructor) { + expectedName = expectedErrorConstructor.name; + actualName = thrown.constructor.name; + if (expectedName === actualName) { + message += + "Expected a " + + expectedName + + " but got a different error constructor with the same name"; + } else { + message += + "Expected a " + expectedName + " but got a " + actualName; + } + throw new Test262Error(message); + } + } + ); + } catch (thrown) { + if (typeof thrown !== "object" || thrown === null) { + message += + "Expected a " + + expectedErrorConstructor.name + + " to be thrown asynchronously but innerThenable synchronously threw a value that was not an object "; + } else { + message += + "Expected a " + + expectedErrorConstructor.name + + " to be thrown asynchronously but a " + + thrown.constructor.name + + " was thrown synchronously"; + } + throw new Test262Error(message); + } +}; diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-null.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-null.js new file mode 100644 index 0000000000..afe9c0d2a3 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-null.js @@ -0,0 +1,60 @@ +// |reftest| async +// Copyright (C) 2020 Alexey Shvayka. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.throw +description: > + If syncIterator's "throw" method is `null`, + a Promise rejected with provided value is returned. +info: | + %AsyncFromSyncIteratorPrototype%.throw ( value ) + + [...] + 6. Let throw be GetMethod(syncIterator, "throw"). + [...] + 8. If throw is undefined, then + ... + g. Perform ! Call(promiseCapability.[[Reject]], undefined, « a newly created TypeError object »). + h. Return promiseCapability.[[Promise]]. + + GetMethod ( V, P ) + + [...] + 2. Let func be ? GetV(V, P). + 3. If func is either undefined or null, return undefined. +flags: [async] +features: [async-iteration] +includes: [asyncHelpers.js] +---*/ + +var throwGets = 0; +var syncIterator = { + [Symbol.iterator]() { + return this; + }, + next() { + return {value: 1, done: false}; + }, + get throw() { + throwGets += 1; + return null; + }, +}; + +async function* asyncGenerator() { + yield* syncIterator; +} + +var asyncIterator = asyncGenerator(); +var thrownError = { name: "err" }; + +asyncTest(async function () { + await assert.throwsAsync(TypeError, async () => { + await asyncIterator.next(); + return asyncIterator.throw(thrownError); + }, "Promise should be rejected"); + const result = await asyncIterator.next(); + assert(result.done, "the iterator is completed"); + assert.sameValue(result.value, undefined, "value is undefined"); +}) diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-result-poisoned-wrapper.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-result-poisoned-wrapper.js new file mode 100644 index 0000000000..4edbcfe390 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-result-poisoned-wrapper.js @@ -0,0 +1,91 @@ +// |reftest| async +// Copyright (C) 2023 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.throw +description: throw() will reject promise if resolving result promise abrupt completes. +info: | + %AsyncFromSyncIteratorPrototype%.throw ( value ) + ... + 3. Let promiseCapability be ! NewPromiseCapability(%Promise%). + 4. Let syncIteratorRecord be O.[[SyncIteratorRecord]]. + 5. Let syncIterator be syncIteratorRecord.[[Iterator]]. + 6. Let throw be GetMethod(syncIterator, "throw"). + 7. IfAbruptRejectPromise(throw, promiseCapability). + 8. If throw is undefined, then + ... + 9. If value is present, then + ... + 10. Else, + a. Let result be Call(throw, syncIterator). + ... + 13. Return ! AsyncFromSyncIteratorContinuation(result, promiseCapability, syncIteratorRecord, true). + + AsyncFromSyncIteratorContinuation ( result, promiseCapability, syncIteratorRecord, closeOnRejection ) + 1. Let done be IteratorComplete(result). + 2. IfAbruptRejectPromise(done, promiseCapability). + 3. Let value be IteratorValue(result). + 4. IfAbruptRejectPromise(value, promiseCapability). + 5. Let valueWrapper be PromiseResolve(%Promise%, value). + 6. If valueWrapper is an abrupt completion, done is false, and closeOnRejection is true, then + a. Set valueWrapper to IteratorClose(syncIteratorRecord, valueWrapper). + 7. IfAbruptRejectPromise(valueWrapper, promiseCapability). + ... + + IfAbruptRejectPromise ( value, capability ) + 1. Assert: value is a Completion Record. + 2. If value is an abrupt completion, then + a. Perform ? Call(capability.[[Reject]], undefined, « value.[[Value]] »). + b. Return capability.[[Promise]]. + ... + +flags: [async] +features: [async-iteration] +includes: [asyncHelpers.js] +---*/ + +var returnCount = 0; +function CatchError() {} +var thrownError = new CatchError(); +var uncaughtError = new Error("Don't catch me"); + +const obj = { + [Symbol.iterator]() { + return { + next() { + return { value: 1, done: false }; + }, + throw() { + const p = Promise.resolve('FAIL'); + Object.defineProperty(p, 'constructor', { + get() { + throw thrownError; + } + }); + return { value: p, done: false }; + }, + return() { + returnCount += 1; + return { value: undefined, done: true }; + } + }; + } +}; + +async function* asyncg() { + return yield* obj; +} + +let iter = asyncg(); + +asyncTest(async function () { + await assert.throwsAsync(CatchError, async () => { + await iter.next(); + return iter.throw(uncaughtError); + }, "Promise should be rejected"); + assert.sameValue(returnCount, 1, 'iterator closed properly'); + const result = await iter.next(); + assert(result.done, "the iterator is completed"); + assert.sameValue(result.value, undefined, "value is undefined"); +}) diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-undefined-get-return-undefined.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-undefined-get-return-undefined.js new file mode 100644 index 0000000000..c3ef881b7b --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-undefined-get-return-undefined.js @@ -0,0 +1,74 @@ +// |reftest| async +// Copyright (C) 2023 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.throw +description: > + If syncIterator's "throw" method is `undefined`, + and its "return" method returns `undefined`, + the iterator will close returning the `undefined` value, + which will be ignored and instead a rejected Promise with a new TypeError is returned. +info: | + %AsyncFromSyncIteratorPrototype%.throw ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let return be GetMethod(syncIterator, "throw"). + 6. IfAbruptRejectPromise(throw, promiseCapability). + 7. If throw is undefined, then + a. NOTE: If syncIterator does not have a throw method, close it to give it a chance to clean up before we reject the capability. + b. Let closeCompletion be Completion { [[Type]]: normal, [[Value]]: empty, [[Target]]: empty }. + c. Set result to IteratorClose(syncIteratorRecord, closeCompletion). + ... + g. Perform ! Call(promiseCapability.[[Reject]], undefined, « a newly created TypeError object »). + h. Return promiseCapability.[[Promise]]. + ... + + IteratorClose ( iterator, completion ) + ... + 2. Let iterator be iteratorRecord.[[Iterator]]. + 3. Let innerResult be Completion(GetMethod(iterator, "return")). + 4. If innerResult.[[Type]] is normal, then + a. Let return be innerResult.[[Value]]. + b. If return is undefined, return ? completion. + ... + +flags: [async] +features: [async-iteration] +includes: [asyncHelpers.js] +---*/ + +var returnCount = 0; + +const obj = { + [Symbol.iterator]() { + return { + next() { + return {value: 1, done: false}; + }, + get return() { + returnCount += 1; + return undefined; + } + }; + } +}; + +async function* wrapper() { + yield* obj; +} + +var iter = wrapper(); + +asyncTest(async function () { + await assert.throwsAsync(TypeError, async () => { + await iter.next(); + return iter.throw(); + }, "Promise should be rejected"); + assert.sameValue(returnCount, 1, 'iterator closed properly'); + const result = await iter.next(); + assert(result.done, "the iterator is completed"); + assert.sameValue(result.value, undefined, "value is undefined"); +}) + diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-undefined-poisoned-return.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-undefined-poisoned-return.js new file mode 100644 index 0000000000..5b0b5ae56a --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-undefined-poisoned-return.js @@ -0,0 +1,78 @@ +// |reftest| async +// Copyright (C) 2023 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.throw +description: throw() will close the iterator and return rejected promise if sync `throw` undefined +info: | + %AsyncFromSyncIteratorPrototype%.throw ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let return be GetMethod(syncIterator, "throw"). + 6. IfAbruptRejectPromise(throw, promiseCapability). + 7. If throw is undefined, then + a. NOTE: If syncIterator does not have a throw method, close it to give it a chance to clean up before we reject the capability. + b. Let closeCompletion be Completion { [[Type]]: normal, [[Value]]: empty, [[Target]]: empty }. + c. Set result to IteratorClose(syncIteratorRecord, closeCompletion). + d. IfAbruptRejectPromise(result, promiseCapability). + e. NOTE: The next step throws a TypeError to indicate that there was a protocol violation: syncIterator does not have a throw method. + f. NOTE: If closing syncIterator does not throw then the result of that operation is ignored, even if it yields a rejected promise. + g. Perform ! Call(promiseCapability.[[Reject]], undefined, « a newly created TypeError object »). + h. Return promiseCapability.[[Promise]]. + + IteratorClose ( iterator, completion ) + ... + 2. Let iterator be iteratorRecord.[[Iterator]]. + 3. Let innerResult be Completion(GetMethod(iterator, "return")). + ... + 6. If innerResult.[[Type]] is throw, return ? innerResult. + ... + + IfAbruptRejectPromise ( value, capability ) + 1. Assert: value is a Completion Record. + 2. If value is an abrupt completion, then + a. Perform ? Call(capability.[[Reject]], undefined, « value.[[Value]] »). + b. Return capability.[[Promise]]. + ... + +flags: [async] +features: [async-iteration] +includes: [asyncHelpers.js] +---*/ + +var returnCount = 0; +function CatchError() {} +var thrownError = new CatchError(); + +const obj = { + [Symbol.iterator]() { + return { + next() { + return {value: 1, done: false}; + }, + get return() { + returnCount += 1; + throw thrownError; + } + }; + } +}; + +async function* wrapper() { + yield* obj; +} + +var iter = wrapper(); + +asyncTest(async function () { + await assert.throwsAsync(CatchError, async () => { + await iter.next(); + return iter.throw(); + }, "Promise should be rejected"); + assert.sameValue(returnCount, 1, 'iterator closed properly'); + const result = await iter.next(); + assert(result.done, "the iterator is completed"); + assert.sameValue(result.value, undefined, "value is undefined"); +}) diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-undefined-return-not-object.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-undefined-return-not-object.js new file mode 100644 index 0000000000..28de5558e0 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-undefined-return-not-object.js @@ -0,0 +1,81 @@ +// |reftest| async +// Copyright (C) 2023 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.throw +description: > + If syncIterator's "throw" method is `undefined`, + and its "return" method returns `undefined`, + the iterator will close returning the `undefined` value, + which will be ignored and instead a rejected Promise with a new TypeError is returned. +info: | + %AsyncFromSyncIteratorPrototype%.throw ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let return be GetMethod(syncIterator, "throw"). + 6. IfAbruptRejectPromise(throw, promiseCapability). + 7. If throw is undefined, then + a. NOTE: If syncIterator does not have a throw method, close it to give it a chance to clean up before we reject the capability. + b. Let closeCompletion be Completion { [[Type]]: normal, [[Value]]: empty, [[Target]]: empty }. + c. Set result to IteratorClose(syncIteratorRecord, closeCompletion). + d. IfAbruptRejectPromise(result, promiseCapability). + ... + + IteratorClose ( iterator, completion ) + ... + 2. Let iterator be iteratorRecord.[[Iterator]]. + 3. Let innerResult be Completion(GetMethod(iterator, "return")). + 4. If innerResult.[[Type]] is normal, then + a. Let return be innerResult.[[Value]]. + ... + c. Set innerResult to Completion(Call(return, iterator)). + ... + 7. If innerResult.[[Value]] is not an Object, throw a TypeError exception. + ... + + IfAbruptRejectPromise ( value, capability ) + 1. Assert: value is a Completion Record. + 2. If value is an abrupt completion, then + a. Perform ? Call(capability.[[Reject]], undefined, « value.[[Value]] »). + b. Return capability.[[Promise]]. + ... + +flags: [async] +features: [async-iteration] +includes: [asyncHelpers.js] +---*/ + +var returnCount = 0; + +const obj = { + [Symbol.iterator]() { + return { + next() { + return {value: 1, done: false}; + }, + return() { + returnCount += 1; + return 2; + } + }; + } +}; + +async function* wrapper() { + yield* obj; +} + +var iter = wrapper(); + +asyncTest(async function () { + await assert.throwsAsync(TypeError, async () => { + await iter.next(); + return iter.throw(); + }, "Promise should be rejected"); + assert.sameValue(returnCount, 1, 'iterator closed properly'); + const result = await iter.next(); + assert(result.done, "the iterator is completed"); + assert.sameValue(result.value, undefined, "value is undefined"); +}) diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-undefined-return-object.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-undefined-return-object.js new file mode 100644 index 0000000000..30e660a0e8 --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-undefined-return-object.js @@ -0,0 +1,75 @@ +// |reftest| async +// Copyright (C) 2023 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.throw +description: > + If syncIterator's "throw" method is `undefined`, + and its "return" method returns `undefined`, + the iterator will close returning the `undefined` value, + which will be ignored and instead a rejected Promise with a new TypeError is returned. +info: | + %AsyncFromSyncIteratorPrototype%.throw ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 5. Let return be GetMethod(syncIterator, "throw"). + ... + 7. If throw is undefined, then + a. NOTE: If syncIterator does not have a throw method, close it to give it a chance to clean up before we reject the capability. + b. Let closeCompletion be Completion { [[Type]]: normal, [[Value]]: empty, [[Target]]: empty }. + c. Set result to IteratorClose(syncIteratorRecord, closeCompletion). + ... + g. Perform ! Call(promiseCapability.[[Reject]], undefined, « a newly created TypeError object »). + h. Return promiseCapability.[[Promise]]. + ... + + IteratorClose ( iterator, completion ) + ... + 2. Let iterator be iteratorRecord.[[Iterator]]. + 3. Let innerResult be Completion(GetMethod(iterator, "return")). + 4. If innerResult.[[Type]] is normal, then + a. Let return be innerResult.[[Value]]. + ... + c. Set innerResult to Completion(Call(return, iterator)). + ... + 8. Return ? completion. + +flags: [async] +features: [async-iteration] +includes: [asyncHelpers.js] +---*/ + +var returnCount = 0; + +const obj = { + [Symbol.iterator]() { + return { + next() { + return {value: 1, done: false}; + }, + return() { + returnCount += 1; + return {value: 2, done: true}; + } + }; + } +}; + +async function* wrapper() { + yield* obj; +} + +var iter = wrapper(); + +asyncTest(async function () { + await assert.throwsAsync(TypeError, async () => { + await iter.next(); + return iter.throw(); + }, "Promise should be rejected"); + assert.sameValue(returnCount, 1, 'iterator closed properly'); + const result = await iter.next(); + assert(result.done, "the iterator is completed"); + assert.sameValue(result.value, undefined, "value is undefined"); +}) diff --git a/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-undefined.js b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-undefined.js new file mode 100644 index 0000000000..4c478c270b --- /dev/null +++ b/js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/throw/throw-undefined.js @@ -0,0 +1,49 @@ +// |reftest| async +// Copyright (C) 2018 Valerie Young. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-%asyncfromsynciteratorprototype%.throw +description: throw() will return rejected promise if sync `throw` undefined +info: | + %AsyncFromSyncIteratorPrototype%.throw ( value ) + ... + 2. Let promiseCapability be ! NewPromiseCapability(%Promise%). + ... + 6. Let throw be GetMethod(syncIterator, "throw"). + [...] + 8. If throw is undefined, then + ... + g. Perform ! Call(promiseCapability.[[Reject]], undefined, « a newly created TypeError object »). + h. Return promiseCapability.[[Promise]]. + +flags: [async] +features: [async-iteration] +includes: [asyncHelpers.js] +---*/ + +var obj = { + [Symbol.iterator]() { + return { + next() { + return { value: 1, done: false }; + } + }; + } +}; + +async function* asyncg() { + yield* obj; +} + +var iter = asyncg(); + +asyncTest(async function () { + await assert.throwsAsync(TypeError, async () => { + await iter.next(); + return iter.throw(); + }, "Promise should be rejected"); + const result = await iter.next(); + assert(result.done, "the iterator is completed"); + assert.sameValue(result.value, undefined, "value is undefined"); +}) |