130 lines
3.1 KiB
Haxe
130 lines
3.1 KiB
Haxe
package gc;
|
|
import haxe.io.Bytes;
|
|
import cpp.vm.Gc;
|
|
|
|
class CustomObject {
|
|
public function new():Void {}
|
|
}
|
|
|
|
class TestGC extends haxe.unit.TestCase {
|
|
function createDummy(val:Dynamic):Dynamic {
|
|
return { dummy: val };
|
|
}
|
|
|
|
function gc():Dynamic {
|
|
Gc.run(true);
|
|
return Gc.getNextZombie();
|
|
}
|
|
|
|
/**
|
|
For avoiding the simple call being optimized in some way.
|
|
*/
|
|
function create(f:Void->Void):Void {
|
|
f();
|
|
clearStack(10);
|
|
}
|
|
|
|
function clearStack(count:Int, ?nothing:Dynamic):Dynamic
|
|
{
|
|
if (count==0)
|
|
return 0;
|
|
return clearStack(count-1);
|
|
}
|
|
|
|
|
|
function createAbc():Void {
|
|
var object = { test: "abc" };
|
|
Gc.doNotKill(object);
|
|
}
|
|
public function testObject():Void {
|
|
create(createAbc);
|
|
var zombie = gc();
|
|
assertTrue(zombie != null);
|
|
assertEquals("abc", zombie.test);
|
|
assertTrue(gc() == null);
|
|
}
|
|
|
|
// Null<int> for numbers < 256 are special cases
|
|
// Infact, there are no guarantees that Null<Int> will be actual objects in the future
|
|
/*
|
|
function create1234():Void {
|
|
var object:Null<Int> = 1234;
|
|
Gc.doNotKill(object);
|
|
};
|
|
public function testBoxedInt():Void {
|
|
create(create1234);
|
|
var zombie:Dynamic = gc();
|
|
assertTrue(zombie != null);
|
|
assertEquals(1234, zombie);
|
|
assertTrue(gc() == null);
|
|
}
|
|
*/
|
|
|
|
function createFunction():Void {
|
|
var object = function() return "abc";
|
|
Gc.doNotKill(object);
|
|
};
|
|
public function testFunc():Void {
|
|
create(createFunction);
|
|
var zombie = gc();
|
|
assertTrue(zombie != null);
|
|
assertEquals("abc", zombie());
|
|
assertTrue(gc() == null);
|
|
}
|
|
|
|
function createCustom():Void {
|
|
var object = new CustomObject();
|
|
Gc.doNotKill(object);
|
|
};
|
|
public function testCustomObject():Void {
|
|
create(createCustom);
|
|
var zombie = gc();
|
|
assertTrue(zombie != null);
|
|
assertTrue(Std.isOfType(zombie, CustomObject));
|
|
assertTrue(gc() == null);
|
|
}
|
|
|
|
function createBytes():Void {
|
|
var object = Bytes.alloc(1);
|
|
Gc.doNotKill(object);
|
|
};
|
|
public function testBytes():Void {
|
|
create(createBytes);
|
|
var zombie = gc();
|
|
assertTrue(zombie != null);
|
|
assertTrue(Std.isOfType(zombie, Bytes));
|
|
assertTrue(gc() == null);
|
|
}
|
|
|
|
public function testBigStack():Void {
|
|
assertTrue( TestBigStack.test() );
|
|
}
|
|
|
|
#if !cppia
|
|
public function testConstStrings():Void {
|
|
// Const strings void Gc overhead
|
|
var strings = new Array<String>();
|
|
strings.push( haxe.Resource.getString("TestMain.hx") );
|
|
strings.push( "some string" );
|
|
var chars = "abc123";
|
|
// Optimization for single chars...
|
|
for(c in 0...chars.length)
|
|
strings.push( chars.substr(c,1) );
|
|
for(string in strings)
|
|
assertTrue( untyped __global__.__hxcpp_is_const_string(string) );
|
|
Gc.run(true);
|
|
for(string in strings)
|
|
assertTrue( untyped __global__.__hxcpp_is_const_string(string) );
|
|
|
|
var strings = new Array<String>();
|
|
strings.push( haxe.Resource.getString("TestMain.hx").substr(10) );
|
|
strings.push( "some string" + chars );
|
|
for(c in 0...chars.length-1)
|
|
strings.push( chars.substr(c,2) );
|
|
|
|
for(string in strings)
|
|
assertFalse( untyped __global__.__hxcpp_is_const_string(string) );
|
|
}
|
|
#end
|
|
}
|