| // 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"); |
| } |
| |
| |