// PERMUTE_ARGS:

// Test memset style array assignments.

extern(C) int printf(const char*, ...);

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

char[] b1;

char[] func1(int dim)
{
    char[] a = new char[dim];

    b1 = a;
    return a;
}

void test1()
{
    printf("test1()\n");
    int i;
    int j;

    char[1] a1;
    a1[] = 'x';
    assert(a1[0] == 'x');

    char[2] a2;
    a2[] = 'x';
    for (i = 0; i < a2.length; i++)
        assert(a2[i] == 'x');

    char[3] a3;
    a3[] = 'x';
    for (i = 0; i < a3.length; i++)
        assert(a3[i] == 'x');

    char[4] a4;
    a4[] = 'x';
    for (i = 0; i < a4.length; i++)
        assert(a4[i] == 'x');

    char[8] a8;
    a8[] = 'x';
    for (i = 0; i < a8.length; i++)
        assert(a8[i] == 'x');

    char[27] a27;
    a27[] = 'x';
    for (i = 0; i < a27.length; i++)
        assert(a27[i] == 'x');

    func1(33)[] = 'y';
    for (i = 0; i < b1.length; i++)
        assert(b1[i] == 'y');


    char[23] a23 = 'x';
    i = 16;
    j = 18;
    a23[i++..++j] = 'c';
    printf("i = %d, j = %d\n", i, j);
    assert(i == 17);
    assert(j == 19);
    assert(a23[15] == 'x');
    assert(a23[16] == 'c');
    assert(a23[17] == 'c');
    assert(a23[18] == 'c');
    assert(a23[19] == 'x');
    assert(a23[20] == 'x');
}

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

short[] b2;

short[] func2(int dim)
{
    short[] a = new short[dim];

    b2 = a;
    return a;
}

void test2()
{
    printf("test2()\n");
    int i;
    int j;

    short[1] a1;
    a1[] = 0x1234;
    assert(a1[0] == 0x1234);

    short[2] a2;
    a2[] = 0x1234;
    for (i = 0; i < a2.length; i++)
        assert(a2[i] == 0x1234);

    short[3] a3;
    a3[] = 0x1234;
    for (i = 0; i < a3.length; i++)
        assert(a3[i] == 0x1234);

    short[4] a4;
    a4[] = 0x1234;
    for (i = 0; i < a4.length; i++)
        assert(a4[i] == 0x1234);

    short[8] a8;
    a8[] = 0x1234;
    for (i = 0; i < a8.length; i++)
        assert(a8[i] == 0x1234);

    short[27] a27;
    a27[] = 0x1234;
    for (i = 0; i < a27.length; i++)
        assert(a27[i] == 0x1234);

    func2(33)[] = 0x5678;
    for (i = 0; i < b2.length; i++)
        assert(b2[i] == 0x5678);


    short[23] a23 = 0x1234;
    i = 16;
    j = 18;
    a23[i++..++j] = 0x4554;
    printf("i = %d, j = %d\n", i, j);
    assert(i == 17);
    assert(j == 19);
    assert(a23[15] == 0x1234);
    assert(a23[16] == 0x4554);
    assert(a23[17] == 0x4554);
    assert(a23[18] == 0x4554);
    assert(a23[19] == 0x1234);
    assert(a23[20] == 0x1234);
}

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

int[] b3;

int[] func3(int dim)
{
    int[] a = new int[dim];

    b3 = a;
    return a;
}

