| import core.vararg; |
| |
| extern(C) int printf(const char*, ...); |
| |
| /*****************************************/ |
| |
| class A1 |
| { |
| union |
| { |
| struct |
| { |
| int x; |
| public int y; |
| } |
| protected int z; |
| } |
| } |
| |
| class A2 |
| { |
| struct |
| { |
| int x; |
| public int y; |
| } |
| } |
| |
| class A3 |
| { |
| union |
| { |
| int x; |
| public int y; |
| } |
| } |
| |
| void test1() |
| { |
| A1 a1 = new A1(); |
| A2 a2 = new A2(); |
| A3 a3 = new A3(); |
| |
| a1.x = 1; |
| a1.y = 2; |
| a1.z = 3; |
| assert(a1.x == 3); |
| assert(a1.y == 2); |
| |
| a2.x = 1; |
| a2.y = 2; |
| assert(a2.x == 1); |
| |
| a3.x = 1; |
| a3.y = 2; |
| assert(a3.x == 2); |
| } |
| |
| /*****************************************/ |
| |
| struct A4 |
| { |
| union |
| { |
| struct |
| { |
| int x = 13; |
| } |
| int y; |
| } |
| } |
| |
| void test4() |
| { |
| printf("A4.sizeof = %zd\n", A4.sizeof); |
| assert(A4.sizeof == 1 * int.sizeof); |
| |
| A4 q; |
| assert(q.y == 13); |
| } |
| |
| /*****************************************/ |
| |
| class A5 |
| { |
| union { |
| struct { |
| int x; |
| } |
| public int y; |
| } |
| } |
| |
| void test5() |
| { |
| A5 a = new A5; |
| |
| a.x = 3; |
| a.y = 4; |
| assert(a.x == 4); |
| } |
| |
| /*****************************************/ |
| |
| int i6 = 5; |
| |
| float m6 = 5.0; |
| |
| void test6() |
| { |
| void f() |
| { |
| void i6(float j) |
| { |
| m6 = j; |
| } |
| |
| void g() |
| { |
| i6 = 1; |
| } |
| g(); |
| } |
| |
| f(); |
| |
| printf( "%d %f\n", i6, m6); |
| assert(i6 == 5); |
| assert(m6 == 1); |
| } |
| |
| /*****************************************/ |
| |
| const int a1 = 50; |
| const int a2 = 50; |
| const int a3 = a1 * a2; |
| |
| const int b1 = a1 - 1; |
| const int b2 = a2 - 1; |
| |
| const int c1 = 50*50; |
| const int c2 = (a1-1)*(a2-1); |
| const int c3 = b1*b2; |
| |
| int[4*c1] array1; // illegal! |
| int[4*c2] array2; // illegal! |
| int[4*c3] array3; // illegal! |
| |
| int[a3] array4; // valid! no error! |
| |
| void test7() |
| { |
| assert(a1 == 50); |
| assert(a2 == 50); |
| assert(a3 == 2500); |
| |
| assert(b1 == 49); |
| assert(b2 == 49); |
| |
| assert(c1 == 2500); |
| assert(c2 == 2401); |
| assert(c3 == 2401); |
| |
| assert(array1.length == 10000); |
| assert(array2.length == 9604); |
| assert(array3.length == 9604); |
| } |
| |
| /*****************************************/ |
| |
| struct Foo8 |
| { |
| static Foo8 bar() |
| { |
| Foo8 res; |
| return res; |
| } |
| } |
| |
| void test8() |
| { |
| Foo8[8] x; |
| x[] = Foo8.bar; |
| } |
| |
| |
| /*****************************************/ |
| |
| void test9() |
| { |
| try { |
| } catch (Exception e) { |
| debug printf("Exception happened\n"); |
| } |
| } |
| |
| /*****************************************/ |
| |
| struct Foo10 { |
| const bool opEquals(const ref Foo10 x) { |
| return this.normalize is x.normalize; |
| } |
| const Foo10 normalize() { |
| Foo10 res; |
| return res; |
| } |
| } |
| |
| void test10() |
| { |
| } |
| |
| |
| /*****************************************/ |
| |
| class T11 |
| { |
| this(){} |
| ~this(){} |
| } |
| |
| void test11() |
| { |
| scope T11 t=new T11(); |
| int i=1; |
| switch(i) |
| { |
| case 1: |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| /*****************************************/ |
| |
| void test12() |
| { |
| char[] s; |
| char[] t; |
| |
| if (true) |
| s = null; |
| s = (true) ? null : t; |
| t = (true) ? s : null; |
| } |
| |
| /*****************************************/ |
| |
| class Foo13 |
| { |
| int init (int x) { return 1; } |
| |
| static int init (long y) { return 2; } |
| } |
| |
| void test13() |
| { |
| Foo13 f = new Foo13(); |
| int i; |
| |
| i = f.init(1); |
| assert(i == 1); |
| i = f.init(1L); |
| assert(i == 2); |
| } |
| |
| /*****************************************/ |
| |
| void write14(bool[] c) |
| { |
| printf("[%2zd]: ", c.length); |
| foreach (bool x; c) |
| printf("%d,", x); |
| printf("\n"); |
| } |
| |
| void test14() |
| { |
| static bool[] a = [ 1, 1, 0, 1, 0 ]; |
| static bool[] b = [ 1, 0, 0, 1 ]; |
| bool[] c = a ~ b; |
| |
| static bool[] r1 = [1,1,0,1,0,1,0,0,1]; |
| static bool[] r2 = [1,1,0,1,0,1,0,0,1,1,1,0,1,0]; |
| static bool[] r3 = [1,1,0,1,0,1,0,0,1,1,1,0,1,0,0]; |
| static bool[] r4 = [1,1,0,1,0,1,0,0,1,1,1,0,1,0,0,1]; |
| |
| |
| write14(c); |
| assert(c == r1); |
| |
| c ~= a; |
| write14(c); |
| assert(c == r2); |
| |
| c ~= 0; |
| write14(c); |
| assert(c == r3); |
| |
| c ~= 1; |
| write14(c); |
| assert(c == r4); |
| } |
| |
| /*****************************************/ |
| |
| void test15() |
| { |
| bool[] b; |
| bool[] c; |
| |
| b.length = 10; |
| c = b[0..4]; |
| c[] = true; |
| |
| assert(b[0] == true); |
| assert(b[1] == true); |
| assert(b[2] == true); |
| assert(b[3] == true); |
| |
| assert(b[4] == false); |
| assert(b[5] == false); |
| assert(b[6] == false); |
| assert(b[7] == false); |
| assert(b[8] == false); |
| assert(b[9] == false); |
| } |
| |
| /*****************************************/ |
| |
| int y16; |
| |
| class C16 |
| { |
| int x; |
| this() |
| { |
| x = 4; |
| } |
| } |
| |
| void test16() |
| { |
| C16 c = new C16(); |
| assert(c.x == 4); |
| } |
| |
| /*****************************************/ |
| |
| ubyte* ptr17; |
| |
| void test17() |
| { |
| ubyte[16] foo; |
| |
| printf("foo = %p\n", foo.ptr); |
| ptr17 = foo.ptr; |
| abc17(foo); |
| } |
| |
| void abc17(ref ubyte[16] bar) |
| { |
| printf("bar = %p\n", bar.ptr); |
| assert(bar.ptr == ptr17); |
| } |
| |
| /*****************************************/ |
| |
| struct Iterator18(T) |
| { |
| T* m_ptr; |
| |
| const bool opEquals(const ref Iterator18 iter) |
| { |
| return (m_ptr == iter.m_ptr); |
| } |
| |
| const int opCmp(const ref Iterator18 iter) |
| { |
| return cast(int)(m_ptr - iter.m_ptr); |
| } |
| } |
| |
| void test18() |
| { |
| Iterator18!(int) iter; |
| } |
| |
| /*****************************************/ |
| |
| struct S29(T) |
| { |
| const bool opEquals(const ref S29!(T) len2) |
| { |
| return 0; |
| } |
| |
| const int opCmp(const ref S29!(T) len2) |
| { |
| return 0; |
| } |
| } |
| |
| |
| void test19() |
| { |
| TypeInfo info = typeid(S29!(int)); |
| } |
| |
| |
| /*****************************************/ |
| |
| class Mapped : Buffer |
| { |
| this() |
| { |
| } |
| |
| ~this() |
| { |
| } |
| } |
| |
| class Buffer |
| { |
| private uint limit; |
| private uint capacity; |
| private uint position; |
| |
| invariant() |
| { |
| assert (position <= limit); |
| assert (limit <= capacity); |
| } |
| } |
| |
| void test20() |
| { |
| Buffer b = new Buffer(); |
| destroy(b); |
| } |
| |
| /*****************************************/ |
| |
| class T21 |
| { |
| char[1] p1; |
| char[1] p2; |
| public: |
| char[] P() {return p1~p2;} |
| } |
| |
| void test21() |
| { |
| T21 t = new T21; |
| t.p1[0] = 'a'; |
| t.p2[0] = 'b'; |
| assert(t.P() == "ab"); |
| } |
| |
| /*****************************************/ |
| |
| void test22() |
| { |
| struct foo1 { int a; int b; int c; } |
| |
| class foo2 |
| { |
| foo1[] x; |
| |
| foo1 fooret(foo1 foo2) |
| { |
| x.length = 9; |
| return x[0] = foo2; // Here |
| |
| // x[0] = foo2; --- This version does not |
| // return x[0]; --- cause the error. |
| } |
| } |
| } |
| |
| |
| /*****************************************/ |
| |
| interface I24 { } |
| |
| void test24() |
| { |
| } |
| |
| /*****************************************/ |
| |
| interface D25{} |
| interface C25:D25{} |
| interface B25:C25{} |
| interface A25:B25{} |
| |
| void test25() |
| { |
| } |
| |
| class A26:B26{} |
| interface B26:C26{} |
| interface C26:D26{} |
| interface D26{} |
| |
| void test26() |
| { |
| } |
| |
| interface A27:B27{} |
| interface B27:C27{} |
| interface C27:D27{} |
| interface D27{} |
| |
| void test27() |
| { |
| } |
| |
| /*****************************************/ |
| |
| void test28() |
| { |
| const double d = -1.0; |
| int i = cast(int)d; |
| printf("i = %d\n", i); |
| assert(-1 == i); |
| } |
| |
| /*****************************************/ |
| |
| static int[1][5] array = [[1],[2],[3],[4],[5] ]; |
| |
| void Lookup( int which ) |
| { |
| switch( which ) |
| { |
| case 0 : return cast(void)array[which]; |
| default: assert(0); |
| } |
| } |
| |
| void test29() |
| { |
| } |
| |
| /*****************************************/ |
| |
| void foo31(...) |
| { |
| byte b = va_arg!byte(_argptr); |
| assert(b == 8); |
| } |
| |
| void test31() |
| { |
| byte x = 9; |
| foo31(--x); |
| --x; |
| foo31(++x); |
| } |
| |
| /*****************************************/ |
| |
| template Foo33(T, int L) |
| { |
| T[L] arr; |
| class Bar { |
| int before = 6; |
| T[L] arr; |
| int after = 7; |
| } |
| } |
| |
| void test33() |
| { |
| alias Foo33!(int, 100) foo; |
| foreach (int x; foo.arr) |
| assert(x == int.init); |
| |
| foo.Bar bar = new foo.Bar(); |
| foreach (int x; bar.arr) |
| { //printf("%d\n", x); |
| assert(x == int.init); |
| } |
| } |
| |
| |
| /*****************************************/ |
| |
| void test34() |
| { |
| bool[1] a; |
| bool[1] b; |
| |
| bool[] concat() { |
| return a~b; |
| } |
| |
| a[]=0; |
| b[]=1; |
| |
| bool[] arr=concat(); |
| |
| assert(arr.length==2); |
| assert(arr[0]==0); |
| assert(arr[1]==1); |
| } |
| |
| /*****************************************/ |
| |
| void dummy35(...) {} |
| |
| void test35() |
| { |
| byte x = 9; |
| dummy35(x); |
| int y = --x; |
| assert (y == 8); |
| assert (x == 8); |
| } |
| |
| /*****************************************/ |
| |
| void test36() |
| { |
| int[] a; |
| a.length = 2; |
| a[0]=1; |
| a[1]=2; |
| |
| int[] b; |
| b.length = 1; |
| b[0]=3; |
| |
| a~=b; |
| |
| assert(a.length==3); |
| assert(a[0]==1); |
| assert(a[1]==2); |
| assert(a[2]==3); |
| |
| assert(b.length==1); |
| assert(b[0]==3); |
| } |
| |
| /*****************************************/ |
| |
| struct Range{ |
| int width(){ |
| return 1; |
| } |
| } |
| |
| class Container { |
| Range opIndex(int i){ |
| return data[i]; |
| } |
| |
| Range[2] data; |
| } |
| |
| void test37() |
| { |
| Container ranges=new Container; |
| |
| // fails with -inline |
| // assert(ranges[0].width() == 1); |
| } |
| |
| /*****************************************/ |
| |
| void test38() |
| { |
| uint mask = (uint.max >> 1); |
| assert(mask == (uint.max >> 1)); |
| } |
| |
| |
| |
| /*****************************************/ |
| |
| void test41() |
| { |
| assert(new void[40] == new void[40]); |
| } |
| |
| /*****************************************/ |
| |
| void test42() |
| { |
| static ubyte[] master = [ |
| 0xE3u, 0x83u, 0xAFu, 0xE3u, 0x83u, 0xADu, 0xE3u, 0x82u, |
| 0xB9u, 0xEFu, 0xBDu, 0x97u |
| ]; |
| |
| string string1 = "ワãƒã‚¹ï½—"; |
| string string2 = r"ワãƒã‚¹ï½—"; |
| string string3 = `ワãƒã‚¹ï½—`; |
| string string4 = "\xE3\x83\xAF\xE3\x83\xAD\xE3\x82\xB9\xEF\xBD\x97"; |
| |
| assert(string1.length==master.length); |
| |
| for(int i=0; i<master.length; i++){ |
| assert(string1[i]==master[i]); |
| } |
| |
| assert(string2.length==master.length); |
| |
| for(int i=0; i<master.length; i++){ |
| assert(string2[i]==master[i]); |
| } |
| |
| assert(string3.length==master.length); |
| |
| for(int i=0; i<master.length; i++){ |
| assert(string3[i]==master[i]); |
| } |
| |
| assert(string4.length==master.length); |
| |
| for(int i=0; i<master.length; i++){ |
| assert(string4[i]==master[i]); |
| } |
| } |
| |
| /*****************************************/ |
| |
| struct S43 |
| { |
| int i=1; |
| } |
| |
| static S43[3] s= [ 1: { 2 } ]; |
| |
| void test43() |
| { |
| assert(s[0].i==1); |
| assert(s[1].i==2); |
| assert(s[2].i==1); |
| } |
| |
| /*****************************************/ |
| |
| struct S44 |
| { |
| int i; |
| } |
| |
| static S44[12] S44s = []; |
| |
| void test44() |
| { |
| } |
| |
| |
| /*****************************************/ |
| |
| struct S45 |
| { |
| double x = 0, y = 0; |
| static S45 opCall(int i) { S45 r; r.x = i; return r; } |
| S45 opBinary(string op)(S45 s) if (op == "*") |
| { |
| S45 r; |
| r.x = x * s.x; |
| r.y = y * s.y; |
| return r; |
| } |
| } |
| |
| template sqr(F) { F sqr(F x) { return x * x; } } |
| |
| template pow(F) |
| { |
| F pow(F x, int i) { |
| if (i < 1) |
| { |
| static if (is(F : real)) |
| return 1; |
| else |
| return F(1); |
| } |
| if (i & 1) |
| { |
| if (i == 1) |
| return x; |
| else |
| return x * pow(x,i-1); |
| } |
| return sqr!(F)(pow(x,i/2)); |
| } |
| } |
| |
| void test45() |
| { |
| S45 s = S45(10); |
| S45 val = pow!(S45)(s,2); |
| printf("x = %2.2f, y = %2.2f\n", val.x, val.y); |
| assert(val.x == 100); |
| assert(val.y == 0); |
| double d = pow!(double)(10,3); |
| printf("%2.2f\n", d); |
| assert(d == 1000); |
| } |
| |
| /*****************************************/ |
| |
| struct Node46 |
| { |
| Node46* left,right,parent; |
| int color = 5; |
| char[] key; |
| char[] value; |
| } |
| |
| void test46() |
| { |
| Node46* x = new Node46; |
| assert( x.left is null ); |
| assert( x.right is null ); |
| assert( x.parent is null ); |
| assert( x.color is 5 ); |
| assert( x.key is null ); |
| assert( x.value is null ); |
| } |
| |
| /*****************************************/ |
| |
| string foo48(string s) |
| { |
| return s; |
| } |
| |
| void test48() |
| { |
| char c = '?'; |
| string s; |
| |
| s = foo48("is this it" ~ c ~ " yep!"); |
| assert(s == "is this it? yep!"); |
| |
| s = foo48("is this it" ~ c); |
| assert(s == "is this it?"); |
| |
| s = foo48(c ~ "is this it"); |
| assert(s == "?is this it"); |
| } |
| |
| |
| /*****************************************/ |
| |
| char[10] foo49 = void; |
| |
| void test49() |
| { |
| int i = void; |
| //printf("i = %d\n", i); |
| int[10] a; |
| foreach (int x; a) |
| { |
| printf("\tx = %d\n", x); |
| } |
| } |
| |
| /*****************************************/ |
| |
| void foo50(string s) { assert(s == "is this it? yep!"); } |
| |
| void test50() |
| { |
| char c = '?'; |
| foo50("is this it"~c~" yep!"); |
| } |
| |
| /*****************************************/ |
| |
| void test51() |
| { |
| bool[9][3] qwert; |
| |
| printf("qwert.sizeof = %zd\n", qwert.sizeof); |
| |
| for (int i = 0; i < 3; i++) |
| for (int j = 0; j < 9; j++) |
| assert(qwert[i][j] == false); |
| |
| version (D_Bits) |
| assert(qwert.sizeof == 12); |
| else |
| assert(qwert.sizeof == 27); |
| |
| qwert[0][3] = true; |
| qwert[0][5] = true; |
| qwert[0][7] = true; |
| |
| qwert[1..3] = qwert[0]; |
| |
| for (int i = 0; i < 3; i++) |
| { |
| assert(qwert[i][0] == false); |
| assert(qwert[i][1] == false); |
| assert(qwert[i][2] == false); |
| assert(qwert[i][3] == true); |
| assert(qwert[i][4] == false); |
| assert(qwert[i][5] == true); |
| assert(qwert[i][6] == false); |
| assert(qwert[i][7] == true); |
| assert(qwert[i][8] == false); |
| } |
| } |
| |
| |
| /*****************************************/ |
| |
| void test52() |
| { |
| size_t vsize = void.sizeof; |
| assert(vsize == 1); |
| } |
| |
| /*****************************************/ |
| |
| const char[3][13] month = [ |
| 1: "Jan", "Feb", "Mar", "Apr", "May", "Jun", |
| 8: "Aug", "Sep", "Oct", "Nov", "Dec" |
| ]; |
| |
| void test53() |
| { |
| printf("%.*s\n", cast(int)month[1].length, month[1].ptr); |
| printf("%.*s\n", cast(int)month[2].length, month[2].ptr); |
| printf("%.*s\n", cast(int)month[3].length, month[3].ptr); |
| printf("%.*s\n", cast(int)month[4].length, month[4].ptr); |
| printf("%.*s\n", cast(int)month[5].length, month[5].ptr); |
| printf("%.*s\n", cast(int)month[6].length, month[6].ptr); |
| printf("%.*s\n", cast(int)month[8].length, month[8].ptr); |
| |
| assert(month[1] == "Jan"); |
| assert(month[2] == "Feb"); |
| assert(month[3] == "Mar"); |
| assert(month[4] == "Apr"); |
| assert(month[5] == "May"); |
| assert(month[6] == "Jun"); |
| assert(month[8] == "Aug"); |
| assert(month[9] == "Sep"); |
| assert(month[10] == "Oct"); |
| assert(month[11] == "Nov"); |
| assert(month[12] == "Dec"); |
| |
| assert(month[0][0] == 0xFF); |
| assert(month[0][1] == 0xFF); |
| assert(month[0][2] == 0xFF); |
| |
| assert(month[7][0] == 0xFF); |
| assert(month[7][1] == 0xFF); |
| assert(month[7][2] == 0xFF); |
| } |
| |
| /*****************************************/ |
| |
| struct S54 |
| { |
| static S54 foo() |
| { |
| S54 s; |
| with (s) {} // bug |
| return s; |
| } |
| |
| static S54 bar() |
| { |
| return S54.foo() * S54.foo(); |
| } |
| |
| S54 opBinary(string op)(S54 s) if (op == "*") |
| { |
| return s; |
| } |
| } |
| |
| void test54() |
| { |
| S54.bar(); |
| } |
| |
| /*****************************************/ |
| |
| void test55() |
| { |
| char c = 'a'; |
| char[] str, uvw; |
| str = str ~ c; |
| uvw = c ~ uvw; |
| |
| printf("%.*s\n", cast(int)str.length, str.ptr); |
| assert(str == "a"); |
| assert(uvw == "a"); |
| |
| c = 'b'; |
| printf("%.*s\n", cast(int)str.length, str.ptr); |
| assert(str == "a"); |
| assert(uvw == "a"); |
| } |
| |
| /*****************************************/ |
| |
| void test56() |
| { |
| char[4] a, b; |
| a[] = 'a'; b[] = 'a'; |
| |
| for (int i = 0; i < 4; i++) |
| { |
| assert(a[i] == 'a'); |
| assert(b[i] == 'a'); |
| } |
| |
| a[] = b[] = 'b'; |
| |
| for (int i = 0; i < 4; i++) |
| { |
| assert(a[i] == 'b'); |
| assert(b[i] == 'b'); |
| } |
| |
| } |
| |
| |
| /*****************************************/ |
| |
| void test57() |
| { |
| char[] a; |
| char[] b; |
| |
| a = a ~ 'x'; |
| assert(a == "x"); |
| b = 'c' ~ a ~ 'b'; |
| assert(b == "cxb"); |
| } |
| |
| |
| /*****************************************/ |
| |
| struct Foo58 |
| { |
| ubyte a, b, c; |
| } |
| |
| void test58() |
| { |
| Foo58 d; |
| foobar58(d); |
| return cast(void)0; |
| } |
| |
| void foobar58(Foo58 e) {} |
| |
| |
| /*****************************************/ |
| |
| void foo59(string s) |
| { |
| assert(s == "hello"); |
| } |
| |
| void foo59(wstring s) |
| { |
| assert(s == "baby"); |
| } |
| |
| void foo59(dstring s) |
| { |
| assert(s == "jane"); |
| } |
| |
| void test59() |
| { |
| string h = "hello"c; |
| wstring b = "baby"w; |
| dstring j = "jane"d; |
| |
| //writefln("%s %s %s", h, b, j); |
| |
| foo59(h); |
| foo59("hello"c); |
| foo59(b); |
| foo59("baby"w); |
| foo59(j); |
| foo59("jane"d); |
| } |
| |
| /*****************************************/ |
| |
| class C60 |
| { |
| static const int x; |
| const int y; |
| |
| void foo() |
| { |
| } |
| |
| static this() |
| { |
| x = 5; |
| } |
| |
| this() |
| { |
| y = 7; |
| } |
| } |
| |
| const int z60; |
| |
| static this() |
| { |
| z60 = 3; |
| } |
| |
| void test60() |
| { |
| C60 c = new C60(); |
| |
| assert(c.x == 5); |
| assert(c.y == 7); |
| assert(z60 == 3); |
| } |
| |
| /*****************************************/ |
| |
| void foo61(real[] arr) |
| { |
| // i = 0 doesn't trigger the bug, everything bigger seems to |
| // also, making this const fixes the bug |
| size_t i = 1; |
| |
| for (size_t j = i; j >= i; j -= i) |
| { |
| // interesting results follow from this: |
| printf("%zd ", i); |
| // it prints a _lot_ of ones |
| |
| arr[j] = arr[j - i]; |
| } |
| } |
| |
| void test61() |
| { |
| real[] array; |
| array.length = 2; // whatever, as long as it's more than 1 |
| |
| foreach (ref real i; array) |
| i = 1; // just something |
| |
| foo61(array); |
| } |
| |
| /*****************************************/ |
| |
| void bug7493() |
| { |
| string str = "abcde"; |
| const(void) [][1] arr = [str]; |
| assert(arr[0].length == str.length); |
| const(void) [][1] arr2; |
| arr2 = [str]; |
| assert(arr[0].length == str.length); |
| } |
| |
| /*****************************************/ |
| |
| int main() |
| { |
| test1(); |
| test4(); |
| test5(); |
| test6(); |
| test7(); |
| test8(); |
| test9(); |
| test10(); |
| test11(); |
| test12(); |
| test13(); |
| test14(); |
| test15(); |
| test16(); |
| test17(); |
| test18(); |
| test19(); |
| test20(); |
| test21(); |
| test22(); |
| test24(); |
| test25(); |
| test26(); |
| test27(); |
| test28(); |
| test29(); |
| test31(); |
| test33(); |
| test34(); |
| test35(); |
| test36(); |
| test37(); |
| test38(); |
| test41(); |
| test42(); |
| test43(); |
| test44(); |
| test45(); |
| test46(); |
| test48(); |
| test49(); |
| test50(); |
| test51(); |
| test52(); |
| test53(); |
| test54(); |
| test55(); |
| test56(); |
| test57(); |
| test58(); |
| test59(); |
| test60(); |
| test61(); |
| bug7493(); |
| |
| printf("Success\n"); |
| return 0; |
| } |
