tricu

execution.test.mjs (4150B)

---

 import test from 'node:test';
 import assert from 'node:assert/strict';
 import {Graph} from '../dist/graph.js';
 import {BROWSER_BUDGET,collectionPolicy,operationFailure,operationTimeout,PACKAGE_LOAD_MS} from '../dist/execution.js';
 import {ActiveClock} from '../dist/clock.js';
 
 test('browser execution has no configurable ceilings; GC is independent',()=>{
  assert.deepEqual(BROWSER_BUDGET,{nodes:Infinity,fuel:Infinity,stack:Infinity});
  const g=new Graph(BROWSER_BUDGET,collectionPolicy(BROWSER_BUDGET));
  assert.equal(g.stats.fuel,Infinity);
  assert.deepEqual(collectionPolicy(BROWSER_BUDGET),{threshold:250000});
  // Finite evaluator budgets remain available to bounded reference tests.
  assert.deepEqual(collectionPolicy({nodes:100}),{threshold:100});
  assert.equal(collectionPolicy({nodes:1}),undefined);
 });
 
 function fakeClock(){
  let now=0,id=0,expired=0;const pending=new Map();
  const clock=new ActiveClock(()=>expired++,()=>now,(fn,delay)=>{pending.set(++id,{fn,delay});return id;},key=>pending.delete(key));
  return {clock,pending,elapsed(ms){now+=ms;},fire(){const [key,item]=pending.entries().next().value;pending.delete(key);now+=item.delay;item.fn();},get expired(){return expired;}};
 }
 test('active deadline excludes pauses, restarts per operation and supports off',()=>{
  const f=fakeClock();f.clock.reset(1000);f.clock.start();f.clock.start();assert.equal(f.pending.size,1);
  f.elapsed(400);f.clock.pause();assert.equal(f.pending.size,0);
  f.elapsed(10000);f.clock.start();assert.equal([...f.pending.values()][0].delay,600);
  f.fire();assert.equal(f.expired,1);
  f.clock.reset(2000);f.clock.start();f.clock.pause();assert.equal(f.pending.size,0);
  f.clock.reset(Infinity);f.clock.start();assert.equal(f.pending.size,0);
  assert.throws(()=>f.clock.reset(0),/deadline/);
 });
 test('large infrastructure deadlines use signed-32-bit-safe timer chunks',()=>{
  const f=fakeClock();f.clock.reset(5000000000);f.clock.start();
  assert.equal([...f.pending.values()][0].delay,2147483647);
  f.fire();assert.equal(f.expired,0);f.fire();assert.equal(f.expired,0);
  assert.equal([...f.pending.values()][0].delay,705032706);
  f.fire();assert.equal(f.expired,1);assert.equal(f.pending.size,0);
 });
 
 test('operation work resets preserve cumulative counters, handles and memory caps',()=>{
  const g=new Graph({nodes:2,fuel:10,stack:1}),value=g.stem(g.leaf);
  while(g.stats.fuel>0)g.tick();
  assert.throws(()=>g.tick(),/fuel/);
  const before=g.stats;g.beginOperation();
  assert.equal(g.stats.fuel,10);
  for(const key of ['nodes','work','allocations','peakNodes','collections','reclaimed','gcWork'])assert.equal(g.stats[key],before[key]);
  assert.equal(g.observe(value).node.kind,'stem');
  assert.throws(()=>g.stem(g.leaf),/allocation/);
  assert.ok(g.stats.work>before.work);
  const limited=new Graph({fuel:1000,stack:1});
  const I=limited.fromTernary('21100');let application=limited.leaf;
  for(let i=0;i<10;i++)application=limited.app(I,application);
  limited.beginOperation();assert.throws(()=>limited.force(application),/stack/);
  const unlimited=new Graph({fuel:Infinity});unlimited.tick();unlimited.beginOperation();
  assert.equal(unlimited.stats.fuel,Infinity);assert.equal(unlimited.stats.work,1);
 });
 
 test('operation failures and deadlines identify the actual phase, not generic execution',()=>{
  assert.equal(PACKAGE_LOAD_MS,60000);
  const labels={catalogue:'Program catalogue loading',loading:'Package loading',compiling:'Draft compilation',running:'Program execution',exporting:'Definition export',downloading:'Bundle download'};
  for(const [operation,label] of Object.entries(labels)){
   assert.equal(operationFailure(operation,'SHA-256 mismatch'),`${label} failed: SHA-256 mismatch`);
   const timeout=operationTimeout(operation);
   assert.ok(timeout.startsWith(label));
   if(['catalogue','loading','downloading'].includes(operation)){
    assert.match(timeout,/timed out/);assert.doesNotMatch(timeout,/active time/);
   }else assert.match(timeout,/active time limit exceeded/);
  }
  assert.equal(operationFailure(undefined,'Invalid literal'),'Invalid literal');
  assert.equal(new Set(Object.keys(labels).map(operationTimeout)).size,6);
 });