[thirdparty/gcc.git] / gcc / testsuite / gdc.test / runnable / stress.d

// RUNNABLE_PHOBOS_TEST
// PERMUTE_ARGS:

import core.stdc.stdio : printf;
import std.string : splitLines;
import std.utf : toUTF16, toUTF32;

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

void test3()
{
    char[] str;
    str ~= "test"; // segfault
}

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

class A {
private:
    int _i;
public:
    this(int i) { _i = i; }
    int i() { return _i; };
}

class B : A {
private:
    char[] s;
public:
    this(int i) { super(i); }
}

int main()
{
    printf("Testing array of Chars\n");
    CHAR();
    printf("Testing array of WChars\n");
    WCHAR();
    printf("Testing array of DChars\n");
    DCHAR();

    printf("Testing array of Bytes\n");
    BYTE();
    printf("Testing array of UBytes\n");
    UBYTE();
    printf("Testing array of Shorts\n");
    SHORT();
    printf("Testing array of UShorts\n");
    USHORT();
    printf("Testing array of Ints\n");
    INT();
    printf("Testing array of UInts\n");
    UINT();
    printf("Testing array of Longs\n");
    LONG();
    printf("Testing array of ULongs\n");
    ULONG();
    printf("Testing array of Floats\n");
    FLOAT();
    printf("Testing array of Doubles\n");
    DOUBLE();
    printf("Testing array of Reals\n");
    REAL();

    printf("Testing multi-dim array of Chars\n");
    MDCHAR();

    printf("Testing array of Objects\n");
    CLASS();

    test3();
    return 0;
}

void MDCHAR()
{
    const int ITERS = 100;
    alias char typ;
    typ[][] str;

    str.length = ITERS;
    for(int idx = 0; idx < ITERS; idx++) {
        str[idx] = str[idx] ~ "TEST LINE\n";
    }

    if(str.length != ITERS) printf("Length Error: %zd\n",str.length);
    if(str[0].length != 10) printf("Length Error: %zd\n",str[0].length);
    if(str[ITERS-1].sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",str[ITERS-1].sizeof);
    if(str[ITERS-1][0].sizeof != (typ).sizeof) printf("Size Error: %zd\n",str[ITERS-1][0].sizeof);

    foreach(s; str) {
        size_t lstart;
        foreach(size_t idx, char c; s) {
            if(c == '\n') {
                typ[] t = s[lstart..idx];
                if(t != "TEST LINE") {
                    printf("Error testing character array\n");
                    break;
                }
                lstart = idx + 1;
            }
        }
    }

    typ[] tmp;
    foreach(char[] s; str) {
        tmp = tmp ~ s;
    }

    foreach(s; splitLines(cast(string)tmp)) {
        size_t lstart;
        foreach(size_t idx, char c; s) {
            if(c == '\n') {
                if(s[lstart..idx] != "TEST LINE") {
                    printf("Error testing character array\n");
                    break;
                }
                lstart = idx + 1;
            }
        }
    }
}

void CHAR()
{
    const int ITERS = 1000;
    alias char typ;
    typ[] str;

    for(int idx = 0; idx < ITERS; idx++) {
        str = str ~ "TEST LINE\n";
    }

    if(str.length != (ITERS * 10)) printf("Length Error: %zd\n",str.length);
    if(str.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",str.sizeof);

    size_t lstart;
    foreach(size_t idx, char c; str) {
        if(c == '\n') {
            if(str[lstart..idx] != "TEST LINE") {
                printf("Error testing character array\n");
                break;
            }
            lstart = idx + 1;
        }
    }
}

void WCHAR()
{
    const int ITERS = 1000;
    alias wchar typ;
    typ[] str;

    for(int idx = 0; idx < ITERS; idx++) {
        str = str ~ toUTF16(cast(char[])"TEST LINE\n");
    }

    if(str.length != (ITERS * 10)) printf("Length Error: %zd\n",str.length);
    if(str.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",str.sizeof);

    size_t lstart;
    foreach(size_t idx, char c; str) {
        if(c == '\n') {
            if(str[lstart..idx] != toUTF16(cast(char[])"TEST LINE")) {
                printf("Error testing character array\n");
                break;
            }
            lstart = idx + 1;
        }
    }
}

void DCHAR()
{
    const int ITERS = 1000;
    alias dchar typ;
    typ[] str;

    for(int idx = 0; idx < ITERS; idx++) {
        str = str ~ toUTF32(cast(char[])"TEST LINE\n");
    }

    if(str.length != (ITERS * 10)) printf("Length Error: %zd\n",str.length);
    if(str.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",str.sizeof);

    size_t lstart;
    foreach(size_t idx, char c; str) {
        if(c == '\n') {
            if(str[lstart..idx] != toUTF32(cast(char[])"TEST LINE")) {
                printf("Error testing character array\n");
                break;
            }
            lstart = idx + 1;
        }
    }
}

void BYTE()
{
    const int ITERS = 100;
    alias byte typ;
    typ[] a;

    for(typ idx = 0; idx < ITERS; idx++) {
        a ~= idx;
    }

    if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
    if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(a[idx] != idx) {
            printf("a Data Error: %d\n",a[idx]);
            break;
        }
    }


    typ[] b = a[];

    if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
    if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(b[idx] != idx) {
            printf("b Data Error: %d\n",b[idx]);
            break;
        }
    }
    typ[] c;
    c = a[0..ITERS/2] ~ b[ITERS/2..$];


    if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
    if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(c[idx] != idx) {
            printf("c Data Error: %d\n",c[idx]);
            break;
        }
    }
}

void UBYTE()
{
    const int ITERS = 100;
    alias ubyte typ;
    typ[] a;

    for(typ idx = 0; idx < ITERS; idx++) {
        a ~= idx;
    }

    if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
    if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(a[idx] != idx) {
            printf("a Data Error: %d\n",a[idx]);
            break;
        }
    }


    typ[] b = a[];

    if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
    if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(b[idx] != idx) {
            printf("b Data Error: %d\n",b[idx]);
            break;
        }
    }

    typ[] c;
    c = a[0..ITERS/2] ~ b[ITERS/2..$];


    if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
    if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(c[idx] != idx) {
            printf("c Data Error: %d\n",c[idx]);
            break;
        }
    }
}

