From 4914e47d0b153c90972e3d88632958431a4f941e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E2=AD=90caitp=E2=AD=90?= Date: Mon, 6 Mar 2017 10:48:13 -0500 Subject: [PATCH] Add tests for Async Generator flow control (#871) --- .../return-suspendedStart-promise.js | 36 +++++++++++++++ .../async-generators/return-suspendedStart.js | 27 +++++++++++ .../return-suspendedYield-promise.js | 41 +++++++++++++++++ ...eturn-suspendedYield-try-finally-return.js | 40 ++++++++++++++++ ...return-suspendedYield-try-finally-throw.js | 41 +++++++++++++++++ .../return-suspendedYield-try-finally.js | 46 +++++++++++++++++++ .../async-generators/return-suspendedYield.js | 36 +++++++++++++++ .../throw-suspendedStart-promise.js | 30 ++++++++++++ .../async-generators/throw-suspendedStart.js | 27 +++++++++++ .../throw-suspendedYield-promise.js | 39 ++++++++++++++++ .../throw-suspendedYield-try-catch.js | 42 +++++++++++++++++ ...throw-suspendedYield-try-finally-return.js | 42 +++++++++++++++++ .../throw-suspendedYield-try-finally-throw.js | 41 +++++++++++++++++ .../throw-suspendedYield-try-finally.js | 46 +++++++++++++++++++ .../async-generators/throw-suspendedYield.js | 36 +++++++++++++++ 15 files changed, 570 insertions(+) create mode 100644 test/language/expressions/async-generators/return-suspendedStart-promise.js create mode 100644 test/language/expressions/async-generators/return-suspendedStart.js create mode 100644 test/language/expressions/async-generators/return-suspendedYield-promise.js create mode 100644 test/language/expressions/async-generators/return-suspendedYield-try-finally-return.js create mode 100644 test/language/expressions/async-generators/return-suspendedYield-try-finally-throw.js create mode 100644 test/language/expressions/async-generators/return-suspendedYield-try-finally.js create mode 100644 test/language/expressions/async-generators/return-suspendedYield.js create mode 100644 test/language/expressions/async-generators/throw-suspendedStart-promise.js create mode 100644 test/language/expressions/async-generators/throw-suspendedStart.js create mode 100644 test/language/expressions/async-generators/throw-suspendedYield-promise.js create mode 100644 test/language/expressions/async-generators/throw-suspendedYield-try-catch.js create mode 100644 test/language/expressions/async-generators/throw-suspendedYield-try-finally-return.js create mode 100644 test/language/expressions/async-generators/throw-suspendedYield-try-finally-throw.js create mode 100644 test/language/expressions/async-generators/throw-suspendedYield-try-finally.js create mode 100644 test/language/expressions/async-generators/throw-suspendedYield.js diff --git a/test/language/expressions/async-generators/return-suspendedStart-promise.js b/test/language/expressions/async-generators/return-suspendedStart-promise.js new file mode 100644 index 0000000000..a73fdeb667 --- /dev/null +++ b/test/language/expressions/async-generators/return-suspendedStart-promise.js @@ -0,0 +1,36 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: pending +description: > + AsyncGeneratorResumeNext: + If completion.[[Type]] is return, and generator.[[AsyncGeneratorState]] is + "suspendedStart", generator is closed without being resumed. + + AsyncGeneratorResolve will unwrap Promise values (steps 6-10) +flags: [async] +---*/ + +var g = async function*() { + throw new Test262Error('Generator must not be resumed.'); +}; + +var it = g(); +var resolve; +var promise = new Promise(function(resolver) { + resolve = resolver; +}); + +it.return(promise).then(function(ret) { + assert.sameValue(ret.value, 'unwrapped-value', 'AsyncGeneratorResolve(generator, completion.[[Value]], true)'); + assert.sameValue(ret.done, true, 'AsyncGeneratorResolve(generator, completion.[[Value]], true)'); + + it.next().then(function(ret) { + assert.sameValue(ret.value, undefined, 'Generator is closed'); + assert.sameValue(ret.done, true, 'Generator is closed'); + }).then($DONE, $DONE); +}).catch($DONE); + +resolve('unwrapped-value'); diff --git a/test/language/expressions/async-generators/return-suspendedStart.js b/test/language/expressions/async-generators/return-suspendedStart.js new file mode 100644 index 0000000000..22245f9ccc --- /dev/null +++ b/test/language/expressions/async-generators/return-suspendedStart.js @@ -0,0 +1,27 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: pending +description: > + AsyncGeneratorResumeNext: + If completion.[[Type]] is return, and generator.[[AsyncGeneratorState]] is + "suspendedStart", generator is closed without being resumed. +flags: [async] +---*/ + +var g = async function*() { + throw new Test262Error('Generator must not be resumed.'); +}; + +var it = g(); +it.return('sent-value').then(function(ret) { + assert.sameValue(ret.value, 'sent-value', 'AsyncGeneratorResolve(generator, completion.[[Value]], true)'); + assert.sameValue(ret.done, true, 'AsyncGeneratorResolve(generator, completion.[[Value]], true)'); + + it.next().then(function(ret) { + assert.sameValue(ret.value, undefined, 'Generator is closed'); + assert.sameValue(ret.done, true, 'Generator is closed'); + }).then($DONE, $DONE); +}).catch($DONE); diff --git a/test/language/expressions/async-generators/return-suspendedYield-promise.js b/test/language/expressions/async-generators/return-suspendedYield-promise.js new file mode 100644 index 0000000000..65a2859edd --- /dev/null +++ b/test/language/expressions/async-generators/return-suspendedYield-promise.js @@ -0,0 +1,41 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: pending +description: > + AsyncGeneratorResumeNext: + If completion.[[Type]] is return, and generator.[[AsyncGeneratorState]] is + "suspendedYield", generator is resumed and immediately closes the generator + and returns completion. +flags: [async] +---*/ + +var g = async function*() { + yield 1; + throw new Test262Error('Generator must not be resumed.'); +}; + +var it = g(); +var resolve; +var promise = new Promise(function(resolver) { + resolve = resolver; +}); +it.next().then(function(ret) { + assert.sameValue(ret.value, 1, 'Initial yield'); + assert.sameValue(ret.done, false, 'Initial yield'); + + it.return(promise).then(function(ret) { + assert.sameValue(ret.value, 'unwrapped-value', 'AsyncGeneratorResolve(generator, resultValue, true)'); + assert.sameValue(ret.done, true, 'AsyncGeneratorResolve(generator, resultValue, true)'); + + it.next().then(function(ret) { + assert.sameValue(ret.value, undefined, 'Generator is closed'); + assert.sameValue(ret.done, true, 'Generator is closed'); + }).then($DONE, $DONE); + + }).catch($DONE); + + resolve('unwrapped-value'); +}).catch($DONE); diff --git a/test/language/expressions/async-generators/return-suspendedYield-try-finally-return.js b/test/language/expressions/async-generators/return-suspendedYield-try-finally-return.js new file mode 100644 index 0000000000..398b415a72 --- /dev/null +++ b/test/language/expressions/async-generators/return-suspendedYield-try-finally-return.js @@ -0,0 +1,40 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: pending +description: > + AsyncGeneratorResumeNext: + If completion.[[Type]] is return, and generator.[[AsyncGeneratorState]] is + "suspendedYield", and generator is resumed within a try-block with an + associated finally block, resume execution within finally. +flags: [async] +---*/ + +var g = async function*() { + try { + yield 1; + throw new Test262Error('Generator must be resumed in finally block.'); + } finally { + return 'done'; + } +}; + +var it = g(); +it.next().then(function(ret) { + assert.sameValue(ret.value, 1, 'Initial yield'); + assert.sameValue(ret.done, false, 'Initial yield'); + + it.return('sent-value').then(function(ret) { + assert.sameValue(ret.value, 'done', 'AsyncGeneratorResolve(generator, resultValue, true)'); + assert.sameValue(ret.done, true, 'AsyncGeneratorResolve(generator, resultValue, true)'); + + it.next().then(function(ret) { + assert.sameValue(ret.value, undefined, 'Generator is closed'); + assert.sameValue(ret.done, true, 'Generator is closed'); + }).then($DONE, $DONE); + + }).catch($DONE); + +}).catch($DONE); diff --git a/test/language/expressions/async-generators/return-suspendedYield-try-finally-throw.js b/test/language/expressions/async-generators/return-suspendedYield-try-finally-throw.js new file mode 100644 index 0000000000..7eba74787f --- /dev/null +++ b/test/language/expressions/async-generators/return-suspendedYield-try-finally-throw.js @@ -0,0 +1,41 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: pending +description: > + AsyncGeneratorResumeNext: + If completion.[[Type]] is return, and generator.[[AsyncGeneratorState]] is + "suspendedYield", and generator is resumed within a try-block with an + associated finally block, resume execution within finally. +flags: [async] +---*/ + +var error = new Error("boop"); +var g = async function*() { + try { + yield 1; + throw new Test262Error('Generator must be resumed in finally block.'); + } finally { + throw error; + throw new Test262Error('Generator must not be resumed.'); + } +}; + +var it = g(); +it.next().then(function(ret) { + assert.sameValue(ret.value, 1, 'Initial yield'); + assert.sameValue(ret.done, false, 'Initial yield'); + + it.return('sent-value').then($DONE, function(err) { + assert.sameValue(err, error, 'AsyncGeneratorReject(generator, resultValue)'); + + it.next().then(function(ret) { + assert.sameValue(ret.value, undefined, 'Generator is closed'); + assert.sameValue(ret.done, true, 'Generator is closed'); + }).then($DONE, $DONE); + + }).catch($DONE); + +}).catch($DONE); diff --git a/test/language/expressions/async-generators/return-suspendedYield-try-finally.js b/test/language/expressions/async-generators/return-suspendedYield-try-finally.js new file mode 100644 index 0000000000..ca95a907d6 --- /dev/null +++ b/test/language/expressions/async-generators/return-suspendedYield-try-finally.js @@ -0,0 +1,46 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: pending +description: > + AsyncGeneratorResumeNext: + If completion.[[Type]] is return, and generator.[[AsyncGeneratorState]] is + "suspendedYield", and generator is resumed within a try-block with an + associated finally block, resume execution within finally. +flags: [async] +---*/ + +var g = async function*() { + try { + yield 1; + throw new Test262Error('Generator must be resumed in finally block.'); + } finally { + yield 2; + } +}; + +var it = g(); +it.next().then(function(ret) { + assert.sameValue(ret.value, 1, 'Initial yield'); + assert.sameValue(ret.done, false, 'Initial yield'); + + it.return('sent-value').then(function(ret) { + assert.sameValue(ret.value, 2, 'Yield in finally block'); + assert.sameValue(ret.done, false, 'Yield in finally block'); + + it.next().then(function(ret) { + assert.sameValue(ret.value, 'sent-value', 'AsyncGeneratorResolve(generator, resultValue, true)'); + assert.sameValue(ret.done, true, 'AsyncGeneratorResolve(generator, resultValue, true)'); + + it.next().then(function(ret) { + assert.sameValue(ret.value, undefined, 'Generator is closed'); + assert.sameValue(ret.done, true, 'Generator is closed'); + }).then($DONE, $DONE); + + }).catch($DONE); + + }).catch($DONE); + +}).catch($DONE); diff --git a/test/language/expressions/async-generators/return-suspendedYield.js b/test/language/expressions/async-generators/return-suspendedYield.js new file mode 100644 index 0000000000..8f65eaaad9 --- /dev/null +++ b/test/language/expressions/async-generators/return-suspendedYield.js @@ -0,0 +1,36 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: pending +description: > + AsyncGeneratorResumeNext: + If completion.[[Type]] is return, and generator.[[AsyncGeneratorState]] is + "suspendedYield", generator is resumed and immediately closes the generator + and returns completion. +flags: [async] +---*/ + +var g = async function*() { + yield 1; + throw new Test262Error('Generator must not be resumed.'); +}; + +var it = g(); +it.next().then(function(ret) { + assert.sameValue(ret.value, 1, 'Initial yield'); + assert.sameValue(ret.done, false, 'Initial yield'); + + it.return('sent-value').then(function(ret) { + assert.sameValue(ret.value, 'sent-value', 'AsyncGeneratorResolve(generator, resultValue, true)'); + assert.sameValue(ret.done, true, 'AsyncGeneratorResolve(generator, resultValue, true)'); + + it.next().then(function(ret) { + assert.sameValue(ret.value, undefined, 'Generator is closed'); + assert.sameValue(ret.done, true, 'Generator is closed'); + }).then($DONE, $DONE); + + }).catch($DONE); + +}).catch($DONE); diff --git a/test/language/expressions/async-generators/throw-suspendedStart-promise.js b/test/language/expressions/async-generators/throw-suspendedStart-promise.js new file mode 100644 index 0000000000..4564566f98 --- /dev/null +++ b/test/language/expressions/async-generators/throw-suspendedStart-promise.js @@ -0,0 +1,30 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: pending +description: > + AsyncGeneratorResumeNext: + If completion.[[Type]] is throw, and generator.[[AsyncGeneratorState]] is + "suspendedStart", generator is closed without being resumed. + + AsyncGeneratorReject will not unwrap Promise values +flags: [async] +---*/ + +var g = async function*() { + throw new Test262Error('Generator must not be resumed.'); +}; + +var it = g(); +var promise = new Promise(function() {}); + +it.throw(promise).then($DONE, function(err) { + assert.sameValue(err, promise, 'AsyncGeneratorReject(generator, completion.[[Value]])'); + + it.next().then(function(ret) { + assert.sameValue(ret.value, undefined, 'Generator is closed'); + assert.sameValue(ret.done, true, 'Generator is closed'); + }).then($DONE, $DONE); +}).catch($DONE); diff --git a/test/language/expressions/async-generators/throw-suspendedStart.js b/test/language/expressions/async-generators/throw-suspendedStart.js new file mode 100644 index 0000000000..ee21cc4ef1 --- /dev/null +++ b/test/language/expressions/async-generators/throw-suspendedStart.js @@ -0,0 +1,27 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: pending +description: > + AsyncGeneratorResumeNext: + If completion.[[Type]] is throw, and generator.[[AsyncGeneratorState]] is + "suspendedStart", generator is closed without being resumed. +flags: [async] +---*/ + +var error = new Error('boop'); +var g = async function*() { + throw new Test262Error('Generator must not be resumed.'); +}; + +var it = g(); +it.throw(error).then($DONE, function(err) { + assert.sameValue(err, error, 'AsyncGeneratorReject(generator, completion.[[Value]])'); + + it.next().then(function(ret) { + assert.sameValue(ret.value, undefined, 'Generator is closed'); + assert.sameValue(ret.done, true, 'Generator is closed'); + }).then($DONE, $DONE); +}).catch($DONE); diff --git a/test/language/expressions/async-generators/throw-suspendedYield-promise.js b/test/language/expressions/async-generators/throw-suspendedYield-promise.js new file mode 100644 index 0000000000..0165d4b75e --- /dev/null +++ b/test/language/expressions/async-generators/throw-suspendedYield-promise.js @@ -0,0 +1,39 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: pending +description: > + AsyncGeneratorResumeNext: + If completion.[[Type]] is throw, and generator.[[AsyncGeneratorState]] is + "suspendedYield", generator is resumed and immediately and + closes the generator and returns completion. + + AsyncGeneratorReject will not unwrap Promise values +flags: [async] +---*/ + +var g = async function*() { + yield 1; + throw new Test262Error('Generator must not be resumed.'); +}; + +var it = g(); +var promise = new Promise(function() {}); + +it.next().then(function(ret) { + assert.sameValue(ret.value, 1, 'Initial yield'); + assert.sameValue(ret.done, false, 'Initial yield'); + + it.throw(promise).then($DONE, function(err) { + assert.sameValue(err, promise, 'AsyncGeneratorReject(generator, resultValue)'); + + it.next().then(function(ret) { + assert.sameValue(ret.value, undefined, 'Generator is closed'); + assert.sameValue(ret.done, true, 'Generator is closed'); + }).then($DONE, $DONE); + + }).catch($DONE); + +}).catch($DONE); diff --git a/test/language/expressions/async-generators/throw-suspendedYield-try-catch.js b/test/language/expressions/async-generators/throw-suspendedYield-try-catch.js new file mode 100644 index 0000000000..eb163a764e --- /dev/null +++ b/test/language/expressions/async-generators/throw-suspendedYield-try-catch.js @@ -0,0 +1,42 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: pending +description: > + AsyncGeneratorResumeNext: + If completion.[[Type]] is throw, and generator.[[AsyncGeneratorState]] is + "suspendedYield", and generator is resumed within a try-block with an + associated catch block, resume execution within catch-block. +flags: [async] +---*/ + +var error = new Error('boop'); +var g = async function*() { + try { + yield 1; + throw new Test262Error('Generator must be resumed in catch block.'); + } catch (err) { + assert.sameValue(err, error); + return 'done'; + } +}; + +var it = g(); +it.next().then(function(ret) { + assert.sameValue(ret.value, 1, 'Initial yield'); + assert.sameValue(ret.done, false, 'Initial yield'); + + it.throw(error).then(function(ret) { + assert.sameValue(ret.value, 'done', 'AsyncGeneratorResolve(generator, resultValue, true)'); + assert.sameValue(ret.done, true, 'AsyncGeneratorResolve(generator, resultValue, true)'); + + it.next().then(function(ret) { + assert.sameValue(ret.value, undefined, 'Generator is closed'); + assert.sameValue(ret.done, true, 'Generator is closed'); + }).then($DONE, $DONE); + + }).catch($DONE); + +}).catch($DONE); diff --git a/test/language/expressions/async-generators/throw-suspendedYield-try-finally-return.js b/test/language/expressions/async-generators/throw-suspendedYield-try-finally-return.js new file mode 100644 index 0000000000..96ff02d250 --- /dev/null +++ b/test/language/expressions/async-generators/throw-suspendedYield-try-finally-return.js @@ -0,0 +1,42 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: pending +description: > + AsyncGeneratorResumeNext: + If completion.[[Type]] is throw, and generator.[[AsyncGeneratorState]] is + "suspendedYield", and generator is resumed within a try-block with an + associated finally block, resume execution within finally. +flags: [async] +---*/ + +class Err extends Error {}; +var g = async function*() { + try { + yield 1; + throw new Test262Error('Generator must be resumed in finally block.'); + } finally { + return 'done'; + throw new Test262Error('Generator must not be resumed.'); + } +}; + +var it = g(); +it.next().then(function(ret) { + assert.sameValue(ret.value, 1, 'Initial yield'); + assert.sameValue(ret.done, false, 'Initial yield'); + + it.throw(new Err).then(function(ret) { + assert.sameValue(ret.value, 'done', 'AsyncGeneratorResolve(generator, resultValue, true)'); + assert.sameValue(ret.done, true, 'AsyncGeneratorResolve(generator, resultValue, true)'); + + it.next().then(function(ret) { + assert.sameValue(ret.value, undefined, 'Generator is closed'); + assert.sameValue(ret.done, true, 'Generator is closed'); + }).then($DONE, $DONE); + + }).catch($DONE); + +}).catch($DONE); diff --git a/test/language/expressions/async-generators/throw-suspendedYield-try-finally-throw.js b/test/language/expressions/async-generators/throw-suspendedYield-try-finally-throw.js new file mode 100644 index 0000000000..7376099d51 --- /dev/null +++ b/test/language/expressions/async-generators/throw-suspendedYield-try-finally-throw.js @@ -0,0 +1,41 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: pending +description: > + AsyncGeneratorResumeNext: + If completion.[[Type]] is throw, and generator.[[AsyncGeneratorState]] is + "suspendedYield", and generator is resumed within a try-block with an + associated finally block, resume execution within finally. +flags: [async] +---*/ + +var error = new Error('boop'); +var g = async function*() { + try { + yield 1; + throw new Test262Error('Generator must be resumed in finally block.'); + } finally { + throw error; + throw new Test262Error('Generator must not be resumed.'); + } +}; + +var it = g(); +it.next().then(function(ret) { + assert.sameValue(ret.value, 1, 'Initial yield'); + assert.sameValue(ret.done, false, 'Initial yield'); + + it.throw(new Error('superceded')).then($DONE, function(err) { + assert.sameValue(err, error, 'AsyncGeneratorReject(generator, resultValue)'); + + it.next().then(function(ret) { + assert.sameValue(ret.value, undefined, 'Generator is closed'); + assert.sameValue(ret.done, true, 'Generator is closed'); + }).then($DONE, $DONE); + + }).catch($DONE); + +}).catch($DONE); diff --git a/test/language/expressions/async-generators/throw-suspendedYield-try-finally.js b/test/language/expressions/async-generators/throw-suspendedYield-try-finally.js new file mode 100644 index 0000000000..7e029ef867 --- /dev/null +++ b/test/language/expressions/async-generators/throw-suspendedYield-try-finally.js @@ -0,0 +1,46 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: pending +description: > + AsyncGeneratorResumeNext: + If completion.[[Type]] is throw, and generator.[[AsyncGeneratorState]] is + "suspendedYield", and generator is resumed within a try-block with an + associated finally block, resume execution within finally. +flags: [async] +---*/ + +var error = new Error('boop'); +var g = async function*() { + try { + yield 1; + throw new Test262Error('Generator must be resumed in finally block.'); + } finally { + yield 2; + } +}; + +var it = g(); +it.next().then(function(ret) { + assert.sameValue(ret.value, 1, 'Initial yield'); + assert.sameValue(ret.done, false, 'Initial yield'); + + it.throw(error).then(function(ret) { + assert.sameValue(ret.value, 2, 'Yield in finally block'); + assert.sameValue(ret.done, false, 'Yield in finally block'); + + it.next().then($DONE, function(err) { + assert.sameValue(err, error, 'AsyncGeneratorReject(generator, returnValue)'); + + it.next().then(function(ret) { + assert.sameValue(ret.value, undefined, 'Generator is closed'); + assert.sameValue(ret.done, true, 'Generator is closed'); + }).then($DONE, $DONE); + + }).catch($DONE); + + }).catch($DONE); + +}).catch($DONE); diff --git a/test/language/expressions/async-generators/throw-suspendedYield.js b/test/language/expressions/async-generators/throw-suspendedYield.js new file mode 100644 index 0000000000..6cf6725b6e --- /dev/null +++ b/test/language/expressions/async-generators/throw-suspendedYield.js @@ -0,0 +1,36 @@ +// Copyright 2017 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +author: Caitlin Potter +esid: pending +description: > + AsyncGeneratorResumeNext: + If completion.[[Type]] is throw, and generator.[[AsyncGeneratorState]] is + "suspendedYield", generator is resumed and immediately and + closes the generator and returns completion. +flags: [async] +---*/ + +var error = new Error('boop'); +var g = async function*() { + yield 1; + throw new Test262Error('Generator must not be resumed.'); +}; + +var it = g(); +it.next().then(function(ret) { + assert.sameValue(ret.value, 1, 'Initial yield'); + assert.sameValue(ret.done, false, 'Initial yield'); + + it.throw(error).then($DONE, function(err) { + assert.sameValue(err, error, 'AsyncGeneratorReject(generator, resultValue)'); + + it.next().then(function(ret) { + assert.sameValue(ret.value, undefined, 'Generator is closed'); + assert.sameValue(ret.done, true, 'Generator is closed'); + }).then($DONE, $DONE); + + }).catch($DONE); + +}).catch($DONE);