[ARM,MIPS] Skip slow tests
[WebKit-https.git] / JSTests / stress / generator-yield-star.js
1 function shouldBe(actual, expected) {
2     if (actual !== expected)
3         throw new Error('bad value: ' + actual);
4 }
5
6 function shouldThrow(func, errorMessage) {
7     var errorThrown = false;
8     var error = null;
9     try {
10         func();
11     } catch (e) {
12         errorThrown = true;
13         error = e;
14     }
15     if (!errorThrown)
16         throw new Error('not thrown');
17     if (String(error) !== errorMessage)
18         throw new Error(`bad error: ${String(error)}`);
19 }
20
21 class CallSite {
22     constructor()
23     {
24         this.count = 0;
25     }
26
27     call()
28     {
29         return this.count++;
30     }
31 }
32
33 (function () {
34     class Arrays {
35         constructor()
36         {
37             this.first = [ 0, 1, 2, 3 ];
38             this.second = [ 4, 5, 6, 7 ];
39         }
40
41         *[Symbol.iterator]()
42         {
43             yield * this.first;
44             yield * this.second;
45         }
46     }
47
48     var arrays = new Arrays;
49     let i = 0;
50     for (let value of arrays)
51         shouldBe(i++, value);
52 }());
53
54 (function () {
55     // throw should be propagated.
56     let c1 = new CallSite;
57     class Iterator {
58         next(value)
59         {
60             return { value, done: false };
61         }
62
63         'throw'(value) {
64             shouldBe(value, 42);
65             c1.call();
66             throw new Error("OK");
67         }
68
69         [Symbol.iterator]()
70         {
71             return this;
72         }
73     }
74
75     function *gen()
76     {
77         let iter = new Iterator();
78         yield * iter;
79     }
80
81     let g = gen();
82     shouldBe(g.next(0).value, undefined);
83     shouldBe(g.next(1).value, 1);
84     shouldBe(g.next(2).value, 2);
85     shouldThrow(() => {
86         g.throw(42);
87     }, `Error: OK`);
88     shouldThrow(() => {
89         g.throw(44);
90     }, `44`);
91     shouldBe(c1.count, 1);
92 }());
93
94 (function () {
95     // No `throw` method.
96     let c1 = new CallSite;
97     class Iterator {
98         next(value)
99         {
100             return { value, done: false };
101         }
102
103         'return'(value)
104         {
105             shouldBe(value, undefined);
106             c1.call();
107             return { value, done: true };
108         }
109
110         [Symbol.iterator]()
111         {
112             return this;
113         }
114     }
115
116     function *gen()
117     {
118         let iter = new Iterator();
119         yield * iter;
120     }
121
122     let g = gen();
123     shouldBe(g.next(0).value, undefined);
124     shouldBe(g.next(1).value, 1);
125     shouldBe(g.next(2).value, 2);
126     shouldThrow(() => {
127         g.throw(42);
128     }, `TypeError: Delegated generator does not have a 'throw' method.`);
129     shouldThrow(() => {
130         g.throw(44);
131     }, `44`);
132     shouldBe(c1.count, 1);
133 }());
134
135 (function () {
136     // No `throw` method, `return` returns an incorrect result.
137     let c1 = new CallSite;
138     class Iterator {
139         next(value)
140         {
141             return { value, done: false };
142         }
143
144         'return'(value)
145         {
146             shouldBe(value, undefined);
147             c1.call();
148         }
149
150         [Symbol.iterator]()
151         {
152             return this;
153         }
154     }
155
156     function *gen()
157     {
158         let iter = new Iterator();
159         yield * iter;
160     }
161
162     let g = gen();
163     shouldBe(g.next(0).value, undefined);
164     shouldBe(g.next(1).value, 1);
165     shouldBe(g.next(2).value, 2);
166     shouldThrow(() => {
167         g.throw(42);
168     }, `TypeError: Iterator result interface is not an object.`);
169     shouldThrow(() => {
170         g.throw(44);
171     }, `44`);
172     shouldBe(c1.count, 1);
173 }());
174
175 (function () {
176     // No `throw` method, No `return` method.
177     class Iterator {
178         next(value)
179         {
180             return { value, done: false };
181         }
182
183         [Symbol.iterator]()
184         {
185             return this;
186         }
187     }
188
189     function *gen()
190     {
191         let iter = new Iterator();
192         yield * iter;
193     }
194
195     let g = gen();
196     shouldBe(g.next(0).value, undefined);
197     shouldBe(g.next(1).value, 1);
198     shouldBe(g.next(2).value, 2);
199     shouldThrow(() => {
200         g.throw(42);
201     }, `TypeError: Delegated generator does not have a 'throw' method.`);
202     shouldThrow(() => {
203         g.throw(44);
204     }, `44`);
205 }());
206
207
208 (function () {
209     // `throw` does not throw. Not returns a object.
210     class Iterator {
211         next(value)
212         {
213             return { value, done: false };
214         }
215
216         'throw'(value)
217         {
218         }
219
220         [Symbol.iterator]()
221         {
222             return this;
223         }
224     }
225
226     function *gen()
227     {
228         let iter = new Iterator();
229         yield * iter;
230     }
231
232     let g = gen();
233     shouldBe(g.next(0).value, undefined);
234     shouldBe(g.next(1).value, 1);
235     shouldBe(g.next(2).value, 2);
236     shouldThrow(() => {
237         g.throw(42);
238     }, `TypeError: Iterator result interface is not an object.`);
239     shouldThrow(() => {
240         g.throw(44);
241     }, `44`);
242 }());
243
244 (function () {
245     // `throw` does not throw. If returned iterator result is marked as done, it becomes `return`.
246     class Iterator {
247         next(value)
248         {
249             return { value, done: false };
250         }
251
252         'throw'(value)
253         {
254             return { value, done: true };
255         }
256
257         [Symbol.iterator]()
258         {
259             return this;
260         }
261     }
262
263     function *gen()
264     {
265         let iter = new Iterator();
266         let result = yield * iter;
267         shouldBe(result, 42);
268         yield 21;
269     }
270
271     let g = gen();
272     shouldBe(g.next(0).value, undefined);
273     shouldBe(g.next(1).value, 1);
274     shouldBe(g.next(2).value, 2);
275     shouldBe(g.throw(42).value, 21);
276     shouldBe(g.next().done, true);
277     shouldThrow(() => {
278         g.throw(44);
279     }, `44`);
280 }());
281
282 (function () {
283     // `return` returns done: false.
284     class Iterator {
285         next(value)
286         {
287             return { value, done: false };
288         }
289
290         'return'(value)
291         {
292             return { value, done: false };
293         }
294
295         [Symbol.iterator]()
296         {
297             return this;
298         }
299     }
300
301     function *gen()
302     {
303         let iter = new Iterator();
304         let result = yield * iter;
305         yield result;
306         yield 42;
307     }
308
309     let g = gen();
310     shouldBe(g.next(0).value, undefined);
311     shouldBe(g.next(1).value, 1);
312     shouldBe(g.next(2).value, 2);
313     shouldBe(g.return(42).value, 42);
314     shouldBe(g.return(42).done, false);
315 }());
316
317 (function () {
318     function *gen()
319     {
320         let result = yield * [ 0, 1, 2 ];
321         yield result;
322     }
323
324     let g = gen();
325     shouldBe(g.next().value, 0);
326     shouldBe(g.next().value, 1);
327     shouldBe(g.next().value, 2);
328     shouldBe(g.next().value, undefined);
329 }());