void test3()
{
    printf("test3()\n");
    int i;
    int j;

    int[1] a1;
    a1[] = 0x12345678;
    assert(a1[0] == 0x12345678);

    int[2] a2;
    a2[] = 0x12345678;
    for (i = 0; i < a2.length; i++)
        assert(a2[i] == 0x12345678);

    int[3] a3;
    a3[] = 0x12345678;
    for (i = 0; i < a3.length; i++)
        assert(a3[i] == 0x12345678);

    int[4] a4;
    a4[] = 0x12345678;
    for (i = 0; i < a4.length; i++)
        assert(a4[i] == 0x12345678);

    int[8] a8;
    a8[] = 0x12345678;
    for (i = 0; i < a8.length; i++)
        assert(a8[i] == 0x12345678);

    int[27] a27;
    a27[] = 0x12345678;
    for (i = 0; i < a27.length; i++)
        assert(a27[i] == 0x12345678);

    func3(33)[] = 0x56781234;
    for (i = 0; i < b3.length; i++)
        assert(b3[i] == 0x56781234);


    int[23] a23 = 0x12345678;
    i = 16;
    j = 18;
    a23[i++..++j] = 0x45546776;
    printf("i = %d, j = %d\n", i, j);
    assert(i == 17);
    assert(j == 19);
    assert(a23[15] == 0x12345678);
    assert(a23[16] == 0x45546776);
    assert(a23[17] == 0x45546776);
    assert(a23[18] == 0x45546776);
    assert(a23[19] == 0x12345678);
    assert(a23[20] == 0x12345678);
}

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

long[] b4;

long[] func4(int dim)
{
    long[] a = new long[dim];

    b4 = a;
    return a;
}

void test4()
{
    printf("test4()\n");
    int i;
    int j;

    long[1] a1;
    a1[] = 0x123456789ABCDEF0;
    assert(a1[0] == 0x123456789ABCDEF0);

    long[2] a2;
    a2[] = 0x123456789ABCDEF0;
    for (i = 0; i < a2.length; i++)
        assert(a2[i] == 0x123456789ABCDEF0);

    long[3] a3;
    a3[] = 0x123456789ABCDEF0;
    for (i = 0; i < a3.length; i++)
        assert(a3[i] == 0x123456789ABCDEF0);

    long[4] a4;
    a4[] = 0x123456789ABCDEF0;
    for (i = 0; i < a4.length; i++)
        assert(a4[i] == 0x123456789ABCDEF0);

    long[8] a8;
    a8[] = 0x123456789ABCDEF0;
    for (i = 0; i < a8.length; i++)
        assert(a8[i] == 0x123456789ABCDEF0);

    long[27] a27;
    a27[] = 0x123456789ABCDEF0;
    for (i = 0; i < a27.length; i++)
        assert(a27[i] == 0x123456789ABCDEF0);

    func4(33)[] = 0x5678889911223344;
    for (i = 0; i < b4.length; i++)
        assert(b4[i] == 0x5678889911223344);


    long[23] a23 = 0x123456789ABCDEF0;
    i = 16;
    j = 18;
    a23[i++..++j] = 0x567888991122334B;
    printf("i = %d, j = %d\n", i, j);
    assert(i == 17);
    assert(j == 19);
    assert(a23[15] == 0x123456789ABCDEF0);
    assert(a23[16] == 0x567888991122334B);
    assert(a23[17] == 0x567888991122334B);
    assert(a23[18] == 0x567888991122334B);
    assert(a23[19] == 0x123456789ABCDEF0);
    assert(a23[20] == 0x123456789ABCDEF0);
}

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

real[] b5;

real[] func5(int dim)
{
    real[] a = new real[dim];

    b5 = a;
    return a;
}

void test5()
{
    printf("test5()\n");
    int i;
    int j;

    real[1] a1;
    a1[] = 31234;
    assert(a1[0] == 31234);

    real[2] a2;
    a2[] = 31234;
    for (i = 0; i < a2.length; i++)
        assert(a2[i] == 31234);

    real[3] a3;
    a3[] = 31234;
    for (i = 0; i < a3.length; i++)
        assert(a3[i] == 31234);

    real[4] a4;
    a4[] = 31234;
    for (i = 0; i < a4.length; i++)
        assert(a4[i] == 31234);

    real[8] a8;
    a8[] = 31234;
    for (i = 0; i < a8.length; i++)
        assert(a8[i] == 31234);

    real[27] a27;
    a27[] = 31234;
    for (i = 0; i < a27.length; i++)
        assert(a27[i] == 31234);

    func5(33)[] = 35678;
    for (i = 0; i < b5.length; i++)
        assert(b5[i] == 35678);


    real[23] a23 = 31234;
    i = 16;
    j = 18;
    a23[i++..++j] = 34554e+4;
    printf("i = %d, j = %d\n", i, j);
    assert(i == 17);
    assert(j == 19);
    assert(a23[15] == 31234);
    assert(a23[16] == 34554e+4);
    assert(a23[17] == 34554e+4);
    assert(a23[18] == 34554e+4);
    assert(a23[19] == 31234);
    assert(a23[20] == 31234);
}

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

