OLD | NEW |
1 // Copyright 2016 the V8 project authors. All rights reserved. | 1 // Copyright 2016 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
| 5 // Flags: --ignition-generators --harmony-do-expressions |
| 6 |
5 | 7 |
6 { // yield in try-catch | 8 { // yield in try-catch |
7 | 9 |
8 let g = function*() { | 10 let g = function*() { |
9 try {yield 1} catch (error) {assertEquals("caught", error)} | 11 try {yield 1} catch (error) {assertEquals("caught", error)} |
10 }; | 12 }; |
11 | 13 |
12 assertThrowsEquals(() => g().throw("not caught"), "not caught"); | 14 assertThrowsEquals(() => g().throw("not caught"), "not caught"); |
13 | 15 |
14 { | 16 { |
(...skipping 248 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
263 return yield* inner(); | 265 return yield* inner(); |
264 } | 266 } |
265 | 267 |
266 { | 268 { |
267 let x = g(); | 269 let x = g(); |
268 assertEquals({value: 1, done: false}, x.next()); | 270 assertEquals({value: 1, done: false}, x.next()); |
269 assertEquals({value: 2, done: false}, x.next()); | 271 assertEquals({value: 2, done: false}, x.next()); |
270 assertEquals({value: 42, done: true}, x.return(42)); | 272 assertEquals({value: 42, done: true}, x.return(42)); |
271 } | 273 } |
272 } | 274 } |
| 275 |
| 276 |
| 277 // More or less random tests from here on. |
| 278 |
| 279 |
| 280 { |
| 281 function* foo() { } |
| 282 let g = foo(); |
| 283 assertEquals({value: undefined, done: true}, g.next()); |
| 284 assertEquals({value: undefined, done: true}, g.next()); |
| 285 } |
| 286 |
| 287 { |
| 288 function* foo() { return new.target } |
| 289 let g = foo(); |
| 290 assertEquals({value: undefined, done: true}, g.next()); |
| 291 assertEquals({value: undefined, done: true}, g.next()); |
| 292 } |
| 293 |
| 294 { |
| 295 function* foo() { throw 666; return 42} |
| 296 let g = foo(); |
| 297 assertThrowsEquals(() => g.next(), 666); |
| 298 assertEquals({value: undefined, done: true}, g.next()); |
| 299 } |
| 300 |
| 301 { |
| 302 function* foo(a) { return a; } |
| 303 let g = foo(42); |
| 304 assertEquals({value: 42, done: true}, g.next()); |
| 305 assertEquals({value: undefined, done: true}, g.next()); |
| 306 } |
| 307 |
| 308 { |
| 309 function* foo(a) { a.iwashere = true; return a; } |
| 310 let x = {}; |
| 311 let g = foo(x); |
| 312 assertEquals({value: {iwashere: true}, done: true}, g.next()); |
| 313 assertEquals({value: undefined, done: true}, g.next()); |
| 314 } |
| 315 |
| 316 { |
| 317 let a = 42; |
| 318 function* foo() { return a; } |
| 319 let g = foo(); |
| 320 assertEquals({value: 42, done: true}, g.next()); |
| 321 assertEquals({value: undefined, done: true}, g.next()); |
| 322 } |
| 323 |
| 324 { |
| 325 let a = 40; |
| 326 function* foo(b) { return a + b; } |
| 327 let g = foo(2); |
| 328 assertEquals({value: 42, done: true}, g.next()); |
| 329 assertEquals({value: undefined, done: true}, g.next()); |
| 330 } |
| 331 |
| 332 { |
| 333 let a = 40; |
| 334 function* foo(b) { a--; b++; return a + b; } |
| 335 let g = foo(2); |
| 336 assertEquals({value: 42, done: true}, g.next()); |
| 337 assertEquals({value: undefined, done: true}, g.next()); |
| 338 } |
| 339 |
| 340 { |
| 341 let g; |
| 342 function* foo() { g.next() } |
| 343 g = foo(); |
| 344 assertThrows(() => g.next(), TypeError); |
| 345 assertEquals({value: undefined, done: true}, g.next()); |
| 346 } |
| 347 |
| 348 { |
| 349 function* foo() { yield 2; yield 3; yield 4 } |
| 350 g = foo(); |
| 351 assertEquals({value: 2, done: false}, g.next()); |
| 352 assertEquals({value: 3, done: false}, g.next()); |
| 353 assertEquals({value: 4, done: false}, g.next()); |
| 354 assertEquals({value: undefined, done: true}, g.next()); |
| 355 assertEquals({value: undefined, done: true}, g.next()); |
| 356 } |
| 357 |
| 358 { |
| 359 function* foo() { yield 2; if (true) { yield 3 }; yield 4 } |
| 360 g = foo(); |
| 361 assertEquals({value: 2, done: false}, g.next()); |
| 362 assertEquals({value: 3, done: false}, g.next()); |
| 363 assertEquals({value: 4, done: false}, g.next()); |
| 364 assertEquals({value: undefined, done: true}, g.next()); |
| 365 assertEquals({value: undefined, done: true}, g.next()); |
| 366 } |
| 367 |
| 368 { |
| 369 function* foo() { yield 2; if (true) { yield 3; yield 4 } } |
| 370 g = foo(); |
| 371 assertEquals({value: 2, done: false}, g.next()); |
| 372 assertEquals({value: 3, done: false}, g.next()); |
| 373 assertEquals({value: 4, done: false}, g.next()); |
| 374 assertEquals({value: undefined, done: true}, g.next()); |
| 375 assertEquals({value: undefined, done: true}, g.next()); |
| 376 } |
| 377 |
| 378 { |
| 379 function* foo() { yield 2; if (false) { yield 3 }; yield 4 } |
| 380 g = foo(); |
| 381 assertEquals({value: 2, done: false}, g.next()); |
| 382 assertEquals({value: 4, done: false}, g.next()); |
| 383 assertEquals({value: undefined, done: true}, g.next()); |
| 384 assertEquals({value: undefined, done: true}, g.next()); |
| 385 } |
| 386 |
| 387 { |
| 388 function* foo() { yield 2; while (true) { yield 3 }; yield 4 } |
| 389 g = foo(); |
| 390 assertEquals({value: 2, done: false}, g.next()); |
| 391 assertEquals({value: 3, done: false}, g.next()); |
| 392 assertEquals({value: 3, done: false}, g.next()); |
| 393 assertEquals({value: 3, done: false}, g.next()); |
| 394 assertEquals({value: 3, done: false}, g.next()); |
| 395 } |
| 396 |
| 397 { |
| 398 function* foo() { yield 2; (yield 3) + 42; yield 4 } |
| 399 g = foo(); |
| 400 assertEquals({value: 2, done: false}, g.next()); |
| 401 assertEquals({value: 3, done: false}, g.next()); |
| 402 assertEquals({value: 4, done: false}, g.next()); |
| 403 } |
| 404 |
| 405 { |
| 406 function* foo() { yield 2; (do {yield 3}) + 42; yield 4 } |
| 407 g = foo(); |
| 408 assertEquals({value: 2, done: false}, g.next()); |
| 409 assertEquals({value: 3, done: false}, g.next()); |
| 410 assertEquals({value: 4, done: false}, g.next()); |
| 411 } |
| 412 |
| 413 { |
| 414 function* foo() { yield 2; return (yield 3) + 42; yield 4 } |
| 415 g = foo(); |
| 416 assertEquals({value: 2, done: false}, g.next()); |
| 417 assertEquals({value: 3, done: false}, g.next()); |
| 418 assertEquals({value: 42, done: true}, g.next(0)); |
| 419 assertEquals({value: undefined, done: true}, g.next()); |
| 420 } |
| 421 |
| 422 { |
| 423 let x = 42; |
| 424 function* foo() { |
| 425 yield x; |
| 426 for (let x in {a: 1, b: 2}) { |
| 427 let i = 2; |
| 428 yield x; |
| 429 yield i; |
| 430 do { |
| 431 yield i; |
| 432 } while (i-- > 0); |
| 433 } |
| 434 yield x; |
| 435 return 5; |
| 436 } |
| 437 g = foo(); |
| 438 assertEquals({value: 42, done: false}, g.next()); |
| 439 assertEquals({value: 'a', done: false}, g.next()); |
| 440 assertEquals({value: 2, done: false}, g.next()); |
| 441 assertEquals({value: 2, done: false}, g.next()); |
| 442 assertEquals({value: 1, done: false}, g.next()); |
| 443 assertEquals({value: 0, done: false}, g.next()); |
| 444 assertEquals({value: 'b', done: false}, g.next()); |
| 445 assertEquals({value: 2, done: false}, g.next()); |
| 446 assertEquals({value: 2, done: false}, g.next()); |
| 447 assertEquals({value: 1, done: false}, g.next()); |
| 448 assertEquals({value: 0, done: false}, g.next()); |
| 449 assertEquals({value: 42, done: false}, g.next()); |
| 450 assertEquals({value: 5, done: true}, g.next()); |
| 451 } |
| 452 |
| 453 { |
| 454 let a = 3; |
| 455 function* foo() { |
| 456 let b = 4; |
| 457 yield 1; |
| 458 { let c = 5; yield 2; yield a; yield b; yield c; } |
| 459 } |
| 460 g = foo(); |
| 461 assertEquals({value: 1, done: false}, g.next()); |
| 462 assertEquals({value: 2, done: false}, g.next()); |
| 463 assertEquals({value: 3, done: false}, g.next()); |
| 464 assertEquals({value: 4, done: false}, g.next()); |
| 465 assertEquals({value: 5, done: false}, g.next()); |
| 466 assertEquals({value: undefined, done: true}, g.next()); |
| 467 } |
| 468 |
| 469 { |
| 470 function* foo() { |
| 471 yield 42; |
| 472 yield 42; |
| 473 yield 42; |
| 474 yield 42; |
| 475 yield 42; |
| 476 yield 42; |
| 477 yield 42; |
| 478 yield 42; |
| 479 yield 42; |
| 480 yield 42; |
| 481 yield 42; |
| 482 yield 42; |
| 483 yield 42; |
| 484 yield 42; |
| 485 yield 42; |
| 486 yield 42; |
| 487 yield 42; |
| 488 yield 42; |
| 489 yield 42; |
| 490 yield 42; |
| 491 yield 42; |
| 492 yield 42; |
| 493 yield 42; |
| 494 yield 42; |
| 495 yield 42; |
| 496 yield 42; |
| 497 yield 42; |
| 498 yield 42; |
| 499 yield 42; |
| 500 yield 42; |
| 501 yield 42; |
| 502 yield 42; |
| 503 yield 42; |
| 504 yield 42; |
| 505 yield 42; |
| 506 yield 42; |
| 507 yield 42; |
| 508 yield 42; |
| 509 yield 42; |
| 510 yield 42; |
| 511 yield 42; |
| 512 yield 42; |
| 513 yield 42; |
| 514 yield 42; |
| 515 yield 42; |
| 516 yield 42; |
| 517 yield 42; |
| 518 yield 42; |
| 519 yield 42; |
| 520 yield 42; |
| 521 yield 42; |
| 522 yield 42; |
| 523 yield 42; |
| 524 yield 42; |
| 525 yield 42; |
| 526 yield 42; |
| 527 yield 42; |
| 528 yield 42; |
| 529 yield 42; |
| 530 yield 42; |
| 531 yield 42; |
| 532 yield 42; |
| 533 yield 42; |
| 534 yield 42; |
| 535 yield 42; |
| 536 yield 42; |
| 537 yield 42; |
| 538 yield 42; |
| 539 yield 42; |
| 540 yield 42; |
| 541 yield 42; |
| 542 yield 42; |
| 543 yield 42; |
| 544 yield 42; |
| 545 yield 42; |
| 546 yield 42; |
| 547 yield 42; |
| 548 yield 42; |
| 549 yield 42; |
| 550 yield 42; |
| 551 yield 42; |
| 552 yield 42; |
| 553 yield 42; |
| 554 yield 42; |
| 555 yield 42; |
| 556 yield 42; |
| 557 yield 42; |
| 558 yield 42; |
| 559 yield 42; |
| 560 yield 42; |
| 561 yield 42; |
| 562 yield 42; |
| 563 yield 42; |
| 564 yield 42; |
| 565 yield 42; |
| 566 yield 42; |
| 567 yield 42; |
| 568 yield 42; |
| 569 yield 42; |
| 570 yield 42; |
| 571 } |
| 572 g = foo(); |
| 573 for (let i = 0; i < 100; ++i) { |
| 574 assertEquals({value: 42, done: false}, g.next()); |
| 575 } |
| 576 assertEquals({value: undefined, done: true}, g.next()); |
| 577 } |
OLD | NEW |