OLD | NEW |
| (Empty) |
1 // Copyright 2013 the V8 project authors. All rights reserved. | |
2 // Redistribution and use in source and binary forms, with or without | |
3 // modification, are permitted provided that the following conditions are | |
4 // met: | |
5 // | |
6 // * Redistributions of source code must retain the above copyright | |
7 // notice, this list of conditions and the following disclaimer. | |
8 // * Redistributions in binary form must reproduce the above | |
9 // copyright notice, this list of conditions and the following | |
10 // disclaimer in the documentation and/or other materials provided | |
11 // with the distribution. | |
12 // * Neither the name of Google Inc. nor the names of its | |
13 // contributors may be used to endorse or promote products derived | |
14 // from this software without specific prior written permission. | |
15 // | |
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | |
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | |
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | |
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT | |
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, | |
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT | |
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, | |
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY | |
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE | |
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
27 | |
28 // Flags: --harmony-promises --harmony-observation --allow-natives-syntax | |
29 | |
30 var asyncAssertsExpected = 0; | |
31 | |
32 function assertAsyncRan() { ++asyncAssertsExpected } | |
33 | |
34 function assertAsync(b, s) { | |
35 if (b) { | |
36 print(s, "succeeded") | |
37 } else { | |
38 %AbortJS(s + " FAILED!") // Simply throwing here will have no effect. | |
39 } | |
40 --asyncAssertsExpected | |
41 } | |
42 | |
43 function assertAsyncDone(iteration) { | |
44 var iteration = iteration || 0 | |
45 var dummy = {} | |
46 Object.observe(dummy, | |
47 function() { | |
48 if (asyncAssertsExpected === 0) | |
49 assertAsync(true, "all") | |
50 else if (iteration > 10) // Shouldn't take more. | |
51 assertAsync(false, "all") | |
52 else | |
53 assertAsyncDone(iteration + 1) | |
54 } | |
55 ) | |
56 dummy.dummy = dummy | |
57 } | |
58 | |
59 | |
60 (function() { | |
61 assertThrows(function() { Promise(function() {}) }, TypeError) | |
62 })(); | |
63 | |
64 (function() { | |
65 assertTrue(new Promise(function() {}) instanceof Promise) | |
66 })(); | |
67 | |
68 (function() { | |
69 assertThrows(function() { new Promise(5) }, TypeError) | |
70 })(); | |
71 | |
72 (function() { | |
73 assertDoesNotThrow(function() { new Promise(function() { throw 5 }) }) | |
74 })(); | |
75 | |
76 (function() { | |
77 (new Promise(function() { throw 5 })).chain( | |
78 assertUnreachable, | |
79 function(r) { assertAsync(r === 5, "new-throw") } | |
80 ) | |
81 assertAsyncRan() | |
82 })(); | |
83 | |
84 (function() { | |
85 Promise.resolve(5); | |
86 Promise.resolve(5).chain(undefined, assertUnreachable).chain( | |
87 function(x) { assertAsync(x === 5, "resolved/chain-nohandler") }, | |
88 assertUnreachable | |
89 ) | |
90 assertAsyncRan() | |
91 })(); | |
92 | |
93 (function() { | |
94 Promise.reject(5).chain(assertUnreachable, undefined).chain( | |
95 assertUnreachable, | |
96 function(r) { assertAsync(r === 5, "rejected/chain-nohandler") } | |
97 ) | |
98 assertAsyncRan() | |
99 })(); | |
100 | |
101 (function() { | |
102 Promise.resolve(5).then(undefined, assertUnreachable).chain( | |
103 function(x) { assertAsync(x === 5, "resolved/then-nohandler") }, | |
104 assertUnreachable | |
105 ) | |
106 assertAsyncRan() | |
107 })(); | |
108 | |
109 (function() { | |
110 Promise.reject(5).then(assertUnreachable, undefined).chain( | |
111 assertUnreachable, | |
112 function(r) { assertAsync(r === 5, "rejected/then-nohandler") } | |
113 ) | |
114 assertAsyncRan() | |
115 })(); | |
116 | |
117 (function() { | |
118 var p1 = Promise.resolve(5) | |
119 var p2 = Promise.resolve(p1) | |
120 var p3 = Promise.resolve(p2) | |
121 p3.chain( | |
122 function(x) { assertAsync(x === p2, "resolved/chain") }, | |
123 assertUnreachable | |
124 ) | |
125 assertAsyncRan() | |
126 })(); | |
127 | |
128 (function() { | |
129 var p1 = Promise.resolve(5) | |
130 var p2 = Promise.resolve(p1) | |
131 var p3 = Promise.resolve(p2) | |
132 p3.then( | |
133 function(x) { assertAsync(x === 5, "resolved/then") }, | |
134 assertUnreachable | |
135 ) | |
136 assertAsyncRan() | |
137 })(); | |
138 | |
139 (function() { | |
140 var p1 = Promise.reject(5) | |
141 var p2 = Promise.resolve(p1) | |
142 var p3 = Promise.resolve(p2) | |
143 p3.chain( | |
144 function(x) { assertAsync(x === p2, "rejected/chain") }, | |
145 assertUnreachable | |
146 ) | |
147 assertAsyncRan() | |
148 })(); | |
149 | |
150 (function() { | |
151 var p1 = Promise.reject(5) | |
152 var p2 = Promise.resolve(p1) | |
153 var p3 = Promise.resolve(p2) | |
154 p3.then( | |
155 assertUnreachable, | |
156 function(x) { assertAsync(x === 5, "rejected/then") } | |
157 ) | |
158 assertAsyncRan() | |
159 })(); | |
160 | |
161 (function() { | |
162 var p1 = Promise.resolve(5) | |
163 var p2 = Promise.resolve(p1) | |
164 var p3 = Promise.resolve(p2) | |
165 p3.chain(function(x) { return x }, assertUnreachable).chain( | |
166 function(x) { assertAsync(x === p1, "resolved/chain/chain") }, | |
167 assertUnreachable | |
168 ) | |
169 assertAsyncRan() | |
170 })(); | |
171 | |
172 (function() { | |
173 var p1 = Promise.resolve(5) | |
174 var p2 = Promise.resolve(p1) | |
175 var p3 = Promise.resolve(p2) | |
176 p3.chain(function(x) { return x }, assertUnreachable).then( | |
177 function(x) { assertAsync(x === 5, "resolved/chain/then") }, | |
178 assertUnreachable | |
179 ) | |
180 assertAsyncRan() | |
181 })(); | |
182 | |
183 (function() { | |
184 var p1 = Promise.resolve(5) | |
185 var p2 = Promise.resolve(p1) | |
186 var p3 = Promise.resolve(p2) | |
187 p3.chain(function(x) { return 6 }, assertUnreachable).chain( | |
188 function(x) { assertAsync(x === 6, "resolved/chain/chain2") }, | |
189 assertUnreachable | |
190 ) | |
191 assertAsyncRan() | |
192 })(); | |
193 | |
194 (function() { | |
195 var p1 = Promise.resolve(5) | |
196 var p2 = Promise.resolve(p1) | |
197 var p3 = Promise.resolve(p2) | |
198 p3.chain(function(x) { return 6 }, assertUnreachable).then( | |
199 function(x) { assertAsync(x === 6, "resolved/chain/then2") }, | |
200 assertUnreachable | |
201 ) | |
202 assertAsyncRan() | |
203 })(); | |
204 | |
205 (function() { | |
206 var p1 = Promise.resolve(5) | |
207 var p2 = Promise.resolve(p1) | |
208 var p3 = Promise.resolve(p2) | |
209 p3.then(function(x) { return x + 1 }, assertUnreachable).chain( | |
210 function(x) { assertAsync(x === 6, "resolved/then/chain") }, | |
211 assertUnreachable | |
212 ) | |
213 assertAsyncRan() | |
214 })(); | |
215 | |
216 (function() { | |
217 var p1 = Promise.resolve(5) | |
218 var p2 = Promise.resolve(p1) | |
219 var p3 = Promise.resolve(p2) | |
220 p3.then(function(x) { return x + 1 }, assertUnreachable).then( | |
221 function(x) { assertAsync(x === 6, "resolved/then/then") }, | |
222 assertUnreachable | |
223 ) | |
224 assertAsyncRan() | |
225 })(); | |
226 | |
227 (function() { | |
228 var p1 = Promise.resolve(5) | |
229 var p2 = Promise.resolve(p1) | |
230 var p3 = Promise.resolve(p2) | |
231 p3.then(function(x){ return Promise.resolve(x+1) }, assertUnreachable).chain( | |
232 function(x) { assertAsync(x === 6, "resolved/then/chain2") }, | |
233 assertUnreachable | |
234 ) | |
235 assertAsyncRan() | |
236 })(); | |
237 | |
238 (function() { | |
239 var p1 = Promise.resolve(5) | |
240 var p2 = Promise.resolve(p1) | |
241 var p3 = Promise.resolve(p2) | |
242 p3.then(function(x) { return Promise.resolve(x+1) }, assertUnreachable).then( | |
243 function(x) { assertAsync(x === 6, "resolved/then/then2") }, | |
244 assertUnreachable | |
245 ) | |
246 assertAsyncRan() | |
247 })(); | |
248 | |
249 (function() { | |
250 var p1 = Promise.resolve(5) | |
251 var p2 = Promise.resolve(p1) | |
252 var p3 = Promise.resolve(p2) | |
253 p3.chain(function(x) { throw 6 }, assertUnreachable).chain( | |
254 assertUnreachable, | |
255 function(x) { assertAsync(x === 6, "resolved/chain-throw/chain") } | |
256 ) | |
257 assertAsyncRan() | |
258 })(); | |
259 | |
260 (function() { | |
261 var p1 = Promise.resolve(5) | |
262 var p2 = Promise.resolve(p1) | |
263 var p3 = Promise.resolve(p2) | |
264 p3.chain(function(x) { throw 6 }, assertUnreachable).then( | |
265 assertUnreachable, | |
266 function(x) { assertAsync(x === 6, "resolved/chain-throw/then") } | |
267 ) | |
268 assertAsyncRan() | |
269 })(); | |
270 | |
271 (function() { | |
272 var p1 = Promise.resolve(5) | |
273 var p2 = Promise.resolve(p1) | |
274 var p3 = Promise.resolve(p2) | |
275 p3.then(function(x) { throw 6 }, assertUnreachable).chain( | |
276 assertUnreachable, | |
277 function(x) { assertAsync(x === 6, "resolved/then-throw/chain") } | |
278 ) | |
279 assertAsyncRan() | |
280 })(); | |
281 | |
282 (function() { | |
283 var p1 = Promise.resolve(5) | |
284 var p2 = Promise.resolve(p1) | |
285 var p3 = Promise.resolve(p2) | |
286 p3.then(function(x) { throw 6 }, assertUnreachable).then( | |
287 assertUnreachable, | |
288 function(x) { assertAsync(x === 6, "resolved/then-throw/then") } | |
289 ) | |
290 assertAsyncRan() | |
291 })(); | |
292 | |
293 (function() { | |
294 var p1 = Promise.resolve(5) | |
295 var p2 = {then: function(onResolve, onReject) { onResolve(p1) }} | |
296 var p3 = Promise.resolve(p2) | |
297 p3.chain( | |
298 function(x) { assertAsync(x === p2, "resolved/thenable/chain") }, | |
299 assertUnreachable | |
300 ) | |
301 assertAsyncRan() | |
302 })(); | |
303 | |
304 (function() { | |
305 var p1 = Promise.resolve(5) | |
306 var p2 = {then: function(onResolve, onReject) { onResolve(p1) }} | |
307 var p3 = Promise.resolve(p2) | |
308 p3.then( | |
309 function(x) { assertAsync(x === 5, "resolved/thenable/then") }, | |
310 assertUnreachable | |
311 ) | |
312 assertAsyncRan() | |
313 })(); | |
314 | |
315 (function() { | |
316 var p1 = Promise.reject(5) | |
317 var p2 = {then: function(onResolve, onReject) { onResolve(p1) }} | |
318 var p3 = Promise.resolve(p2) | |
319 p3.chain( | |
320 function(x) { assertAsync(x === p2, "rejected/thenable/chain") }, | |
321 assertUnreachable | |
322 ) | |
323 assertAsyncRan() | |
324 })(); | |
325 | |
326 (function() { | |
327 var p1 = Promise.reject(5) | |
328 var p2 = {then: function(onResolve, onReject) { onResolve(p1) }} | |
329 var p3 = Promise.resolve(p2) | |
330 p3.then( | |
331 assertUnreachable, | |
332 function(x) { assertAsync(x === 5, "rejected/thenable/then") } | |
333 ) | |
334 assertAsyncRan() | |
335 })(); | |
336 | |
337 (function() { | |
338 var deferred = Promise.defer() | |
339 var p1 = deferred.promise | |
340 var p2 = Promise.resolve(p1) | |
341 var p3 = Promise.resolve(p2) | |
342 p3.chain( | |
343 function(x) { assertAsync(x === p2, "chain/resolve") }, | |
344 assertUnreachable | |
345 ) | |
346 deferred.resolve(5) | |
347 assertAsyncRan() | |
348 })(); | |
349 | |
350 (function() { | |
351 var deferred = Promise.defer() | |
352 var p1 = deferred.promise | |
353 var p2 = Promise.resolve(p1) | |
354 var p3 = Promise.resolve(p2) | |
355 p3.then( | |
356 function(x) { assertAsync(x === 5, "then/resolve") }, | |
357 assertUnreachable | |
358 ) | |
359 deferred.resolve(5) | |
360 assertAsyncRan() | |
361 })(); | |
362 | |
363 (function() { | |
364 var deferred = Promise.defer() | |
365 var p1 = deferred.promise | |
366 var p2 = Promise.resolve(p1) | |
367 var p3 = Promise.resolve(p2) | |
368 p3.chain( | |
369 function(x) { assertAsync(x === p2, "chain/reject") }, | |
370 assertUnreachable | |
371 ) | |
372 deferred.reject(5) | |
373 assertAsyncRan() | |
374 })(); | |
375 | |
376 (function() { | |
377 var deferred = Promise.defer() | |
378 var p1 = deferred.promise | |
379 var p2 = Promise.resolve(p1) | |
380 var p3 = Promise.resolve(p2) | |
381 p3.then( | |
382 assertUnreachable, | |
383 function(x) { assertAsync(x === 5, "then/reject") } | |
384 ) | |
385 deferred.reject(5) | |
386 assertAsyncRan() | |
387 })(); | |
388 | |
389 (function() { | |
390 var deferred = Promise.defer() | |
391 var p1 = deferred.promise | |
392 var p2 = {then: function(onResolve, onReject) { onResolve(p1) }} | |
393 var p3 = Promise.resolve(p2) | |
394 p3.chain( | |
395 function(x) { assertAsync(x === p2, "chain/resolve/thenable") }, | |
396 assertUnreachable | |
397 ) | |
398 deferred.resolve(5) | |
399 assertAsyncRan() | |
400 })(); | |
401 | |
402 (function() { | |
403 var deferred = Promise.defer() | |
404 var p1 = deferred.promise | |
405 var p2 = {then: function(onResolve, onReject) { onResolve(p1) }} | |
406 var p3 = Promise.resolve(p2) | |
407 p3.then( | |
408 function(x) { assertAsync(x === 5, "then/resolve/thenable") }, | |
409 assertUnreachable | |
410 ) | |
411 deferred.resolve(5) | |
412 assertAsyncRan() | |
413 })(); | |
414 | |
415 (function() { | |
416 var deferred = Promise.defer() | |
417 var p1 = deferred.promise | |
418 var p2 = {then: function(onResolve, onReject) { onResolve(p1) }} | |
419 var p3 = Promise.resolve(p2) | |
420 p3.chain( | |
421 function(x) { assertAsync(x === p2, "chain/reject/thenable") }, | |
422 assertUnreachable | |
423 ) | |
424 deferred.reject(5) | |
425 assertAsyncRan() | |
426 })(); | |
427 | |
428 (function() { | |
429 var deferred = Promise.defer() | |
430 var p1 = deferred.promise | |
431 var p2 = {then: function(onResolve, onReject) { onResolve(p1) }} | |
432 var p3 = Promise.resolve(p2) | |
433 p3.then( | |
434 assertUnreachable, | |
435 function(x) { assertAsync(x === 5, "then/reject/thenable") } | |
436 ) | |
437 deferred.reject(5) | |
438 assertAsyncRan() | |
439 })(); | |
440 | |
441 (function() { | |
442 var p1 = Promise.resolve(5) | |
443 var p2 = Promise.resolve(p1) | |
444 var deferred = Promise.defer() | |
445 var p3 = deferred.promise | |
446 p3.chain( | |
447 function(x) { assertAsync(x === p2, "chain/resolve2") }, | |
448 assertUnreachable | |
449 ) | |
450 deferred.resolve(p2) | |
451 assertAsyncRan() | |
452 })(); | |
453 | |
454 (function() { | |
455 var p1 = Promise.resolve(5) | |
456 var p2 = Promise.resolve(p1) | |
457 var deferred = Promise.defer() | |
458 var p3 = deferred.promise | |
459 p3.then( | |
460 function(x) { assertAsync(x === 5, "then/resolve2") }, | |
461 assertUnreachable | |
462 ) | |
463 deferred.resolve(p2) | |
464 assertAsyncRan() | |
465 })(); | |
466 | |
467 (function() { | |
468 var p1 = Promise.resolve(5) | |
469 var p2 = Promise.resolve(p1) | |
470 var deferred = Promise.defer() | |
471 var p3 = deferred.promise | |
472 p3.chain( | |
473 assertUnreachable, | |
474 function(x) { assertAsync(x === 5, "chain/reject2") } | |
475 ) | |
476 deferred.reject(5) | |
477 assertAsyncRan() | |
478 })(); | |
479 | |
480 (function() { | |
481 var p1 = Promise.resolve(5) | |
482 var p2 = Promise.resolve(p1) | |
483 var deferred = Promise.defer() | |
484 var p3 = deferred.promise | |
485 p3.then( | |
486 assertUnreachable, | |
487 function(x) { assertAsync(x === 5, "then/reject2") } | |
488 ) | |
489 deferred.reject(5) | |
490 assertAsyncRan() | |
491 })(); | |
492 | |
493 (function() { | |
494 var p1 = Promise.resolve(5) | |
495 var p2 = {then: function(onResolve, onReject) { onResolve(p1) }} | |
496 var deferred = Promise.defer() | |
497 var p3 = deferred.promise | |
498 p3.chain( | |
499 function(x) { assertAsync(x === p2, "chain/resolve/thenable2") }, | |
500 assertUnreachable | |
501 ) | |
502 deferred.resolve(p2) | |
503 assertAsyncRan() | |
504 })(); | |
505 | |
506 (function() { | |
507 var p1 = Promise.resolve(5) | |
508 var p2 = {then: function(onResolve, onReject) { onResolve(p1) }} | |
509 var deferred = Promise.defer() | |
510 var p3 = deferred.promise | |
511 p3.then( | |
512 function(x) { assertAsync(x === 5, "then/resolve/thenable2") }, | |
513 assertUnreachable | |
514 ) | |
515 deferred.resolve(p2) | |
516 assertAsyncRan() | |
517 })(); | |
518 | |
519 (function() { | |
520 var p1 = Promise.resolve(0) | |
521 var p2 = p1.chain(function(x) { return p2 }, assertUnreachable) | |
522 p2.chain( | |
523 assertUnreachable, | |
524 function(r) { assertAsync(r instanceof TypeError, "cyclic/chain") } | |
525 ) | |
526 assertAsyncRan() | |
527 })(); | |
528 | |
529 (function() { | |
530 var p1 = Promise.resolve(0) | |
531 var p2 = p1.then(function(x) { return p2 }, assertUnreachable) | |
532 p2.chain( | |
533 assertUnreachable, | |
534 function(r) { assertAsync(r instanceof TypeError, "cyclic/then") } | |
535 ) | |
536 assertAsyncRan() | |
537 })(); | |
538 | |
539 (function() { | |
540 var deferred = Promise.defer() | |
541 var p = deferred.promise | |
542 deferred.resolve(p) | |
543 p.chain( | |
544 function(x) { assertAsync(x === p, "cyclic/deferred/chain") }, | |
545 assertUnreachable | |
546 ) | |
547 assertAsyncRan() | |
548 })(); | |
549 | |
550 (function() { | |
551 var deferred = Promise.defer() | |
552 var p = deferred.promise | |
553 deferred.resolve(p) | |
554 p.then( | |
555 assertUnreachable, | |
556 function(r) { assertAsync(r instanceof TypeError, "cyclic/deferred/then") } | |
557 ) | |
558 assertAsyncRan() | |
559 })(); | |
560 | |
561 (function() { | |
562 Promise.all({}).chain( | |
563 assertUnreachable, | |
564 function(r) { assertAsync(r instanceof TypeError, "all/no-array") } | |
565 ) | |
566 assertAsyncRan() | |
567 })(); | |
568 | |
569 (function() { | |
570 Promise.all([]).chain( | |
571 function(x) { assertAsync(x.length === 0, "all/resolve/empty") }, | |
572 assertUnreachable | |
573 ) | |
574 assertAsyncRan() | |
575 })(); | |
576 | |
577 (function() { | |
578 var deferred1 = Promise.defer() | |
579 var p1 = deferred1.promise | |
580 var deferred2 = Promise.defer() | |
581 var p2 = deferred2.promise | |
582 var deferred3 = Promise.defer() | |
583 var p3 = deferred3.promise | |
584 Promise.all([p1, p2, p3]).chain( | |
585 function(x) { | |
586 assertAsync(x.length === 3, "all/resolve") | |
587 assertAsync(x[0] === 1, "all/resolve/0") | |
588 assertAsync(x[1] === 2, "all/resolve/1") | |
589 assertAsync(x[2] === 3, "all/resolve/2") | |
590 }, | |
591 assertUnreachable | |
592 ) | |
593 deferred1.resolve(1) | |
594 deferred3.resolve(3) | |
595 deferred2.resolve(2) | |
596 assertAsyncRan() | |
597 assertAsyncRan() | |
598 assertAsyncRan() | |
599 assertAsyncRan() | |
600 })(); | |
601 | |
602 (function() { | |
603 var deferred = Promise.defer() | |
604 var p1 = deferred.promise | |
605 var p2 = Promise.resolve(2) | |
606 var p3 = Promise.defer().promise | |
607 Promise.all([p1, p2, p3]).chain( | |
608 assertUnreachable, | |
609 assertUnreachable | |
610 ) | |
611 deferred.resolve(1) | |
612 })(); | |
613 | |
614 (function() { | |
615 var deferred1 = Promise.defer() | |
616 var p1 = deferred1.promise | |
617 var deferred2 = Promise.defer() | |
618 var p2 = deferred2.promise | |
619 var deferred3 = Promise.defer() | |
620 var p3 = deferred3.promise | |
621 Promise.all([p1, p2, p3]).chain( | |
622 assertUnreachable, | |
623 function(x) { assertAsync(x === 2, "all/reject") } | |
624 ) | |
625 deferred1.resolve(1) | |
626 deferred3.resolve(3) | |
627 deferred2.reject(2) | |
628 assertAsyncRan() | |
629 })(); | |
630 | |
631 (function() { | |
632 Promise.race([]).chain( | |
633 assertUnreachable, | |
634 assertUnreachable | |
635 ) | |
636 })(); | |
637 | |
638 (function() { | |
639 var p1 = Promise.resolve(1) | |
640 var p2 = Promise.resolve(2) | |
641 var p3 = Promise.resolve(3) | |
642 Promise.race([p1, p2, p3]).chain( | |
643 function(x) { assertAsync(x === 1, "resolved/one") }, | |
644 assertUnreachable | |
645 ) | |
646 assertAsyncRan() | |
647 })(); | |
648 | |
649 (function() { | |
650 var p1 = Promise.resolve(1) | |
651 var p2 = Promise.resolve(2) | |
652 var p3 = Promise.resolve(3) | |
653 Promise.race([0, p1, p2, p3]).chain( | |
654 function(x) { assertAsync(x === 0, "resolved-const/one") }, | |
655 assertUnreachable | |
656 ) | |
657 assertAsyncRan() | |
658 })(); | |
659 | |
660 (function() { | |
661 Promise.race({}).chain( | |
662 assertUnreachable, | |
663 function(r) { assertAsync(r instanceof TypeError, "one/no-array") } | |
664 ) | |
665 assertAsyncRan() | |
666 })(); | |
667 | |
668 (function() { | |
669 var deferred1 = Promise.defer() | |
670 var p1 = deferred1.promise | |
671 var deferred2 = Promise.defer() | |
672 var p2 = deferred2.promise | |
673 var deferred3 = Promise.defer() | |
674 var p3 = deferred3.promise | |
675 Promise.race([p1, p2, p3]).chain( | |
676 function(x) { assertAsync(x === 3, "one/resolve") }, | |
677 assertUnreachable | |
678 ) | |
679 deferred3.resolve(3) | |
680 deferred1.resolve(1) | |
681 assertAsyncRan() | |
682 })(); | |
683 | |
684 (function() { | |
685 var deferred = Promise.defer() | |
686 var p1 = deferred.promise | |
687 var p2 = Promise.resolve(2) | |
688 var p3 = Promise.defer().promise | |
689 Promise.race([p1, p2, p3]).chain( | |
690 function(x) { assertAsync(x === 2, "resolved/one") }, | |
691 assertUnreachable | |
692 ) | |
693 deferred.resolve(1) | |
694 assertAsyncRan() | |
695 })(); | |
696 | |
697 (function() { | |
698 var deferred1 = Promise.defer() | |
699 var p1 = deferred1.promise | |
700 var deferred2 = Promise.defer() | |
701 var p2 = deferred2.promise | |
702 var deferred3 = Promise.defer() | |
703 var p3 = deferred3.promise | |
704 Promise.race([p1, p2, p3]).chain( | |
705 function(x) { assertAsync(x === 3, "one/resolve/reject") }, | |
706 assertUnreachable | |
707 ) | |
708 deferred3.resolve(3) | |
709 deferred1.reject(1) | |
710 assertAsyncRan() | |
711 })(); | |
712 | |
713 (function() { | |
714 var deferred1 = Promise.defer() | |
715 var p1 = deferred1.promise | |
716 var deferred2 = Promise.defer() | |
717 var p2 = deferred2.promise | |
718 var deferred3 = Promise.defer() | |
719 var p3 = deferred3.promise | |
720 Promise.race([p1, p2, p3]).chain( | |
721 assertUnreachable, | |
722 function(x) { assertAsync(x === 3, "one/reject/resolve") } | |
723 ) | |
724 deferred3.reject(3) | |
725 deferred1.resolve(1) | |
726 assertAsyncRan() | |
727 })(); | |
728 | |
729 (function() { | |
730 var log | |
731 function MyPromise(resolver) { | |
732 log += "n" | |
733 var promise = new Promise(function(resolve, reject) { | |
734 resolver( | |
735 function(x) { log += "x" + x; resolve(x) }, | |
736 function(r) { log += "r" + r; reject(r) } | |
737 ) | |
738 }) | |
739 promise.__proto__ = MyPromise.prototype | |
740 return promise | |
741 } | |
742 | |
743 MyPromise.__proto__ = Promise | |
744 MyPromise.defer = function() { | |
745 log += "d" | |
746 return this.__proto__.defer.call(this) | |
747 } | |
748 | |
749 MyPromise.prototype.__proto__ = Promise.prototype | |
750 MyPromise.prototype.chain = function(resolve, reject) { | |
751 log += "c" | |
752 return this.__proto__.__proto__.chain.call(this, resolve, reject) | |
753 } | |
754 | |
755 log = "" | |
756 var p1 = new MyPromise(function(resolve, reject) { resolve(1) }) | |
757 var p2 = new MyPromise(function(resolve, reject) { reject(2) }) | |
758 var d3 = MyPromise.defer() | |
759 assertTrue(d3.promise instanceof Promise, "subclass/instance") | |
760 assertTrue(d3.promise instanceof MyPromise, "subclass/instance-my3") | |
761 assertTrue(log === "nx1nr2dn", "subclass/create") | |
762 | |
763 log = "" | |
764 var p4 = MyPromise.resolve(4) | |
765 var p5 = MyPromise.reject(5) | |
766 assertTrue(p4 instanceof Promise, "subclass/instance4") | |
767 assertTrue(p4 instanceof MyPromise, "subclass/instance-my4") | |
768 assertTrue(p5 instanceof Promise, "subclass/instance5") | |
769 assertTrue(p5 instanceof MyPromise, "subclass/instance-my5") | |
770 d3.resolve(3) | |
771 assertTrue(log === "nx4nr5x3", "subclass/resolve") | |
772 | |
773 log = "" | |
774 var d6 = MyPromise.defer() | |
775 d6.promise.chain(function(x) { | |
776 return new Promise(function(resolve) { resolve(x) }) | |
777 }).chain(function() {}) | |
778 d6.resolve(6) | |
779 assertTrue(log === "dncncnx6", "subclass/chain") | |
780 | |
781 log = "" | |
782 Promise.all([11, Promise.resolve(12), 13, MyPromise.resolve(14), 15, 16]) | |
783 assertTrue(log === "nx14cn", "subclass/all/arg") | |
784 | |
785 log = "" | |
786 MyPromise.all([21, Promise.resolve(22), 23, MyPromise.resolve(24), 25, 26]) | |
787 assertTrue(log === "nx24nnx21cnnx23cncnnx25cnnx26cn", "subclass/all/self") | |
788 })(); | |
789 | |
790 | |
791 assertAsyncDone() | |
OLD | NEW |