src/v8/test/mjsunit/es6/promises.js

   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 --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.accept(5);
  86   Promise.accept(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.accept(5).then(undefined, assertUnreachable).chain(
 103     function(x) { assertAsync(x === 5, "resolved/then-nohandler-undefined") },
 104     assertUnreachable
 105   )
 106   assertAsyncRan()
 107   Promise.accept(6).then(null, assertUnreachable).chain(
 108     function(x) { assertAsync(x === 6, "resolved/then-nohandler-null") },
 109     assertUnreachable
 110   )
 111   assertAsyncRan()
 112 })();
 113
 114 (function() {
 115   Promise.reject(5).then(assertUnreachable, undefined).chain(
 116     assertUnreachable,
 117     function(r) { assertAsync(r === 5, "rejected/then-nohandler-undefined") }
 118   )
 119   assertAsyncRan()
 120   Promise.reject(6).then(assertUnreachable, null).chain(
 121     assertUnreachable,
 122     function(r) { assertAsync(r === 6, "rejected/then-nohandler-null") }
 123   )
 124   assertAsyncRan()
 125 })();
 126
 127 (function() {
 128   var p1 = Promise.accept(5)
 129   var p2 = Promise.accept(p1)
 130   var p3 = Promise.accept(p2)
 131   p3.chain(
 132     function(x) { assertAsync(x === p2, "resolved/chain") },
 133     assertUnreachable
 134   )
 135   assertAsyncRan()
 136 })();
 137
 138 (function() {
 139   var p1 = Promise.accept(5)
 140   var p2 = Promise.accept(p1)
 141   var p3 = Promise.accept(p2)
 142   p3.then(
 143     function(x) { assertAsync(x === 5, "resolved/then") },
 144     assertUnreachable
 145   )
 146   assertAsyncRan()
 147 })();
 148
 149 (function() {
 150   var p1 = Promise.reject(5)
 151   var p2 = Promise.accept(p1)
 152   var p3 = Promise.accept(p2)
 153   p3.chain(
 154     function(x) { assertAsync(x === p2, "rejected/chain") },
 155     assertUnreachable
 156   )
 157   assertAsyncRan()
 158 })();
 159
 160 (function() {
 161   var p1 = Promise.reject(5)
 162   var p2 = Promise.accept(p1)
 163   var p3 = Promise.accept(p2)
 164   p3.then(
 165     assertUnreachable,
 166     function(x) { assertAsync(x === 5, "rejected/then") }
 167   )
 168   assertAsyncRan()
 169 })();
 170
 171 (function() {
 172   var p1 = Promise.accept(5)
 173   var p2 = Promise.accept(p1)
 174   var p3 = Promise.accept(p2)
 175   p3.chain(function(x) { return x }, assertUnreachable).chain(
 176     function(x) { assertAsync(x === p1, "resolved/chain/chain") },
 177     assertUnreachable
 178   )
 179   assertAsyncRan()
 180 })();
 181
 182 (function() {
 183   var p1 = Promise.accept(5)
 184   var p2 = Promise.accept(p1)
 185   var p3 = Promise.accept(p2)
 186   p3.chain(function(x) { return x }, assertUnreachable).then(
 187     function(x) { assertAsync(x === 5, "resolved/chain/then") },
 188     assertUnreachable
 189   )
 190   assertAsyncRan()
 191 })();
 192
 193 (function() {
 194   var p1 = Promise.accept(5)
 195   var p2 = Promise.accept(p1)
 196   var p3 = Promise.accept(p2)
 197   p3.chain(function(x) { return 6 }, assertUnreachable).chain(
 198     function(x) { assertAsync(x === 6, "resolved/chain/chain2") },
 199     assertUnreachable
 200   )
 201   assertAsyncRan()
 202 })();
 203
 204 (function() {
 205   var p1 = Promise.accept(5)
 206   var p2 = Promise.accept(p1)
 207   var p3 = Promise.accept(p2)
 208   p3.chain(function(x) { return 6 }, assertUnreachable).then(
 209     function(x) { assertAsync(x === 6, "resolved/chain/then2") },
 210     assertUnreachable
 211   )
 212   assertAsyncRan()
 213 })();
 214
 215 (function() {
 216   var p1 = Promise.accept(5)
 217   var p2 = Promise.accept(p1)
 218   var p3 = Promise.accept(p2)
 219   p3.then(function(x) { return x + 1 }, assertUnreachable).chain(
 220     function(x) { assertAsync(x === 6, "resolved/then/chain") },
 221     assertUnreachable
 222   )
 223   assertAsyncRan()
 224 })();
 225
 226 (function() {
 227   var p1 = Promise.accept(5)
 228   var p2 = Promise.accept(p1)
 229   var p3 = Promise.accept(p2)
 230   p3.then(function(x) { return x + 1 }, assertUnreachable).then(
 231     function(x) { assertAsync(x === 6, "resolved/then/then") },
 232     assertUnreachable
 233   )
 234   assertAsyncRan()
 235 })();
 236
 237 (function() {
 238   var p1 = Promise.accept(5)
 239   var p2 = Promise.accept(p1)
 240   var p3 = Promise.accept(p2)
 241   p3.then(function(x){ return Promise.accept(x+1) }, assertUnreachable).chain(
 242     function(x) { assertAsync(x === 6, "resolved/then/chain2") },
 243     assertUnreachable
 244   )
 245   assertAsyncRan()
 246 })();
 247
 248 (function() {
 249   var p1 = Promise.accept(5)
 250   var p2 = Promise.accept(p1)
 251   var p3 = Promise.accept(p2)
 252   p3.then(function(x) { return Promise.accept(x+1) }, assertUnreachable).then(
 253     function(x) { assertAsync(x === 6, "resolved/then/then2") },
 254     assertUnreachable
 255   )
 256   assertAsyncRan()
 257 })();
 258
 259 (function() {
 260   var p1 = Promise.accept(5)
 261   var p2 = Promise.accept(p1)
 262   var p3 = Promise.accept(p2)
 263   p3.chain(function(x) { throw 6 }, assertUnreachable).chain(
 264     assertUnreachable,
 265     function(x) { assertAsync(x === 6, "resolved/chain-throw/chain") }
 266   )
 267   assertAsyncRan()
 268 })();
 269
 270 (function() {
 271   var p1 = Promise.accept(5)
 272   var p2 = Promise.accept(p1)
 273   var p3 = Promise.accept(p2)
 274   p3.chain(function(x) { throw 6 }, assertUnreachable).then(
 275     assertUnreachable,
 276     function(x) { assertAsync(x === 6, "resolved/chain-throw/then") }
 277   )
 278   assertAsyncRan()
 279 })();
 280
 281 (function() {
 282   var p1 = Promise.accept(5)
 283   var p2 = Promise.accept(p1)
 284   var p3 = Promise.accept(p2)
 285   p3.then(function(x) { throw 6 }, assertUnreachable).chain(
 286     assertUnreachable,
 287     function(x) { assertAsync(x === 6, "resolved/then-throw/chain") }
 288   )
 289   assertAsyncRan()
 290 })();
 291
 292 (function() {
 293   var p1 = Promise.accept(5)
 294   var p2 = Promise.accept(p1)
 295   var p3 = Promise.accept(p2)
 296   p3.then(function(x) { throw 6 }, assertUnreachable).then(
 297     assertUnreachable,
 298     function(x) { assertAsync(x === 6, "resolved/then-throw/then") }
 299   )
 300   assertAsyncRan()
 301 })();
 302
 303 (function() {
 304   var p1 = Promise.accept(5)
 305   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
 306   var p3 = Promise.accept(p2)
 307   p3.chain(
 308     function(x) { assertAsync(x === p2, "resolved/thenable/chain") },
 309     assertUnreachable
 310   )
 311   assertAsyncRan()
 312 })();
 313
 314 (function() {
 315   var p1 = Promise.accept(5)
 316   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
 317   var p3 = Promise.accept(p2)
 318   p3.then(
 319     function(x) { assertAsync(x === 5, "resolved/thenable/then") },
 320     assertUnreachable
 321   )
 322   assertAsyncRan()
 323 })();
 324
 325 (function() {
 326   var p1 = Promise.reject(5)
 327   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
 328   var p3 = Promise.accept(p2)
 329   p3.chain(
 330     function(x) { assertAsync(x === p2, "rejected/thenable/chain") },
 331     assertUnreachable
 332   )
 333   assertAsyncRan()
 334 })();
 335
 336 (function() {
 337   var p1 = Promise.reject(5)
 338   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
 339   var p3 = Promise.accept(p2)
 340   p3.then(
 341     assertUnreachable,
 342     function(x) { assertAsync(x === 5, "rejected/thenable/then") }
 343   )
 344   assertAsyncRan()
 345 })();
 346
 347 (function() {
 348   var deferred = Promise.defer()
 349   var p1 = deferred.promise
 350   var p2 = Promise.accept(p1)
 351   var p3 = Promise.accept(p2)
 352   p3.chain(
 353     function(x) { assertAsync(x === p2, "chain/resolve") },
 354     assertUnreachable
 355   )
 356   deferred.resolve(5)
 357   assertAsyncRan()
 358 })();
 359
 360 (function() {
 361   var deferred = Promise.defer()
 362   var p1 = deferred.promise
 363   var p2 = Promise.accept(p1)
 364   var p3 = Promise.accept(p2)
 365   p3.then(
 366     function(x) { assertAsync(x === 5, "then/resolve") },
 367     assertUnreachable
 368   )
 369   deferred.resolve(5)
 370   assertAsyncRan()
 371 })();
 372
 373 (function() {
 374   var deferred = Promise.defer()
 375   var p1 = deferred.promise
 376   var p2 = Promise.accept(p1)
 377   var p3 = Promise.accept(p2)
 378   p3.chain(
 379     function(x) { assertAsync(x === p2, "chain/reject") },
 380     assertUnreachable
 381   )
 382   deferred.reject(5)
 383   assertAsyncRan()
 384 })();
 385
 386 (function() {
 387   var deferred = Promise.defer()
 388   var p1 = deferred.promise
 389   var p2 = Promise.accept(p1)
 390   var p3 = Promise.accept(p2)
 391   p3.then(
 392     assertUnreachable,
 393     function(x) { assertAsync(x === 5, "then/reject") }
 394   )
 395   deferred.reject(5)
 396   assertAsyncRan()
 397 })();
 398
 399 (function() {
 400   var deferred = Promise.defer()
 401   var p1 = deferred.promise
 402   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
 403   var p3 = Promise.accept(p2)
 404   p3.chain(
 405     function(x) { assertAsync(x === p2, "chain/resolve/thenable") },
 406     assertUnreachable
 407   )
 408   deferred.resolve(5)
 409   assertAsyncRan()
 410 })();
 411
 412 (function() {
 413   var deferred = Promise.defer()
 414   var p1 = deferred.promise
 415   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
 416   var p3 = Promise.accept(p2)
 417   p3.then(
 418     function(x) { assertAsync(x === 5, "then/resolve/thenable") },
 419     assertUnreachable
 420   )
 421   deferred.resolve(5)
 422   assertAsyncRan()
 423 })();
 424
 425 (function() {
 426   var deferred = Promise.defer()
 427   var p1 = deferred.promise
 428   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
 429   var p3 = Promise.accept(p2)
 430   p3.chain(
 431     function(x) { assertAsync(x === p2, "chain/reject/thenable") },
 432     assertUnreachable
 433   )
 434   deferred.reject(5)
 435   assertAsyncRan()
 436 })();
 437
 438 (function() {
 439   var deferred = Promise.defer()
 440   var p1 = deferred.promise
 441   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
 442   var p3 = Promise.accept(p2)
 443   p3.then(
 444     assertUnreachable,
 445     function(x) { assertAsync(x === 5, "then/reject/thenable") }
 446   )
 447   deferred.reject(5)
 448   assertAsyncRan()
 449 })();
 450
 451 (function() {
 452   var p1 = Promise.accept(5)
 453   var p2 = Promise.accept(p1)
 454   var deferred = Promise.defer()
 455   var p3 = deferred.promise
 456   p3.chain(
 457     function(x) { assertAsync(x === p2, "chain/resolve2") },
 458     assertUnreachable
 459   )
 460   deferred.resolve(p2)
 461   assertAsyncRan()
 462 })();
 463
 464 (function() {
 465   var p1 = Promise.accept(5)
 466   var p2 = Promise.accept(p1)
 467   var deferred = Promise.defer()
 468   var p3 = deferred.promise
 469   p3.then(
 470     function(x) { assertAsync(x === 5, "then/resolve2") },
 471     assertUnreachable
 472   )
 473   deferred.resolve(p2)
 474   assertAsyncRan()
 475 })();
 476
 477 (function() {
 478   var p1 = Promise.accept(5)
 479   var p2 = Promise.accept(p1)
 480   var deferred = Promise.defer()
 481   var p3 = deferred.promise
 482   p3.chain(
 483     assertUnreachable,
 484     function(x) { assertAsync(x === 5, "chain/reject2") }
 485   )
 486   deferred.reject(5)
 487   assertAsyncRan()
 488 })();
 489
 490 (function() {
 491   var p1 = Promise.accept(5)
 492   var p2 = Promise.accept(p1)
 493   var deferred = Promise.defer()
 494   var p3 = deferred.promise
 495   p3.then(
 496     assertUnreachable,
 497     function(x) { assertAsync(x === 5, "then/reject2") }
 498   )
 499   deferred.reject(5)
 500   assertAsyncRan()
 501 })();
 502
 503 (function() {
 504   var p1 = Promise.accept(5)
 505   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
 506   var deferred = Promise.defer()
 507   var p3 = deferred.promise
 508   p3.chain(
 509     function(x) { assertAsync(x === p2, "chain/resolve/thenable2") },
 510     assertUnreachable
 511   )
 512   deferred.resolve(p2)
 513   assertAsyncRan()
 514 })();
 515
 516 (function() {
 517   var p1 = Promise.accept(5)
 518   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
 519   var deferred = Promise.defer()
 520   var p3 = deferred.promise
 521   p3.then(
 522     function(x) { assertAsync(x === 5, "then/resolve/thenable2") },
 523     assertUnreachable
 524   )
 525   deferred.resolve(p2)
 526   assertAsyncRan()
 527 })();
 528
 529 (function() {
 530   var p1 = Promise.accept(0)
 531   var p2 = p1.chain(function(x) { return p2 }, assertUnreachable)
 532   p2.chain(
 533     assertUnreachable,
 534     function(r) { assertAsync(r instanceof TypeError, "cyclic/chain") }
 535   )
 536   assertAsyncRan()
 537 })();
 538
 539 (function() {
 540   var p1 = Promise.accept(0)
 541   var p2 = p1.then(function(x) { return p2 }, assertUnreachable)
 542   p2.chain(
 543     assertUnreachable,
 544     function(r) { assertAsync(r instanceof TypeError, "cyclic/then") }
 545   )
 546   assertAsyncRan()
 547 })();
 548
 549 (function() {
 550   var deferred = Promise.defer()
 551   var p = deferred.promise
 552   deferred.resolve(p)
 553   p.chain(
 554     function(x) { assertAsync(x === p, "cyclic/deferred/chain") },
 555     assertUnreachable
 556   )
 557   assertAsyncRan()
 558 })();
 559
 560 (function() {
 561   var deferred = Promise.defer()
 562   var p = deferred.promise
 563   deferred.resolve(p)
 564   p.then(
 565     assertUnreachable,
 566     function(r) { assertAsync(r instanceof TypeError, "cyclic/deferred/then") }
 567   )
 568   assertAsyncRan()
 569 })();
 570
 571 (function() {
 572   Promise.all({}).chain(
 573     assertUnreachable,
 574     function(r) { assertAsync(r instanceof TypeError, "all/no-array") }
 575   )
 576   assertAsyncRan()
 577 })();
 578
 579 (function() {
 580   Promise.all([]).chain(
 581     function(x) { assertAsync(x.length === 0, "all/resolve/empty") },
 582     assertUnreachable
 583   )
 584   assertAsyncRan()
 585 })();
 586
 587 (function() {
 588   var deferred1 = Promise.defer()
 589   var p1 = deferred1.promise
 590   var deferred2 = Promise.defer()
 591   var p2 = deferred2.promise
 592   var deferred3 = Promise.defer()
 593   var p3 = deferred3.promise
 594   Promise.all([p1, p2, p3]).chain(
 595     function(x) {
 596       assertAsync(x.length === 3, "all/resolve")
 597       assertAsync(x[0] === 1, "all/resolve/0")
 598       assertAsync(x[1] === 2, "all/resolve/1")
 599       assertAsync(x[2] === 3, "all/resolve/2")
 600     },
 601     assertUnreachable
 602   )
 603   deferred1.resolve(1)
 604   deferred3.resolve(3)
 605   deferred2.resolve(2)
 606   assertAsyncRan()
 607   assertAsyncRan()
 608   assertAsyncRan()
 609   assertAsyncRan()
 610 })();
 611
 612 (function() {
 613   var deferred = Promise.defer()
 614   var p1 = deferred.promise
 615   var p2 = Promise.accept(2)
 616   var p3 = Promise.defer().promise
 617   Promise.all([p1, p2, p3]).chain(
 618     assertUnreachable,
 619     assertUnreachable
 620   )
 621   deferred.resolve(1)
 622 })();
 623
 624 (function() {
 625   var deferred1 = Promise.defer()
 626   var p1 = deferred1.promise
 627   var deferred2 = Promise.defer()
 628   var p2 = deferred2.promise
 629   var deferred3 = Promise.defer()
 630   var p3 = deferred3.promise
 631   Promise.all([p1, p2, p3]).chain(
 632     assertUnreachable,
 633     function(x) { assertAsync(x === 2, "all/reject") }
 634   )
 635   deferred1.resolve(1)
 636   deferred3.resolve(3)
 637   deferred2.reject(2)
 638   assertAsyncRan()
 639 })();
 640
 641 (function() {
 642   Promise.race([]).chain(
 643     assertUnreachable,
 644     assertUnreachable
 645   )
 646 })();
 647
 648 (function() {
 649   var p1 = Promise.accept(1)
 650   var p2 = Promise.accept(2)
 651   var p3 = Promise.accept(3)
 652   Promise.race([p1, p2, p3]).chain(
 653     function(x) { assertAsync(x === 1, "resolved/one") },
 654     assertUnreachable
 655   )
 656   assertAsyncRan()
 657 })();
 658
 659 (function() {
 660   var p1 = Promise.accept(1)
 661   var p2 = Promise.accept(2)
 662   var p3 = Promise.accept(3)
 663   Promise.race([0, p1, p2, p3]).chain(
 664     function(x) { assertAsync(x === 0, "resolved-const/one") },
 665     assertUnreachable
 666   )
 667   assertAsyncRan()
 668 })();
 669
 670 (function() {
 671   Promise.race({}).chain(
 672     assertUnreachable,
 673     function(r) { assertAsync(r instanceof TypeError, "one/no-array") }
 674   )
 675   assertAsyncRan()
 676 })();
 677
 678 (function() {
 679   var deferred1 = Promise.defer()
 680   var p1 = deferred1.promise
 681   var deferred2 = Promise.defer()
 682   var p2 = deferred2.promise
 683   var deferred3 = Promise.defer()
 684   var p3 = deferred3.promise
 685   Promise.race([p1, p2, p3]).chain(
 686     function(x) { assertAsync(x === 3, "one/resolve") },
 687     assertUnreachable
 688   )
 689   deferred3.resolve(3)
 690   deferred1.resolve(1)
 691   assertAsyncRan()
 692 })();
 693
 694 (function() {
 695   var deferred = Promise.defer()
 696   var p1 = deferred.promise
 697   var p2 = Promise.accept(2)
 698   var p3 = Promise.defer().promise
 699   Promise.race([p1, p2, p3]).chain(
 700     function(x) { assertAsync(x === 2, "resolved/one") },
 701     assertUnreachable
 702   )
 703   deferred.resolve(1)
 704   assertAsyncRan()
 705 })();
 706
 707 (function() {
 708   var deferred1 = Promise.defer()
 709   var p1 = deferred1.promise
 710   var deferred2 = Promise.defer()
 711   var p2 = deferred2.promise
 712   var deferred3 = Promise.defer()
 713   var p3 = deferred3.promise
 714   Promise.race([p1, p2, p3]).chain(
 715     function(x) { assertAsync(x === 3, "one/resolve/reject") },
 716     assertUnreachable
 717   )
 718   deferred3.resolve(3)
 719   deferred1.reject(1)
 720   assertAsyncRan()
 721 })();
 722
 723 (function() {
 724   var deferred1 = Promise.defer()
 725   var p1 = deferred1.promise
 726   var deferred2 = Promise.defer()
 727   var p2 = deferred2.promise
 728   var deferred3 = Promise.defer()
 729   var p3 = deferred3.promise
 730   Promise.race([p1, p2, p3]).chain(
 731     assertUnreachable,
 732     function(x) { assertAsync(x === 3, "one/reject/resolve") }
 733   )
 734   deferred3.reject(3)
 735   deferred1.resolve(1)
 736   assertAsyncRan()
 737 })();
 738
 739 (function() {
 740   var log
 741   function MyPromise(resolver) {
 742     log += "n"
 743     var promise = new Promise(function(resolve, reject) {
 744       resolver(
 745         function(x) { log += "x" + x; resolve(x) },
 746         function(r) { log += "r" + r; reject(r) }
 747       )
 748     })
 749     promise.__proto__ = MyPromise.prototype
 750     return promise
 751   }
 752
 753   MyPromise.__proto__ = Promise
 754   MyPromise.defer = function() {
 755     log += "d"
 756     return this.__proto__.defer.call(this)
 757   }
 758
 759   MyPromise.prototype.__proto__ = Promise.prototype
 760   MyPromise.prototype.chain = function(resolve, reject) {
 761     log += "c"
 762     return this.__proto__.__proto__.chain.call(this, resolve, reject)
 763   }
 764
 765   log = ""
 766   var p1 = new MyPromise(function(resolve, reject) { resolve(1) })
 767   var p2 = new MyPromise(function(resolve, reject) { reject(2) })
 768   var d3 = MyPromise.defer()
 769   assertTrue(d3.promise instanceof Promise, "subclass/instance")
 770   assertTrue(d3.promise instanceof MyPromise, "subclass/instance-my3")
 771   assertTrue(log === "nx1nr2dn", "subclass/create")
 772
 773   log = ""
 774   var p4 = MyPromise.resolve(4)
 775   var p5 = MyPromise.reject(5)
 776   assertTrue(p4 instanceof Promise, "subclass/instance4")
 777   assertTrue(p4 instanceof MyPromise, "subclass/instance-my4")
 778   assertTrue(p5 instanceof Promise, "subclass/instance5")
 779   assertTrue(p5 instanceof MyPromise, "subclass/instance-my5")
 780   d3.resolve(3)
 781   assertTrue(log === "nx4nr5x3", "subclass/resolve")
 782
 783   log = ""
 784   var d6 = MyPromise.defer()
 785   d6.promise.chain(function(x) {
 786     return new Promise(function(resolve) { resolve(x) })
 787   }).chain(function() {})
 788   d6.resolve(6)
 789   assertTrue(log === "dncncnx6", "subclass/chain")
 790
 791   log = ""
 792   Promise.all([11, Promise.accept(12), 13, MyPromise.accept(14), 15, 16])
 793   assertTrue(log === "nx14n", "subclass/all/arg")
 794
 795   log = ""
 796   MyPromise.all([21, Promise.accept(22), 23, MyPromise.accept(24), 25, 26])
 797   assertTrue(log === "nx24nnx21nnx23nnnx25nnx26n", "subclass/all/self")
 798 })();
 799
 800
 801 assertAsyncDone()