diff options
Diffstat (limited to 'js/src/tests/test262/built-ins/AsyncFromSyncIteratorPrototype/return')
12 files changed, 720 insertions, 0 deletions
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); + } +}; |