void SHORT()
{
    const int ITERS = 10000;
    alias short typ;
    typ[] a;

    for(typ idx = 0; idx < ITERS; idx++) {
        a ~= idx;
    }

    if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
    if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(a[idx] != idx) {
            printf("a Data Error: %d\n",a[idx]);
            break;
        }
    }

    typ[] b = a[];

    if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
    if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(b[idx] != idx) {
            printf("b Data Error: %d\n",b[idx]);
            break;
        }
    }

    typ[] c;
    c = a[0..ITERS/2] ~ b[ITERS/2..$];


    if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
    if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(c[idx] != idx) {
            printf("c Data Error: %d\n",c[idx]);
            break;
        }
    }
}

void USHORT()
{
    const int ITERS = 10000;
    alias ushort typ;
    typ[] a;

    for(typ idx = 0; idx < ITERS; idx++) {
        a ~= idx;
    }

    if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
    if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(a[idx] != idx) {
            printf("a Data Error: %d\n",a[idx]);
            break;
        }
    }

    typ[] b = a[];

    if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
    if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(b[idx] != idx) {
            printf("b Data Error: %d\n",b[idx]);
            break;
        }
    }

    typ[] c;
    c = a[0..ITERS/2] ~ b[ITERS/2..$];


    if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
    if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(c[idx] != idx) {
            printf("c Data Error: %d\n",c[idx]);
            break;
        }
    }
}

void INT()
{
    const int ITERS = 1000000;
    alias int typ;
    typ[] a;

    for(int idx = 0; idx < ITERS; idx++) {
        a ~= idx;
    }

    if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
    if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(a[idx] != idx) {
            printf("a Data Error: %d\n",a[idx]);
            break;
        }
    }


    typ[] b = a[];

    if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
    if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(b[idx] != idx) {
            printf("b Data Error: %d\n",b[idx]);
            break;
        }
    }

    typ[] c;
    c = a[0..ITERS/2] ~ b[ITERS/2..$];


    if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
    if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(c[idx] != idx) {
            printf("c Data Error: %d\n",c[idx]);
            break;
        }
    }
}

void UINT()
{
    const int ITERS = 1000000;
    alias uint typ;
    typ[] a;

    for(int idx = 0; idx < ITERS; idx++) {
        a ~= idx;
    }

    if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
    if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(a[idx] != idx) {
            printf("a Data Error: %d\n",a[idx]);
            break;
        }
    }


    typ[] b = a[];

    if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
    if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(b[idx] != idx) {
            printf("b Data Error: %d\n",b[idx]);
            break;
        }
    }

    typ[] c;
    c = a[0..ITERS/2] ~ b[ITERS/2..$];


    if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
    if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(c[idx] != idx) {
            printf("c Data Error: %d\n",c[idx]);
            break;
        }
    }
}

