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: --allow-natives-syntax --harmony-tostring
  29
  30 // Make sure we don't rely on functions patchable by monkeys.
  31 var call = Function.prototype.call.call.bind(Function.prototype.call)
  32 var observe = Object.observe;
  33 var getOwnPropertyNames = Object.getOwnPropertyNames;
  34 var defineProperty = Object.defineProperty;
  35
  36
  37 (function() {
  38   // Test before clearing global (fails otherwise)
  39   assertEquals("[object Promise]",
  40       Object.prototype.toString.call(new Promise(function() {})));
  41 })();
  42
  43
  44 function clear(o) {
  45   if (o === null || (typeof o !== 'object' && typeof o !== 'function')) return
  46   clear(o.__proto__)
  47   var properties = getOwnPropertyNames(o)
  48   for (var i in properties) {
  49     clearProp(o, properties[i])
  50   }
  51 }
  52
  53 function clearProp(o, name) {
  54   var poisoned = {caller: 0, callee: 0, arguments: 0}
  55   try {
  56     var x = o[name]
  57     o[name] = undefined
  58     clear(x)
  59   } catch(e) {} // assertTrue(name in poisoned) }
  60 }
  61
  62 // Find intrinsics and null them out.
  63 var globals = Object.getOwnPropertyNames(this)
  64 var whitelist = {Promise: true, TypeError: true}
  65 for (var i in globals) {
  66   var name = globals[i]
  67   if (name in whitelist || name[0] === name[0].toLowerCase()) delete globals[i]
  68 }
  69 for (var i in globals) {
  70   if (globals[i]) clearProp(this, globals[i])
  71 }
  72
  73
  74 var asyncAssertsExpected = 0;
  75
  76 function assertAsyncRan() { ++asyncAssertsExpected }
  77
  78 function assertAsync(b, s) {
  79   if (b) {
  80     print(s, "succeeded")
  81   } else {
  82     %AbortJS(s + " FAILED!")  // Simply throwing here will have no effect.
  83   }
  84   --asyncAssertsExpected
  85 }
  86
  87 function assertAsyncDone(iteration) {
  88   var iteration = iteration || 0
  89   var dummy = {}
  90   observe(dummy,
  91     function() {
  92       if (asyncAssertsExpected === 0)
  93         assertAsync(true, "all")
  94       else if (iteration > 10)  // Shouldn't take more.
  95         assertAsync(false, "all")
  96       else
  97         assertAsyncDone(iteration + 1)
  98     }
  99   )
 100   dummy.dummy = dummy
 101 }
 102
 103
 104 (function() {
 105   assertThrows(function() { Promise(function() {}) }, TypeError)
 106 })();
 107
 108 (function() {
 109   assertTrue(new Promise(function() {}) instanceof Promise)
 110 })();
 111
 112 (function() {
 113   assertThrows(function() { new Promise(5) }, TypeError)
 114 })();
 115
 116 (function() {
 117   assertDoesNotThrow(function() { new Promise(function() { throw 5 }) })
 118 })();
 119
 120 (function() {
 121   (new Promise(function() { throw 5 })).chain(
 122     assertUnreachable,
 123     function(r) { assertAsync(r === 5, "new-throw") }
 124   )
 125   assertAsyncRan()
 126 })();
 127
 128 (function() {
 129   Promise.accept(5);
 130   Promise.accept(5).chain(undefined, assertUnreachable).chain(
 131     function(x) { assertAsync(x === 5, "resolved/chain-nohandler") },
 132     assertUnreachable
 133   )
 134   assertAsyncRan()
 135 })();
 136
 137 (function() {
 138   Promise.reject(5).chain(assertUnreachable, undefined).chain(
 139     assertUnreachable,
 140     function(r) { assertAsync(r === 5, "rejected/chain-nohandler") }
 141   )
 142   assertAsyncRan()
 143 })();
 144
 145 (function() {
 146   Promise.accept(5).then(undefined, assertUnreachable).chain(
 147     function(x) { assertAsync(x === 5, "resolved/then-nohandler-undefined") },
 148     assertUnreachable
 149   )
 150   assertAsyncRan()
 151   Promise.accept(6).then(null, assertUnreachable).chain(
 152     function(x) { assertAsync(x === 6, "resolved/then-nohandler-null") },
 153     assertUnreachable
 154   )
 155   assertAsyncRan()
 156 })();
 157
 158 (function() {
 159   Promise.reject(5).then(assertUnreachable, undefined).chain(
 160     assertUnreachable,
 161     function(r) { assertAsync(r === 5, "rejected/then-nohandler-undefined") }
 162   )
 163   assertAsyncRan()
 164   Promise.reject(6).then(assertUnreachable, null).chain(
 165     assertUnreachable,
 166     function(r) { assertAsync(r === 6, "rejected/then-nohandler-null") }
 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(
 176     function(x) { assertAsync(x === p2, "resolved/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.then(
 187     function(x) { assertAsync(x === 5, "resolved/then") },
 188     assertUnreachable
 189   )
 190   assertAsyncRan()
 191 })();
 192
 193 (function() {
 194   var p1 = Promise.reject(5)
 195   var p2 = Promise.accept(p1)
 196   var p3 = Promise.accept(p2)
 197   p3.chain(
 198     function(x) { assertAsync(x === p2, "rejected/chain") },
 199     assertUnreachable
 200   )
 201   assertAsyncRan()
 202 })();
 203
 204 (function() {
 205   var p1 = Promise.reject(5)
 206   var p2 = Promise.accept(p1)
 207   var p3 = Promise.accept(p2)
 208   p3.then(
 209     assertUnreachable,
 210     function(x) { assertAsync(x === 5, "rejected/then") }
 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.chain(function(x) { return x }, assertUnreachable).chain(
 220     function(x) { assertAsync(x === p1, "resolved/chain/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.chain(function(x) { return x }, assertUnreachable).then(
 231     function(x) { assertAsync(x === 5, "resolved/chain/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.chain(function(x) { return 6 }, assertUnreachable).chain(
 242     function(x) { assertAsync(x === 6, "resolved/chain/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.chain(function(x) { return 6 }, assertUnreachable).then(
 253     function(x) { assertAsync(x === 6, "resolved/chain/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.then(function(x) { return x + 1 }, assertUnreachable).chain(
 264     function(x) { assertAsync(x === 6, "resolved/then/chain") },
 265     assertUnreachable
 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.then(function(x) { return x + 1 }, assertUnreachable).then(
 275     function(x) { assertAsync(x === 6, "resolved/then/then") },
 276     assertUnreachable
 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){ return Promise.accept(x+1) }, assertUnreachable).chain(
 286     function(x) { assertAsync(x === 6, "resolved/then/chain2") },
 287     assertUnreachable
 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) { return Promise.accept(x+1) }, assertUnreachable).then(
 297     function(x) { assertAsync(x === 6, "resolved/then/then2") },
 298     assertUnreachable
 299   )
 300   assertAsyncRan()
 301 })();
 302
 303 (function() {
 304   var p1 = Promise.accept(5)
 305   var p2 = Promise.accept(p1)
 306   var p3 = Promise.accept(p2)
 307   p3.chain(function(x) { throw 6 }, assertUnreachable).chain(
 308     assertUnreachable,
 309     function(x) { assertAsync(x === 6, "resolved/chain-throw/chain") }
 310   )
 311   assertAsyncRan()
 312 })();
 313
 314 (function() {
 315   var p1 = Promise.accept(5)
 316   var p2 = Promise.accept(p1)
 317   var p3 = Promise.accept(p2)
 318   p3.chain(function(x) { throw 6 }, assertUnreachable).then(
 319     assertUnreachable,
 320     function(x) { assertAsync(x === 6, "resolved/chain-throw/then") }
 321   )
 322   assertAsyncRan()
 323 })();
 324
 325 (function() {
 326   var p1 = Promise.accept(5)
 327   var p2 = Promise.accept(p1)
 328   var p3 = Promise.accept(p2)
 329   p3.then(function(x) { throw 6 }, assertUnreachable).chain(
 330     assertUnreachable,
 331     function(x) { assertAsync(x === 6, "resolved/then-throw/chain") }
 332   )
 333   assertAsyncRan()
 334 })();
 335
 336 (function() {
 337   var p1 = Promise.accept(5)
 338   var p2 = Promise.accept(p1)
 339   var p3 = Promise.accept(p2)
 340   p3.then(function(x) { throw 6 }, assertUnreachable).then(
 341     assertUnreachable,
 342     function(x) { assertAsync(x === 6, "resolved/then-throw/then") }
 343   )
 344   assertAsyncRan()
 345 })();
 346
 347 (function() {
 348   var p1 = Promise.accept(5)
 349   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
 350   var p3 = Promise.accept(p2)
 351   p3.chain(
 352     function(x) { assertAsync(x === p2, "resolved/thenable/chain") },
 353     assertUnreachable
 354   )
 355   assertAsyncRan()
 356 })();
 357
 358 (function() {
 359   var p1 = Promise.accept(5)
 360   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
 361   var p3 = Promise.accept(p2)
 362   p3.then(
 363     function(x) { assertAsync(x === 5, "resolved/thenable/then") },
 364     assertUnreachable
 365   )
 366   assertAsyncRan()
 367 })();
 368
 369 (function() {
 370   var p1 = Promise.reject(5)
 371   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
 372   var p3 = Promise.accept(p2)
 373   p3.chain(
 374     function(x) { assertAsync(x === p2, "rejected/thenable/chain") },
 375     assertUnreachable
 376   )
 377   assertAsyncRan()
 378 })();
 379
 380 (function() {
 381   var p1 = Promise.reject(5)
 382   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
 383   var p3 = Promise.accept(p2)
 384   p3.then(
 385     assertUnreachable,
 386     function(x) { assertAsync(x === 5, "rejected/thenable/then") }
 387   )
 388   assertAsyncRan()
 389 })();
 390
 391 (function() {
 392   var deferred = Promise.defer()
 393   var p1 = deferred.promise
 394   var p2 = Promise.accept(p1)
 395   var p3 = Promise.accept(p2)
 396   p3.chain(
 397     function(x) { assertAsync(x === p2, "chain/resolve") },
 398     assertUnreachable
 399   )
 400   deferred.resolve(5)
 401   assertAsyncRan()
 402 })();
 403
 404 (function() {
 405   var deferred = Promise.defer()
 406   var p1 = deferred.promise
 407   var p2 = Promise.accept(p1)
 408   var p3 = Promise.accept(p2)
 409   p3.then(
 410     function(x) { assertAsync(x === 5, "then/resolve") },
 411     assertUnreachable
 412   )
 413   deferred.resolve(5)
 414   assertAsyncRan()
 415 })();
 416
 417 (function() {
 418   var deferred = Promise.defer()
 419   var p1 = deferred.promise
 420   var p2 = Promise.accept(p1)
 421   var p3 = Promise.accept(p2)
 422   p3.chain(
 423     function(x) { assertAsync(x === p2, "chain/reject") },
 424     assertUnreachable
 425   )
 426   deferred.reject(5)
 427   assertAsyncRan()
 428 })();
 429
 430 (function() {
 431   var deferred = Promise.defer()
 432   var p1 = deferred.promise
 433   var p2 = Promise.accept(p1)
 434   var p3 = Promise.accept(p2)
 435   p3.then(
 436     assertUnreachable,
 437     function(x) { assertAsync(x === 5, "then/reject") }
 438   )
 439   deferred.reject(5)
 440   assertAsyncRan()
 441 })();
 442
 443 (function() {
 444   var deferred = Promise.defer()
 445   var p1 = deferred.promise
 446   var p2 = p1.then(1, 2)
 447   p2.then(
 448     function(x) { assertAsync(x === 5, "then/resolve-non-function") },
 449     assertUnreachable
 450   )
 451   deferred.resolve(5)
 452   assertAsyncRan()
 453 })();
 454
 455 (function() {
 456   var deferred = Promise.defer()
 457   var p1 = deferred.promise
 458   var p2 = p1.then(1, 2)
 459   p2.then(
 460     assertUnreachable,
 461     function(x) { assertAsync(x === 5, "then/reject-non-function") }
 462   )
 463   deferred.reject(5)
 464   assertAsyncRan()
 465 })();
 466
 467 (function() {
 468   var deferred = Promise.defer()
 469   var p1 = deferred.promise
 470   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
 471   var p3 = Promise.accept(p2)
 472   p3.chain(
 473     function(x) { assertAsync(x === p2, "chain/resolve/thenable") },
 474     assertUnreachable
 475   )
 476   deferred.resolve(5)
 477   assertAsyncRan()
 478 })();
 479
 480 (function() {
 481   var deferred = Promise.defer()
 482   var p1 = deferred.promise
 483   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
 484   var p3 = Promise.accept(p2)
 485   p3.then(
 486     function(x) { assertAsync(x === 5, "then/resolve/thenable") },
 487     assertUnreachable
 488   )
 489   deferred.resolve(5)
 490   assertAsyncRan()
 491 })();
 492
 493 (function() {
 494   var deferred = Promise.defer()
 495   var p1 = deferred.promise
 496   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
 497   var p3 = Promise.accept(p2)
 498   p3.chain(
 499     function(x) { assertAsync(x === p2, "chain/reject/thenable") },
 500     assertUnreachable
 501   )
 502   deferred.reject(5)
 503   assertAsyncRan()
 504 })();
 505
 506 (function() {
 507   var deferred = Promise.defer()
 508   var p1 = deferred.promise
 509   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
 510   var p3 = Promise.accept(p2)
 511   p3.then(
 512     assertUnreachable,
 513     function(x) { assertAsync(x === 5, "then/reject/thenable") }
 514   )
 515   deferred.reject(5)
 516   assertAsyncRan()
 517 })();
 518
 519 (function() {
 520   var p1 = Promise.accept(5)
 521   var p2 = Promise.accept(p1)
 522   var deferred = Promise.defer()
 523   var p3 = deferred.promise
 524   p3.chain(
 525     function(x) { assertAsync(x === p2, "chain/resolve2") },
 526     assertUnreachable
 527   )
 528   deferred.resolve(p2)
 529   assertAsyncRan()
 530 })();
 531
 532 (function() {
 533   var p1 = Promise.accept(5)
 534   var p2 = Promise.accept(p1)
 535   var deferred = Promise.defer()
 536   var p3 = deferred.promise
 537   p3.then(
 538     function(x) { assertAsync(x === 5, "then/resolve2") },
 539     assertUnreachable
 540   )
 541   deferred.resolve(p2)
 542   assertAsyncRan()
 543 })();
 544
 545 (function() {
 546   var p1 = Promise.accept(5)
 547   var p2 = Promise.accept(p1)
 548   var deferred = Promise.defer()
 549   var p3 = deferred.promise
 550   p3.chain(
 551     assertUnreachable,
 552     function(x) { assertAsync(x === 5, "chain/reject2") }
 553   )
 554   deferred.reject(5)
 555   assertAsyncRan()
 556 })();
 557
 558 (function() {
 559   var p1 = Promise.accept(5)
 560   var p2 = Promise.accept(p1)
 561   var deferred = Promise.defer()
 562   var p3 = deferred.promise
 563   p3.then(
 564     assertUnreachable,
 565     function(x) { assertAsync(x === 5, "then/reject2") }
 566   )
 567   deferred.reject(5)
 568   assertAsyncRan()
 569 })();
 570
 571 (function() {
 572   var p1 = Promise.accept(5)
 573   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
 574   var deferred = Promise.defer()
 575   var p3 = deferred.promise
 576   p3.chain(
 577     function(x) { assertAsync(x === p2, "chain/resolve/thenable2") },
 578     assertUnreachable
 579   )
 580   deferred.resolve(p2)
 581   assertAsyncRan()
 582 })();
 583
 584 (function() {
 585   var p1 = Promise.accept(5)
 586   var p2 = {then: function(onResolve, onReject) { onResolve(p1) }}
 587   var deferred = Promise.defer()
 588   var p3 = deferred.promise
 589   p3.then(
 590     function(x) { assertAsync(x === 5, "then/resolve/thenable2") },
 591     assertUnreachable
 592   )
 593   deferred.resolve(p2)
 594   assertAsyncRan()
 595 })();
 596
 597 (function() {
 598   var p1 = Promise.accept(0)
 599   var p2 = p1.chain(function(x) { return p2 }, assertUnreachable)
 600   p2.chain(
 601     assertUnreachable,
 602     function(r) { assertAsync(r instanceof TypeError, "cyclic/chain") }
 603   )
 604   assertAsyncRan()
 605 })();
 606
 607 (function() {
 608   var p1 = Promise.accept(0)
 609   var p2 = p1.then(function(x) { return p2 }, assertUnreachable)
 610   p2.chain(
 611     assertUnreachable,
 612     function(r) { assertAsync(r instanceof TypeError, "cyclic/then") }
 613   )
 614   assertAsyncRan()
 615 })();
 616
 617 (function() {
 618   var deferred = Promise.defer()
 619   var p = deferred.promise
 620   deferred.resolve(p)
 621   p.chain(
 622     function(x) { assertAsync(x === p, "cyclic/deferred/chain") },
 623     assertUnreachable
 624   )
 625   assertAsyncRan()
 626 })();
 627
 628 (function() {
 629   var deferred = Promise.defer()
 630   var p = deferred.promise
 631   deferred.resolve(p)
 632   p.then(
 633     assertUnreachable,
 634     function(r) { assertAsync(r instanceof TypeError, "cyclic/deferred/then") }
 635   )
 636   assertAsyncRan()
 637 })();
 638
 639 (function() {
 640   Promise.all({}).chain(
 641     assertUnreachable,
 642     function(r) { assertAsync(r instanceof TypeError, "all/no-array") }
 643   )
 644   assertAsyncRan()
 645 })();
 646
 647 (function() {
 648   Promise.all([]).chain(
 649     function(x) { assertAsync(x.length === 0, "all/resolve/empty") },
 650     assertUnreachable
 651   )
 652   assertAsyncRan()
 653 })();
 654
 655 (function() {
 656   var deferred1 = Promise.defer()
 657   var p1 = deferred1.promise
 658   var deferred2 = Promise.defer()
 659   var p2 = deferred2.promise
 660   var deferred3 = Promise.defer()
 661   var p3 = deferred3.promise
 662   Promise.all([p1, p2, p3]).chain(
 663     function(x) {
 664       assertAsync(x.length === 3, "all/resolve")
 665       assertAsync(x[0] === 1, "all/resolve/0")
 666       assertAsync(x[1] === 2, "all/resolve/1")
 667       assertAsync(x[2] === 3, "all/resolve/2")
 668     },
 669     assertUnreachable
 670   )
 671   deferred1.resolve(1)
 672   deferred3.resolve(3)
 673   deferred2.resolve(2)
 674   assertAsyncRan()
 675   assertAsyncRan()
 676   assertAsyncRan()
 677   assertAsyncRan()
 678 })();
 679
 680 (function() {
 681   var deferred = Promise.defer()
 682   var p1 = deferred.promise
 683   var p2 = Promise.accept(2)
 684   var p3 = Promise.defer().promise
 685   Promise.all([p1, p2, p3]).chain(
 686     assertUnreachable,
 687     assertUnreachable
 688   )
 689   deferred.resolve(1)
 690 })();
 691
 692 (function() {
 693   var deferred1 = Promise.defer()
 694   var p1 = deferred1.promise
 695   var deferred2 = Promise.defer()
 696   var p2 = deferred2.promise
 697   var deferred3 = Promise.defer()
 698   var p3 = deferred3.promise
 699   Promise.all([p1, p2, p3]).chain(
 700     assertUnreachable,
 701     function(x) { assertAsync(x === 2, "all/reject") }
 702   )
 703   deferred1.resolve(1)
 704   deferred3.resolve(3)
 705   deferred2.reject(2)
 706   assertAsyncRan()
 707 })();
 708
 709 (function() {
 710   Promise.race([]).chain(
 711     assertUnreachable,
 712     assertUnreachable
 713   )
 714 })();
 715
 716 (function() {
 717   var p1 = Promise.accept(1)
 718   var p2 = Promise.accept(2)
 719   var p3 = Promise.accept(3)
 720   Promise.race([p1, p2, p3]).chain(
 721     function(x) { assertAsync(x === 1, "resolved/one") },
 722     assertUnreachable
 723   )
 724   assertAsyncRan()
 725 })();
 726
 727 (function() {
 728   var p1 = Promise.accept(1)
 729   var p2 = Promise.accept(2)
 730   var p3 = Promise.accept(3)
 731   Promise.race([0, p1, p2, p3]).chain(
 732     function(x) { assertAsync(x === 0, "resolved-const/one") },
 733     assertUnreachable
 734   )
 735   assertAsyncRan()
 736 })();
 737
 738 (function() {
 739   Promise.race({}).chain(
 740     assertUnreachable,
 741     function(r) { assertAsync(r instanceof TypeError, "one/no-array") }
 742   )
 743   assertAsyncRan()
 744 })();
 745
 746 (function() {
 747   var deferred1 = Promise.defer()
 748   var p1 = deferred1.promise
 749   var deferred2 = Promise.defer()
 750   var p2 = deferred2.promise
 751   var deferred3 = Promise.defer()
 752   var p3 = deferred3.promise
 753   Promise.race([p1, p2, p3]).chain(
 754     function(x) { assertAsync(x === 3, "one/resolve") },
 755     assertUnreachable
 756   )
 757   deferred3.resolve(3)
 758   deferred1.resolve(1)
 759   assertAsyncRan()
 760 })();
 761
 762 (function() {
 763   var deferred = Promise.defer()
 764   var p1 = deferred.promise
 765   var p2 = Promise.accept(2)
 766   var p3 = Promise.defer().promise
 767   Promise.race([p1, p2, p3]).chain(
 768     function(x) { assertAsync(x === 2, "resolved/one") },
 769     assertUnreachable
 770   )
 771   deferred.resolve(1)
 772   assertAsyncRan()
 773 })();
 774
 775 (function() {
 776   var deferred1 = Promise.defer()
 777   var p1 = deferred1.promise
 778   var deferred2 = Promise.defer()
 779   var p2 = deferred2.promise
 780   var deferred3 = Promise.defer()
 781   var p3 = deferred3.promise
 782   Promise.race([p1, p2, p3]).chain(
 783     function(x) { assertAsync(x === 3, "one/resolve/reject") },
 784     assertUnreachable
 785   )
 786   deferred3.resolve(3)
 787   deferred1.reject(1)
 788   assertAsyncRan()
 789 })();
 790
 791 (function() {
 792   var deferred1 = Promise.defer()
 793   var p1 = deferred1.promise
 794   var deferred2 = Promise.defer()
 795   var p2 = deferred2.promise
 796   var deferred3 = Promise.defer()
 797   var p3 = deferred3.promise
 798   Promise.race([p1, p2, p3]).chain(
 799     assertUnreachable,
 800     function(x) { assertAsync(x === 3, "one/reject/resolve") }
 801   )
 802   deferred3.reject(3)
 803   deferred1.resolve(1)
 804   assertAsyncRan()
 805 })();
 806
 807 (function() {
 808   var log
 809   function MyPromise(resolver) {
 810     log += "n"
 811     var promise = new Promise(function(resolve, reject) {
 812       resolver(
 813         function(x) { log += "x" + x; resolve(x) },
 814         function(r) { log += "r" + r; reject(r) }
 815       )
 816     })
 817     promise.__proto__ = MyPromise.prototype
 818     return promise
 819   }
 820
 821   MyPromise.__proto__ = Promise
 822   MyPromise.defer = function() {
 823     log += "d"
 824     return call(this.__proto__.defer, this)
 825   }
 826
 827   MyPromise.prototype.__proto__ = Promise.prototype
 828   MyPromise.prototype.chain = function(resolve, reject) {
 829     log += "c"
 830     return call(this.__proto__.__proto__.chain, this, resolve, reject)
 831   }
 832
 833   log = ""
 834   var p1 = new MyPromise(function(resolve, reject) { resolve(1) })
 835   var p2 = new MyPromise(function(resolve, reject) { reject(2) })
 836   var d3 = MyPromise.defer()
 837   assertTrue(d3.promise instanceof Promise, "subclass/instance")
 838   assertTrue(d3.promise instanceof MyPromise, "subclass/instance-my3")
 839   assertTrue(log === "nx1nr2dn", "subclass/create")
 840
 841   log = ""
 842   var p4 = MyPromise.resolve(4)
 843   var p5 = MyPromise.reject(5)
 844   assertTrue(p4 instanceof Promise, "subclass/instance4")
 845   assertTrue(p4 instanceof MyPromise, "subclass/instance-my4")
 846   assertTrue(p5 instanceof Promise, "subclass/instance5")
 847   assertTrue(p5 instanceof MyPromise, "subclass/instance-my5")
 848   d3.resolve(3)
 849   assertTrue(log === "nx4nr5x3", "subclass/resolve")
 850
 851   log = ""
 852   var d6 = MyPromise.defer()
 853   d6.promise.chain(function(x) {
 854     return new Promise(function(resolve) { resolve(x) })
 855   }).chain(function() {})
 856   d6.resolve(6)
 857   assertTrue(log === "dncncnx6", "subclass/chain")
 858
 859   log = ""
 860   Promise.all([11, Promise.accept(12), 13, MyPromise.accept(14), 15, 16])
 861   assertTrue(log === "nx14n", "subclass/all/arg")
 862
 863   log = ""
 864   MyPromise.all([21, Promise.accept(22), 23, MyPromise.accept(24), 25, 26])
 865   assertTrue(log === "nx24nnx21nnx23nnnx25nnx26n", "subclass/all/self")
 866 })();
 867
 868
 869 assertAsyncDone()