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 --no-lazy | |
neis
2017/01/20 14:38:16
Why do you require --no-lazy?
caitp
2017/01/20 20:17:19
This was from debugging the issue with lexical var
| |
6 | |
7 let testFailed = false; | |
8 let testFailure; | |
9 (async function() { | |
10 | |
11 function async(iterable) { | |
12 // Helper to turn a synchronous iterable into an asynchronous iterable, | |
13 // without using the [Async-from-Sync Iterator]. | |
14 let it = iterable[Symbol.iterator](); | |
15 return { | |
16 [Symbol.asyncIterator]() { | |
17 return this; | |
18 } | |
19 , | |
20 | |
21 next() { | |
neis
2017/01/20 14:38:16
The formatting here seems odd.
caitp
2017/01/20 20:17:19
I think clang-format doesn't really know how to de
| |
22 return new Promise(function(resolve, reject) { | |
23 let {value, done} = it.next(); | |
24 Promise.resolve(value).then(function(value) { | |
25 resolve({value, done}); | |
26 }, reject); | |
27 }); | |
28 } | |
29 } | |
30 } | |
31 | |
32 let testDone; | |
33 let test; | |
neis
2017/01/20 14:38:16
nit: add blank line
caitp
2017/01/20 20:17:19
Done.
| |
34 async function testBindingIdentifierVarDeclarationStatement() { | |
35 let sum = 0; | |
36 testDone = false; | |
37 for | |
38 await(var value of async([100, 200, 300, 400, 500])) sum += value; | |
39 testDone = true; | |
40 return sum; | |
41 } | |
42 | |
43 test = testBindingIdentifierVarDeclarationStatement(); | |
44 assertFalse(testDone); | |
45 assertEquals(1500, await test); | |
46 assertTrue(testDone); | |
47 | |
48 async function testBindingIdentifierVarDeclarationBlockStatement() { | |
49 let sum = 0; | |
50 testDone = false; | |
51 for | |
52 await(var value of async([100, 200, 300, 400, 500])) { | |
53 'use strict'; | |
54 assertDoesNotThrow(() => delete test.nonexistentProperty); | |
55 sum += value; | |
56 } | |
57 testDone = true; | |
58 return sum; | |
59 } | |
60 | |
61 test = testBindingIdentifierVarDeclarationBlockStatement(); | |
62 assertFalse(testDone); | |
63 assertEquals(1500, await test); | |
64 assertTrue(testDone); | |
65 | |
66 async function testObjectBindingPatternVarDeclarationStatement() { | |
67 let sum = 0, keys = []; | |
68 let collection = [ | |
69 {key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30}, | |
70 {key: 'last', value: 40} | |
71 ]; | |
72 testDone = false; | |
73 for | |
74 await(var {key = 'unknown', value} of async(collection)) | |
75 keys.push(key), sum += value; | |
76 testDone = true; | |
77 return {keys, sum}; | |
78 } | |
79 | |
80 test = testObjectBindingPatternVarDeclarationStatement(); | |
81 assertFalse(testDone); | |
82 assertEquals( | |
83 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
84 assertTrue(testDone); | |
85 | |
86 async function testObjectBindingPatternVarDeclarationBlockStatement() { | |
87 let sum = 0, keys = []; | |
88 let collection = [ | |
89 {key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30}, | |
90 {key: 'last', value: 40} | |
91 ]; | |
92 testDone = false; | |
93 for | |
94 await(var {key = 'unknown', value} of async(collection)) { | |
95 'use strict'; | |
96 assertDoesNotThrow(() => delete test.nonexistentProperty); | |
97 keys.push(key); | |
98 sum += value; | |
99 } | |
100 testDone = true; | |
101 return {keys, sum}; | |
102 } | |
103 | |
104 test = testObjectBindingPatternVarDeclarationBlockStatement(); | |
105 assertFalse(testDone); | |
106 assertEquals( | |
107 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
108 assertTrue(testDone); | |
109 | |
110 async function testArrayBindingPatternVarDeclarationStatement() { | |
111 let sum = 0, keys = []; | |
112 let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]]; | |
113 testDone = false; | |
114 for | |
115 await(var [key = 'unknown', value] of async(collection)) | |
116 keys.push(key), sum += value; | |
117 testDone = true; | |
118 return {keys, sum}; | |
119 } | |
120 | |
121 test = testArrayBindingPatternVarDeclarationStatement(); | |
122 assertFalse(testDone); | |
123 assertEquals( | |
124 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
125 assertTrue(testDone); | |
126 | |
127 async function testArrayBindingPatternVarDeclarationBlockStatement() { | |
128 let sum = 0, keys = []; | |
129 let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]]; | |
130 testDone = false; | |
131 for | |
132 await(var [key = 'unknown', value] of async(collection)) { | |
133 'use strict'; | |
134 assertDoesNotThrow(() => delete test.nonexistentProperty); | |
135 keys.push(key); | |
136 sum += value; | |
137 } | |
138 testDone = true; | |
139 return {keys, sum}; | |
140 } | |
141 | |
142 test = testArrayBindingPatternVarDeclarationBlockStatement(); | |
143 assertFalse(testDone); | |
144 assertEquals( | |
145 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
146 assertTrue(testDone); | |
147 | |
148 // -------------------------------------------------------------------------- | |
149 | |
150 async function testBindingIdentifierLetDeclarationStatement() { | |
151 let sum = 0; | |
152 testDone = false; | |
153 for | |
154 await(let value of async([100, 200, 300, 400, 500])) sum += value; | |
155 testDone = true; | |
156 return sum; | |
157 } | |
158 | |
159 test = testBindingIdentifierLetDeclarationStatement(); | |
160 assertFalse(testDone); | |
161 assertEquals(1500, await test); | |
162 assertTrue(testDone); | |
163 | |
164 async function testBindingIdentifierLetDeclarationBlockStatement() { | |
165 let sum = 0; | |
166 testDone = false; | |
167 for | |
168 await(let value of async([100, 200, 300, 400, 500])) { | |
169 'use strict'; | |
170 // Ensure strict mode applies to block with use-strict-directive | |
neis
2017/01/20 14:38:16
Do you mean "does not apply"?
Maybe replace the c
caitp
2017/01/20 20:17:19
sgtm, done
| |
171 assertDoesNotThrow(() => delete test.nonexistentProperty); | |
172 sum += value; | |
173 } | |
174 testDone = true; | |
175 return sum; | |
176 } | |
177 | |
178 test = testBindingIdentifierLetDeclarationBlockStatement(); | |
179 assertFalse(testDone); | |
180 assertEquals(1500, await test); | |
181 assertTrue(testDone); | |
182 | |
183 async function testObjectBindingPatternLetDeclarationStatement() { | |
184 let sum = 0, keys = []; | |
185 let collection = [ | |
186 {key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30}, | |
187 {key: 'last', value: 40} | |
188 ]; | |
189 testDone = false; | |
190 for | |
191 await(let {key = 'unknown', value} of async(collection)) | |
192 keys.push(key), sum += value; | |
193 testDone = true; | |
194 return {keys, sum}; | |
195 } | |
196 | |
197 test = testObjectBindingPatternLetDeclarationStatement(); | |
198 assertFalse(testDone); | |
199 assertEquals( | |
200 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
201 assertTrue(testDone); | |
202 | |
203 async function testObjectBindingPatternLetDeclarationBlockStatement() { | |
204 let sum = 0, keys = []; | |
205 let collection = [ | |
206 {key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30}, | |
207 {key: 'last', value: 40} | |
208 ]; | |
209 testDone = false; | |
210 for | |
211 await(let {key = 'unknown', value} of async(collection)) { | |
212 'use strict'; | |
213 assertDoesNotThrow(() => delete test.nonexistentProperty); | |
214 keys.push(key); | |
215 sum += value; | |
216 } | |
217 testDone = true; | |
218 return {keys, sum}; | |
219 } | |
220 | |
221 test = testObjectBindingPatternLetDeclarationBlockStatement(); | |
222 assertFalse(testDone); | |
223 assertEquals( | |
224 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
225 assertTrue(testDone); | |
226 | |
227 async function testArrayBindingPatternLetDeclarationStatement() { | |
228 let sum = 0, keys = []; | |
229 let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]]; | |
230 testDone = false; | |
231 for | |
232 await(let [key = 'unknown', value] of async(collection)) | |
233 keys.push(key), sum += value; | |
234 testDone = true; | |
235 return {keys, sum}; | |
236 } | |
237 | |
238 test = testArrayBindingPatternLetDeclarationStatement(); | |
239 assertFalse(testDone); | |
240 assertEquals( | |
241 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
242 assertTrue(testDone); | |
243 | |
244 async function testArrayBindingPatternLetDeclarationBlockStatement() { | |
245 let sum = 0, keys = []; | |
246 let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]]; | |
247 testDone = false; | |
248 for | |
249 await(let [key = 'unknown', value] of async(collection)) { | |
250 'use strict'; | |
251 assertDoesNotThrow(() => delete test.nonexistentProperty); | |
252 keys.push(key); | |
253 sum += value; | |
254 } | |
255 testDone = true; | |
256 return {keys, sum}; | |
257 } | |
258 | |
259 test = testArrayBindingPatternLetDeclarationBlockStatement(); | |
260 assertFalse(testDone); | |
261 assertEquals( | |
262 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
263 assertTrue(testDone); | |
264 | |
265 // -------------------------------------------------------------------------- | |
266 | |
267 async function testBindingIdentifierConstDeclarationStatement() { | |
268 let sum = 0; | |
269 testDone = false; | |
270 for | |
271 await(let value of async([100, 200, 300, 400, 500])) sum += value; | |
272 testDone = true; | |
273 return sum; | |
274 } | |
275 | |
276 test = testBindingIdentifierConstDeclarationStatement(); | |
277 assertFalse(testDone); | |
278 assertEquals(1500, await test); | |
279 assertTrue(testDone); | |
280 | |
281 async function testBindingIdentifierConstDeclarationBlockStatement() { | |
282 let sum = 0; | |
283 testDone = false; | |
284 for | |
285 await(const value of async([100, 200, 300, 400, 500])) { | |
286 'use strict'; | |
287 // Ensure strict mode applies to block with use-strict-directive | |
288 assertDoesNotThrow(() => delete test.nonexistentProperty); | |
289 sum += value; | |
290 } | |
291 testDone = true; | |
292 return sum; | |
293 } | |
294 | |
295 test = testBindingIdentifierConstDeclarationBlockStatement(); | |
296 assertFalse(testDone); | |
297 assertEquals(1500, await test); | |
298 assertTrue(testDone); | |
299 | |
300 async function testObjectBindingPatternConstDeclarationStatement() { | |
301 let sum = 0, keys = []; | |
302 let collection = [ | |
303 {key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30}, | |
304 {key: 'last', value: 40} | |
305 ]; | |
306 testDone = false; | |
307 for | |
308 await(const {key = 'unknown', value} of async(collection)) | |
309 keys.push(key), sum += value; | |
310 testDone = true; | |
311 return {keys, sum}; | |
312 } | |
313 | |
314 test = testObjectBindingPatternConstDeclarationStatement(); | |
315 assertFalse(testDone); | |
316 assertEquals( | |
317 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
318 assertTrue(testDone); | |
319 | |
320 async function testObjectBindingPatternConstDeclarationBlockStatement() { | |
321 let sum = 0, keys = []; | |
322 let collection = [ | |
323 {key: 'first', value: 10}, {key: undefined, value: 20}, {value: 30}, | |
324 {key: 'last', value: 40} | |
325 ]; | |
326 testDone = false; | |
327 for | |
328 await(const {key = 'unknown', value} of async(collection)) { | |
329 'use strict'; | |
330 assertDoesNotThrow(() => delete test.nonexistentProperty); | |
331 keys.push(key); | |
332 sum += value; | |
333 } | |
334 testDone = true; | |
335 return {keys, sum}; | |
336 } | |
337 | |
338 test = testObjectBindingPatternConstDeclarationBlockStatement(); | |
339 assertFalse(testDone); | |
340 assertEquals( | |
341 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
342 assertTrue(testDone); | |
343 | |
344 async function testArrayBindingPatternConstDeclarationStatement() { | |
345 let sum = 0, keys = []; | |
346 let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]]; | |
347 testDone = false; | |
348 for | |
349 await(const [key = 'unknown', value] of async(collection)) | |
350 keys.push(key), sum += value; | |
351 testDone = true; | |
352 return {keys, sum}; | |
353 } | |
354 | |
355 test = testArrayBindingPatternConstDeclarationStatement(); | |
356 assertFalse(testDone); | |
357 assertEquals( | |
358 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
359 assertTrue(testDone); | |
360 | |
361 async function testArrayBindingPatternConstDeclarationBlockStatement() { | |
362 let sum = 0, keys = []; | |
363 let collection = [['first', 10], [undefined, 20], [, 30], ['last', 40]]; | |
364 testDone = false; | |
365 for | |
366 await(const [key = 'unknown', value] of async(collection)) { | |
367 'use strict'; | |
368 assertDoesNotThrow(() => delete test.nonexistentProperty); | |
369 keys.push(key); | |
370 sum += value; | |
371 } | |
372 testDone = true; | |
373 return {keys, sum}; | |
374 } | |
375 | |
376 test = testArrayBindingPatternLetDeclarationBlockStatement(); | |
377 assertFalse(testDone); | |
378 assertEquals( | |
379 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 100}, await test); | |
380 assertTrue(testDone); | |
381 | |
382 // -------------------------------------------------------------------------- | |
383 | |
384 async function testBindingIdentifierLHSStatement() { | |
385 let sum = 0; | |
386 let value; | |
387 testDone = false; | |
388 for | |
389 await(value of async([100, 200, 300, 400, 500])) sum += value; | |
390 testDone = true; | |
391 return sum; | |
392 } | |
393 | |
394 test = testBindingIdentifierLHSStatement(); | |
395 assertFalse(testDone); | |
396 assertEquals(1500, await test); | |
397 assertTrue(testDone); | |
398 | |
399 async function testBindingIdentifierLHSBlockStatement() { | |
400 let sum = 0; | |
401 let value; | |
402 testDone = false; | |
403 for | |
404 await(value of async([100, 200, 300, 400, 500])) { | |
405 'use strict'; | |
406 assertDoesNotThrow(() => delete test.nonexistentProperty); | |
407 sum += value; | |
408 } | |
409 testDone = true; | |
410 return sum; | |
411 } | |
412 | |
413 test = testBindingIdentifierLHSStatement(); | |
414 assertFalse(testDone); | |
415 assertEquals(1500, await test); | |
416 assertTrue(testDone); | |
417 | |
418 async function testObjectBindingPatternLHSStatement() { | |
419 let sum = 0; | |
420 let keys = []; | |
421 let value; | |
422 let key; | |
423 let collection = [ | |
424 {key: 'first', value: 1}, {key: undefined, value: 2}, {value: 3}, | |
425 {key: 'last', value: 4} | |
426 ]; | |
427 testDone = false; | |
428 for | |
429 await({key = 'unknown', value} of async(collection)) | |
430 keys.push(key), sum += value; | |
431 testDone = true; | |
432 return {keys, sum}; | |
433 } | |
434 | |
435 test = testObjectBindingPatternLHSStatement(); | |
436 assertFalse(testDone); | |
437 assertEquals( | |
438 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 10}, await test); | |
439 assertTrue(testDone); | |
440 | |
441 async function testObjectBindingPatternLHSBlockStatement() { | |
442 let sum = 0; | |
443 let keys = []; | |
444 let value; | |
445 let key; | |
446 let collection = [ | |
447 {key: 'first', value: 1}, {key: undefined, value: 2}, {value: 3}, | |
448 {key: 'last', value: 4} | |
449 ]; | |
450 testDone = false; | |
451 for | |
452 await({key = 'unknown', value} of async(collection)) { | |
453 'use strict'; | |
454 assertDoesNotThrow(() => delete test.nonexistentProperty); | |
455 keys.push(key); | |
456 sum += value; | |
457 } | |
458 testDone = true; | |
459 return {keys, sum}; | |
460 } | |
461 | |
462 test = testObjectBindingPatternLHSBlockStatement(); | |
463 assertFalse(testDone); | |
464 assertEquals( | |
465 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 10}, await test); | |
466 assertTrue(testDone); | |
467 | |
468 async function testArrayBindingPatternLHSStatement() { | |
469 let sum = 0; | |
470 let keys = []; | |
471 let value; | |
472 let key; | |
473 let collection = [['first', 1], [undefined, 2], [, 3], ['last', 4]]; | |
474 testDone = false; | |
475 for | |
476 await([key = 'unknown', value] of async(collection)) { | |
477 'use strict'; | |
478 assertDoesNotThrow(() => delete test.nonexistentProperty); | |
479 keys.push(key); | |
480 sum += value; | |
481 } | |
482 testDone = true; | |
483 return {keys, sum}; | |
484 } | |
485 | |
486 test = testArrayBindingPatternLHSStatement(); | |
487 assertFalse(testDone); | |
488 assertEquals( | |
489 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 10}, await test); | |
490 assertTrue(testDone); | |
491 | |
492 async function testArrayBindingPatternLHSBlockStatement() { | |
493 let sum = 0; | |
494 let keys = []; | |
495 let value; | |
496 let key; | |
497 let collection = [ | |
498 {key: 'first', value: 1}, {key: undefined, value: 2}, {value: 3}, | |
499 {key: 'last', value: 4} | |
500 ]; | |
501 testDone = false; | |
502 for | |
503 await({key = 'unknown', value} of async(collection)) { | |
504 'use strict'; | |
505 assertDoesNotThrow(() => delete test.nonexistentProperty); | |
506 keys.push(key); | |
507 sum += value; | |
508 } | |
509 testDone = true; | |
510 return {keys, sum}; | |
511 } | |
512 | |
513 test = testArrayBindingPatternLHSBlockStatement(); | |
514 assertFalse(testDone); | |
515 assertEquals( | |
516 {keys: ['first', 'unknown', 'unknown', 'last'], sum: 10}, await test); | |
517 assertTrue(testDone); | |
518 })().then(undefined, function(error) { | |
519 testFailed = true; | |
520 testFailure = error; | |
521 }); | |
522 | |
523 % RunMicrotasks(); | |
524 | |
525 if (testFailed) { | |
526 print(testFailure.stack); | |
527 throw testFailure; | |
528 } | |
neis
2017/01/20 14:38:16
Great tests!
Please add some that exercise the it
caitp
2017/01/20 20:17:19
I think the tests where "Symbol.asyncIterator" isn
| |
OLD | NEW |