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 |