1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
describe("correct behavior", () => {
test("iterate through array", () => {
const a = [];
for (const num of [1, 2, 3]) {
a.push(num);
}
expect(a).toEqual([1, 2, 3]);
});
test("iterate through string", () => {
const a = [];
for (const char of "hello") {
a.push(char);
}
expect(a).toEqual(["h", "e", "l", "l", "o"]);
});
test("iterate through string object", () => {
const a = [];
for (const char of new String("hello")) {
a.push(char);
}
expect(a).toEqual(["h", "e", "l", "l", "o"]);
});
test("use already-declared variable", () => {
var char;
for (char of "abc");
expect(char).toBe("c");
});
test("respects custom Symbol.iterator method", () => {
const o = {
[Symbol.iterator]() {
return {
i: 0,
next() {
if (this.i++ == 3) {
return { done: true };
}
return { value: this.i, done: false };
},
};
},
};
const a = [];
for (const k of o) {
a.push(k);
}
expect(a).toEqual([1, 2, 3]);
});
test("loops through custom iterator if there is an exception thrown part way through", () => {
// This tests against the way custom iterators used to be implemented, where the values
// were all collected at once before the for-of body was executed, instead of getting
// the values one at a time
const o = {
[Symbol.iterator]() {
return {
i: 0,
next() {
if (this.i++ === 3) {
throw new Error();
}
return { value: this.i };
},
};
},
};
const a = [];
try {
for (let k of o) {
a.push(k);
}
expect().fail();
} catch (e) {
expect(a).toEqual([1, 2, 3]);
}
});
});
describe("errors", () => {
test("right hand side is a primitive", () => {
expect(() => {
for (const _ of 123) {
}
}).toThrowWithMessage(TypeError, "123 is not iterable");
});
test("right hand side is an object", () => {
expect(() => {
for (const _ of { foo: 1, bar: 2 }) {
}
}).toThrowWithMessage(TypeError, "[object Object] is not iterable");
});
});
test("allow binding patterns", () => {
let counter = 0;
for (let [a, b] of [
[1, 2],
[3, 4],
[5, 6],
]) {
expect(a + 1).toBe(b);
counter++;
}
expect(counter).toBe(3);
});
describe("special left hand sides", () => {
test("allow member expression as variable", () => {
const f = {};
for (f.a of "abc");
expect(f.a).toBe("c");
});
test("allow member expression of function call", () => {
const b = {};
function f() {
return b;
}
for (f().a of "abc");
expect(f().a).toBe("c");
});
test("call function is allowed in parsing but fails in runtime", () => {
function f() {
expect().fail();
}
// Does not fail since it does not iterate but prettier does not like it so we use eval.
expect("for (f() of []);").toEvalTo(undefined);
expect(() => {
eval("for (f() of [0]) { expect().fail() }");
}).toThrowWithMessage(ReferenceError, "Invalid left-hand side in assignment");
});
test("Cannot change constant declaration in body", () => {
const vals = [];
for (const v of [1, 2]) {
expect(() => v++).toThrowWithMessage(TypeError, "Invalid assignment to const variable");
vals.push(v);
}
expect(vals).toEqual([1, 2]);
});
});
|
