387 lines
19 KiB
JavaScript
387 lines
19 KiB
JavaScript
// Verifier for Bloxorz (Node only — no browser).
|
|
//
|
|
// 1. Schema-lints data/bloxorz.json (bounds, bridge/switch/teleport linkage).
|
|
// 2. Re-solves every level fresh from the JSON (independent of whatever
|
|
// genBloxorz.js already asserted at generation time) and checks par.
|
|
// 3. Unit-tests the engine primitives directly against small synthetic
|
|
// levels: tip-over physics, death cases, switches, teleport, walls, and
|
|
// the split/merge mechanic.
|
|
//
|
|
// Usage: node tools/verifyBloxorz.js
|
|
|
|
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import { fileURLToPath } from 'node:url';
|
|
import {
|
|
loadLevel, newState, applyMove, solve, previewRoll, DIR_LIST,
|
|
} from '../src/games/bloxorz/BloxorzLogic.js';
|
|
import {
|
|
EX, EY, depthOf, boxesForBlock, boxCorners, rollPoints, visibleFaces,
|
|
} from '../src/games/bloxorz/BloxorzIso.js';
|
|
|
|
const __dirname = path.dirname(fileURLToPath(import.meta.url));
|
|
const FILE = path.join(__dirname, '../data/bloxorz.json');
|
|
|
|
let passes = 0;
|
|
let failures = 0;
|
|
function check(name, cond, detail = '') {
|
|
if (cond) { passes += 1; console.log(` ok ${name}`); }
|
|
else { failures += 1; console.error(`FAIL ${name}${detail ? ` — ${detail}` : ''}`); }
|
|
}
|
|
|
|
// ── Bank checks ──────────────────────────────────────────────────────────────
|
|
|
|
const raw = JSON.parse(fs.readFileSync(FILE, 'utf8'));
|
|
const levels = raw.levels ?? [];
|
|
console.log(`[verify] ${FILE}`);
|
|
console.log(`[verify] ${levels.length} levels`);
|
|
|
|
check('bank has 36 levels', levels.length === 36, `found ${levels.length}`);
|
|
|
|
const actPars = [];
|
|
for (const def of levels) {
|
|
const inBounds = (x, y) => x >= 0 && x < def.cols && y >= 0 && y < def.rows;
|
|
|
|
let boundsOk = inBounds(def.start.x, def.start.y) && inBounds(def.goal.x, def.goal.y);
|
|
const bridgeIds = new Set();
|
|
const switchLinks = new Map(); // bridgeId -> Set of switch modes
|
|
const teleportCounts = new Map();
|
|
let splitCount = 0;
|
|
|
|
for (const t of def.tiles) {
|
|
if (!inBounds(t.x, t.y)) boundsOk = false;
|
|
if (t.type === 'bridge') bridgeIds.add(t.bridgeId);
|
|
if (t.type === 'switch') {
|
|
for (const bid of t.linkedBridgeIds) {
|
|
if (!switchLinks.has(bid)) switchLinks.set(bid, new Set());
|
|
switchLinks.get(bid).add(t.mode);
|
|
}
|
|
}
|
|
if (t.type === 'switch' && !['standing', 'any', 'lying'].includes(t.requireOrientation)) boundsOk = false;
|
|
if (t.type === 'teleport') teleportCounts.set(t.teleportId, (teleportCounts.get(t.teleportId) ?? 0) + 1);
|
|
if (t.split) splitCount++;
|
|
}
|
|
check(`L${def.level}: all tiles/start/goal in bounds`, boundsOk);
|
|
|
|
let bridgesLinked = true;
|
|
for (const bid of bridgeIds) if (!switchLinks.has(bid)) bridgesLinked = false;
|
|
check(`L${def.level}: every bridge has a linking switch`, bridgesLinked);
|
|
|
|
let noMixedModes = true;
|
|
for (const modes of switchLinks.values()) if (modes.size > 1) noMixedModes = false;
|
|
check(`L${def.level}: no bridge mixes toggle+momentary switches`, noMixedModes);
|
|
|
|
let teleportsPaired = true;
|
|
for (const count of teleportCounts.values()) if (count !== 2) teleportsPaired = false;
|
|
check(`L${def.level}: every teleporter id appears exactly twice`, teleportsPaired);
|
|
|
|
check(`L${def.level}: split-flagged tile count is even`, splitCount % 2 === 0, `count=${splitCount}`);
|
|
|
|
// Fresh solver re-run, independent of genBloxorz.js's own check at write time.
|
|
const compiled = loadLevel(def);
|
|
const { moves } = solve(compiled, { maxStates: 300000 });
|
|
check(`L${def.level} "${def.name}": solvable`, moves >= 0, `solve() returned moves=${moves}`);
|
|
check(`L${def.level}: par matches fresh solve`, moves === def.par, `par=${def.par} solve=${moves}`);
|
|
|
|
actPars.push(def.par);
|
|
}
|
|
|
|
// The bank is built as six six-level acts that have to get harder. Compare act
|
|
// averages rather than adjacent levels, so an act can still open with a
|
|
// breather without the whole curve flattening out.
|
|
const actAvg = [];
|
|
for (let i = 0; i < actPars.length; i += 6) {
|
|
const slice = actPars.slice(i, i + 6);
|
|
actAvg.push(slice.reduce((a, b) => a + b, 0) / slice.length);
|
|
}
|
|
for (let i = 1; i < actAvg.length; i++) {
|
|
check(`act ${i + 1} is harder than act ${i}`, actAvg[i] > actAvg[i - 1],
|
|
`${actAvg[i - 1].toFixed(1)} -> ${actAvg[i].toFixed(1)}`);
|
|
}
|
|
check('no two levels share a name', new Set(levels.map((l) => l.name)).size === levels.length);
|
|
|
|
// ── Engine unit tests ────────────────────────────────────────────────────────
|
|
|
|
function synthLevel(tiles, start, cols = 12, rows = 12) {
|
|
return loadLevel({ cols, rows, start, goal: { x: 0, y: 0 }, tiles });
|
|
}
|
|
const floor = (x, y, extra = {}) => ({ x, y, type: 'floor', ...extra });
|
|
const wall = (x, y) => ({ x, y, type: 'wall' });
|
|
const goal = (x, y) => ({ x, y, type: 'goal' });
|
|
const fragileT = (x, y) => ({ x, y, type: 'fragile' });
|
|
const bridgeT = (x, y, id, open = false) => ({ x, y, type: 'bridge', bridgeId: id, initiallyOpen: open });
|
|
const softSw = (x, y, id, ids) => ({ x, y, type: 'switch', switchId: id, linkedBridgeIds: ids, requireOrientation: 'any', mode: 'toggle' });
|
|
const heavySw = (x, y, id, ids) => ({ x, y, type: 'switch', switchId: id, linkedBridgeIds: ids, requireOrientation: 'standing', mode: 'toggle' });
|
|
const holdPad = (x, y, id, ids) => ({ x, y, type: 'switch', switchId: id, linkedBridgeIds: ids, requireOrientation: 'lying', mode: 'momentary' });
|
|
const tp = (x, y, id) => ({ x, y, type: 'teleport', teleportId: id });
|
|
|
|
// -- Tip-over physics: standing -> lying --
|
|
{
|
|
const lvl = synthLevel([floor(0, 0), floor(1, 0), floor(2, 0), floor(0, 1), floor(0, 2)], { x: 0, y: 0, orient: 'up' });
|
|
let s = newState(lvl);
|
|
applyMove(lvl, s, 'right');
|
|
check('standing rolls right into lying-x at [1,2]', s.block.mode === 'joined' && s.block.orient === 'x' && s.block.x === 1 && s.block.y === 0, JSON.stringify(s.block));
|
|
|
|
s = newState(lvl);
|
|
applyMove(lvl, s, 'down');
|
|
check('standing rolls down into lying-y at [1,2]', s.block.orient === 'y' && s.block.x === 0 && s.block.y === 1, JSON.stringify(s.block));
|
|
}
|
|
|
|
// -- Tip-over physics: lying -> standing (along axis) and lying -> lying (perpendicular shift) --
|
|
{
|
|
const lvl = synthLevel([
|
|
floor(1, 0), floor(2, 0), floor(3, 0), floor(4, 0), floor(2, 1), floor(3, 1),
|
|
], { x: 1, y: 0, orient: 'up' });
|
|
|
|
let s = newState(lvl);
|
|
applyMove(lvl, s, 'right'); // standing1 -> lying[2,3]
|
|
applyMove(lvl, s, 'right'); // lying[2,3] -> standing (anchor2+2=4)
|
|
check('lying-x tips right back to standing (x+2)', s.block.orient === 'up' && s.block.x === 4, JSON.stringify(s.block));
|
|
|
|
s = newState(lvl);
|
|
applyMove(lvl, s, 'right'); // standing1 -> lying[2,3]
|
|
applyMove(lvl, s, 'down'); // perpendicular shift: stays lying-x, y+1
|
|
check('lying-x shifts perpendicular (down) without changing orientation', s.block.orient === 'x' && s.block.x === 2 && s.block.y === 1, JSON.stringify(s.block));
|
|
}
|
|
|
|
// -- Falling off the edge is fatal --
|
|
{
|
|
const lvl = synthLevel([floor(0, 0)], { x: 0, y: 0, orient: 'up' });
|
|
const s = newState(lvl);
|
|
const res = applyMove(lvl, s, 'right');
|
|
check('rolling off the platform edge is fatal', res.dead === true && s.status === 'dead');
|
|
}
|
|
|
|
// -- Only a standing landing drops into the goal; lying just bridges it --
|
|
{
|
|
const lvl = synthLevel([floor(0, 0), goal(1, 0), floor(2, 0)], { x: 0, y: 0, orient: 'up' });
|
|
const s = newState(lvl);
|
|
const res = applyMove(lvl, s, 'right'); // lands lying across the goal [1] and floor [2]
|
|
check('a block lying across the goal bridges it instead of falling in',
|
|
res.dead !== true && s.status === 'playing', JSON.stringify(s.block));
|
|
|
|
const lvl1b = synthLevel([floor(0, 0), goal(1, 0)], { x: 0, y: 0, orient: 'up' });
|
|
const s1b = newState(lvl1b);
|
|
const res1b = applyMove(lvl1b, s1b, 'right'); // lying across the goal [1] and void [2]
|
|
check('a lying landing half over the void is still fatal, goal or not', res1b.dead === true);
|
|
|
|
const lvl2 = synthLevel([floor(0, 0), floor(1, 0), floor(2, 0), goal(3, 0)], { x: 0, y: 0, orient: 'up' });
|
|
const s2 = newState(lvl2);
|
|
applyMove(lvl2, s2, 'right'); // standing0 -> lying[1,2]
|
|
applyMove(lvl2, s2, 'right'); // lying[1,2] -> standing3 (goal)
|
|
check('a standing landing exactly on the goal wins', s2.status === 'won');
|
|
}
|
|
|
|
// -- Fragile ground: safe lying, straight through it standing --
|
|
{
|
|
const lvl = synthLevel([floor(0, 0), fragileT(1, 0), fragileT(2, 0), floor(3, 0)], { x: 0, y: 0, orient: 'up' });
|
|
const s = newState(lvl);
|
|
const res = applyMove(lvl, s, 'right'); // lying across both fragile cells
|
|
check('a lying block rests on fragile ground safely', res.dead !== true && s.status === 'playing');
|
|
const res2 = applyMove(lvl, s, 'right'); // lying[1,2] -> standing3 (solid) — fine
|
|
check('rolling off fragile onto solid ground is fine', res2.dead !== true && s.status === 'playing');
|
|
}
|
|
{
|
|
const lvl = synthLevel([floor(0, 0), floor(1, 0), floor(2, 0), fragileT(3, 0), floor(4, 0)], { x: 0, y: 0, orient: 'up' });
|
|
const s = newState(lvl);
|
|
applyMove(lvl, s, 'right'); // standing0 -> lying[1,2]
|
|
const res = applyMove(lvl, s, 'right'); // lying[1,2] -> standing3, upright on fragile
|
|
check('standing upright on fragile ground drops the block', res.dead === true && s.status === 'dead');
|
|
}
|
|
{
|
|
// A lone split cube is half the weight, so it may stand on fragile ground.
|
|
const lvl = synthLevel([floor(0, 0), floor(1, 0), floor(1, 1), fragileT(2, 1)], { x: 0, y: 0, orient: 'up' });
|
|
const s = {
|
|
block: { mode: 'split', a: { x: 0, y: 0 }, b: { x: 1, y: 1 } },
|
|
toggleBridges: new Map(), status: 'playing',
|
|
};
|
|
const res = applyMove(lvl, s, 'right'); // a -> (1,0) solid, b -> (2,1) fragile
|
|
check('a split cube is light enough to stand on fragile ground',
|
|
res.dead !== true && s.status === 'playing' && s.block.mode === 'split', JSON.stringify(s.block));
|
|
}
|
|
|
|
// -- Heavy switch: only counts standing upright on it --
|
|
{
|
|
const lvl = synthLevel([
|
|
floor(0, 0), floor(1, 0), heavySw(2, 0, 's1', ['b1']), bridgeT(3, 0, 'b1', false), floor(4, 0),
|
|
], { x: 0, y: 0, orient: 'up' });
|
|
const s = newState(lvl);
|
|
applyMove(lvl, s, 'right'); // standing0 -> lying[1,2], LYING across the heavy switch
|
|
check('a lying block does not press a heavy switch', s.toggleBridges.get('b1') !== true);
|
|
const res = applyMove(lvl, s, 'right'); // lying[1,2] -> standing3, the still-closed bridge
|
|
check('the heavy-switch bridge is still shut for a lying press', res.dead === true);
|
|
|
|
const lvl2 = synthLevel([
|
|
floor(0, 0), floor(1, 0), heavySw(2, 0, 's1', ['b1']), bridgeT(3, 0, 'b1', false), floor(4, 0),
|
|
floor(2, 1), floor(2, 2), floor(2, 3),
|
|
], { x: 2, y: 3, orient: 'up' });
|
|
const s2 = newState(lvl2);
|
|
applyMove(lvl2, s2, 'up'); // standing (2,3) -> lying (2,1)-(2,2)
|
|
applyMove(lvl2, s2, 'up'); // -> standing on (2,0), the heavy switch
|
|
check('standing upright on a heavy switch opens its bridge',
|
|
s2.block.orient === 'up' && s2.block.y === 0 && s2.toggleBridges.get('b1') === true, JSON.stringify(s2.block));
|
|
}
|
|
|
|
// -- Soft switch: any contact, persistent --
|
|
{
|
|
const lvl = synthLevel([
|
|
floor(0, 0), softSw(1, 0, 's1', ['b1']), floor(2, 0), bridgeT(3, 0, 'b1', false), floor(4, 0),
|
|
], { x: 0, y: 0, orient: 'up' });
|
|
const s = newState(lvl);
|
|
applyMove(lvl, s, 'right'); // standing0 -> lying[1,2], covers the soft switch
|
|
check('soft switch opens its bridge on contact (any orientation)', s.toggleBridges.get('b1') === true);
|
|
const res = applyMove(lvl, s, 'right'); // lying[1,2] -> standing3, onto the now-open bridge
|
|
check('soft-switch bridge stays open for a later crossing', res.dead !== true && s.status === 'playing');
|
|
}
|
|
|
|
// -- Hold pad (momentary): open only while covered, recloses immediately --
|
|
{
|
|
const lvl = synthLevel([
|
|
floor(0, 0), floor(1, 0), holdPad(2, 0, 's1', ['b1']), bridgeT(3, 0, 'b1', false), floor(4, 0), floor(5, 0),
|
|
], { x: 0, y: 0, orient: 'up' });
|
|
const s = newState(lvl);
|
|
applyMove(lvl, s, 'right'); // standing0 -> lying[1,2], covers the hold pad (col2)
|
|
const res = applyMove(lvl, s, 'right'); // lying[1,2] -> standing3, crossing the bridge in the same instant
|
|
check('hold-pad bridge is passable while still covered from the prior landing', res.dead !== true && s.status === 'playing');
|
|
check('hold-pad bridge recloses once the block leaves', s.toggleBridges.get('b1') !== true);
|
|
}
|
|
|
|
// -- Teleport relocates a standing landing --
|
|
{
|
|
const lvl = synthLevel([
|
|
floor(0, 0), floor(1, 0), floor(2, 0), tp(3, 0, 't1'), tp(3, 3, 't1'), floor(4, 3),
|
|
], { x: 0, y: 0, orient: 'up' });
|
|
const s = newState(lvl);
|
|
applyMove(lvl, s, 'right'); // standing0 -> lying[1,2]
|
|
applyMove(lvl, s, 'right'); // lying[1,2] -> standing3 (teleport source) -> relocated to (3,3)
|
|
check('standing on a teleporter relocates to its paired tile', s.block.x === 3 && s.block.y === 3, JSON.stringify(s.block));
|
|
}
|
|
|
|
// -- Split trigger + auto-merge --
|
|
{
|
|
const lvl = synthLevel([
|
|
floor(0, 0), floor(1, 0), floor(2, 0), floor(3, 0),
|
|
floor(0, 0), { x: 4, y: 0, type: 'floor', split: true }, { x: 5, y: 0, type: 'floor', split: true },
|
|
floor(6, 0), floor(7, 0),
|
|
], { x: 0, y: 0, orient: 'up' });
|
|
const s = newState(lvl);
|
|
applyMove(lvl, s, 'right'); // standing0 -> lying[1,2]
|
|
applyMove(lvl, s, 'right'); // lying[1,2] -> standing3
|
|
applyMove(lvl, s, 'right'); // standing3 -> candidate lying[4,5] both split-flagged -> SPLIT
|
|
check('a lying landing on two split-flagged tiles splits the block', s.block.mode === 'split', JSON.stringify(s.block));
|
|
applyMove(lvl, s, 'right'); // both units step +1, become adjacent again -> auto-merge
|
|
check('two adjacent split units auto-merge back into a joined lying block', s.block.mode === 'joined' && s.block.orient === 'x', JSON.stringify(s.block));
|
|
}
|
|
|
|
// -- Wall: illegal move, never fatal --
|
|
{
|
|
const lvl = synthLevel([floor(0, 0), wall(1, 0)], { x: 0, y: 0, orient: 'up' });
|
|
const s = newState(lvl);
|
|
const res = applyMove(lvl, s, 'right');
|
|
check('rolling into a wall is a no-op, not fatal', res.moved === false && s.status === 'playing');
|
|
check('the block does not move when blocked by a wall', s.block.x === 0 && s.block.y === 0 && s.block.orient === 'up');
|
|
}
|
|
|
|
// -- Split units move independently: one blocked by a wall, the other proceeds --
|
|
{
|
|
const lvl = synthLevel([floor(5, 5), wall(6, 5), floor(6, 6), floor(7, 5)], { x: 5, y: 5, orient: 'up' });
|
|
const s = {
|
|
block: { mode: 'split', a: { x: 5, y: 5 }, b: { x: 6, y: 5 } },
|
|
toggleBridges: new Map(), status: 'playing',
|
|
};
|
|
applyMove(lvl, s, 'right');
|
|
const { a, b } = s.block;
|
|
check('a wall-blocked split unit stays put while its partner moves on', a.x === 5 && a.y === 5 && b.x === 7 && b.y === 5, JSON.stringify(s.block));
|
|
}
|
|
|
|
// -- Two cubes can never end up stacked in one cell --
|
|
{
|
|
const lvl = synthLevel([floor(0, 0), floor(1, 0), wall(2, 0)], { x: 0, y: 0, orient: 'up' });
|
|
const s = {
|
|
block: { mode: 'split', a: { x: 0, y: 0 }, b: { x: 1, y: 0 } },
|
|
toggleBridges: new Map(), status: 'playing',
|
|
};
|
|
const res = applyMove(lvl, s, 'right'); // b is wall-blocked, so a can't take its cell
|
|
check('a cube cannot roll into the cell its wall-blocked partner still fills',
|
|
res.moved === false && s.block.a.x === 0 && s.block.b.x === 1, JSON.stringify(s.block));
|
|
}
|
|
|
|
// -- Either split unit falling is fatal for the whole run --
|
|
{
|
|
const lvl = synthLevel([floor(0, 0), floor(1, 0)], { x: 0, y: 0, orient: 'up' });
|
|
const s = {
|
|
block: { mode: 'split', a: { x: 0, y: 0 }, b: { x: 1, y: 0 } },
|
|
toggleBridges: new Map(), status: 'playing',
|
|
};
|
|
const res = applyMove(lvl, s, 'down'); // both units roll off into the void
|
|
check('either split unit falling ends the run', res.dead === true && s.status === 'dead');
|
|
}
|
|
|
|
// ── Renderer geometry (BloxorzIso is Phaser-free, so it runs here) ───────────
|
|
|
|
// The rolling animation is only faithful if a 90-degree tip about the leading
|
|
// ground edge lands the block exactly where the engine says it goes — this is
|
|
// what ties the renderer to the single source of truth.
|
|
{
|
|
const canon = (pts) => pts
|
|
.map((p) => [p.x, p.y, p.z].map((v) => v.toFixed(6)).join(','))
|
|
.sort()
|
|
.join(' | ');
|
|
|
|
for (const orient of ['up', 'x', 'y']) {
|
|
for (const dir of DIR_LIST) {
|
|
const block = { mode: 'joined', orient, x: 5, y: 4 };
|
|
const box = boxesForBlock(block)[0];
|
|
const rolled = canon(rollPoints(boxCorners(box), dir, box, 1));
|
|
const target = canon(boxCorners(boxesForBlock(previewRoll(block, dir))[0]));
|
|
check(`rolling a '${orient}' block ${dir} lands on the engine's pose`, rolled === target);
|
|
}
|
|
}
|
|
|
|
// Rigid body: every edge length is preserved through the whole sweep,
|
|
// including past 90 degrees where the fall animation keeps turning.
|
|
const box = boxesForBlock({ mode: 'joined', orient: 'up', x: 0, y: 0 })[0];
|
|
const start = boxCorners(box);
|
|
const EDGES = [[0, 1], [0, 2], [0, 4], [3, 1], [3, 2], [3, 7], [5, 1], [5, 4], [5, 7], [6, 2], [6, 4], [6, 7]];
|
|
const len = (p, q) => Math.hypot(p.x - q.x, p.y - q.y, p.z - q.z);
|
|
let rigid = true;
|
|
for (const t of [0.13, 0.4, 0.77, 1, 1.6, 2.1]) {
|
|
const pts = rollPoints(start, 'right', box, t);
|
|
for (const [a, b] of EDGES) {
|
|
if (Math.abs(len(start[a], start[b]) - len(pts[a], pts[b])) > 1e-9) rigid = false;
|
|
}
|
|
}
|
|
check('the block stays rigid through the entire roll and tumble', rigid);
|
|
|
|
check('a lying block is one cell tall, a standing block two', (() => {
|
|
const up = boxesForBlock({ mode: 'joined', orient: 'up', x: 0, y: 0 })[0];
|
|
const lying = boxesForBlock({ mode: 'joined', orient: 'x', x: 0, y: 0 })[0];
|
|
return up.z1 === 2 && lying.z1 === 1 && lying.x1 - lying.x0 === 2;
|
|
})());
|
|
|
|
check('split cubes render as two separate inset 1x1x1 pieces', (() => {
|
|
const cubes = boxesForBlock({ mode: 'split', a: { x: 1, y: 1 }, b: { x: 4, y: 1 } });
|
|
return cubes.length === 2 && cubes.every((c) => c.z1 === 1 && c.x1 - c.x0 < 1 && c.x1 - c.x0 > 0.8);
|
|
})());
|
|
|
|
// Painter's algorithm precondition: both grid axes must recede down-screen,
|
|
// otherwise ascending depthOf() no longer draws far tiles first.
|
|
check('projection is non-degenerate', Math.abs(EX.x * EY.y - EX.y * EY.x) > 1e-6);
|
|
check('both grid axes point down-screen (painter order holds)', EX.y > 0 && EY.y > 0);
|
|
check('depthOf increases along both axes', depthOf(1, 0) > depthOf(0, 0) && depthOf(0, 1) > depthOf(0, 0));
|
|
check('the block is not viewed at 45 degrees', Math.abs(EX.y / EX.x) < 0.35);
|
|
|
|
// Convex box: culling alone must leave a non-overlapping set of front faces.
|
|
let faceCountOk = visibleFaces(boxCorners(box)).length === 3;
|
|
for (let t = 0; t <= 2.2; t += 0.05) {
|
|
const n = visibleFaces(rollPoints(start, 'right', box, t)).length;
|
|
if (n < 2 || n > 3) faceCountOk = false;
|
|
}
|
|
check('only front faces are drawn, at every roll angle', faceCountOk);
|
|
}
|
|
|
|
// ── Summary ──────────────────────────────────────────────────────────────────
|
|
|
|
console.log(`[verify] ${passes} passed, ${failures} failed`);
|
|
if (failures > 0) process.exit(1);
|