struct ABC
{
    int a,b,c,d;
}

ABC abc1 = { a:1, b:2, c:3, d:4 };
ABC abc2 = { a:7, b:6, c:8, d:9 };
ABC abc3 = { a:5, b:10, c:11, d:12 };

ABC[] b6;

ABC[] func6(int dim)
{
    ABC[] a = new ABC[dim];

    b6 = a;
    return a;
}

void test6()
{
    printf("test6()\n");
    int i;
    int j;

    ABC[1] a1;
    a1[] = abc1;
    assert(a1[0] == abc1);

    ABC[2] a2;
    a2[] = abc1;
    for (i = 0; i < a2.length; i++)
        assert(a2[i] == abc1);

    ABC[3] a3;
    a3[] = abc1;
    for (i = 0; i < a3.length; i++)
        assert(a3[i] == abc1);

    ABC[4] a4;
    a4[] = abc1;
    for (i = 0; i < a4.length; i++)
        assert(a4[i] == abc1);

    ABC[8] a8;
    a8[] = abc1;
    for (i = 0; i < a8.length; i++)
        assert(a8[i] == abc1);

    ABC[27] a27;
    a27[] = abc1;
    for (i = 0; i < a27.length; i++)
        assert(a27[i] == abc1);

    func6(33)[] = abc2;
    for (i = 0; i < b6.length; i++)
        assert(b6[i] == abc2);


    ABC[23] a23 = abc1;
    i = 16;
    j = 18;
    a23[i++..++j] = abc3;
    printf("i = %d, j = %d\n", i, j);
    assert(i == 17);
    assert(j == 19);
    assert(a23[15] == abc1);
    assert(a23[16] == abc3);
    assert(a23[17] == abc3);
    assert(a23[18] == abc3);
    assert(a23[19] == abc1);
    assert(a23[20] == abc1);
}

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

bool[] b7;

bool[] func7(int dim)
{
    bool[] a = new bool[dim];

    b7 = a;
    return a;
}

void test7()
{
    printf("test7()\n");
    int i;
    int j;

    bool[1] a1;
    a1[] = 1;
    assert(a1[0] == 1);

    bool[2] a2;
    a2[] = 1;
    for (i = 0; i < a2.length; i++)
        assert(a2[i] == 1);

    bool[3] a3;
    a3[] = 1;
    for (i = 0; i < a3.length; i++)
        assert(a3[i] == 1);

    bool[4] a4;
    a4[] = 1;
    for (i = 0; i < a4.length; i++)
        assert(a4[i] == 1);

    bool[8] a8;
    a8[] = 1;
    for (i = 0; i < a8.length; i++)
        assert(a8[i] == 1);

    bool[27] a27;
    a27[] = 1;
    for (i = 0; i < a27.length; i++)
        assert(a27[i] == 1);

    func7(33)[] = 1;
    assert(b7.length == 33);
    for (i = 0; i < b7.length; i++)
        assert(b7[i] == 1);

    func7(33)[3..6] = 1;
    //printf("b7.ptr = %p, b7.length = %d\n", b7.ptr, b7.length);
    assert(b7.length == 33);
    for (i = 0; i < b7.length; i++)
    {
        //printf("b7[%d] = %d\n", i, b7[i]);
        if (i >= 3 && i < 6)
            assert(b7[i] == 1);
        else
            assert(b7[i] == 0);
    }

    bool[23] a23 = 1;
    i = 16;
    j = 18;
    a23[i++..++j] = 0;
    printf("i = %d, j = %d\n", i, j);
    assert(i == 17);
    assert(j == 19);
    assert(a23[15] == 1);
    assert(a23[16] == 0);
    assert(a23[17] == 0);
    assert(a23[18] == 0);
    assert(a23[19] == 1);
    assert(a23[20] == 1);

}

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

