| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file | |
| 2 // for details. All rights reserved. Use of this source code is governed by a | |
| 3 // BSD-style license that can be found in the LICENSE file. | |
| 4 | |
| 5 /// Test data for the end2end test. | |
| 6 library test.end2end.data; | |
| 7 | |
| 8 import 'test_helper.dart'; | |
| 9 | |
| 10 class TestSpec extends TestSpecBase { | |
| 11 final String output; | |
| 12 | |
| 13 const TestSpec(String input, [String output]) | |
| 14 : this.output = output != null ? output : input, | |
| 15 super(input); | |
| 16 } | |
| 17 | |
| 18 const List<Group> TEST_DATA = const <Group>[ | |
| 19 const Group('Empty main', const <TestSpec>[ | |
| 20 const TestSpec(''' | |
| 21 main() {} | |
| 22 '''), | |
| 23 | |
| 24 const TestSpec(''' | |
| 25 main() {} | |
| 26 foo() {} | |
| 27 ''', ''' | |
| 28 main() {} | |
| 29 '''), | |
| 30 ]), | |
| 31 const Group('Simple call-chains', const <TestSpec>[ | |
| 32 const TestSpec(''' | |
| 33 foo() {} | |
| 34 main() { | |
| 35 foo(); | |
| 36 } | |
| 37 '''), | |
| 38 | |
| 39 const TestSpec(''' | |
| 40 bar() {} | |
| 41 foo() { | |
| 42 bar(); | |
| 43 } | |
| 44 main() { | |
| 45 foo(); | |
| 46 } | |
| 47 '''), | |
| 48 | |
| 49 const TestSpec(''' | |
| 50 bar() { | |
| 51 main(); | |
| 52 } | |
| 53 foo() { | |
| 54 bar(); | |
| 55 } | |
| 56 main() { | |
| 57 foo(); | |
| 58 } | |
| 59 '''), | |
| 60 | |
| 61 ]), | |
| 62 const Group('Literals', const <TestSpec>[ | |
| 63 const TestSpec(''' | |
| 64 main() { | |
| 65 return 0; | |
| 66 } | |
| 67 '''), | |
| 68 | |
| 69 const TestSpec(''' | |
| 70 main() { | |
| 71 return 1.5; | |
| 72 } | |
| 73 '''), | |
| 74 | |
| 75 const TestSpec(''' | |
| 76 main() { | |
| 77 return true; | |
| 78 } | |
| 79 '''), | |
| 80 | |
| 81 const TestSpec(''' | |
| 82 main() { | |
| 83 return false; | |
| 84 } | |
| 85 '''), | |
| 86 | |
| 87 const TestSpec(''' | |
| 88 main() { | |
| 89 return "a"; | |
| 90 } | |
| 91 '''), | |
| 92 | |
| 93 const TestSpec(''' | |
| 94 main() { | |
| 95 return "a" "b"; | |
| 96 } | |
| 97 ''', ''' | |
| 98 main() { | |
| 99 return "ab"; | |
| 100 } | |
| 101 '''), | |
| 102 ]), | |
| 103 | |
| 104 const Group('Parameters', const <TestSpec>[ | |
| 105 const TestSpec(''' | |
| 106 main(args) {} | |
| 107 '''), | |
| 108 | |
| 109 const TestSpec(''' | |
| 110 main(a, b) {} | |
| 111 '''), | |
| 112 ]), | |
| 113 | |
| 114 const Group('Typed parameters', const <TestSpec>[ | |
| 115 const TestSpec(''' | |
| 116 void main(args) {} | |
| 117 '''), | |
| 118 | |
| 119 const TestSpec(''' | |
| 120 main(int a, String b) {} | |
| 121 '''), | |
| 122 | |
| 123 const TestSpec(''' | |
| 124 main(Comparator a, List b) {} | |
| 125 '''), | |
| 126 | |
| 127 const TestSpec(''' | |
| 128 main(Comparator<dynamic> a, List<dynamic> b) {} | |
| 129 ''',''' | |
| 130 main(Comparator a, List b) {} | |
| 131 '''), | |
| 132 | |
| 133 const TestSpec(''' | |
| 134 main(Map a, Map<dynamic, List<int>> b) {} | |
| 135 '''), | |
| 136 ]), | |
| 137 | |
| 138 const Group('Pass arguments', const <TestSpec>[ | |
| 139 const TestSpec(''' | |
| 140 foo(a) {} | |
| 141 main() { | |
| 142 foo(null); | |
| 143 } | |
| 144 '''), | |
| 145 | |
| 146 const TestSpec(''' | |
| 147 bar(b, c) {} | |
| 148 foo(a) {} | |
| 149 main() { | |
| 150 foo(null); | |
| 151 bar(0, ""); | |
| 152 } | |
| 153 '''), | |
| 154 | |
| 155 const TestSpec(''' | |
| 156 bar(b) {} | |
| 157 foo(a) { | |
| 158 bar(a); | |
| 159 } | |
| 160 main() { | |
| 161 foo(null); | |
| 162 } | |
| 163 '''), | |
| 164 ]), | |
| 165 | |
| 166 const Group('Top level field', const <TestSpec>[ | |
| 167 const TestSpec(''' | |
| 168 var field; | |
| 169 main(args) { | |
| 170 return field; | |
| 171 } | |
| 172 '''), | |
| 173 | |
| 174 // TODO(johnniwinther): Eliminate unneeded `null` initializers. | |
| 175 const TestSpec(''' | |
| 176 var field = null; | |
| 177 main(args) { | |
| 178 return field; | |
| 179 } | |
| 180 '''), | |
| 181 | |
| 182 const TestSpec(''' | |
| 183 var field = 0; | |
| 184 main(args) { | |
| 185 return field; | |
| 186 } | |
| 187 '''), | |
| 188 | |
| 189 const TestSpec(''' | |
| 190 var field; | |
| 191 main(args) { | |
| 192 field = args.length; | |
| 193 return field; | |
| 194 } | |
| 195 '''), | |
| 196 ]), | |
| 197 | |
| 198 const Group('Local variables', const <TestSpec>[ | |
| 199 const TestSpec(''' | |
| 200 main() { | |
| 201 var a; | |
| 202 return a; | |
| 203 } | |
| 204 ''',''' | |
| 205 main() {} | |
| 206 '''), | |
| 207 | |
| 208 const TestSpec(''' | |
| 209 main() { | |
| 210 var a = 0; | |
| 211 return a; | |
| 212 } | |
| 213 ''',''' | |
| 214 main() { | |
| 215 return 0; | |
| 216 } | |
| 217 '''), | |
| 218 ]), | |
| 219 | |
| 220 const Group('Local variable writes', const <TestSpec>[ | |
| 221 const TestSpec(''' | |
| 222 main() { | |
| 223 var a; | |
| 224 a = 10; | |
| 225 return a; | |
| 226 } | |
| 227 ''', ''' | |
| 228 main() { | |
| 229 return 10; | |
| 230 } | |
| 231 '''), | |
| 232 | |
| 233 const TestSpec(''' | |
| 234 main() { | |
| 235 var a = 0; | |
| 236 a = 10; | |
| 237 return a; | |
| 238 } | |
| 239 ''', ''' | |
| 240 main() { | |
| 241 return 10; | |
| 242 } | |
| 243 '''), | |
| 244 | |
| 245 const TestSpec(''' | |
| 246 main() { | |
| 247 var a = 0; | |
| 248 print(a); | |
| 249 a = ""; | |
| 250 print(a); | |
| 251 return a; | |
| 252 } | |
| 253 ''', ''' | |
| 254 main() { | |
| 255 var a; | |
| 256 print(0); | |
| 257 a = ""; | |
| 258 print(a); | |
| 259 return a; | |
| 260 } | |
| 261 '''), | |
| 262 | |
| 263 const TestSpec(''' | |
| 264 main(a) { | |
| 265 print(a); | |
| 266 a = ""; | |
| 267 print(a); | |
| 268 return a; | |
| 269 } | |
| 270 '''), | |
| 271 | |
| 272 const TestSpec(''' | |
| 273 main(a) { | |
| 274 if (a) { | |
| 275 a = ""; | |
| 276 } | |
| 277 print(a); | |
| 278 return a; | |
| 279 } | |
| 280 ''', ''' | |
| 281 main(a) { | |
| 282 print(a = a ? "" : a); | |
| 283 return a; | |
| 284 } | |
| 285 '''), | |
| 286 ]), | |
| 287 | |
| 288 const Group('Dynamic access', const <TestSpec>[ | |
| 289 const TestSpec(''' | |
| 290 main(a) { | |
| 291 return a.foo; | |
| 292 } | |
| 293 '''), | |
| 294 | |
| 295 const TestSpec(''' | |
| 296 main() { | |
| 297 var a = ""; | |
| 298 return a.foo; | |
| 299 } | |
| 300 ''',''' | |
| 301 main() { | |
| 302 return "".foo; | |
| 303 } | |
| 304 '''), | |
| 305 ]), | |
| 306 | |
| 307 const Group('Dynamic invocation', const <TestSpec>[ | |
| 308 const TestSpec(''' | |
| 309 main(a) { | |
| 310 return a.foo(0); | |
| 311 } | |
| 312 '''), | |
| 313 | |
| 314 const TestSpec(''' | |
| 315 main() { | |
| 316 var a = ""; | |
| 317 return a.foo(0, 1); | |
| 318 } | |
| 319 ''',''' | |
| 320 main() { | |
| 321 return "".foo(0, 1); | |
| 322 } | |
| 323 '''), | |
| 324 ]), | |
| 325 | |
| 326 const Group('Binary expressions', const <TestSpec>[ | |
| 327 const TestSpec(''' | |
| 328 main(a, b) { | |
| 329 return a + b; | |
| 330 } | |
| 331 '''), | |
| 332 | |
| 333 const TestSpec(''' | |
| 334 main(a, b) { | |
| 335 return a - b; | |
| 336 } | |
| 337 '''), | |
| 338 | |
| 339 const TestSpec(''' | |
| 340 main(a, b) { | |
| 341 return a * b; | |
| 342 } | |
| 343 '''), | |
| 344 | |
| 345 const TestSpec(''' | |
| 346 main(a, b) { | |
| 347 return a / b; | |
| 348 } | |
| 349 '''), | |
| 350 | |
| 351 const TestSpec(''' | |
| 352 main(a, b) { | |
| 353 return a ~/ b; | |
| 354 } | |
| 355 '''), | |
| 356 | |
| 357 const TestSpec(''' | |
| 358 main(a, b) { | |
| 359 return a % b; | |
| 360 } | |
| 361 '''), | |
| 362 | |
| 363 const TestSpec(''' | |
| 364 main(a, b) { | |
| 365 return a < b; | |
| 366 } | |
| 367 '''), | |
| 368 | |
| 369 const TestSpec(''' | |
| 370 main(a, b) { | |
| 371 return a <= b; | |
| 372 } | |
| 373 '''), | |
| 374 | |
| 375 const TestSpec(''' | |
| 376 main(a, b) { | |
| 377 return a > b; | |
| 378 } | |
| 379 '''), | |
| 380 | |
| 381 const TestSpec(''' | |
| 382 main(a, b) { | |
| 383 return a >= b; | |
| 384 } | |
| 385 '''), | |
| 386 | |
| 387 const TestSpec(''' | |
| 388 main(a, b) { | |
| 389 return a << b; | |
| 390 } | |
| 391 '''), | |
| 392 | |
| 393 const TestSpec(''' | |
| 394 main(a, b) { | |
| 395 return a >> b; | |
| 396 } | |
| 397 '''), | |
| 398 | |
| 399 const TestSpec(''' | |
| 400 main(a, b) { | |
| 401 return a & b; | |
| 402 } | |
| 403 '''), | |
| 404 | |
| 405 const TestSpec(''' | |
| 406 main(a, b) { | |
| 407 return a | b; | |
| 408 } | |
| 409 '''), | |
| 410 | |
| 411 const TestSpec(''' | |
| 412 main(a, b) { | |
| 413 return a ^ b; | |
| 414 } | |
| 415 '''), | |
| 416 | |
| 417 const TestSpec(''' | |
| 418 main(a, b) { | |
| 419 return a == b; | |
| 420 } | |
| 421 '''), | |
| 422 | |
| 423 const TestSpec(''' | |
| 424 main(a, b) { | |
| 425 return a != b; | |
| 426 } | |
| 427 ''',''' | |
| 428 main(a, b) { | |
| 429 return !(a == b); | |
| 430 } | |
| 431 '''), | |
| 432 | |
| 433 const TestSpec(''' | |
| 434 main(a, b) { | |
| 435 return a && b; | |
| 436 } | |
| 437 '''), | |
| 438 | |
| 439 const TestSpec(''' | |
| 440 main(a, b) { | |
| 441 return a || b; | |
| 442 } | |
| 443 '''), | |
| 444 ]), | |
| 445 | |
| 446 const Group('If statement', const <TestSpec>[ | |
| 447 const TestSpec(''' | |
| 448 main(a) { | |
| 449 if (a) { | |
| 450 print(0); | |
| 451 } | |
| 452 } | |
| 453 '''), | |
| 454 | |
| 455 const TestSpec(''' | |
| 456 main(a) { | |
| 457 if (a) { | |
| 458 print(0); | |
| 459 } else { | |
| 460 print(1); | |
| 461 } | |
| 462 } | |
| 463 ''',''' | |
| 464 main(a) { | |
| 465 a ? print(0) : print(1); | |
| 466 } | |
| 467 '''), | |
| 468 | |
| 469 const TestSpec(''' | |
| 470 main(a) { | |
| 471 if (a) { | |
| 472 print(0); | |
| 473 } else { | |
| 474 print(1); | |
| 475 print(2); | |
| 476 } | |
| 477 } | |
| 478 '''), | |
| 479 ]), | |
| 480 | |
| 481 const Group('Conditional expression', const <TestSpec>[ | |
| 482 const TestSpec(''' | |
| 483 main(a) { | |
| 484 return a ? print(0) : print(1); | |
| 485 } | |
| 486 '''), | |
| 487 ]), | |
| 488 | |
| 489 // These test that unreachable statements are skipped within a block. | |
| 490 const Group('Block statements', const <TestSpec>[ | |
| 491 const TestSpec(''' | |
| 492 main(a) { | |
| 493 return 0; | |
| 494 return 1; | |
| 495 } | |
| 496 ''', ''' | |
| 497 main(a) { | |
| 498 return 0; | |
| 499 } | |
| 500 '''), | |
| 501 | |
| 502 const TestSpec(''' | |
| 503 main(a) { | |
| 504 if (a) { | |
| 505 return 0; | |
| 506 return 1; | |
| 507 } else { | |
| 508 return 2; | |
| 509 return 3; | |
| 510 } | |
| 511 } | |
| 512 ''', ''' | |
| 513 main(a) { | |
| 514 return a ? 0 : 2; | |
| 515 } | |
| 516 '''), | |
| 517 | |
| 518 const TestSpec(''' | |
| 519 main(a) { | |
| 520 if (a) { | |
| 521 print(0); | |
| 522 return 0; | |
| 523 return 1; | |
| 524 } else { | |
| 525 print(2); | |
| 526 return 2; | |
| 527 return 3; | |
| 528 } | |
| 529 } | |
| 530 ''', ''' | |
| 531 main(a) { | |
| 532 if (a) { | |
| 533 print(0); | |
| 534 return 0; | |
| 535 } else { | |
| 536 print(2); | |
| 537 return 2; | |
| 538 } | |
| 539 } | |
| 540 '''), | |
| 541 ]), | |
| 542 | |
| 543 const Group('List literal', const <TestSpec>[ | |
| 544 const TestSpec(''' | |
| 545 main() { | |
| 546 return []; | |
| 547 } | |
| 548 '''), | |
| 549 | |
| 550 const TestSpec(''' | |
| 551 main() { | |
| 552 return <int>[]; | |
| 553 } | |
| 554 '''), | |
| 555 | |
| 556 const TestSpec(''' | |
| 557 main() { | |
| 558 return <int>[0]; | |
| 559 } | |
| 560 '''), | |
| 561 | |
| 562 const TestSpec(''' | |
| 563 main(a) { | |
| 564 return <int>[0, 1, a]; | |
| 565 } | |
| 566 '''), | |
| 567 | |
| 568 const TestSpec(''' | |
| 569 main(a) { | |
| 570 return [0, [1], [a, <int>[3]]]; | |
| 571 } | |
| 572 '''), | |
| 573 ]), | |
| 574 | |
| 575 const Group('Constructor invocation', const <TestSpec>[ | |
| 576 const TestSpec(''' | |
| 577 main(a) { | |
| 578 new Object(); | |
| 579 } | |
| 580 '''), | |
| 581 | |
| 582 const TestSpec(''' | |
| 583 main(a) { | |
| 584 new Deprecated(""); | |
| 585 } | |
| 586 '''), | |
| 587 ]), | |
| 588 | |
| 589 const Group('Map literal', const <TestSpec>[ | |
| 590 const TestSpec(''' | |
| 591 main() { | |
| 592 return {}; | |
| 593 } | |
| 594 '''), | |
| 595 | |
| 596 const TestSpec(''' | |
| 597 main() { | |
| 598 return <int, String>{}; | |
| 599 } | |
| 600 '''), | |
| 601 | |
| 602 const TestSpec(''' | |
| 603 main() { | |
| 604 return <String, int>{"a": 0}; | |
| 605 } | |
| 606 '''), | |
| 607 | |
| 608 const TestSpec(''' | |
| 609 main(a) { | |
| 610 return <String, int>{"a": 0, "b": 1, "c": a}; | |
| 611 } | |
| 612 '''), | |
| 613 | |
| 614 const TestSpec(''' | |
| 615 main(a) { | |
| 616 return {0: "a", 1: {2: "b"}, a: {3: "c"}}; | |
| 617 } | |
| 618 '''), | |
| 619 ]), | |
| 620 const Group('For loop', const <TestSpec>[ | |
| 621 const TestSpec(''' | |
| 622 main() { | |
| 623 for (;;) {} | |
| 624 } | |
| 625 ''', ''' | |
| 626 main() { | |
| 627 while (true) {} | |
| 628 } | |
| 629 '''), | |
| 630 | |
| 631 const TestSpec(''' | |
| 632 main() { | |
| 633 for (var i = 0; i < 10; i = i + 1) { | |
| 634 print(i); | |
| 635 } | |
| 636 } | |
| 637 ''', ''' | |
| 638 main() { | |
| 639 var i = 0; | |
| 640 while (i < 10) { | |
| 641 print(i); | |
| 642 ++i; | |
| 643 } | |
| 644 } | |
| 645 '''), | |
| 646 | |
| 647 const TestSpec(''' | |
| 648 main(i) { | |
| 649 for (i = 0; i < 10; i = i + 1) { | |
| 650 print(i); | |
| 651 } | |
| 652 } | |
| 653 ''', ''' | |
| 654 main(i) { | |
| 655 i = 0; | |
| 656 while (i < 10) { | |
| 657 print(i); | |
| 658 ++i; | |
| 659 } | |
| 660 } | |
| 661 '''), | |
| 662 ]), | |
| 663 | |
| 664 const Group('While loop', const <TestSpec>[ | |
| 665 const TestSpec(''' | |
| 666 main() { | |
| 667 while (true) {} | |
| 668 } | |
| 669 '''), | |
| 670 | |
| 671 const TestSpec(''' | |
| 672 main() { | |
| 673 var i = 0; | |
| 674 while (i < 10) { | |
| 675 print(i); | |
| 676 i = i + 1; | |
| 677 } | |
| 678 }''', ''' | |
| 679 main() { | |
| 680 var i = 0; | |
| 681 while (i < 10) { | |
| 682 print(i); | |
| 683 ++i; | |
| 684 } | |
| 685 }'''), | |
| 686 ]), | |
| 687 | |
| 688 const Group('Type operators', const <TestSpec>[ | |
| 689 const TestSpec(''' | |
| 690 main(a) { | |
| 691 return a is String; | |
| 692 } | |
| 693 '''), | |
| 694 | |
| 695 const TestSpec(''' | |
| 696 main(a) { | |
| 697 return a is List<String>; | |
| 698 } | |
| 699 '''), | |
| 700 | |
| 701 const TestSpec(''' | |
| 702 main(a) { | |
| 703 return a is Comparator<String>; | |
| 704 } | |
| 705 '''), | |
| 706 | |
| 707 const TestSpec(''' | |
| 708 main(a) { | |
| 709 return a is! String; | |
| 710 } | |
| 711 ''', ''' | |
| 712 main(a) { | |
| 713 return !(a is String); | |
| 714 } | |
| 715 '''), | |
| 716 | |
| 717 const TestSpec(''' | |
| 718 main(a) { | |
| 719 return a as String; | |
| 720 } | |
| 721 '''), | |
| 722 ]), | |
| 723 | |
| 724 const Group('For in loop', const <TestSpec>[ | |
| 725 // TODO(johnniwinther): Add tests for `i` as top-level, static and instance | |
| 726 // fields. | |
| 727 const TestSpec(''' | |
| 728 main(a) { | |
| 729 for (var i in a) { | |
| 730 print(i); | |
| 731 } | |
| 732 } | |
| 733 ''', ''' | |
| 734 main(a) { | |
| 735 var v0 = a.iterator; | |
| 736 while (v0.moveNext()) { | |
| 737 print(v0.current); | |
| 738 } | |
| 739 }'''), | |
| 740 | |
| 741 const TestSpec(''' | |
| 742 main(a) { | |
| 743 for (var i in a) { | |
| 744 print(i); | |
| 745 i = 0; | |
| 746 print(i); | |
| 747 } | |
| 748 } | |
| 749 ''', ''' | |
| 750 main(a) { | |
| 751 var v0 = a.iterator; | |
| 752 while (v0.moveNext()) { | |
| 753 print(v0.current); | |
| 754 print(0); | |
| 755 } | |
| 756 } | |
| 757 '''), | |
| 758 | |
| 759 const TestSpec(''' | |
| 760 main(a) { | |
| 761 var i; | |
| 762 for (i in a) { | |
| 763 print(i); | |
| 764 } | |
| 765 } | |
| 766 ''', ''' | |
| 767 main(a) { | |
| 768 var v0 = a.iterator; | |
| 769 while (v0.moveNext()) { | |
| 770 print(v0.current); | |
| 771 } | |
| 772 } | |
| 773 '''), | |
| 774 ]), | |
| 775 | |
| 776 const Group('Local functions', const <TestSpec>[ | |
| 777 const TestSpec(''' | |
| 778 main(a) { | |
| 779 local() {} | |
| 780 return local(); | |
| 781 } | |
| 782 ''', ''' | |
| 783 main(a) { | |
| 784 return (() {})(); | |
| 785 } | |
| 786 '''), | |
| 787 | |
| 788 const TestSpec(''' | |
| 789 main(a) { | |
| 790 local() {} | |
| 791 var l = local; | |
| 792 return l(); | |
| 793 } | |
| 794 ''', ''' | |
| 795 main(a) { | |
| 796 return (() {})(); | |
| 797 } | |
| 798 '''), | |
| 799 | |
| 800 const TestSpec(''' | |
| 801 main(a) { | |
| 802 return () {}(); | |
| 803 } | |
| 804 ''', ''' | |
| 805 main(a) { | |
| 806 return (() {})(); | |
| 807 } | |
| 808 '''), | |
| 809 | |
| 810 const TestSpec(''' | |
| 811 main(a) { | |
| 812 var c = a ? () { return 0; } : () { return 1; }; | |
| 813 return c(); | |
| 814 } | |
| 815 ''', ''' | |
| 816 main(a) { | |
| 817 return (a ? () { | |
| 818 return 0; | |
| 819 } : () { | |
| 820 return 1; | |
| 821 })(); | |
| 822 } | |
| 823 '''), | |
| 824 ]), | |
| 825 | |
| 826 const Group('Constructors', const <TestSpec>[ | |
| 827 const TestSpec(''' | |
| 828 class C {} | |
| 829 main() { | |
| 830 return new C(); | |
| 831 } | |
| 832 '''), | |
| 833 | |
| 834 const TestSpec(''' | |
| 835 class C { | |
| 836 C() {} | |
| 837 } | |
| 838 main() { | |
| 839 return new C(); | |
| 840 } | |
| 841 '''), | |
| 842 | |
| 843 const TestSpec(''' | |
| 844 class B {} | |
| 845 class C extends B { | |
| 846 C() {} | |
| 847 } | |
| 848 main() { | |
| 849 return new C(); | |
| 850 } | |
| 851 '''), | |
| 852 | |
| 853 const TestSpec(''' | |
| 854 class B { | |
| 855 B() {} | |
| 856 } | |
| 857 class C extends B {} | |
| 858 main() { | |
| 859 return new C(); | |
| 860 } | |
| 861 '''), | |
| 862 ]), | |
| 863 | |
| 864 const Group('Instance method', const <TestSpec>[ | |
| 865 const TestSpec(''' | |
| 866 class C { | |
| 867 C() {} | |
| 868 foo() {} | |
| 869 } | |
| 870 main() { | |
| 871 return new C().foo(); | |
| 872 } | |
| 873 '''), | |
| 874 ]), | |
| 875 | |
| 876 const Group('Try-catch', const <TestSpec>[ | |
| 877 const TestSpec(''' | |
| 878 main() { | |
| 879 try {} catch (e) {} | |
| 880 } | |
| 881 ''', | |
| 882 // TODO(kmillikin): Remove the unused stack trace parameter. | |
| 883 ''' | |
| 884 main() { | |
| 885 try {} catch (e, v0) {} | |
| 886 } | |
| 887 '''), | |
| 888 | |
| 889 const TestSpec(''' | |
| 890 main() { | |
| 891 try { | |
| 892 return; | |
| 893 } catch (e) {} | |
| 894 } | |
| 895 ''', | |
| 896 // TODO(kmillikin): Remove the unused stack trace parameter and unneeded return | |
| 897 // statement(s). | |
| 898 ''' | |
| 899 main() { | |
| 900 try { | |
| 901 return null; | |
| 902 } catch (e, v0) { | |
| 903 return null; | |
| 904 } | |
| 905 } | |
| 906 '''), | |
| 907 ]), | |
| 908 ]; | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2037123002:
Cleanup: remove package "analyzer2dart". (Closed)
Base URL: git@github.com:dart-lang/sdk.git@master