#!/usr/bin/env node // proba-conformance.mjs: the probe of the conformance suite itself. Three states per row: VERDE (as required), ROSU (not), STRICAT / // NEMASURAT (the row could not be measured: counted, never passed); INFO rows are measurements printed beside the gates, not counted. Exit 0 all green, 1 a red or broken row, 2 only unmeasured rows. // // node proba-conformance.mjs [--online] [--acceptate] the suite is derived, whole, single-place, two implementations pass it, // and malformed artifacts are refused by name (--acceptate lists what a // verifier still accepts when damaged: the optional and the unread) // node proba-conformance.mjs --control-negativ [--online] every rule planted out of its verifier, one at a time: the vectors that // name the rule, and only they, must fail; plus the controls of the // runner, of the coverage gate and of the rule derivation // node proba-conformance.mjs --pe-loc a MEASUREMENT, not a gate: each check site planted out alone; how many // of the sites the vectors reach // // The independent implementation needs Python 3 (AERE_CONFORMANCE_PYTHON=, default python3 then python); the envelope // vectors need the AIP-23 reference verifier (AERE_VERIFY_PROOF=, with `npm install` done beside it); --online // reads testnet 28001 (nothing is sent). import fs from 'node:fs'; import os from 'node:os'; import path from 'node:path'; import { spawn, spawnSync } from 'node:child_process'; import { fileURLToPath, pathToFileURL } from 'node:url'; import { deriva, hartaPublica, VERIFICATOARE, MODULE, VERIFY_PROOF, FINALITY_SITES, incarca } from './reguli.mjs'; import { incarcaVectorii, ruleazaSuita } from './conformance.mjs'; import { aplica, plicuriKinds } from './genereaza-vectori.mjs'; const AICI = path.dirname(fileURLToPath(import.meta.url)); const a = process.argv.slice(2); const online = a.includes('--online'); const control = a.includes('--control-negativ'); const peLoc = a.includes('--pe-loc'); const REF = `node "${path.join(AICI, 'implementare-aere.mjs')}"`; let verzi = 0, rosii = 0, nemas = 0; const rand = (stare, text) => { console.log(` [${stare.padEnd(9)}] ${text}`); if (stare === 'VERDE') verzi++; else if (stare === 'ROSU') rosii++; else if (stare !== 'INFO') nemas++; }; const cer = (cond, text, detaliu = '') => rand(cond ? 'VERDE' : 'ROSU', text + (detaliu ? ': ' + detaliu : '')); const canon = (x) => (x === null || typeof x !== 'object' ? JSON.stringify(x) : Array.isArray(x) ? '[' + x.map(canon).join(',') + ']' : '{' + Object.keys(x).sort().map((k) => JSON.stringify(k) + ':' + canon(x[k])).join(',') + '}'); /** the JSON paths at which two values differ (a subtree added, removed or of another type is one path) */ function difera(x, y, p = []) { if (canon(x) === canon(y)) return []; const ob = (v) => v !== null && typeof v === 'object'; if (!ob(x) || !ob(y) || Array.isArray(x) !== Array.isArray(y)) return [p]; return [...new Set([...Object.keys(x), ...Object.keys(y)])].flatMap((k) => (k in x && k in y ? difera(x[k], y[k], [...p, Array.isArray(x) ? Number(k) : k]) : [[...p, Array.isArray(x) ? Number(k) : k]])); } const prefix = (pre, p) => pre.length <= p.length && pre.every((k, i) => String(k) === String(p[i])); if (!fs.existsSync(VERIFY_PROOF)) { console.log('NEMASURAT: the AIP-23 reference verifier is not at ' + VERIFY_PROOF + ' (AERE_VERIFY_PROOF=)'); process.exit(2); } const S = incarcaVectorii(); if (S.eroare) { console.log('ROSU: the vector set is not whole: ' + S.eroare); process.exit(1); } const vectori = S.vectori; const HARTA = hartaPublica(); const TOATE = Object.keys(HARTA); const cuRegula = (r, lista = vectori) => lista.filter((v) => v.expected.failed.includes(r)).map((v) => v.id); /** coverage: every rule has a vector that expects it; returns the rules without one */ const neacoperite = (reguli, lista = vectori) => reguli.filter((r) => !cuRegula(r, lista).length); const python = () => { for (const c of [process.env.AERE_CONFORMANCE_PYTHON, 'python3', 'python'].filter(Boolean)) { const r = spawnSync(c, ['--version'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }); if (r.status === 0 && /Python 3/.test(r.stdout + r.stderr)) return c; } return null; }; const numar = (s, st) => s.rezultate.filter((r) => r.stare === st); // ---------- planting ---------- const PLANT = "|| String(1) === '1' /*PLANTAT*/"; /** exact-once plantings of the reference verifier (a published program without markers): rule -> [text, planted text] */ const PLANT_VP = { form: [".test(env.statementHash);", ".test(env.statementHash) || String(1) === '1';"], integrity: ["const ok = h === env.statementHash.toLowerCase();", "const ok = h === env.statementHash.toLowerCase() || String(1) === '1';"], signature: ["const ok = crypto.verify(null, Buffer.from(text, 'utf8'), pub, sig);", "const ok = crypto.verify(null, Buffer.from(text, 'utf8'), pub, sig) || String(1) === '1';"], finality: ["env.notarization ? 'FAILED' : 'ABSENT'", "(env.notarization && String(1) === '2') ? 'FAILED' : 'ABSENT'"], }; /** Writes the planted copy of a rule's verifier beside the original; returns { copie, env } or { stricat }. `loc` plants one site only. */ function planteaza(verifier, sursa, loc = null) { const d = VERIFICATOARE[verifier]; if (d.sursa === 'verify-proof') { const src = fs.readFileSync(VERIFY_PROOF, 'utf8'); const [de, cu] = PLANT_VP[sursa] || []; const n = de ? src.split(de).length - 1 : 0; if (n !== 1) return { stricat: `the planting anchor of ${sursa} appears ${n} times in the reference verifier` }; const copie = path.join(path.dirname(VERIFY_PROOF), `.plantat-conf-${process.pid}-${sursa}.mjs`); fs.writeFileSync(copie, src.replace(de, () => cu)); return { copie, env: { AERE_VERIFY_PROOF: copie } }; } const p = fileURLToPath(MODULE[d.sursa].url); const src = fs.readFileSync(p, 'utf8'); const bucati = src.split(`/*PAZA:${sursa}*/`); const n = bucati.length - 1; if (n < 1) return { stricat: `no /*PAZA:${sursa}*/ marker in ${path.basename(p)}` }; if (loc !== null && loc >= n) return { stricat: 'site ' + loc + ' of ' + n }; const text = loc === null ? bucati.join(PLANT) : bucati.map((b, i) => (i === bucati.length - 1 ? b : b + (i === loc ? PLANT : `/*PAZA:${sursa}*/`))).join(''); const copie = path.join(path.dirname(p), `_plantat-conf-${process.pid}-${sursa}${loc === null ? '' : '-' + loc}.mjs`); fs.writeFileSync(copie, text); return { copie, env: { [MODULE[d.sursa].env]: copie } }; } /** the suite, run as a separate program (several plantings run side by side) */ function suitaAsync(env, { online: on = false, doar = null } = {}) { return new Promise((gata) => { const args = [path.join(AICI, 'conformance.mjs'), '--impl', REF, '--json']; if (on) args.push('--online'); if (doar) args.push('--only', doar); const c = spawn(process.execPath, args, { env: { ...process.env, ...env }, stdio: ['ignore', 'pipe', 'pipe'] }); let out = '', err = ''; c.stdout.on('data', (d) => { out += d; }); c.stderr.on('data', (d) => { err += d; }); c.on('close', () => { try { gata({ rezultate: JSON.parse(out).results }); } catch { gata({ eroare: (out + err).trim().split('\n').slice(-1)[0].slice(0, 200) }); } }); }); } async function inParalel(sarcini, n = 4) { const rez = new Array(sarcini.length); let k = 0; await Promise.all(Array.from({ length: Math.min(n, sarcini.length) }, async () => { while (k < sarcini.length) { const i = k++; rez[i] = await sarcini[i](); } })); return rez; } const ramase = () => [...Object.values(MODULE).map((m) => path.dirname(fileURLToPath(m.url))), path.dirname(VERIFY_PROOF)].flatMap((d) => fs.readdirSync(d).filter((f) => /^[._]plantat-conf-/.test(f)).map((f) => path.join(d, f))); /** * Every path of every offline vector that is not INVALID, removed or replaced by null, a string, a number, a list, an object, and given * to the module verifiers directly. Left out, and said: the policy (a policy that cannot be defined is refused by definePolicy by * throwing, by design: nothing is judged under it) and the public task of a market job (each replay costs seconds). * @returns {{ cazuri: number, aruncate: string[], acceptate: string[] }} acceptate = the paths (without array positions) whose damage was accepted */ async function malformate() { const R = await incarca('risc'), C = await incarca('chitanta'), P = await incarca('piata'), B = await incarca('baza'); const clona = (x) => JSON.parse(JSON.stringify(x)); const J = { 'payment-risk': (i) => R.judeca(i.policy, i.inputs).decision === 'ALLOW', 'payment-receipt': (i) => C.verificaChitanta(i.receipt, { policy: i.policy, inputs: i.inputs, tx: i.tx, receipt: i.txReceipt }).verdict === 'VALID', 'market-timeline': (i) => P.judeca(i).verdict === 'VALID', 'dataset-record': (i) => B.verificaInregistrare(i.record, i.commitment).ok, 'dataset-answer': (i) => B.verificaRaspuns(i.answer, i.commitment).verdict === 'VALID', 'dataset-consistency': (i) => B.verificaConsistentaVersiuni(i.proof, i.older, i.newer).ok }; const cai = (x, p = []) => (x !== null && typeof x === 'object' ? [p, ...Object.keys(x).flatMap((k) => cai(x[k], [...p, Array.isArray(x) ? Number(k) : k]))] : [p]).filter((q) => q.length); const VAL = [null, 'x', 7, [], {}]; let cazuri = 0; const aruncate = [], acceptate = []; for (const v of vectori) { if (!J[v.artifact] || v.expected.verdict === 'INVALID' || v.requires.length) continue; const inp = clona(v.input); if (v.artifact === 'market-timeline') delete inp.spec; for (const p of cai(inp)) { if (p[0] === 'policy') continue; for (const op of ['remove', 0, 1, 2, 3, 4]) { const c = clona(inp); let o = c; for (const k of p.slice(0, -1)) o = o[k]; const k = p[p.length - 1]; if (op === 'remove') { if (Array.isArray(o)) o.splice(k, 1); else delete o[k]; } else { if (JSON.stringify(o[k]) === JSON.stringify(VAL[op])) continue; o[k] = clona(VAL[op]); } cazuri++; try { if (J[v.artifact](c)) acceptate.push(v.artifact + ':' + p.filter((x) => typeof x !== 'number').join('.')); } catch (e) { aruncate.push(v.id + ' ' + p.join('.') + ' <- ' + (op === 'remove' ? 'removed' : JSON.stringify(VAL[op])) + ': ' + String(e.message).slice(0, 60)); } } } } return { cazuri, aruncate, acceptate }; } if (!control && !peLoc) { console.log('A. the rules and the vectors are derived, and nothing is typed in their place'); const D = await deriva(); cer(!D.probleme.length && !D.nemasurat.length, `the rules derive from the code of ${Object.keys(D.tabel.verifiers).length} verifiers: declared == marked == mapped (${TOATE.length} rules)`, [...D.probleme, ...D.nemasurat].join(' | ')); const rj = path.join(AICI, 'REGULI.json'); cer(fs.existsSync(rj) && fs.readFileSync(rj, 'utf8').replace(/\r\n/g, '\n') === JSON.stringify(D.tabel, null, 1) + '\n', 'REGULI.json is what the code derives now'); const g = spawnSync(process.execPath, [path.join(AICI, 'genereaza-vectori.mjs'), '--verifica'], { encoding: 'utf8' }); cer(g.status === 0, 'the vectors on disk are what the generator derives now, byte for byte', g.status === 0 ? g.stdout.trim().split('\n').slice(-1)[0] : (g.stdout + g.stderr).trim().split('\n').slice(-3).join(' | ')); const dev = path.join(AICI, '..', 'aere-proof-protocol', 'genereaza-vectori-kinds.mjs'); if (fs.existsSync(dev)) { const G = await import(pathToFileURL(dev).href); const lor = new Map(G.totiVectorii().map((x) => [x.nume, canon(x.plic)])); const ale = plicuriKinds(); cer(ale.length === lor.size && ale.every(([k, p]) => lor.get(k) === canon(p)), `the ${ale.length} kind envelopes are the published AIP-23 kind vectors (same producers, same fixed inputs)`); } else rand('INFO', 'the comparison with the published AIP-23 kind vectors is made in the development repository (their generator is not part of this copy)'); console.log('B. coverage and single place'); const fara = neacoperite(TOATE); cer(!fara.length, `every rule a verifier names has a vector that expects it (${TOATE.length} of ${TOATE.length})`, fara.length ? 'without a vector: ' + fara.join(', ') : ''); const artifacte = Object.values(VERIFICATOARE).flatMap((v) => v.artifacts); const faraValid = artifacte.filter((x) => !vectori.some((v) => v.artifact === x && v.expected.verdict === 'VALID')); cer(!faraValid.length, `every artifact kind has a VALID vector (${artifacte.length} kinds)`, faraValid.join(', ')); const kinds = plicuriKinds().map(([k]) => k); const kLipsa = kinds.filter((k) => !['valid', 'form', 'integrity'].every((s) => vectori.some((v) => v.id === `envelope/${k}.${s}`))); cer(!kLipsa.length, `every AIP-23 proof kind (${kinds.length}) has its VALID vector and one INVALID vector per offline envelope rule`, kLipsa.join(', ')); let unLoc = 0, prod = 0, alte = 0; const rele = []; for (const v of vectori) { if (!v.base) { if (v.expected.verdict === 'INVALID') rele.push(v.id + ': INVALID without a base'); continue; } const b = vectori.find((x) => x.id === v.base); if (!b) { rele.push(v.id + ': base missing'); continue; } if (b.expected.verdict === 'INVALID') rele.push(v.id + ': its base is INVALID'); if (v.mutation && v.mutation.op) { let m; try { m = aplica(b.input, v.mutation); } catch (e) { rele.push(v.id + ': ' + e.message); continue; } if (canon(m) !== canon(v.input)) rele.push(v.id + ': the input is not the base with the one operation applied'); else if (v.expected.verdict === 'INVALID') unLoc++; else alte++; } else if (v.mutation && v.mutation.producer) { const dif = difera(b.input, v.input); const afara = dif.filter((p) => !v.mutation.changed.some((c) => prefix(c, p))); const neatinse = v.mutation.changed.filter((c) => !dif.some((p) => prefix(c, p))); if (!dif.length || afara.length || neatinse.length) rele.push(v.id + ': differs outside what it declares (' + afara.map((p) => p.join('.')).join(', ') + ') or declares paths that did not move (' + neatinse.map((p) => p.join('.')).join(', ') + ')'); else prod++; } else rele.push(v.id + ': a base without a mutation'); } const inv = vectori.filter((v) => v.expected.verdict === 'INVALID').length; cer(!rele.length && unLoc + prod === inv, `every INVALID vector (${inv}) is its base with ONE operation applied (${unLoc}), or one change at the producer with the paths that moved declared (${prod}); ${alte} more vectors that are not INVALID are also one operation from their base`, rele.slice(0, 4).join(' | ')); const multe = vectori.filter((v) => v.expected.failed.length > 1); const fin = cuRegula('envelope.finality'); rand('INFO', `measured, not a gate: ${multe.length} vector(s) expect more than one rule (rules that guard the same field: ${multe.map((v) => v.id.split('/')[1]).join(', ')}); of the ${FINALITY_SITES.length} refusal sites of the reference verifier's finality level the vectors reach ${fin.length ? FINALITY_SITES.filter((x) => x.reachable).length : 0} (the others need an endpoint that lies)`); console.log('C. two implementations, one runner'); const r1 = ruleazaSuita({ impl: REF, online }); if (r1.eroare) rand('STRICAT', 'the reference verifiers: ' + r1.eroare); else { const p = numar(r1, 'PASS').length, deRulat = vectori.filter((v) => online || !v.requires.length).length; cer(p === deRulat && !numar(r1, 'FAIL').length && !numar(r1, 'BROKEN').length && !numar(r1, 'NOT_COVERED').length, `the published verifiers behind the one verdict form pass ${p} of ${deRulat} vectors${online ? ' (testnet 28001 read)' : ' (offline)'}`, [...numar(r1, 'FAIL'), ...numar(r1, 'BROKEN')].slice(0, 3).map((x) => x.id + ' ' + x.detaliu).join(' | ')); if (!online) rand('NEMASURAT', `${numar(r1, 'SKIPPED_ONLINE').length} vectors need testnet 28001 and were not run (--online)`); } const py = python(); if (!py) rand('NEMASURAT', 'the independent implementation needs Python 3 (AERE_CONFORMANCE_PYTHON=)'); else { const r2 = ruleazaSuita({ impl: `${py} "${path.join(AICI, 'implementare-integritate.py')}"`, online: false }); if (r2.eroare) rand('STRICAT', 'the independent implementation: ' + r2.eroare); else { const p = numar(r2, 'PASS').length, nc = numar(r2, 'NOT_COVERED').length; const revendica = vectori.filter((v) => r2.caps.artifacts.includes(v.artifact) && v.exercises.every((x) => r2.caps.rules.includes(x)) && !v.requires.length).length; cer(p === revendica && p > 0 && !numar(r2, 'FAIL').length && !numar(r2, 'BROKEN').length && p + nc === vectori.length, `an independent implementation in another language (${r2.caps.name}) passes all ${p} vectors it claims; the other ${nc} are reported NOT COVERED, never passed`, [...numar(r2, 'FAIL'), ...numar(r2, 'BROKEN')].slice(0, 3).map((x) => x.id + ' ' + x.detaliu).join(' | ')); } } console.log('D. a malformed artifact is refused by name, never thrown at the reader'); { const m = await malformate(); cer(m.cazuri > 1000 && !m.aruncate.length, `${m.cazuri} malformed inputs (every path removed or replaced) given to the module verifiers: each got a verdict, none threw`, m.aruncate.slice(0, 3).join(' | ') + (m.aruncate.length > 3 ? ' ... ' + m.aruncate.length + ' in all' : '')); const cai = [...new Set(m.acceptate)].sort(); const peFel = {}; for (const c of cai) { const k = c.split(':')[0]; peFel[k] = (peFel[k] || 0) + 1; } rand('INFO', `measured, not a gate: ${m.acceptate.length} of them were still accepted, at ${cai.length} distinct paths (${Object.entries(peFel).map(([k, n]) => k + ' ' + n).join(', ')}): parts a verifier treats as optional (the transaction facts of a receipt, the envelope of a timeline) and fields no rule reads; --acceptate lists them`); if (a.includes('--acceptate')) for (const c of cai) console.log(' ' + c); } } else if (control) { console.log('CONTROL: every rule planted out of its verifier, one at a time; the vectors that expect the rule, and only they, must fail'); const cazuri = []; for (const [v, d] of Object.entries(VERIFICATOARE)) for (const [src, [id]] of Object.entries(d.reguli)) cazuri.push({ v, src, id, online: id === 'envelope.finality' }); const deRulat = cazuri.filter((c) => !c.online || online); let bune = 0; try { const rez = await inParalel(deRulat.map((c) => async () => { const p = planteaza(c.v, c.src); if (p.stricat) return { stricat: p.stricat }; try { return await suitaAsync(p.env, { online: c.online }); } finally { fs.rmSync(p.copie, { force: true }); } })); deRulat.forEach((c, k) => { const r = rez[k]; const asteptate = cuRegula(c.id, vectori.filter((v) => c.online || !v.requires.length)).sort(); if (r.stricat || r.eroare) return rand('STRICAT', `${c.id}: ${r.stricat || r.eroare}`); const cazute = r.rezultate.filter((x) => x.stare === 'FAIL').map((x) => x.id).sort(); const stricate = r.rezultate.filter((x) => x.stare === 'BROKEN').map((x) => x.id); const ok = asteptate.length > 0 && cazute.join() === asteptate.join() && !stricate.length; if (ok) bune++; rand(ok ? 'VERDE' : stricate.length ? 'STRICAT' : 'ROSU', `${c.id} planted out: ${cazute.length} vector(s) fail` + (ok ? `, exactly the ${asteptate.length} that expect it` : `; expected exactly [${asteptate.join(', ')}], failed [${cazute.join(', ')}]` + (stricate.length ? `, broken [${stricate.join(', ')}]` : ''))); }); } finally { for (const f of ramase()) fs.rmSync(f, { force: true }); } for (const c of cazuri.filter((x) => x.online && !online)) rand('NEMASURAT', `${c.id}: its vectors need testnet 28001 (--online)`); console.log('CONTROL of the instruments'); { // the runner can fail: an implementation that calls everything VALID const stub = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'aere-conf-stub-')), 'stub.mjs'); fs.writeFileSync(stub, `import fs from 'node:fs'; const a = process.argv.slice(2); const V = JSON.stringify({ verdict: 'VALID', failed: [], levels: [{ level: 'integrity', state: 'PASSED' }, { level: 'authenticity', state: 'NOT_MEASURED' }, { level: 'anchoring', state: 'NOT_MEASURED' }, { level: 'finality', state: 'NOT_MEASURED' }] });\nif (a.includes('--capabilities')) console.log(JSON.stringify({ artifacts: ${JSON.stringify(Object.values(VERIFICATOARE).flatMap((v) => v.artifacts))}, rules: ${JSON.stringify(TOATE)}, online: false, batch: true }));\nelse for (const x of JSON.parse(fs.readFileSync(a[a.indexOf('--batch') + 1], 'utf8'))) console.log(V);\n`); const r = ruleazaSuita({ impl: `node "${stub}"` }); fs.rmSync(path.dirname(stub), { recursive: true, force: true }); const off = vectori.filter((v) => !v.requires.length); const trebuie = off.filter((v) => !(v.expected.verdict === 'VALID' && Object.entries(v.expected.levels).every(([l, s]) => s === (l === 'integrity' ? 'PASSED' : 'NOT_MEASURED')))).map((v) => v.id).sort(); const cazute = r.eroare ? [] : numar(r, 'FAIL').map((x) => x.id).sort(); cer(!r.eroare && cazute.join() === trebuie.join() && trebuie.length > 0, `the runner fails an implementation that calls everything VALID on ${trebuie.length} of ${off.length} offline vectors (every one that is not plainly VALID)`, r.eroare || ''); } { const lista = vectori.filter((v) => !v.expected.failed.includes('dataset.order')); const f = neacoperite(TOATE, lista); cer(f.join() === 'dataset.order', 'the coverage gate goes red when the vector of one rule is taken away (dataset.order)', f.join(', ')); } { // a rule added to a verifier and not mapped in the suite is refused by the derivation const p = fileURLToPath(MODULE.baza.url); const copie = path.join(path.dirname(p), `_plantat-conf-${process.pid}-regula-noua.mjs`); const src = fs.readFileSync(p, 'utf8'); const anc = "'consistenta', 'esantion'];"; try { if (src.split(anc).length !== 2) rand('STRICAT', 'the anchor of the new-rule planting is not in the dataset module'); else { fs.writeFileSync(copie, src.replace(anc, "'consistenta', 'esantion', 'noua'];") + '\n/*PAZA:noua*/\n'); const D = await deriva({ cai: { baza: copie } }); cer(D.probleme.length === 1 && /names rule noua and the suite does not map it/.test(D.probleme[0]), 'a rule added to a verifier and not mapped in the suite is refused by the derivation (a new rule without a vector cannot pass unseen)', D.probleme.join(' | ')); } } finally { fs.rmSync(copie, { force: true }); } } { // the malformed-input row can go red: the market judge without its form check and without its catch throws again, and the row counts it const p = fileURLToPath(MODULE.piata.url); const copie = path.join(path.dirname(p), `_plantat-conf-${process.pid}-arunca.mjs`); const src = fs.readFileSync(p, 'utf8'); const anc = "catch (e) { return { verdict: 'INVALID', motive: ['malformed timeline: '"; try { if (src.split(anc).length !== 2) rand('STRICAT', 'the anchor of the throwing planting is not in the market judge'); else { fs.writeFileSync(copie, src.replace(anc, "catch (e) { throw e; return { verdict: 'INVALID', motive: ['malformed timeline: '").split('/*PAZA:forma*/').join(PLANT)); process.env[MODULE.piata.env] = copie; const m = await malformate(); delete process.env[MODULE.piata.env]; cer(m.aruncate.length > 0 && m.aruncate.every((x) => x.startsWith('market-timeline/')), `the malformed-input row goes red when a judge throws again (the market judge without its form check and its catch: ${m.aruncate.length} of ${m.cazuri} inputs thrown)`); } } finally { delete process.env[MODULE.piata.env]; fs.rmSync(copie, { force: true }); } } const r = ramase(); cer(!r.length, 'no planted copy is left behind', r.join(', ')); console.log(`CONTROL: ${bune} of ${cazuri.length} rules proven load-bearing through their vectors`); } else { console.log('MEASUREMENT (not a gate): each check site planted out alone, the vectors of its artifact kinds run'); const locuri = []; for (const [v, d] of Object.entries(VERIFICATOARE)) { if (d.sursa === 'verify-proof') continue; const src = fs.readFileSync(fileURLToPath(MODULE[d.sursa].url), 'utf8'); for (const [s, [id]] of Object.entries(d.reguli)) { const n = src.split(`/*PAZA:${s}*/`).length - 1; for (let k = 0; k < n; k++) locuri.push({ v, src: s, id, k, n, doar: d.artifacts[0].split('-')[0] }); } } let atinse = 0; try { const rez = await inParalel(locuri.map((c) => async () => { const p = planteaza(c.v, c.src, c.k); if (p.stricat) return { stricat: p.stricat }; try { return await suitaAsync(p.env, { doar: c.doar }); } finally { fs.rmSync(p.copie, { force: true }); } })); const peRegula = {}; locuri.forEach((c, k) => { const r = rez[k]; const cazute = r.rezultate ? r.rezultate.filter((x) => x.stare === 'FAIL').length : 0; if (cazute) atinse++; (peRegula[c.id] || (peRegula[c.id] = [])).push(r.stricat || r.eroare ? '?' : cazute ? 'reached' : 'NOT reached'); }); for (const [id, l] of Object.entries(peRegula)) console.log(` ${id}: ${l.filter((x) => x === 'reached').length} of ${l.length} site(s) reached` + (l.includes('NOT reached') ? ' (sites ' + l.map((x, i) => (x === 'NOT reached' ? i + 1 : null)).filter(Boolean).join(', ') + ' have no vector)' : '')); } finally { for (const f of ramase()) fs.rmSync(f, { force: true }); } console.log(`SITES: the vectors reach ${atinse} of ${locuri.length} check sites of the module verifiers (the reference verifier's own sites are counted in REGULI.json)`); process.exit(0); } console.log(`\nconformance suite${control ? ' (control)' : ''}: ${verzi} VERDE, ${rosii} ROSU, ${nemas} NEMASURAT/STRICAT`); process.exitCode = rosii ? 1 : nemas ? 2 : 0;