bool[] slice8(bool[] b)
{
    return b[8..16];
}

void test8()
{
    bool[16] b;
    bool[] b2;
    b[9] = true;
    b2 = slice8(b);
    assert(b2.length == 8);
    assert(b2[1] == true);
    b[9] = false;
    assert(b2[1] == false);
}


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

bool[] slice9(bool[] b, int i, int j)
{
    return b[i..j];
}

void test9()
{
    bool[17] b;
    bool[] b2;
    b[9] = true;
    b[16] = true;
    b2 = slice9(b,8,17);
    assert(b2.length == 9);
    assert(b2[1] == true);
    assert(b2[8] == true);
    b[9] = false;
    b[16] = false;
    assert(b2[1] == false);
    assert(b2[8] == false);
}


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

bool* foo10(bool[] b, int i)
{
    return &b[i];
}

void test10()
{
    bool[17] b;
    bool* pb;

    b[8] = true;
    b[9] = true;
    pb = foo10(b, 8);
    assert(*pb == true);
    b[8] = false;
    assert(*pb == false);
}

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

bool* foo11(bool[] b, int i)
{
    return &b[i];
}

void test11()
{
    bool[17] b;
    bool* pb;

    b[9] = true;
    b[10] = true;
    pb = foo11(b, 8);
    assert(pb[1] == true);
    b[9] = false;
    assert(pb[1] == false);
}


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

bool* foo12(bool[] b, int i)
{
    return &b[i];
}

void test12()
{
    bool[17] b;
    bool* pb;

    b[9] = true;
    b[10] = true;
    pb = foo12(b, 0);
    pb = pb + 8;
    assert(pb[1] == true);
    b[9] = false;
    assert(pb[1] == false);
}

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

bool* foo13(bool* b, int i)
{
    return &b[i];
}

void test13()
{
    bool[17] b;
    bool* pb;

    b[9] = true;
    b[10] = true;
    pb = foo13(b.ptr, 8);
    assert(pb[1] == true);
    b[9] = false;
    assert(pb[1] == false);
}

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

void test14()
{
    bool b = true;
    assert(b);
    b = !b;
    assert(!b);
}

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

void test15()
{
   bool b = 1;
   bool *pb = &b;
   *pb = false;
   assert(!b);
}


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

void foo16(bool[] b1, bool[] b2)
{
    b1[0..3] = b2[8..11];
}

void test16()
{
    static bool[16] b1 = [1,1,0,1,0,0,0,0];
    static bool[16] b2 = [0,0,0,0,0,0,0,0, 0,0,1,0,1,1,1,1];

    foo16(b1, b2);
    assert(b1[0] == false);
    assert(b1[1] == false);
    assert(b1[2] == true);
    assert(b1[3] == true);
    assert(b1[4] == false);
    assert(b1[5] == false);
    assert(b1[6] == false);
    assert(b1[7] == false);
    assert(b1[8] == false);
}

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

void test17()
{
  bool bi = true;
  byte by;

  by=bi;
  assert(by == 1);
}


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

void test18()
{
    bool b = 1;
    bool c = 1;
    b |= cast(bool)(3 + c);
    assert(b == true);
}


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

void test19()
{
        int i;
        for (i = 0; i < 10; i++){
                version(dummy) i=22;
        }
        assert(i==10);

        char[][] args;
        foreach(char[] p; args){
                version(dummy) int i;
        }
}

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

int main()
{
    test1();
    test2();
    test3();
    test4();
    test5();
    test6();
    test7();
    test8();
    test9();
    test10();
    test11();
    test12();
    test13();
    test14();
    test15();
    test16();
    test17();
    test18();
    test19();

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