957 lines
20 KiB
D
957 lines
20 KiB
D
// RUNNABLE_PHOBOS_TEST
|
|
import std.math;
|
|
|
|
extern(C) int printf(const char*, ...);
|
|
|
|
string abc;
|
|
|
|
template Floating(T)
|
|
{
|
|
T[3] a;
|
|
T[3] b;
|
|
T[3] c;
|
|
|
|
T[] A()
|
|
{
|
|
printf("A\n");
|
|
abc ~= "A";
|
|
return a;
|
|
}
|
|
|
|
T[] B()
|
|
{
|
|
printf("B\n");
|
|
abc ~= "B";
|
|
return b;
|
|
}
|
|
|
|
T[] C()
|
|
{
|
|
printf("C\n");
|
|
abc ~= "C";
|
|
return c;
|
|
}
|
|
|
|
T D()
|
|
{
|
|
printf("D\n");
|
|
abc ~= "D";
|
|
return 4;
|
|
}
|
|
|
|
|
|
void testx()
|
|
{
|
|
a = [11, 22, 33];
|
|
b = [1, 2, 3];
|
|
c = [4, 5, 6];
|
|
|
|
abc = null;
|
|
A()[] = B()[] + C()[];
|
|
assert(abc == "BCA");
|
|
assert(a[0] == 5);
|
|
assert(a[1] == 7);
|
|
assert(a[2] == 9);
|
|
|
|
abc = null;
|
|
A()[] = B()[] + 4;
|
|
assert(abc == "BA");
|
|
assert(a[0] == 5);
|
|
assert(a[1] == 6);
|
|
assert(a[2] == 7);
|
|
|
|
abc = null;
|
|
A()[] = 4 + B()[];
|
|
assert(abc == "BA");
|
|
assert(a[0] == 5);
|
|
assert(a[1] == 6);
|
|
assert(a[2] == 7);
|
|
|
|
abc = null;
|
|
A()[] = D() + B()[];
|
|
assert(abc == "DBA");
|
|
assert(a[0] == 5);
|
|
assert(a[1] == 6);
|
|
assert(a[2] == 7);
|
|
|
|
a = [11, 22, 33];
|
|
abc = null;
|
|
A()[] += B()[];
|
|
assert(abc == "BA");
|
|
assert(a[0] == 12);
|
|
assert(a[1] == 24);
|
|
assert(a[2] == 36);
|
|
|
|
a = [11, 22, 33];
|
|
A()[] += 4;
|
|
assert(a[0] == 15);
|
|
assert(a[1] == 26);
|
|
assert(a[2] == 37);
|
|
|
|
a = [11, 22, 33];
|
|
A()[] -= 4;
|
|
assert(a[0] == 7);
|
|
assert(a[1] == 18);
|
|
assert(a[2] == 29);
|
|
|
|
a = [11, 22, 33];
|
|
A()[] *= 4;
|
|
assert(a[0] == 44);
|
|
assert(a[1] == 88);
|
|
assert(a[2] == 132);
|
|
|
|
a = [4, 8, 32];
|
|
A()[] /= 4;
|
|
assert(a[0] == 1);
|
|
assert(a[1] == 2);
|
|
assert(a[2] == 8);
|
|
|
|
a = [4, 8, 33];
|
|
A()[] %= 4;
|
|
assert(a[0] == 0);
|
|
assert(a[1] == 0);
|
|
assert(a[2] == 1);
|
|
|
|
a = [11, 22, 33];
|
|
abc = null;
|
|
A()[] += 4 + B()[];
|
|
assert(abc == "BA");
|
|
assert(a[0] == 16);
|
|
assert(a[1] == 28);
|
|
assert(a[2] == 40);
|
|
|
|
abc = null;
|
|
A()[] = B()[] - C()[];
|
|
assert(abc == "BCA");
|
|
printf("%Lg, %Lg, %Lg\n", cast(real)a[0], cast(real)a[1], cast(real)a[2]);
|
|
assert(a[0] == -3);
|
|
assert(a[1] == -3);
|
|
assert(a[2] == -3);
|
|
|
|
abc = null;
|
|
A()[] = -B()[] - C()[];
|
|
assert(abc == "BCA");
|
|
printf("%Lg, %Lg, %Lg\n", cast(real)a[0], cast(real)a[1], cast(real)a[2]);
|
|
assert(a[0] == -5);
|
|
assert(a[1] == -7);
|
|
assert(a[2] == -9);
|
|
|
|
abc = null;
|
|
A()[] = B()[] + C()[] * 4;
|
|
assert(abc == "BCA");
|
|
printf("%Lg, %Lg, %Lg\n", cast(real)a[0], cast(real)a[1], cast(real)a[2]);
|
|
assert(a[0] == 17);
|
|
assert(a[1] == 22);
|
|
assert(a[2] == 27);
|
|
|
|
abc = null;
|
|
A()[] = B()[] + C()[] * B()[];
|
|
assert(abc == "BCBA");
|
|
printf("%Lg, %Lg, %Lg\n", cast(real)a[0], cast(real)a[1], cast(real)a[2]);
|
|
assert(a[0] == 5);
|
|
assert(a[1] == 12);
|
|
assert(a[2] == 21);
|
|
|
|
abc = null;
|
|
A()[] = B()[] + C()[] / 2;
|
|
assert(abc == "BCA");
|
|
printf("%Lg, %Lg, %Lg\n", cast(real)a[0], cast(real)a[1], cast(real)a[2]);
|
|
assert(a[0] == 3);
|
|
assert(a[1] == 4.5);
|
|
assert(a[2] == 6);
|
|
|
|
abc = null;
|
|
A()[] = B()[] + C()[] % 2;
|
|
assert(abc == "BCA");
|
|
printf("%Lg, %Lg, %Lg\n", cast(real)a[0], cast(real)a[1], cast(real)a[2]);
|
|
assert(a[0] == 1);
|
|
assert(a[1] == 3);
|
|
assert(a[2] == 3);
|
|
}
|
|
}
|
|
|
|
mixin Floating!(float) Ffloat;
|
|
mixin Floating!(double) Fdouble;
|
|
mixin Floating!(real) Freal;
|
|
|
|
void test1()
|
|
{
|
|
Ffloat.testx();
|
|
Fdouble.testx();
|
|
Freal.testx();
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
template Integral(T)
|
|
{
|
|
T[3] a;
|
|
T[3] b;
|
|
T[3] c;
|
|
|
|
T[] A()
|
|
{
|
|
printf("A\n");
|
|
abc ~= "A";
|
|
return a;
|
|
}
|
|
|
|
T[] B()
|
|
{
|
|
printf("B\n");
|
|
abc ~= "B";
|
|
return b;
|
|
}
|
|
|
|
T[] C()
|
|
{
|
|
printf("C\n");
|
|
abc ~= "C";
|
|
return c;
|
|
}
|
|
|
|
T D()
|
|
{
|
|
printf("D\n");
|
|
abc ~= "D";
|
|
return 4;
|
|
}
|
|
|
|
|
|
void testx()
|
|
{
|
|
a = [11, 22, 33];
|
|
b = [1, 2, 3];
|
|
c = [4, 5, 6];
|
|
|
|
abc = null;
|
|
A()[] = B()[] + C()[];
|
|
assert(abc == "BCA");
|
|
assert(a[0] == 5);
|
|
assert(a[1] == 7);
|
|
assert(a[2] == 9);
|
|
|
|
abc = null;
|
|
A()[] = B()[] + 4;
|
|
assert(abc == "BA");
|
|
assert(a[0] == 5);
|
|
assert(a[1] == 6);
|
|
assert(a[2] == 7);
|
|
|
|
abc = null;
|
|
A()[] = 4 + B()[];
|
|
assert(abc == "BA");
|
|
assert(a[0] == 5);
|
|
assert(a[1] == 6);
|
|
assert(a[2] == 7);
|
|
|
|
abc = null;
|
|
A()[] = D() + B()[];
|
|
assert(abc == "DBA");
|
|
assert(a[0] == 5);
|
|
assert(a[1] == 6);
|
|
assert(a[2] == 7);
|
|
|
|
a = [11, 22, 33];
|
|
abc = null;
|
|
A()[] += B()[];
|
|
assert(abc == "BA");
|
|
assert(a[0] == 12);
|
|
assert(a[1] == 24);
|
|
assert(a[2] == 36);
|
|
|
|
a = [11, 22, 33];
|
|
A()[] += 4;
|
|
assert(a[0] == 15);
|
|
assert(a[1] == 26);
|
|
assert(a[2] == 37);
|
|
|
|
a = [11, 22, 33];
|
|
A()[] -= 4;
|
|
assert(a[0] == 7);
|
|
assert(a[1] == 18);
|
|
assert(a[2] == 29);
|
|
|
|
a = [11, 22, 27];
|
|
A()[] *= 4;
|
|
assert(a[0] == 44);
|
|
assert(a[1] == 88);
|
|
assert(a[2] == 108);
|
|
|
|
a = [11, 22, 33];
|
|
A()[] /= 4;
|
|
assert(a[0] == 2);
|
|
assert(a[1] == 5);
|
|
assert(a[2] == 8);
|
|
|
|
a = [11, 22, 33];
|
|
A()[] %= 4;
|
|
assert(a[0] == 3);
|
|
assert(a[1] == 2);
|
|
assert(a[2] == 1);
|
|
|
|
a = [1, 2, 7];
|
|
A()[] &= 4;
|
|
assert(a[0] == 0);
|
|
assert(a[1] == 0);
|
|
assert(a[2] == 4);
|
|
|
|
a = [1, 2, 7];
|
|
A()[] |= 4;
|
|
assert(a[0] == 5);
|
|
assert(a[1] == 6);
|
|
assert(a[2] == 7);
|
|
|
|
a = [1, 2, 7];
|
|
A()[] ^= 4;
|
|
assert(a[0] == 5);
|
|
assert(a[1] == 6);
|
|
assert(a[2] == 3);
|
|
|
|
a = [11, 22, 33];
|
|
abc = null;
|
|
A()[] += 4 + B()[];
|
|
assert(abc == "BA");
|
|
assert(a[0] == 16);
|
|
assert(a[1] == 28);
|
|
assert(a[2] == 40);
|
|
|
|
abc = null;
|
|
A()[] = B()[] - C()[];
|
|
assert(abc == "BCA");
|
|
printf("%lld, %lld, %lld\n", cast(long)a[0], cast(long)a[1], cast(long)a[2]);
|
|
assert(a[0] == -3);
|
|
assert(a[1] == -3);
|
|
assert(a[2] == -3);
|
|
|
|
abc = null;
|
|
A()[] = -B()[] - C()[];
|
|
assert(abc == "BCA");
|
|
printf("%lld, %lld, %lld\n", cast(long)a[0], cast(long)a[1], cast(long)a[2]);
|
|
assert(a[0] == -5);
|
|
assert(a[1] == -7);
|
|
assert(a[2] == -9);
|
|
|
|
abc = null;
|
|
A()[] = B()[] + C()[] * 4;
|
|
assert(abc == "BCA");
|
|
printf("%lld, %lld, %lld\n", cast(long)a[0], cast(long)a[1], cast(long)a[2]);
|
|
assert(a[0] == 17);
|
|
assert(a[1] == 22);
|
|
assert(a[2] == 27);
|
|
|
|
abc = null;
|
|
A()[] = B()[] + C()[] * B()[];
|
|
assert(abc == "BCBA");
|
|
printf("%lld, %lld, %lld\n", cast(long)a[0], cast(long)a[1], cast(long)a[2]);
|
|
assert(a[0] == 5);
|
|
assert(a[1] == 12);
|
|
assert(a[2] == 21);
|
|
|
|
abc = null;
|
|
A()[] = B()[] + C()[] / 2;
|
|
assert(abc == "BCA");
|
|
printf("%lld, %lld, %lld\n", cast(long)a[0], cast(long)a[1], cast(long)a[2]);
|
|
assert(a[0] == 3);
|
|
assert(a[1] == 4);
|
|
assert(a[2] == 6);
|
|
|
|
abc = null;
|
|
A()[] = B()[] + C()[] % 2;
|
|
assert(abc == "BCA");
|
|
printf("%lld, %lld, %lld\n", cast(long)a[0], cast(long)a[1], cast(long)a[2]);
|
|
assert(a[0] == 1);
|
|
assert(a[1] == 3);
|
|
assert(a[2] == 3);
|
|
|
|
abc = null;
|
|
A()[] = ~B()[];
|
|
assert(abc == "BA");
|
|
assert(a[0] == ~cast(T)1);
|
|
assert(a[1] == ~cast(T)2);
|
|
assert(a[2] == ~cast(T)3);
|
|
|
|
abc = null;
|
|
A()[] = B()[] & 2;
|
|
assert(abc == "BA");
|
|
assert(a[0] == 0);
|
|
assert(a[1] == 2);
|
|
assert(a[2] == 2);
|
|
|
|
abc = null;
|
|
A()[] = B()[] | 2;
|
|
assert(abc == "BA");
|
|
assert(a[0] == 3);
|
|
assert(a[1] == 2);
|
|
assert(a[2] == 3);
|
|
|
|
abc = null;
|
|
A()[] = B()[] ^ 2;
|
|
assert(abc == "BA");
|
|
assert(a[0] == 3);
|
|
assert(a[1] == 0);
|
|
assert(a[2] == 1);
|
|
}
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
mixin Integral!(byte) Fbyte;
|
|
mixin Integral!(short) Fshort;
|
|
mixin Integral!(int) Fint;
|
|
mixin Integral!(long) Flong;
|
|
|
|
void test2()
|
|
{
|
|
Fbyte.testx();
|
|
Fshort.testx();
|
|
Fint.testx();
|
|
Flong.testx();
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
void test3()
|
|
{
|
|
auto a = new double[10], b = a.dup, c = a.dup, d = a.dup;
|
|
a[] = -(b[] * (c[] + 4)) + 5 * d[] / 3.0;
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
void test4()
|
|
{
|
|
int[] a, b;
|
|
if (a && b) {}
|
|
}
|
|
|
|
/***************************************************/
|
|
|
|
void test4662()
|
|
{
|
|
immutable double[] nums = [1.0, 2.0];
|
|
|
|
static assert(!is(typeof({ nums[] += nums[]; })));
|
|
static assert(!is(typeof({ nums[] -= nums[]; })));
|
|
static assert(!is(typeof({ nums[] /= nums[]; })));
|
|
static assert(!is(typeof({ nums[] += 4; })));
|
|
static assert(!is(typeof({ nums[] /= 7; })));
|
|
}
|
|
|
|
/***************************************************/
|
|
// 5284
|
|
|
|
void bug5284_1()
|
|
{
|
|
class C { int v; }
|
|
|
|
C [] mda;
|
|
immutable(C)[] ida;
|
|
static assert(!__traits(compiles, (mda[] = ida[])));
|
|
|
|
C [1] msa;
|
|
immutable(C)[1] isa;
|
|
static assert(!__traits(compiles, (msa[] = isa[])));
|
|
|
|
C m;
|
|
immutable(C) i;
|
|
static assert(!__traits(compiles, m = i));
|
|
}
|
|
void bug5284_2a()
|
|
{
|
|
struct S { int v; }
|
|
|
|
S [] mda;
|
|
immutable(S)[] ida;
|
|
mda[] = ida[];
|
|
|
|
S [1] msa;
|
|
immutable(S)[1] isa;
|
|
msa[] = isa[];
|
|
|
|
S m = S();
|
|
immutable(S) i = immutable(S)();
|
|
m = i;
|
|
}
|
|
void bug5284_2b()
|
|
{
|
|
struct S { int v; int[] arr; }
|
|
|
|
S [] mda;
|
|
immutable(S)[] ida;
|
|
static assert(!__traits(compiles, (mda[] = ida[])));
|
|
|
|
S [1] msa;
|
|
immutable(S)[1] isa;
|
|
static assert(!__traits(compiles, (msa[] = isa[])));
|
|
|
|
S m;
|
|
immutable(S) i;
|
|
static assert(!__traits(compiles, m = i));
|
|
}
|
|
void bug5284_3()
|
|
{
|
|
int [] ma;
|
|
immutable(int)[] ia;
|
|
ma[] = ia[];
|
|
|
|
int m;
|
|
immutable(int) i;
|
|
m = i;
|
|
}
|
|
|
|
void test5()
|
|
{
|
|
bug5284_1();
|
|
bug5284_2a();
|
|
bug5284_2b();
|
|
bug5284_3();
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
void test6()
|
|
{
|
|
int[10] a = [1,2,3,4,5,6,7,8,9,10];
|
|
int[10] b;
|
|
|
|
b = a[] ^^ 2;
|
|
assert(b[0] == 1);
|
|
assert(b[1] == 4);
|
|
assert(b[2] == 9);
|
|
assert(b[3] == 16);
|
|
assert(b[4] == 25);
|
|
assert(b[5] == 36);
|
|
assert(b[6] == 49);
|
|
assert(b[7] == 64);
|
|
assert(b[8] == 81);
|
|
assert(b[9] == 100);
|
|
|
|
int[10] c = 3;
|
|
b = a[] ^^ c[];
|
|
assert(b[0] == 1);
|
|
assert(b[1] == 8);
|
|
assert(b[2] == 27);
|
|
assert(b[3] == 64);
|
|
assert(b[4] == 125);
|
|
assert(b[5] == 216);
|
|
assert(b[6] == 343);
|
|
assert(b[7] == 512);
|
|
assert(b[8] == 729);
|
|
assert(b[9] == 1000);
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
void test8390() {
|
|
const int[] a = new int[5];
|
|
int[] b = new int[5];
|
|
b[] += a[];
|
|
}
|
|
|
|
/************************************************************************/
|
|
// 8651
|
|
|
|
void test8651()
|
|
{
|
|
void test(T)() @safe pure nothrow
|
|
{
|
|
T[3] a = [11, 22, 33];
|
|
T[3] b = [1, 2, 3];
|
|
T[3] c = [4, 5, 6];
|
|
T d = 4;
|
|
|
|
// Arithmetic array ops
|
|
{
|
|
a[] = b[] + c[];
|
|
a[] = b[] + 4;
|
|
a[] = 4 + b[];
|
|
a[] = d + b[];
|
|
a[] += b[];
|
|
a[] += 4;
|
|
a[] -= 4;
|
|
a[] *= 4;
|
|
a[] /= 4;
|
|
a[] %= 4;
|
|
a[] += 4 + b[];
|
|
a[] = b[] - c[];
|
|
a[] = -b[] - c[];
|
|
a[] = b[] + c[] * 4;
|
|
a[] = b[] + c[] * b[];
|
|
a[] = b[] + c[] / 2;
|
|
a[] = b[] + c[] % 2;
|
|
}
|
|
// Bitwise array ops
|
|
static if (is(typeof(T.init & T.init)))
|
|
{
|
|
a[] &= 4;
|
|
a[] |= 4;
|
|
a[] ^= 4;
|
|
a[] = ~b[];
|
|
a[] = b[] & 2;
|
|
a[] = b[] | 2;
|
|
a[] = b[] ^ 2;
|
|
}
|
|
}
|
|
|
|
test!float();
|
|
test!double();
|
|
test!real();
|
|
|
|
test!byte();
|
|
test!short();
|
|
test!int();
|
|
test!long();
|
|
}
|
|
|
|
/************************************************************************/
|
|
// 9656
|
|
|
|
void test9656()
|
|
{
|
|
static class C {}
|
|
static struct S
|
|
{
|
|
immutable int[] narr1;
|
|
immutable int[] narr2;
|
|
immutable C[] carr1;
|
|
immutable C[] carr2;
|
|
this(int n) {
|
|
narr1 = new int[](3); // OK, expected
|
|
narr2 = [1,2,3].dup; // NG -> OK
|
|
carr1 = [new C].dup; // NG -> OK
|
|
|
|
C c = new C;
|
|
static assert(!__traits(compiles, carr2 = [c]));
|
|
}
|
|
}
|
|
|
|
{
|
|
int[] ma = [1,2,3];
|
|
immutable ia = ma.dup;
|
|
}
|
|
|
|
|
|
{
|
|
static struct V { int val; }
|
|
V[] ma = [V(1), V(2)];
|
|
immutable ia = ma.dup;
|
|
}
|
|
|
|
{
|
|
static struct R { int* ptr; }
|
|
R[] ma = [R(new int), R(null)];
|
|
static assert(!__traits(compiles, { immutable ia = rarr.dup; }));
|
|
}
|
|
|
|
{
|
|
C[] ma = [new C(), new C()];
|
|
static assert(!__traits(compiles, { immutable ia = carr.dup; }));
|
|
}
|
|
}
|
|
|
|
/************************************************************************/
|
|
// 10282
|
|
|
|
void test10282()
|
|
{
|
|
int[3] a1 = [1, 3, 6];
|
|
int[3] a2 = [1, 3, 6] * 3; // OK
|
|
const int[3] a3 = a1[] * 3; // OK <- Error
|
|
const int[3] a4 = [1, 3, 6] * 3; // OK <- Error
|
|
immutable int[3] a5 = [1, 3, 6] * 3; // OK <- Error
|
|
|
|
assert(a1[0] == 1 && a1[1] == 3 && a1[2] == 6);
|
|
assert(a2[0] == 3 && a2[1] == 9 && a2[2] == 18);
|
|
assert(a3[0] == 3 && a3[1] == 9 && a3[2] == 18);
|
|
assert(a4[0] == 3 && a4[1] == 9 && a4[2] == 18);
|
|
assert(a5[0] == 3 && a5[1] == 9 && a5[2] == 18);
|
|
}
|
|
|
|
/************************************************************************/
|
|
// 10433
|
|
|
|
void test10433()
|
|
{
|
|
void foo(T)(in int[] v1, in T v2)
|
|
{
|
|
int[2] r;
|
|
r[] = v1[] + v2[];
|
|
}
|
|
|
|
immutable int[] v = [10, 20];
|
|
foo(v, v);
|
|
}
|
|
|
|
/************************************************************************/
|
|
// 10684
|
|
|
|
void test10684a()
|
|
{
|
|
int[] a = [0, 0];
|
|
a[] += [10, 20][];
|
|
}
|
|
|
|
void test10684b()
|
|
{
|
|
int[] a = [1, 2, 3];
|
|
int[] b = [4, 5, 6];
|
|
|
|
// Allow array literal as the operand of array oeration
|
|
a[] += [1, 2, 3];
|
|
assert(a == [2, 4, 6]);
|
|
|
|
a[] *= b[] + [1, 1, 1];
|
|
assert(a == [2*(4+1), 4*(5+1), 6*(6+1)]);
|
|
|
|
a[] = [9, 8, 7] - [1, 2, 3];
|
|
assert(a == [8, 6, 4]);
|
|
|
|
a[] = [2, 4, 6] / 2;
|
|
assert(a == [1,2,3]);
|
|
|
|
// Disallow: [1,2,3] is not an lvalue
|
|
static assert(!__traits(compiles, { [1,2,3] = a[] * 2; }));
|
|
static assert(!__traits(compiles, { [1,2,3] += a[] * b[]; }));
|
|
}
|
|
|
|
/************************************************************************/
|
|
// 11376
|
|
|
|
template TL11376(T...)
|
|
{
|
|
alias TL11376 = T;
|
|
}
|
|
|
|
auto sumArrs11376(T0, T1)(T0[] a, T1[] b)
|
|
{
|
|
a[] += b[]; //no ICE without this line
|
|
return a;
|
|
}
|
|
|
|
static assert(!__traits(compiles, sumArrs11376(TL11376!(string[], string).init)));
|
|
|
|
/************************************************************************/
|
|
// 11525
|
|
|
|
void test11525()
|
|
{
|
|
static struct Complex(T)
|
|
{
|
|
T re, im;
|
|
|
|
ref opOpAssign(string op : "*")(Complex z)
|
|
{
|
|
auto temp = re*z.re - im*z.im;
|
|
im = im*z.re + re*z.im;
|
|
re = temp;
|
|
return this;
|
|
}
|
|
}
|
|
|
|
auto a = [Complex!double(2, 2)];
|
|
assert(a.length == 1 && a[0].re == 2 && a[0].im == 2);
|
|
a[] *= a[];
|
|
assert(a.length == 1 && a[0].re == 0 && a[0].im == 8);
|
|
}
|
|
|
|
/************************************************************************/
|
|
// 12250
|
|
|
|
void f12250(inout int[] p, inout int[] q, int[] r)
|
|
{
|
|
r[] = p[] + q[];
|
|
assert(r == [5,7,9]);
|
|
r[] -= p[] - q[];
|
|
assert(r == [8,10,12]);
|
|
}
|
|
|
|
void test12250()
|
|
{
|
|
immutable int[3] x = [1,2,3], y = [4,5,6];
|
|
int[3] z;
|
|
f12250(x[], y[], z[]);
|
|
}
|
|
|
|
/************************************************************************/
|
|
// 12179
|
|
|
|
void test12179()
|
|
{
|
|
void foo(int[]) {}
|
|
int[1] a;
|
|
|
|
foo(a[] = a[]);
|
|
foo(a[] += a[]);
|
|
foo(a[] -= a[]);
|
|
foo(a[] *= a[]);
|
|
foo(a[] /= a[]);
|
|
foo(a[] %= a[]);
|
|
foo(a[] ^= a[]);
|
|
foo(a[] &= a[]);
|
|
foo(a[] |= a[]);
|
|
foo(a[] ^^= a[]);
|
|
|
|
// from issue 11992
|
|
int[] arr1;
|
|
int[][] arr2;
|
|
arr1 ~= (a[] = [1] + a[]); // OK
|
|
arr2 ~= (a[] = [1] + a[]); // OK
|
|
}
|
|
|
|
/************************************************************************/
|
|
// 12780
|
|
|
|
void test12780()
|
|
{
|
|
int ival = 2;
|
|
int[] iarr = [1, 2, 3];
|
|
double dval = 2.0;
|
|
double[] darr = [4, 5, 6];
|
|
|
|
double[] oarr = [0, 0, 0];
|
|
|
|
// multiply array operations
|
|
oarr[] = dval * iarr[];
|
|
assert(oarr == [dval * iarr[0],
|
|
dval * iarr[1],
|
|
dval * iarr[2]]);
|
|
|
|
oarr[] = iarr[] / dval;
|
|
assert(oarr == [iarr[0] / dval,
|
|
iarr[1] / dval,
|
|
iarr[2] / dval]);
|
|
|
|
oarr[] = dval * (ival + iarr[]);
|
|
assert(oarr == [dval * (ival + iarr[0]),
|
|
dval * (ival + iarr[1]),
|
|
dval * (ival + iarr[2])]);
|
|
|
|
oarr[] = (iarr[] & ival) / dval;
|
|
assert(oarr == [(iarr[0] & ival) / dval,
|
|
(iarr[1] & ival) / dval,
|
|
(iarr[2] & ival) / dval]);
|
|
|
|
oarr[] = darr[] + iarr[];
|
|
assert(oarr == [darr[0] + iarr[0],
|
|
darr[1] + iarr[1],
|
|
darr[2] + iarr[2]]);
|
|
|
|
oarr[] = iarr[] - darr[];
|
|
assert(oarr == [iarr[0] - darr[0],
|
|
iarr[1] - darr[1],
|
|
iarr[2] - darr[2]]);
|
|
|
|
oarr[] = darr[] * (ival & iarr[]);
|
|
assert(oarr == [darr[0] * (ival & iarr[0]),
|
|
darr[1] * (ival & iarr[1]),
|
|
darr[2] * (ival & iarr[2])]);
|
|
|
|
oarr[] = (iarr[] ^ ival) / darr[];
|
|
assert(oarr == [(iarr[0] ^ ival) / darr[0],
|
|
(iarr[1] ^ ival) / darr[1],
|
|
(iarr[2] ^ ival) / darr[2]]);
|
|
}
|
|
|
|
/************************************************************************/
|
|
// 13497
|
|
|
|
void test13497()
|
|
{
|
|
int[1] a = [2], b = [3];
|
|
int[1] c1 = a[] * b[];
|
|
int[1] c2 = (a[] * b[])[];
|
|
assert(c1 == [6]);
|
|
assert(c2 == [6]);
|
|
}
|
|
|
|
/************************************************************************/
|
|
// 14649
|
|
|
|
void test14649()
|
|
{
|
|
char[] a = "abc".dup;
|
|
char[] b = [char(1), char(2), char(3)];
|
|
string x = "abc";
|
|
string y = [char(1), char(2), char(3)];
|
|
char[] r = new char[](3);
|
|
|
|
r[] = a[] + b[];
|
|
assert(r == "bdf");
|
|
|
|
r[] = x[] + y[];
|
|
assert(r == "bdf");
|
|
|
|
r[] = "hel"[] + "lo."[];
|
|
assert(r == [('h'+'l'), ('e'+'o'), ('l'+'.')]);
|
|
|
|
enum s = "abc";
|
|
r[] = s[0..3] + "def"[0..3];
|
|
assert(r == [('a'+'d'), ('b'+'e'), ('c'+'f')]);
|
|
}
|
|
|
|
/************************************************************************/
|
|
// 14851
|
|
|
|
void test14851()
|
|
{
|
|
int[8] a, b, c;
|
|
|
|
c = a[] | b[]; // OK <- NG from 2.068.0-b2
|
|
c = a[] ^ b[]; // OK <- NG from 2.068.0-b2
|
|
|
|
c[] = a[] | b[]; // OK
|
|
c[] = a[] ^ b[]; // OK
|
|
}
|
|
|
|
/************************************************************************/
|
|
|
|
int main()
|
|
{
|
|
version(X86)
|
|
{
|
|
test1();
|
|
test2();
|
|
}
|
|
else version(X86_64)
|
|
{
|
|
test1();
|
|
test2();
|
|
}
|
|
else
|
|
{
|
|
//pragma(msg, "Test skipped because arrayop evaluation order is ill-defined.");
|
|
}
|
|
test3();
|
|
test4();
|
|
test5();
|
|
test6();
|
|
test8390();
|
|
test8651();
|
|
test9656();
|
|
test10282();
|
|
test10433();
|
|
test10684a();
|
|
test10684b();
|
|
test11525();
|
|
test12250();
|
|
test12780();
|
|
test13497();
|
|
test14649();
|
|
test14851();
|
|
|
|
printf("Success\n");
|
|
return 0;
|
|
}
|
|
|
|
|
|
version (none)
|
|
{
|
|
extern (C) T[] _arraySliceSliceAddSliceAssignd(T[] a, T[] c, T[] b)
|
|
{
|
|
foreach (i; 0 .. a.length)
|
|
a[i] = b[i] + c[i];
|
|
return a;
|
|
}
|
|
}
|