1302 lines
22 KiB
D
1302 lines
22 KiB
D
// RUNNABLE_PHOBOS_TEST
|
|
/*
|
|
TEST_OUTPUT:
|
|
---
|
|
Object
|
|
---
|
|
*/
|
|
|
|
module test34;
|
|
|
|
import std.stdio;
|
|
import std.string;
|
|
import std.format;
|
|
import core.exception;
|
|
|
|
|
|
/************************************************/
|
|
|
|
class Foo {}
|
|
class Bar {}
|
|
|
|
void test1()
|
|
{
|
|
TypeInfo ti_foo = typeid(Foo);
|
|
TypeInfo ti_bar = typeid(Bar);
|
|
|
|
auto hfoo = ti_foo.toHash();
|
|
auto hbar = ti_bar.toHash();
|
|
writefln("typeid(Foo).toHash: ", hfoo);
|
|
writefln("typeid(Bar).toHash: ", hbar);
|
|
assert(hfoo != hbar);
|
|
|
|
auto e = (ti_foo == ti_bar);
|
|
writefln("opEquals: ", e ? "equal" : "not equal");
|
|
assert(!e);
|
|
|
|
auto c = (ti_foo.opCmp(ti_bar) == 0);
|
|
writefln("opCmp: ", c ? "equal" : "not equal");
|
|
assert(!c);
|
|
}
|
|
|
|
|
|
/************************************************/
|
|
|
|
void test2()
|
|
{
|
|
assert( [2,3]!=[2,4] );
|
|
assert( [3,2]!=[4,2] );
|
|
assert( !([2,3]==[2,4]) );
|
|
assert( ([2,3]==[2,3]) );
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
struct Struct
|
|
{
|
|
int langID;
|
|
long _force_nrvo;
|
|
}
|
|
|
|
Struct[1] table;
|
|
|
|
Struct getfirst()
|
|
{
|
|
foreach(v; table) {
|
|
writeln(v.langID);
|
|
assert(v.langID == 1);
|
|
return v;
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
Struct getsecond()
|
|
{
|
|
foreach(ref v; table) {
|
|
writeln(v.langID);
|
|
assert(v.langID == 1);
|
|
return v;
|
|
}
|
|
assert(0);
|
|
}
|
|
|
|
void test3()
|
|
{
|
|
table[0].langID = 1;
|
|
|
|
auto v = getfirst();
|
|
writeln(v.langID);
|
|
assert(v.langID == 1);
|
|
|
|
v = getsecond();
|
|
writeln(v.langID);
|
|
assert(v.langID == 1);
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
class ExOuter
|
|
{
|
|
class ExInner
|
|
{
|
|
this()
|
|
{
|
|
typeof(this.outer) X;
|
|
static assert(is(typeof(X) == ExOuter));
|
|
}
|
|
}
|
|
}
|
|
|
|
void test4()
|
|
{
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
int status5;
|
|
|
|
struct MyStruct5
|
|
{
|
|
}
|
|
|
|
void rec5(int i, MyStruct5 s)
|
|
{
|
|
if( i > 0 )
|
|
{
|
|
status5++;
|
|
rec5(i-1, s);
|
|
}
|
|
}
|
|
|
|
void test5()
|
|
{
|
|
assert(status5==0);
|
|
MyStruct5 st;
|
|
rec5(1030, st);
|
|
assert(status5==1030);
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
class C6
|
|
{
|
|
const int a;
|
|
|
|
this()
|
|
{
|
|
a = 3;
|
|
}
|
|
|
|
this(int x)
|
|
{
|
|
this();
|
|
}
|
|
}
|
|
|
|
void test6()
|
|
{
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
template parseUinteger(string s)
|
|
{
|
|
static if (s.length == 0)
|
|
{ const char[] value = "";
|
|
const char[] rest = "";
|
|
}
|
|
else static if (s[0] >= '0' && s[0] <= '9')
|
|
{ const char[] value = s[0] ~ parseUinteger!(s[1..$]).value;
|
|
const char[] rest = parseUinteger!(s[1..$]).rest;
|
|
}
|
|
else
|
|
{ const char[] value = "";
|
|
const char[] rest = s;
|
|
}
|
|
}
|
|
|
|
template parseInteger(string s)
|
|
{
|
|
static if (s.length == 0)
|
|
{ const char[] value = "";
|
|
const char[] rest = "";
|
|
}
|
|
else static if (s[0] >= '0' && s[0] <= '9')
|
|
{ const char[] value = s[0] ~ parseUinteger!(s[1..$]).value;
|
|
const char[] rest = parseUinteger!(s[1..$]).rest;
|
|
}
|
|
else static if (s.length >= 2 &&
|
|
s[0] == '-' && s[1] >= '0' && s[1] <= '9')
|
|
{ const char[] value = s[0..2] ~ parseUinteger!(s[2..$]).value;
|
|
const char[] rest = parseUinteger!(s[2..$]).rest;
|
|
}
|
|
else
|
|
{ const char[] value = "";
|
|
const char[] rest = s;
|
|
}
|
|
}
|
|
|
|
void test7()
|
|
{
|
|
writeln(parseUinteger!("1234abc").value);
|
|
writeln(parseUinteger!("1234abc").rest);
|
|
writeln(parseInteger!("-1234abc").value);
|
|
writeln(parseInteger!("-1234abc").rest);
|
|
|
|
assert(parseUinteger!("1234abc").value == "1234");
|
|
assert(parseUinteger!("1234abc").rest == "abc");
|
|
assert(parseInteger!("-1234abc").value == "-1234");
|
|
assert(parseInteger!("-1234abc").rest == "abc");
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
struct Foo8 { }
|
|
|
|
enum Enum { RED }
|
|
|
|
//typedef int myint;
|
|
|
|
alias int myalias;
|
|
|
|
void test8()
|
|
{
|
|
/+
|
|
assert((1+2).stringof == "1 + 2");
|
|
assert(Foo8.stringof == "Foo8");
|
|
assert(test.Foo8.stringof == "test.Foo8");
|
|
assert(int.stringof == "int");
|
|
assert((int*[5][]).stringof == "int*[5][]");
|
|
assert(Enum.RED.stringof == "Enum.RED");
|
|
assert(test.myint.stringof == "test.myint");
|
|
assert(myalias.stringof == "myalias");
|
|
assert((5).stringof == "5");
|
|
assert(typeof(5).stringof == "typeof(5)");
|
|
+/
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
/+
|
|
class Base9 {
|
|
public void fnc(){
|
|
}
|
|
}
|
|
|
|
class Foo9 : Base9 {
|
|
alias Base9.fnc fnc;
|
|
public void fnc(){
|
|
}
|
|
static this(){
|
|
alias void function() T;
|
|
T ptr = & fnc;
|
|
}
|
|
}
|
|
+/
|
|
|
|
void test9()
|
|
{
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
bool isalnum(dchar c) { return c>='0' && c >= '9'; }
|
|
|
|
char[] toHtmlFilename(char[] fname)
|
|
{
|
|
foreach (ref c; fname)
|
|
{
|
|
if (!isalnum(c) && c != '.' && c != '-')
|
|
c = '_';
|
|
}
|
|
return fname;
|
|
}
|
|
|
|
void test10()
|
|
{
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
class A34 { }
|
|
class B34 : A34 { }
|
|
|
|
void test11()
|
|
{
|
|
A34 test=new B34;
|
|
writefln("Test is ", test.toString);
|
|
assert(test.toString == "test34.B34");
|
|
A34 test_2=cast(A34)(new B34);
|
|
writefln("Test 2 is ", test_2.toString);
|
|
assert(test_2.toString == "test34.B34");
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
template Foo12(T: T[U], U)
|
|
{
|
|
alias int Foo12;
|
|
}
|
|
|
|
void test12()
|
|
{
|
|
Foo12!(int[long]) x;
|
|
assert(is(typeof(x) == int));
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
class C13
|
|
{
|
|
int a = 4;
|
|
this()
|
|
{
|
|
printf("C13.this()\n");
|
|
assert(a == 4);
|
|
a = 5;
|
|
}
|
|
}
|
|
|
|
void test13()
|
|
{
|
|
C13 c = cast(C13)Object.factory("test34.C13");
|
|
assert(c.a == 5);
|
|
Object o = Object.factory("test35.C13");
|
|
assert(o is null);
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
class Base15 {
|
|
int func(int a) { return 1; }
|
|
}
|
|
|
|
|
|
class Foo15 : Base15 {
|
|
alias Base15.func func;
|
|
}
|
|
|
|
|
|
class Bar15 : Foo15 {
|
|
alias Foo15.func func;
|
|
int func(string a) { return 2; }
|
|
}
|
|
|
|
void test15()
|
|
{
|
|
Bar15 b = new Bar15();
|
|
assert(b.func("hello") == 2);
|
|
assert(b.func(5) == 1);
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
struct Basic16(T, U) {}
|
|
|
|
struct Iterator16(T : Basic16!(T, U), U)
|
|
{
|
|
static void Foo()
|
|
{
|
|
writeln(typeid(T), typeid(U));
|
|
assert(is(T == int));
|
|
assert(is(U == float));
|
|
}
|
|
}
|
|
|
|
void test16()
|
|
{
|
|
Iterator16!(Basic16!(int, float)).Foo();
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
struct S17(T)
|
|
{
|
|
struct iterator {}
|
|
}
|
|
|
|
int insert17(T) (S17!(T) lst, S17!(T).iterator i)
|
|
{
|
|
return 3;
|
|
}
|
|
|
|
void test17()
|
|
{
|
|
S17!(int) a;
|
|
S17!(int).iterator i;
|
|
auto x = insert17(a, i);
|
|
assert(x == 3);
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
void test18()
|
|
{
|
|
real t = 0.;
|
|
for(int i=0; i<10; i++)
|
|
{
|
|
t += 1.;
|
|
real r = (2*t);
|
|
printf("%Lg %Lg %Lg\n", t, r, 2*t);
|
|
assert(2*t == (i+1)*2);
|
|
}
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
void test19()
|
|
{
|
|
char c = '3';
|
|
void[] ca = cast(void[])[c];
|
|
char[] x = cast(char[])ca;
|
|
assert(x[0] == '3');
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
enum type20
|
|
{
|
|
a,
|
|
b,
|
|
}
|
|
|
|
class myclass20
|
|
{
|
|
template XX(uint a, uint c)
|
|
{
|
|
static uint XX(){ return (a*256+c);}
|
|
}
|
|
void testcase()
|
|
{
|
|
switch (cast(uint)type20.a)
|
|
{
|
|
case XX!(cast(uint)type20.a,cast(uint)type20.b)():
|
|
break;
|
|
default: assert(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
void test20()
|
|
{
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
struct S21
|
|
{
|
|
alias int Foo;
|
|
int x;
|
|
}
|
|
|
|
void test21()
|
|
{
|
|
S21 s;
|
|
typeof(s).Foo j;
|
|
assert(is(typeof(j) == int));
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
void test22()
|
|
{
|
|
auto i = 3, j = 4;
|
|
assert(is(typeof(i) == int));
|
|
assert(is(typeof(j) == int));
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
static m23 = 5, n23 = 6;
|
|
|
|
void test23()
|
|
{
|
|
auto i = 3, j = 4;
|
|
assert(is(typeof(i) == int));
|
|
assert(is(typeof(j) == int));
|
|
assert(is(typeof(m23) == int));
|
|
assert(is(typeof(n23) == int));
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
const int a24 = 0;
|
|
const int foo24 = 4;
|
|
const int[1] bar24 = [foo24 * 2];
|
|
const int zap24 = (1 << bar24[a24]);
|
|
|
|
void test24()
|
|
{
|
|
assert(zap24 == 256);
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
struct List25(T) { }
|
|
struct CircularQueue25(T) { }
|
|
|
|
void front25(T)(ref List25!(T) list) { }
|
|
void front25(T)(ref CircularQueue25!(T) queue) { }
|
|
|
|
void test25()
|
|
{
|
|
List25!(int) x;
|
|
front25(x);
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
struct Foo26
|
|
{
|
|
const string x;
|
|
}
|
|
|
|
static Foo26 foo26 = {"something"};
|
|
|
|
void test26()
|
|
{
|
|
assert(foo26.x == "something");
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
template Mang(alias F)
|
|
{
|
|
class G { }
|
|
alias void function (G ) H;
|
|
const string mangledname = H.mangleof;
|
|
}
|
|
|
|
template moo(alias A)
|
|
{
|
|
pragma(msg," ");
|
|
const string a = Mang!(A).mangledname;
|
|
pragma(msg," ");
|
|
static assert(Mang!(A).mangledname == a); // FAILS !!!
|
|
pragma(msg," ");
|
|
}
|
|
|
|
void test27()
|
|
{
|
|
int q;
|
|
string b = moo!(q).a;
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
struct Color
|
|
{
|
|
static void fromRgb(uint rgb)
|
|
{
|
|
}
|
|
|
|
static void fromRgb(ubyte alpha, uint rgb)
|
|
{
|
|
}
|
|
}
|
|
|
|
void test28()
|
|
{
|
|
Color.fromRgb(0);
|
|
Color.fromRgb(cast(uint)0);
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
void test29()
|
|
{
|
|
const char[] t="abcd";
|
|
const ubyte[] t2=cast(ubyte[])t;
|
|
const char[] t3=['a','b','c','d'];
|
|
const ubyte[] t4=cast(ubyte[])t3;
|
|
assert(t4[1] == 'b');
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
void test30()
|
|
{
|
|
const char[] test = "" ~ 'a' ~ 'b' ~ 'c';
|
|
char[] test2 = (cast(char[])null)~'a'~'b'~'c';
|
|
const char[] test3 = (cast(char[])null)~'a'~'b'~'c';
|
|
char[] test4 = (cast(char[])[])~'a'~'b'~'c';
|
|
const char[] test5 = (cast(char[])[])~'a'~'b'~'c';
|
|
const char[] test6 = null;
|
|
const char[] test7 = test6~'a'~'b'~'c';
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
class C31
|
|
{
|
|
synchronized invariant() { int x; }
|
|
}
|
|
|
|
void test31()
|
|
{
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
ulong foo32()
|
|
{
|
|
return cast(ulong) (cast(ulong) 1176576512 + cast(float) -2);
|
|
}
|
|
|
|
void test32()
|
|
{
|
|
assert(foo32()==1176576510);
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
class RangeCoder
|
|
{
|
|
uint[258] cumCount; // 256 + end + total
|
|
uint lower;
|
|
uint upper;
|
|
ulong range;
|
|
|
|
this() {
|
|
for (int i=0; i<cumCount.length; i++)
|
|
cumCount[i] = i;
|
|
lower = 0;
|
|
upper = 0xffffffff;
|
|
range = 0x100000000;
|
|
}
|
|
|
|
void encode(uint symbol) {
|
|
uint total = cumCount[$ - 1];
|
|
// "Error: Access Violation" in following line
|
|
upper = lower + cast(uint)((cumCount[symbol+1] * range) / total) - 1;
|
|
lower = lower + cast(uint)((cumCount[symbol] * range) / total);
|
|
}
|
|
}
|
|
|
|
void test33()
|
|
{
|
|
RangeCoder rc = new RangeCoder();
|
|
rc.encode(77);
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
struct Vector34
|
|
{
|
|
float x, y, z;
|
|
|
|
public static Vector34 opCall(float x = 0, float y = 0, float z = 0)
|
|
{
|
|
Vector34 v;
|
|
|
|
v.x = x;
|
|
v.y = y;
|
|
v.z = z;
|
|
|
|
return v;
|
|
}
|
|
|
|
public string toString()
|
|
{
|
|
return std.string.format("<%f, %f, %f>", x, y, z);
|
|
}
|
|
}
|
|
|
|
class Foo34
|
|
{
|
|
private Vector34 v;
|
|
|
|
public this()
|
|
{
|
|
v = Vector34(1, 0, 0);
|
|
}
|
|
|
|
public void foo()
|
|
{
|
|
bar();
|
|
}
|
|
|
|
private void bar()
|
|
{
|
|
auto s = foobar();
|
|
writef("Returned: %s\n", s);
|
|
assert(std.string.format("%s", s) == "<1.000000, 0.000000, 0.000000>");
|
|
}
|
|
|
|
public Vector34 foobar()
|
|
{
|
|
writef("Returning %s\n", v);
|
|
|
|
return v;
|
|
Vector34 b = Vector34();
|
|
return b;
|
|
}
|
|
}
|
|
|
|
void test34()
|
|
{
|
|
Foo34 f = new Foo34();
|
|
f.foo();
|
|
}
|
|
|
|
|
|
/************************************************/
|
|
|
|
void foo35()
|
|
{
|
|
uint a;
|
|
uint b;
|
|
uint c;
|
|
extern (Windows) int function(int i, int j, int k) xxx;
|
|
|
|
a = 1;
|
|
b = 2;
|
|
c = 3;
|
|
|
|
xxx = cast(typeof(xxx))(a + b);
|
|
throw new Exception("xxx");
|
|
xxx( 4, 5, 6 );
|
|
}
|
|
|
|
void test35()
|
|
{
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
void test36()
|
|
{
|
|
int* p = void, c = void;
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
void test37()
|
|
{
|
|
synchronized
|
|
{
|
|
synchronized
|
|
{
|
|
writefln("Hello world!");
|
|
}
|
|
}
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
struct Rect {
|
|
int left, top, right, bottom;
|
|
}
|
|
|
|
void test38()
|
|
{
|
|
print38(sizeTest(false));
|
|
print38(sizeTest(true));
|
|
print38(defaultRect);
|
|
}
|
|
|
|
static Rect sizeTest(bool empty) {
|
|
if (empty) {
|
|
Rect result;
|
|
return result;
|
|
//return Rect.init;
|
|
} else {
|
|
return defaultRect;
|
|
/+Rect result = defaultRect;
|
|
return result;+/
|
|
}
|
|
}
|
|
|
|
void print38(Rect r) {
|
|
writefln("(%d, %d)-(%d, %d)", r.left, r.top, r.right, r.bottom);
|
|
assert(r.left == 0);
|
|
assert(r.right == 0);
|
|
assert(r.top == 0);
|
|
assert(r.bottom == 0);
|
|
}
|
|
|
|
Rect defaultRect() {
|
|
return Rect.init;
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
void test39()
|
|
{
|
|
double[][] foo = [[1.0],[2.0]];
|
|
|
|
writeln(foo[0]); // --> [1] , ok
|
|
writeln(foo[1]); // --> [2] , ok
|
|
|
|
writeln(foo); // --> [[1],4.63919e-306] ack!
|
|
writefln("%s", foo); // --> ditto
|
|
auto f = std.string.format("%s", foo);
|
|
assert(f == "[[1], [2]]");
|
|
|
|
double[1][2] bar;
|
|
bar[0][0] = 1.0;
|
|
bar[1][0] = 2.0;
|
|
|
|
writeln(bar); // Error: Access violation
|
|
auto r = std.string.format("%s", bar);
|
|
assert(r == "[[1], [2]]");
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
void test40()
|
|
{
|
|
int[char] x;
|
|
x['b'] = 123;
|
|
writeln(x);
|
|
auto r = std.string.format("%s", x);
|
|
assert(r == "['b':123]");
|
|
writeln(x['b']);
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
void test41()
|
|
{
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
enum Enum42 {
|
|
A = 1
|
|
}
|
|
|
|
void test42() {
|
|
Enum42[] enums = new Enum42[1];
|
|
assert(enums[0] == Enum42.A);
|
|
}
|
|
|
|
|
|
/************************************************/
|
|
|
|
struct A43 {}
|
|
|
|
struct B43(L) {
|
|
A43 l;
|
|
}
|
|
|
|
void test43()
|
|
{
|
|
A43 a;
|
|
auto b = B43!(A43)(a);
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
void test44()
|
|
{
|
|
int[ const char[] ] a = ["abc":3, "def":4];
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
void test45()
|
|
{
|
|
//char[3][] a = ["abc", "def"];
|
|
//writefln(a);
|
|
//char[][2] b = ["abc", "def"];
|
|
//writefln(b);
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
struct bignum
|
|
{
|
|
bool smaller()
|
|
{
|
|
if (true) return false;
|
|
else return false;
|
|
assert(0);
|
|
}
|
|
|
|
void equal()
|
|
{
|
|
if (!smaller)
|
|
return;
|
|
}
|
|
}
|
|
|
|
void test46()
|
|
{
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
static size_t myfind(string haystack, char needle) {
|
|
foreach (i, c ; haystack) {
|
|
if (c == needle) return i;
|
|
}
|
|
return size_t.max;
|
|
}
|
|
|
|
static size_t skip_digits(string s) {
|
|
foreach (i, c ; s) {
|
|
if (c < '0' || c > '9') return i;
|
|
}
|
|
return s.length;
|
|
}
|
|
|
|
static uint matoi(string s) {
|
|
uint result = 0;
|
|
foreach (c ; s) {
|
|
if (c < '0' || c > '9') break;
|
|
result = result * 10 + (c - '0');
|
|
}
|
|
return result;
|
|
}
|
|
|
|
enum { leading, skip, width, modifier, format, fmt_length, extra };
|
|
|
|
static string GetFormat(string s) {
|
|
uint pos = 0;
|
|
string result;
|
|
// find the percent sign
|
|
while (pos < s.length && s[pos] != '%') {
|
|
++pos;
|
|
}
|
|
const leading_chars = pos;
|
|
result ~= cast(char) pos;
|
|
if (pos < s.length) ++pos; // go right after the '%'
|
|
// skip?
|
|
if (pos < s.length && s[pos] == '*') {
|
|
result ~= 1;
|
|
++pos;
|
|
} else {
|
|
result ~= 0;
|
|
}
|
|
// width?
|
|
result ~= cast(char) matoi(s);
|
|
pos += skip_digits(s[pos .. $]);
|
|
// modifier?
|
|
if (pos < s.length && myfind("hjlLqtz", s[pos]) != size_t.max) {
|
|
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@
|
|
static if (true) {
|
|
result ~= s[pos++];
|
|
} else {
|
|
result ~= s[pos];
|
|
++pos;
|
|
}
|
|
// @@@@@@@@@@@@@@@@@@@@@@@@@@@@
|
|
} else {
|
|
result ~= '\0';
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void test47()
|
|
{
|
|
static string test = GetFormat(" %*Lf");
|
|
assert(test[modifier] == 'L', "`" ~ test[modifier] ~ "'");
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
class B48() {}
|
|
class C48 {}
|
|
|
|
int foo48()(B48!()) { return 1; }
|
|
int foo48()(C48 c) { return 2; }
|
|
|
|
void test48()
|
|
{
|
|
auto i = foo48(new B48!());
|
|
assert(i == 1);
|
|
|
|
i = foo48(new C48);
|
|
assert(i == 2);
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
void test49()
|
|
{
|
|
struct A { int v; }
|
|
|
|
A a = A(10);
|
|
|
|
version (all)
|
|
{
|
|
writefln("Before test 1: ", a.v);
|
|
if (a == a.init) { writeln(a.v,"(a==a.init)"); assert(0); }
|
|
else { writeln(a.v,"(a!=a.init)"); assert(a.v == 10); }
|
|
}
|
|
else
|
|
{
|
|
writefln("Before test 1: ", a.v);
|
|
if (a == a.init) { writeln(a.v,"(a==a.init)"); assert(a.v == 10); }
|
|
else { writeln(a.v,"(a!=a.init)"); assert(0); }
|
|
}
|
|
|
|
a.v = 100;
|
|
writefln("Before test 2: ", a.v);
|
|
if (a == a.init) { writeln(a.v,"(a==a.init)"); assert(0); }
|
|
else { writeln(a.v,"(a!=a.init)"); assert(a.v == 100); }
|
|
|
|
a = A(1000);
|
|
writefln("Before test 3: ", a.v);
|
|
if (a == a.init) { writeln(a.v,"(a==a.init)"); assert(0); }
|
|
else { writeln(a.v,"(a!=a.init)"); assert(a.v == 1000); }
|
|
|
|
version (all)
|
|
assert(a.init.v == 0);
|
|
else
|
|
assert(a.init.v == 10);
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
struct S51
|
|
{
|
|
int i = 3;
|
|
void div() { assert(i == 3); }
|
|
}
|
|
|
|
void test51()
|
|
{
|
|
S51().div();
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
void test52()
|
|
{
|
|
struct Foo {
|
|
alias int Y;
|
|
}
|
|
with (Foo) {
|
|
Y y;
|
|
}
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
struct TestStruct
|
|
{
|
|
int dummy0 = 0;
|
|
int dummy1 = 1;
|
|
int dummy2 = 2;
|
|
}
|
|
|
|
void func53(TestStruct[2] testarg)
|
|
{
|
|
writeln(testarg[0].dummy0);
|
|
writeln(testarg[0].dummy1);
|
|
writeln(testarg[0].dummy2);
|
|
|
|
writeln(testarg[1].dummy0);
|
|
writeln(testarg[1].dummy1);
|
|
writeln(testarg[1].dummy2);
|
|
|
|
assert(testarg[0].dummy0 == 0);
|
|
assert(testarg[0].dummy1 == 1);
|
|
assert(testarg[0].dummy2 == 2);
|
|
|
|
assert(testarg[1].dummy0 == 0);
|
|
assert(testarg[1].dummy1 == 1);
|
|
assert(testarg[1].dummy2 == 2);
|
|
}
|
|
|
|
TestStruct m53[2];
|
|
|
|
void test53()
|
|
{
|
|
writeln(&m53);
|
|
func53(m53);
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
void test54()
|
|
{
|
|
double a = 0;
|
|
double b = 1;
|
|
// Internal error: ..\ztc\cg87.c 3233
|
|
// a += (1? b: 1+1i)*1i;
|
|
writeln(a);
|
|
// assert(a == 0);
|
|
// Internal error: ..\ztc\cod2.c 1680
|
|
// a += (b?1:b-1i)*1i;
|
|
writeln(a);
|
|
// assert(a == 0);
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
class B55 {}
|
|
class D55 : B55 {}
|
|
|
|
template foo55(S, T : S) { } // doesn't work
|
|
|
|
alias foo55!(B55, D55) bar55;
|
|
|
|
void test55()
|
|
{
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
template t56() { alias Object t56; }
|
|
pragma(msg, t56!().stringof);
|
|
|
|
void test56()
|
|
{
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
void test57()
|
|
{
|
|
alias long[char[]] AA;
|
|
|
|
static if (is(AA T : T[U], U : const char[]))
|
|
{
|
|
writeln(typeid(T));
|
|
writeln(typeid(U));
|
|
|
|
assert(is(T == long));
|
|
assert(is(U == const(char)[]));
|
|
}
|
|
|
|
static if (is(AA A : A[B], B : int))
|
|
{
|
|
assert(0);
|
|
}
|
|
|
|
static if (is(int[10] W : W[V], int V))
|
|
{
|
|
writeln(typeid(W));
|
|
assert(is(W == int));
|
|
writeln(V);
|
|
assert(V == 10);
|
|
}
|
|
|
|
static if (is(int[10] X : X[Y], int Y : 5))
|
|
{
|
|
assert(0);
|
|
}
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
static this()
|
|
{
|
|
printf("one\n");
|
|
}
|
|
|
|
static this()
|
|
{
|
|
printf("two\n");
|
|
}
|
|
|
|
static ~this()
|
|
{
|
|
printf("~two\n");
|
|
}
|
|
|
|
static ~this()
|
|
{
|
|
printf("~one\n");
|
|
}
|
|
|
|
|
|
void test59()
|
|
{
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
class C60
|
|
{
|
|
extern (C++) int bar60(int i, int j, int k)
|
|
{
|
|
printf("this = %p\n", this);
|
|
printf("i = %d\n", i);
|
|
printf("j = %d\n", j);
|
|
printf("k = %d\n", k);
|
|
assert(i == 4);
|
|
assert(j == 5);
|
|
assert(k == 6);
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
|
|
extern (C++)
|
|
int foo60(int i, int j, int k)
|
|
{
|
|
printf("i = %d\n", i);
|
|
printf("j = %d\n", j);
|
|
printf("k = %d\n", k);
|
|
assert(i == 1);
|
|
assert(j == 2);
|
|
assert(k == 3);
|
|
return 1;
|
|
}
|
|
|
|
void test60()
|
|
{
|
|
foo60(1, 2, 3);
|
|
|
|
C60 c = new C60();
|
|
c.bar60(4, 5, 6);
|
|
}
|
|
|
|
/***************************************************/
|
|
|
|
template Foo61(alias a) {}
|
|
|
|
struct Bar61 {}
|
|
const Bar61 bar61 = {};
|
|
|
|
alias Foo61!(bar61) baz61;
|
|
|
|
void test61()
|
|
{
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
T foo62(T)(lazy T value)
|
|
{
|
|
return value;
|
|
}
|
|
|
|
void test62()
|
|
{
|
|
foo62(new float[1]);
|
|
}
|
|
|
|
/************************************************/
|
|
|
|
void main()
|
|
{
|
|
test1();
|
|
test2();
|
|
test3();
|
|
test4();
|
|
test5();
|
|
test6();
|
|
test7();
|
|
test8();
|
|
test9();
|
|
test10();
|
|
test11();
|
|
test12();
|
|
test13();
|
|
test15();
|
|
test16();
|
|
test17();
|
|
test18();
|
|
test19();
|
|
test20();
|
|
test21();
|
|
test22();
|
|
test23();
|
|
test24();
|
|
test25();
|
|
test26();
|
|
test27();
|
|
test28();
|
|
test29();
|
|
test30();
|
|
test31();
|
|
test32();
|
|
test33();
|
|
test34();
|
|
test35();
|
|
test36();
|
|
test37();
|
|
test38();
|
|
test39();
|
|
test40();
|
|
test41();
|
|
test42();
|
|
test43();
|
|
test44();
|
|
test45();
|
|
test46();
|
|
test47();
|
|
test48();
|
|
test49();
|
|
test51();
|
|
test52();
|
|
test53();
|
|
test54();
|
|
test55();
|
|
test56();
|
|
test57();
|
|
test59();
|
|
test60();
|
|
test61();
|
|
test62();
|
|
|
|
writefln("Success");
|
|
}
|
|
|
|
|