mirror of
https://github.com/dlang/dmd.git
synced 2025-04-26 05:00:16 +03:00
1040 lines
21 KiB
D
1040 lines
21 KiB
D
// REQUIRED_ARGS:
|
|
|
|
import core.stdc.stdarg;
|
|
|
|
extern(C)
|
|
{
|
|
int printf(const char*, ...);
|
|
version(Windows)
|
|
{
|
|
int _snprintf(char*, size_t, const char*, ...);
|
|
alias _snprintf snprintf;
|
|
}
|
|
else
|
|
int snprintf(char*, size_t, const char*, ...);
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
// https://www.digitalmars.com/d/archives/digitalmars/D/bugs/4766.html
|
|
// Only with -O
|
|
|
|
real randx()
|
|
{
|
|
return 1.2;
|
|
}
|
|
|
|
void test1()
|
|
{
|
|
float x10=randx();
|
|
float x11=randx();
|
|
float x20=randx();
|
|
float x21=randx();
|
|
float y10=randx();
|
|
float y11=randx();
|
|
float y20=randx();
|
|
float y21=randx();
|
|
|
|
float tmp=(
|
|
x20*x21 + y10*y10 + y10*y11 + y11*y11 +
|
|
y11*y20 + y20*y20 + y10*y21 + y11*y21 +
|
|
y21*y21);
|
|
assert(tmp > 0);
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
void test2()
|
|
{
|
|
double x10=randx();
|
|
double x11=randx();
|
|
double x20=randx();
|
|
double x21=randx();
|
|
double y10=randx();
|
|
double y11=randx();
|
|
double y20=randx();
|
|
double y21=randx();
|
|
|
|
double tmp=(
|
|
x20*x21 + y10*y10 + y10*y11 + y11*y11 +
|
|
y11*y20 + y20*y20 + y10*y21 + y11*y21 +
|
|
y21*y21);
|
|
assert(tmp > 0);
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
void test3()
|
|
{
|
|
real x10=randx();
|
|
real x11=randx();
|
|
real x20=randx();
|
|
real x21=randx();
|
|
real y10=randx();
|
|
real y11=randx();
|
|
real y20=randx();
|
|
real y21=randx();
|
|
|
|
real tmp=(
|
|
x20*x21 + y10*y10 + y10*y11 + y11*y11 +
|
|
y11*y20 + y20*y20 + y10*y21 + y11*y21 +
|
|
y21*y21);
|
|
assert(tmp > 0);
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
void test4()
|
|
{
|
|
printf("main() : (-128 >= 0)=%s, (-128 <= 0)=%s\n",
|
|
cast(char*)(-128 >= 0 ? "true" : "false"),
|
|
cast(char*)(-128 <= 0 ? "true" : "false"));
|
|
|
|
printf("main() : (128 >= 0)=%s, (128 <= 0)=%s\n",
|
|
cast(char*)(128 >= 0 ? "true" : "false"),
|
|
cast(char*)(128 <= 0 ? "true" : "false"));
|
|
|
|
assert((-128 >= 0 ? "true" : "false") == "false"),
|
|
assert((-128 <= 0 ? "true" : "false") == "true");
|
|
assert((+128 >= 0 ? "true" : "false") == "true"),
|
|
assert((+128 <= 0 ? "true" : "false") == "false");
|
|
}
|
|
|
|
|
|
/*************************************/
|
|
|
|
int foo5() { assert(0); } // No return.
|
|
|
|
int abc5()
|
|
{
|
|
printf("foo = %d\n", foo5());
|
|
return 0;
|
|
}
|
|
|
|
void test5()
|
|
{
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
class A9
|
|
{
|
|
this(int[] params ...)
|
|
{
|
|
for (int i = 0; i < params.length; i++)
|
|
{
|
|
assert(params[i] == i + 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
class B9
|
|
{
|
|
this()
|
|
{
|
|
init();
|
|
}
|
|
|
|
private void init()
|
|
{
|
|
A9 test1 = new A9(1, 2, 3);
|
|
A9 test2 = new A9(1, 2, 3, 4);
|
|
int[3] arg;
|
|
arg[0]=1, arg[1]=2, arg[2]=3;
|
|
A9 test3 = new A9(arg);
|
|
}
|
|
}
|
|
|
|
void test9()
|
|
{
|
|
B9 test2 = new B9();
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
void test10()
|
|
{
|
|
auto i = 5u;
|
|
auto s = typeid(typeof(i)).toString;
|
|
printf("%.*s\n", cast(int)s.length, s.ptr);
|
|
assert(typeid(typeof(i)) == typeid(uint));
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
void test11()
|
|
{
|
|
printf("%d\n", 3);
|
|
printf("xhello world!\n");
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
real x16;
|
|
|
|
void foo16()
|
|
{
|
|
x16 = -x16;
|
|
}
|
|
|
|
void bar16()
|
|
{
|
|
return foo16();
|
|
}
|
|
|
|
void test16()
|
|
{
|
|
x16=2;
|
|
bar16();
|
|
assert(x16==-2);
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
class Bar17
|
|
{
|
|
this(...) {}
|
|
}
|
|
|
|
class Foo17
|
|
{
|
|
void opBinary(string op : "+") (Bar17 b) {}
|
|
}
|
|
|
|
void test17()
|
|
{
|
|
auto f = new Foo17;
|
|
f + new Bar17;
|
|
}
|
|
|
|
|
|
/*************************************/
|
|
|
|
template u18(int n)
|
|
{
|
|
static if (n==1) {
|
|
int a = 1;
|
|
} else
|
|
int b = 4;
|
|
}
|
|
|
|
void test18()
|
|
{
|
|
mixin u18!(2);
|
|
assert(b == 4);
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
class DP
|
|
{
|
|
private:
|
|
void I(char[] p)
|
|
{
|
|
I(p[1..p.length]);
|
|
}
|
|
}
|
|
|
|
void test19()
|
|
{
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
struct Struct20
|
|
{
|
|
int i;
|
|
}
|
|
|
|
void test20()
|
|
{
|
|
auto s = new Struct20;
|
|
s.i = 7;
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
class C21(float f)
|
|
{
|
|
float ff = f;
|
|
}
|
|
|
|
void test21()
|
|
{
|
|
auto a = new C21!(1.2);
|
|
C21!(1.2) b = new C21!(1.2);
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
const int c23 = b23 * b23;
|
|
const int a23 = 1;
|
|
const int b23 = a23 * 3;
|
|
|
|
template T23(int n)
|
|
{
|
|
int[n] x23;
|
|
}
|
|
|
|
mixin T23!(c23);
|
|
|
|
void test23()
|
|
{
|
|
assert(x23.length==9);
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
template cat(int n)
|
|
{
|
|
const int dog = n;
|
|
}
|
|
|
|
const char [] bird = "canary";
|
|
|
|
const int sheep = cat!(bird.length).dog;
|
|
|
|
void test25()
|
|
{
|
|
assert(sheep == 6);
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
void test27()
|
|
{ int x;
|
|
|
|
string s = (int*function(int ...)[]).mangleof;
|
|
printf("%.*s\n", cast(int)s.length, s.ptr);
|
|
assert((int*function(int ...)[]).mangleof == "APFiXPi");
|
|
assert(typeof(x).mangleof == "i");
|
|
assert(x.mangleof == "_D6test226test27FZ1xi");
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
void test29()
|
|
{
|
|
ulong a = 10_000_000_000_000_000,
|
|
b = 1_000_000_000_000_000;
|
|
|
|
printf("test29\n%llx\n%llx\n%llx\n", a, b, a / b);
|
|
assert((a / b) == 10);
|
|
}
|
|
|
|
static assert((10_000_000_000_000_000 / 1_000_000_000_000_000) == 10);
|
|
|
|
/*************************************/
|
|
|
|
template chook(int n)
|
|
{
|
|
const int chook = 3;
|
|
}
|
|
|
|
template dog(alias f) {
|
|
const int dog = chook!(f.mangleof.length);
|
|
}
|
|
|
|
class pig {}
|
|
|
|
const int goose = dog!(pig);
|
|
|
|
void test30()
|
|
{
|
|
printf("%d\n", goose);
|
|
assert(goose == 3);
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
template dog31(string sheep)
|
|
{
|
|
immutable string dog31 = "daschund";
|
|
}
|
|
|
|
void test31()
|
|
{
|
|
string duck = dog31!("bird"[1..3]);
|
|
|
|
assert(duck == "daschund");
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
struct particle
|
|
{
|
|
int active; /* Active (Yes/No) */
|
|
float life; /* Particle Life */
|
|
float fade; /* Fade Speed */
|
|
|
|
float r; /* Red Value */
|
|
float g; /* Green Value */
|
|
float b; /* Blue Value */
|
|
|
|
float x; /* X Position */
|
|
float y; /* Y Position */
|
|
|
|
float xi; /* X Direction */
|
|
float yi; /* Y Direction */
|
|
|
|
float xg; /* X Gravity */
|
|
float yg; /* Y Gravity */
|
|
}
|
|
|
|
particle[10000] particles;
|
|
|
|
void test32()
|
|
{
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
class Foo33
|
|
{
|
|
template foo()
|
|
{
|
|
int foo() { return 6; }
|
|
}
|
|
}
|
|
|
|
|
|
void test33()
|
|
{
|
|
Foo33 f = new Foo33;
|
|
|
|
assert(f.foo!()() == 6);
|
|
with (f)
|
|
assert(foo!()() == 6);
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
template dog34(string duck)
|
|
{
|
|
const int dog34 = 2;
|
|
}
|
|
|
|
void test34()
|
|
{
|
|
int aardvark = dog34!("cat" ~ "pig");
|
|
|
|
assert(aardvark == 2);
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
class A35
|
|
{
|
|
private bool quit;
|
|
void halt() {quit = true;}
|
|
bool isHalted() {return quit;}
|
|
}
|
|
|
|
void test35()
|
|
{
|
|
auto a = new A35;
|
|
|
|
a.halt; // error here
|
|
a.halt();
|
|
|
|
a.isHalted; // error here
|
|
bool done = a.isHalted;
|
|
if (a.isHalted)
|
|
{
|
|
}
|
|
}
|
|
|
|
|
|
/*************************************/
|
|
|
|
void test36()
|
|
{
|
|
bool q = (0.9 + 3.5L == 0.9L + 3.5L);
|
|
assert(q);
|
|
static assert(0.9 + 3.5L == 0.9L + 3.5L);
|
|
assert(0.9 + 3.5L == 0.9L + 3.5L);
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
abstract class Foo37(T)
|
|
{
|
|
void bar () { }
|
|
}
|
|
|
|
class Bar37 : Foo37!(int)
|
|
{
|
|
}
|
|
|
|
void test37()
|
|
{
|
|
auto f = new Bar37;
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
void test38()
|
|
{
|
|
auto s=`hello`;
|
|
assert(s.length==5);
|
|
assert(s[0]=='h');
|
|
assert(s[1]=='e');
|
|
assert(s[2]=='l');
|
|
assert(s[3]=='l');
|
|
assert(s[4]=='o');
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
void test39()
|
|
{
|
|
int value=1;
|
|
string key = "eins";
|
|
int[char[]] array;
|
|
|
|
array[key]=value;
|
|
int* ptr = key in array;
|
|
|
|
assert(value == *ptr);
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
void test40()
|
|
{
|
|
auto s=r"hello";
|
|
assert(s.length==5);
|
|
assert(s[0]=='h');
|
|
assert(s[1]=='e');
|
|
assert(s[2]=='l');
|
|
assert(s[3]=='l');
|
|
assert(s[4]=='o');
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
void test41()
|
|
{
|
|
version (Windows)
|
|
{
|
|
version(D_InlineAsm){
|
|
double a = 1.2;
|
|
double b = 0.2;
|
|
double c = 1.4;
|
|
|
|
asm{
|
|
movq XMM0, a;
|
|
movq XMM1, b;
|
|
addsd XMM1, XMM0;
|
|
movq c, XMM1;
|
|
}
|
|
|
|
a += b;
|
|
|
|
b = a-c;
|
|
b = (b>0) ? b : (-1 * b);
|
|
|
|
assert(b < b.epsilon*4);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
const char[] tapir = "some horned animal";
|
|
|
|
const byte[] antelope = cast(byte []) tapir;
|
|
|
|
void test42()
|
|
{
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
void test43()
|
|
{
|
|
string armadillo = "abc" ~ 'a';
|
|
assert(armadillo == "abca");
|
|
string armadillo2 = 'b' ~ "abc";
|
|
assert(armadillo2 == "babc");
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
const uint baboon44 = 3;
|
|
|
|
const int monkey44 = 4;
|
|
|
|
const ape44 = monkey44 * baboon44;
|
|
|
|
void test44()
|
|
{
|
|
assert(ape44 == 12);
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
class A45
|
|
{
|
|
this()
|
|
{
|
|
b = new B();
|
|
b.x = 5; // illegal
|
|
}
|
|
|
|
class B
|
|
{
|
|
protected int x;
|
|
}
|
|
|
|
B b;
|
|
}
|
|
|
|
void test45()
|
|
{
|
|
}
|
|
|
|
|
|
/*************************************/
|
|
|
|
class C46(T)
|
|
{
|
|
private T i; // or protected or package
|
|
}
|
|
|
|
void test46()
|
|
{
|
|
C46!(int) c = new C46!(int); // class t4.C46!(int).C46 member i is not accessible
|
|
c.i = 10;
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
void bug5809()
|
|
{
|
|
ushort[2] x = void;
|
|
x[0] = 0;
|
|
x[1] = 0x1234;
|
|
ushort *px = &x[0];
|
|
|
|
uint b = px[0];
|
|
|
|
assert(px[0] == 0);
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
void bug7546()
|
|
{
|
|
double p = -0.0;
|
|
assert(p == 0);
|
|
}
|
|
|
|
|
|
/*************************************/
|
|
|
|
real poly_asm(real x, real[] A)
|
|
in
|
|
{
|
|
assert(A.length > 0);
|
|
}
|
|
do
|
|
{
|
|
version (D_InlineAsm_X86)
|
|
{
|
|
version (linux)
|
|
{
|
|
asm // assembler by W. Bright
|
|
{
|
|
// EDX = (A.length - 1) * real.sizeof
|
|
mov ECX,A[EBP] ; // ECX = A.length
|
|
dec ECX ;
|
|
lea EDX,[ECX][ECX*8] ;
|
|
add EDX,ECX ;
|
|
add EDX,ECX ;
|
|
add EDX,ECX ;
|
|
add EDX,A+4[EBP] ;
|
|
fld real ptr [EDX] ; // ST0 = coeff[ECX]
|
|
jecxz return_ST ;
|
|
fld x[EBP] ; // ST0 = x
|
|
fxch ST(1) ; // ST1 = x, ST0 = r
|
|
align 4 ;
|
|
L2: fmul ST,ST(1) ; // r *= x
|
|
fld real ptr -12[EDX] ;
|
|
sub EDX,12 ; // deg--
|
|
faddp ST(1),ST ;
|
|
dec ECX ;
|
|
jne L2 ;
|
|
fxch ST(1) ; // ST1 = r, ST0 = x
|
|
fstp ST(0) ; // dump x
|
|
align 4 ;
|
|
return_ST: ;
|
|
;
|
|
}
|
|
}
|
|
else version (OSX)
|
|
{
|
|
asm // assembler by W. Bright
|
|
{
|
|
// EDX = (A.length - 1) * real.sizeof
|
|
mov ECX,A[EBP] ; // ECX = A.length
|
|
dec ECX ;
|
|
lea EDX,[ECX*8] ;
|
|
add EDX,EDX ;
|
|
add EDX,A+4[EBP] ;
|
|
fld real ptr [EDX] ; // ST0 = coeff[ECX]
|
|
jecxz return_ST ;
|
|
fld x[EBP] ; // ST0 = x
|
|
fxch ST(1) ; // ST1 = x, ST0 = r
|
|
align 4 ;
|
|
L2: fmul ST,ST(1) ; // r *= x
|
|
fld real ptr -16[EDX] ;
|
|
sub EDX,16 ; // deg--
|
|
faddp ST(1),ST ;
|
|
dec ECX ;
|
|
jne L2 ;
|
|
fxch ST(1) ; // ST1 = r, ST0 = x
|
|
fstp ST(0) ; // dump x
|
|
align 4 ;
|
|
return_ST: ;
|
|
;
|
|
}
|
|
}
|
|
else version (FreeBSD)
|
|
{
|
|
asm // assembler by W. Bright
|
|
{
|
|
// EDX = (A.length - 1) * real.sizeof
|
|
mov ECX,A[EBP] ; // ECX = A.length
|
|
dec ECX ;
|
|
lea EDX,[ECX][ECX*8] ;
|
|
add EDX,ECX ;
|
|
add EDX,ECX ;
|
|
add EDX,ECX ;
|
|
add EDX,A+4[EBP] ;
|
|
fld real ptr [EDX] ; // ST0 = coeff[ECX]
|
|
jecxz return_ST ;
|
|
fld x[EBP] ; // ST0 = x
|
|
fxch ST(1) ; // ST1 = x, ST0 = r
|
|
align 4 ;
|
|
L2: fmul ST,ST(1) ; // r *= x
|
|
fld real ptr -12[EDX] ;
|
|
sub EDX,12 ; // deg--
|
|
faddp ST(1),ST ;
|
|
dec ECX ;
|
|
jne L2 ;
|
|
fxch ST(1) ; // ST1 = r, ST0 = x
|
|
fstp ST(0) ; // dump x
|
|
align 4 ;
|
|
return_ST: ;
|
|
;
|
|
}
|
|
}
|
|
else version (Solaris)
|
|
{
|
|
asm // assembler by W. Bright
|
|
{
|
|
// EDX = (A.length - 1) * real.sizeof
|
|
mov ECX,A[EBP] ; // ECX = A.length
|
|
dec ECX ;
|
|
lea EDX,[ECX][ECX*8] ;
|
|
add EDX,ECX ;
|
|
add EDX,ECX ;
|
|
add EDX,ECX ;
|
|
add EDX,A+4[EBP] ;
|
|
fld real ptr [EDX] ; // ST0 = coeff[ECX]
|
|
jecxz return_ST ;
|
|
fld x[EBP] ; // ST0 = x
|
|
fxch ST(1) ; // ST1 = x, ST0 = r
|
|
align 4 ;
|
|
L2: fmul ST,ST(1) ; // r *= x
|
|
fld real ptr -12[EDX] ;
|
|
sub EDX,12 ; // deg--
|
|
faddp ST(1),ST ;
|
|
dec ECX ;
|
|
jne L2 ;
|
|
fxch ST(1) ; // ST1 = r, ST0 = x
|
|
fstp ST(0) ; // dump x
|
|
align 4 ;
|
|
return_ST: ;
|
|
;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
asm // assembler by W. Bright
|
|
{
|
|
// EDX = (A.length - 1) * real.sizeof
|
|
mov ECX,A[EBP] ; // ECX = A.length
|
|
dec ECX ;
|
|
lea EDX,[ECX][ECX*8] ;
|
|
add EDX,ECX ;
|
|
add EDX,A+4[EBP] ;
|
|
fld real ptr [EDX] ; // ST0 = coeff[ECX]
|
|
jecxz return_ST ;
|
|
fld x[EBP] ; // ST0 = x
|
|
fxch ST(1) ; // ST1 = x, ST0 = r
|
|
align 4 ;
|
|
L2: fmul ST,ST(1) ; // r *= x
|
|
fld real ptr -10[EDX] ;
|
|
sub EDX,10 ; // deg--
|
|
faddp ST(1),ST ;
|
|
dec ECX ;
|
|
jne L2 ;
|
|
fxch ST(1) ; // ST1 = r, ST0 = x
|
|
fstp ST(0) ; // dump x
|
|
align 4 ;
|
|
return_ST: ;
|
|
;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printf("Sorry, you don't seem to have InlineAsm_X86\n");
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
real poly_c(real x, real[] A)
|
|
in
|
|
{
|
|
assert(A.length > 0);
|
|
}
|
|
do
|
|
{
|
|
ptrdiff_t i = A.length - 1;
|
|
real r = A[i];
|
|
while (--i >= 0)
|
|
{
|
|
r *= x;
|
|
r += A[i];
|
|
}
|
|
return r;
|
|
}
|
|
|
|
void test47()
|
|
{
|
|
real x = 3.1;
|
|
static real[] pp = [56.1, 32.7, 6];
|
|
real r;
|
|
|
|
printf("The result should be %Lf\n",(56.1L + (32.7L + 6L * x) * x));
|
|
printf("The C version outputs %Lf\n", poly_c(x, pp));
|
|
printf("The asm version outputs %Lf\n", poly_asm(x, pp));
|
|
|
|
r = (56.1L + (32.7L + 6L * x) * x);
|
|
assert(r == poly_c(x, pp));
|
|
version (D_InlineAsm_X86)
|
|
assert(r == poly_asm(x, pp));
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
const c48 = 1uL-1;
|
|
|
|
void test48()
|
|
{
|
|
assert(c48 == 0);
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
template cat49()
|
|
{
|
|
static assert(1); // OK
|
|
static if (1)
|
|
{
|
|
static assert(1); // doesn't work
|
|
static if (1)
|
|
{
|
|
static assert(1); // OK
|
|
const int cat49 = 3;
|
|
}
|
|
}
|
|
}
|
|
|
|
void test49()
|
|
{
|
|
const int a = cat49!();
|
|
assert(a == 3);
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
void test50()
|
|
{
|
|
if (auto x = 1)
|
|
{
|
|
assert(typeid(typeof(x)) == typeid(int));
|
|
assert(x == 1);
|
|
}
|
|
else
|
|
assert(0);
|
|
|
|
if (int x = 1)
|
|
{
|
|
assert(typeid(typeof(x)) == typeid(int));
|
|
assert(x == 1);
|
|
}
|
|
else
|
|
assert(0);
|
|
|
|
if (1)
|
|
{
|
|
}
|
|
else
|
|
assert(0);
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
void test51()
|
|
{
|
|
bool b;
|
|
assert(b == false);
|
|
b &= 1;
|
|
assert(b == false);
|
|
b |= 1;
|
|
assert(b == true);
|
|
b ^= 1;
|
|
assert(b == false);
|
|
b = b | true;
|
|
assert(b == true);
|
|
b = b & false;
|
|
assert(b == false);
|
|
b = b ^ true;
|
|
assert(b == true);
|
|
b = !b;
|
|
assert(b == false);
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
alias int function (int) x52;
|
|
|
|
template T52(string str){
|
|
const int T52 = 1;
|
|
}
|
|
|
|
static assert(T52!(x52.mangleof));
|
|
|
|
void test52()
|
|
{
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
void myfunc(int a1, ...) {
|
|
va_list argument_list;
|
|
TypeInfo argument_type;
|
|
string sa; int ia; double da;
|
|
assert(_arguments.length == 9);
|
|
|
|
va_start(argument_list, a1);
|
|
for (int i = 0; i < _arguments.length; ) {
|
|
if ((argument_type=_arguments[i++]) == typeid(string)) {
|
|
va_arg(argument_list, sa);
|
|
switch (i)
|
|
{
|
|
case 1: assert(sa == "2"); break;
|
|
case 7: assert(sa == "8"); break;
|
|
case 8: assert(sa == "9"); break;
|
|
case 9: assert(sa == "10"); break;
|
|
default:
|
|
printf("i = %d\n", i);
|
|
assert(false);
|
|
}
|
|
} else if (argument_type == typeid(int)) {
|
|
va_arg(argument_list, ia);
|
|
assert(ia == i+1);
|
|
} else if (argument_type == typeid(double)) {
|
|
va_arg(argument_list, da);
|
|
const e = i+1;
|
|
assert((e - 0.0001) < da && da < (e + 0.0001));
|
|
} else {
|
|
assert(false, argument_type.toString());
|
|
}
|
|
}
|
|
va_end(argument_list);
|
|
}
|
|
|
|
void test6758() {
|
|
myfunc(1, 2, 3, 4, 5, 6, 7, 8, "9", "10"); // Fails.
|
|
myfunc(1, 2.0, 3, 4, 5, 6, 7, 8, "9", "10"); // Works OK.
|
|
myfunc(1, 2, 3, 4, 5, 6, 7, "8", "9", "10"); // Works OK.
|
|
myfunc(1, "2", 3, 4, 5, 6, 7, 8, "9", "10"); // Works OK.
|
|
}
|
|
|
|
|
|
/*************************************/
|
|
|
|
real f18573() { return 1; }
|
|
|
|
void test18573()
|
|
{
|
|
cast(void) f18573();
|
|
cast(void) f18573();
|
|
cast(void) f18573();
|
|
cast(void) f18573();
|
|
cast(void) f18573();
|
|
cast(void) f18573();
|
|
cast(void) f18573();
|
|
|
|
real b = 2;
|
|
assert(b == 2); /* fails; should pass */
|
|
}
|
|
|
|
/*************************************/
|
|
|
|
int main()
|
|
{
|
|
test1();
|
|
test2();
|
|
test3();
|
|
test4();
|
|
test5();
|
|
test9();
|
|
test10();
|
|
test11();
|
|
test16();
|
|
test17();
|
|
test18();
|
|
test19();
|
|
test20();
|
|
test21();
|
|
test23();
|
|
test25();
|
|
test27();
|
|
test29();
|
|
test30();
|
|
test31();
|
|
test32();
|
|
test33();
|
|
test34();
|
|
test35();
|
|
test36();
|
|
test37();
|
|
test38();
|
|
test39();
|
|
test40();
|
|
test41();
|
|
test42();
|
|
test43();
|
|
test44();
|
|
test45();
|
|
test46();
|
|
bug5809();
|
|
bug7546();
|
|
test47();
|
|
test48();
|
|
test49();
|
|
test50();
|
|
test51();
|
|
test52();
|
|
test6758();
|
|
test18573();
|
|
|
|
printf("Success\n");
|
|
return 0;
|
|
}
|