Files
pplus-core/tests/library-harness.test.mjs
T
alexm 401084bab3
Test / gate (push) Failing after 19m0s
Initial commit
2026-11-12 22:23:54 -05:00

122 lines
7.1 KiB
JavaScript

// SPDX-FileCopyrightText: 2026 Scientific Computing Studio, LLC
// SPDX-License-Identifier: Apache-2.0
// The program a compiled reference of the library is run as (scripts/library.mjs harness): it holds no case. Its
// cases arrive at run time on one line of stdin, so no runner's answer is the compiler working out a call on
// literal arguments while it builds (Mojo folds such a call with arithmetic of its own; built with contraction on,
// its fold does not fuse a multiply-add as the built code does: library/mojo/probes/float-contract-runtime). The
// line carries every value exactly.
import test from 'node:test';
import assert from 'node:assert/strict';
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import { spawnSync } from 'node:child_process';
import { checkMojo } from '../dist/mojo/check.js';
import { runMojo } from '../dist/mojo/interp.js';
import { harness, harnessInput, floatWords, referencePrograms } from '../scripts/library.mjs';
/** Another value of the same type: other numbers, other text, a list one item longer. */
function other(v, t) {
switch (t?.k) {
case 'FLOAT': return Number(v) * 3 + 1.5;
case 'INTEGER': return typeof v === 'bigint' ? v + 7n : Number(v) + 7;
case 'BOOL': return !v;
case 'CHAR': return v === 'Q' ? 'R' : 'Q';
case 'STRING': return `${v}x y`;
case 'LIST': case 'ARRAY': { const xs = Array.isArray(v) ? v : v?.data ?? []; return [...xs.map((x) => other(x, t.of)), other(xs[0] ?? (t.of.k === 'STRING' ? '' : 0), t.of)]; }
default: throw new Error(`no other value for ${t?.k}`);
}
}
test('a compiled reference\'s program is the same whatever its cases are: they arrive on stdin', async () => {
const programs = (await referencePrograms()).filter((p) => p.ref.lang === 'mojo' || p.ref.lang === 'c');
assert.ok(programs.filter((p) => p.ref.lang === 'mojo').length >= 17, 'every Mojo reference');
assert.ok(programs.filter((p) => p.ref.lang === 'c').length >= 4, 'every C reference');
for (const p of programs) {
const id = `${p.id} ${p.ref.lang}/${p.ref.level}`;
const src = p.make();
const changed = p.calls.map((c) => ({ args: c.args.map((v, i) => other(v, p.sub.params[i].type)) }));
assert.equal(harness(p.ref.lang, p.ref, p.fname, p.sub, changed), src, `${id}: the program changes with the cases' arguments, so they are written into it`);
assert.equal(harness(p.ref.lang, p.ref, p.fname, p.sub, p.calls.slice(0, 1)), src, `${id}: the program changes with the number of cases`);
assert.notEqual(harnessInput(p.ref.lang, p.sub, changed), p.input(), `${id}: the input line does not carry the arguments`);
assert.match(p.input(), new RegExp(`^${p.calls.length} .* end\\n$`), id);
assert.ok(src.includes(p.ref.source.replace(/\s+$/, '')), `${id}: the reference's own text is in its program unchanged`);
}
});
test('a FLOAT is sent as m and e with x = m * 2^e exactly, m odd and below 2^53', () => {
const dv = new DataView(new ArrayBuffer(8));
const xs = [0.1, 1e-16, 1e300, 5e-324, 2.2250738585072014e-308, -1.5, 1, 2 ** 53 + 2, Number.MAX_VALUE];
for (let i = 0; i < 2000; i++) { dv.setUint32(0, (Math.random() * 2 ** 32) >>> 0); dv.setUint32(4, (Math.random() * 2 ** 32) >>> 0); const x = dv.getFloat64(0); if (Number.isFinite(x)) xs.push(x); }
for (const x of xs) {
const [m, e] = floatWords(x);
const big = BigInt(m);
assert.ok((big < 0n ? -big : big) < 2n ** 53n && (big % 2n !== 0n), `${x}: m = ${m}`);
assert.equal(Number(big) * 2 ** Number(e), x, `${x}: ${m} * 2^${e}`);
}
assert.deepEqual(floatWords(-0), ['-0', '0']);
assert.deepEqual(floatWords(Infinity), ['1', '1024']);
assert.throws(() => floatWords(NaN));
});
// A routine taking every kind of argument a reference can, and cases with the values a line could mangle
const EVERY = { params: ['FLOAT', 'INTEGER', 'BOOL', 'STRING', { k: 'LIST', of: { k: 'FLOAT' } }, { k: 'LIST', of: { k: 'STRING' } }].map((k) => ({ type: typeof k === 'string' ? { k } : k })), returns: { k: 'STRING' } };
const CASES = [
{ args: [0.1, -5, true, 'a b', [1e-16, -0, 5e-324], ['', '100%', 'x%20y']] },
{ args: [1e300, 4611686018427387904n, false, '', [], ['tab\there', 'end']] },
{ args: [-Infinity, 0, true, ' ', [2.5], []] },
];
test('core\'s Mojo interpreter runs a harness with every kind of argument and gets each value back exactly', () => {
const ref = { source: `def every(x: Float64, n: Int, b: Bool, s: String, xs: List[Float64], ss: List[String]) -> String:
var out = String(x) + "|" + String(n) + "|" + String(b) + "|[" + s + "]|"
for i in range(len(xs)):
out += String(xs[i]) + ","
out += "|"
for i in range(len(ss)):
out += "[" + ss[i] + "]"
return out
` };
const src = harness('mojo', ref, 'every', EVERY, CASES);
const ck = checkMojo(src);
assert.deepEqual(ck.diagnostics.filter((d) => d.severity === 'error').map((d) => `L${d.line} ${d.message}`), []);
const run = runMojo(ck.module, src, { input: [harnessInput('mojo', EVERY, CASES).replace(/\n$/, '')], maxSteps: 400000 });
assert.ok(!run.refused, `the interpreter declines ${run.refused}`);
assert.equal(run.exitCode, 0, run.stdout);
assert.equal(run.stdout, [
'0.1|-5|True|[a b]|1e-16,-0.0,5e-324,|[][100%][x%20y]',
'1e+300|4611686018427387904|False|[]||[tab\there][end]',
'-inf|0|True|[ ]|2.5,|',
].join('\n') + '\n');
// a line that holds more or fewer words than its cases announce stops the program
const short = runMojo(ck.module, src, { input: ['1 1 0'], maxSteps: 400000 });
assert.notEqual(short.exitCode, 0);
});
test('a C harness gets each value back exactly, at -O0 and -O2', (t) => {
if (spawnSync('cc', ['--version']).status !== 0) { assert.ok(!process.env.CI, 'cc is not installed, and CI must run this'); t.skip('no cc'); return; }
const sub = { params: ['FLOAT', 'INTEGER', 'STRING', 'CHAR', { k: 'LIST', of: { k: 'FLOAT' } }].map((k) => ({ type: typeof k === 'string' ? { k } : k })), returns: { k: 'INTEGER' } };
const ref = { source: `long every(double x, long n, const char *s, char c, const double *xs, long count) {
printf("%.17g %ld [%s] %c", x, n, s, c);
for (long i = 0; i < count; i++) printf(" %.17g", xs[i]);
printf(" | ");
return count;
}
` };
const cases = [
{ args: [0.1, -5, 'a b%', 'Z', [1e-16, -0, 5e-324]] },
{ args: [-Infinity, 4611686018427387904n, '', ' ', []] },
];
const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pplus-harness-'));
try {
fs.writeFileSync(path.join(dir, 'every.c'), harness('c', ref, 'every', sub, cases));
for (const level of ['-O0', '-O2']) {
const c = spawnSync('cc', ['-std=c11', '-Wall', '-Wextra', '-Werror', level, '-o', path.join(dir, 'every'), path.join(dir, 'every.c'), '-lm'], { encoding: 'utf8' });
assert.equal(c.status, 0, c.stderr);
const r = spawnSync(path.join(dir, 'every'), [], { input: harnessInput('c', sub, cases), encoding: 'utf8' });
assert.equal(r.status, 0, r.stderr);
assert.equal(r.stdout, '0.10000000000000001 -5 [a b%] Z 9.9999999999999998e-17 -0 4.9406564584124654e-324 | 3\n-inf 4611686018427387904 [] | 0\n', level);
}
} finally { fs.rmSync(dir, { recursive: true, force: true }); }
});