Google Git
Sign in
android / platform / external / v8 / 8b7e11b1efb8d0955b4b72d240a4f39461eea6c7 / . / test / mjsunit / harmony / iterator-close.js
blob: 03cdeac0383b4660da1e267a7f41ae6024fc3b60 [file] [log] [blame]
// Copyright 2016 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-iterator-close
function* g() { yield 42; return 88 };
// Return method is "undefined".
{
g.prototype.return = null;
assertEquals(undefined, (() => {
for (var x of g()) { break; }
})());
assertEquals(undefined, (() => {
for (let x of g()) { break; }
})());
assertEquals(undefined, (() => {
for (const x of g()) { break; }
})());
assertEquals(undefined, (() => {
for (x of g()) { break; }
})());
assertThrowsEquals(() => {
for (var x of g()) { throw 42; }
}, 42);
assertThrowsEquals(() => {
for (let x of g()) { throw 42; }
}, 42);
assertThrowsEquals(() => {
for (const x of g()) { throw 42; }
}, 42);
assertThrowsEquals(() => {
for (x of g()) { throw 42; }
}, 42);
assertEquals(42, (() => {
for (var x of g()) { return 42; }
})());
assertEquals(42, (() => {
for (let x of g()) { return 42; }
})());
assertEquals(42, (() => {
for (const x of g()) { return 42; }
})());
assertEquals(42, (() => {
for (x of g()) { return 42; }
})());
assertEquals(42, eval('for (var x of g()) { x; }'));
assertEquals(42, eval('for (let x of g()) { x; }'));
assertEquals(42, eval('for (const x of g()) { x; }'));
assertEquals(42, eval('for (x of g()) { x; }'));
assertEquals(42, (() => {
var [x] = g(); return x;
})());
assertEquals(42, (() => {
let [x] = g(); return x;
})());
assertEquals(42, (() => {
const [x] = g(); return x;
})());
assertEquals(42, (() => {
[x] = g(); return x;
})());
assertEquals(42,
(([x]) => x)(g())
);
}
// Return method is not callable.
{
g.prototype.return = 666;
assertThrows(() => {
for (var x of g()) { break; }
}, TypeError);
assertThrows(() => {
for (let x of g()) { break; }
}, TypeError);
assertThrows(() => {
for (const x of g()) { break; }
}, TypeError);
assertThrows(() => {
for (x of g()) { break; }
}, TypeError);
assertThrows(() => {
for (var x of g()) { throw 666; }
}, TypeError);
assertThrows(() => {
for (let x of g()) { throw 666; }
}, TypeError);
assertThrows(() => {
for (const x of g()) { throw 666; }
}, TypeError);
assertThrows(() => {
for (x of g()) { throw 666; }
}, TypeError);
assertThrows(() => {
for (var x of g()) { return 666; }
}, TypeError);
assertThrows(() => {
for (let x of g()) { return 666; }
}, TypeError);
assertThrows(() => {
for (const x of g()) { return 666; }
}, TypeError);
assertThrows(() => {
for (x of g()) { return 666; }
}, TypeError);
assertEquals(42, eval('for (var x of g()) { x; }'));
assertEquals(42, eval('for (let x of g()) { x; }'));
assertEquals(42, eval('for (const x of g()) { x; }'));
assertEquals(42, eval('for (x of g()) { x; }'));
assertThrows(() => {
var [x] = g(); return x;
}, TypeError);
assertThrows(() => {
let [x] = g(); return x;
}, TypeError);
assertThrows(() => {
const [x] = g(); return x;
}, TypeError);
assertThrows(() => {
[x] = g(); return x;
}, TypeError);
assertThrows(() => {
(([x]) => x)(g());
}, TypeError);
}
// Return method does not return an object.
{
g.prototype.return = () => 666;
assertThrows(() => {
for (var x of g()) { break; }
}, TypeError);
assertThrows(() => {
for (let x of g()) { break; }
}, TypeError);
assertThrows(() => {
for (const x of g()) { break; }
}, TypeError);
assertThrows(() => {
for (x of g()) { break; }
}, TypeError);
// Throw from the body of a for loop 'wins' vs throw
// originating from a bad 'return' value.
assertThrowsEquals(() => {
for (var x of g()) { throw 666; }
}, 666);
assertThrowsEquals(() => {
for (let x of g()) { throw 666; }
}, 666);
assertThrowsEquals(() => {
for (const x of g()) { throw 666; }
}, 666);
assertThrowsEquals(() => {
for (x of g()) { throw 666; }
}, 666);
assertThrows(() => {
for (var x of g()) { return 666; }
}, TypeError);
assertThrows(() => {
for (let x of g()) { return 666; }
}, TypeError);
assertThrows(() => {
for (const x of g()) { return 666; }
}, TypeError);
assertThrows(() => {
for (x of g()) { return 666; }
}, TypeError);
assertEquals(42, eval('for (var x of g()) { x; }'));
assertEquals(42, eval('for (let x of g()) { x; }'));
assertEquals(42, eval('for (const x of g()) { x; }'));
assertEquals(42, eval('for (x of g()) { x; }'));
assertThrows(() => {
var [x] = g(); return x;
}, TypeError);
assertThrows(() => {
let [x] = g(); return x;
}, TypeError);
assertThrows(() => {
const [x] = g(); return x;
}, TypeError);
assertThrows(() => {
[x] = g(); return x;
}, TypeError);
assertThrows(() => {
(([x]) => x)(g());
}, TypeError);
}
// Return method returns an object.
{
let log = [];
g.prototype.return = (...args) => { log.push(args); return {} };
log = [];
for (var x of g()) { break; }
assertEquals([[]], log);
log = [];
for (let x of g()) { break; }
assertEquals([[]], log);
log = [];
for (const x of g()) { break; }
assertEquals([[]], log);
log = [];
for (x of g()) { break; }
assertEquals([[]], log);
log = [];
assertThrowsEquals(() => {
for (var x of g()) { throw 42; }
}, 42);
assertEquals([[]], log);
log = [];
assertThrowsEquals(() => {
for (let x of g()) { throw 42; }
}, 42);
assertEquals([[]], log);
log = [];
assertThrowsEquals(() => {
for (const x of g()) { throw 42; }
}, 42);
assertEquals([[]], log);
log = [];
assertThrowsEquals(() => {
for (x of g()) { throw 42; }
}, 42);
assertEquals([[]], log);
log = [];
assertEquals(42, (() => {
for (var x of g()) { return 42; }
})());
assertEquals([[]], log);
log = [];
assertEquals(42, (() => {
for (let x of g()) { return 42; }
})());
assertEquals([[]], log);
log = [];
assertEquals(42, (() => {
for (const x of g()) { return 42; }
})());
assertEquals([[]], log);
log = [];
assertEquals(42, (() => {
for (x of g()) { return 42; }
})());
assertEquals([[]], log);
log = [];
assertEquals(42, eval('for (var x of g()) { x; }'));
assertEquals([], log);
log = [];
assertEquals(42, eval('for (let x of g()) { x; }'));
assertEquals([], log);
log = [];
assertEquals(42, eval('for (const x of g()) { x; }'));
assertEquals([], log);
log = [];
assertEquals(42, eval('for (x of g()) { x; }'));
assertEquals([], log);
// Even if doing the assignment throws, still call return
log = [];
x = { set attr(_) { throw 1234; } };
assertThrowsEquals(() => {
for (x.attr of g()) { throw 456; }
}, 1234);
assertEquals([[]], log);
log = [];
assertEquals(42, (() => {
var [x] = g(); return x;
})());
assertEquals([[]], log);
log = [];
assertEquals(42, (() => {
let [x] = g(); return x;
})());
assertEquals([[]], log);
log = [];
assertEquals(42, (() => {
const [x] = g(); return x;
})());
assertEquals([[]], log);
log = [];
assertEquals(42, (() => {
[x] = g(); return x;
})());
assertEquals([[]], log);
log = []
assertEquals(42,
(([x]) => x)(g())
);
assertEquals([[]], log);
log = [];
assertEquals(42, (() => {
var [x,] = g(); return x;
})());
assertEquals([[]], log);
log = [];
assertEquals(42, (() => {
let [x,] = g(); return x;
})());
assertEquals([[]], log);
log = [];
assertEquals(42, (() => {
const [x,] = g(); return x;
})());
assertEquals([[]], log);
log = [];
assertEquals(42, (() => {
[x,] = g(); return x;
})());
assertEquals([[]], log);
log = []
assertEquals(42,
(([x,]) => x)(g())
);
assertEquals([[]], log);
log = [];
assertEquals(42, (() => {
var [x,,] = g(); return x;
})());
assertEquals([], log);
log = [];
assertEquals(42, (() => {
let [x,,] = g(); return x;
})());
assertEquals([], log);
log = [];
assertEquals(42, (() => {
const [x,,] = g(); return x;
})());
assertEquals([], log);
log = [];
assertEquals(42, (() => {
[x,,] = g(); return x;
})());
assertEquals([], log);
log = []
assertEquals(42,
(([x,,]) => x)(g())
);
assertEquals([], log);
log = [];
assertEquals([42, undefined], (() => {
var [x, y] = g(); return [x, y];
})());
assertEquals([], log);
log = [];
assertEquals([42, undefined], (() => {
let [x, y] = g(); return [x, y];
})());
assertEquals([], log);
log = [];
assertEquals([42, undefined], (() => {
const [x, y] = g(); return [x, y];
})());
assertEquals([], log);
log = [];
assertEquals([42, undefined], (() => {
[x, y] = g(); return [x, y];
})());
assertEquals([], log);
log = []
assertEquals([42, undefined],
(([x, y]) => [x, y])(g())
);
assertEquals([], log);
log = [];
assertEquals([42], (() => {
var [...x] = g(); return x;
})());
assertEquals([], log);
log = [];
assertEquals([42], (() => {
let [...x] = g(); return x;
})());
assertEquals([], log);
log = [];
assertEquals([42], (() => {
const [...x] = g(); return x;
})());
assertEquals([], log);
log = [];
assertEquals([42], (() => {
[...x] = g(); return x;
})());
assertEquals([], log);
log = []
assertEquals([42],
(([...x]) => x)(g())
);
assertEquals([], log);
log = [];
assertEquals([42, []], (() => {
var [x, ...y] = g(); return [x, y];
})());
assertEquals([], log);
log = [];
assertEquals([42, []], (() => {
let [x, ...y] = g(); return [x, y];
})());
assertEquals([], log);
log = [];
assertEquals([42, []], (() => {
const [x, ...y] = g(); return [x, y];
})());
assertEquals([], log);
log = [];
assertEquals([42, []], (() => {
[x, ...y] = g(); return [x, y];
})());
assertEquals([], log);
log = []
assertEquals([42, []],
(([x, ...y]) => [x, y])(g())
);
assertEquals([], log);
log = [];
assertEquals([], (() => {
var [] = g(); return [];
})());
assertEquals([[]], log);
log = [];
assertEquals([], (() => {
let [] = g(); return [];
})());
assertEquals([[]], log);
log = [];
assertEquals([], (() => {
const [] = g(); return [];
})());
assertEquals([[]], log);
log = [];
assertEquals([], (() => {
[] = g(); return [];
})());
assertEquals([[]], log);
log = []
assertEquals([],
(([]) => [])(g())
);
assertEquals([[]], log);
log = [];
assertEquals([], (() => {
var [...[]] = g(); return [];
})());
assertEquals([], log);
log = [];
assertEquals([], (() => {
let [...[]] = g(); return [];
})());
assertEquals([], log);
log = [];
assertEquals([], (() => {
const [...[]] = g(); return [];
})());
assertEquals([], log);
log = [];
assertEquals([], (() => {
[...[]] = g(); return [];
})());
assertEquals([], log);
log = []
assertEquals([],
(([...[]]) => [])(g())
);
assertEquals([], log);
log = [];
assertEquals([42], (() => {
var [...[x]] = g(); return [x];
})());
assertEquals([], log);
log = [];
assertEquals([42], (() => {
let [...[x]] = g(); return [x];
})());
assertEquals([], log);
log = [];
assertEquals([42], (() => {
const [...[x]] = g(); return [x];
})());
assertEquals([], log);
log = [];
assertEquals([42], (() => {
[...[x]] = g(); return [x];
})());
assertEquals([], log);
log = []
assertEquals([42],
(([...[x]]) => [x])(g())
);
assertEquals([], log);
log = [];
assertEquals([42, undefined], (() => {
var [...[x, y]] = g(); return [x, y];
})());
assertEquals([], log);
log = [];
assertEquals([42, undefined], (() => {
let [...[x, y]] = g(); return [x, y];
})());
assertEquals([], log);
log = [];
assertEquals([42, undefined], (() => {
const [...[x, y]] = g(); return [x, y];
})());
assertEquals([], log);
log = [];
assertEquals([42, undefined], (() => {
[...[x, y]] = g(); return [x, y];
})());
assertEquals([], log);
log = []
assertEquals([42, undefined],
(([...[x, y]]) => [x, y])(g())
);
assertEquals([], log);
log = []
assertThrowsEquals(() => {
let x = { set foo(_) { throw 666; } };
[x.foo] = g();
}, 666);
assertEquals([[]], log);
log = []
assertThrows(() => {
var [[]] = g();
}, TypeError);
assertEquals([[]], log);
log = []
assertThrows(() => {
let [[]] = g();
}, TypeError);
assertEquals([[]], log);
log = []
assertThrows(() => {
const [[]] = g();
}, TypeError);
assertEquals([[]], log);
log = []
assertThrows(() => {
[[]] = g();
}, TypeError);
assertEquals([[]], log);
log = []
assertThrows(() => {
(([[]]) => 0)(g());
}, TypeError);
assertEquals([[]], log);
log = []
assertThrows(() => {
var [...[[]]] = g();
}, TypeError);
assertEquals([], log);
log = []
assertThrows(() => {
let [...[[]]] = g();
}, TypeError);
assertEquals([], log);
log = []
assertThrows(() => {
const [...[[]]] = g();
}, TypeError);
assertEquals([], log);
log = []
assertThrows(() => {
[...[[]]] = g();
}, TypeError);
assertEquals([], log);
log = []
assertThrows(() => {
(([...[[]]]) => 0)(g());
}, TypeError);
assertEquals([], log);
{
let backup = Array.prototype[Symbol.iterator];
Array.prototype[Symbol.iterator] = () => g();
log = [];
assertDoesNotThrow(() => {
var [x, ...[y]] = [1, 2, 3]
});
assertEquals(log, [[]]);
log = [];
assertDoesNotThrow(() => {
let [x, ...[y]] = [1, 2, 3];
});
assertEquals(log, [[]]);
log = [];
assertDoesNotThrow(() => {
const [x, ...[y]] = [1, 2, 3];
});
assertEquals(log, [[]]);
log = [];
assertDoesNotThrow(() => {
(([x, ...[y]]) => {})([1, 2, 3]);
});
assertEquals(log, [[]]);
log = [];
assertThrows(() => {
var [x, ...[[]]] = [1, 2, 3];
}, TypeError);
assertEquals(log, [[]]);
log = [];
assertThrows(() => {
let [x, ...[[]]] = [1, 2, 3];
}, TypeError);
assertEquals(log, [[]]);
log = [];
assertThrows(() => {
const [x, ...[[]]] = [1, 2, 3];
}, TypeError);
assertEquals(log, [[]]);
log = [];
assertThrows(() => {
(([x, ...[[]]]) => {})([1, 2, 3]);
}, TypeError);
assertEquals(log, [[]]);
log = [];
assertDoesNotThrow(() => {
var [x, ...[...y]] = [1, 2, 3];
});
assertEquals(log, []);
log = [];
assertDoesNotThrow(() => {
let [x, ...[...y]] = [1, 2, 3];
});
assertEquals(log, []);
log = [];
assertDoesNotThrow(() => {
const [x, ...[...y]] = [1, 2, 3];
});
assertEquals(log, []);
log = [];
assertDoesNotThrow(() => {
(([x, ...[...y]]) => {})([1, 2, 3]);
});
assertEquals(log, []);
Array.prototype[Symbol.iterator] = backup;
}
}
// Return method throws.
{
let log = [];
g.prototype.return = (...args) => { log.push(args); throw 23 };
log = [];
assertThrowsEquals(() => {
for (var x of g()) { break; }
}, 23);
assertEquals([[]], log);
log = [];
assertThrowsEquals(() => {
for (let x of g()) { break; }
}, 23);
assertEquals([[]], log);
log = [];
assertThrowsEquals(() => {
for (const x of g()) { break; }
}, 23);
assertEquals([[]], log);
log = [];
assertThrowsEquals(() => {
for (x of g()) { break; }
}, 23);
assertEquals([[]], log);
log = [];
assertThrowsEquals(() => {
for (var x of g()) { throw 42; }
}, 42);
assertEquals([[]], log);
log = [];
assertThrowsEquals(() => {
for (let x of g()) { throw 42; }
}, 42);
assertEquals([[]], log);
log = [];
assertThrowsEquals(() => {
for (const x of g()) { throw 42; }
}, 42);
assertEquals([[]], log);
log = [];
assertThrowsEquals(() => {
for (x of g()) { throw 42; }
}, 42);
assertEquals([[]], log);
log = [];
assertThrowsEquals(() => {
for (var x of g()) { return 42; }
}, 23);
assertEquals([[]], log);
log = [];
assertThrowsEquals(() => {
for (let x of g()) { return 42; }
}, 23);
assertEquals([[]], log);
log = [];
assertThrowsEquals(() => {
for (const x of g()) { return 42; }
}, 23);
assertEquals([[]], log);
log = [];
assertThrowsEquals(() => {
for (x of g()) { return 42; }
}, 23);
assertEquals([[]], log);
log = [];
assertEquals(42, eval('for (var x of g()) { x; }'));
assertEquals([], log);
log = [];
assertEquals(42, eval('for (let x of g()) { x; }'));
assertEquals([], log);
log = [];
assertEquals(42, eval('for (const x of g()) { x; }'));
assertEquals([], log);
log = [];
assertEquals(42, eval('for (x of g()) { x; }'));
assertEquals([], log);
log = [];
assertThrowsEquals(() => {
var [x] = g(); return x;
}, 23);
assertEquals([[]], log);
log = [];
assertThrowsEquals(() => {
let [x] = g(); return x;
}, 23);
assertEquals([[]], log);
log = [];
assertThrowsEquals(() => {
const [x] = g(); return x;
}, 23);
assertEquals([[]], log);
log = [];
assertThrowsEquals(() => {
[x] = g(); return x;
}, 23);
assertEquals([[]], log);
log = [];
assertThrowsEquals(() => {
(([x]) => x)(g())
}, 23);
assertEquals([[]], log);
}
// Next method throws.
{
g.prototype.next = () => { throw 666; };
g.prototype.return = () => { assertUnreachable() };
assertThrowsEquals(() => {
for (var x of g()) {}
}, 666);
assertThrowsEquals(() => {
for (let x of g()) {}
}, 666);
assertThrowsEquals(() => {
for (const x of g()) {}
}, 666);
assertThrowsEquals(() => {
for (x of g()) {}
}, 666);
assertThrowsEquals(() => {
var [x] = g();
}, 666);
assertThrowsEquals(() => {
let [x] = g();
}, 666);
assertThrowsEquals(() => {
const [x] = g();
}, 666);
assertThrowsEquals(() => {
[x] = g();
}, 666);
assertThrowsEquals(() => {
(([x]) => x)(g());
}, 666);
assertThrowsEquals(() => {
var [...x] = g();
}, 666);
assertThrowsEquals(() => {
let [...x] = g();
}, 666);
assertThrowsEquals(() => {
const [...x] = g();
}, 666);
assertThrowsEquals(() => {
[...x] = g();
}, 666);
assertThrowsEquals(() => {
(([...x]) => x)(g());
}, 666);
}
// Value throws.
{
g.prototype.next = () => ({get value() {throw 666}});
g.prototype.return = () => { assertUnreachable() };
assertThrowsEquals(() => {
for (var x of g()) {}
}, 666);
assertThrowsEquals(() => {
for (let x of g()) {}
}, 666);
assertThrowsEquals(() => {
for (const x of g()) {}
}, 666);
assertThrowsEquals(() => {
for (x of g()) {}
}, 666);
assertThrowsEquals(() => {
var [x] = g();
}, 666);
assertThrowsEquals(() => {
let [x] = g();
}, 666);
assertThrowsEquals(() => {
const [x] = g();
}, 666);
assertThrowsEquals(() => {
[x] = g();
}, 666);
assertThrowsEquals(() => {
(([x]) => x)(g());
}, 666);
assertThrowsEquals(() => {
var [...x] = g();
}, 666);
assertThrowsEquals(() => {
let [...x] = g();
}, 666);
assertThrowsEquals(() => {
const [...x] = g();
}, 666);
assertThrowsEquals(() => {
[...x] = g();
}, 666);
assertThrowsEquals(() => {
(([...x]) => x)(g());
}, 666);
}
// Done throws.
{
g.prototype.next = () => ({get done() {throw 666}});
g.prototype.return = () => { assertUnreachable() };
assertThrowsEquals(() => {
for (var x of g()) {}
}, 666);
assertThrowsEquals(() => {
for (let x of g()) {}
}, 666);
assertThrowsEquals(() => {
for (const x of g()) {}
}, 666);
assertThrowsEquals(() => {
for (x of g()) {}
}, 666);
assertThrowsEquals(() => {
var [x] = g();
}, 666);
assertThrowsEquals(() => {
let [x] = g();
}, 666);
assertThrowsEquals(() => {
const [x] = g();
}, 666);
assertThrowsEquals(() => {
[x] = g();
}, 666);
assertThrowsEquals(() => {
(([x]) => x)(g());
}, 666);
assertThrowsEquals(() => {
var [...x] = g();
}, 666);
assertThrowsEquals(() => {
let [...x] = g();
}, 666);
assertThrowsEquals(() => {
const [...x] = g();
}, 666);
assertThrowsEquals(() => {
[...x] = g();
}, 666);
assertThrowsEquals(() => {
(([...x]) => x)(g());
}, 666);
}
// Nested loops.
{
function* g1() { yield 1; yield 2; throw 3; }
function* g2() { yield -1; yield -2; throw -3; }
assertDoesNotThrow(() => {
for (let x of g1()) {
for (let y of g2()) {
if (y == -2) break;
}
if (x == 2) break;
}
}, -3);
assertThrowsEquals(() => {
for (let x of g1()) {
for (let y of g2()) {
}
}
}, -3);
assertThrowsEquals(() => {
for (let x of g1()) {
for (let y of g2()) {
if (y == -2) break;
}
}
}, 3);
assertDoesNotThrow(() => {
l: for (let x of g1()) {
for (let y of g2()) {
if (y == -2) break l;
}
}
});
assertThrowsEquals(() => {
for (let x of g1()) {
for (let y of g2()) {
throw 4;
}
}
}, 4);
assertThrowsEquals(() => {
for (let x of g1()) {
for (let y of g2()) {
if (y == -2) throw 4;
}
}
}, 4);
let log = [];
g1.prototype.return = () => { log.push(1); throw 5 };
g2.prototype.return = () => { log.push(2); throw -5 };
log = [];
assertThrowsEquals(() => {
for (let x of g1()) {
for (let y of g2()) {
if (y == -2) break;
}
if (x == 2) break;
}
}, -5);
assertEquals([2, 1], log);
log = [];
assertThrowsEquals(() => {
for (let x of g1()) {
for (let y of g2()) {
}
}
}, -3);
assertEquals([1], log);
log = [];
assertThrowsEquals(() => {
for (let x of g1()) {
for (let y of g2()) {
if (y == -2) break;
}
}
}, -5);
assertEquals([2, 1], log);
log = [];
assertThrowsEquals(() => {
l: for (let x of g1()) {
for (let y of g2()) {
if (y == -2) break l;
}
}
}, -5);
assertEquals([2, 1], log);
log = [];
assertThrowsEquals(() => {
for (let x of g1()) {
for (let y of g2()) {
throw 4;
}
}
}, 4);
assertEquals([2, 1], log);
log = [];
assertThrowsEquals(() => {
for (let x of g1()) {
for (let y of g2()) {
if (y == -2) throw 4;
}
}
}, 4);
assertEquals([2, 1], log);
log = [];
assertThrowsEquals(() => {
for (let x of g1()) {
try {
for (let y of g2()) {
}
} catch (_) {}
}
}, 3);
assertEquals([], log);
log = [];
assertThrowsEquals(() => {
for (let x of g1()) {
try {
for (let y of g2()) {
}
} catch (_) {}
if (x == 2) break;
}
}, 5);
assertEquals([1], log);
}
// yield*, argument's return method is "undefined".
function TestYieldStarWithoutReturn(get_iterable) {
assertTrue(get_iterable().return == undefined);
function* g() { yield* get_iterable() }
{
let gen = g();
assertEquals({value: 1, done: false}, gen.next());
assertEquals({value: undefined, done: true}, gen.return());
}
assertEquals(42, (() => {
for (let x of g()) break;
return 42;
})());
assertEquals(42, (() => {
for (let x of g()) return 42;
})());
assertThrowsEquals(() => {
for (let x of g()) throw 42;
}, 42);
}
{
let get_iterable1 = () => [1, 2];
let get_iterable2 = function*() { yield 1; yield 2 };
get_iterable2.prototype.return = null;
TestYieldStarWithoutReturn(get_iterable1);
TestYieldStarWithoutReturn(get_iterable2);
}
// yield*, argument's return method is defined.
{
let get_iterable = function*() { yield 1; yield 2 };
const obj = {};
get_iterable.prototype.return = (...args) => obj;
function* g() { yield* get_iterable() }
{
let gen = g();
assertEquals({value: 1, done: false}, gen.next());
assertSame(obj, gen.return());
assertSame(obj, gen.return());
assertSame(obj, gen.return());
assertEquals({value: 2, done: false}, gen.next());
assertSame(obj, gen.return());
assertSame(obj, gen.return());
assertSame(obj, gen.return());
assertEquals({value: undefined, done: true}, gen.next());
assertEquals({value: undefined, done: true}, gen.return());
assertEquals({value: undefined, done: true}, gen.return());
}
assertEquals(42, (() => {
for (let x of g()) break;
return 42;
})());
assertEquals(42, (() => {
for (let x of g()) return 42;
})());
assertThrowsEquals(() => {
for (let x of g()) throw 42;
}, 42);
}