Retro68/gcc/libphobos/testsuite/libphobos.shared/lib.d
Wolfgang Thaller 6fbf4226da gcc-9.1
2019-06-20 20:10:10 +02:00

134 lines
2.6 KiB
D

module lib;
// test EH
void throwException()
{
throw new Exception(null);
}
Exception collectException(void delegate() dg)
{
try
dg();
catch (Exception e)
return e;
return null;
}
// test GC
__gshared Object root;
void alloc() { root = new Object(); }
void access() { assert(root.toString() !is null); } // vtbl call will fail if finalized
void free() { root = null; }
Object tls_root;
void tls_alloc() { tls_root = new Object(); }
void tls_access() { assert(tls_root.toString() !is null); } // vtbl call will fail if finalized
void tls_free() { tls_root = null; }
void stack(alias func)()
{
// allocate some extra stack space to not keep references to GC memory on the scanned stack
ubyte[1024] buf = void;
func();
}
void testGC()
{
import core.memory;
stack!alloc();
stack!tls_alloc();
stack!access();
stack!tls_access();
GC.collect();
stack!tls_access();
stack!access();
stack!tls_free();
stack!free();
}
// test Init
import core.atomic : atomicOp;
shared uint shared_static_ctor, shared_static_dtor, static_ctor, static_dtor;
shared static this() { if (atomicOp!"+="(shared_static_ctor, 1) != 1) assert(0); }
shared static ~this() { if (atomicOp!"+="(shared_static_dtor, 1) != 1) assert(0); }
static this() { atomicOp!"+="(static_ctor, 1); }
static ~this() { atomicOp!"+="(static_dtor, 1); }
extern(C) int runTests()
{
try
runTestsImpl();
catch (Throwable)
return 0;
return 1;
}
void runTestsImpl()
{
import core.thread;
bool passed;
try
throwException();
catch (Exception e)
passed = true;
assert(passed);
assert(collectException({throwException();}) !is null);
testGC();
assert(shared_static_ctor == 1);
assert(static_ctor == 1);
static void run()
{
assert(static_ctor == 2);
assert(shared_static_ctor == 1);
testGC();
}
auto thr = new Thread(&run);
thr.start();
thr.join();
assert(static_dtor == 1);
passed = false;
foreach (m; ModuleInfo)
if (m.name == "lib") passed = true;
assert(passed);
}
// Provide a way to initialize D from C programs that are D agnostic.
import core.runtime : rt_init, rt_term;
extern(C) int lib_init()
{
return rt_init();
}
extern(C) int lib_term()
{
return rt_term();
}
shared size_t* _finalizeCounter;
class MyFinalizer
{
~this()
{
import core.atomic;
atomicOp!"+="(*_finalizeCounter, 1);
}
}
class MyFinalizerBig : MyFinalizer
{
ubyte[4096] _big = void;
}
extern(C) void setFinalizeCounter(shared(size_t)* p)
{
_finalizeCounter = p;
}