HomePhorge
Diffusion Ant (master) Code

ant/tests/test_gc_in_coro.js
8755416ca476master

Last Change
Raw File

test_gc_in_coro.js
View Options

// Test: GC compaction runs correctly inside coroutines.
console.log('=== GC-in-coroutine test ===');
let passed = 0;
let failed = 0;
function assert(cond, msg) {
if (cond) { passed++; }
else { failed++; console.log('FAIL: ' + msg); }
}
function trace(msg) { console.log('[trace] ' + msg); }
// --- helpers ---
function allocBulk(n) {
const arr = [];
for (let i = 0; i < n; i++) {
arr.push({ idx: i, data: 'item_' + i + '_' + 'x'.repeat(64) });
}
return arr;
}
function verifyBulk(arr, label) {
for (let i = 0; i < arr.length; i++) {
assert(arr[i].idx === i, label + ': idx mismatch at ' + i);
assert(arr[i].data.startsWith('item_' + i + '_'), label + ': data mismatch at ' + i);
}
}
// --- Test 1: pre-existing objects survive GC inside coroutine ---
trace('allocating preAlloc');
const preAlloc = allocBulk(200);
trace('preAlloc done, length=' + preAlloc.length);
async function test1() {
trace('test1: start');
verifyBulk(preAlloc, 'test1-preAlloc');
trace('test1: preAlloc verified');
const innerAlloc = allocBulk(200);
verifyBulk(innerAlloc, 'test1-innerAlloc');
verifyBulk(preAlloc, 'test1-preAlloc-after');
trace('test1: done');
}
// --- Test 2: cross-coroutine references ---
const shared = { value: 'original', children: [] };
async function test2() {
trace('test2: start');
for (let i = 0; i < 100; i++) {
shared.children.push({ ref: i, str: 'child_' + i });
}
assert(shared.value === 'original', 'test2: shared.value');
assert(shared.children.length === 100, 'test2: children.length');
for (let i = 0; i < 100; i++) {
assert(shared.children[i].ref === i, 'test2: child ref ' + i);
}
trace('test2: done');
}
// --- Test 3: nested async (coroutine-in-coroutine) ---
async function inner(depth) {
const obj = { depth, payload: 'nested_' + depth + '_' + 'y'.repeat(32) };
if (depth > 0) {
await inner(depth - 1);
}
assert(obj.depth === depth, 'test3: depth mismatch at ' + depth);
assert(obj.payload.startsWith('nested_' + depth), 'test3: payload at ' + depth);
return obj;
}
async function test3() {
trace('test3: start');
await inner(8);
trace('test3: done');
}
// --- Test 4: allocation pressure inside coroutine (natural GC trigger) ---
async function test4() {
trace('test4: start');
const anchors = [];
for (let wave = 0; wave < 20; wave++) {
const batch = [];
for (let i = 0; i < 500; i++) {
batch.push({ wave, i, s: 'w' + wave + '_i' + i + '_' + 'z'.repeat(128) });
}
anchors.push(batch);
}
for (let wave = 0; wave < anchors.length; wave++) {
const batch = anchors[wave];
assert(batch.length === 500, 'test4: wave ' + wave + ' length');
assert(batch[0].wave === wave, 'test4: wave ' + wave + ' tag');
assert(batch[499].i === 499, 'test4: wave ' + wave + ' last idx');
}
trace('test4: done');
}
// --- Test 5: await + GC interleaving ---
function delay(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
async function test5() {
trace('test5: start');
const before = allocBulk(100);
await delay(1);
trace('test5: after first await');
verifyBulk(before, 'test5-before-await');
const after = allocBulk(100);
await delay(1);
trace('test5: after second await');
verifyBulk(before, 'test5-before-final');
verifyBulk(after, 'test5-after-final');
trace('test5: done');
}
// --- run all ---
trace('calling main()');
async function main() {
trace('main: start');
await test1();
trace('main: test1 complete');
await test2();
trace('main: test2 complete');
await test3();
trace('main: test3 complete');
await test4();
trace('main: test4 complete');
await test5();
trace('main: test5 complete');
console.log('passed: ' + passed + ', failed: ' + failed);
if (failed > 0) {
console.log('FAIL');
process.exit(1);
} else {
console.log('OK');
}
}
main();
trace('main() returned (promise pending)');

Owner Packages

  • No Owners