1 // RUNNABLE_PHOBOS_TEST
2 // REQUIRED_ARGS:
3
4 extern(C) int printf(const char*, ...);
5 extern(C) size_t strlen(const char*);
6
7 /**************************************/
8
9 alias strlen foo1;
10
test1()11 void test1()
12 {
13 const(char) *p = "bar";
14 size_t i = foo1(p);
15 assert(i == 3);
16 }
17
18 /**************************************/
19
Foo2(T)20 template Foo2(T)
21 {
22 alias T t;
23 }
24
25 alias Foo2!(int) t1;
26 alias Foo2!(int).t t2;
27 alias t1.t t3;
28 alias t2 t4;
29 alias Foo2!(int) t5;
30
test2()31 void test2()
32 {
33 t1.t v1;
34 t2 v2;
35 t3 v3;
36 t4 v4;
37 t5.t v5;
38 int *p;
39
40 p = &v1;
41 p = &v2;
42 p = &v3;
43 p = &v4;
44 p = &v5;
45 }
46
47
48 /**************************************/
49
50 debug = stdchar;
51
debug(mychar)52 debug(mychar)
53 {
54 alias byte mychar;
55 }
56
test3()57 void test3()
58 {
59 debug(mychar)
60 {
61 mychar[] line=cast(mychar[])cast(char[])"It is a long line.";
62 mychar[] delimiter=cast(mychar[])cast(string)"is";
63 }
64
65 debug(stdchar)
66 {
67 string line="It is a long line.";
68 string delimiter="is";
69 }
70
71 debug(stdbyte)
72 {
73 byte[] line=cast(byte[])cast(string)"It is a long line.";
74 byte[] delimiter=cast(byte[])cast(string)"is";
75 }
76
77 debug(stdwchar)
78 {
79 wstring line="It is a long line.";
80 wstring delimiter="is";
81 }
82 int ptr=3;
83
84 size_t dl=delimiter.length;
85 size_t pl=ptr+dl;
86
87 assert(line[ptr..pl]==delimiter[]);
88 }
89
90
91 /**************************************/
92
test4()93 void test4()
94 {
95 byte* p;
96
97 version(D_LP64)
98 assert(p.sizeof == 8);
99 else
100 assert(p.sizeof == 4);
101 }
102
103
104 /**************************************/
105
106
107 class Foo6
108 {
109 }
110
test6()111 void test6()
112 {
113 Foo6 foo = new Foo6();
114
115 with (foo)
116 {
117 int x;
118
119 x = 4;
120 }
121 }
122
123 /**************************************/
124
125 int i7 = 3;
126
test7()127 void test7()
128 {
129 switch (i7)
130 {
131 default: assert(0);
132 case 3:
133 int x;
134
135 x = 4;
136 }
137 }
138
139 /**************************************/
140
test8()141 void test8()
142 {
143 string a = "a
144 b
145 c";
146 assert(a.length == 5);
147 assert(a[1] == '\n');
148 }
149
150 /**************************************/
151
152
barFoo9153 struct Foo9 { char c; char bar() { return c; } }
154
makeFoo()155 Foo9 makeFoo() { Foo9 f; return f; }
156
callFoo(Foo9 a)157 void callFoo (Foo9 a)
158 {
159 a.bar();
160 }
161
test9()162 void test9()
163 {
164 callFoo(makeFoo ());
165 }
166
167 /**************************************/
168
169
170 struct Foo10 { }
171
makeFoo10()172 Foo10 makeFoo10() { Foo10 f; return f; }
173
callFoo(Foo10 a)174 void callFoo (Foo10 a)
175 {
176 }
177
test10()178 void test10()
179 {
180 callFoo(makeFoo10());
181 }
182
183 /**************************************/
184
185 struct Color
186 { int x; }
187
188 Color[3] colors;
189
eval(float x,float y)190 Color eval(float x, float y)
191 {
192 colors[1].x = 7;
193 return colors[1];
194 }
195
test11()196 void test11()
197 {
198 Color c;
199
200 c = eval(1.0, 2.0);
201 assert(c.x == 7);
202 }
203
204 /**************************************/
205
206 struct Size12
207 {
208 int width;
209 int height;
210 }
211
212 int x12;
213
foo12(out Size12 sz)214 void foo12(out Size12 sz)
215 {
216 sz.width = 2;
217
218 if(sz.width == 2)
219 x12 = 1;
220 }
221
222
test12()223 void test12()
224 {
225 Size12 sz;
226
227 foo12(sz);
228 assert(x12 == 1);
229 assert(sz.width == 2);
230 }
231
232 /**************************************/
233
234
235 interface D13
236 {
237 void setHostFrame();
238 }
239
240 class A13 : D13
241 {
setHostFrame()242 void setHostFrame()
243 {
244 }
245
246 char group;
247 }
248
249
setLayout(D13 lo)250 void setLayout(D13 lo)
251 {
252 printf("lo = %p\n", lo);
253 lo.setHostFrame();
254 printf("ok\n");
255 }
256
257
test13()258 void test13()
259 {
260 A13 a = new A13();
261 printf("a = %p\n", a);
262 setLayout(a);
263 }
264
265 /**************************************/
266
test14()267 void test14()
268 {
269 while(false)
270 {
271 static int a;
272 }
273 }
274
275
276 /**************************************/
277
278 alias void delegate(int) t_func;
279
280 class Foo15
281 {
282 t_func func1;
283 int x;
284
dothis()285 void dothis()
286 {
287 if (func1)
288 func1(4);
289 else
290 x = 3;
291 }
292
func(int num)293 void func(int num) { x = num; }
294 }
295
test15()296 void test15()
297 {
298 Foo15 a = new Foo15;
299 a.dothis();
300 assert(a.x == 3);
301 a.func1 = &a.func;
302 a.dothis();
303 assert(a.x == 4);
304 }
305
306
307 /**************************************/
308
foo16(byte[]a)309 int[] foo16(byte[] a)
310 {
311 return cast(int[])a;
312 }
313
test16()314 void test16()
315 {
316 byte[12] b;
317 int[] i;
318
319 i = foo16(b);
320 assert(i.length == 3);
321 }
322
323 /**************************************/
324
test17()325 void test17()
326 {
327 {
328 float x = 10;
329 x %= 4;
330 printf("x = %g\n", x);
331 assert(x == 2);
332 x = 10;
333 x = x % 4;
334 printf("x = %g\n", x);
335 assert(x == 2);
336 x = 4;
337 x = 10 % x;
338 printf("x = %g\n", x);
339 assert(x == 2);
340 }
341 {
342 double y = 10;
343 y %= 4;
344 printf("y = %g\n", y);
345 assert(y == 2);
346 y = 10;
347 y = y % 4;
348 printf("y = %g\n", y);
349 assert(y == 2);
350 y = 4;
351 y = 10 % y;
352 printf("y = %g\n", y);
353 assert(y == 2);
354 }
355 {
356 real z = 10;
357 z %= 4;
358 printf("z = %Lg\n", z);
359 assert(z == 2);
360 z = 10;
361 z = z % 4;
362 printf("z = %Lg\n", z);
363 assert(z == 2);
364 z = 4;
365 z = 10 % z;
366 printf("z = %Lg\n", z);
367 assert(z == 2);
368 }
369 }
370
371
372 /**************************************/
373
374 struct Bar18 { }
375
376 struct Foo18
377 {
378 static Bar18 x = { };
379 }
380
test18()381 void test18()
382 {
383 const Bar18 b = Foo18.x;
384 }
385
386
387 /**************************************/
388
389 int x19 = 10;
390
test19()391 void test19()
392 { bool b;
393
394 b = cast(bool)x19;
395 assert(b == true);
396 }
397
398 /**************************************/
399
400 class A20
401 {
abc()402 int abc() { return 3; }
403
404 alias abc def;
405 }
406
test20()407 void test20()
408 {
409 int i;
410 A20 a = new A20();
411
412 i = a.def();
413 assert(i == 3);
414 }
415
416
417 /**************************************/
418
test21()419 void test21()
420 {
421 string s;
422 s = 1 ? "a" : "b";
423 assert(s == "a");
424 }
425
426 /**************************************/
427
428 class Foo22
429 {
430 }
431
432 class Bar22 : Foo22
433 {
434 }
435
436 class Abc22
437 {
test()438 Foo22 test() { return null; }
439 }
440
441 class Def22 : Abc22
442 {
test()443 override Bar22 test() { return new Bar22; }
444 }
445
testx22(Abc22 a)446 void testx22(Abc22 a)
447 {
448 assert(a.test() !is null);
449 }
450
test22()451 void test22()
452 {
453 Def22 d = new Def22();
454
455 testx22(d);
456 }
457
458 /**************************************/
459
460 struct foo23
461 {
462 static struct bar
463 {
464 int x;
465 }
466 }
467
468 void test23()
469 {
470 //printf ("%d\n", foo23.bar.sizeof);
471 assert(foo23.bar.sizeof == int.sizeof);
472 }
473
474
475 /**************************************/
476
477 void test24()
478 {
479 struct Test
480 {
481 int i;
482
483 bool bar(int a)
484 {
485 i = a;
486 return true;
487 }
488 }
489
490 Test t;
491 assert(t.bar(3));
492 }
493
494
495 /**************************************/
496
497 void test25()
498 {
499 { const int [] list = [ 1, 2 ];
500 assert(list[0] == 1);
501 assert(list[1] == 2);
502 }
503
504 { const int [] list = [ 3, 4 ];
505 assert(list[0] == 3);
506 assert(list[1] == 4);
507 }
508 }
509
510
511 /**************************************/
512
513 void test26()
514 {
515 while (0)
516 {
517 int x;
518 }
519
520 while (0)
521 {
522 int x;
523 }
524 }
525
526
527 /**************************************/
528
529 struct NODE27 {
530 int data;
531 shared(NODE27) *next;
532 }
533
534 static shared NODE27 nodetbl[3] =
535 [
536 { 0,cast(shared(NODE27)*)nodetbl + 1},
537 { 0,cast(shared(NODE27)*)nodetbl + 2},
538 { 0,null}
539 ];
540
541 static shared NODE27 nodetbl2[3] = [
542 { 0,&nodetbl2[1]},
543 { 0,&nodetbl2[2]},
544 { 0,null}
545 ];
546
547 void test27()
548 {
549 }
550
551
552 /**************************************/
553
554 class Foo28
555 {
556 protected int x;
557
558 static class Bar
559 {
560 Foo28 f;
561
562 int method () { return f.x; }
563 }
564 }
565
566 void test28()
567 {
568 }
569
570
571 /**************************************/
572
573 void test29()
574 {
575 int[immutable(byte)[]] foo;
576
577 static immutable(byte)[] bar = [ 65, 66, 67 ];
578
579 foo[bar] = 1;
580 assert(foo[bar] == 1);
581 }
582
583 /**************************************/
584
585 class A30
586 {
587 static class Child
588 {
589 }
590 }
591
592
593 class B30
594 {
595 static class Child
596 {
597 static int value = 6;
598 }
599 }
600
601 void test30()
602 {
603 printf ("%d\n", B30.Child.value);
604 assert(B30.Child.value == 6);
605 }
606
607
608 /**************************************/
609
610 void test31()
611 {
612 float b;
613 b -= 1.0;
614 b += 1.0;
615 }
616
617 /**************************************/
618
619 class Foo32
620 {
621 struct Bar
622 {
623 int x;
624 }
625 }
626
627 void test32()
628 {
629 with (new Foo32)
630 {
631 Bar z;
632 z.x = 5;
633 }
634 }
635
636
637 /**************************************/
638
639 string[2][] foo33;
640
641 void test33()
642 {
643 string[2] bar;
644
645 bar[1] = "hello";
646 foo33 ~= bar;
647 assert(foo33[0][1] == "hello");
648 }
649
650
651 /**************************************/
652
653
654 void test34()
655 {
656 try {
657 int i = 0;
658 printf( "i:%d\n", i );
659 } finally {
660 printf( "Done\n" );
661 }
662 try {
663 int i = 1;
664 printf( "i:%d\n", i );
665 } finally {
666 printf( "Done\n" );
667 }
668 }
669
670
671 /**************************************/
672
673 class Bar35 {}
674
675 template Foo35( T )
676 {
677 void func() { };
678 }
679
680 void test35()
681 {
682 try {
683 alias Foo35!( Bar35 ) filter;
684 } catch (Exception e) {
685 printf( "Exception %.*s", e.msg.length, e.msg.ptr );
686 } finally {
687 printf( "Done0." );
688 }
689 }
690
691
692 /**************************************/
693
694 void test36()
695 {
696 enum {A=1}
697 enum {B=A?0:1}
698 assert(A == 1);
699 assert(B == 0);
700 }
701
702 /**************************************/
703
704 struct A37
705 {
706 int a;
707 }
708
709 struct B37
710 {
711 int a;
712 int b;
713 }
714
715 struct C37
716 {
717 int a;
718 int b;
719 int c;
720 }
721
722 struct D37
723 {
724 byte a,b,c;
725 }
726
727 void test37()
728 {
729 A37 a;
730 B37 b;
731 C37 c;
732 D37 d;
733
734 assert(a.a == 0);
735 assert(b.a == 0 && b.b == 0);
736 assert(c.a == 0 && c.b == 0 && c.c == 0);
737 assert(d.a == 0 && d.b == 0 && d.c == 0);
738 }
739
740
741 /**************************************/
742
743 int function() fp18;
744
745 extern(Windows) int func18()
746 {
747 static int otherfunc()
748 { return 18; }
749
750 fp18 = &otherfunc;
751 return fp18();
752 }
753
754 void test38()
755 {
756 assert(func18() == 18);
757 }
758
759
760 /**************************************/
761
762 class bar39
763 {
764 struct _sub
765 {
766 bool a;
767 string d;
768 };
769 _sub mySub;
770 };
771
772 class foo39
773 {
774 bar39._sub[] subArray;
775
776 this(bar39[] arr)
777 {
778 for(int i=0; i<arr.length; i++)
779 subArray ~= arr[i].mySub;
780 };
781 };
782
783
784 void test39()
785 {
786 }
787
788
789 /**************************************/
790
791 void test40()
792 {
793 void* h;
794
795 h = h.init;
796 assert(h == cast(void*)0);
797 }
798
799 /**************************************/
800
801 int test41()
802 {
803 label:
804 int foo;
805 foo = 0;
806 return foo;
807 }
808
809
810 /**************************************/
811
812 struct A42
813 {
814 invariant()
815 {
816 }
817
818 B42 *findPool()
819 {
820 return null;
821 }
822
823 }
824
825 struct B42
826 {
827 int cmp(B42 *p2)
828 {
829 return 0;
830 }
831 }
832
833 void test42()
834 {
835 }
836
837
838 /**************************************/
839
840 void test43()
841 {
842 real a = 0.9;
843 ulong b = cast(ulong) a;
844 printf("%u", cast(uint) b);
845 assert(cast(uint) b == 0);
846
847 int c = cast(int) a;
848 printf("%i", c);
849 assert(c == 0);
850 }
851
852
853 /**************************************/
854
855 void test44()
856 {
857 switch("asdf")
858 {
859 case "asdf":
860 printf("asdf\n");
861 break;
862
863
864 case "jkl":
865 printf("jkl\n");
866 assert(0);
867 break;
868
869
870 default:
871 printf("default\n");
872 assert(0);
873 }
874 }
875
876
877 /**************************************/
878
879 void func45(string a)
880 {
881 assert(a.length == 5);
882 }
883
884 void test45()
885 {
886 char[5] foo;
887
888 foo[] = "hello";
889 printf("'%.*s'\n", foo.length, foo.ptr);
890 func45(cast(string)foo);
891 }
892
893 /**************************************/
894
895 struct Foo46
896 {
897 int x;
898 }
899
900 void test46()
901 {
902 Foo46 f;
903
904 with (f)
905 {
906 x = 3;
907 }
908 assert(f.x == 3);
909 }
910
911 /**************************************/
912
913 struct Bar48
914 {
915 uint k;
916 ubyte m;
917 }
918
919 Bar48 makebar48() { Bar48 b; return b; }
920
921 void test48()
922 {
923 Bar48 b = makebar48();
924 }
925
926 /**************************************/
927
928 void testx49() { printf("testx49()\n"); }
929
930 void test49() { return testx49(); }
931
932 /**************************************/
933
934 int testx50() { printf("testx50()\n"); return 3; }
935
936 void test50() { return cast(void)testx50(); }
937
938 /**************************************/
939
940 class A51
941 {
942 static typeof(this) foo()
943 {
944 return new A51();
945 }
946
947 this()
948 {
949 bar = 3;
950 }
951
952 int bar;
953 }
954
955 class B51 : A51
956 {
957 static typeof(super) b;
958 }
959
960 struct C51
961 {
962 typeof(&this) x;
963 }
964
965 void test51()
966 {
967 A51 a = A51.foo();
968 assert(a.bar == 3);
969
970 B51.b = a;
971 assert(B51.b.bar == 3);
972 assert(B51.b.classinfo == A51.classinfo);
973
974 C51 c;
975 c.x = &c;
976 }
977
978
979 /**************************************/
980
981 class A52
982 {
983 char get() { return 'A'; }
984
985 char foo() { return typeof(this).get(); }
986 char bar() { return A52.get(); }
987 }
988
989 class B52 : A52
990 {
991 override char get() { return 'B'; }
992 }
993
994 void test52()
995 {
996 B52 b = new B52();
997
998 assert(b.foo() == 'A');
999 assert(b.bar() == 'A');
1000 assert(b.get() == 'B');
1001 }
1002
1003 /**************************************/
1004
1005 struct A53
1006 {
1007 int b() { return 1; }
1008 }
1009
1010 int x53()
1011 {
1012 A53 a;
1013 return a.b;
1014 }
1015
1016 void test53()
1017 {
1018 assert(x53() == 1);
1019 }
1020
1021 /**************************************/
1022
1023 class A54
1024 {
1025 void a()
1026 {
1027 printf("A54.a\n");
1028 }
1029
1030 void b()
1031 {
1032 typeof(this).a();
1033 }
1034 }
1035
1036 class B54 : A54
1037 {
1038 override void a()
1039 {
1040 printf("B54.a\n");
1041 assert(0);
1042 }
1043 }
1044
1045 void test54()
1046 {
1047 B54 b = new B54();
1048
1049 b.b();
1050 }
1051
1052
1053 /**************************************/
1054
1055 int foo55(int x = 5)
1056 {
1057 printf("x = %d\n", x);
1058 return x;
1059 }
1060
1061 void test55()
1062 { int i;
1063
1064 i = foo55(6);
1065 assert(i == 6);
1066 i = foo55();
1067 assert(i == 5);
1068 }
1069
1070 /**************************************/
1071
1072 class A56
1073 {
1074 int foo(int x = 5)
1075 {
1076 printf("A56.x = %d\n", x);
1077 return x;
1078 }
1079 }
1080
1081 class B56 : A56
1082 {
1083 override int foo(int x = 7)
1084 {
1085 printf("B56.x = %d\n", x);
1086 return x;
1087 }
1088 }
1089
1090
1091 void test56()
1092 { int i;
1093 B56 b = new B56();
1094
1095 i = b.foo(6);
1096 assert(i == 6);
1097 i = b.foo();
1098 assert(i == 7);
1099 }
1100
1101
1102 /**************************************/
1103
1104 void test57()
1105 {
1106 char c;
1107 wchar w;
1108 dchar d;
1109
1110 printf("c = %x, w = %x, d = %x\n", c, w, d);
1111 assert(c == 0xFF);
1112 assert(w == 0xFFFF);
1113 assert(d == 0xFFFF);
1114 }
1115
1116 /**************************************/
1117
1118 void test58()
1119 {
1120 static int x;
1121
1122 static class S
1123 {
1124 static this()
1125 {
1126 printf ("static constructor\n");
1127 x = 10;
1128 }
1129
1130 this()
1131 {
1132 printf ("class constructor\n");
1133 }
1134 }
1135
1136 assert(x == 10);
1137 new S;
1138 }
1139
1140 /**************************************/
1141
1142 struct S61 {
1143 int a, b, c, d;
1144 }
1145
1146 void rec(int n, S61 t)
1147 {
1148 if (n > 0) {
1149 t.b++;
1150 rec(n-1,t);
1151 }
1152 }
1153
1154 void test61()
1155 {
1156 S61 F;
1157
1158 rec(100, F);
1159 }
1160
1161 /**************************************/
1162
1163 class A62
1164 {
1165 static A62 test(int q=0) {
1166 return null;
1167 }
1168 }
1169
1170 A62 foo62()
1171 {
1172 return A62.test;
1173 }
1174
1175 void test62()
1176 {
1177 foo62();
1178 }
1179
1180
1181 /**************************************/
1182
1183 class A63
1184 {
1185 private import std.file;
1186 alias std.file.getcwd getcwd;
1187 }
1188
1189 void test63()
1190 {
1191 A63 f = new A63();
1192 auto s = f.getcwd();
1193 printf("%.*s\n", s.length, s.ptr);
1194 }
1195
1196
1197 /**************************************/
1198
1199 debug = 3;
1200
1201 void test64()
1202 {
1203 debug(5)
1204 {
1205 assert(0);
1206 }
1207 debug(3)
1208 {
1209 int x = 3;
1210 }
1211 assert(x == 3);
1212 }
1213
1214 /**************************************/
1215
1216 version = 3;
1217
1218 void test65()
1219 {
1220 version(5)
1221 {
1222 assert(0);
1223 }
1224 version(3)
1225 {
1226 int x = 3;
1227 }
1228 assert(x == 3);
1229 }
1230
1231 /**************************************/
1232 // 8809
1233
1234 void test8809()
1235 {
1236 static class B
1237 {
1238 char foo() { return 'B'; }
1239 }
1240 static class C : B
1241 {
1242 char test1Bx() { return B.foo(); }
1243 char test1Cx() { return C.foo(); }
1244 char test1Dx() { return foo(); }
1245 char test1By() { return this.B.foo(); }
1246 char test1Cy() { return this.C.foo(); } // cannot compile -> OK
1247 char test1Dy() { return this. foo(); }
1248 char test1Bz() { return typeof(super).foo(); }
1249 char test1Cz() { return typeof(this). foo(); }
1250 //char test1Dz();
1251
1252 char test2Bx() { return { return B.foo(); }(); }
1253 char test2Cx() { return { return C.foo(); }(); }
1254 char test2Dx() { return { return foo(); }(); }
1255 char test2By() { return { return this.B.foo(); }(); }
1256 char test2Cy() { return { return this.C.foo(); }(); } // cannot compile -> OK
1257 char test2Dy() { return { return this. foo(); }(); }
1258 char test2Bz() { return { return typeof(super).foo(); }(); }
1259 char test2Cz() { return { return typeof(this). foo(); }(); }
1260 //char test2Dz();
1261
1262 char test3Bx() { return (new class Object { char bar() { return B.foo(); } }).bar(); }
1263 char test3Cx() { return (new class Object { char bar() { return C.foo(); } }).bar(); }
1264 char test3Dx() { return (new class Object { char bar() { return foo(); } }).bar(); }
1265
1266 override char foo() { return 'C'; }
1267 }
1268 static class D : C
1269 {
1270 override char foo() { return 'D'; }
1271 }
1272
1273 C c = new D();
1274
1275 assert(c.test1Bx() == 'B');
1276 assert(c.test1Cx() == 'C');
1277 assert(c.test1Dx() == 'D');
1278 assert(c.test1By() == 'B');
1279 assert(c.test1Cy() == 'C');
1280 assert(c.test1Dy() == 'D');
1281 assert(c.test1Bz() == 'B'); // NG('D') -> OK
1282 assert(c.test1Cz() == 'C');
1283 //assert(c.test1Dz() == 'D');
1284
1285 assert(c.test2Bx() == 'B'); // NG('D') -> OK
1286 assert(c.test2Cx() == 'C'); // NG('D') -> OK
1287 assert(c.test2Dx() == 'D');
1288 assert(c.test2By() == 'B');
1289 assert(c.test2Cy() == 'C');
1290 assert(c.test2Dy() == 'D');
1291 assert(c.test2Bz() == 'B'); // NG('D') -> OK
1292 assert(c.test2Cz() == 'C'); // NG('D') -> OK
1293 //assert(c.test2Dz() == 'D');
1294
1295 assert(c.test3Bx() == 'B'); // NG('D') -> OK
1296 assert(c.test3Cx() == 'C'); // NG('D') -> OK
1297 assert(c.test3Dx() == 'D');
1298 }
1299
1300 /**************************************/
1301 // 9734
1302
1303 void test9734()
1304 {
1305 class C {}
1306 class D : C
1307 {
1308 static bool test(C) { return true; }
1309
1310 void foo()() if (is(typeof(test(super)))) {}
1311 void bar()() if (is(typeof(super) == C)) {}
1312 }
1313 void baz()() if (is(typeof(super))) {}
1314
1315 auto d = new D();
1316 d.foo();
1317 d.bar();
1318 static assert(!__traits(compiles, baz()));
1319 }
1320
1321 /**************************************/
1322
1323 int main(string[] argv)
1324 {
1325 test1();
1326 test2();
1327 test3();
1328 test4();
1329 test6();
1330 test7();
1331 test8();
1332 test9();
1333 test10();
1334 test11();
1335 test12();
1336 test13();
1337 test14();
1338 test15();
1339 test16();
1340 test17();
1341 test18();
1342 test19();
1343 test20();
1344 test21();
1345 test22();
1346 test23();
1347 test24();
1348 test25();
1349 test26();
1350 test27();
1351 test28();
1352 test29();
1353 test30();
1354 test31();
1355 test32();
1356 test33();
1357 test34();
1358 test35();
1359 test36();
1360 test37();
1361 test38();
1362 test39();
1363 test40();
1364 test41();
1365 test42();
1366 test43();
1367 test44();
1368 test45();
1369 test46();
1370 test48();
1371 test49();
1372 test50();
1373 test51();
1374 test52();
1375 test53();
1376 test54();
1377 test55();
1378 test56();
1379 test57();
1380 test58();
1381 test61();
1382 test62();
1383 test63();
1384 test64();
1385 test65();
1386 test8809();
1387 test9734();
1388
1389 printf("Success\n");
1390 return 0;
1391 }
1392
1393
1394