Files
rea/scripts/lib/real-hopper-fixture.mjs
T

210 lines
6.8 KiB
JavaScript

import { createHash } from "node:crypto";
import { readFile, realpath } from "node:fs/promises";
import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
const MANDATORY_FIXTURE_NAMES = [
"c",
"version-v1",
"version-v2",
"objc",
"napi",
"large",
];
const OPTIONAL_FIXTURE_NAMES = ["swift"];
/**
* Bind the real-Hopper semantic verifier to source-owned manifest artifacts.
*
* Every present artifact is distinct and digest-bound. Swift remains optional.
*/
export async function loadRealHopperFixtureTargets(manifestPath) {
const canonicalManifest = await realpath(manifestPath);
const manifest = JSON.parse(await readFile(canonicalManifest, "utf8"));
if (manifest?.schemaVersion !== 1 || !Array.isArray(manifest.fixtures))
throw new Error("Invalid conformance fixture manifest");
const root = dirname(canonicalManifest);
const entries = new Map();
for (const name of MANDATORY_FIXTURE_NAMES)
entries.set(name, fixtureEntry(manifest.fixtures, name));
for (const name of OPTIONAL_FIXTURE_NAMES) {
const matches = manifest.fixtures.filter(
(fixture) => fixture?.name === name,
);
if (matches.length === 1) entries.set(name, matches[0]);
else if (matches.length > 1) throw new Error(`Duplicate fixture ${name}`);
}
const oracle = requireCOracle(entries.get("c")?.expectations?.hopperOracle);
const largeOracle = requireLargeOracle(entries.get("large")?.expectations);
const versionV1Expectations = requireStringArrayExpectations(
entries.get("version-v1"),
"version-v1",
);
const versionV2Expectations = requireStringArrayExpectations(
entries.get("version-v2"),
"version-v2",
);
const objcExpectations = requireStringArrayExpectations(
entries.get("objc"),
"objc",
);
const napiExpectations = requireStringArrayExpectations(
entries.get("napi"),
"napi",
);
const swiftExpectations = entries.has("swift")
? requireStringArrayExpectations(entries.get("swift"), "swift")
: undefined;
const bound = new Map();
for (const [name, entry] of entries)
bound.set(name, await bindFixtureArtifact(root, entry));
requireDistinctArtifacts([...bound.values()]);
const compilers = Object.fromEntries(
[...entries].map(([name, entry]) => [name, requireCompiler(entry, name)]),
);
return {
manifestPath: canonicalManifest,
primary: bound.get("c"),
secondary: bound.get("version-v2"),
large: bound.get("large"),
versionV1: bound.get("version-v1"),
versionV2: bound.get("version-v2"),
objc: bound.get("objc"),
napi: bound.get("napi"),
swift: bound.get("swift"),
oracle,
largeOracle,
versionV1Expectations,
versionV2Expectations,
objcExpectations,
napiExpectations,
swiftExpectations,
compilers,
};
}
function requireCompiler(entry, name) {
const compiler = entry?.compiler;
if (
compiler === null ||
typeof compiler !== "object" ||
typeof compiler.path !== "string" ||
compiler.path.length === 0 ||
typeof compiler.version !== "string" ||
compiler.version.length === 0 ||
!Array.isArray(compiler.arguments) ||
compiler.arguments.some((argument) => typeof argument !== "string")
)
throw new Error(`Fixture ${name} omitted its compiler provenance`);
return {
path: compiler.path,
version: compiler.version,
arguments: [...compiler.arguments],
};
}
function requireCOracle(oracle) {
if (
oracle === null ||
typeof oracle !== "object" ||
typeof oracle.mainProcedure !== "string" ||
typeof oracle.entryProcedure !== "string" ||
typeof oracle.branchProcedure !== "string" ||
typeof oracle.leafProcedure !== "string" ||
typeof oracle.entryString !== "string" ||
typeof oracle.leafString !== "string" ||
typeof oracle.globalName !== "string" ||
[
oracle.mainProcedure,
oracle.entryProcedure,
oracle.branchProcedure,
oracle.leafProcedure,
oracle.entryString,
oracle.leafString,
oracle.globalName,
].some((value) => value.length === 0)
)
throw new Error("C fixture omitted its Hopper semantic oracle");
return oracle;
}
function requireLargeOracle(largeOracle) {
if (
largeOracle === null ||
typeof largeOracle !== "object" ||
typeof largeOracle.symbolPrefix !== "string" ||
largeOracle.symbolPrefix.length === 0 ||
typeof largeOracle.stringPrefix !== "string" ||
largeOracle.stringPrefix.length === 0 ||
!Number.isInteger(largeOracle.symbolCount) ||
largeOracle.symbolCount !== largeOracle.stringCount ||
largeOracle.symbolCount <= 0
)
throw new Error("Large fixture omitted its exact pagination oracle");
return largeOracle;
}
function requireStringArrayExpectations(entry, name) {
const expectations = entry?.expectations;
if (
expectations === null ||
typeof expectations !== "object" ||
Array.isArray(expectations)
)
throw new Error(`Fixture ${name} omitted its expectations`);
const keys = Object.keys(expectations);
if (keys.length === 0)
throw new Error(`Fixture ${name} expectations must be nonempty`);
for (const key of keys) {
const value = expectations[key];
if (!Array.isArray(value) || value.length === 0)
throw new Error(`Fixture ${name} expectation ${key} must be nonempty`);
for (const item of value) {
if (typeof item !== "string" || item.length === 0)
throw new Error(
`Fixture ${name} expectation ${key} must be nonempty strings`,
);
}
}
return expectations;
}
function requireDistinctArtifacts(artifacts) {
if (
new Set(artifacts.map(({ path }) => path)).size !== artifacts.length ||
new Set(artifacts.map(({ sha256 }) => sha256)).size !== artifacts.length
)
throw new Error("Hopper conformance fixtures must be distinct artifacts");
}
function fixtureEntry(fixtures, name) {
const matches = fixtures.filter((fixture) => fixture?.name === name);
if (matches.length !== 1) throw new Error(`Missing fixture ${name}`);
return matches[0];
}
async function bindFixtureArtifact(root, fixture) {
if (
typeof fixture.artifact !== "string" ||
typeof fixture.artifactSha256 !== "string" ||
!/^[0-9a-f]{64}$/u.test(fixture.artifactSha256)
)
throw new Error(`Invalid artifact declaration for ${fixture.name}`);
const path = await realpath(resolve(root, fixture.artifact));
const relation = relative(root, path);
if (
relation === ".." ||
relation.startsWith(`..${sep}`) ||
isAbsolute(relation)
)
throw new Error(`Fixture ${fixture.name} escapes its manifest root`);
const actual = sha256(await readFile(path));
if (actual !== fixture.artifactSha256)
throw new Error(
`Fixture ${fixture.name} digest did not match its manifest`,
);
return { path, sha256: actual };
}
const sha256 = (value) => createHash("sha256").update(value).digest("hex");