void LONG()
{
    const int ITERS = 1000000;
    alias long typ;
    typ[] a;

    for(int idx = 0; idx < ITERS; idx++) {
        a ~= idx;
    }

    if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
    if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(a[idx] != idx) {
            printf("a Data Error: %lld\n",a[idx]);
            break;
        }
    }

    typ[] b = a[];

    if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
    if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(b[idx] != idx) {
            printf("b Data Error: %lld\n",b[idx]);
            break;
        }
    }

    typ[] c;
    c = a[0..ITERS/2] ~ b[ITERS/2..$];


    if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
    if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(c[idx] != idx) {
            printf("c Data Error: %lld\n",c[idx]);
            break;
        }
    }
}

void ULONG()
{
    const int ITERS = 1000000;
    alias ulong typ;
    typ[] a;

    for(int idx = 0; idx < ITERS; idx++) {
        a ~= idx;
    }

    if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
    if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(a[idx] != idx) {
            printf("a Data Error: %lld\n",a[idx]);
            break;
        }
    }

    typ[] b = a[];

    if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
    if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(b[idx] != idx) {
            printf("b Data Error: %lld\n",b[idx]);
            break;
        }
    }

    typ[] c;
    c = a[0..ITERS/2] ~ b[ITERS/2..$];


    if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
    if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(c[idx] != idx) {
            printf("c Data Error: %lld\n",c[idx]);
            break;
        }
    }
}

void FLOAT()
{
    const int ITERS = 1000000;
    alias float typ;
    typ[] a;

    for(int idx = 0; idx < ITERS; idx++) {
        a ~= idx;
    }

    if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
    if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(a[idx] != idx) {
            printf("a Data Error: %g\n",a[idx]);
            break;
        }
    }

    typ[] b = a[];

    if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
    if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(b[idx] != idx) {
            printf("b Data Error: %g\n",b[idx]);
            break;
        }
    }

    typ[] c;
    c = a[0..ITERS/2] ~ b[ITERS/2..$];


    if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
    if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(c[idx] != idx) {
            printf("c Data Error: %g\n",c[idx]);
            break;
        }
    }
}

void DOUBLE()
{
    const int ITERS = 1000000;
    alias double typ;
    typ[] a;

    for(int idx = 0; idx < ITERS; idx++) {
        a ~= idx;
    }

    if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
    if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(a[idx] != idx) {
            printf("a Data Error: %g\n",a[idx]);
            break;
        }
    }

    typ[] b = a[];

    if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
    if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(b[idx] != idx) {
            printf("b Data Error: %g\n",b[idx]);
            break;
        }
    }

    typ[] c;
    c = a[0..ITERS/2] ~ b[ITERS/2..$];


    if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
    if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(c[idx] != idx) {
            printf("c Data Error: %g\n",c[idx]);
            break;
        }
    }
}

void REAL()
{
    const int ITERS = 1000000;
    alias real typ;
    typ[] a;

    for(int idx = 0; idx < ITERS; idx++) {
        a ~= idx;
    }

    if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
    if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(a[idx] != idx) {
            printf("a Data Error: %Lg\n",a[idx]);
            break;
        }
    }

    typ[] b = a[];

    if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
    if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(b[idx] != idx) {
            printf("b Data Error: %Lg\n",b[idx]);
            break;
        }
    }

    typ[] c;
    c = a[0..ITERS/2] ~ b[ITERS/2..$];


    if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
    if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(c[idx] != idx) {
            printf("c Data Error: %Lg\n",c[idx]);
            break;
        }
    }
}

