| module test; |
| |
| import core.stdc.stdio; |
| import core.vararg; |
| |
| /*******************************************/ |
| |
| struct S1 |
| { |
| void* function(void*) fn; |
| } |
| |
| template M1() |
| { |
| S1 s; |
| } |
| |
| void test1() |
| { |
| S1 s2; |
| mixin M1; |
| assert(s.fn == null); |
| } |
| |
| /*******************************************/ |
| |
| enum Qwert { yuiop } |
| |
| int asdfg(Qwert hjkl) { return 1; } |
| int asdfg(uint zxcvb) { return 2; } |
| |
| void test2() |
| { |
| int nm = 2; |
| |
| assert(asdfg(nm) == 2); |
| assert(asdfg(cast(int) nm) == 2); |
| assert(asdfg(3) == 2); |
| assert(asdfg(cast(int) 3) == 2); |
| assert(asdfg(3L) == 2); |
| assert(asdfg(cast(int) 3L) == 2); |
| assert(asdfg(3 + 2) == 2); |
| assert(asdfg(cast(int) (3 + 2)) == 2); |
| assert(asdfg(nm + 2) == 2); |
| assert(asdfg(cast(int) (nm + 2)) == 2); |
| assert(asdfg(3 + nm) == 2); |
| assert(asdfg(cast(int) (3 + nm)) == 2); |
| |
| } |
| |
| /*******************************************/ |
| |
| template Qwert3(string yuiop) { |
| immutable string Qwert3 = cast(string)yuiop; |
| } |
| |
| template Asdfg3(string yuiop) { |
| immutable string Asdfg3 = cast(string)Qwert3!(cast(string)(cast(string)yuiop ~ cast(string)"hjkl")); |
| } |
| |
| void test3() |
| { |
| string zxcvb = Asdfg3!(null); |
| assert(zxcvb == "hjkl"); |
| assert(zxcvb == "hjkl" ~ null); |
| } |
| |
| /*******************************************/ |
| |
| template Qwert4(string yuiop) |
| { |
| immutable string Qwert4 = cast(string)(yuiop ~ "asdfg" ~ yuiop); |
| } |
| |
| void test4() |
| { |
| string hjkl = Qwert4!(null); |
| assert(hjkl == "asdfg"); |
| } |
| |
| /*******************************************/ |
| |
| void test6() |
| { |
| struct Foo |
| { |
| void foo() { } |
| } |
| |
| alias Foo Bar; |
| |
| Bar a; |
| a.foo(); |
| } |
| |
| /*******************************************/ |
| |
| void test7() |
| { |
| struct Foo |
| { |
| alias typeof(this) ThisType; |
| alias typeof(this) ThatType; |
| } |
| |
| assert(is(Foo.ThisType == Foo)); |
| assert(is(Foo.ThatType == Foo)); |
| } |
| |
| /*******************************************/ |
| |
| void test8() |
| { |
| int[] test; |
| test.length = 10; |
| assert(test.length == 10); |
| assert(test.ptr != null); |
| |
| test.length = 1; |
| assert(test.length == 1); |
| assert(test.ptr != null); |
| |
| test.length = 8; |
| assert(test.length == 8); |
| assert(test.ptr != null); |
| |
| test.length = 0; |
| assert(test.length == 0); |
| assert(test.ptr != null); |
| } |
| |
| /*******************************************/ |
| |
| class CBase10 |
| { |
| this() { } |
| } |
| |
| void foo10( CBase10 l ) |
| { |
| } |
| |
| void test10() |
| { |
| if (1) |
| { |
| foo10( new class() CBase10 |
| { |
| this() { super(); } |
| } |
| ); |
| } |
| return; |
| } |
| |
| /*******************************************/ |
| |
| struct Foo11 |
| { |
| static |
| int func(T)(T a) { assert(a == 1); return 0; } |
| } |
| |
| void test11() |
| { |
| auto a = Foo11.init.func(1); |
| a = Foo11.init.func!(int)(1); |
| a = Foo11.func(1); |
| a = Foo11.func!(int)(1); |
| } |
| |
| /*******************************************/ |
| |
| void test12() |
| { |
| class ExceptioN { } |
| |
| class ExceptioX { } |
| |
| static assert(ExceptioN.mangleof[0 ..$-1] == ExceptioX.mangleof[0 .. $-1]); |
| } |
| |
| /*******************************************/ |
| |
| template check( char ch1, char ch2) |
| { |
| const bool check = ch1 == ch2; |
| } |
| |
| void test13() |
| { |
| const char[] s = "123+456" ; |
| assert(check!( '+', s[3] ) == true); |
| } |
| |
| /*******************************************/ |
| |
| void test14() |
| { |
| static const char[] test=['a','b','c','d']; |
| static assert(test==['a','b','c','d']); |
| static assert(['a','b','c','d']== test); |
| } |
| |
| /*******************************************/ |
| |
| void func15(...) |
| in { |
| printf("Arguments len = %d\n", cast(int)_arguments.length); |
| assert(_arguments.length == 2); |
| } |
| do { |
| |
| } |
| |
| void test15() |
| { |
| func15(1, 2); |
| } |
| |
| /*******************************************/ |
| |
| void test17() |
| { |
| void delegate() y = { }; |
| y(); |
| } |
| |
| /*******************************************/ |
| |
| abstract class Pen { int foo(); } |
| |
| class Penfold : Pen { |
| override int foo() { return 1; } |
| } |
| |
| class Pinky : Pen { |
| override int foo() { return 2; } |
| } |
| |
| class Printer { |
| void vprint(Pen obj) { |
| assert(obj.foo() == 1 || obj.foo() == 2); |
| } |
| |
| C print(C)(C obj) { |
| assert(obj.foo() == 1 || obj.foo() == 2); |
| return obj; |
| } |
| |
| } |
| |
| void test18() |
| { |
| Printer p = new Printer; |
| p.print(new Pinky); |
| p.print(new Penfold); |
| with (p) |
| { |
| vprint(new Pinky); |
| vprint(new Penfold); |
| |
| print!(Pinky)(new Pinky); |
| print!(Penfold)(new Penfold); |
| |
| p.print(new Pinky); |
| p.print(new Penfold); |
| |
| print(new Pinky); |
| print(new Penfold); |
| } |
| } |
| |
| /*******************************************/ |
| |
| |
| class A19 |
| { |
| void s() {} |
| } |
| |
| class B19 : A19 |
| { |
| alias A19.s s; |
| static void s(int i) {} |
| override void s() {} |
| } |
| |
| class C19 |
| { |
| void f() { |
| B19.s(0); |
| } |
| } |
| |
| void test19() |
| { |
| } |
| |
| |
| /*******************************************/ |
| |
| class U {} |
| class T : U {} |
| |
| void test20() |
| { |
| T* ptr; |
| T[2] sar; |
| T[] dar; |
| |
| // all of the following should work according to the "Implicit |
| // Conversions" section of the spec |
| |
| tPtr(ptr); |
| tPtr(sar.ptr); |
| tPtr(dar.ptr); |
| tDar(sar); |
| |
| // uPtr(ptr); // T* => U* |
| // uPtr(sar); // T[2] => U* |
| // uPtr(dar); // T[] => U* |
| // uSar(sar); // T[2] => U[2] |
| // uDar(sar); // T[2] => U[] |
| |
| uDar(dar); // T[] => const(U)[] |
| vPtr(ptr); // T* => void* |
| vPtr(sar.ptr); |
| vPtr(dar.ptr); |
| |
| vDar(sar); |
| vDar(dar); // works, but T[] => void[] isn't mentioned in the spec |
| } |
| |
| void tPtr(T*t){} |
| void tDar(T[]t){} |
| void uPtr(U*u){} |
| void uSar(U[2]u){} |
| void uDar(const(U)[]u){} |
| void vPtr(void*v){} |
| void vDar(void[]v){} |
| |
| |
| /*******************************************/ |
| |
| struct Foo21 |
| { |
| int i; |
| } |
| |
| template some_struct_instance(T) |
| { |
| static Foo21 some_struct_instance = |
| { |
| 5, |
| }; |
| } |
| |
| void test21() |
| { |
| alias some_struct_instance!(int) inst; |
| assert(inst.i == 5); |
| } |
| |
| /*******************************************/ |
| |
| struct Foo22(T) {} |
| |
| void test22() |
| { |
| int i; |
| |
| if ((Foo22!(char)).init == (Foo22!(char)).init) |
| i = 1; |
| assert(i == 1); |
| } |
| |
| |
| /*******************************************/ |
| |
| void test23() |
| { |
| auto t=['a','b','c','d']; |
| assert(is(typeof(t) == char[])); |
| |
| const t2=['a','b','c','d','e']; |
| assert(is(typeof(t2) == const(const(char)[]))); |
| } |
| |
| /*******************************************/ |
| |
| int foo24(int i ...) |
| { |
| return i; |
| } |
| |
| void test24() |
| { |
| assert(foo24(3) == 3); |
| } |
| |
| /*******************************************/ |
| |
| struct Foo26 |
| { |
| int a; |
| |
| static Foo26 opCall(int i) |
| { Foo26 f; |
| f.a += i; |
| return f; |
| } |
| } |
| |
| void test26() |
| { Foo26 f; |
| |
| f = cast(Foo26)3; |
| assert(f.a == 3); |
| |
| Foo26 g = 3; |
| assert(g.a == 3); |
| } |
| |
| /*******************************************/ |
| |
| struct S27 |
| { |
| int x; |
| |
| void opAssign(int i) |
| { |
| x = i + 1; |
| } |
| } |
| |
| void test27() |
| { |
| S27 s; |
| s = 1; |
| assert(s.x == 2); |
| } |
| |
| /*******************************************/ |
| |
| class C28 |
| { |
| int x; |
| |
| void opAssign(int i) |
| { |
| x = i + 1; |
| } |
| } |
| |
| void test28() |
| { |
| // No longer supported for 2.0 |
| // C28 s = new C28; |
| // s = 1; |
| // assert(s.x == 2); |
| } |
| |
| /*******************************************/ |
| |
| struct S29 |
| { |
| static S29 opCall(int v) |
| { |
| S29 result; |
| result.v = v; |
| return result; |
| } |
| int a; |
| int v; |
| int x,y,z; |
| } |
| |
| int foo29() |
| { |
| auto s = S29(5); |
| return s.v; |
| } |
| |
| void test29() |
| { |
| int i = foo29(); |
| printf("%d\n", i); |
| assert(i == 5); |
| } |
| |
| /*******************************************/ |
| |
| struct S30 |
| { |
| static S30 opCall(int v) |
| { |
| S30 result; |
| |
| void bar() |
| { |
| result.v += 1; |
| } |
| |
| result.v = v; |
| bar(); |
| return result; |
| } |
| int a; |
| int v; |
| int x,y,z; |
| } |
| |
| int foo30() |
| { |
| auto s = S30(5); |
| return s.v; |
| } |
| |
| void test30() |
| { |
| int i = foo30(); |
| printf("%d\n", i); |
| assert(i == 6); |
| } |
| |
| /*******************************************/ |
| |
| struct S31 |
| { |
| static void abc(S31 *r) |
| { |
| r.v += 1; |
| } |
| |
| static S31 opCall(int v) |
| { |
| S31 result; |
| |
| void bar() |
| { |
| abc(&result); |
| } |
| |
| result.v = v; |
| bar(); |
| return result; |
| } |
| int a; |
| int v; |
| int x,y,z; |
| } |
| |
| int foo31() |
| { |
| auto s = S31(5); |
| return s.v; |
| } |
| |
| void test31() |
| { |
| int i = foo31(); |
| printf("%d\n", i); |
| assert(i == 6); |
| } |
| |
| /*******************************************/ |
| |
| |
| struct T32 |
| { |
| int opApply(int delegate(ref int i) dg) |
| { |
| int i; |
| return dg(i); |
| } |
| } |
| |
| struct S32 |
| { |
| static void abc(S32 *r) |
| { |
| r.v += 1; |
| } |
| |
| static S32 opCall(int v) |
| { |
| S32 result; |
| T32 t; |
| |
| result.v = v; |
| foreach (i; t) |
| { |
| result.v += 1; |
| break; |
| } |
| return result; |
| } |
| int a; |
| int v; |
| int x,y,z; |
| } |
| |
| int foo32() |
| { |
| auto s = S32(5); |
| return s.v; |
| } |
| |
| void test32() |
| { |
| int i = foo32(); |
| printf("%d\n", i); |
| assert(i == 6); |
| } |
| |
| /*******************************************/ |
| |
| class Confectionary |
| { |
| this(int sugar) |
| { |
| //if (sugar < 500) |
| // tastiness = 200; |
| |
| //for (int i = 0; i < 10; ++i) |
| // tastiness = 300; |
| |
| //int[] tastinesses_array; |
| |
| //foreach (n; tastinesses_array) |
| // tastiness = n; |
| |
| //int[int] tastinesses_aa; |
| |
| //foreach (n; tastinesses_aa) |
| // tastiness = n; |
| |
| tastiness = 1; |
| } |
| |
| const int tastiness; |
| } |
| |
| void test33() |
| { |
| } |
| |
| /*******************************************/ |
| |
| template a34(string name, T...) |
| { |
| string a34(string name,T t) |
| { |
| string localchar; |
| foreach (a34; T) |
| { |
| localchar ~= a34.mangleof; |
| } |
| return localchar; |
| } |
| } |
| |
| void test34() |
| { |
| assert(a34!("Adf"[], typeof("adf"),uint)("Adf"[],"adf",1234) == "Ayak"); |
| } |
| |
| /*******************************************/ |
| |
| template a35(string name, T...) |
| { |
| int a35(M...)(M m) |
| { |
| return 3; |
| } |
| } |
| |
| void test35() |
| { |
| assert(a35!("adf")() == 3); |
| } |
| |
| /*******************************************/ |
| |
| template a36(AnotherT,string name,T...){ |
| AnotherT a36(M...)(M){ |
| AnotherT localchar; |
| foreach(a;T) |
| { |
| localchar~=a.mangleof; |
| } |
| return cast(AnotherT)localchar; |
| } |
| } |
| |
| void test36() |
| { |
| string b="adf"; |
| uint i=123; |
| char[3] c="Adf"; |
| assert(a36!(typeof(b),"Adf")() == ""); |
| } |
| |
| /*******************************************/ |
| |
| struct Q37 { |
| Y37 opCast() { |
| return Y37.init; |
| } |
| } |
| |
| struct Y37 { |
| Q37 asdfg() { |
| return Q37.init; |
| } |
| |
| void hjkl() { |
| Q37 zxcvb = asdfg(); // line 13 |
| } |
| } |
| |
| void test37() |
| { |
| } |
| |
| /*******************************************/ |
| |
| |
| |
| class C38 { } |
| |
| const(Object)[] foo38(C38[3] c) @system |
| { const(Object)[] x = c; |
| return x; |
| } |
| |
| void test38() |
| { |
| } |
| |
| /*******************************************/ |
| |
| void test39() |
| { |
| void print(string[] strs) |
| { |
| assert(strs == ["Matt", "Andrew"]); |
| } |
| |
| print(["Matt", "Andrew"]); |
| } |
| |
| /*******************************************/ |
| |
| void test40() |
| { |
| class C |
| { |
| Object propName() |
| { |
| return this; |
| } |
| } |
| |
| auto c = new C; |
| |
| with (c.propName) |
| { |
| assert(toString() == "test.test40.C"); |
| } |
| |
| auto foo = c.propName; |
| } |
| |
| /*******************************************/ |
| |
| void test41() |
| { |
| auto test = new char [2]; |
| |
| int x1, x2, x3; |
| char[] foo1() { x1++; return test; } |
| int foo2() { x2++; return 0; } |
| int foo3() { x3++; return 1; } |
| |
| test [] = 'a'; |
| test = test [0 .. 1]; |
| |
| foo1() [foo2() .. foo3()] = 'b'; |
| assert(x1 == 1); |
| assert(x2 == 1); |
| assert(x3 == 1); |
| |
| //test [0 .. 2] = 'b'; // this line should assert |
| assert(test.ptr[0 .. 2] == "ba"); |
| } |
| |
| /*******************************************/ |
| |
| void test42() |
| { |
| struct X { int x; } |
| |
| X x; |
| assert(x.x == 0); |
| x = x.init; |
| assert(x.x == 0); |
| } |
| |
| /*******************************************/ |
| |
| void vararg43(string fmt, ...) |
| { |
| assert(_arguments[0] is typeid(const string)); |
| assert(va_arg!(const string)(_argptr) == "hello"); |
| } |
| |
| struct A43 |
| { |
| static const MY_CONST_STRING = "hello"; |
| |
| void foo() |
| { |
| // This will either print garbage or throw a UTF exception. |
| // But if never_called() is commented out, then it will work. |
| vararg43("%s", MY_CONST_STRING); |
| } |
| } |
| |
| void never_called43() |
| { |
| // This can be anything; there just needs to be a reference to |
| // A43.MY_CONST_STRING somewhere. |
| vararg43("%s", A43.MY_CONST_STRING); |
| } |
| |
| void test43() |
| { |
| A43 a; |
| a.foo(); |
| } |
| |
| /*******************************************/ |
| |
| void vararg44(string fmt, ...) |
| { |
| assert(_arguments[0] is typeid(const string)); |
| assert(va_arg!(const string)(_argptr) == "hello"); |
| } |
| |
| class A44 |
| { |
| static const MY_CONST_STRING = "hello"; |
| |
| this() |
| { |
| // This will either print garbage or throw a UTF exception. |
| // But if never_called() is commented out, then it will work. |
| vararg44("%s", MY_CONST_STRING); |
| } |
| } |
| |
| void never_called44() |
| { |
| // This can be anything; there just needs to be a reference to |
| // A44.MY_CONST_STRING somewhere. |
| vararg44("%s", A44.MY_CONST_STRING); |
| } |
| |
| void test44() |
| { |
| A44 a = new A44(); |
| } |
| |
| /*******************************************/ |
| |
| class C45 |
| { |
| void func(lazy size_t x) |
| { |
| (new C45).func(super.toHash()); |
| } |
| } |
| |
| void test45() |
| { |
| } |
| |
| /*******************************************/ |
| |
| template T46(double v) |
| { |
| double T46 = v; |
| } |
| |
| void test46() |
| { |
| double g = T46!(double.nan) + T46!(-double.nan); |
| } |
| |
| /*******************************************/ |
| |
| void test47() |
| { |
| uint* where = (new uint[](5)).ptr; |
| |
| where[0 .. 5] = 1; |
| assert(where[2] == 1); |
| where[0 .. 0] = 0; |
| assert(where[0] == 1); |
| assert(where[2] == 1); |
| } |
| |
| /*******************************************/ |
| |
| void test48() |
| { |
| Object o = new Object(); |
| printf("%.*s\n", cast(int)typeof(o).classinfo.name.length, typeof(o).classinfo.name.ptr); |
| printf("%.*s\n", cast(int)(typeof(o)).classinfo.name.length, (typeof(o)).classinfo.name.ptr); |
| printf("%.*s\n", cast(int)(Object).classinfo.name.length, (Object).classinfo.name.ptr); |
| } |
| |
| /*******************************************/ |
| |
| void test49() |
| { |
| foo49(); |
| } |
| |
| void foo49() |
| { |
| char[] bar; |
| assert(true, bar ~ "foo"); |
| } |
| |
| /*******************************************/ |
| |
| void test50() |
| { |
| foo50("foo"); |
| } |
| |
| void foo50(string bar) |
| { |
| assert(true, bar ~ "foo"); |
| } |
| |
| /*******************************************/ |
| |
| struct Foo51 |
| { |
| static Foo51 opCall() |
| { |
| return Foo51.init; |
| } |
| private char[] _a; |
| private bool _b; |
| } |
| |
| void test51() |
| { |
| } |
| |
| /*******************************************/ |
| |
| template A52(T ...) { } |
| mixin A52!(["abc2", "def"]); |
| |
| void test52() |
| { |
| } |
| |
| /*******************************************/ |
| |
| enum: int |
| { |
| AF_INET53 = 2, |
| PF_INET53 = AF_INET53, |
| } |
| |
| enum: int |
| { |
| SOCK_STREAM53 = 1, |
| } |
| |
| struct sockaddr_in53 |
| { |
| int sin_family = AF_INET53; |
| } |
| |
| enum AddressFamily53: int |
| { |
| INET = AF_INET53, |
| } |
| |
| enum SocketType53: int |
| { |
| STREAM = SOCK_STREAM53, |
| } |
| |
| |
| class Socket53 |
| { |
| this(AddressFamily53 af, SocketType53 type) |
| { |
| } |
| } |
| |
| void test53() |
| { |
| new Socket53(AddressFamily53.INET, SocketType53.STREAM); |
| } |
| |
| /*******************************************/ |
| |
| void test54() |
| { |
| int[2][] a; |
| a ~= [1,2]; |
| assert(a.length == 1); |
| assert(a[0][0] == 1); |
| assert(a[0][1] == 2); |
| } |
| |
| /*******************************************/ |
| |
| void test55() |
| { |
| float[][] a = new float [][](1, 1); |
| |
| if((a.length != 1) || (a[0].length != 1)){ |
| assert(0); |
| } |
| if (a[0][0] == a[0][0]){ |
| assert(0); |
| } |
| } |
| |
| /*******************************************/ |
| |
| void test58() |
| { |
| struct S |
| { |
| int i; |
| int[4] bar = 4; |
| float[4] abc; |
| } |
| |
| static S a = {i: 1}; |
| static S b; |
| |
| assert(a.i == 1); |
| assert(a.bar[0] == 4); |
| assert(a.bar[1] == 4); |
| assert(a.bar[2] == 4); |
| assert(a.bar[3] == 4); |
| assert(b.i == 0); |
| assert(b.bar[0] == 4); |
| assert(b.bar[1] == 4); |
| assert(b.bar[2] == 4); |
| assert(b.bar[3] == 4); |
| } |
| |
| |
| /*******************************************/ |
| |
| void vararg59(...) |
| { |
| if (_arguments[0] is typeid(size_t)) |
| assert(va_arg!size_t(_argptr) == 454); |
| else |
| assert(va_arg!string(_argptr) == "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234"); |
| } |
| |
| void bug59(string s)() |
| { |
| vararg59(s); |
| vararg59(s.length); |
| } |
| |
| void test59() |
| { |
| bug59!("1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234")(); |
| } |
| |
| /*******************************************/ |
| |
| class Foo60(T) |
| { |
| this() { unknown_identifier; } |
| } |
| |
| void test60() |
| { |
| bool foobar = is( Foo60!(int) ); |
| assert(!foobar); |
| } |
| |
| |
| /*******************************************/ |
| |
| void repeat( int n, void delegate() dg ) |
| { |
| printf("n = %d\n", n); |
| if( n&1 ) dg(); |
| if( n/2 ) repeat( n/2, {dg();dg();} ); |
| } |
| |
| void test61() |
| { |
| repeat( 10, {printf("Hello\n");} ); |
| } |
| |
| /*******************************************/ |
| |
| void test62() |
| { |
| Vector62 a; |
| a.set(1,2,24); |
| a = a * 2; |
| assert(a.x == 2); |
| assert(a.y == 4); |
| assert(a.z == 48); |
| } |
| |
| |
| struct Vector62 |
| { |
| float x,y,z; |
| |
| // constructor |
| void set(float _x, float _y, float _z) |
| { |
| x = _x; |
| y = _y; |
| z = _z; |
| } |
| |
| Vector62 opBinary(string op : "*")(float s) |
| { |
| Vector62 ret; |
| ret.x = x*s; |
| ret.y = y*s; |
| ret.z = z*s; |
| return ret; |
| } |
| } |
| |
| /*******************************************/ |
| |
| struct Data63 |
| { |
| int x, y; |
| |
| /// To make size > 8 so NRVO is used. |
| /// Program runs correctly with this line commented out: |
| byte filler; |
| } |
| |
| Data63 frob(ref Data63 d) |
| { |
| Data63 ret; |
| ret.y = d.x - d.y; |
| ret.x = d.x + d.y; |
| return ret; |
| } |
| |
| void test63() |
| { |
| Data63 d; d.x = 1; d.y = 2; |
| d = frob(d); |
| assert(d.x == 3 && d.y == -1); |
| } |
| |
| /*******************************************/ |
| |
| class Foo64 |
| { |
| this() { } |
| ~this() { } |
| } |
| |
| template Mix64() |
| { |
| void init() { |
| ptr = new Foo64; |
| } |
| Foo64 ptr; |
| } |
| |
| class Container64 |
| { |
| this() { init(); } |
| mixin Mix64; |
| } |
| |
| |
| void test64() |
| { |
| auto x = new Container64; |
| |
| assert(!(x.classinfo.flags & 2)); |
| } |
| |
| /*******************************************/ |
| |
| struct Vector65(T, uint dim) |
| { |
| T[dim] data; |
| } |
| |
| T dot65(T, uint dim)(Vector65!(T,dim) a, Vector65!(T,dim) b) |
| { |
| T tmp; |
| for ( int i = 0; i < dim; ++i ) |
| tmp += a.data[i] * b.data[i]; |
| return tmp; |
| } |
| |
| void test65() |
| { |
| Vector65!(double,3u) a,b; |
| auto t = dot65(a,b); |
| } |
| |
| |
| /*******************************************/ |
| // https://issues.dlang.org/show_bug.cgi?id=18576 |
| |
| void delegate() callback; |
| |
| struct S66 { |
| int x; |
| @disable this(this); |
| |
| this(int x) { |
| this.x = x; |
| callback = &inc; |
| } |
| void inc() { |
| x++; |
| } |
| } |
| |
| auto f66() |
| { |
| return g66(); // RVO should be done |
| } |
| |
| auto g66() |
| { |
| return h66(); // RVO should be done |
| } |
| |
| auto h66() |
| { |
| return S66(100); |
| } |
| |
| void test18576() |
| { |
| auto s = f66(); |
| printf("%p vs %p\n", &s, callback.ptr); |
| callback(); |
| printf("s.x = %d\n", s.x); |
| assert(s.x == 101); |
| assert(&s == callback.ptr); |
| } |
| |
| /*******************************************/ |
| |
| void main() |
| { |
| printf("Start\n"); |
| |
| test1(); |
| test2(); |
| test3(); |
| test4(); |
| test6(); |
| test7(); |
| test8(); |
| test10(); |
| test11(); |
| test12(); |
| test13(); |
| test14(); |
| test15(); |
| test17(); |
| test18(); |
| test19(); |
| test20(); |
| test21(); |
| test22(); |
| test23(); |
| test24(); |
| test26(); |
| test27(); |
| test28(); |
| test29(); |
| test30(); |
| test31(); |
| test32(); |
| test33(); |
| test34(); |
| test35(); |
| test36(); |
| test37(); |
| test38(); |
| test39(); |
| test40(); |
| test41(); |
| test42(); |
| test43(); |
| test44(); |
| test45(); |
| test46(); |
| test47(); |
| test48(); |
| test49(); |
| test50(); |
| test51(); |
| test52(); |
| test53(); |
| test54(); |
| test55(); |
| test58(); |
| test59(); |
| test60(); |
| test61(); |
| test62(); |
| test63(); |
| test64(); |
| test65(); |
| test18576(); |
| |
| printf("Success\n"); |
| } |
