tricu

conformance.mjs (4913B)

---

 import { readFileSync, writeFileSync, mkdtempSync, rmSync, existsSync, readdirSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { strict as assert } from 'node:assert';
 import { Library, TricuError } from '../src/lib.js';
 
 export function conformance(path, fixtureDir, specification, copier) {
   const f = JSON.parse(readFileSync(specification, 'utf8'));
   const library = new Library(path), ctx = library.context(), other = library.context();
   const report = {};
   const load = (file, name) => ctx.loadBundle(readFileSync(join(fixtureDir, file)), name);
   try {
     report.numbers = f.numbers.map(n => ctx.toNumber(ctx.number(BigInt(n))).toString());
     report.strings = f.strings.map(s => ctx.toString(ctx.string(s)));
     report.bytesHex = f.bytesHex.map(h => ctx.toBytes(ctx.bytes(Buffer.from(h,'hex'))).toString('hex'));
     const worker = load('id.arboricx','id'), argument = ctx.string(f.identity);
     assert.equal(typeof worker, 'bigint');
     const application = ctx.apply(worker, argument);
     ctx.release(worker); ctx.release(argument);
     report.identity = ctx.toString(ctx.reduce(application));
     let append = load('append.arboricx','append');
     for (const text of f.append) append = ctx.apply(append,ctx.string(text));
     report.append = ctx.toString(append);
     report.booleans = ['true','false'].map(name => ctx.toBool(load(name+'.arboricx',name)));
     report.notQKind = ctx.kind(ctx.reduce(load('notQ.arboricx','not?')));
     report.outcomes = [];
     for (const code of [0,2,9]) {
       const program = ctx.fork(ctx.string('tricuIO'),ctx.fork(ctx.number(2),ctx.fork(ctx.number(code),ctx.string('opaque payload'))));
       const {outcome,value,cleanup} = ctx.runIO(program);
       report.outcomes.push({outcome,payload:ctx.toString(value),cleanupKind:ctx.kind(cleanup)});
       for (const handle of [program,value,cleanup]) ctx.release(handle);
     }
     const root = ctx.string('owned'), alias = ctx.retain(root);
     assert.notEqual(root,alias);
     ctx.release(root);
     assert.equal(ctx.toString(alias),'owned');
     const wrong = ctx.stem(ctx.stem(ctx.leaf()));
     report.negativeStatuses = [() => ctx.release(root), () => other.retain(alias),
       () => ctx.toNumber(wrong), () => ctx.toBool(wrong),
       () => ctx.loadBundle(Buffer.from('bad bundle'),'id'), () => load('id.arboricx','missing'),
       () => ctx.runIO(ctx.leaf())].map(operation => {
         try { operation(); } catch (error) {
           assert.ok(error instanceof TricuError); assert.ok(error.message.length); return error.status;
         }
         throw new Error('invalid operation accepted');
       });
     assert.throws(() => ctx.string('\ud800'), /surrogate/);
     for (const number of [-1n,2n**64n,9007199254740992,1.5]) assert.throws(() => ctx.number(number));
     if (copier) checkCopier(library,copier,f);
     assert.deepEqual(report,f.expected);
   } finally { other.close(); ctx.close(); }
   assert.throws(() => ctx.leaf(), e => e instanceof TricuError && e.status === 1);
   ctx.close(); // idempotent
   for (let i=0;i<100;i++) { const fresh=library.context(); fresh.close(); }
   return report;
 }
 
 function checkCopier(library,bundle,f) {
   const dir=mkdtempSync(join(tmpdir(),'tricu-js-')),ctx=library.context();
   const source=join(dir,'in'),target=join(dir,'out'),body=Buffer.from(f.copyHex.repeat(f.copyRepeats),'hex');
   const bytes=readFileSync(bundle),worker=ctx.loadBundle(bytes,'copy');
   const run = (fn,destination=target) => ctx.runIO(ctx.apply(ctx.apply(fn,ctx.string(source)),ctx.string(destination)));
   const fdCount = () => existsSync('/proc/self/fd') ? readdirSync('/proc/self/fd').length : null;
   try {
     writeFileSync(source,body);
     let baseline;
     for (let i=0;i<3;i++) {
       const r=run(worker);
       assert.equal(r.outcome,0); assert.equal(ctx.kind(r.cleanup),0);
       assert.equal(ctx.toBool(ctx.child(r.value,0)),true);
       assert.deepEqual(readFileSync(target),body);
       if (i===0) baseline=fdCount(); else assert.equal(fdCount(),baseline);
       ctx.release(r.value); ctx.release(r.cleanup);
     }
     const cancelled=run(ctx.loadBundle(bytes,'cancelledCopy'));
     assert.equal(cancelled.outcome,0);
     assert.equal(ctx.toString(ctx.child(cancelled.value,0)),'cancelled');
     assert.equal(ctx.toString(ctx.child(ctx.child(cancelled.value,1),0)),'requested');
     assert.deepEqual(readFileSync(target),body.subarray(0,4096));
     const failed=run(worker,join(dir,'missing-parent','out'));
     assert.equal(failed.outcome,0); assert.equal(ctx.toBool(ctx.child(failed.value,0)),false);
     assert.equal(fdCount(),baseline);
     rmSync(source); rmSync(target);
     const missing=run(worker);
     assert.equal(missing.outcome,0); assert.equal(ctx.toBool(ctx.child(missing.value,0)),false);
     assert.equal(existsSync(target),false);
   } finally { ctx.close(); rmSync(dir,{recursive:true,force:true}); }
 }