void CLASS()
{
    const int ITERS = 1000000;
    alias B typ;
    typ[] a;

    for(int idx = 0; idx < ITERS; idx++) {
        typ tc = new typ(idx);
        a ~= tc;
    }

    if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
    if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(a[idx].i != idx) {
            printf("a Data Error: %d\n",a[idx].i);
            break;
        }
    }

    typ[] b = a[];

    if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
    if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(b[idx].i != idx) {
            printf("b Data Error: %d\n",b[idx].i);
            break;
        }
    }

    typ[] c;
    c = a[0..ITERS/2] ~ b[ITERS/2..$];

    if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
    if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
    for(int idx = 0; idx < ITERS; idx++) {
        if(c[idx].i != idx) {
            printf("c Data Error: %d\n",c[idx].i);
            break;
        }
    }
}
Commit	Line	Data
01873032	1	// RUNNABLE_PHOBOS_TEST
b4c522fa IB	2	// PERMUTE_ARGS:
	3
	4	import core.stdc.stdio : printf;
	5	import std.string : splitLines;
	6	import std.utf : toUTF16, toUTF32;
	7
	8	/***********************************************/
	9
	10	void test3()
	11	{
	12	char[] str;
	13	str ~= "test"; // segfault
	14	}
	15
	16	/***********************************************/
	17
	18	class A {
	19	private:
	20	int _i;
	21	public:
	22	this(int i) { _i = i; }
	23	int i() { return _i; };
	24	}
	25
	26	class B : A {
	27	private:
	28	char[] s;
	29	public:
	30	this(int i) { super(i); }
	31	}
	32
	33	int main()
	34	{
	35	printf("Testing array of Chars\n");
	36	CHAR();
	37	printf("Testing array of WChars\n");
	38	WCHAR();
	39	printf("Testing array of DChars\n");
	40	DCHAR();
	41
	42	printf("Testing array of Bytes\n");
	43	BYTE();
	44	printf("Testing array of UBytes\n");
	45	UBYTE();
	46	printf("Testing array of Shorts\n");
	47	SHORT();
	48	printf("Testing array of UShorts\n");
	49	USHORT();
	50	printf("Testing array of Ints\n");
	51	INT();
	52	printf("Testing array of UInts\n");
	53	UINT();
	54	printf("Testing array of Longs\n");
	55	LONG();
	56	printf("Testing array of ULongs\n");
	57	ULONG();
	58	printf("Testing array of Floats\n");
	59	FLOAT();
	60	printf("Testing array of Doubles\n");
	61	DOUBLE();
	62	printf("Testing array of Reals\n");
	63	REAL();
	64
	65	printf("Testing multi-dim array of Chars\n");
66	MDCHAR();
67
68	printf("Testing array of Objects\n");
69	CLASS();
70
71	test3();
72	return 0;
73	}
74
75	void MDCHAR()
76	{
77	const int ITERS = 100;
78	alias char typ;
79	typ[][] str;
80
81	str.length = ITERS;
82	for(int idx = 0; idx < ITERS; idx++) {
83	str[idx] = str[idx] ~ "TEST LINE\n";
84	}
85
5fee5ec3 IB	86	if(str.length != ITERS) printf("Length Error: %zd\n",str.length);
	87	if(str[0].length != 10) printf("Length Error: %zd\n",str[0].length);
	88	if(str[ITERS-1].sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",str[ITERS-1].sizeof);
	89	if(str[ITERS-1][0].sizeof != (typ).sizeof) printf("Size Error: %zd\n",str[ITERS-1][0].sizeof);
b4c522fa IB	90
b4c522fa IB	91	foreach(s; str) {
7da827c9 IB	92	size_t lstart;
7da827c9 IB	93	foreach(size_t idx, char c; s) {
b4c522fa IB	94	if(c == '\n') {
	95	typ[] t = s[lstart..idx];
	96	if(t != "TEST LINE") {
	97	printf("Error testing character array\n");
	98	break;
	99	}
	100	lstart = idx + 1;
	101	}
	102	}
	103	}
	104
	105	typ[] tmp;
	106	foreach(char[] s; str) {
	107	tmp = tmp ~ s;
	108	}
	109
	110	foreach(s; splitLines(cast(string)tmp)) {
7da827c9 IB	111	size_t lstart;
7da827c9 IB	112	foreach(size_t idx, char c; s) {
b4c522fa IB	113	if(c == '\n') {
	114	if(s[lstart..idx] != "TEST LINE") {
	115	printf("Error testing character array\n");
	116	break;
	117	}
	118	lstart = idx + 1;
	119	}
	120	}
	121	}
	122	}
	123
	124	void CHAR()
	125	{
	126	const int ITERS = 1000;
	127	alias char typ;
	128	typ[] str;
	129
	130	for(int idx = 0; idx < ITERS; idx++) {
	131	str = str ~ "TEST LINE\n";
	132	}
	133
5fee5ec3 IB	134	if(str.length != (ITERS * 10)) printf("Length Error: %zd\n",str.length);
5fee5ec3 IB	135	if(str.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",str.sizeof);
b4c522fa	136
7da827c9 IB	137	size_t lstart;
7da827c9 IB	138	foreach(size_t idx, char c; str) {
b4c522fa IB	139	if(c == '\n') {
	140	if(str[lstart..idx] != "TEST LINE") {
	141	printf("Error testing character array\n");
	142	break;
	143	}
	144	lstart = idx + 1;
	145	}
	146	}
	147	}
	148
	149	void WCHAR()
	150	{
	151	const int ITERS = 1000;
	152	alias wchar typ;
	153	typ[] str;
	154
	155	for(int idx = 0; idx < ITERS; idx++) {
	156	str = str ~ toUTF16(cast(char[])"TEST LINE\n");
	157	}
	158
5fee5ec3 IB	159	if(str.length != (ITERS * 10)) printf("Length Error: %zd\n",str.length);
5fee5ec3 IB	160	if(str.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",str.sizeof);
b4c522fa	161
7da827c9 IB	162	size_t lstart;
7da827c9 IB	163	foreach(size_t idx, char c; str) {
b4c522fa IB	164	if(c == '\n') {
	165	if(str[lstart..idx] != toUTF16(cast(char[])"TEST LINE")) {
	166	printf("Error testing character array\n");
	167	break;
	168	}
	169	lstart = idx + 1;
	170	}
	171	}
	172	}
	173
	174	void DCHAR()
	175	{
	176	const int ITERS = 1000;
	177	alias dchar typ;
	178	typ[] str;
	179
	180	for(int idx = 0; idx < ITERS; idx++) {
	181	str = str ~ toUTF32(cast(char[])"TEST LINE\n");
	182	}
	183
5fee5ec3 IB	184	if(str.length != (ITERS * 10)) printf("Length Error: %zd\n",str.length);
5fee5ec3 IB	185	if(str.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",str.sizeof);
b4c522fa	186
7da827c9 IB	187	size_t lstart;
7da827c9 IB	188	foreach(size_t idx, char c; str) {
b4c522fa IB	189	if(c == '\n') {
	190	if(str[lstart..idx] != toUTF32(cast(char[])"TEST LINE")) {
	191	printf("Error testing character array\n");
	192	break;
	193	}
	194	lstart = idx + 1;
	195	}
	196	}
	197	}
	198
	199	void BYTE()
	200	{
	201	const int ITERS = 100;
	202	alias byte typ;
	203	typ[] a;
	204
	205	for(typ idx = 0; idx < ITERS; idx++) {
	206	a ~= idx;
	207	}
	208
5fee5ec3 IB	209	if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
5fee5ec3 IB	210	if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
b4c522fa IB	211	for(int idx = 0; idx < ITERS; idx++) {
	212	if(a[idx] != idx) {
	213	printf("a Data Error: %d\n",a[idx]);
	214	break;
	215	}
	216	}
	217
	218
	219	typ[] b = a[];
	220
5fee5ec3 IB	221	if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
5fee5ec3 IB	222	if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
b4c522fa IB	223	for(int idx = 0; idx < ITERS; idx++) {
	224	if(b[idx] != idx) {
	225	printf("b Data Error: %d\n",b[idx]);
	226	break;
	227	}
	228	}
	229	typ[] c;
	230	c = a[0..ITERS/2] ~ b[ITERS/2..$];
	231
	232
5fee5ec3 IB	233	if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
5fee5ec3 IB	234	if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
b4c522fa IB	235	for(int idx = 0; idx < ITERS; idx++) {
	236	if(c[idx] != idx) {
	237	printf("c Data Error: %d\n",c[idx]);
	238	break;
	239	}
	240	}
	241	}
	242
	243	void UBYTE()
	244	{
	245	const int ITERS = 100;
	246	alias ubyte typ;
	247	typ[] a;
	248
	249	for(typ idx = 0; idx < ITERS; idx++) {
	250	a ~= idx;
	251	}
	252
5fee5ec3 IB	253	if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
5fee5ec3 IB	254	if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
b4c522fa IB	255	for(int idx = 0; idx < ITERS; idx++) {
	256	if(a[idx] != idx) {
	257	printf("a Data Error: %d\n",a[idx]);
	258	break;
	259	}
	260	}
	261
	262
	263	typ[] b = a[];
	264
5fee5ec3 IB	265	if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
5fee5ec3 IB	266	if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
b4c522fa IB	267	for(int idx = 0; idx < ITERS; idx++) {
	268	if(b[idx] != idx) {
	269	printf("b Data Error: %d\n",b[idx]);
	270	break;
	271	}
	272	}
	273
	274	typ[] c;
	275	c = a[0..ITERS/2] ~ b[ITERS/2..$];
	276
	277
5fee5ec3 IB	278	if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
5fee5ec3 IB	279	if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
b4c522fa IB	280	for(int idx = 0; idx < ITERS; idx++) {
	281	if(c[idx] != idx) {
	282	printf("c Data Error: %d\n",c[idx]);
	283	break;
	284	}
	285	}
	286	}
	287
	288	void SHORT()
	289	{
	290	const int ITERS = 10000;
	291	alias short typ;
	292	typ[] a;
	293
	294	for(typ idx = 0; idx < ITERS; idx++) {
	295	a ~= idx;
	296	}
	297
5fee5ec3 IB	298	if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
5fee5ec3 IB	299	if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
b4c522fa IB	300	for(int idx = 0; idx < ITERS; idx++) {
	301	if(a[idx] != idx) {
	302	printf("a Data Error: %d\n",a[idx]);
	303	break;
	304	}
	305	}
	306
	307	typ[] b = a[];
	308
5fee5ec3 IB	309	if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
5fee5ec3 IB	310	if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
b4c522fa IB	311	for(int idx = 0; idx < ITERS; idx++) {
	312	if(b[idx] != idx) {
	313	printf("b Data Error: %d\n",b[idx]);
	314	break;
	315	}
	316	}
	317
	318	typ[] c;
	319	c = a[0..ITERS/2] ~ b[ITERS/2..$];
	320
	321
5fee5ec3 IB	322	if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
5fee5ec3 IB	323	if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
b4c522fa IB	324	for(int idx = 0; idx < ITERS; idx++) {
	325	if(c[idx] != idx) {
	326	printf("c Data Error: %d\n",c[idx]);
	327	break;
	328	}
	329	}
	330	}
	331
	332	void USHORT()
	333	{
	334	const int ITERS = 10000;
	335	alias ushort typ;
	336	typ[] a;
	337
	338	for(typ idx = 0; idx < ITERS; idx++) {
	339	a ~= idx;
	340	}
	341
5fee5ec3 IB	342	if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
5fee5ec3 IB	343	if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
b4c522fa IB	344	for(int idx = 0; idx < ITERS; idx++) {
	345	if(a[idx] != idx) {
	346	printf("a Data Error: %d\n",a[idx]);
	347	break;
	348	}
	349	}
	350
	351	typ[] b = a[];
	352
5fee5ec3 IB	353	if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
5fee5ec3 IB	354	if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
b4c522fa IB	355	for(int idx = 0; idx < ITERS; idx++) {
	356	if(b[idx] != idx) {
	357	printf("b Data Error: %d\n",b[idx]);
	358	break;
	359	}
	360	}
	361
	362	typ[] c;
	363	c = a[0..ITERS/2] ~ b[ITERS/2..$];
	364
	365
5fee5ec3 IB	366	if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
5fee5ec3 IB	367	if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
b4c522fa IB	368	for(int idx = 0; idx < ITERS; idx++) {
	369	if(c[idx] != idx) {
	370	printf("c Data Error: %d\n",c[idx]);
	371	break;
	372	}
	373	}
	374	}
	375
	376	void INT()
	377	{
	378	const int ITERS = 1000000;
	379	alias int typ;
	380	typ[] a;
	381
	382	for(int idx = 0; idx < ITERS; idx++) {
	383	a ~= idx;
	384	}
	385
5fee5ec3 IB	386	if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
5fee5ec3 IB	387	if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
b4c522fa IB	388	for(int idx = 0; idx < ITERS; idx++) {
	389	if(a[idx] != idx) {
	390	printf("a Data Error: %d\n",a[idx]);
	391	break;
	392	}
	393	}
	394
	395
	396	typ[] b = a[];
	397
5fee5ec3 IB	398	if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
5fee5ec3 IB	399	if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
b4c522fa IB	400	for(int idx = 0; idx < ITERS; idx++) {
	401	if(b[idx] != idx) {
	402	printf("b Data Error: %d\n",b[idx]);
	403	break;
	404	}
	405	}
	406
	407	typ[] c;
	408	c = a[0..ITERS/2] ~ b[ITERS/2..$];
	409
	410
5fee5ec3 IB	411	if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
5fee5ec3 IB	412	if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
b4c522fa IB	413	for(int idx = 0; idx < ITERS; idx++) {
	414	if(c[idx] != idx) {
	415	printf("c Data Error: %d\n",c[idx]);
	416	break;
	417	}
	418	}
	419	}
	420
	421	void UINT()
	422	{
	423	const int ITERS = 1000000;
	424	alias uint typ;
	425	typ[] a;
	426
	427	for(int idx = 0; idx < ITERS; idx++) {
	428	a ~= idx;
	429	}
	430
5fee5ec3 IB	431	if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
5fee5ec3 IB	432	if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
b4c522fa IB	433	for(int idx = 0; idx < ITERS; idx++) {
	434	if(a[idx] != idx) {
	435	printf("a Data Error: %d\n",a[idx]);
	436	break;
	437	}
	438	}
	439
	440
	441	typ[] b = a[];
	442
5fee5ec3 IB	443	if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
5fee5ec3 IB	444	if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
b4c522fa IB	445	for(int idx = 0; idx < ITERS; idx++) {
	446	if(b[idx] != idx) {
	447	printf("b Data Error: %d\n",b[idx]);
	448	break;
	449	}
	450	}
	451
	452	typ[] c;
	453	c = a[0..ITERS/2] ~ b[ITERS/2..$];
	454
	455
5fee5ec3 IB	456	if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
5fee5ec3 IB	457	if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
b4c522fa IB	458	for(int idx = 0; idx < ITERS; idx++) {
	459	if(c[idx] != idx) {
	460	printf("c Data Error: %d\n",c[idx]);
	461	break;
	462	}
	463	}
	464	}
	465
	466	void LONG()
	467	{
	468	const int ITERS = 1000000;
	469	alias long typ;
	470	typ[] a;
	471
	472	for(int idx = 0; idx < ITERS; idx++) {
	473	a ~= idx;
	474	}
	475
5fee5ec3 IB	476	if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
5fee5ec3 IB	477	if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
b4c522fa IB	478	for(int idx = 0; idx < ITERS; idx++) {
b4c522fa IB	479	if(a[idx] != idx) {
5fee5ec3	480	printf("a Data Error: %lld\n",a[idx]);
b4c522fa IB	481	break;
	482	}
	483	}
	484
	485	typ[] b = a[];
	486
5fee5ec3 IB	487	if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
5fee5ec3 IB	488	if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
b4c522fa IB	489	for(int idx = 0; idx < ITERS; idx++) {
b4c522fa IB	490	if(b[idx] != idx) {
5fee5ec3	491	printf("b Data Error: %lld\n",b[idx]);
b4c522fa IB	492	break;
	493	}
	494	}
	495
	496	typ[] c;
	497	c = a[0..ITERS/2] ~ b[ITERS/2..$];
	498
	499
5fee5ec3 IB	500	if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
5fee5ec3 IB	501	if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
b4c522fa IB	502	for(int idx = 0; idx < ITERS; idx++) {
b4c522fa IB	503	if(c[idx] != idx) {
5fee5ec3	504	printf("c Data Error: %lld\n",c[idx]);
b4c522fa IB	505	break;
	506	}
	507	}
	508	}
	509
	510	void ULONG()
	511	{
	512	const int ITERS = 1000000;
	513	alias ulong typ;
	514	typ[] a;
	515
	516	for(int idx = 0; idx < ITERS; idx++) {
	517	a ~= idx;
	518	}
	519
5fee5ec3 IB	520	if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
5fee5ec3 IB	521	if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
b4c522fa IB	522	for(int idx = 0; idx < ITERS; idx++) {
b4c522fa IB	523	if(a[idx] != idx) {
5fee5ec3	524	printf("a Data Error: %lld\n",a[idx]);
b4c522fa IB	525	break;
	526	}
	527	}
	528
	529	typ[] b = a[];
	530
5fee5ec3 IB	531	if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
5fee5ec3 IB	532	if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
b4c522fa IB	533	for(int idx = 0; idx < ITERS; idx++) {
b4c522fa IB	534	if(b[idx] != idx) {
5fee5ec3	535	printf("b Data Error: %lld\n",b[idx]);
b4c522fa IB	536	break;
	537	}
	538	}
	539
	540	typ[] c;
	541	c = a[0..ITERS/2] ~ b[ITERS/2..$];
	542
	543
5fee5ec3 IB	544	if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
5fee5ec3 IB	545	if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
b4c522fa IB	546	for(int idx = 0; idx < ITERS; idx++) {
b4c522fa IB	547	if(c[idx] != idx) {
5fee5ec3	548	printf("c Data Error: %lld\n",c[idx]);
b4c522fa IB	549	break;
	550	}
	551	}
	552	}
	553
	554	void FLOAT()
	555	{
	556	const int ITERS = 1000000;
	557	alias float typ;
	558	typ[] a;
	559
	560	for(int idx = 0; idx < ITERS; idx++) {
	561	a ~= idx;
	562	}
	563
5fee5ec3 IB	564	if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
5fee5ec3 IB	565	if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
b4c522fa IB	566	for(int idx = 0; idx < ITERS; idx++) {
b4c522fa IB	567	if(a[idx] != idx) {
5fee5ec3	568	printf("a Data Error: %g\n",a[idx]);
b4c522fa IB	569	break;
	570	}
	571	}
	572
	573	typ[] b = a[];
	574
5fee5ec3 IB	575	if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
5fee5ec3 IB	576	if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
b4c522fa IB	577	for(int idx = 0; idx < ITERS; idx++) {
b4c522fa IB	578	if(b[idx] != idx) {
5fee5ec3	579	printf("b Data Error: %g\n",b[idx]);
b4c522fa IB	580	break;
	581	}
	582	}
	583
	584	typ[] c;
	585	c = a[0..ITERS/2] ~ b[ITERS/2..$];
	586
	587
5fee5ec3 IB	588	if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
5fee5ec3 IB	589	if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
b4c522fa IB	590	for(int idx = 0; idx < ITERS; idx++) {
b4c522fa IB	591	if(c[idx] != idx) {
5fee5ec3	592	printf("c Data Error: %g\n",c[idx]);
b4c522fa IB	593	break;
	594	}
	595	}
	596	}
	597
	598	void DOUBLE()
	599	{
	600	const int ITERS = 1000000;
	601	alias double typ;
	602	typ[] a;
	603
	604	for(int idx = 0; idx < ITERS; idx++) {
	605	a ~= idx;
	606	}
	607
5fee5ec3 IB	608	if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
5fee5ec3 IB	609	if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
b4c522fa IB	610	for(int idx = 0; idx < ITERS; idx++) {
b4c522fa IB	611	if(a[idx] != idx) {
5fee5ec3	612	printf("a Data Error: %g\n",a[idx]);
b4c522fa IB	613	break;
	614	}
	615	}
	616
	617	typ[] b = a[];
	618
5fee5ec3 IB	619	if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
5fee5ec3 IB	620	if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
b4c522fa IB	621	for(int idx = 0; idx < ITERS; idx++) {
b4c522fa IB	622	if(b[idx] != idx) {
5fee5ec3	623	printf("b Data Error: %g\n",b[idx]);
b4c522fa IB	624	break;
	625	}
	626	}
	627
	628	typ[] c;
	629	c = a[0..ITERS/2] ~ b[ITERS/2..$];
	630
	631
5fee5ec3 IB	632	if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
5fee5ec3 IB	633	if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
b4c522fa IB	634	for(int idx = 0; idx < ITERS; idx++) {
b4c522fa IB	635	if(c[idx] != idx) {
5fee5ec3	636	printf("c Data Error: %g\n",c[idx]);
b4c522fa IB	637	break;
	638	}
	639	}
	640	}
	641
	642	void REAL()
	643	{
	644	const int ITERS = 1000000;
	645	alias real typ;
	646	typ[] a;
	647
	648	for(int idx = 0; idx < ITERS; idx++) {
	649	a ~= idx;
	650	}
	651
5fee5ec3 IB	652	if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
5fee5ec3 IB	653	if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
b4c522fa IB	654	for(int idx = 0; idx < ITERS; idx++) {
b4c522fa IB	655	if(a[idx] != idx) {
5fee5ec3	656	printf("a Data Error: %Lg\n",a[idx]);
b4c522fa IB	657	break;
	658	}
	659	}
	660
	661	typ[] b = a[];
	662
5fee5ec3 IB	663	if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
5fee5ec3 IB	664	if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
b4c522fa IB	665	for(int idx = 0; idx < ITERS; idx++) {
b4c522fa IB	666	if(b[idx] != idx) {
5fee5ec3	667	printf("b Data Error: %Lg\n",b[idx]);
b4c522fa IB	668	break;
	669	}
	670	}
	671
	672	typ[] c;
	673	c = a[0..ITERS/2] ~ b[ITERS/2..$];
	674
	675
5fee5ec3 IB	676	if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
5fee5ec3 IB	677	if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
b4c522fa IB	678	for(int idx = 0; idx < ITERS; idx++) {
b4c522fa IB	679	if(c[idx] != idx) {
5fee5ec3	680	printf("c Data Error: %Lg\n",c[idx]);
b4c522fa IB	681	break;
	682	}
	683	}
	684	}
	685
	686	void CLASS()
	687	{
	688	const int ITERS = 1000000;
	689	alias B typ;
	690	typ[] a;
	691
	692	for(int idx = 0; idx < ITERS; idx++) {
	693	typ tc = new typ(idx);
	694	a ~= tc;
	695	}
	696
5fee5ec3 IB	697	if(a.length != ITERS) printf("Length Error: %zd\n",a.length);
5fee5ec3 IB	698	if(a.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",a.sizeof);
b4c522fa IB	699	for(int idx = 0; idx < ITERS; idx++) {
	700	if(a[idx].i != idx) {
	701	printf("a Data Error: %d\n",a[idx].i);
	702	break;
	703	}
	704	}
	705
	706	typ[] b = a[];
	707
5fee5ec3 IB	708	if(b.length != ITERS) printf("Length Error: %zd\n",b.length);
5fee5ec3 IB	709	if(b.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",b.sizeof);
b4c522fa IB	710	for(int idx = 0; idx < ITERS; idx++) {
	711	if(b[idx].i != idx) {
	712	printf("b Data Error: %d\n",b[idx].i);
	713	break;
	714	}
	715	}
	716
	717	typ[] c;
	718	c = a[0..ITERS/2] ~ b[ITERS/2..$];
	719
5fee5ec3 IB	720	if(c.length != ITERS) printf("Length Error: %zd\n",c.length);
5fee5ec3 IB	721	if(c.sizeof != (typ[]).sizeof) printf("Size Error: %zd\n",c.sizeof);
b4c522fa IB	722	for(int idx = 0; idx < ITERS; idx++) {
	723	if(c[idx].i != idx) {
	724	printf("c Data Error: %d\n",c[idx].i);
	725	break;
	726	}
	727	}
	728	}