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 = %d\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()
{
}


/*****************************************/

scope 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("[%2d]: ", 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
{
        new(size_t size, byte blah){
                void* v = (new byte[C16.classinfo.initializer.length]).ptr;
                y16 = 1;
                assert(blah == 3);
                return v;
        }
        int x;
        this()
        {
            x = 4;
        }
}

void test16()
{
    C16 c = new(3) C16;
    assert(y16 == 1);
    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();
    delete 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.
        }
    }
}


/*****************************************/

void test23()
{
    float f;
    double d;
    real r;

    if (f > ifloat.max)
        goto Loverflow;
    if (d > ifloat.max)
        goto Loverflow;
    if (r > ifloat.max)
        goto Loverflow;

    if (ifloat.max < f)
        goto Loverflow;
    if (ifloat.max < d)
        goto Loverflow;
    if (ifloat.max < r)
        goto Loverflow;

    return;

  Loverflow:
    return;
}

/*****************************************/

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 test30()
{
  double d = 1;
  cdouble cd = 1+0i;
  assert(cd == 1.0 + 0i);
}

/*****************************************/

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 = x"E3 83 AF E3 83 AD E3 82 B9 EF BD 97";

        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 opMul(S45 s)
    {
        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.2lf, y = %2.2lf\n", val.x, val.y);
    assert(val.x == 100);
    assert(val.y == 0);
    double d = pow!(double)(10,3);
    printf("%2.2lf\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 );
}

/*****************************************/

void test47()
{
   cdouble[] a;
   cdouble[] b;
   foreach(ref cdouble d; b)
     {
       d = -a[0];
       for(;;){}
     }
}

/*****************************************/

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 = void;
    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 = %d\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", month[1].length, month[1].ptr);
    printf("%.*s\n", month[2].length, month[2].ptr);
    printf("%.*s\n", month[3].length, month[3].ptr);
    printf("%.*s\n", month[4].length, month[4].ptr);
    printf("%.*s\n", month[5].length, month[5].ptr);
    printf("%.*s\n", month[6].length, month[6].ptr);
    printf("%.*s\n", 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 opMul(S54 s)
    {
        return s;
    }
}

void test54()
{
    S54.bar();
}

/*****************************************/

void test55()
{
  char c = 'a';
  char[] str, uvw;
  str = str ~ c;
  uvw = c ~ uvw;

  printf("%.*s\n", str.length, str.ptr);
  assert(str == "a");
  assert(uvw == "a");

  c = 'b';
  printf("%.*s\n", 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("%d ", 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();
    test23();
    test24();
    test25();
    test26();
    test27();
    test28();
    test29();
    test30();
    test31();
    test33();
    test34();
    test35();
    test36();
    test37();
    test38();
    test41();
    test42();
    test43();
    test44();
    test45();
    test46();
    test47();
    test48();
    test49();
    test50();
    test51();
    test52();
    test53();
    test54();
    test55();
    test56();
    test57();
    test58();
    test59();
    test60();
    test61();
    bug7493();

    printf("Success\n");
    return 0;
}