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 |
| 29 |
| 30 var asyncAssertsExpected = 0; |
| 31 |
| 32 function assertAsyncRan() { ++asyncAssertsExpected } |
| 33 |
| 34 function assertAsync(b, s) { |
| 35 assert(b, s) |
| 36 --asyncAssertsExpected |
| 37 } |
| 38 |
| 39 function assertAsyncDone() { |
| 40 var previous = asyncAssertsExpected |
| 41 var dummy = {} |
| 42 Object.observe(dummy, |
| 43 function() { |
| 44 if (asyncAssertsExpected < previous) |
| 45 assertAsyncDone() // Progress, queue check again |
| 46 else |
| 47 assertEqual(0, asyncAssertsExpected) |
| 48 } |
| 49 ) |
| 50 dummy.dummy = dummy |
| 51 } |
| 52 |
| 53 |
| 54 (function() { |
| 55 Promise.resolved(5); |
| 56 Promise.resolved(5).when(undefined, assertUnreachable).when( |
| 57 function(x) { assertAsync(x === undefined, "resolved/when-nohandler") }, |
| 58 assertUnreachable |
| 59 ) |
| 60 assertAsyncRan() |
| 61 })(); |
| 62 |
| 63 (function() { |
| 64 Promise.rejected(5).when(assertUnreachable, undefined).when( |
| 65 function(x) { assertAsync(x === undefined, "rejected/when-nohandler") }, |
| 66 assertUnreachable |
| 67 ) |
| 68 assertAsyncRan() |
| 69 })(); |
| 70 |
| 71 (function() { |
| 72 Promise.resolved(5).then(undefined, assertUnreachable).when( |
| 73 function(x) { assertAsync(x === undefined, "resolved/then-nohandler") }, |
| 74 assertUnreachable |
| 75 ) |
| 76 assertAsyncRan() |
| 77 })(); |
| 78 |
| 79 (function() { |
| 80 Promise.rejected(5).then(assertUnreachable, undefined).when( |
| 81 function(x) { assertAsync(x === undefined, "rejected/then-nohandler") }, |
| 82 assertUnreachable |
| 83 ) |
| 84 assertAsyncRan() |
| 85 })(); |
| 86 |
| 87 (function() { |
| 88 var p1 = Promise.resolved(5) |
| 89 var p2 = Promise.resolved(p1) |
| 90 var p3 = Promise.resolved(p2) |
| 91 p3.when(function(x) { assertAsync(x === p2, "resolved/when") }, assertUnreacha
ble) |
| 92 assertAsyncRan() |
| 93 })(); |
| 94 |
| 95 (function() { |
| 96 var p1 = Promise.resolved(5) |
| 97 var p2 = Promise.resolved(p1) |
| 98 var p3 = Promise.resolved(p2) |
| 99 p3.then(function(x) { assertAsync(x === 5, "resolved/then") }, assertUnreachab
le) |
| 100 assertAsyncRan() |
| 101 })(); |
| 102 |
| 103 (function() { |
| 104 var p1 = Promise.rejected(5) |
| 105 var p2 = Promise.resolved(p1) |
| 106 var p3 = Promise.resolved(p2) |
| 107 p3.when(function(x) { assertAsync(x === p2, "rejected/when") }, assertUnreacha
ble) |
| 108 assertAsyncRan() |
| 109 })(); |
| 110 |
| 111 (function() { |
| 112 var p1 = Promise.rejected(5) |
| 113 var p2 = Promise.resolved(p1) |
| 114 var p3 = Promise.resolved(p2) |
| 115 p3.then(assertUnreachable, function(x) { assertAsync(x === 5, "rejected/then")
}) |
| 116 assertAsyncRan() |
| 117 })(); |
| 118 |
| 119 (function() { |
| 120 var p1 = Promise.resolved(5) |
| 121 var p2 = Promise.resolved(p1) |
| 122 var p3 = Promise.resolved(p2) |
| 123 p3.when(function(x) { return x }, assertUnreachable) |
| 124 .when(function(x) { assertAsync(x === p1, "resolved/when/when") }, assertUnr
eachable) |
| 125 assertAsyncRan() |
| 126 })(); |
| 127 |
| 128 (function() { |
| 129 var p1 = Promise.resolved(5) |
| 130 var p2 = Promise.resolved(p1) |
| 131 var p3 = Promise.resolved(p2) |
| 132 p3.when(function(x) { return x }, assertUnreachable) |
| 133 .then(function(x) { assertAsync(x === 5, "resolved/when/then") }, assertUnre
achable) |
| 134 assertAsyncRan() |
| 135 })(); |
| 136 |
| 137 (function() { |
| 138 var p1 = Promise.resolved(5) |
| 139 var p2 = Promise.resolved(p1) |
| 140 var p3 = Promise.resolved(p2) |
| 141 p3.when(function(x) { return 6 }, assertUnreachable) |
| 142 .when(function(x) { assertAsync(x === 6, "resolved/when/when2") }, assertUnr
eachable) |
| 143 assertAsyncRan() |
| 144 })(); |
| 145 |
| 146 (function() { |
| 147 var p1 = Promise.resolved(5) |
| 148 var p2 = Promise.resolved(p1) |
| 149 var p3 = Promise.resolved(p2) |
| 150 p3.when(function(x) { return 6 }, assertUnreachable) |
| 151 .then(function(x) { assertAsync(x === 6, "resolved/when/then2") }, assertUnr
eachable) |
| 152 assertAsyncRan() |
| 153 })(); |
| 154 |
| 155 (function() { |
| 156 var p1 = Promise.resolved(5) |
| 157 var p2 = Promise.resolved(p1) |
| 158 var p3 = Promise.resolved(p2) |
| 159 p3.then(function(x) { return x + 1 }, assertUnreachable) |
| 160 .when(function(x) { assertAsync(x === 6, "resolved/then/when") }, assertUnre
achable) |
| 161 assertAsyncRan() |
| 162 })(); |
| 163 |
| 164 (function() { |
| 165 var p1 = Promise.resolved(5) |
| 166 var p2 = Promise.resolved(p1) |
| 167 var p3 = Promise.resolved(p2) |
| 168 p3.then(function(x) { return x + 1 }, assertUnreachable) |
| 169 .then(function(x) { assertAsync(x === 6, "resolved/then/then") }, assertUnre
achable) |
| 170 assertAsyncRan() |
| 171 })(); |
| 172 |
| 173 (function() { |
| 174 var p1 = Promise.resolved(5) |
| 175 var p2 = Promise.resolved(p1) |
| 176 var p3 = Promise.resolved(p2) |
| 177 p3.then(function(x) { return Promise.resolved(x + 1) }, assertUnreachable) |
| 178 .when(function(x) { assertAsync(x === 6, "resolved/then/when2") }, assertUnr
eachable) |
| 179 assertAsyncRan() |
| 180 })(); |
| 181 |
| 182 (function() { |
| 183 var p1 = Promise.resolved(5) |
| 184 var p2 = Promise.resolved(p1) |
| 185 var p3 = Promise.resolved(p2) |
| 186 p3.then(function(x) { return Promise.resolved(x + 1) }, assertUnreachable) |
| 187 .then(function(x) { assertAsync(x === 6, "resolved/then/then2") }, assertUnr
eachable) |
| 188 assertAsyncRan() |
| 189 })(); |
| 190 |
| 191 (function() { |
| 192 var p1 = Promise.resolved(5) |
| 193 var p2 = Promise.resolved(p1) |
| 194 var p3 = Promise.resolved(p2) |
| 195 p3.when(function(x) { throw 6 }, assertUnreachable) |
| 196 .when(assertUnreachable, function(x) { assertAsync(x === 6, "resolved/when-t
hrow/when") }) |
| 197 assertAsyncRan() |
| 198 })(); |
| 199 |
| 200 (function() { |
| 201 var p1 = Promise.resolved(5) |
| 202 var p2 = Promise.resolved(p1) |
| 203 var p3 = Promise.resolved(p2) |
| 204 p3.when(function(x) { throw 6 }, assertUnreachable) |
| 205 .then(assertUnreachable, function(x) { assertAsync(x === 6, "resolved/when-t
hrow/then") }) |
| 206 assertAsyncRan() |
| 207 })(); |
| 208 |
| 209 (function() { |
| 210 var p1 = Promise.resolved(5) |
| 211 var p2 = Promise.resolved(p1) |
| 212 var p3 = Promise.resolved(p2) |
| 213 p3.then(function(x) { throw 6 }, assertUnreachable) |
| 214 .when(assertUnreachable, function(x) { assertAsync(x === 6, "resolved/then-t
hrow/when") }) |
| 215 assertAsyncRan() |
| 216 })(); |
| 217 |
| 218 (function() { |
| 219 var p1 = Promise.resolved(5) |
| 220 var p2 = Promise.resolved(p1) |
| 221 var p3 = Promise.resolved(p2) |
| 222 p3.then(function(x) { throw 6 }, assertUnreachable) |
| 223 .then(assertUnreachable, function(x) { assertAsync(x === 6, "resolved/then-t
hrow/then") }) |
| 224 assertAsyncRan() |
| 225 })(); |
| 226 |
| 227 (function() { |
| 228 var p1 = Promise.resolved(5) |
| 229 var p2 = {then: function(onResolve, onReject) { onResolve(p1) }} |
| 230 var p3 = Promise.resolved(p2) |
| 231 p3.when(function(x) { assertAsync(x === p2, "resolved/thenable/when") }, asser
tUnreachable) |
| 232 assertAsyncRan() |
| 233 })(); |
| 234 |
| 235 (function() { |
| 236 var p1 = Promise.resolved(5) |
| 237 var p2 = {then: function(onResolve, onReject) { onResolve(p1) }} |
| 238 var p3 = Promise.resolved(p2) |
| 239 p3.then(function(x) { assertAsync(x === 5, "resolved/thenable/then") }, assert
Unreachable) |
| 240 assertAsyncRan() |
| 241 })(); |
| 242 |
| 243 (function() { |
| 244 var p1 = Promise.rejected(5) |
| 245 var p2 = {then: function(onResolve, onReject) { onResolve(p1) }} |
| 246 var p3 = Promise.resolved(p2) |
| 247 p3.when(function(x) { assertAsync(x === p2, "rejected/thenable/when") }, asser
tUnreachable) |
| 248 assertAsyncRan() |
| 249 })(); |
| 250 |
| 251 (function() { |
| 252 var p1 = Promise.rejected(5) |
| 253 var p2 = {then: function(onResolve, onReject) { onResolve(p1) }} |
| 254 var p3 = Promise.resolved(p2) |
| 255 p3.then(assertUnreachable, function(x) { assertAsync(x === 5, "rejected/thenab
le/then") }) |
| 256 assertAsyncRan() |
| 257 })(); |
| 258 |
| 259 (function() { |
| 260 var deferred = Promise.deferred() |
| 261 var p1 = deferred.promise |
| 262 var p2 = Promise.resolved(p1) |
| 263 var p3 = Promise.resolved(p2) |
| 264 p3.when(function(x) { assertAsync(x === p2, "when/resolve") }, assertUnreachab
le) |
| 265 deferred.resolve(5) |
| 266 assertAsyncRan() |
| 267 })(); |
| 268 |
| 269 (function() { |
| 270 var deferred = Promise.deferred() |
| 271 var p1 = deferred.promise |
| 272 var p2 = Promise.resolved(p1) |
| 273 var p3 = Promise.resolved(p2) |
| 274 p3.then(function(x) { assertAsync(x === 5, "then/resolve") }, assertUnreachabl
e) |
| 275 deferred.resolve(5) |
| 276 assertAsyncRan() |
| 277 })(); |
| 278 |
| 279 (function() { |
| 280 var deferred = Promise.deferred() |
| 281 var p1 = deferred.promise |
| 282 var p2 = Promise.resolved(p1) |
| 283 var p3 = Promise.resolved(p2) |
| 284 p3.when(function(x) { assertAsync(x === p2, "when/reject") }, assertUnreachabl
e) |
| 285 deferred.reject(5) |
| 286 assertAsyncRan() |
| 287 })(); |
| 288 |
| 289 (function() { |
| 290 var deferred = Promise.deferred() |
| 291 var p1 = deferred.promise |
| 292 var p2 = Promise.resolved(p1) |
| 293 var p3 = Promise.resolved(p2) |
| 294 p3.then(assertUnreachable, function(x) { assertAsync(x === 5, "then/reject") }
) |
| 295 deferred.reject(5) |
| 296 assertAsyncRan() |
| 297 })(); |
| 298 |
| 299 (function() { |
| 300 var deferred = Promise.deferred() |
| 301 var p1 = deferred.promise |
| 302 var p2 = {then: function(onResolve, onReject) { onResolve(p1) }} |
| 303 var p3 = Promise.resolved(p2) |
| 304 p3.when(function(x) { assertAsync(x === p2, "when/resolve/thenable") }, assert
Unreachable) |
| 305 deferred.resolve(5) |
| 306 assertAsyncRan() |
| 307 })(); |
| 308 |
| 309 (function() { |
| 310 var deferred = Promise.deferred() |
| 311 var p1 = deferred.promise |
| 312 var p2 = {then: function(onResolve, onReject) { onResolve(p1) }} |
| 313 var p3 = Promise.resolved(p2) |
| 314 p3.then(function(x) { assertAsync(x === 5, "then/resolve/thenable") }, assertU
nreachable) |
| 315 deferred.resolve(5) |
| 316 assertAsyncRan() |
| 317 })(); |
| 318 |
| 319 (function() { |
| 320 var deferred = Promise.deferred() |
| 321 var p1 = deferred.promise |
| 322 var p2 = {then: function(onResolve, onReject) { onResolve(p1) }} |
| 323 var p3 = Promise.resolved(p2) |
| 324 p3.when(function(x) { assertAsync(x === p2, "when/reject/thenable") }, assertU
nreachable) |
| 325 deferred.reject(5) |
| 326 assertAsyncRan() |
| 327 })(); |
| 328 |
| 329 (function() { |
| 330 var deferred = Promise.deferred() |
| 331 var p1 = deferred.promise |
| 332 var p2 = {then: function(onResolve, onReject) { onResolve(p1) }} |
| 333 var p3 = Promise.resolved(p2) |
| 334 p3.then(assertUnreachable, function(x) { assertAsync(x === 5, "then/reject/the
nable") }) |
| 335 deferred.reject(5) |
| 336 assertAsyncRan() |
| 337 })(); |
| 338 |
| 339 (function() { |
| 340 var p1 = Promise.resolved(5) |
| 341 var p2 = Promise.resolved(p1) |
| 342 var deferred = Promise.deferred() |
| 343 var p3 = deferred.promise |
| 344 p3.when(function(x) { assertAsync(x === p2, "when/resolve2") }, assertUnreacha
ble) |
| 345 deferred.resolve(p2) |
| 346 assertAsyncRan() |
| 347 })(); |
| 348 |
| 349 (function() { |
| 350 var p1 = Promise.resolved(5) |
| 351 var p2 = Promise.resolved(p1) |
| 352 var deferred = Promise.deferred() |
| 353 var p3 = deferred.promise |
| 354 p3.then(function(x) { assertAsync(x === 5, "then/resolve2") }, assertUnreachab
le) |
| 355 deferred.resolve(p2) |
| 356 assertAsyncRan() |
| 357 })(); |
| 358 |
| 359 (function() { |
| 360 var p1 = Promise.resolved(5) |
| 361 var p2 = Promise.resolved(p1) |
| 362 var deferred = Promise.deferred() |
| 363 var p3 = deferred.promise |
| 364 p3.when(assertUnreachable, function(x) { assertAsync(x === 5, "when/reject2")
}) |
| 365 deferred.reject(5) |
| 366 assertAsyncRan() |
| 367 })(); |
| 368 |
| 369 (function() { |
| 370 var p1 = Promise.resolved(5) |
| 371 var p2 = Promise.resolved(p1) |
| 372 var deferred = Promise.deferred() |
| 373 var p3 = deferred.promise |
| 374 p3.then(assertUnreachable, function(x) { assertAsync(x === 5, "then/reject2")
}) |
| 375 deferred.reject(5) |
| 376 assertAsyncRan() |
| 377 })(); |
| 378 |
| 379 (function() { |
| 380 var p1 = Promise.resolved(5) |
| 381 var p2 = {then: function(onResolve, onReject) { onResolve(p1) }} |
| 382 var deferred = Promise.deferred() |
| 383 var p3 = deferred.promise |
| 384 p3.when(function(x) { assertAsync(x === p2, "when/resolve/thenable2") }, asser
tUnreachable) |
| 385 deferred.resolve(p2) |
| 386 assertAsyncRan() |
| 387 })(); |
| 388 |
| 389 (function() { |
| 390 var p1 = Promise.resolved(5) |
| 391 var p2 = {then: function(onResolve, onReject) { onResolve(p1) }} |
| 392 var deferred = Promise.deferred() |
| 393 var p3 = deferred.promise |
| 394 p3.then(function(x) { assertAsync(x === 5, "then/resolve/thenable2") }, assert
Unreachable) |
| 395 deferred.resolve(p2) |
| 396 assertAsyncRan() |
| 397 })(); |
| 398 |
| 399 (function() { |
| 400 var p1 = Promise.resolved(0) |
| 401 var p2 = p1.when(function(x) { return p2 }, assertUnreachable) |
| 402 p2.when(assertUnreachable, |
| 403 function(r) { assertAsync(r instanceof TypeError, "cyclic/when") }) |
| 404 assertAsyncRan() |
| 405 })(); |
| 406 |
| 407 (function() { |
| 408 var p1 = Promise.resolved(0) |
| 409 var p2 = p1.then(function(x) { return p2 }, assertUnreachable) |
| 410 p2.when(assertUnreachable, |
| 411 function(r) { assertAsync(r instanceof TypeError, "cyclic/then") }) |
| 412 assertAsyncRan() |
| 413 })(); |
| 414 |
| 415 (function() { |
| 416 var deferred = Promise.deferred() |
| 417 var p = deferred.promise |
| 418 deferred.resolve(p) |
| 419 p.when(function(x) { assertAsync(x === p, "cyclic/deferred/when") }, assertUnr
eachable) |
| 420 assertAsyncRan() |
| 421 })(); |
| 422 |
| 423 (function() { |
| 424 var deferred = Promise.deferred() |
| 425 var p = deferred.promise |
| 426 deferred.resolve(p) |
| 427 p.then(assertUnreachable, |
| 428 function(r) { assertAsync(r instanceof TypeError, "cyclic/deferred/then") }) |
| 429 assertAsyncRan() |
| 430 })(); |
| 431 |
| 432 (function() { |
| 433 var deferred1 = Promise.deferred() |
| 434 var p1 = deferred1.promise |
| 435 var deferred2 = Promise.deferred() |
| 436 var p2 = deferred2.promise |
| 437 var deferred3 = Promise.deferred() |
| 438 var p3 = deferred3.promise |
| 439 Promise.all([p1, p2, p3]).when(function(x) { assertAsync(x === undefined, "all
/resolve") }, assertUnreachable) |
| 440 deferred1.resolve(1) |
| 441 deferred3.resolve(3) |
| 442 deferred2.resolve(2) |
| 443 assertAsyncRan() |
| 444 })(); |
| 445 |
| 446 (function() { |
| 447 var deferred = Promise.deferred() |
| 448 var p1 = deferred.promise |
| 449 var p2 = Promise.resolved(2) |
| 450 var p3 = Promise.deferred().promise |
| 451 Promise.all([p1, p2, p3]).when(assertUnreachable, assertUnreachable) |
| 452 deferred.resolve(1) |
| 453 })(); |
| 454 |
| 455 (function() { |
| 456 var deferred1 = Promise.deferred() |
| 457 var p1 = deferred1.promise |
| 458 var deferred2 = Promise.deferred() |
| 459 var p2 = deferred2.promise |
| 460 var deferred3 = Promise.deferred() |
| 461 var p3 = deferred3.promise |
| 462 Promise.all([p1, p2, p3]).when(assertUnreachable, function(x) { assertAsync(x
=== 2, "all/reject") }) |
| 463 deferred1.resolve(1) |
| 464 deferred3.resolve(3) |
| 465 deferred2.reject(2) |
| 466 assertAsyncRan() |
| 467 })(); |
| 468 |
| 469 (function() { |
| 470 var p1 = Promise.resolved(1) |
| 471 var p2 = Promise.resolved(2) |
| 472 var p3 = Promise.resolved(3) |
| 473 Promise.one([p1, p2, p3]).when(function(x) { assertAsync(x === 1, "resolved/al
l") }, assertUnreachable) |
| 474 assertAsyncRan() |
| 475 })(); |
| 476 |
| 477 (function() { |
| 478 var p1 = Promise.resolved(1) |
| 479 var p2 = Promise.resolved(2) |
| 480 var p3 = Promise.resolved(3) |
| 481 Promise.one([0, p1, p2, p3]).when(function(x) { assertAsync(x === 0, "resolved
-const/all") }, assertUnreachable) |
| 482 assertAsyncRan() |
| 483 })(); |
| 484 |
| 485 (function() { |
| 486 var deferred1 = Promise.deferred() |
| 487 var p1 = deferred1.promise |
| 488 var deferred2 = Promise.deferred() |
| 489 var p2 = deferred2.promise |
| 490 var deferred3 = Promise.deferred() |
| 491 var p3 = deferred3.promise |
| 492 Promise.one([p1, p2, p3]).when(function(x) { assertAsync(x === 3, "one/resolve
") }, assertUnreachable) |
| 493 deferred3.resolve(3) |
| 494 deferred1.resolve(1) |
| 495 assertAsyncRan() |
| 496 })(); |
| 497 |
| 498 (function() { |
| 499 var deferred = Promise.deferred() |
| 500 var p1 = deferred.promise |
| 501 var p2 = Promise.resolved(2) |
| 502 var p3 = Promise.deferred().promise |
| 503 Promise.one([p1, p2, p3]).when(function(x) { assertAsync(x === 2, "resolved/on
e") }, assertUnreachable) |
| 504 deferred.resolve(1) |
| 505 assertAsyncRan() |
| 506 })(); |
| 507 |
| 508 (function() { |
| 509 var deferred1 = Promise.deferred() |
| 510 var p1 = deferred1.promise |
| 511 var deferred2 = Promise.deferred() |
| 512 var p2 = deferred2.promise |
| 513 var deferred3 = Promise.deferred() |
| 514 var p3 = deferred3.promise |
| 515 Promise.one([p1, p2, p3]).when(function(x) { assertAsync(x === 3, "one/resolve
/reject") }, assertUnreachable) |
| 516 deferred3.resolve(3) |
| 517 deferred1.reject(1) |
| 518 assertAsyncRan() |
| 519 })(); |
| 520 |
| 521 (function() { |
| 522 var deferred1 = Promise.deferred() |
| 523 var p1 = deferred1.promise |
| 524 var deferred2 = Promise.deferred() |
| 525 var p2 = deferred2.promise |
| 526 var deferred3 = Promise.deferred() |
| 527 var p3 = deferred3.promise |
| 528 Promise.one([p1, p2, p3]).when(assertUnreachable, function(x) { assertAsync(x
=== 3, "one/reject/resolve") }) |
| 529 deferred3.reject(3) |
| 530 deferred1.resolve(1) |
| 531 assertAsyncRan() |
| 532 })(); |
| 533 |
| 534 (function() { |
| 535 var log |
| 536 function MyPromise(resolver) { |
| 537 log += "n" |
| 538 Promise.call(this, |
| 539 function(resolve, reject) { |
| 540 resolver( |
| 541 function(x) { log += "x" + x; resolve(x) }, |
| 542 function(r) { log += "r" + r; reject(r) } |
| 543 ) |
| 544 } |
| 545 ) |
| 546 } |
| 547 |
| 548 MyPromise.__proto__ = Promise |
| 549 MyPromise.deferred = function() { |
| 550 log += "d" |
| 551 return this.__proto__.deferred.call(this) |
| 552 } |
| 553 |
| 554 MyPromise.prototype.__proto__ = Promise.prototype |
| 555 MyPromise.prototype.when = function(resolve, reject) { |
| 556 log += "w" |
| 557 return this.__proto__.__proto__.when.call(this, resolve, reject) |
| 558 } |
| 559 |
| 560 log = "" |
| 561 var p1 = new MyPromise(function(resolve, reject) { resolve(1) }) |
| 562 var p2 = new MyPromise(function(resolve, reject) { reject(2) }) |
| 563 var d3 = MyPromise.deferred() |
| 564 assertTrue(d3.promise instanceof MyPromise, "subclass/instance3") |
| 565 assertTrue(log === "nx1nr2dn", "subclass/create") |
| 566 |
| 567 log = "" |
| 568 var p4 = MyPromise.resolved(4) |
| 569 var p5 = MyPromise.rejected(5) |
| 570 assertTrue(p4 instanceof MyPromise, "subclass/instance4") |
| 571 assertTrue(p5 instanceof MyPromise, "subclass/instance5") |
| 572 d3.resolve(3) |
| 573 assertTrue(log === "nx4nr5x3", "subclass/resolve") |
| 574 |
| 575 log = "" |
| 576 var d6 = MyPromise.deferred() |
| 577 d6.promise.when(function(x) { return new Promise(x) }).when(function() {}) |
| 578 d6.resolve(6) |
| 579 assertTrue(log === "dnwnwnx6", "subclass/when") |
| 580 |
| 581 log = "" |
| 582 Promise.all([11, Promise.resolved(12), 13, MyPromise.resolved(14), 15, 16]) |
| 583 assertTrue(log === "nx14wn", "subclass/all/arg") |
| 584 |
| 585 log = "" |
| 586 MyPromise.all([21, Promise.resolved(22), 23, MyPromise.resolved(24), 25, 26]) |
| 587 assertTrue(log === "nx24dnnx21wndnwnnx23wnwnnx25wnnx26wn", "subclass/all/self"
) |
| 588 })(); |
| 589 |
| 590 |
| 591 assertAsyncDone() |
OLD | NEW |