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