tricu

tree-export.test.mjs (5762B)

---

 import test from 'node:test';
 import assert from 'node:assert/strict';
 import { readFile } from 'node:fs/promises';
 import { COMPILER_BUNDLE_LIMIT, decodeBundle } from '../dist/bundle.js';
 import { exportTree, treeFormat, FLAT_EXPORT_LIMIT, DAG_EXPORT_LIMIT } from '../dist/tree-export.js';
 import { makeBundle } from './bundle-fixture.mjs';
 // Independent structural readers. Application is constructor assembly only:
 // a third argument to a fork would constitute evaluation and fails these tests.
 const leaf = [];
 function apply(fn, arg) { assert.ok(fn.length < 2); return [...fn, arg]; }
 function dag(text) {
   const env = new Map([['△', leaf]]);
   for (const line of text.split('\n')) {
     if (!line) continue;
     const words = line.split(' '); assert.ok(words.every(Boolean));
     const get = name => { assert.ok(env.has(name), name); return env.get(name); };
     if (words.length === 1) return get(words[0]);
     assert.ok(words.length === 2 || words.length === 3);
     env.set(words[0], words.length === 2 ? get(words[1]) : apply(get(words[1]), get(words[2])));
   }
   assert.fail('Missing final value');
 }
 function expression(text, symbol) {
   const tokens = text.match(/△|t|\(|\)/gu); let at = 0;
   function read() {
     const token = tokens[at++];
     if (token === symbol) return leaf;
     assert.equal(token, '('); let result = read();
     while (tokens[at] !== ')') result = apply(result, read());
     at++; return result;
   }
   const result = read(); assert.equal(at, tokens.length); return result;
 }
 function ternary(text) {
   let at = 0;
   function read() { const n = Number(text[at++]); assert.ok(n >= 0 && n <= 2); return Array.from({length:n}, read); }
   const result = read(); assert.equal(at,text.length); return result;
 }
 const bundle = records => decodeBundle(makeBundle(records,[['main',records.length-1],['alias',records.length-1]]));
 test('leaf, stem, fork and identity export exact stored trees in every format', () => {
   for (const [records, expected] of [[ [[]], '0'], [[[],[0]],'10'], [[[],[0,0]],'200'], [[[],[0],[1],[2,0]],'21100']]) {
     const b = bundle(records), want = ternary(expected), original = JSON.stringify(b);
     for (const format of ['ternary','tricu','triangle','dag']) {
       const file = exportTree(b,'main',format);
       assert.equal(file.bytes, Buffer.byteLength(file.text));
       assert.deepEqual(format === 'ternary' ? ternary(file.text) : format === 'dag' ? dag(file.text) : expression(file.text,format === 'tricu' ? 't' : '△'),want);
       assert.deepEqual(exportTree(b,'alias',format),file);
     }
     assert.equal(exportTree(b,'main','ternary').text,expected);
     assert.equal(JSON.stringify(b),original);
   }
   const b=bundle([[],[0],[1],[2,0]]);
   assert.equal(exportTree(b,'main','tricu').text,'(t (t (t t)) t)');
 });
 test('DAG exports only reachable records, handles arbitrary names without embedding them, preserves sharing', () => {
   const b=decodeBundle(makeBundle([[],[0],[1],[0,0],[3,3]],[['x\n△ hacked',4],['unused',2]]));
   const file=exportTree(b,'x\n△ hacked','dag'), tree=dag(file.text);
   assert.equal(file.storedNodes,3); assert.equal(tree[0],tree[1]);
   assert.ok(!file.text.includes('hacked'));assert.ok(!file.text.includes(':n1'));
   assert.match(file.text,/\ntree :n4\ntree\n$/u);
 });
 test('expanded size preflight rejects exponential trees before unfolding, DAG remains linear', () => {
   const records=[[]];for(let i=1;i<64;i++)records.push([i-1,i-1]);
   const b=bundle(records), file=exportTree(b,'main','dag');
   assert.ok(file.bytes<4000);assert.equal(file.storedNodes,64);
   const tree=dag(file.text);assert.equal(tree[0],tree[1]);
   for(const format of ['ternary','tricu','triangle']) assert.throws(()=>exportTree(b,'main',format),/32 MiB.*DAG/);
   assert.throws(()=>exportTree(b,'missing','dag'),/Unknown export/);
   for(const format of ['json','',null]) assert.throws(()=>treeFormat(format),/format/);
 });
 test('deep exports use iterative traversal, UTF-8 byte budgets and complete nontruncated boundaries', () => {
   assert.equal(FLAT_EXPORT_LIMIT,32*1024*1024);assert.equal(DAG_EXPORT_LIMIT,128*1024*1024);
   const records=[[]];for(let i=1;i<20000;i++)records.push([i-1]);
   const b=bundle(records);
   for(const format of ['ternary','tricu','triangle','dag']) {
     const file=exportTree(b,'main',format);assert.equal(file.bytes,Buffer.byteLength(file.text));
     assert.equal(file.storedNodes,20000);
   }
   const doubled=[[]];for(let i=1;i<=24;i++)doubled.push([i-1,i-1]);
   const exact=exportTree(bundle(doubled),'main','ternary');assert.equal(exact.bytes,FLAT_EXPORT_LIMIT-1);
   assert.equal(exact.text.length,exact.bytes);assert.match(exact.text,/^[012]+$/u);
   assert.throws(()=>exportTree(bundle([...doubled,[24]]),'main','triangle'),/32 MiB/);
   assert.throws(()=>exportTree(bundle([...doubled,[24,24]]),'main','ternary'),/32 MiB.*DAG/);
 });
 test('every curated definition and compiler definition has bounded DAG output without evaluating', async () => {
   const entries=JSON.parse(await readFile(new URL('../catalogue.json',import.meta.url)));
   entries.push(JSON.parse(await readFile(new URL('../compiler.json',import.meta.url))));
   for(const hash of new Set(entries.map(e=>e.hash))) {
     const b=decodeBundle(await readFile(new URL('../bundles/'+hash+'.arboricx',import.meta.url)),COMPILER_BUNDLE_LIMIT);
     // Largest compiler exports plus all demo definitions, not repeated all compiler traversals.
     const names=b.exports.length>100 ? ['source_unit.compileStableModuleDefinitions','base.id','base.y'] : b.exports.map(e=>e.name);
     for(const name of names) {
       const file=exportTree(b,name,'dag');assert.equal(file.bytes,Buffer.byteLength(file.text));
       assert.ok(file.storedNodes<=b.nodes.length);dag(file.text);
     }
   }
 });