919 lines
12 KiB
D
919 lines
12 KiB
D
// RUNNABLE_PHOBOS_TEST
|
|
import std.stdio;
|
|
|
|
/*******************************************************/
|
|
|
|
class Outer
|
|
{
|
|
int o;
|
|
static int os = 3;
|
|
|
|
static class StaticInner
|
|
{
|
|
int si;
|
|
|
|
int foo()
|
|
{
|
|
return si + os;
|
|
}
|
|
}
|
|
|
|
class Inner
|
|
{
|
|
int i;
|
|
|
|
int foo(int m)
|
|
{
|
|
return i * o + m;
|
|
}
|
|
|
|
this(int k)
|
|
{
|
|
i = k + 7;
|
|
os = 6;
|
|
}
|
|
}
|
|
|
|
Inner bar()
|
|
{
|
|
return new Inner(17);
|
|
}
|
|
}
|
|
|
|
void test1()
|
|
{
|
|
Outer p = new Outer();
|
|
|
|
assert(p.o == 0);
|
|
assert(p.os == 3);
|
|
p.o = 9;
|
|
|
|
Outer.StaticInner s = new Outer.StaticInner;
|
|
s.si = 10;
|
|
assert(s.foo() == 13);
|
|
|
|
Outer.Inner q = p.bar();
|
|
assert(q.i == 24);
|
|
assert(q.foo(8) == 24*9+8);
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
class C1
|
|
{
|
|
int c1;
|
|
|
|
this()
|
|
{
|
|
c1 = 2;
|
|
}
|
|
|
|
class C2
|
|
{
|
|
class C3
|
|
{
|
|
int c3;
|
|
|
|
this(int n)
|
|
{
|
|
c3 = n + c1 + c2;
|
|
}
|
|
}
|
|
|
|
int c2;
|
|
|
|
C3 foo()
|
|
{
|
|
return new C3(8);
|
|
}
|
|
|
|
this(int k)
|
|
{
|
|
c2 = k + 7;
|
|
}
|
|
}
|
|
|
|
C2 bar()
|
|
{
|
|
return new C2(17);
|
|
}
|
|
}
|
|
|
|
void test2()
|
|
{
|
|
C1 p = new C1();
|
|
assert(p.c1 == 2);
|
|
|
|
C1.C2 q = p.bar();
|
|
assert(q.c2 == 24);
|
|
|
|
C1.C2.C3 r = q.foo();
|
|
assert(r.c3 == 2+24+8);
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
class C3
|
|
{
|
|
int c1;
|
|
|
|
this()
|
|
{
|
|
c1 = 2;
|
|
}
|
|
|
|
class B { }
|
|
|
|
class C2 : B
|
|
{
|
|
int c2;
|
|
|
|
this(int k)
|
|
{
|
|
c2 = c1 + k + 7;
|
|
}
|
|
}
|
|
|
|
C2 bar()
|
|
{
|
|
return new C2(17);
|
|
}
|
|
}
|
|
|
|
void test3()
|
|
{
|
|
C3 q = new C3();
|
|
assert(q.c1 == 2);
|
|
C3.C2 p = q.bar();
|
|
assert(p.c2 == 26);
|
|
}
|
|
|
|
|
|
/*******************************************************/
|
|
|
|
void test4()
|
|
{
|
|
int m = 3;
|
|
|
|
class C
|
|
{
|
|
void foo()
|
|
{
|
|
assert(m == 3);
|
|
}
|
|
}
|
|
|
|
void bar()
|
|
{
|
|
assert(m == 3);
|
|
}
|
|
|
|
bar();
|
|
C c = new C;
|
|
c.foo();
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
void test5()
|
|
{
|
|
int m = 3;
|
|
|
|
void bar()
|
|
{
|
|
assert(m == 3);
|
|
}
|
|
|
|
class C
|
|
{
|
|
void foo()
|
|
{
|
|
assert(m == 3);
|
|
bar();
|
|
}
|
|
}
|
|
|
|
bar();
|
|
C c = new C;
|
|
c.foo();
|
|
}
|
|
|
|
|
|
/*******************************************************/
|
|
|
|
void test6()
|
|
{
|
|
int m = 3;
|
|
|
|
void bar()
|
|
{
|
|
assert(m == 3);
|
|
}
|
|
|
|
void abc()
|
|
{
|
|
class C
|
|
{
|
|
void foo()
|
|
{
|
|
assert(m == 3);
|
|
bar();
|
|
}
|
|
}
|
|
|
|
bar();
|
|
C c = new C;
|
|
c.foo();
|
|
}
|
|
|
|
abc();
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
void test7()
|
|
{
|
|
int m = 3;
|
|
|
|
void bar()
|
|
{
|
|
assert(m == 3);
|
|
}
|
|
|
|
void ghi()
|
|
{
|
|
void abc()
|
|
{
|
|
class C
|
|
{
|
|
void foo()
|
|
{
|
|
assert(m == 3);
|
|
bar();
|
|
}
|
|
}
|
|
|
|
bar();
|
|
C c = new C;
|
|
c.foo();
|
|
}
|
|
|
|
abc();
|
|
}
|
|
|
|
ghi();
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
void test8()
|
|
{
|
|
int m = 3;
|
|
|
|
void bar()
|
|
{
|
|
assert(m == 3);
|
|
}
|
|
|
|
void ghi()
|
|
{
|
|
void abc()
|
|
{
|
|
class C
|
|
{
|
|
void foo()
|
|
{
|
|
void fooey()
|
|
{
|
|
assert(m == 3);
|
|
bar();
|
|
}
|
|
|
|
fooey();
|
|
}
|
|
}
|
|
|
|
bar();
|
|
C c = new C;
|
|
c.foo();
|
|
}
|
|
|
|
abc();
|
|
}
|
|
|
|
ghi();
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
class C9
|
|
{
|
|
int m;
|
|
|
|
void ccc()
|
|
{
|
|
assert(m == 3);
|
|
}
|
|
|
|
this()
|
|
{
|
|
m = 3;
|
|
}
|
|
|
|
class D
|
|
{
|
|
int n;
|
|
|
|
this() { n = 4; }
|
|
|
|
void abc()
|
|
{
|
|
assert(m == 3);
|
|
ccc();
|
|
}
|
|
}
|
|
|
|
D def()
|
|
{
|
|
return new D;
|
|
}
|
|
}
|
|
|
|
|
|
void test9()
|
|
{
|
|
C9 c = new C9;
|
|
assert(c.m == 3);
|
|
c.ccc();
|
|
|
|
C9.D d = c.def();
|
|
assert(d.n == 4);
|
|
d.abc();
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
void test10()
|
|
{
|
|
int m = 3;
|
|
|
|
class C
|
|
{
|
|
void foo()
|
|
{
|
|
assert(m == 3);
|
|
}
|
|
}
|
|
|
|
void abc()
|
|
{
|
|
C c = new C;
|
|
c.foo();
|
|
}
|
|
|
|
abc();
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
void test11()
|
|
{
|
|
int m = 3;
|
|
|
|
class C
|
|
{
|
|
void foo()
|
|
{
|
|
assert(m == 3);
|
|
}
|
|
}
|
|
|
|
void abc()
|
|
{
|
|
void def()
|
|
{
|
|
C c = new C;
|
|
c.foo();
|
|
}
|
|
|
|
def();
|
|
}
|
|
|
|
abc();
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
void test12()
|
|
{
|
|
int m = 3;
|
|
|
|
class C
|
|
{
|
|
void foo()
|
|
{
|
|
assert(m == 3);
|
|
}
|
|
|
|
void abc()
|
|
{
|
|
assert(m == 3);
|
|
C c = new C;
|
|
c.foo();
|
|
}
|
|
}
|
|
|
|
C d = new C;
|
|
d.abc();
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
void test13()
|
|
{
|
|
int m = 3;
|
|
|
|
class C
|
|
{
|
|
void foo()
|
|
{
|
|
assert(m == 3);
|
|
}
|
|
|
|
void abc()
|
|
{
|
|
void def()
|
|
{
|
|
assert(m == 3);
|
|
C c = new C;
|
|
c.foo();
|
|
}
|
|
|
|
def();
|
|
}
|
|
}
|
|
|
|
C d = new C;
|
|
d.abc();
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
class C14
|
|
{
|
|
void foo()
|
|
{
|
|
assert(0);
|
|
}
|
|
}
|
|
|
|
void test14()
|
|
{
|
|
int m = 3;
|
|
|
|
C14 c = new class C14
|
|
{
|
|
override void foo()
|
|
{
|
|
printf("in inner class\n");
|
|
assert(m == 3);
|
|
}
|
|
};
|
|
|
|
c.foo();
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
class C15
|
|
{
|
|
void foo()
|
|
{
|
|
assert(0);
|
|
}
|
|
}
|
|
|
|
void test15()
|
|
{
|
|
int m = 3;
|
|
|
|
C15 c = new class(1,2) C15
|
|
{
|
|
this(int i, int j)
|
|
{
|
|
printf("in inner class ctor\n");
|
|
assert(i == 1);
|
|
assert(j == 2);
|
|
}
|
|
|
|
override void foo()
|
|
{
|
|
printf("in inner class\n");
|
|
assert(m == 3);
|
|
}
|
|
};
|
|
|
|
c.foo();
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
class C16
|
|
{
|
|
int w = 3;
|
|
|
|
void iterator()
|
|
{
|
|
class Foo
|
|
{
|
|
void current()
|
|
{
|
|
assert(w == 3);
|
|
}
|
|
}
|
|
|
|
Foo f = new Foo();
|
|
f.current();
|
|
}
|
|
}
|
|
|
|
void test16()
|
|
{
|
|
C16 s = new C16();
|
|
|
|
s.iterator();
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
class Owner
|
|
{
|
|
|
|
this()
|
|
{
|
|
n = new Nested(this);
|
|
}
|
|
|
|
class Nested
|
|
{
|
|
this(Owner owner)
|
|
{
|
|
m = owner;
|
|
}
|
|
|
|
Owner foo()
|
|
{
|
|
return m;
|
|
}
|
|
|
|
Owner m;
|
|
}
|
|
|
|
Nested n;
|
|
}
|
|
|
|
class OwnerDerived : Owner
|
|
{
|
|
}
|
|
|
|
void test17()
|
|
{
|
|
OwnerDerived o = new OwnerDerived();
|
|
|
|
assert(o.n.foo() is o);
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
class Foo18
|
|
{
|
|
class Bar
|
|
{
|
|
void doSayHello()
|
|
{
|
|
writefln("Betty");
|
|
sayHello();
|
|
}
|
|
}
|
|
Bar bar;
|
|
|
|
void sayHello()
|
|
{
|
|
writefln("Hello");
|
|
}
|
|
}
|
|
|
|
class Foo182 : Foo18
|
|
{
|
|
this()
|
|
{
|
|
bar = new Bar();
|
|
}
|
|
}
|
|
|
|
void test18()
|
|
{
|
|
Foo182 foo = new Foo182();
|
|
writefln("This should print Hello:");
|
|
|
|
foo.bar.doSayHello();
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
class Foo19
|
|
{
|
|
class Bar
|
|
{
|
|
void doSayHello()
|
|
{
|
|
writefln("Betty");
|
|
sayHello();
|
|
}
|
|
}
|
|
Bar bar;
|
|
|
|
void sayHello()
|
|
{
|
|
writefln("Hello");
|
|
}
|
|
|
|
this()
|
|
{
|
|
bar = new Bar();
|
|
}
|
|
}
|
|
|
|
class Foo192 : Foo19
|
|
{
|
|
}
|
|
|
|
void test19()
|
|
{
|
|
Foo192 foo = new Foo192();
|
|
writefln("This should print Hello:");
|
|
|
|
foo.bar.doSayHello();
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
class Outer20
|
|
{
|
|
int a;
|
|
|
|
class Inner
|
|
{
|
|
int foo()
|
|
{
|
|
return a;
|
|
}
|
|
}
|
|
}
|
|
|
|
void test20()
|
|
{
|
|
Outer20 o = new Outer20;
|
|
o.a = 3;
|
|
Outer20.Inner oi = o.new Inner;
|
|
assert(oi.foo() == 3);
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
class Foo21{}
|
|
|
|
static if (is(typeof(new class Foo21{}))) {}
|
|
|
|
void test21()
|
|
{
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
class Outer22
|
|
{
|
|
class Inner
|
|
{
|
|
Outer22 foo()
|
|
{
|
|
return this.outer;
|
|
}
|
|
}
|
|
|
|
void bar()
|
|
{
|
|
Inner i = new Inner;
|
|
assert(this == i.foo());
|
|
}
|
|
}
|
|
|
|
void test22()
|
|
{
|
|
Outer22 o = new Outer22;
|
|
o.bar();
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
class Adapter23
|
|
{
|
|
void func() { }
|
|
}
|
|
|
|
class Foo23
|
|
{
|
|
class AnonAdapter : Adapter23
|
|
{
|
|
}
|
|
|
|
void bar()
|
|
{
|
|
Adapter23 a = cast( Adapter23 )( new AnonAdapter() );
|
|
}
|
|
}
|
|
|
|
void test23()
|
|
{
|
|
Foo23 f = new Foo23();
|
|
f.bar();
|
|
Adapter23 a = cast( Adapter23 )( f.new AnonAdapter() );
|
|
auto aa = f.new AnonAdapter();
|
|
Adapter23 ab = cast( Adapter23 )(aa);
|
|
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
class I24
|
|
{
|
|
public abstract void callI();
|
|
}
|
|
|
|
C24 c24;
|
|
|
|
class C24
|
|
{
|
|
private int index;
|
|
void foo()
|
|
{
|
|
printf( "ok, this = %p\n", this);
|
|
assert(this == c24);
|
|
}
|
|
I24 bar()
|
|
{
|
|
auto i = new class() I24
|
|
{
|
|
override public void callI()
|
|
{
|
|
foo();
|
|
}
|
|
};
|
|
printf("bar.this = %p\n", this);
|
|
printf(" i.this = %p\n", (cast(void**)i)[2]);
|
|
assert(*cast(void**)&c24 == (cast(void**)i)[2]);
|
|
return i;
|
|
}
|
|
}
|
|
|
|
void test24()
|
|
{
|
|
c24 = new C24;
|
|
printf("c = %p\n", c24);
|
|
auto i = c24.bar();
|
|
i.callI();
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
struct S7426
|
|
{
|
|
static struct Inner
|
|
{
|
|
int x;
|
|
alias typeof(Inner.tupleof) T;
|
|
}
|
|
}
|
|
|
|
/*******************************************************/
|
|
// 14046
|
|
|
|
class A14046
|
|
{
|
|
class NestedA { }
|
|
}
|
|
|
|
class B14046 : A14046
|
|
{
|
|
int field;
|
|
|
|
class NestedB : NestedA
|
|
{
|
|
void foo()
|
|
{
|
|
this.outer.field = 1; // ok <- disallowed
|
|
|
|
//(cast(B14046)this.outer).field = 1; // workaround
|
|
}
|
|
}
|
|
}
|
|
|
|
void test14046()
|
|
{
|
|
auto b = new B14046();
|
|
auto nb = b.new NestedB();
|
|
assert(b.field == 0);
|
|
nb.foo();
|
|
assert(b.field == 1);
|
|
}
|
|
|
|
/*******************************************************/
|
|
// 15839
|
|
|
|
class AnimatedProgress15839(bool makeClosure)
|
|
{
|
|
static AnimatedProgress15839 saveThis;
|
|
|
|
interface Runnable {}
|
|
|
|
static class GC
|
|
{
|
|
this(AnimatedProgress15839 ap)
|
|
{
|
|
assert(ap is saveThis);
|
|
}
|
|
}
|
|
|
|
void start()
|
|
{
|
|
assert(this is saveThis);
|
|
|
|
static if (makeClosure) int a;
|
|
|
|
auto r = new class Runnable
|
|
{
|
|
void run()
|
|
{
|
|
static assert(is(typeof(this.outer) == AnimatedProgress15839));
|
|
assert(this.outer is saveThis);
|
|
|
|
GC gc = new GC(this.outer);
|
|
|
|
static if (makeClosure) int b = a;
|
|
}
|
|
};
|
|
r.run();
|
|
}
|
|
}
|
|
|
|
void test15839()
|
|
{
|
|
auto ap1 = new AnimatedProgress15839!false();
|
|
ap1.saveThis = ap1;
|
|
ap1.start();
|
|
|
|
auto ap2 = new AnimatedProgress15839!true();
|
|
ap2.saveThis = ap2;
|
|
ap2.start();
|
|
}
|
|
|
|
/*******************************************************/
|
|
|
|
int main()
|
|
{
|
|
|
|
test1();
|
|
test2();
|
|
test3();
|
|
test4();
|
|
test5();
|
|
test6();
|
|
test7();
|
|
test8();
|
|
test9();
|
|
test10();
|
|
|
|
test11();
|
|
test12();
|
|
test13();
|
|
|
|
test14();
|
|
test15();
|
|
test16();
|
|
test17();
|
|
test18();
|
|
test19();
|
|
test20();
|
|
|
|
test21();
|
|
test22();
|
|
test23();
|
|
test24();
|
|
|
|
test14046();
|
|
test15839();
|
|
|
|
printf("Success\n");
|
|
return 0;
|
|
}
|