blob: efcfdab2eaba60bc9e26a6315f33a5daf9cbd022 [file] [log] [blame]
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Flags: --harmony-async-iteration --allow-natives-syntax
let testFailed = false;
let testFailure;
(async function() {
const kNext = 1;
const kThrow = 2;
const kReturn = 4;
const kReturnPrimitive = kReturn | 32;
function async(iterable, features = kNext, log = []) {
// Helper to turn a synchronous iterable into an asynchronous iterable,
// without using the [Async-from-Sync Iterator].
let it = iterable[Symbol.iterator]();
let methods = {
next(sentValue) {
return new Promise(function(resolve, reject) {
let {value, done} = it.next(sentValue);
Promise.resolve(value).then(function(value) {
log.push('.next() -> resolved ' + value);
resolve({value, done});
}, function(value) {
log.push('.next() -> rejected ' + value);
reject(value);
});
});
},
throw(sentValue) {
return new Promise(function(resolve, reject) {
let throwMethod = it.throw;
if (typeof throwMethod !== 'function') {
log.push('.throw(' + sentValue + ')');
return reject(sentValue);
}
let {value, done} = throwMethod.call(it, sentValue);
Promise.resolve(value).then(function(value) {
log.push('.throw() -> resolved ' + value);
resolve({ value, done });
}, function(value) {
log.push('.throw() -> rejected ' + value);
reject(value);
});
});
},
return(sentValue) {
return new Promise(function(resolve, reject) {
let returnMethod = it.return;
if (typeof returnMethod !== 'function') {
log.push('.return(' + sentValue + ')');
if ((features & kReturnPrimitive) === kReturnPrimitive)
return resolve(sentValue);
return resolve({value: sentValue, done: true});
}
let {value, done} = returnMethod.call(it, sentValue);
Promise.resolve(value).then(function(value) {
log.push('.return() -> resolved ' + value);
if ((features & kReturnPrimitive) === kReturnPrimitive)
return resolve(value);
resolve({ value, done });
}, function(value) {
log.push('.return() -> rejected ' + value);
reject(value);
});
});
}
};
return {
[Symbol.asyncIterator]() {
log.push('[Symbol.asyncIterator]()')
return this;
},
next: (features & kNext) ? methods.next : undefined,
throw: (features & kThrow) ? methods.throw : undefined,
return: (features & kReturn) ? methods.return : undefined
};
}
let testDone;
let test;
async function testBindingIdentifierVarDeclarationStatement() {
let sum = 0;
testDone = false;
for await (var value of async([100, 200, 300, 400, 500])) sum += value;
testDone = true;
return sum;
}
test = testBindingIdentifierVarDeclarationStatement();
assertFalse(testDone);
assertEquals(1500, await test);
assertTrue(testDone);
async function testBindingIdentifierVarDeclarationBlockStatement() {
let sum = 0;
testDone = false;
for await (var value of async([100, 200, 300, 400, 500])) {
'use strict';
let strict = (function() { return this === undefined; })();
assertFalse(strict);
sum += value;
}
testDone = true;
return sum;
}
test = testBindingIdentifierVarDeclarationBlockStatement();
assertFalse(testDone);
assertEquals(1500, await test);
assertTrue(testDone);
async function testObjectBindingPatternVarDeclarationStatement() {
let sum = 0, keys = [];
let collection = [
{key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30},
{key: 'last', value: 40}
];
testDone = false;
for await (var {key = 'unknown', value} of async(collection))
keys.push(key), sum += value;
testDone = true;
return {keys, sum};
}
test = testObjectBindingPatternVarDeclarationStatement();
assertFalse(testDone);
assertEquals(
{keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
assertTrue(testDone);
async function testObjectBindingPatternVarDeclarationBlockStatement() {
let sum = 0, keys = [];
let collection = [
{key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30},
{key: 'last', value: 40}
];
testDone = false;
for await (var {key = 'unknown', value} of async(collection)) {
'use strict';
let strict = (function() { return this === undefined; })();
assertFalse(strict);
keys.push(key);
sum += value;
}
testDone = true;
return {keys, sum};
}
test = testObjectBindingPatternVarDeclarationBlockStatement();
assertFalse(testDone);
assertEquals(
{keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
assertTrue(testDone);
async function testArrayBindingPatternVarDeclarationStatement() {
let sum = 0, keys = [];
let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]];
testDone = false;
for await (var [key = 'unknown', value] of async(collection))
keys.push(key), sum += value;
testDone = true;
return {keys, sum};
}
test = testArrayBindingPatternVarDeclarationStatement();
assertFalse(testDone);
assertEquals(
{keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
assertTrue(testDone);
async function testArrayBindingPatternVarDeclarationBlockStatement() {
let sum = 0, keys = [];
let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]];
testDone = false;
for await (var [key = 'unknown', value] of async(collection)) {
'use strict';
let strict = (function() { return this === undefined; })();
assertFalse(strict);
keys.push(key);
sum += value;
}
testDone = true;
return {keys, sum};
}
test = testArrayBindingPatternVarDeclarationBlockStatement();
assertFalse(testDone);
assertEquals(
{keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
assertTrue(testDone);
// --------------------------------------------------------------------------
async function testBindingIdentifierLetDeclarationStatement() {
let sum = 0;
testDone = false;
for await (let value of async([100, 200, 300, 400, 500])) sum += value;
testDone = true;
return sum;
}
test = testBindingIdentifierLetDeclarationStatement();
assertFalse(testDone);
assertEquals(1500, await test);
assertTrue(testDone);
async function testBindingIdentifierLetDeclarationBlockStatement() {
let sum = 0;
testDone = false;
for await (let value of async([100, 200, 300, 400, 500])) {
'use strict';
let strict = (function() { return this === undefined; })();
assertFalse(strict);
sum += value;
}
testDone = true;
return sum;
}
test = testBindingIdentifierLetDeclarationBlockStatement();
assertFalse(testDone);
assertEquals(1500, await test);
assertTrue(testDone);
async function testObjectBindingPatternLetDeclarationStatement() {
let sum = 0, keys = [];
let collection = [
{key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30},
{key: 'last', value: 40}
];
testDone = false;
for await (let {key = 'unknown', value} of async(collection))
keys.push(key), sum += value;
testDone = true;
return {keys, sum};
}
test = testObjectBindingPatternLetDeclarationStatement();
assertFalse(testDone);
assertEquals(
{keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
assertTrue(testDone);
async function testObjectBindingPatternLetDeclarationBlockStatement() {
let sum = 0, keys = [];
let collection = [
{key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30},
{key: 'last', value: 40}
];
testDone = false;
for await (let {key = 'unknown', value} of async(collection)) {
'use strict';
let strict = (function() { return this === undefined; })();
assertFalse(strict);
keys.push(key);
sum += value;
}
testDone = true;
return {keys, sum};
}
let threwEarly = false;
test = testObjectBindingPatternLetDeclarationBlockStatement();
assertFalse(testDone);
assertEquals(
{keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
assertTrue(testDone);
async function testObjectBindingPatternTDZLetDeclarationStatement() {
// See https://codereview.chromium.org/1218543003
let sum = 0;
testDone = false;
let value = { value: 1 };
try {
for await (let {value} of async([value])) sum += value;
} catch (error) {
threwEarly = true;
throw { sum, error, toString() { return 'TestError' } };
}
}
test = testObjectBindingPatternTDZLetDeclarationStatement();
assertTrue(threwEarly, 'Async function promise should be rejected');
try {
await test;
} catch (e) {
assertEquals('TestError', e.toString());
assertEquals(0, e.sum);
assertInstanceof(e.error, ReferenceError);
testDone = true;
}
assertTrue(testDone, 'Awaited promise should be rejected');
async function testObjectBindingPatternTDZLetDeclarationBlockStatement() {
// See https://codereview.chromium.org/1218543003
let sum = 0;
testDone = false;
let value = { value: 1 };
try {
for await (let {value} of async([value])) {
sum += value;
}
} catch (error) {
threwEarly = true;
throw { sum, error, toString() { return 'TestError' } };
}
}
threwEarly = false;
test = testObjectBindingPatternTDZLetDeclarationBlockStatement();
assertTrue(threwEarly, 'Async function promise should be rejected');
try {
await test;
} catch (e) {
assertEquals('TestError', e.toString());
assertEquals(0, e.sum);
assertInstanceof(e.error, ReferenceError);
testDone = true;
}
assertTrue(testDone, 'Awaited promise should be rejected');
async function testArrayBindingPatternLetDeclarationStatement() {
let sum = 0, keys = [];
let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]];
testDone = false;
for await (let [key = 'unknown', value] of async(collection))
keys.push(key), sum += value;
testDone = true;
return {keys, sum};
}
test = testArrayBindingPatternLetDeclarationStatement();
assertFalse(testDone);
assertEquals(
{keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
assertTrue(testDone);
async function testArrayBindingPatternLetDeclarationBlockStatement() {
let sum = 0, keys = [];
let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]];
testDone = false;
for await (let [key = 'unknown', value] of async(collection)) {
'use strict';
let strict = (function() { return this === undefined; })();
assertFalse(strict);
keys.push(key);
sum += value;
}
testDone = true;
return {keys, sum};
}
test = testArrayBindingPatternLetDeclarationBlockStatement();
assertFalse(testDone);
assertEquals(
{keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
assertTrue(testDone);
async function testArrayBindingPatternTDZLetDeclarationStatement() {
// See https://codereview.chromium.org/1218543003
let sum = 0;
testDone = false;
let value = [1];
try {
for await (let [value] of async([value])) sum += value;
} catch (error) {
threwEarly = true;
throw { sum, error, toString() { return 'TestError' } };
}
}
threwEarly = false;
test = testArrayBindingPatternTDZLetDeclarationStatement();
assertTrue(threwEarly, 'Async function promise should be rejected');
try {
await test;
} catch (e) {
assertEquals('TestError', e.toString());
assertEquals(0, e.sum);
assertInstanceof(e.error, ReferenceError);
testDone = true;
}
assertTrue(testDone, 'Awaited promise should be rejected');
async function testArrayBindingPatternTDZLetDeclarationBlockStatement() {
// See https://codereview.chromium.org/1218543003
let sum = 0;
testDone = false;
let value = [1];
try {
for await (let [value] of async([value])) {
sum += value;
}
} catch (error) {
threwEarly = true;
throw { sum, error, toString() { return 'TestError' } };
}
}
threwEarly = false;
test = testArrayBindingPatternTDZLetDeclarationBlockStatement();
assertTrue(threwEarly, 'Async function promise should be rejected');
try {
await test;
} catch (e) {
assertEquals('TestError', e.toString());
assertEquals(0, e.sum);
assertInstanceof(e.error, ReferenceError);
testDone = true;
}
assertTrue(testDone, 'Awaited promise should be rejected');
// --------------------------------------------------------------------------
async function testBindingIdentifierConstDeclarationStatement() {
let sum = 0;
testDone = false;
for await (let value of async([100, 200, 300, 400, 500])) sum += value;
testDone = true;
return sum;
}
test = testBindingIdentifierConstDeclarationStatement();
assertFalse(testDone);
assertEquals(1500, await test);
assertTrue(testDone);
async function testBindingIdentifierConstDeclarationBlockStatement() {
let sum = 0;
testDone = false;
for await (const value of async([100, 200, 300, 400, 500])) {
'use strict';
let strict = (function() { return this === undefined; })();
assertFalse(strict);
sum += value;
}
testDone = true;
return sum;
}
test = testBindingIdentifierConstDeclarationBlockStatement();
assertFalse(testDone);
assertEquals(1500, await test);
assertTrue(testDone);
async function testObjectBindingPatternConstDeclarationStatement() {
let sum = 0, keys = [];
let collection = [
{key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30},
{key: 'last', value: 40}
];
testDone = false;
for await (const {key = 'unknown', value} of async(collection))
keys.push(key), sum += value;
testDone = true;
return {keys, sum};
}
test = testObjectBindingPatternConstDeclarationStatement();
assertFalse(testDone);
assertEquals(
{keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
assertTrue(testDone);
async function testObjectBindingPatternConstDeclarationBlockStatement() {
let sum = 0, keys = [];
let collection = [
{key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30},
{key: 'last', value: 40}
];
testDone = false;
for await (const {key = 'unknown', value} of async(collection)) {
'use strict';
let strict = (function() { return this === undefined; })();
assertFalse(strict);
keys.push(key);
sum += value;
}
testDone = true;
return {keys, sum};
}
test = testObjectBindingPatternConstDeclarationBlockStatement();
assertFalse(testDone);
assertEquals(
{keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
assertTrue(testDone);
async function testObjectBindingPatternTDZConstDeclarationStatement() {
// See https://codereview.chromium.org/1218543003
let sum = 0;
testDone = false;
const value = { value: 1 };
try {
for await (const {value} of async([value])) sum += value;
} catch (error) {
threwEarly = true;
throw { sum, error, toString() { return 'TestError' } };
}
}
threwEarly = false;
test = testObjectBindingPatternTDZConstDeclarationStatement();
assertTrue(threwEarly, 'Async function promise should be rejected');
try {
await test;
} catch (e) {
assertEquals('TestError', e.toString());
assertEquals(0, e.sum);
assertInstanceof(e.error, ReferenceError);
testDone = true;
}
assertTrue(testDone, 'Awaited promise should be rejected');
async function testObjectBindingPatternTDZConstDeclarationBlockStatement() {
// See https://codereview.chromium.org/1218543003
let sum = 0;
testDone = false;
const value = { value: 1 };
try {
for await (const {value} of async([value])) {
sum += value;
}
} catch (error) {
threwEarly = true;
throw { sum, error, toString() { return 'TestError' } };
}
}
threwEarly = false;
test = testObjectBindingPatternTDZConstDeclarationBlockStatement();
assertTrue(threwEarly, 'Async function promise should be rejected');
try {
await test;
} catch (e) {
assertEquals('TestError', e.toString());
assertEquals(0, e.sum);
assertInstanceof(e.error, ReferenceError);
testDone = true;
}
assertTrue(testDone, 'Awaited promise should be rejected');
async function testArrayBindingPatternConstDeclarationStatement() {
let sum = 0, keys = [];
let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]];
testDone = false;
for await (const [key = 'unknown', value] of async(collection))
keys.push(key), sum += value;
testDone = true;
return {keys, sum};
}
test = testArrayBindingPatternConstDeclarationStatement();
assertFalse(testDone);
assertEquals(
{keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
assertTrue(testDone);
async function testArrayBindingPatternConstDeclarationBlockStatement() {
let sum = 0, keys = [];
let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]];
testDone = false;
for await (const [key = 'unknown', value] of async(collection)) {
'use strict';
let strict = (function() { return this === undefined; })();
assertFalse(strict);
keys.push(key);
sum += value;
}
testDone = true;
return {keys, sum};
}
test = testArrayBindingPatternLetDeclarationBlockStatement();
assertFalse(testDone);
assertEquals(
{keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test);
assertTrue(testDone);
async function testArrayBindingPatternTDZConstDeclarationStatement() {
// See https://codereview.chromium.org/1218543003
let sum = 0;
testDone = false;
const value = [1];
try {
for await (const [value] of async([value])) sum += value;
} catch (error) {
threwEarly = true;
throw { sum, error, toString() { return 'TestError' } };
}
}
threwEarly = false;
test = testArrayBindingPatternTDZConstDeclarationStatement();
assertTrue(threwEarly, 'Async function promise should be rejected');
try {
await test;
} catch (e) {
assertEquals('TestError', e.toString());
assertEquals(0, e.sum);
assertInstanceof(e.error, ReferenceError);
testDone = true;
}
assertTrue(testDone, 'Awaited promise should be rejected');
async function testArrayBindingPatternTDZConstDeclarationBlockStatement() {
// See https://codereview.chromium.org/1218543003
let sum = 0;
testDone = false;
const value = [1];
try {
for await (const [value] of async([value])) {
sum += value;
}
} catch (error) {
threwEarly = true;
throw { sum, error, toString() { return 'TestError' } };
}
}
threwEarly = false;
test = testArrayBindingPatternTDZConstDeclarationBlockStatement();
assertTrue(threwEarly, 'Async function promise should be rejected');
try {
await test;
} catch (e) {
assertEquals('TestError', e.toString());
assertEquals(0, e.sum);
assertInstanceof(e.error, ReferenceError);
testDone = true;
}
assertTrue(testDone, 'Awaited promise should be rejected');
// --------------------------------------------------------------------------
async function testBindingIdentifierLHSStatement() {
let sum = 0;
let value;
testDone = false;
for await (value of async([100, 200, 300, 400, 500])) sum += value;
testDone = true;
return sum;
}
test = testBindingIdentifierLHSStatement();
assertFalse(testDone);
assertEquals(1500, await test);
assertTrue(testDone);
async function testBindingIdentifierLHSBlockStatement() {
let sum = 0;
let value;
testDone = false;
for await (value of async([100, 200, 300, 400, 500])) {
'use strict';
let strict = (function() { return this === undefined; })();
assertFalse(strict);
sum += value;
}
testDone = true;
return sum;
}
test = testBindingIdentifierLHSStatement();
assertFalse(testDone);
assertEquals(1500, await test);
assertTrue(testDone);
async function testObjectBindingPatternLHSStatement() {
let sum = 0;
let keys = [];
let value;
let key;
let collection = [
{key: 'first', value: 1}, {key: undefined, value: 2}, {value: 3},
{key: 'last', value: 4}
];
testDone = false;
for await ({key = 'unknown', value} of async(collection))
keys.push(key), sum += value;
testDone = true;
return {keys, sum};
}
test = testObjectBindingPatternLHSStatement();
assertFalse(testDone);
assertEquals(
{keys: ['first', 'unknown', 'unknown', 'last'], sum: 10}, await test);
assertTrue(testDone);
async function testObjectBindingPatternLHSBlockStatement() {
let sum = 0;
let keys = [];
let value;
let key;
let collection = [
{key: 'first', value: 1}, {key: undefined, value: 2}, {value: 3},
{key: 'last', value: 4}
];
testDone = false;
for await ({key = 'unknown', value} of async(collection)) {
'use strict';
let strict = (function() { return this === undefined; })();
assertFalse(strict);
keys.push(key);
sum += value;
}
testDone = true;
return {keys, sum};
}
test = testObjectBindingPatternLHSBlockStatement();
assertFalse(testDone);
assertEquals(
{keys: ['first', 'unknown', 'unknown', 'last'], sum: 10}, await test);
assertTrue(testDone);
async function testArrayBindingPatternLHSStatement() {
let sum = 0;
let keys = [];
let value;
let key;
let collection = [['first', 1], [undefined, 2], [, 3], ['last', 4]];
testDone = false;
for await ([key = 'unknown', value] of async(collection)) {
'use strict';
let strict = (function() { return this === undefined; })();
assertFalse(strict);
keys.push(key);
sum += value;
}
testDone = true;
return {keys, sum};
}
test = testArrayBindingPatternLHSStatement();
assertFalse(testDone);
assertEquals(
{keys: ['first', 'unknown', 'unknown', 'last'], sum: 10}, await test);
assertTrue(testDone);
async function testArrayBindingPatternLHSBlockStatement() {
let sum = 0;
let keys = [];
let value;
let key;
let collection = [
{key: 'first', value: 1}, {key: undefined, value: 2}, {value: 3},
{key: 'last', value: 4}
];
testDone = false;
for await ({key = 'unknown', value} of async(collection)) {
'use strict';
let strict = (function() { return this === undefined; })();
assertFalse(strict);
keys.push(key);
sum += value;
}
testDone = true;
return {keys, sum};
}
test = testArrayBindingPatternLHSBlockStatement();
assertFalse(testDone);
assertEquals(
{keys: ['first', 'unknown', 'unknown', 'last'], sum: 10}, await test);
assertTrue(testDone);
// --------------------------------------------------------------------------
async function testBreakStatementReturnMethodNotPresent() {
let log = [];
let collection = [1, 2, 3, 4, 5];
let sum = 0;
let i = 0;
testDone = false;
for await (var x of async(collection, kNext, log)) {
sum += x;
if (++i === 3) break;
}
testDone = true;
return { sum, log };
}
test = testBreakStatementReturnMethodNotPresent();
assertFalse(testDone);
assertEquals({sum: 6, log: ['[Symbol.asyncIterator]()',
'.next() -> resolved 1',
'.next() -> resolved 2',
'.next() -> resolved 3']},
await test);
assertTrue(testDone);
async function testBreakStatementReturnMethodPresent() {
let log = [];
let collection = [1, 2, 3, 4, 5];
let sum = 0;
let i = 0;
testDone = false;
for await (var x of async(collection, kNext|kReturn, log)) {
sum += x;
if (++i === 2) break;
}
testDone = true;
return { sum, log };
}
test = testBreakStatementReturnMethodPresent();
assertFalse(testDone);
assertEquals({sum: 3, log: ['[Symbol.asyncIterator]()',
'.next() -> resolved 1',
'.next() -> resolved 2',
'.return(undefined)']},
await test);
assertTrue(testDone);
async function testBreakStatementReturnMethodAwaitIterResult() {
let log = [];
let collection = [1, 2, 3, 4, 5];
let sync_iter = collection[Symbol.iterator]();
sync_iter.return = function() {
return {
value: new Promise(function(resolve, reject) {
Promise.resolve().then(function() {
resolve('break!');
});
}),
done: true
};
};
let sum = 0;
let i = 0;
testDone = false;
for await (var x of async(sync_iter, kNext|kReturn, log)) {
sum += x;
if (++i === 2) break;
}
testDone = true;
return { sum, log };
}
test = testBreakStatementReturnMethodAwaitIterResult();
assertFalse(testDone);
assertEquals({sum: 3,
log: ['[Symbol.asyncIterator]()',
'.next() -> resolved 1',
'.next() -> resolved 2',
'.return() -> resolved break!' ]},
await test);
assertTrue(testDone);
async function testBreakStatementReturnMethodAwaitRejection(log) {
let collection = [1, 2, 3, 4, 5];
let sync_iter = collection[Symbol.iterator]();
let sum = 0;
sync_iter.return = function() {
return {
value: new Promise(function(resolve, reject) {
Promise.resolve().then(function() {
reject('break! ' + sum);
});
}),
done: true
};
};
let i = 0;
testDone = false;
for await (var x of async(sync_iter, kNext|kReturn, log)) {
sum += x;
if (++i === 2) break;
}
return { sum, log };
}
let log = [];
test = testBreakStatementReturnMethodAwaitRejection(log);
assertFalse(testDone);
try {
await test;
} catch (e) {
assertEquals(log, ['[Symbol.asyncIterator]()',
'.next() -> resolved 1',
'.next() -> resolved 2',
'.return() -> rejected break! 3']);
assertEquals('break! 3', e);
testDone = true;
}
assertTrue(testDone, 'Promise should be rejected');
async function testBreakStatementReturnMethodPrimitiveValue(log) {
let collection = [1, 2, 3, 4, 5];
let sync_iter = collection[Symbol.iterator]();
sync_iter.return = function() {
return { value: 'break! primitive!', done: true };
}
let sum = 0;
let i = 0;
testDone = false;
for await (var x of async(sync_iter, kNext|kReturnPrimitive, log)) {
sum += x;
if (++i === 2) break;
}
return { sum, log };
}
log = [];
test = testBreakStatementReturnMethodPrimitiveValue(log);
assertFalse(testDone);
try {
await test;
} catch (e) {
assertEquals(['[Symbol.asyncIterator]()',
'.next() -> resolved 1',
'.next() -> resolved 2',
'.return() -> resolved break! primitive!'],
log);
assertInstanceof(e, TypeError);
testDone = true;
}
assertTrue(testDone, 'Promise should be rejected');
async function testReturnStatementReturnMethodNotPresent() {
let log = [];
let collection = [1, 2, 3, 4, 5];
let sum = 0;
let i = 0;
testDone = false;
for await (var x of async(collection, kNext, log)) {
sum += x;
if (++i === 3) {
testDone = true;
return { sum, log };
}
}
}
test = testReturnStatementReturnMethodNotPresent();
assertFalse(testDone);
assertEquals({sum: 6, log: ['[Symbol.asyncIterator]()',
'.next() -> resolved 1',
'.next() -> resolved 2',
'.next() -> resolved 3']},
await test);
assertTrue(testDone);
async function testReturnStatementReturnMethodPresent() {
let log = [];
let collection = [1, 2, 3, 4, 5];
let sum = 0;
let i = 0;
testDone = false;
for await (var x of async(collection, kNext|kReturn, log)) {
sum += x;
if (++i === 2) {
testDone = true;
return { sum, log };
}
}
}
test = testReturnStatementReturnMethodPresent();
assertFalse(testDone);
assertEquals({sum: 3, log: ['[Symbol.asyncIterator]()',
'.next() -> resolved 1',
'.next() -> resolved 2',
'.return(undefined)']},
await test);
assertTrue(testDone);
async function testReturnStatementReturnMethodAwaitIterResult() {
let log = [];
let collection = [1, 2, 3, 4, 5];
let sync_iter = collection[Symbol.iterator]();
sync_iter.return = function() {
return {
value: new Promise(function(resolve, reject) {
Promise.resolve().then(function() {
testDone = true;
resolve('return!');
});
}),
done: true
};
};
let sum = 0;
let i = 0;
testDone = false;
for await (var x of async(sync_iter, kNext|kReturn, log)) {
sum += x;
if (++i === 2) return { sum, log };
}
}
test = testReturnStatementReturnMethodAwaitIterResult();
assertFalse(testDone);
assertEquals({sum: 3,
log: ['[Symbol.asyncIterator]()',
'.next() -> resolved 1',
'.next() -> resolved 2',
'.return() -> resolved return!' ]},
await test);
assertTrue(testDone);
async function testReturnStatementReturnMethodAwaitRejection(log) {
let collection = [1, 2, 3, 4, 5];
let sync_iter = collection[Symbol.iterator]();
let sum = 0;
sync_iter.return = function() {
return {
value: new Promise(function(resolve, reject) {
Promise.resolve().then(function() {
reject('return! ' + sum);
});
}),
done: true
};
};
let i = 0;
testDone = false;
for await (var x of async(sync_iter, kNext|kReturn, log)) {
sum += x;
if (++i === 2) return { sum, log };
}
}
log = [];
test = testReturnStatementReturnMethodAwaitRejection(log);
assertFalse(testDone);
try {
await test;
} catch (e) {
assertEquals('return! 3', e);
assertEquals(['[Symbol.asyncIterator]()',
'.next() -> resolved 1',
'.next() -> resolved 2',
'.return() -> rejected return! 3'],
log);
testDone = true;
}
assertTrue(testDone, 'Promise should be rejected');
async function testReturnStatementReturnMethodPrimitiveValue(log) {
let collection = [1, 2, 3, 4, 5];
let sync_iter = collection[Symbol.iterator]();
sync_iter.return = function() {
return { value: 'return! primitive!', done: true };
}
let sum = 0;
let i = 0;
testDone = false;
for await (var x of async(sync_iter, kNext|kReturnPrimitive, log)) {
sum += x;
if (++i === 2) break;
}
return { sum, log };
}
log = [];
test = testReturnStatementReturnMethodPrimitiveValue(log);
assertFalse(testDone);
try {
await test;
} catch (e) {
assertEquals(['[Symbol.asyncIterator]()',
'.next() -> resolved 1',
'.next() -> resolved 2',
'.return() -> resolved return! primitive!'],
log);
assertInstanceof(e, TypeError);
testDone = true;
}
assertTrue(testDone, 'Promise should be rejected');
async function testThrowStatementReturnMethodNotPresent() {
let log = [];
let collection = [1, 2, 3, 4, 5];
let sum = 0;
let i = 0;
testDone = false;
for await (var x of async(collection, kNext|kThrow, log)) {
sum += x;
if (++i === 3) {
throw { sum, log, toString() { return 'TestError'; } };
}
}
return { sum, log };
}
test = testThrowStatementReturnMethodNotPresent();
assertFalse(testDone);
try {
await test;
} catch (e) {
assertEquals('TestError', e.toString());
assertEquals(6, e.sum);
assertEquals(['[Symbol.asyncIterator]()', '.next() -> resolved 1',
'.next() -> resolved 2', '.next() -> resolved 3'
], e.log);
testDone = true;
}
assertTrue(testDone, 'Awaited Promise should be rejected');
async function testThrowStatementReturnMethodPresent() {
let log = [];
let collection = [1, 2, 3, 4, 5];
let sum = 0;
let i = 0;
testDone = false;
for await (var x of async(collection, kNext|kThrow|kReturn, log)) {
sum += x;
if (++i === 2) {
throw { sum, log, toString() { return 'TestError2'; } };
}
}
return { sum, log };
}
test = testThrowStatementReturnMethodPresent();
assertFalse(testDone);
try {
await test;
} catch (e) {
assertEquals('TestError2', e.toString());
assertEquals(3, e.sum);
assertEquals(['[Symbol.asyncIterator]()', '.next() -> resolved 1',
'.next() -> resolved 2', '.return(undefined)'
], e.log);
testDone = true;
}
assertTrue(testDone, 'Awaited Promise should be rejected');
async function testThrowStatementReturnMethodAwaitIterResult(log) {
let collection = [1, 2, 3, 4, 5];
let sync_iter = collection[Symbol.iterator]();
sync_iter.return = function() {
return {
value: new Promise(function(resolve, reject) {
Promise.resolve().then(function() {
testDone = true;
resolve('throw!');
});
}),
done: true
};
};
let sum = 0;
let i = 0;
testDone = false;
for await (var x of async(sync_iter, kNext|kReturn, log)) {
sum += x;
if (++i === 2) throw 'Boo!!';
}
}
log = [];
test = testThrowStatementReturnMethodAwaitIterResult(log);
assertFalse(testDone);
try {
await test;
} catch (e) {
assertEquals('Boo!!', e);
assertEquals(['[Symbol.asyncIterator]()',
'.next() -> resolved 1',
'.next() -> resolved 2',
'.return() -> resolved throw!' ], log);
testDone = true;
}
assertTrue(testDone, 'Awaited Promise should be rejected');
async function testThrowStatementReturnMethodAwaitRejection(log) {
let collection = [1, 2, 3, 4, 5];
let sync_iter = collection[Symbol.iterator]();
let sum = 0;
sync_iter.return = function() {
return {
value: new Promise(function(resolve, reject) {
Promise.resolve().then(function() {
reject('return! ' + sum);
});
}),
done: true
};
};
let i = 0;
testDone = false;
for await (var x of async(sync_iter, kNext|kReturn, log)) {
sum += x;
if (++i === 2) throw 'Boo!!';
}
}
log = [];
test = testThrowStatementReturnMethodAwaitRejection(log);
assertFalse(testDone);
try {
await test;
} catch (e) {
assertEquals('Boo!!', e);
assertEquals(['[Symbol.asyncIterator]()',
'.next() -> resolved 1',
'.next() -> resolved 2',
'.return() -> rejected return! 3'],
log);
testDone = true;
}
assertTrue(testDone, 'Promise should be rejected');
async function testThrowStatementReturnMethodPrimitiveValue(log) {
let collection = [1, 2, 3, 4, 5];
let sync_iter = collection[Symbol.iterator]();
sync_iter.return = function() {
return { value: 'return! primitive!', done: true };
}
let sum = 0;
let i = 0;
testDone = false;
for await (var x of async(sync_iter, kNext|kReturnPrimitive, log)) {
sum += x;
if (++i === 2) throw 'Boo!!';
}
}
log = [];
test = testThrowStatementReturnMethodPrimitiveValue(log);
assertFalse(testDone);
try {
await test;
} catch (e) {
assertEquals(['[Symbol.asyncIterator]()',
'.next() -> resolved 1',
'.next() -> resolved 2',
'.return() -> resolved return! primitive!'],
log);
// AsyncIteratorClose does not require Throw completions to be of type
// Object
assertEquals('Boo!!', e);
testDone = true;
}
assertTrue(testDone, 'Promise should be rejected');
})().catch(function(error) {
testFailed = true;
testFailure = error;
});
%RunMicrotasks();
if (testFailed) {
throw testFailure;
}