OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2016 the V8 project authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 // Flags: --harmony-async-iteration --allow-natives-syntax | |
6 | |
7 let testFailed = false; | |
8 let testFailure; | |
9 (async function() { | |
10 const kNext = 1; | |
11 const kThrow = 2; | |
12 const kReturn = 4; | |
13 | |
14 function async(iterable, features = kNext, log = []) { | |
15 // Helper to turn a synchronous iterable into an asynchronous iterable, | |
16 // without using the [Async-from-Sync Iterator]. | |
17 let it = iterable[Symbol.iterator](); | |
18 let methods = { | |
19 next(sentValue) { | |
20 return new Promise(function(resolve, reject) { | |
21 let {value, done} = it.next(sentValue); | |
22 Promise.resolve(value).then(function(value) { | |
23 log.push(".next() -> resolved " + value); | |
24 resolve({value, done}); | |
25 }, function(value) { | |
26 log.push(".next() -> rejected " + value); | |
27 reject(value); | |
28 }); | |
29 }); | |
30 }, | |
31 | |
32 throw(sentValue) { | |
33 return new Promise(function(resolve, reject) { | |
34 let throwMethod = it.throw; | |
35 if (typeof throwMethod !== "function") { | |
36 log.push(".throw(" + sentValue + ")"); | |
37 return reject(sentValue); | |
38 } | |
39 | |
40 let {value, done} = throwMethod.call(it, sentValue); | |
41 Promise.resolve(value).then(function(value) { | |
42 log.push(".throw() -> resolved " + value); | |
43 resolve({ value, done }); | |
44 }, function(value) { | |
45 log.push(".throw() -> rejected " + value); | |
46 reject(value); | |
47 }); | |
48 }); | |
49 }, | |
50 | |
51 return(sentValue) { | |
52 return new Promise(function(resolve, reject) { | |
53 let returnMethod = it.return; | |
54 if (typeof returnMethod !== "function") { | |
55 log.push(".return(" + sentValue + ")"); | |
56 return resolve({value: sentValue, done: true}); | |
57 } | |
58 | |
59 let {value, done} = returnMethod.call(it, sentValue); | |
60 Promise.resolve(value).then(function(value) { | |
61 log.push(".return() -> resolved " + value); | |
62 resolve({ value, done }); | |
63 }, function(value) { | |
64 log.push(".return() -> rejected " + value); | |
65 reject(value); | |
66 }); | |
67 }); | |
68 } | |
69 }; | |
70 | |
71 | |
72 return { | |
73 [Symbol.asyncIterator]() { | |
74 log.push("[Symbol.asyncIterator]()") | |
75 return this; | |
76 }, | |
77 | |
78 next: (features & kNext) ? methods.next : undefined, | |
79 throw: (features & kThrow) ? methods.throw : undefined, | |
80 return: (features & kReturn) ? methods.return : undefined | |
81 }; | |
82 } | |
83 | |
84 let testDone; | |
85 let test; | |
86 async function testBindingIdentifierVarDeclarationStatement() { | |
87 let sum = 0; | |
88 testDone = false; | |
89 for await(var value of async([100, 200, 300, 400, 500])) sum += value; | |
90 testDone = true; | |
91 return sum; | |
92 } | |
93 | |
94 test = testBindingIdentifierVarDeclarationStatement(); | |
95 assertFalse(testDone); | |
96 assertEquals(1500, await test); | |
97 assertTrue(testDone); | |
98 | |
99 async function testBindingIdentifierVarDeclarationBlockStatement() { | |
100 let sum = 0; | |
101 testDone = false; | |
102 for await(var value of async([100, 200, 300, 400, 500])) { | |
103 'use strict'; | |
104 let strict = (function() { return this === undefined; })(); | |
105 assertFalse(strict); | |
106 sum += value; | |
107 } | |
108 testDone = true; | |
109 return sum; | |
110 } | |
111 | |
112 test = testBindingIdentifierVarDeclarationBlockStatement(); | |
113 assertFalse(testDone); | |
114 assertEquals(1500, await test); | |
115 assertTrue(testDone); | |
116 | |
117 async function testObjectBindingPatternVarDeclarationStatement() { | |
118 let sum = 0, keys = []; | |
119 let collection = [ | |
120 {key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30}, | |
121 {key: 'last', value: 40} | |
122 ]; | |
123 testDone = false; | |
124 for await(var {key = 'unknown', value} of async(collection)) | |
125 keys.push(key), sum += value; | |
126 testDone = true; | |
127 return {keys, sum}; | |
128 } | |
129 | |
130 test = testObjectBindingPatternVarDeclarationStatement(); | |
131 assertFalse(testDone); | |
132 assertEquals( | |
133 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
134 assertTrue(testDone); | |
135 | |
136 async function testObjectBindingPatternVarDeclarationBlockStatement() { | |
137 let sum = 0, keys = []; | |
138 let collection = [ | |
139 {key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30}, | |
140 {key: 'last', value: 40} | |
141 ]; | |
142 testDone = false; | |
143 for await(var {key = 'unknown', value} of async(collection)) { | |
144 'use strict'; | |
145 let strict = (function() { return this === undefined; })(); | |
146 assertFalse(strict); | |
147 keys.push(key); | |
148 sum += value; | |
149 } | |
150 testDone = true; | |
151 return {keys, sum}; | |
152 } | |
153 | |
154 test = testObjectBindingPatternVarDeclarationBlockStatement(); | |
155 assertFalse(testDone); | |
156 assertEquals( | |
157 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
158 assertTrue(testDone); | |
159 | |
160 async function testArrayBindingPatternVarDeclarationStatement() { | |
161 let sum = 0, keys = []; | |
162 let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]]; | |
163 testDone = false; | |
164 for await(var [key = 'unknown', value] of async(collection)) | |
165 keys.push(key), sum += value; | |
166 testDone = true; | |
167 return {keys, sum}; | |
168 } | |
169 | |
170 test = testArrayBindingPatternVarDeclarationStatement(); | |
171 assertFalse(testDone); | |
172 assertEquals( | |
173 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
174 assertTrue(testDone); | |
175 | |
176 async function testArrayBindingPatternVarDeclarationBlockStatement() { | |
177 let sum = 0, keys = []; | |
178 let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]]; | |
179 testDone = false; | |
180 for await(var [key = 'unknown', value] of async(collection)) { | |
181 'use strict'; | |
182 let strict = (function() { return this === undefined; })(); | |
183 assertFalse(strict); | |
184 keys.push(key); | |
185 sum += value; | |
186 } | |
187 testDone = true; | |
188 return {keys, sum}; | |
189 } | |
190 | |
191 test = testArrayBindingPatternVarDeclarationBlockStatement(); | |
192 assertFalse(testDone); | |
193 assertEquals( | |
194 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
195 assertTrue(testDone); | |
196 | |
197 // -------------------------------------------------------------------------- | |
198 | |
199 async function testBindingIdentifierLetDeclarationStatement() { | |
200 let sum = 0; | |
201 testDone = false; | |
202 for await(let value of async([100, 200, 300, 400, 500])) sum += value; | |
203 testDone = true; | |
204 return sum; | |
205 } | |
206 | |
207 test = testBindingIdentifierLetDeclarationStatement(); | |
208 assertFalse(testDone); | |
209 assertEquals(1500, await test); | |
210 assertTrue(testDone); | |
211 | |
212 async function testBindingIdentifierLetDeclarationBlockStatement() { | |
213 let sum = 0; | |
214 testDone = false; | |
215 for await(let value of async([100, 200, 300, 400, 500])) { | |
216 'use strict'; | |
217 let strict = (function() { return this === undefined; })(); | |
218 assertFalse(strict); | |
219 sum += value; | |
220 } | |
221 testDone = true; | |
222 return sum; | |
223 } | |
224 | |
225 test = testBindingIdentifierLetDeclarationBlockStatement(); | |
226 assertFalse(testDone); | |
227 assertEquals(1500, await test); | |
228 assertTrue(testDone); | |
229 | |
230 async function testObjectBindingPatternLetDeclarationStatement() { | |
231 let sum = 0, keys = []; | |
232 let collection = [ | |
233 {key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30}, | |
234 {key: 'last', value: 40} | |
235 ]; | |
236 testDone = false; | |
237 for await(let {key = 'unknown', value} of async(collection)) | |
238 keys.push(key), sum += value; | |
239 testDone = true; | |
240 return {keys, sum}; | |
241 } | |
242 | |
243 test = testObjectBindingPatternLetDeclarationStatement(); | |
244 assertFalse(testDone); | |
245 assertEquals( | |
246 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
247 assertTrue(testDone); | |
248 | |
249 async function testObjectBindingPatternLetDeclarationBlockStatement() { | |
250 let sum = 0, keys = []; | |
251 let collection = [ | |
252 {key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30}, | |
253 {key: 'last', value: 40} | |
254 ]; | |
255 testDone = false; | |
256 for await(let {key = 'unknown', value} of async(collection)) { | |
257 'use strict'; | |
258 let strict = (function() { return this === undefined; })(); | |
259 assertFalse(strict); | |
260 keys.push(key); | |
261 sum += value; | |
262 } | |
263 testDone = true; | |
264 return {keys, sum}; | |
265 } | |
266 | |
267 test = testObjectBindingPatternLetDeclarationBlockStatement(); | |
268 assertFalse(testDone); | |
269 assertEquals( | |
270 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
271 assertTrue(testDone); | |
272 | |
273 async function testArrayBindingPatternLetDeclarationStatement() { | |
274 let sum = 0, keys = []; | |
275 let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]]; | |
276 testDone = false; | |
277 for await(let [key = 'unknown', value] of async(collection)) | |
278 keys.push(key), sum += value; | |
279 testDone = true; | |
280 return {keys, sum}; | |
281 } | |
282 | |
283 test = testArrayBindingPatternLetDeclarationStatement(); | |
284 assertFalse(testDone); | |
285 assertEquals( | |
286 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
287 assertTrue(testDone); | |
288 | |
289 async function testArrayBindingPatternLetDeclarationBlockStatement() { | |
290 let sum = 0, keys = []; | |
291 let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]]; | |
292 testDone = false; | |
293 for await(let [key = 'unknown', value] of async(collection)) { | |
294 'use strict'; | |
295 let strict = (function() { return this === undefined; })(); | |
296 assertFalse(strict); | |
297 keys.push(key); | |
298 sum += value; | |
299 } | |
300 testDone = true; | |
301 return {keys, sum}; | |
302 } | |
303 | |
304 test = testArrayBindingPatternLetDeclarationBlockStatement(); | |
305 assertFalse(testDone); | |
306 assertEquals( | |
307 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
308 assertTrue(testDone); | |
309 | |
310 // -------------------------------------------------------------------------- | |
311 | |
312 async function testBindingIdentifierConstDeclarationStatement() { | |
313 let sum = 0; | |
314 testDone = false; | |
315 for await(let value of async([100, 200, 300, 400, 500])) sum += value; | |
316 testDone = true; | |
317 return sum; | |
318 } | |
319 | |
320 test = testBindingIdentifierConstDeclarationStatement(); | |
321 assertFalse(testDone); | |
322 assertEquals(1500, await test); | |
323 assertTrue(testDone); | |
324 | |
325 async function testBindingIdentifierConstDeclarationBlockStatement() { | |
326 let sum = 0; | |
327 testDone = false; | |
328 for await(const value of async([100, 200, 300, 400, 500])) { | |
329 'use strict'; | |
330 // Ensure strict mode applies to block with use-strict-directive | |
neis
2017/01/24 12:49:19
Fix or remove comment.
caitp
2017/01/24 22:51:55
removed
| |
331 let strict = (function() { return this === undefined; })(); | |
332 assertFalse(strict); | |
333 sum += value; | |
334 } | |
335 testDone = true; | |
336 return sum; | |
337 } | |
338 | |
339 test = testBindingIdentifierConstDeclarationBlockStatement(); | |
340 assertFalse(testDone); | |
341 assertEquals(1500, await test); | |
342 assertTrue(testDone); | |
343 | |
344 async function testObjectBindingPatternConstDeclarationStatement() { | |
345 let sum = 0, keys = []; | |
346 let collection = [ | |
347 {key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30}, | |
348 {key: 'last', value: 40} | |
349 ]; | |
350 testDone = false; | |
351 for await(const {key = 'unknown', value} of async(collection)) | |
352 keys.push(key), sum += value; | |
353 testDone = true; | |
354 return {keys, sum}; | |
355 } | |
356 | |
357 test = testObjectBindingPatternConstDeclarationStatement(); | |
358 assertFalse(testDone); | |
359 assertEquals( | |
360 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
361 assertTrue(testDone); | |
362 | |
363 async function testObjectBindingPatternConstDeclarationBlockStatement() { | |
364 let sum = 0, keys = []; | |
365 let collection = [ | |
366 {key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30}, | |
367 {key: 'last', value: 40} | |
368 ]; | |
369 testDone = false; | |
370 for await(const {key = 'unknown', value} of async(collection)) { | |
371 'use strict'; | |
372 let strict = (function() { return this === undefined; })(); | |
373 assertFalse(strict); | |
374 keys.push(key); | |
375 sum += value; | |
376 } | |
377 testDone = true; | |
378 return {keys, sum}; | |
379 } | |
380 | |
381 test = testObjectBindingPatternConstDeclarationBlockStatement(); | |
382 assertFalse(testDone); | |
383 assertEquals( | |
384 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
385 assertTrue(testDone); | |
386 | |
387 async function testArrayBindingPatternConstDeclarationStatement() { | |
388 let sum = 0, keys = []; | |
389 let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]]; | |
390 testDone = false; | |
391 for await(const [key = 'unknown', value] of async(collection)) | |
392 keys.push(key), sum += value; | |
393 testDone = true; | |
394 return {keys, sum}; | |
395 } | |
396 | |
397 test = testArrayBindingPatternConstDeclarationStatement(); | |
398 assertFalse(testDone); | |
399 assertEquals( | |
400 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
401 assertTrue(testDone); | |
402 | |
403 async function testArrayBindingPatternConstDeclarationBlockStatement() { | |
404 let sum = 0, keys = []; | |
405 let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]]; | |
406 testDone = false; | |
407 for await(const [key = 'unknown', value] of async(collection)) { | |
408 'use strict'; | |
409 let strict = (function() { return this === undefined; })(); | |
410 assertFalse(strict); | |
411 keys.push(key); | |
412 sum += value; | |
413 } | |
414 testDone = true; | |
415 return {keys, sum}; | |
416 } | |
417 | |
418 test = testArrayBindingPatternLetDeclarationBlockStatement(); | |
419 assertFalse(testDone); | |
420 assertEquals( | |
421 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
422 assertTrue(testDone); | |
423 | |
424 // -------------------------------------------------------------------------- | |
425 | |
426 async function testBindingIdentifierLHSStatement() { | |
427 let sum = 0; | |
428 let value; | |
429 testDone = false; | |
430 for await(value of async([100, 200, 300, 400, 500])) sum += value; | |
431 testDone = true; | |
432 return sum; | |
433 } | |
434 | |
435 test = testBindingIdentifierLHSStatement(); | |
436 assertFalse(testDone); | |
437 assertEquals(1500, await test); | |
438 assertTrue(testDone); | |
439 | |
440 async function testBindingIdentifierLHSBlockStatement() { | |
441 let sum = 0; | |
442 let value; | |
443 testDone = false; | |
444 for await(value of async([100, 200, 300, 400, 500])) { | |
445 'use strict'; | |
446 let strict = (function() { return this === undefined; })(); | |
447 assertFalse(strict); | |
448 sum += value; | |
449 } | |
450 testDone = true; | |
451 return sum; | |
452 } | |
453 | |
454 test = testBindingIdentifierLHSStatement(); | |
455 assertFalse(testDone); | |
456 assertEquals(1500, await test); | |
457 assertTrue(testDone); | |
458 | |
459 async function testObjectBindingPatternLHSStatement() { | |
460 let sum = 0; | |
461 let keys = []; | |
462 let value; | |
463 let key; | |
464 let collection = [ | |
465 {key: 'first', value: 1}, {key: undefined, value: 2}, {value: 3}, | |
466 {key: 'last', value: 4} | |
467 ]; | |
468 testDone = false; | |
469 for await({key = 'unknown', value} of async(collection)) | |
470 keys.push(key), sum += value; | |
471 testDone = true; | |
472 return {keys, sum}; | |
473 } | |
474 | |
475 test = testObjectBindingPatternLHSStatement(); | |
476 assertFalse(testDone); | |
477 assertEquals( | |
478 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 10}, await test); | |
479 assertTrue(testDone); | |
480 | |
481 async function testObjectBindingPatternLHSBlockStatement() { | |
482 let sum = 0; | |
483 let keys = []; | |
484 let value; | |
485 let key; | |
486 let collection = [ | |
487 {key: 'first', value: 1}, {key: undefined, value: 2}, {value: 3}, | |
488 {key: 'last', value: 4} | |
489 ]; | |
490 testDone = false; | |
491 for await({key = 'unknown', value} of async(collection)) { | |
492 'use strict'; | |
493 let strict = (function() { return this === undefined; })(); | |
494 assertFalse(strict); | |
495 keys.push(key); | |
496 sum += value; | |
497 } | |
498 testDone = true; | |
499 return {keys, sum}; | |
500 } | |
501 | |
502 test = testObjectBindingPatternLHSBlockStatement(); | |
503 assertFalse(testDone); | |
504 assertEquals( | |
505 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 10}, await test); | |
506 assertTrue(testDone); | |
507 | |
508 async function testArrayBindingPatternLHSStatement() { | |
509 let sum = 0; | |
510 let keys = []; | |
511 let value; | |
512 let key; | |
513 let collection = [['first', 1], [undefined, 2], [, 3], ['last', 4]]; | |
514 testDone = false; | |
515 for await([key = 'unknown', value] of async(collection)) { | |
516 'use strict'; | |
517 let strict = (function() { return this === undefined; })(); | |
518 assertFalse(strict); | |
519 keys.push(key); | |
520 sum += value; | |
521 } | |
522 testDone = true; | |
523 return {keys, sum}; | |
524 } | |
525 | |
526 test = testArrayBindingPatternLHSStatement(); | |
527 assertFalse(testDone); | |
528 assertEquals( | |
529 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 10}, await test); | |
530 assertTrue(testDone); | |
531 | |
532 async function testArrayBindingPatternLHSBlockStatement() { | |
533 let sum = 0; | |
534 let keys = []; | |
535 let value; | |
536 let key; | |
537 let collection = [ | |
538 {key: 'first', value: 1}, {key: undefined, value: 2}, {value: 3}, | |
539 {key: 'last', value: 4} | |
540 ]; | |
541 testDone = false; | |
542 for await({key = 'unknown', value} of async(collection)) { | |
543 'use strict'; | |
544 let strict = (function() { return this === undefined; })(); | |
545 assertFalse(strict); | |
546 keys.push(key); | |
547 sum += value; | |
548 } | |
549 testDone = true; | |
550 return {keys, sum}; | |
551 } | |
552 | |
553 test = testArrayBindingPatternLHSBlockStatement(); | |
554 assertFalse(testDone); | |
555 assertEquals( | |
556 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 10}, await test); | |
557 assertTrue(testDone); | |
558 | |
559 // -------------------------------------------------------------------------- | |
560 | |
561 async function testBreakStatementReturnMethodNotPresent() { | |
562 let log = []; | |
563 let collection = [1, 2, 3, 4, 5]; | |
564 let sum = 0; | |
565 let i = 0; | |
566 testDone = false; | |
567 for await (var x of async(collection, kNext, log)) { | |
568 sum += x; | |
569 if (++i === 3) break; | |
570 } | |
571 testDone = true; | |
572 return { sum, log }; | |
573 } | |
574 | |
575 test = testBreakStatementReturnMethodNotPresent(); | |
576 assertFalse(testDone); | |
577 assertEquals({sum: 6, log: ["[Symbol.asyncIterator]()", | |
578 ".next() -> resolved 1", | |
579 ".next() -> resolved 2", | |
580 ".next() -> resolved 3"]}, | |
581 await test); | |
582 assertTrue(testDone); | |
583 | |
584 async function testBreakStatementReturnMethodPresent() { | |
585 let log = []; | |
586 let collection = [1, 2, 3, 4, 5]; | |
587 let sum = 0; | |
588 let i = 0; | |
589 testDone = false; | |
590 for await (var x of async(collection, kNext|kReturn, log)) { | |
591 sum += x; | |
592 if (++i === 2) break; | |
593 } | |
594 testDone = true; | |
595 return { sum, log }; | |
596 } | |
597 | |
598 test = testBreakStatementReturnMethodPresent(); | |
599 assertFalse(testDone); | |
600 assertEquals({sum: 3, log: ["[Symbol.asyncIterator]()", | |
601 ".next() -> resolved 1", | |
602 ".next() -> resolved 2", | |
603 ".return(undefined)"]}, | |
604 await test); | |
605 assertTrue(testDone); | |
606 | |
607 async function testReturnStatementReturnMethodNotPresent() { | |
608 let log = []; | |
609 let collection = [1, 2, 3, 4, 5]; | |
610 let sum = 0; | |
611 let i = 0; | |
612 testDone = false; | |
613 for await (var x of async(collection, kNext, log)) { | |
614 sum += x; | |
615 if (++i === 3) { | |
616 testDone = true; | |
617 return { sum, log }; | |
618 } | |
619 } | |
620 } | |
621 | |
622 test = testReturnStatementReturnMethodNotPresent(); | |
623 assertFalse(testDone); | |
624 assertEquals({sum: 6, log: ["[Symbol.asyncIterator]()", | |
625 ".next() -> resolved 1", | |
626 ".next() -> resolved 2", | |
627 ".next() -> resolved 3"]}, | |
628 await test); | |
629 assertTrue(testDone); | |
630 | |
631 async function testReturnStatementReturnMethodPresent() { | |
632 let log = []; | |
633 let collection = [1, 2, 3, 4, 5]; | |
634 let sum = 0; | |
635 let i = 0; | |
636 testDone = false; | |
637 for await (var x of async(collection, kNext|kReturn, log)) { | |
638 sum += x; | |
639 if (++i === 2) { | |
640 testDone = true; | |
641 return { sum, log }; | |
642 } | |
643 } | |
644 } | |
645 | |
646 test = testReturnStatementReturnMethodPresent(); | |
647 assertFalse(testDone); | |
648 assertEquals({sum: 3, log: ["[Symbol.asyncIterator]()", | |
649 ".next() -> resolved 1", | |
650 ".next() -> resolved 2", | |
651 ".return(undefined)"]}, | |
652 await test); | |
653 assertTrue(testDone); | |
654 | |
655 async function testThrowStatementReturnMethodNotPresent() { | |
656 let log = []; | |
657 let collection = [1, 2, 3, 4, 5]; | |
658 let sum = 0; | |
659 let i = 0; | |
660 testDone = false; | |
661 for await (var x of async(collection, kNext|kThrow, log)) { | |
662 sum += x; | |
663 if (++i === 3) { | |
664 testDone = true; | |
665 throw { sum, log, toString() { return "TestError"; } }; | |
666 } | |
667 } | |
668 return { sum, log }; | |
669 } | |
670 | |
671 test = testThrowStatementReturnMethodNotPresent(); | |
672 assertFalse(testDone); | |
673 try { | |
674 await test; | |
675 assertUnreachable("Awaited Promise should be rejected"); | |
676 } catch (e) { | |
677 assertEquals("TestError", e.toString()); | |
678 assertEquals(6, e.sum); | |
679 assertEquals(["[Symbol.asyncIterator]()", ".next() -> resolved 1", | |
680 ".next() -> resolved 2", ".next() -> resolved 3" | |
681 ], e.log); | |
682 assertTrue(testDone); | |
683 } | |
684 | |
685 async function testThrowStatementReturnMethodPresent() { | |
686 let log = []; | |
687 let collection = [1, 2, 3, 4, 5]; | |
688 let sum = 0; | |
689 let i = 0; | |
690 testDone = false; | |
691 for await (var x of async(collection, kNext|kThrow|kReturn, log)) { | |
692 sum += x; | |
693 if (++i === 2) { | |
694 testDone = true; | |
695 throw { sum, log, toString() { return "TestError2"; } }; | |
696 } | |
697 } | |
698 return { sum, log }; | |
699 } | |
700 | |
701 test = testThrowStatementReturnMethodPresent(); | |
702 assertFalse(testDone); | |
703 try { | |
704 await test; | |
705 assertUnreachable("Awaited Promise should be rejected"); | |
706 } catch (e) { | |
707 assertEquals("TestError2", e.toString()); | |
708 assertEquals(3, e.sum); | |
709 assertEquals(["[Symbol.asyncIterator]()", ".next() -> resolved 1", | |
710 ".next() -> resolved 2", ".return(undefined)" | |
711 ], e.log); | |
712 assertTrue(testDone); | |
713 } | |
714 | |
715 })().then(undefined, function(error) { | |
716 testFailed = true; | |
717 testFailure = error; | |
718 }); | |
719 | |
720 %RunMicrotasks(); | |
721 | |
722 if (testFailed) { | |
723 throw testFailure; | |
724 } | |
OLD | NEW |