findings(E-10..E-22): fix the defects a code review found in the E-1..E-9 work
A review of the group-E fixes found 13 further defects; ten were introduced by
those fixes, two pre-existed and were merely relocated, one is deferred.
Services / transport
E-10 retireWorker synthesized no bg/exit frame, so sharedspice's s_bgRunning
mirror stayed latched true after a mid-run worker death: Run stayed
disabled and the promised fresh-worker restart was unreachable for the
whole session. Retirement now dispatches a synthetic controlled-exit
straight to the installed handler (never through dispatchEvt — a
fabricated frame must not touch the credit ledger). Driving the repro
exposed two further defects, both fixed here: a replacement worker
trapped on pre-init engine reads, and the rerun's cm_input_path/circ hit
that uninitialized engine before KiCad's validate() re-init (the native
flow assumes a crashed engine survives in-process — true for the dll,
false for a dead worker). Reads now answer their empty shapes pre-init,
writes lazy-init, and init is idempotent per worker engine.
E-19 dispatchEvt acked only AFTER handler(evt) returned, and the sharedspice
client deliberately rethrows non-trap errors — so each throw leaked one
unit of the 64-frame credit window until the stream died with a
misattributed "transport exceeded". The ack moves to a finally in both
service copies; the throw still propagates (the trap machinery needs it).
E-20 the oversize-line path promises to transfer the accepted prefix, but
with the window full that flush only DEFERS, and stopEventStream wiped
the deferred queue — losing the diagnostics that explain the failure.
The terminal notice now carries them as pendingEvents; both hosts
deliver them in order, unacked (the fatal frame is outside the credit
protocol).
E-21 the 30s prefetch deadline discarded every model already collected and
reported nothing. A caller-owned progress sink ships the partials and
the omission reaches the export report. (Awaiting the aborted collection
was rejected: an in-flight source fetch is not abortable — E-4's
original disease.) Plus a serving-candidate memo, so a .wrl ref served
by its .step fallback stops re-probing the miss on every export.
Scheduler
E-14 _terminalizeNativeTrap classified by message substring, so any plain JS
error QUOTING 'Aborted(' or 'out of bounds' permanently bricked a
healthy instance. Now structural only: instanceof RuntimeError plus a
duck-typed name check (verified in this build's glue that abort() throws
a genuine RuntimeError both pre- and post-runtime-init). Module.onAbort
now latches the gate — the authoritative notification, previously
ignored.
E-15 the shim half: _pumpResume gates on terminal (catching wakes already
queued at latch time) and resolveWait refuses on terminal WITHOUT
consuming the entry, so a frame stays visibly parked rather than
resuming inside a trapped module.
E-16 the E-5 handler read the realm-global scheduler at dispatch instead of
its installing module's; also frees the per-line buffer on the non-trap
rethrow path.
E-11 get_vec trusted the worker's res.length over the transferred arrays.
Observed death shape: a 4 GiB std::vector threw an unhandled
std::length_error that exited the editor's main loop. Now clamped, with
the buffers freed on every failure path.
Guardrails (replacing two deferred refactors: e2e→production-code injection and
collapsing the four copies of the worker-lifecycle machinery)
E-18 the source contract asserted comment-string counts — rewording failed
CI while moving a guard outside its #ifdef passed. It now parses the
#ifdef regions and asserts on code.
service-stub-parity.ts pins what the four lifecycle copies must share:
credit-window equality parsed from source, the finally-ack, boot
deadlines, terminal-notice consumption. The transport numbers are now
single-sourced from the worker.
CI actually runs the gates: the web/standalone vitest suites (which had
NEVER run in CI), the reducer, the source contract and the parity tool —
with a NON_PLAYWRIGHT_GATES check so deleting a step re-fails the lint.
E-22 the e2e occ stub's 60s boot watchdog, deleted in a66e109, is restored in
the ngspice-stub shape with a wedgeNextBoot() repro hook.
Every behavioral fix has red-then-green evidence (the reds were captured first).
E-17 (a stale RUNNING cross-stamping the next run's generation under E-6's
transport deferral) is DEFERRED with its analysis recorded — a real fix needs
run identity on the bg frames.
Test hygiene: the dwell lint now requires the mandated ": <why>" and all 47 bare
markers carry their reason; three export-report dwells became modal-lease polls;
exact-ledger assertions became relative deltas; the dead data-wx-dom-id branch,
an unused fault hook and unused receipt plumbing are gone; abort scans, wx
dialog drivers, the sim harness and the vitest FakeWorker are each one copy now.
Bumps kicad and wxwidgets to their findings-group-e tips.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
This commit is contained in:
Istvan Matejcsok
parent
0f21a33216
commit
c421d724b0
48 changed files with 2071 additions and 694 deletions
|
|
@ -58,9 +58,9 @@ test.describe('wxFileDialog Tests', () => {
|
|||
|
||||
// Try all three buttons
|
||||
await clickByLabel(page, 'Open File...');
|
||||
await page.waitForTimeout(300); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(300); // eslint-disable-line -- documented interaction dwell: click commit before the next dialog button click
|
||||
await clickByLabel(page, 'Save File...');
|
||||
await page.waitForTimeout(300); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(300); // eslint-disable-line -- documented interaction dwell: click commit before the next dialog button click
|
||||
await clickByLabel(page, 'Open Multiple...');
|
||||
|
||||
await stableShot(page, 'filedialog-05-all-buttons.png', { fullPage: true });
|
||||
|
|
|
|||
|
|
@ -82,7 +82,7 @@ test.describe('wxSplitterWindow & wxScrolledWindow Tests', () => {
|
|||
await page.mouse.down();
|
||||
await page.mouse.move(sash!.centerX + 100, sash!.centerY, { steps: 5 });
|
||||
await page.mouse.up();
|
||||
await page.waitForTimeout(300); // eslint-disable-line -- documented interaction dwell (splitter drag commit before re-reading sash from registry)
|
||||
await page.waitForTimeout(300); // eslint-disable-line -- documented interaction dwell: splitter drag commit before re-reading sash from registry
|
||||
|
||||
// Get updated sash position after drag
|
||||
const sashAfter = await getSplitterSash(page);
|
||||
|
|
@ -91,7 +91,7 @@ test.describe('wxSplitterWindow & wxScrolledWindow Tests', () => {
|
|||
// Scroll left pane (use position left of sash)
|
||||
await page.mouse.move(sashAfter!.centerX - 100, sashAfter!.centerY);
|
||||
await page.mouse.wheel(0, 50);
|
||||
await page.waitForTimeout(200); // eslint-disable-line -- documented interaction dwell (scroll commit between the two pane scrolls)
|
||||
await page.waitForTimeout(200); // eslint-disable-line -- documented interaction dwell: scroll commit between the two pane scrolls
|
||||
|
||||
// Scroll right pane (use position right of sash)
|
||||
await page.mouse.move(sashAfter!.centerX + 100, sashAfter!.centerY);
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ test.describe('wxMenuBar Tests', () => {
|
|||
for (const label of menuLabels) {
|
||||
const clicked = await clickMenuBarItem(page, label);
|
||||
expect(clicked, `Menu "${label}" should be found and clicked`).toBe(true);
|
||||
await page.waitForTimeout(300); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(300); // eslint-disable-line -- documented interaction dwell: menu open commit between menu-bar clicks
|
||||
}
|
||||
|
||||
await stableShot(page, 'menu-05-all-menus.png', { fullPage: true });
|
||||
|
|
|
|||
|
|
@ -173,9 +173,9 @@ test.describe('Modal dialog border + drag (pcbjam #22)', () => {
|
|||
const startX = tbox!.x + tbox!.width / 2;
|
||||
const startY = tbox!.y + tbox!.height / 2;
|
||||
await page.mouse.move(startX, startY);
|
||||
await page.waitForTimeout(350); // eslint-disable-line -- documented interaction dwell (pointer settle before grabbing the title bar)
|
||||
await page.waitForTimeout(350); // eslint-disable-line -- documented interaction dwell: pointer settle before grabbing the title bar
|
||||
await page.mouse.down();
|
||||
await page.waitForTimeout(150); // eslint-disable-line -- documented interaction dwell (press commit before the drag begins)
|
||||
await page.waitForTimeout(150); // eslint-disable-line -- documented interaction dwell: press commit before the drag begins
|
||||
|
||||
// Drag in many small steps, sampling the modal canvas immediately after each
|
||||
// move. Each move calls setWindowRect, which clears the canvas; the dialog's
|
||||
|
|
@ -257,7 +257,7 @@ test.describe('Modal dialog border + drag (pcbjam #22)', () => {
|
|||
const startY = hbox!.y + hbox!.height / 2;
|
||||
await page.mouse.move(startX, startY);
|
||||
await page.mouse.down();
|
||||
await page.waitForTimeout(120); // eslint-disable-line -- documented interaction dwell (press commit before the resize drag begins)
|
||||
await page.waitForTimeout(120); // eslint-disable-line -- documented interaction dwell: press commit before the resize drag begins
|
||||
|
||||
let minOpaque = 1;
|
||||
let lowFrames = 0;
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ test.describe('DOM-port scrollbars', () => {
|
|||
await page.mouse.down();
|
||||
await page.mouse.move(tx, ty, { steps: 6 });
|
||||
await page.mouse.up();
|
||||
await page.waitForTimeout(150); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(150); // eslint-disable-line -- documented interaction dwell: slider drag commit before the next drag
|
||||
}
|
||||
|
||||
// At least one standalone scrollbar must have reported a non-zero position.
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ test.describe('secondary-frame DOM title bar (drag / close)', () => {
|
|||
const after = await listWindows();
|
||||
const id = after.find((w) => !before.includes(w));
|
||||
expect(id, `${buttonLabel} should open a new window`).toBeTruthy();
|
||||
await page.waitForTimeout(200); // eslint-disable-line -- documented interaction dwell (new-window DOM population settle; no event/registry observable)
|
||||
await page.waitForTimeout(200); // eslint-disable-line -- documented interaction dwell: new-window DOM population settle; no event/registry observable
|
||||
return id as string;
|
||||
}
|
||||
|
||||
|
|
@ -61,14 +61,14 @@ test.describe('secondary-frame DOM title bar (drag / close)', () => {
|
|||
await page.mouse.down();
|
||||
await page.mouse.move(sx, sy + 90, { steps: 10 });
|
||||
await page.mouse.up();
|
||||
await page.waitForTimeout(250); // eslint-disable-line -- documented interaction dwell (title-bar drag commit; no event/registry observable)
|
||||
await page.waitForTimeout(250); // eslint-disable-line -- documented interaction dwell: title-bar drag commit; no event/registry observable
|
||||
const after = await styleRect(winId);
|
||||
return !!before && !!after && (Math.abs(after.top - before.top) > 5 || Math.abs(after.left - before.left) > 5);
|
||||
}
|
||||
|
||||
async function closeViaTitlebar(winId: string): Promise<boolean> {
|
||||
await page.locator(`#${winId} .window-titlebar-close`).click();
|
||||
await page.waitForTimeout(400); // eslint-disable-line -- documented interaction dwell (× close / modal EndModal commit; no event/registry observable)
|
||||
await page.waitForTimeout(400); // eslint-disable-line -- documented interaction dwell: × close / modal EndModal commit; no event/registry observable
|
||||
return page.evaluate((wid) => {
|
||||
const el = document.getElementById(wid);
|
||||
return !el || getComputedStyle(el).display === 'none';
|
||||
|
|
@ -87,7 +87,7 @@ test.describe('secondary-frame DOM title bar (drag / close)', () => {
|
|||
await page.mouse.down();
|
||||
await page.mouse.move(sx + 60, sy + 60, { steps: 10 });
|
||||
await page.mouse.up();
|
||||
await page.waitForTimeout(250); // eslint-disable-line -- documented interaction dwell (se-corner resize drag commit; no event/registry observable)
|
||||
await page.waitForTimeout(250); // eslint-disable-line -- documented interaction dwell: se-corner resize drag commit; no event/registry observable
|
||||
const after = await styleRect(winId);
|
||||
return !!before && !!after
|
||||
&& (after.width - before.width > 20) && (after.height - before.height > 20);
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ test.describe('wxWizard Tests', () => {
|
|||
|
||||
// Let the Next page-transition commit before clicking Back (the Back/Next
|
||||
// buttons persist across pages, so there is no registry delta to poll on).
|
||||
await page.waitForTimeout(200); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(200); // eslint-disable-line -- documented interaction dwell: Next page-transition commit; no registry delta to poll
|
||||
|
||||
// Click Back using element registry
|
||||
const backClicked = await clickByLabel(page, 'Back');
|
||||
|
|
|
|||
|
|
@ -144,9 +144,9 @@ async function loadBoard(page: Page, testLogger: { consoleLogs: string[]; errors
|
|||
|
||||
await page.mouse.click(filenameInput.x, filenameInput.y);
|
||||
// Documented interaction dwells: focus + typed-text registration have no observable signal.
|
||||
await page.waitForTimeout(200); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(200); // eslint-disable-line -- documented interaction dwell: focus registration has no observable signal
|
||||
await page.keyboard.type(pcbFilename);
|
||||
await page.waitForTimeout(300); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(300); // eslint-disable-line -- documented interaction dwell: typed-text registration has no observable signal
|
||||
await page.keyboard.press('Enter');
|
||||
|
||||
const result = await waitForBoardLoaded(page, testLogger, 60000);
|
||||
|
|
@ -215,7 +215,7 @@ test.describe('3D viewer component models', () => {
|
|||
SERVED_REF, { timeout: 120000 });
|
||||
// Let the rest of the model-enumeration ensures flush after the served ref lands —
|
||||
// the total count isn't known up front, so this is a documented settle interval.
|
||||
await page.waitForTimeout(3000); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(3000); // eslint-disable-line -- documented interaction dwell: model-enumeration ensures flush; total count unknown up front
|
||||
|
||||
// --- bridge assertions (run on CI too) ---------------------------------
|
||||
const ensures = await page.evaluate(() => window.__modelEnsures ?? []);
|
||||
|
|
|
|||
|
|
@ -269,13 +269,13 @@ test.describe('3D viewer from pcbnew', () => {
|
|||
// Let the frame-move op (wx_window_move → wxWindow::Move) fully settle before the
|
||||
// next interaction: the DOM style.top updates before the wx-side op completes, so
|
||||
// polling the outcome races the following close click (documented interaction dwell).
|
||||
await page.waitForTimeout(300); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(300); // eslint-disable-line -- documented interaction dwell: frame-move op settle; polling races the close click
|
||||
const afterTop = await styleTop(winId as string);
|
||||
expect(afterTop, 'dragging the title bar should move the 3D viewer frame').not.toBe(beforeTop);
|
||||
|
||||
// Close via the × (wx_window_close → wx Close() → OnCloseWindow).
|
||||
await page.locator(`#${winId} .window-titlebar-close`).click();
|
||||
await page.waitForTimeout(600); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(600); // eslint-disable-line -- documented interaction dwell: wx Close() commit before checking the frame is gone
|
||||
const gone = await page.evaluate((wid) => {
|
||||
const el = document.getElementById(wid);
|
||||
return !el || getComputedStyle(el).display === 'none';
|
||||
|
|
@ -352,7 +352,7 @@ test.describe('3D viewer from pcbnew', () => {
|
|||
await page.mouse.up();
|
||||
// Let the resize op (wx_window_resize → SetSize → relayout + GL canvas resize)
|
||||
// settle before reading widths (documented interaction dwell).
|
||||
await page.waitForTimeout(500); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(500); // eslint-disable-line -- documented interaction dwell: resize + GL canvas relayout settle before reading widths
|
||||
|
||||
const afterFrame = await frameWidth(winId as string);
|
||||
const afterGl = await glWidth();
|
||||
|
|
|
|||
183
tests/kicad/eeschema-sim-recovery.spec.ts
Normal file
183
tests/kicad/eeschema-sim-recovery.spec.ts
Normal file
|
|
@ -0,0 +1,183 @@
|
|||
import { test, expect } from './fixtures';
|
||||
import { clickByTooltip, waitForEditorReady } from '../e2e/utils/element-tracker';
|
||||
import { FATAL_WASM_PATTERNS, findNativeFailure } from './utils/native-failure';
|
||||
import {
|
||||
loadRectifier,
|
||||
openSimulator,
|
||||
runSimulation,
|
||||
waitForRunToolEnabled,
|
||||
} from './utils/sim-harness';
|
||||
|
||||
/**
|
||||
* eeschema simulator worker-death recovery (findings E-10/E-12/E-11): the
|
||||
* promise of the out-of-process engine is that a worker death settles
|
||||
* everything in flight and the next Run transparently boots a fresh worker.
|
||||
* These specs kill (or corrupt) the service at exact points and assert the
|
||||
* simulator UI actually recovers:
|
||||
*
|
||||
* - E-10: a mid-run worker death must unlatch the client's s_bgRunning
|
||||
* mirror (via the service's synthetic controlled-exit) — otherwise the
|
||||
* Run tool's ENABLE(!simRunning) holds "running" forever and the promised
|
||||
* fresh-worker restart is unreachable for the whole session.
|
||||
* - E-12: a run whose transport dies between launch acceptance and its
|
||||
* RUNNING transition delivers its crash-exit completion — the wasm-only
|
||||
* unowned-event drop must not swallow an owned run's only IDLE.
|
||||
* - E-11: a corrupted worker's oversized get_vec length must be clamped to
|
||||
* the actually-transferred arrays — not copied into the editor heap as a
|
||||
* multi-gigabyte read that traps the instance.
|
||||
*/
|
||||
|
||||
test.describe('eeschema simulator worker-death recovery', () => {
|
||||
test.setTimeout(300000);
|
||||
|
||||
test('a mid-run worker death re-enables Run and a rerun succeeds (E-10)', async ({ page, testLogger }) => {
|
||||
await page.goto('/kicad/eeschema.html');
|
||||
await waitForEditorReady(page);
|
||||
await loadRectifier(page);
|
||||
await openSimulator(page);
|
||||
await waitForRunToolEnabled(page);
|
||||
const checkpoint = await page.evaluate(() => {
|
||||
const hooks = (globalThis as any).__ngspiceServiceTestHooks;
|
||||
return hooks.appliedGenerationCheckpoint() as number;
|
||||
});
|
||||
|
||||
// Start a run and inject the worker death while it is live. The check
|
||||
// and the retirement happen in ONE page.evaluate — frames dispatch on
|
||||
// the same main thread, so no finish frame can interleave between the
|
||||
// "still running" check and the kill. Event scans are scoped past any
|
||||
// frame-open activity (workbook plot restoration).
|
||||
const eventFloor = await page.evaluate(
|
||||
() => ((window as any).__ngspiceEvents as unknown[]).length);
|
||||
expect(await clickByTooltip(page, 'Run Simulation', { elementType: 'tool' }),
|
||||
'Run tool').toBe(true);
|
||||
|
||||
// Run accepted: the worker's bg started frame arrived.
|
||||
await expect.poll(
|
||||
() => page.evaluate((floor: number) =>
|
||||
((window as any).__ngspiceEvents as Array<{ kind: string; finished?: boolean }>)
|
||||
.slice(floor)
|
||||
.some((e) => e.kind === 'bg' && e.finished === false), eventFloor),
|
||||
{ message: 'the run must report bg started', timeout: 60000 },
|
||||
).toBe(true);
|
||||
|
||||
const injected = await page.evaluate((floor: number) => {
|
||||
const events = ((window as any).__ngspiceEvents as Array<{
|
||||
kind: string; finished?: boolean }>).slice(floor);
|
||||
const finishSeen = events.some((e) => e.kind === 'bg' && e.finished === true);
|
||||
const retired = (globalThis as any).__ngspiceServiceTestHooks
|
||||
.forceRetire('E-10 repro: worker death mid-run');
|
||||
return { finishSeen, retired };
|
||||
}, eventFloor);
|
||||
expect(injected.finishSeen,
|
||||
'repro window: the run must still be live when the fault is injected').toBe(false);
|
||||
expect(injected.retired, 'the active generation was retired').toBe(true);
|
||||
|
||||
// THE E-10 oracle: without the synthetic controlled-exit the
|
||||
// s_bgRunning mirror stays latched true; and without the worker's
|
||||
// pre-init read guard the crash-recovery finish parks on a vector
|
||||
// pull into the trapped replacement engine — either way this poll
|
||||
// times out with the Run tool disabled forever.
|
||||
await waitForRunToolEnabled(page);
|
||||
|
||||
// The crashed run's completion was delivered (cursor/finish body ran).
|
||||
const crashReceipt = await page.evaluate(async (after: number) => {
|
||||
const hooks = (globalThis as any).__ngspiceServiceTestHooks;
|
||||
return await hooks.waitForAppliedGenerationAfter(after, 60000);
|
||||
}, checkpoint);
|
||||
expect(crashReceipt.generation, 'the crashed run applied its completion')
|
||||
.toBeGreaterThan(checkpoint);
|
||||
|
||||
// The synthetic exit is visible in the event record.
|
||||
const exitSeen = await page.evaluate((floor: number) =>
|
||||
((window as any).__ngspiceEvents as Array<{ kind: string }>)
|
||||
.slice(floor)
|
||||
.some((e) => e.kind === 'exit'), eventFloor);
|
||||
expect(exitSeen, 'a controlled-exit event reached the client').toBe(true);
|
||||
|
||||
// And the promised transparent restart: a full rerun on a fresh
|
||||
// worker generation succeeds end to end.
|
||||
const rerunGeneration = await runSimulation(page);
|
||||
expect(rerunGeneration).toBeGreaterThan(crashReceipt.generation);
|
||||
const generations = await page.evaluate(() =>
|
||||
(globalThis as any).__ngspiceServiceTestHooks.snapshot());
|
||||
expect(generations.retiredGenerations, 'the killed generation was retired')
|
||||
.toContain(1);
|
||||
|
||||
expect(findNativeFailure([...testLogger.consoleLogs, ...testLogger.errors]),
|
||||
'no wasm abort during the recovery').toBeUndefined();
|
||||
});
|
||||
|
||||
test('a launch that dies before RUNNING still delivers its completion (E-12)', async ({ page, testLogger }) => {
|
||||
await page.goto('/kicad/eeschema.html');
|
||||
await waitForEditorReady(page);
|
||||
await loadRectifier(page);
|
||||
await openSimulator(page);
|
||||
await waitForRunToolEnabled(page);
|
||||
|
||||
// Arm: the transport dies on the bg_run launch itself — after the
|
||||
// native side published its run generation, before any RUNNING
|
||||
// transition could fire. The retirement's synthetic exit then
|
||||
// delivers this run's ONLY completion. (The arm keys on bg_run
|
||||
// specifically, so frame-open plot restoration cannot consume it.)
|
||||
const checkpoint = await page.evaluate(() => {
|
||||
const hooks = (globalThis as any).__ngspiceServiceTestHooks;
|
||||
hooks.dieOnNextBgRun();
|
||||
return hooks.appliedGenerationCheckpoint() as number;
|
||||
});
|
||||
|
||||
expect(await clickByTooltip(page, 'Run Simulation', { elementType: 'tool' }),
|
||||
'Run tool').toBe(true);
|
||||
|
||||
// THE E-12 oracle: on the unfixed build the crash-exit IDLE carries
|
||||
// generation 0 (its RUNNING never fired) and is deleted — the owned
|
||||
// run's completion never applies and this receipt times out.
|
||||
const receipt = await page.evaluate(async (after: number) => {
|
||||
const hooks = (globalThis as any).__ngspiceServiceTestHooks;
|
||||
return await hooks.waitForAppliedGenerationAfter(after, 60000);
|
||||
}, checkpoint);
|
||||
expect(receipt.generation, 'the dead launch applied its crash completion')
|
||||
.toBeGreaterThan(checkpoint);
|
||||
|
||||
// Recovery stays intact: a rerun on the replacement generation works.
|
||||
const rerunGeneration = await runSimulation(page);
|
||||
expect(rerunGeneration).toBeGreaterThan(receipt.generation);
|
||||
|
||||
expect(findNativeFailure([...testLogger.consoleLogs, ...testLogger.errors]),
|
||||
'no wasm abort during the recovery').toBeUndefined();
|
||||
});
|
||||
|
||||
test('a corrupted get_vec length is clamped, not copied out of bounds (E-11)', async ({ page, testLogger }) => {
|
||||
await page.goto('/kicad/eeschema.html');
|
||||
await waitForEditorReady(page);
|
||||
await loadRectifier(page);
|
||||
await openSimulator(page);
|
||||
await waitForRunToolEnabled(page);
|
||||
|
||||
// Arm BEFORE the run: the next vector pull reports a ~5e8-element
|
||||
// length while its arrays stay ~101 elements. (Frame-open plot
|
||||
// restoration also pulls vectors; whichever pull the arm hits, the
|
||||
// corrupted answer flows through the same client prepare.)
|
||||
await page.evaluate(() => {
|
||||
(globalThis as any).__ngspiceServiceTestHooks.corruptNextGetVec();
|
||||
});
|
||||
|
||||
// THE E-11 oracle: on the unfixed build the client copies v_length
|
||||
// doubles from the small buffer. Observed death shape on this build:
|
||||
// the 4 GiB std::vector throws an UNHANDLED std::length_error that
|
||||
// exits the editor's main loop — the scheduler shuts down and the
|
||||
// whole session is dead (an OOB trap is the sibling shape). Fixed,
|
||||
// the length clamps to the transferred arrays and the run completes.
|
||||
await runSimulation(page);
|
||||
|
||||
const scheduler = await page.evaluate(() => ({
|
||||
dead: (globalThis as any).__wxScheduler?.dead === true,
|
||||
terminal: (globalThis as any).__wxScheduler?.terminal === true,
|
||||
}));
|
||||
expect(scheduler.dead,
|
||||
'the corrupted vector must not exit the editor main loop').toBe(false);
|
||||
expect(scheduler.terminal, 'the editor instance must not be terminal').toBe(false);
|
||||
const fatal = findNativeFailure([...testLogger.consoleLogs, ...testLogger.errors]);
|
||||
expect(fatal, `no wasm trap from the corrupted vector (patterns: ${
|
||||
FATAL_WASM_PATTERNS.join(', ')})`).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
|
@ -1,15 +1,7 @@
|
|||
import { test, expect } from './fixtures';
|
||||
import * as path from 'path';
|
||||
import { PNG } from 'pngjs';
|
||||
import {
|
||||
clickByTooltip,
|
||||
clickMenuBarItem,
|
||||
clickMenuItemByText,
|
||||
findByTooltip,
|
||||
stableShot,
|
||||
waitForEditorReady,
|
||||
} from '../e2e/utils/element-tracker';
|
||||
import { injectFileIntoMemfs } from './utils/fs-inject';
|
||||
import { stableShot, waitForEditorReady } from '../e2e/utils/element-tracker';
|
||||
import { loadRectifier, openSimulator, runSimulation } from './utils/sim-harness';
|
||||
|
||||
/**
|
||||
* eeschema simulator end-to-end (docs/features/ngspice-split/): the historic
|
||||
|
|
@ -26,116 +18,6 @@ import { injectFileIntoMemfs } from './utils/fs-inject';
|
|||
* run with "unable to find definition of model").
|
||||
*/
|
||||
|
||||
const RECTIFIER_DIR = path.resolve(__dirname, '..', '..',
|
||||
'kicad', 'demos', 'simulation', 'rectifier');
|
||||
const MEMFS_DIR = '/home/kicad/documents/rectifier';
|
||||
const PROJECT_FILES = ['rectifier.kicad_sch', 'rectifier.kicad_pro', 'diode.mod',
|
||||
'rectifier_schlib.kicad_sym', 'sym-lib-table', 'rectifier.wbk'];
|
||||
|
||||
async function loadRectifier(page: import('@playwright/test').Page): Promise<void> {
|
||||
for (const f of PROJECT_FILES)
|
||||
await injectFileIntoMemfs(page, path.join(RECTIFIER_DIR, f), `${MEMFS_DIR}/${f}`);
|
||||
|
||||
await page.evaluate(async (sch: string) => {
|
||||
await (window as any).Module.kicadOpenFile(sch);
|
||||
}, `${MEMFS_DIR}/rectifier.kicad_sch`);
|
||||
|
||||
await expect
|
||||
.poll(async () => page.title(), { timeout: 120000 })
|
||||
.toMatch(/rectifier/i);
|
||||
}
|
||||
|
||||
// Open Inspect → Simulator and return the new top-level window's DOM id.
|
||||
async function openSimulator(page: import('@playwright/test').Page): Promise<string> {
|
||||
const idsBefore = await page.$$eval('#window-container [id^="window-"]',
|
||||
(els) => els.map((e) => e.id));
|
||||
|
||||
expect(await clickMenuBarItem(page, 'Inspect'), 'Inspect menu').toBe(true);
|
||||
await clickMenuItemByText(page, 'Simulator');
|
||||
|
||||
await page.waitForFunction((before: string[]) => {
|
||||
const ids = Array.from(
|
||||
document.querySelectorAll('#window-container [id^="window-"]'),
|
||||
(e) => e.id);
|
||||
return ids.some((id) => !before.includes(id));
|
||||
}, idsBefore, { timeout: 60000 });
|
||||
|
||||
const idsAfter = await page.$$eval('#window-container [id^="window-"]',
|
||||
(els) => els.map((e) => e.id));
|
||||
const simWin = idsAfter.find((id) => !idsBefore.includes(id));
|
||||
expect(simWin, 'simulator window appeared').toBeTruthy();
|
||||
return simWin!;
|
||||
}
|
||||
|
||||
// Run the loaded workbook's analysis and await the exact native run generation
|
||||
// only after its final plot, operating-point, and canvas refresh calls return.
|
||||
async function runSimulation(page: import('@playwright/test').Page): Promise<number> {
|
||||
// The simulator window div appears while the frame ctor is still
|
||||
// suspended in the init RPC; the toolbar registers its tools only after
|
||||
// init completes and the frame first paints. The Run tool's
|
||||
// ENABLE(!simRunning) condition is a wxUpdateUIEvent check, and the WASM
|
||||
// port only reliably re-evaluates those when input events pump the loop —
|
||||
// after a run finishes, the last input was the click that started it, so
|
||||
// nudge the mouse each poll or the toolbar can hold its stale
|
||||
// "running" state forever.
|
||||
await expect
|
||||
.poll(async () => {
|
||||
await page.mouse.move(4, 4);
|
||||
await page.mouse.move(8, 8);
|
||||
const el = await findByTooltip(page, 'Run Simulation', { elementType: 'tool' });
|
||||
return !!el && el.enabled;
|
||||
}, { timeout: 60000 })
|
||||
.toBe(true);
|
||||
|
||||
const generationCheckpoint = await page.evaluate(() => {
|
||||
const hooks = (globalThis as any).__ngspiceServiceTestHooks;
|
||||
if (!hooks || typeof hooks.appliedGenerationCheckpoint !== 'function'
|
||||
|| typeof hooks.waitForAppliedGenerationAfter !== 'function') {
|
||||
throw new Error('exact ngspice applied-generation hooks are missing');
|
||||
}
|
||||
return hooks.appliedGenerationCheckpoint() as number;
|
||||
});
|
||||
|
||||
expect(await clickByTooltip(page, 'Run Simulation', { elementType: 'tool' }),
|
||||
'Run tool').toBe(true);
|
||||
|
||||
const appliedReceipt = await page.evaluate(async (after: number) => {
|
||||
const hooks = (globalThis as any).__ngspiceServiceTestHooks;
|
||||
return await hooks.waitForAppliedGenerationAfter(after, 120000);
|
||||
}, generationCheckpoint);
|
||||
expect(appliedReceipt.generation, 'the clicked run published a newer applied generation')
|
||||
.toBeGreaterThan(generationCheckpoint);
|
||||
|
||||
// The native receipt fires after the final refreshes. Additionally
|
||||
// require the scheduler to hold no parked ngspice wait — a stale
|
||||
// suspended frame here means the finish path leaked a wait. (The codex
|
||||
// line awaited the execution owner's barrier; that machinery does not
|
||||
// exist on the JSPI line, and wait drainage is its observable
|
||||
// equivalent.)
|
||||
await expect.poll(
|
||||
() => page.evaluate(() => {
|
||||
const scheduler = (globalThis as any).__wxScheduler;
|
||||
return scheduler?.pendingWaits?.('ngspice') ?? -1;
|
||||
}),
|
||||
{ message: 'no ngspice wait may stay parked after the applied receipt', timeout: 30000 },
|
||||
).toBe(0);
|
||||
|
||||
// Vector traffic is result validation only. It is deliberately not used as
|
||||
// completion evidence because periodic OnSimRefresh(false) pulls can look
|
||||
// identical to the final pull at the worker boundary.
|
||||
const vectorReceipt = await page.evaluate(() =>
|
||||
((window as any).__ngspiceLog as Array<{
|
||||
sequence: number; kind: string; error?: string; length?: number;
|
||||
}>).find((entry) => entry.kind === 'get_vec_info'
|
||||
&& entry.error === undefined
|
||||
&& (entry.length ?? -1) >= 101) ?? null,
|
||||
);
|
||||
expect(vectorReceipt, 'the applied run returned a non-trivial successful vector')
|
||||
.not.toBeNull();
|
||||
|
||||
return appliedReceipt.generation;
|
||||
}
|
||||
|
||||
function distinctColors(png: PNG): number {
|
||||
const colors = new Set<number>();
|
||||
// 8x8 grid sampling, same spirit as the 3d-viewer render check.
|
||||
|
|
|
|||
|
|
@ -139,9 +139,9 @@ function runLoadPcbTest(demo: DemoCfg): void {
|
|||
await page.mouse.click(filenameInput.x, filenameInput.y);
|
||||
// Small settle so the focus click lands before typing — no JS-observable "input
|
||||
// focused" signal here (documented interaction wait).
|
||||
await page.waitForTimeout(200); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(200); // eslint-disable-line -- documented interaction dwell: focus click commit; no JS-observable focus signal
|
||||
await page.keyboard.type(pcbFilename);
|
||||
await page.waitForTimeout(300); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(300); // eslint-disable-line -- documented interaction dwell: typed-text registration has no observable signal
|
||||
await page.keyboard.press('Enter');
|
||||
|
||||
// ── Wait for the load to complete (no dialogs visible). The
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@ import { test, expect } from './fixtures';
|
|||
import { clickMenuBarItem, clickMenuItem, waitForEditorReady, waitForRenderedByLabel, waitUntil } from '../e2e/utils/element-tracker';
|
||||
import { injectFromSubmodule } from './utils/fs-inject';
|
||||
import { waitForBoardLoaded } from './utils/board-ready';
|
||||
import { clickWxButton, openStepExportDialog, waitForMenuItems, dismissReportDialog } from './utils/wx-dialogs';
|
||||
|
||||
/**
|
||||
* STEP export × 3D model delivery (docs/features/3d-models, 0007): File →
|
||||
|
|
@ -52,19 +53,6 @@ interface ExportCapture {
|
|||
productCount: number;
|
||||
}
|
||||
|
||||
/** Wait for a rendered popup menu to have its items (replaces a fixed post-menu-click sleep). */
|
||||
async function waitForMenuItems(page: Page): Promise<void> {
|
||||
await waitUntil(
|
||||
page,
|
||||
() => {
|
||||
const r = window.wxElementRegistry;
|
||||
if (!r?.findAllRendered) return false;
|
||||
return r.findAllRendered({ elementType: 'menuitem' }).length > 3;
|
||||
},
|
||||
'popup menu items rendered',
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Record every model3d bridge request and serve ALL of them from the fixture —
|
||||
* the delivery side is never the bottleneck in this spec (mirrors the serveAll
|
||||
|
|
@ -92,7 +80,6 @@ async function installModelProviderStub(page: Page): Promise<void> {
|
|||
|
||||
// Mirror models-bridge.ts ensureModelInMemfs: write under the
|
||||
// JS-owned model root, answer with the ABSOLUTE path.
|
||||
// @ts-expect-error — Emscripten FS lives on window
|
||||
const FS = (window as any).FS;
|
||||
const dest = `${stockDir}/${arg}`;
|
||||
FS.mkdirTree(dest.slice(0, dest.lastIndexOf('/')));
|
||||
|
|
@ -149,48 +136,18 @@ async function loadBoard(page: Page, testLogger: { consoleLogs: string[]; errors
|
|||
|
||||
await page.mouse.click(filenameInput.x, filenameInput.y);
|
||||
// Documented interaction dwells: focus + typed-text registration have no observable signal.
|
||||
await page.waitForTimeout(200); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(200); // eslint-disable-line -- documented interaction dwell: focus registration has no observable signal
|
||||
await page.keyboard.type(pcbFilename);
|
||||
await page.waitForTimeout(300); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(300); // eslint-disable-line -- documented interaction dwell: typed-text registration has no observable signal
|
||||
await page.keyboard.press('Enter');
|
||||
|
||||
const result = await waitForBoardLoaded(page, testLogger, 60000);
|
||||
console.log(`[TEST] ${DEMO.name} board-ready result: ${result}`);
|
||||
}
|
||||
|
||||
/** Click a visible wx button by label; returns whether it was found. */
|
||||
async function clickWxButton(page: Page, label: string): Promise<boolean> {
|
||||
const pos = await page.evaluate((wanted: string) => {
|
||||
const registry = window.wxElementRegistry;
|
||||
if (!registry) return null;
|
||||
const el = registry.findAll({ visible: true })
|
||||
.find((e) => (e.label === wanted || e.label === `&${wanted}`)
|
||||
&& (e.typeName ?? '').includes('Button'));
|
||||
return el ? { x: el.centerX, y: el.centerY } : null;
|
||||
}, label);
|
||||
if (!pos) return false;
|
||||
await page.mouse.click(pos.x, pos.y);
|
||||
return true;
|
||||
}
|
||||
|
||||
/** Drive File → Export → STEP through the (unchanged) dialog; return the capture. */
|
||||
async function runStepExport(page: Page): Promise<{ exp: ExportCapture; ensures: Array<{ op: string; arg: string }> }> {
|
||||
expect(await clickMenuBarItem(page, 'File'), 'File menu').toBe(true);
|
||||
await waitForMenuItems(page);
|
||||
await waitForRenderedByLabel(page, 'Export', { elementType: 'menuitem' });
|
||||
expect(await clickMenuItem(page, 'Export'), 'Export submenu').toBe(true);
|
||||
// Wait for the SUBMENU's item — waitForMenuItems(>3) is satisfied by
|
||||
// the still-rendered File menu items before the submenu paints.
|
||||
await waitForRenderedByLabel(page, 'STEP/GLB/BREP/XAO/PLY/STL...', { elementType: 'menuitem' });
|
||||
expect(await clickMenuItem(page, 'STEP/GLB/BREP/XAO/PLY/STL...'),
|
||||
'STEP export menu item').toBe(true);
|
||||
|
||||
await page.waitForFunction(() => {
|
||||
const registry = window.wxElementRegistry;
|
||||
return !!registry && registry.findAll({ visible: true })
|
||||
.some((el) => (el.label === 'Export' || el.label === '&Export')
|
||||
&& (el.typeName ?? '').includes('Button'));
|
||||
}, null, { timeout: 20000 });
|
||||
await openStepExportDialog(page);
|
||||
|
||||
expect(await clickWxButton(page, 'Export'), 'Export button click').toBe(true);
|
||||
|
||||
|
|
@ -258,10 +215,9 @@ test.describe('STEP export × 3D model delivery', () => {
|
|||
for (const f of missing.lib.slice(0, 5)) console.log(`[TEST] missing lib: ${f}`);
|
||||
for (const f of missing.project) console.log(`[TEST] missing project: ${f}`);
|
||||
|
||||
// Dismiss the export report dialog (its appearance after the worker
|
||||
// returns has no distinct registry signal to poll).
|
||||
await page.waitForTimeout(1000); // eslint-disable-line -- documented interaction dwell
|
||||
await clickWxButton(page, 'OK');
|
||||
// Dismiss the export report dialog via its modal lease (the export
|
||||
// dialog holds 1; the report raises it to 2).
|
||||
await dismissReportDialog(page, 1, 'export report');
|
||||
|
||||
expect(testLogger.errors, 'no page errors during the export flow').toEqual([]);
|
||||
});
|
||||
|
|
|
|||
|
|
@ -2,22 +2,10 @@ import type { Page } from '@playwright/test';
|
|||
import * as fs from 'fs';
|
||||
import * as path from 'path';
|
||||
import { test, expect } from './fixtures';
|
||||
import { clickMenuBarItem, clickMenuItem, waitForEditorReady, waitForRenderedByLabel, waitUntil, stableShot, settledShot } from '../e2e/utils/element-tracker';
|
||||
import { waitForEditorReady, stableShot, settledShot } from '../e2e/utils/element-tracker';
|
||||
import { injectFromSubmodule } from './utils/fs-inject';
|
||||
import { openBoardProgrammatically } from './utils/board-ready';
|
||||
|
||||
/** Wait for a rendered popup menu to have its items (replaces a fixed post-menu-click sleep). */
|
||||
async function waitForMenuItems(page: Page): Promise<void> {
|
||||
await waitUntil(
|
||||
page,
|
||||
() => {
|
||||
const r = window.wxElementRegistry;
|
||||
if (!r?.findAllRendered) return false;
|
||||
return r.findAllRendered({ elementType: 'menuitem' }).length > 3;
|
||||
},
|
||||
'popup menu items rendered',
|
||||
);
|
||||
}
|
||||
import { findWxButton, clickWxButton, openStepExportDialog, dismissReportDialog } from './utils/wx-dialogs';
|
||||
|
||||
/**
|
||||
* STEP export through the occ_service worker (docs/features/occ-split/):
|
||||
|
|
@ -58,59 +46,6 @@ async function loadBoard(page: Page, testLogger: { consoleLogs: string[]; errors
|
|||
console.log(`[TEST] ${DEMO.name} board-ready result: ${result}`);
|
||||
}
|
||||
|
||||
type WxButtonTarget = { x: number; y: number; domId: number | null };
|
||||
|
||||
/** Resolve one visible wx button to its stable DOM identity and fallback point. */
|
||||
async function findWxButton(page: Page, label: string): Promise<WxButtonTarget | null> {
|
||||
return page.evaluate((wanted: string) => {
|
||||
const registry = window.wxElementRegistry;
|
||||
if (!registry) return null;
|
||||
const el = registry.findAll({ visible: true })
|
||||
.find((e) => (e.label === wanted || e.label === `&${wanted}`)
|
||||
&& (e.typeName ?? '').includes('Button'));
|
||||
// domId is present only for DOM-backed controls on lines that expose
|
||||
// it; this line's registry may omit it — the coordinate fallback in
|
||||
// clickWxButtonTarget is the supported path then.
|
||||
const domId = (el as { domId?: number } | undefined)?.domId;
|
||||
return el
|
||||
? { x: el.centerX, y: el.centerY, domId: domId && domId > 0 ? domId : null }
|
||||
: null;
|
||||
}, label);
|
||||
}
|
||||
|
||||
async function clickWxButtonTarget(page: Page, target: WxButtonTarget): Promise<void> {
|
||||
if (target.domId) {
|
||||
await page.locator(`[data-wx-dom-id="${target.domId}"]`).click();
|
||||
return;
|
||||
}
|
||||
|
||||
await page.mouse.click(target.x, target.y);
|
||||
}
|
||||
|
||||
/** Click a visible wx button by label; returns whether it was found. */
|
||||
async function clickWxButton(page: Page, label: string): Promise<boolean> {
|
||||
const target = await findWxButton(page, label);
|
||||
if (!target) return false;
|
||||
await clickWxButtonTarget(page, target);
|
||||
return true;
|
||||
}
|
||||
|
||||
async function openStepExportDialog(page: Page): Promise<void> {
|
||||
expect(await clickMenuBarItem(page, 'File'), 'File menu').toBe(true);
|
||||
await waitForMenuItems(page);
|
||||
await waitForRenderedByLabel(page, 'Export', { elementType: 'menuitem' });
|
||||
expect(await clickMenuItem(page, 'Export'), 'Export submenu').toBe(true);
|
||||
await waitForRenderedByLabel(page, 'STEP/GLB/BREP/XAO/PLY/STL...', { elementType: 'menuitem' });
|
||||
expect(await clickMenuItem(page, 'STEP/GLB/BREP/XAO/PLY/STL...'),
|
||||
'STEP export menu item').toBe(true);
|
||||
await page.waitForFunction(() => {
|
||||
const registry = window.wxElementRegistry;
|
||||
return !!registry && registry.findAll({ visible: true })
|
||||
.some((el) => (el.label === 'Export' || el.label === '&Export')
|
||||
&& (el.typeName ?? '').includes('Button'));
|
||||
}, null, { timeout: 20000 });
|
||||
}
|
||||
|
||||
test.describe('OCC export via occ_service worker', () => {
|
||||
test.describe.configure({ mode: 'serial' });
|
||||
test.setTimeout(240000);
|
||||
|
|
@ -161,11 +96,9 @@ test.describe('OCC export via occ_service worker', () => {
|
|||
expect(occFetches.length, 'occ_service was fetched lazily by the export')
|
||||
.toBeGreaterThan(0);
|
||||
|
||||
// Dismiss the "Export complete" report dialog if present. Its appearance after
|
||||
// the worker returns has no distinct registry signal to poll — a short documented
|
||||
// dwell, then click OK if present.
|
||||
await page.waitForTimeout(1000); // eslint-disable-line -- documented interaction dwell
|
||||
await clickWxButton(page, 'OK');
|
||||
// Dismiss the "Export complete" report dialog: it opens on top of the
|
||||
// export dialog's modal lease (1 → 2), which IS its observable signal.
|
||||
await dismissReportDialog(page, 1, 'export complete');
|
||||
|
||||
await stableShot(page, 'occ-export-done.png');
|
||||
});
|
||||
|
|
@ -243,14 +176,14 @@ test.describe('OCC export via occ_service worker', () => {
|
|||
expect(failed.service.maxPending,
|
||||
'two requests must coexist in one generation; worker requests are not serialized')
|
||||
.toBeGreaterThanOrEqual(2);
|
||||
expect(failed.service.requestsStarted,
|
||||
'the direct probe and one native export must be the only provider entries').toBe(2);
|
||||
expect(failed.service.requestsPosted,
|
||||
'both failed-generation requests must reach the real worker transport').toBe(2);
|
||||
'every provider entry must reach the real worker transport')
|
||||
.toBe(failed.service.requestsStarted);
|
||||
expect(failed.service.workerGenerationsStarted,
|
||||
'the two parallel requests must share one worker generation').toEqual([1]);
|
||||
'the two parallel requests must share one worker generation').toHaveLength(1);
|
||||
expect(failed.service.pending, 'fail-all must drain the failed generation').toBe(0);
|
||||
expect(failed.service.retiredGenerations, 'generation 1 must be retired').toEqual([1]);
|
||||
expect(failed.service.retiredGenerations, 'the shared generation must be retired')
|
||||
.toContain(failed.service.workerGenerationsStarted[0]);
|
||||
expect(failed.service.activeGeneration, 'the failed slot must be cleared').toBeNull();
|
||||
expect(failed.service.armed, 'the one-shot fault must be consumed').toBe(false);
|
||||
console.log(`[TEST-OCC] native fault dialog labels: ${JSON.stringify(failed.labels)}`);
|
||||
|
|
@ -260,9 +193,6 @@ test.describe('OCC export via occ_service worker', () => {
|
|||
// turning the handback race into a click on some replacement control.
|
||||
const retryExport = await findWxButton(page, 'Export');
|
||||
expect(retryExport, 'the original parent Export button must remain registered').not.toBeNull();
|
||||
// On this line the export dialog's buttons may be canvas-rendered
|
||||
// (domId null); clickWxButtonTarget's coordinate fallback is the
|
||||
// supported path, so only the captured geometry must be sane.
|
||||
expect(retryExport!.x, 'the retry target has stable geometry').toBeGreaterThan(0);
|
||||
expect(retryExport!.y, 'the retry target has stable geometry').toBeGreaterThan(0);
|
||||
|
||||
|
|
@ -283,9 +213,10 @@ test.describe('OCC export via occ_service worker', () => {
|
|||
).toBe(1);
|
||||
|
||||
// The export dialog remains open. Its next request must create a fresh
|
||||
// generation and complete through the actual OCC module.
|
||||
// generation and complete through the actual OCC module. Reuse the
|
||||
// captured geometry so a re-query can't land on a replacement control.
|
||||
if (!retryExport) throw new Error('parent Export button disappeared before retry');
|
||||
await clickWxButtonTarget(page, retryExport);
|
||||
await page.mouse.click(retryExport.x, retryExport.y);
|
||||
await expect.poll(
|
||||
() => page.evaluate(() => (globalThis as any)
|
||||
.__occServiceTestHooks.snapshot().requestsStarted),
|
||||
|
|
@ -321,16 +252,22 @@ test.describe('OCC export via occ_service worker', () => {
|
|||
.toBeGreaterThan(10_000);
|
||||
expect(recovered.service.activeGeneration, 'retry must own a replacement generation').toBe(2);
|
||||
expect(recovered.service.requestsStarted,
|
||||
'the parent retry must add exactly one provider entry').toBe(3);
|
||||
'the parent retry must add exactly one provider entry')
|
||||
.toBe(failed.service.requestsStarted + 1);
|
||||
expect(recovered.service.requestsPosted,
|
||||
'the parent retry must post exactly once to the replacement worker').toBe(3);
|
||||
'the parent retry must post exactly once to the replacement worker')
|
||||
.toBe(failed.service.requestsPosted + 1);
|
||||
expect(recovered.service.workerGenerationsStarted,
|
||||
'the retry must create exactly one replacement generation').toEqual([1, 2]);
|
||||
'the retry must create exactly one replacement generation')
|
||||
.toHaveLength(failed.service.workerGenerationsStarted.length + 1);
|
||||
expect(recovered.service.workerGenerationsStarted,
|
||||
'the replacement generation must be the active one').toContain(2);
|
||||
expect(recovered.service.pending, 'replacement generation must quiesce').toBe(0);
|
||||
expect(recovered.schedulerDead, 'the worker failure must not terminalize the editor').toBe(false);
|
||||
expect(recovered.occWaits, 'the replacement native OCC wait must quiesce').toBe(0);
|
||||
|
||||
await page.waitForTimeout(1000); // eslint-disable-line -- documented interaction dwell
|
||||
await clickWxButton(page, 'OK');
|
||||
// Dismiss the retry's "Export complete" report dialog via its modal
|
||||
// lease (export dialog holds 1; the report raises it to 2).
|
||||
await dismissReportDialog(page, 1, 'retry export complete');
|
||||
});
|
||||
});
|
||||
|
|
|
|||
82
tests/kicad/occ-service-watchdog.spec.ts
Normal file
82
tests/kicad/occ-service-watchdog.spec.ts
Normal file
|
|
@ -0,0 +1,82 @@
|
|||
import * as fs from 'fs';
|
||||
import * as path from 'path';
|
||||
import { test, expect } from './fixtures';
|
||||
|
||||
/**
|
||||
* occ_service boot watchdog (findings E-22): a wedged worker boot — an
|
||||
* importScripts hang, pthread spawn wedge, or OOM-kill leaves a worker that
|
||||
* never posts `ready` OR `bootError` — must settle the request with a loud
|
||||
* boot-timeout report instead of hanging to the spec timeout with zero
|
||||
* evidence, and the NEXT request must recover on a fresh generation against
|
||||
* the real occ_service.
|
||||
*
|
||||
* The wedge is a real silent Worker (a data: module that runs nothing), armed
|
||||
* one-shot through the harness hook; the recovery half exercises the real
|
||||
* occ_service wasm end to end.
|
||||
*/
|
||||
|
||||
test.describe('occ_service boot watchdog', () => {
|
||||
test.setTimeout(240000);
|
||||
|
||||
test('a wedged boot settles with a timeout report and the next request recovers', async ({ page }) => {
|
||||
await page.goto('/kicad/pcbnew.html', { waitUntil: 'domcontentloaded' });
|
||||
|
||||
const probeBoard = fs.readFileSync(
|
||||
path.resolve(__dirname, '..', 'fixtures', 'demo', 'demo.kicad_pcb'),
|
||||
'utf8',
|
||||
);
|
||||
|
||||
await page.evaluate((boardText: string) => {
|
||||
const runtime = globalThis as any;
|
||||
runtime.__occServiceTestHooks.wedgeNextBoot(5000);
|
||||
runtime.__occWedgeResult = null;
|
||||
void runtime.occService.request({
|
||||
kind: 'export',
|
||||
board: new TextEncoder().encode(boardText),
|
||||
jobJson: JSON.stringify({ format: 'step', export_components: false }),
|
||||
fileName: 'wedged.step',
|
||||
}).then((res: unknown) => { runtime.__occWedgeResult = res; });
|
||||
}, probeBoard);
|
||||
|
||||
await expect.poll(
|
||||
() => page.evaluate(() => (globalThis as any).__occWedgeResult),
|
||||
{
|
||||
message: 'the wedged boot must settle via the boot watchdog, not hang',
|
||||
timeout: 30000,
|
||||
},
|
||||
).toMatchObject({
|
||||
ok: false,
|
||||
report: expect.stringContaining('boot timed out after 5000 ms'),
|
||||
});
|
||||
|
||||
const wedgedState = await page.evaluate(
|
||||
() => (globalThis as any).__occServiceTestHooks.snapshot());
|
||||
expect(wedgedState.retiredGenerations, 'the wedged generation was retired')
|
||||
.toEqual([1]);
|
||||
expect(wedgedState.activeGeneration, 'no active generation remains').toBeNull();
|
||||
expect(wedgedState.pending, 'nothing left pending').toBe(0);
|
||||
|
||||
// Recovery: the wedge was one-shot — this boots the REAL occ_service
|
||||
// and completes a real export through it.
|
||||
const recovered = await page.evaluate(async (boardText: string) => {
|
||||
const runtime = globalThis as any;
|
||||
return await runtime.occService.request({
|
||||
kind: 'export',
|
||||
board: new TextEncoder().encode(boardText),
|
||||
jobJson: JSON.stringify({ format: 'step', export_components: false }),
|
||||
fileName: 'recovered.step',
|
||||
});
|
||||
}, probeBoard);
|
||||
expect(recovered.ok, 'the fresh generation must serve the retry').toBe(true);
|
||||
|
||||
const recoveredState = await page.evaluate(
|
||||
() => (globalThis as any).__occServiceTestHooks.snapshot());
|
||||
expect(recoveredState.workerGenerationsStarted, 'a replacement generation booted')
|
||||
.toEqual([1, 2]);
|
||||
expect(recoveredState.pending, 'the replacement generation quiesced').toBe(0);
|
||||
|
||||
const exports = await page.evaluate(() => (window as any).__occExports);
|
||||
expect(exports, 'the recovery produced a real STEP capture').toHaveLength(1);
|
||||
expect(exports[0].magic.startsWith('ISO-10303-21'), 'real STEP bytes').toBe(true);
|
||||
});
|
||||
});
|
||||
|
|
@ -118,15 +118,15 @@ test.describe('PCBnew move with "m" (#9)', () => {
|
|||
// JS-observable signal, and the asyncified pointer-move handler needs wall-clock
|
||||
// time to update the world cursor before each button press.
|
||||
await page.mouse.move(startPoint.x, startPoint.y);
|
||||
await page.waitForTimeout(350); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(350); // eslint-disable-line -- documented interaction dwell: asyncified pointer-move needs wall-clock time before press
|
||||
await page.mouse.down();
|
||||
await page.mouse.up();
|
||||
await page.waitForTimeout(350); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(350); // eslint-disable-line -- documented interaction dwell: line-vertex commit has no JS-observable signal
|
||||
await page.mouse.move(endPoint.x, endPoint.y);
|
||||
await page.waitForTimeout(350); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(350); // eslint-disable-line -- documented interaction dwell: asyncified pointer-move needs wall-clock time before press
|
||||
await page.mouse.down();
|
||||
await page.mouse.up();
|
||||
await page.waitForTimeout(500); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(500); // eslint-disable-line -- documented interaction dwell: line-vertex commit has no JS-observable signal
|
||||
// Finish the segment, then wait for the new board item to register
|
||||
// (deterministic — replaces two fixed 250ms sleeps).
|
||||
await page.keyboard.press('Escape');
|
||||
|
|
@ -150,21 +150,21 @@ test.describe('PCBnew move with "m" (#9)', () => {
|
|||
// asyncified event loop to process before the next. The outcome (the item moved
|
||||
// right) is asserted below via the embind position hook.
|
||||
await page.mouse.move(midPoint.x, midPoint.y);
|
||||
await page.waitForTimeout(350); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(350); // eslint-disable-line -- documented interaction dwell: asyncified pointer-move needs wall-clock time before select click
|
||||
await page.mouse.down();
|
||||
await page.mouse.up();
|
||||
await page.waitForTimeout(350); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(350); // eslint-disable-line -- documented interaction dwell: selection commit has no per-step observable
|
||||
|
||||
const NUDGES = 10;
|
||||
await page.keyboard.press('m');
|
||||
await page.waitForTimeout(400); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(400); // eslint-disable-line -- documented interaction dwell: move-mode entry has no observable signal
|
||||
for (let i = 0; i < NUDGES; i++) {
|
||||
await page.keyboard.press('ArrowRight');
|
||||
await page.waitForTimeout(150); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(150); // eslint-disable-line -- documented interaction dwell: per-arrow nudge has no per-step observable
|
||||
}
|
||||
// Commit at the nudged position WITHOUT moving the cursor (Enter, not click).
|
||||
await page.keyboard.press('Enter');
|
||||
await page.waitForTimeout(500); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(500); // eslint-disable-line -- documented interaction dwell: keyboard move commit; outcome asserted via position hook
|
||||
|
||||
const afterMove = await page.screenshot({ path: shotPath(page, 'pcbnew-move-01-after.png'), scale: 'css' });
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,9 @@
|
|||
import type { Page } from '@playwright/test';
|
||||
import { waitForCanvasStable } from '../../e2e/utils/element-tracker';
|
||||
import { assertNoNativeFailure, findNativeFailure } from './native-failure';
|
||||
|
||||
export type RuntimeLogger = { consoleLogs: string[]; errors: string[] };
|
||||
export type { RuntimeLogger } from './native-failure';
|
||||
import type { RuntimeLogger } from './native-failure';
|
||||
|
||||
/**
|
||||
* Wait for pcbnew to finish opening a board.
|
||||
|
|
@ -34,10 +36,7 @@ export async function waitForBoardLoaded(
|
|||
// goes away and we'd burn the full timeout. KiCad logs the abort
|
||||
// line through Module.printErr, which our test logger captures as
|
||||
// a console error. We re-read the live arrays each tick.
|
||||
const allLines = [...logger.consoleLogs, ...logger.errors];
|
||||
const abort = allLines.find((l) =>
|
||||
l.includes('Aborted(') || l.includes('RuntimeError: unreachable')
|
||||
);
|
||||
const abort = findNativeFailure([...logger.consoleLogs, ...logger.errors]);
|
||||
if (abort) {
|
||||
throw new Error(`WASM aborted during LoadBoard:\n${abort}`);
|
||||
}
|
||||
|
|
@ -79,16 +78,6 @@ function assertExpectedBoard(expectedBoard: string): void {
|
|||
}
|
||||
}
|
||||
|
||||
function assertNoNativeFailure(logger: RuntimeLogger | undefined, phase: string): void {
|
||||
if (!logger) return;
|
||||
const failure = [...logger.consoleLogs, ...logger.errors].find((line) =>
|
||||
line.includes('Aborted(')
|
||||
|| line.includes('RuntimeError: unreachable')
|
||||
|| line.includes('memory access out of bounds')
|
||||
);
|
||||
if (failure) throw new Error(`WASM failed during ${phase}:\n${failure}`);
|
||||
}
|
||||
|
||||
async function waitForBoardIdentityAndPaint(
|
||||
page: Page,
|
||||
expectedBoard: string,
|
||||
|
|
|
|||
35
tests/kicad/utils/native-failure.ts
Normal file
35
tests/kicad/utils/native-failure.ts
Normal file
|
|
@ -0,0 +1,35 @@
|
|||
export type RuntimeLogger = { consoleLogs: string[]; errors: string[] };
|
||||
|
||||
/**
|
||||
* The one shared list of fatal wasm-runtime console signatures. Before this
|
||||
* module, three divergent copies existed (trio.ts hasAbort: `Aborted(` only;
|
||||
* board-ready.ts: + `RuntimeError: unreachable` + `memory access out of
|
||||
* bounds`; spec-local variants: + `index out of bounds` etc.) — so whether a
|
||||
* native crash failed a spec fast or burned its full timeout depended on
|
||||
* which helper the spec happened to call. Add new engine wordings HERE.
|
||||
*/
|
||||
export const FATAL_WASM_PATTERNS = [
|
||||
'Aborted(',
|
||||
'RuntimeError: unreachable',
|
||||
'memory access out of bounds',
|
||||
'index out of bounds',
|
||||
'indirect call to null',
|
||||
'uncaught exception: unwind',
|
||||
] as const;
|
||||
|
||||
/** First captured console/error line matching a fatal wasm signature, if any. */
|
||||
export function findNativeFailure(lines: readonly string[]): string | undefined {
|
||||
return lines.find((line) => FATAL_WASM_PATTERNS.some((p) => line.includes(p)));
|
||||
}
|
||||
|
||||
/** Whether the logger has captured any fatal wasm signature. */
|
||||
export function hasNativeFailure(logger: RuntimeLogger): boolean {
|
||||
return findNativeFailure([...logger.consoleLogs, ...logger.errors]) !== undefined;
|
||||
}
|
||||
|
||||
/** Throw (with the offending line) if the logger captured a fatal wasm signature. */
|
||||
export function assertNoNativeFailure(logger: RuntimeLogger | undefined, phase: string): void {
|
||||
if (!logger) return;
|
||||
const failure = findNativeFailure([...logger.consoleLogs, ...logger.errors]);
|
||||
if (failure) throw new Error(`WASM failed during ${phase}:\n${failure}`);
|
||||
}
|
||||
|
|
@ -108,26 +108,10 @@ export async function installNgspiceServiceStub(
|
|||
name?: string;
|
||||
minimumLength?: number;
|
||||
}
|
||||
interface RequestWaiter {
|
||||
after: number;
|
||||
criteria: RequestCriteria;
|
||||
resolve: (summary: RequestSummary) => void;
|
||||
reject: (reason?: unknown) => void;
|
||||
timer: ReturnType<typeof setTimeout>;
|
||||
}
|
||||
interface AppliedGenerationReceipt {
|
||||
generation: number;
|
||||
t: number;
|
||||
}
|
||||
interface AppliedGenerationWaiter {
|
||||
after: number;
|
||||
resolve: (receipt: AppliedGenerationReceipt) => void;
|
||||
reject: (reason?: unknown) => void;
|
||||
timer: ReturnType<typeof setTimeout>;
|
||||
}
|
||||
interface CancellableReceipt<T> extends Promise<T> {
|
||||
cancel: (reason?: string) => void;
|
||||
}
|
||||
|
||||
const RECEIPT_TIMEOUT_MS = 2 * 60_000;
|
||||
const MAX_RECEIPT_TIMEOUT_MS = 5 * 60_000;
|
||||
|
|
@ -140,11 +124,11 @@ export async function installNgspiceServiceStub(
|
|||
let maxPending = 0;
|
||||
let bootMessageErrorArmed = false;
|
||||
let runtimeMessageErrorThreshold: number | null = null;
|
||||
let dieOnNextBgRunArmed = false;
|
||||
let corruptNextGetVecArmed = false;
|
||||
const retiredGenerations: number[] = [];
|
||||
let nextRequestSequence = 1;
|
||||
const requestWaiters = new Set<RequestWaiter>();
|
||||
const appliedGenerations: AppliedGenerationReceipt[] = [];
|
||||
const appliedGenerationWaiters = new Set<AppliedGenerationWaiter>();
|
||||
let disposed = false;
|
||||
|
||||
const validateReceiptTimeout = (timeoutMs: number): string | undefined => {
|
||||
|
|
@ -155,15 +139,6 @@ export async function installNgspiceServiceStub(
|
|||
return undefined;
|
||||
};
|
||||
|
||||
const cancellable = <T>(
|
||||
promise: Promise<T>,
|
||||
cancel: (reason?: string) => void,
|
||||
): CancellableReceipt<T> => {
|
||||
const receipt = promise as CancellableReceipt<T>;
|
||||
Object.defineProperty(receipt, 'cancel', { value: cancel });
|
||||
return receipt;
|
||||
};
|
||||
|
||||
const requestMatches = (
|
||||
summary: RequestSummary,
|
||||
after: number,
|
||||
|
|
@ -175,115 +150,130 @@ export async function installNgspiceServiceStub(
|
|||
&& (criteria.minimumLength === undefined
|
||||
|| (summary.length ?? -1) >= criteria.minimumLength);
|
||||
|
||||
const rejectRequestWaiter = (waiter: RequestWaiter, reason: Error): void => {
|
||||
if (!requestWaiters.delete(waiter)) return;
|
||||
clearTimeout(waiter.timer);
|
||||
waiter.reject(reason);
|
||||
interface ReceiptWaiter<TReceipt, TCriteria> {
|
||||
after: number;
|
||||
criteria: TCriteria;
|
||||
resolve: (receipt: TReceipt) => void;
|
||||
reject: (reason?: unknown) => void;
|
||||
timer: ReturnType<typeof setTimeout>;
|
||||
}
|
||||
|
||||
/**
|
||||
* One scan-then-subscribe receipt channel (shared by the request and
|
||||
* applied-generation receipts, which differ only in their match
|
||||
* predicate, existing-receipt scan, and error strings): scan the
|
||||
* already-published receipts first, otherwise subscribe a bounded,
|
||||
* timed waiter — so a receipt cannot land in the gap between an array
|
||||
* scan and listener installation.
|
||||
*/
|
||||
const makeReceiptChannel = <TReceipt, TCriteria>(channel: {
|
||||
validate: (after: number, criteria: TCriteria) => string | undefined;
|
||||
/** Defensive copy of the criteria, taken only after validation. */
|
||||
snapshotCriteria?: (criteria: TCriteria) => TCriteria;
|
||||
scanExisting: (after: number, criteria: TCriteria) => TReceipt | undefined;
|
||||
matches: (receipt: TReceipt, after: number, criteria: TCriteria) => boolean;
|
||||
capacityError: string;
|
||||
timeoutError: (timeoutMs: number) => string;
|
||||
}) => {
|
||||
const waiters = new Set<ReceiptWaiter<TReceipt, TCriteria>>();
|
||||
const rejectWaiter = (
|
||||
waiter: ReceiptWaiter<TReceipt, TCriteria>,
|
||||
reason: Error,
|
||||
): void => {
|
||||
if (!waiters.delete(waiter)) return;
|
||||
clearTimeout(waiter.timer);
|
||||
waiter.reject(reason);
|
||||
};
|
||||
return {
|
||||
wait(after: number, criteria: TCriteria, timeoutMs: number): Promise<TReceipt> {
|
||||
if (disposed)
|
||||
return Promise.reject(new Error('ngspice receipt service was disposed'));
|
||||
const invalid = channel.validate(after, criteria)
|
||||
?? validateReceiptTimeout(timeoutMs);
|
||||
if (invalid) return Promise.reject(new Error(invalid));
|
||||
const existing = channel.scanExisting(after, criteria);
|
||||
if (existing) return Promise.resolve(existing);
|
||||
if (waiters.size >= MAX_RECEIPT_WAITERS)
|
||||
return Promise.reject(new Error(channel.capacityError));
|
||||
const held = channel.snapshotCriteria
|
||||
? channel.snapshotCriteria(criteria) : criteria;
|
||||
return new Promise<TReceipt>((resolve, reject) => {
|
||||
const waiter: ReceiptWaiter<TReceipt, TCriteria> = {
|
||||
after,
|
||||
criteria: held,
|
||||
resolve,
|
||||
reject,
|
||||
timer: setTimeout(() => rejectWaiter(
|
||||
waiter,
|
||||
new Error(channel.timeoutError(timeoutMs)),
|
||||
), timeoutMs),
|
||||
};
|
||||
waiters.add(waiter);
|
||||
});
|
||||
},
|
||||
publish(receipt: TReceipt): void {
|
||||
for (const waiter of [...waiters]) {
|
||||
if (!channel.matches(receipt, waiter.after, waiter.criteria)) continue;
|
||||
waiters.delete(waiter);
|
||||
clearTimeout(waiter.timer);
|
||||
waiter.resolve(receipt);
|
||||
}
|
||||
},
|
||||
drain(reason: string): void {
|
||||
for (const waiter of [...waiters]) rejectWaiter(waiter, new Error(reason));
|
||||
},
|
||||
size: () => waiters.size,
|
||||
};
|
||||
};
|
||||
|
||||
const requestReceipts = makeReceiptChannel<RequestSummary, RequestCriteria>({
|
||||
validate: (after, criteria) => {
|
||||
if (!Number.isSafeInteger(after) || after < 0)
|
||||
return 'request checkpoint must be a non-negative integer';
|
||||
if (!criteria || typeof criteria !== 'object')
|
||||
return 'request receipt criteria must be an object';
|
||||
if (criteria.minimumLength !== undefined
|
||||
&& (!Number.isSafeInteger(criteria.minimumLength)
|
||||
|| criteria.minimumLength < 0)) {
|
||||
return 'minimumLength must be a non-negative integer';
|
||||
}
|
||||
return undefined;
|
||||
},
|
||||
snapshotCriteria: (criteria) => ({ ...criteria }),
|
||||
scanExisting: (after, criteria) => ((window as any).__ngspiceLog as RequestSummary[])
|
||||
.find((entry) => requestMatches(entry, after, criteria)),
|
||||
matches: requestMatches,
|
||||
capacityError: 'ngspice request receipt waiter capacity exceeded',
|
||||
timeoutError: (timeoutMs) =>
|
||||
`ngspice request receipt timed out after ${timeoutMs} ms`,
|
||||
});
|
||||
|
||||
const appliedReceipts = makeReceiptChannel<AppliedGenerationReceipt, undefined>({
|
||||
validate: (after) => (!Number.isSafeInteger(after) || after < 0)
|
||||
? 'applied generation checkpoint must be a non-negative integer'
|
||||
: undefined,
|
||||
scanExisting: (after) => appliedGenerations.find((entry) => entry.generation > after),
|
||||
matches: (receipt, after) => receipt.generation > after,
|
||||
capacityError: 'ngspice applied-generation waiter capacity exceeded',
|
||||
timeoutError: (timeoutMs) =>
|
||||
`ngspice applied generation timed out after ${timeoutMs} ms`,
|
||||
});
|
||||
|
||||
const publishRequestReceipt = (summary: RequestSummary) => {
|
||||
(window as any).__ngspiceLog.push(summary);
|
||||
for (const waiter of [...requestWaiters]) {
|
||||
if (!requestMatches(summary, waiter.after, waiter.criteria)) continue;
|
||||
requestWaiters.delete(waiter);
|
||||
clearTimeout(waiter.timer);
|
||||
waiter.resolve(summary);
|
||||
}
|
||||
requestReceipts.publish(summary);
|
||||
};
|
||||
|
||||
const waitForRequestAfter = (
|
||||
after: number,
|
||||
criteria: RequestCriteria,
|
||||
timeoutMs = RECEIPT_TIMEOUT_MS,
|
||||
): CancellableReceipt<RequestSummary> => {
|
||||
const rejected = (message: string) => cancellable(
|
||||
Promise.reject(new Error(message)),
|
||||
() => undefined,
|
||||
);
|
||||
if (disposed) return rejected('ngspice receipt service was disposed');
|
||||
if (!Number.isSafeInteger(after) || after < 0)
|
||||
return rejected('request checkpoint must be a non-negative integer');
|
||||
if (!criteria || typeof criteria !== 'object')
|
||||
return rejected('request receipt criteria must be an object');
|
||||
if (criteria.minimumLength !== undefined
|
||||
&& (!Number.isSafeInteger(criteria.minimumLength)
|
||||
|| criteria.minimumLength < 0)) {
|
||||
return rejected('minimumLength must be a non-negative integer');
|
||||
}
|
||||
const timeoutError = validateReceiptTimeout(timeoutMs);
|
||||
if (timeoutError) return rejected(timeoutError);
|
||||
const log = (window as any).__ngspiceLog as RequestSummary[];
|
||||
const existing = log.find((entry) =>
|
||||
requestMatches(entry, after, criteria));
|
||||
if (existing) return cancellable(Promise.resolve(existing), () => undefined);
|
||||
if (requestWaiters.size >= MAX_RECEIPT_WAITERS)
|
||||
return rejected('ngspice request receipt waiter capacity exceeded');
|
||||
|
||||
let waiter!: RequestWaiter;
|
||||
const promise = new Promise<RequestSummary>((resolve, reject) => {
|
||||
waiter = {
|
||||
after,
|
||||
criteria: { ...criteria },
|
||||
resolve,
|
||||
reject,
|
||||
timer: setTimeout(() => rejectRequestWaiter(
|
||||
waiter,
|
||||
new Error(`ngspice request receipt timed out after ${timeoutMs} ms`),
|
||||
), timeoutMs),
|
||||
};
|
||||
requestWaiters.add(waiter);
|
||||
});
|
||||
return cancellable(promise, (reason = 'canceled') => rejectRequestWaiter(
|
||||
waiter,
|
||||
new Error(`ngspice request receipt ${reason}`),
|
||||
));
|
||||
};
|
||||
|
||||
const rejectAppliedGenerationWaiter = (
|
||||
waiter: AppliedGenerationWaiter,
|
||||
reason: Error,
|
||||
): void => {
|
||||
if (!appliedGenerationWaiters.delete(waiter)) return;
|
||||
clearTimeout(waiter.timer);
|
||||
waiter.reject(reason);
|
||||
};
|
||||
): Promise<RequestSummary> => requestReceipts.wait(after, criteria, timeoutMs);
|
||||
|
||||
const waitForAppliedGenerationAfter = (
|
||||
after: number,
|
||||
timeoutMs = RECEIPT_TIMEOUT_MS,
|
||||
): CancellableReceipt<AppliedGenerationReceipt> => {
|
||||
const rejected = (message: string) => cancellable(
|
||||
Promise.reject(new Error(message)),
|
||||
() => undefined,
|
||||
);
|
||||
if (disposed) return rejected('ngspice receipt service was disposed');
|
||||
if (!Number.isSafeInteger(after) || after < 0)
|
||||
return rejected('applied generation checkpoint must be a non-negative integer');
|
||||
const timeoutError = validateReceiptTimeout(timeoutMs);
|
||||
if (timeoutError) return rejected(timeoutError);
|
||||
const existing = appliedGenerations.find((entry) => entry.generation > after);
|
||||
if (existing) return cancellable(Promise.resolve(existing), () => undefined);
|
||||
if (appliedGenerationWaiters.size >= MAX_RECEIPT_WAITERS)
|
||||
return rejected('ngspice applied-generation waiter capacity exceeded');
|
||||
|
||||
let waiter!: AppliedGenerationWaiter;
|
||||
const promise = new Promise<AppliedGenerationReceipt>((resolve, reject) => {
|
||||
waiter = {
|
||||
after,
|
||||
resolve,
|
||||
reject,
|
||||
timer: setTimeout(() => rejectAppliedGenerationWaiter(
|
||||
waiter,
|
||||
new Error(`ngspice applied generation timed out after ${timeoutMs} ms`),
|
||||
), timeoutMs),
|
||||
};
|
||||
appliedGenerationWaiters.add(waiter);
|
||||
});
|
||||
return cancellable(promise, (reason = 'canceled') => rejectAppliedGenerationWaiter(
|
||||
waiter,
|
||||
new Error(`ngspice applied-generation receipt ${reason}`),
|
||||
));
|
||||
};
|
||||
): Promise<AppliedGenerationReceipt> => appliedReceipts.wait(after, undefined, timeoutMs);
|
||||
|
||||
const previousAppliedHook = (globalThis as any).__pcbjamNgspiceFinalRefreshApplied;
|
||||
const publishAppliedGeneration = (generation: number): void => {
|
||||
|
|
@ -301,12 +291,7 @@ export async function installNgspiceServiceStub(
|
|||
}
|
||||
const receipt = { generation, t: Date.now() - t0 };
|
||||
appliedGenerations.push(receipt);
|
||||
for (const waiter of [...appliedGenerationWaiters]) {
|
||||
if (generation <= waiter.after) continue;
|
||||
appliedGenerationWaiters.delete(waiter);
|
||||
clearTimeout(waiter.timer);
|
||||
waiter.resolve(receipt);
|
||||
}
|
||||
appliedReceipts.publish(receipt);
|
||||
if (typeof previousAppliedHook === 'function') previousAppliedHook(generation);
|
||||
};
|
||||
(globalThis as any).__pcbjamNgspiceFinalRefreshApplied = publishAppliedGeneration;
|
||||
|
|
@ -353,15 +338,21 @@ export async function installNgspiceServiceStub(
|
|||
(window as any).__ngspiceEvents.push({ ...evt, t: Date.now() - t0 });
|
||||
const handler = (globalThis as any).__ngspiceOnEvent;
|
||||
if (handler) {
|
||||
while (evtQueue.length) {
|
||||
const queued = evtQueue.shift()!;
|
||||
evtQueueBytes -= queued.bytes;
|
||||
if (queued.generation !== slot.generation) continue;
|
||||
// Queued frames were acked at enqueue (ownership taken then).
|
||||
handler(queued.evt);
|
||||
// Mirrors the production service: the host owns the frame's
|
||||
// credit from onmessage on, so the ack survives a throwing
|
||||
// handler (which keeps propagating).
|
||||
try {
|
||||
while (evtQueue.length) {
|
||||
const queued = evtQueue.shift()!;
|
||||
evtQueueBytes -= queued.bytes;
|
||||
if (queued.generation !== slot.generation) continue;
|
||||
// Queued frames were acked at enqueue (ownership taken then).
|
||||
handler(queued.evt);
|
||||
}
|
||||
handler(evt);
|
||||
} finally {
|
||||
ackEvent(slot, frame);
|
||||
}
|
||||
handler(evt);
|
||||
ackEvent(slot, frame);
|
||||
} else {
|
||||
if (evtQueue.length >= MAX_QUEUED_EVENT_FRAMES
|
||||
|| evtQueueBytes > MAX_QUEUED_EVENT_BYTES - bytes) {
|
||||
|
|
@ -377,6 +368,26 @@ export async function installNgspiceServiceStub(
|
|||
}
|
||||
};
|
||||
|
||||
// Mirrors the production service: the worker's terminal notice carries
|
||||
// the deferred frames it had already accepted — deliver best-effort,
|
||||
// in order, WITHOUT acking (the fatal frame is outside the credit
|
||||
// protocol), and record them for the specs like any live frame.
|
||||
const deliverTerminalEvents = (entries: unknown): void => {
|
||||
if (!Array.isArray(entries) || entries.length === 0) return;
|
||||
const handler = (globalThis as any).__ngspiceOnEvent;
|
||||
for (const entry of entries) {
|
||||
const evt = (entry as { evt?: any } | null)?.evt;
|
||||
if (!evt) continue;
|
||||
(window as any).__ngspiceEvents.push({ ...evt, t: Date.now() - t0 });
|
||||
if (!handler) continue;
|
||||
try {
|
||||
handler(evt);
|
||||
} catch (error) {
|
||||
console.log(`[TEST-NGSPICE] terminal event delivery failed: ${String(error)}`);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const failPending = (generation: number, why: string) => {
|
||||
for (const [id, request] of pending) {
|
||||
if (request.generation !== generation) continue;
|
||||
|
|
@ -389,6 +400,7 @@ export async function installNgspiceServiceStub(
|
|||
const retireWorker = (slot: WorkerSlot, why: string) => {
|
||||
if (slot.failed) return;
|
||||
slot.failed = true;
|
||||
console.log(`[TEST-NGSPICE] retiring generation ${slot.generation}: ${why}`);
|
||||
retiredGenerations.push(slot.generation);
|
||||
if (slot.bootTimer !== undefined) {
|
||||
clearTimeout(slot.bootTimer);
|
||||
|
|
@ -412,6 +424,23 @@ export async function installNgspiceServiceStub(
|
|||
const reject = slot.rejectBoot;
|
||||
slot.rejectBoot = undefined;
|
||||
reject?.(new Error(why));
|
||||
|
||||
// Mirrors the production service (E-10): a retired worker emits
|
||||
// no bg/exit frame of its own, so synthesize the controlled-exit
|
||||
// the crashed engine could not send — straight to the installed
|
||||
// handler, never through dispatchEvt (no fabricated credit).
|
||||
const handler = (globalThis as any).__ngspiceOnEvent;
|
||||
if (handler) {
|
||||
(window as any).__ngspiceEvents.push({
|
||||
kind: 'exit', status: 1, immediate: true, quit: false,
|
||||
t: Date.now() - t0,
|
||||
});
|
||||
try {
|
||||
handler({ kind: 'exit', status: 1, immediate: true, quit: false });
|
||||
} catch (error) {
|
||||
console.log(`[TEST-NGSPICE] synthetic exit dispatch failed: ${String(error)}`);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
const ensureWorker = (): Promise<WorkerSlot> => {
|
||||
|
|
@ -446,6 +475,7 @@ export async function installNgspiceServiceStub(
|
|||
if (slot.failed || workerSlot !== slot) return;
|
||||
const data = e.data ?? {};
|
||||
if (data.fatal) {
|
||||
deliverTerminalEvents(data.pendingEvents);
|
||||
failWorker(`event stream failure: ${String(data.fatal)}`);
|
||||
return;
|
||||
}
|
||||
|
|
@ -555,6 +585,27 @@ export async function installNgspiceServiceStub(
|
|||
// checkpoint can therefore never satisfy that simulation.
|
||||
if (disposed) return { error: 'ngspice service was disposed' };
|
||||
const requestSequence = nextRequestSequence++;
|
||||
// Armed fault: the transport dies on the bg_run launch itself —
|
||||
// AFTER the native side published its run generation, BEFORE any
|
||||
// RUNNING transition could fire (the E-12 window). Retirement
|
||||
// runs the production funnel (and its synthetic exit).
|
||||
if (dieOnNextBgRunArmed && req.kind === 'command'
|
||||
&& typeof req.cmd === 'string' && req.cmd.startsWith('bg_run')) {
|
||||
dieOnNextBgRunArmed = false;
|
||||
console.log('[TEST-NGSPICE] armed fault: transport death on bg_run');
|
||||
const res = {
|
||||
error: 'ngspice_service crashed: transport died on bg_run (armed fault)',
|
||||
};
|
||||
if (workerSlot) retireWorker(workerSlot, res.error);
|
||||
publishRequestReceipt({
|
||||
sequence: requestSequence,
|
||||
kind: req.kind,
|
||||
cmd: req.cmd,
|
||||
error: res.error,
|
||||
t: Date.now() - t0,
|
||||
});
|
||||
return res;
|
||||
}
|
||||
let slot: WorkerSlot;
|
||||
try {
|
||||
slot = await ensureWorker();
|
||||
|
|
@ -571,6 +622,15 @@ export async function installNgspiceServiceStub(
|
|||
return res;
|
||||
}
|
||||
const res: any = await post(slot, req);
|
||||
// Armed fault: corrupt the next get_vec_info answer's LENGTH field
|
||||
// only (the arrays stay small) — the corrupted-worker shape the
|
||||
// sharedspice client must clamp against.
|
||||
if (corruptNextGetVecArmed && req.kind === 'get_vec_info'
|
||||
&& res && !res.error) {
|
||||
corruptNextGetVecArmed = false;
|
||||
console.log('[TEST-NGSPICE] armed fault: inflating get_vec_info length');
|
||||
res.length = 1 << 29;
|
||||
}
|
||||
publishRequestReceipt({
|
||||
sequence: requestSequence,
|
||||
kind: req.kind,
|
||||
|
|
@ -588,15 +648,8 @@ export async function installNgspiceServiceStub(
|
|||
if (disposed) return;
|
||||
disposed = true;
|
||||
if (workerSlot) retireWorker(workerSlot, 'ngspice service was disposed');
|
||||
for (const waiter of [...requestWaiters]) {
|
||||
rejectRequestWaiter(waiter, new Error('ngspice request receipt canceled by teardown'));
|
||||
}
|
||||
for (const waiter of [...appliedGenerationWaiters]) {
|
||||
rejectAppliedGenerationWaiter(
|
||||
waiter,
|
||||
new Error('ngspice applied-generation receipt canceled by teardown'),
|
||||
);
|
||||
}
|
||||
requestReceipts.drain('ngspice request receipt canceled by teardown');
|
||||
appliedReceipts.drain('ngspice applied-generation receipt canceled by teardown');
|
||||
if ((globalThis as any).__pcbjamNgspiceFinalRefreshApplied
|
||||
=== publishAppliedGeneration) {
|
||||
(globalThis as any).__pcbjamNgspiceFinalRefreshApplied = previousAppliedHook;
|
||||
|
|
@ -623,6 +676,25 @@ export async function installNgspiceServiceStub(
|
|||
throw new Error('pending threshold must be a positive safe integer');
|
||||
runtimeMessageErrorThreshold = count;
|
||||
},
|
||||
/** Retire the active generation through the production funnel
|
||||
* (the same retireWorker every watchdog/onerror path uses). */
|
||||
forceRetire(reason: string): boolean {
|
||||
const slot = workerSlot;
|
||||
if (!slot) return false;
|
||||
retireWorker(slot, String(reason || 'forced retirement'));
|
||||
return true;
|
||||
},
|
||||
/** One-shot: the transport dies on the next bg_run launch (the
|
||||
* generation retires through the production funnel before any
|
||||
* RUNNING transition can fire). */
|
||||
dieOnNextBgRun() {
|
||||
dieOnNextBgRunArmed = true;
|
||||
},
|
||||
/** One-shot: the next successful get_vec_info answer reports a
|
||||
* huge vector length while its arrays stay small. */
|
||||
corruptNextGetVec() {
|
||||
corruptNextGetVecArmed = true;
|
||||
},
|
||||
snapshot() {
|
||||
return {
|
||||
activeGeneration: workerSlot?.generation ?? null,
|
||||
|
|
@ -632,9 +704,9 @@ export async function installNgspiceServiceStub(
|
|||
bootFaultArmed: bootMessageErrorArmed,
|
||||
runtimeFaultArmed: runtimeMessageErrorThreshold !== null,
|
||||
lastRequestSequence: nextRequestSequence - 1,
|
||||
requestReceiptWaiters: requestWaiters.size,
|
||||
requestReceiptWaiters: requestReceipts.size(),
|
||||
appliedGenerations: appliedGenerations.map((entry) => entry.generation),
|
||||
appliedGenerationWaiters: appliedGenerationWaiters.size,
|
||||
appliedGenerationWaiters: appliedReceipts.size(),
|
||||
disposed,
|
||||
};
|
||||
},
|
||||
|
|
|
|||
|
|
@ -39,10 +39,23 @@ const OCC_WORKER_SRC = fs.readFileSync(
|
|||
'web', 'standalone', 'src', 'wasm', 'occ-worker.js'),
|
||||
'utf8');
|
||||
|
||||
export async function installOccServiceStub(page: Page): Promise<void> {
|
||||
await page.addInitScript((workerSrc: string) => {
|
||||
export interface OccHarnessWatchdogs {
|
||||
bootTimeoutMs?: number;
|
||||
}
|
||||
|
||||
export async function installOccServiceStub(
|
||||
page: Page,
|
||||
watchdogs: OccHarnessWatchdogs = {},
|
||||
): Promise<void> {
|
||||
const bootTimeoutMs = watchdogs.bootTimeoutMs ?? 2 * 60_000;
|
||||
if (!Number.isSafeInteger(bootTimeoutMs) || bootTimeoutMs < 1)
|
||||
throw new Error('bootTimeoutMs must be a positive safe integer');
|
||||
|
||||
await page.addInitScript((options: { workerSrc: string; bootTimeoutMs: number }) => {
|
||||
if ((globalThis as any).occService) return;
|
||||
|
||||
const { workerSrc, bootTimeoutMs } = options;
|
||||
|
||||
(window as any).__occExports = [];
|
||||
|
||||
interface WorkerSlot {
|
||||
|
|
@ -50,6 +63,9 @@ export async function installOccServiceStub(page: Page): Promise<void> {
|
|||
worker?: Worker;
|
||||
failed: boolean;
|
||||
ready: Promise<WorkerSlot>;
|
||||
bootTimer?: ReturnType<typeof setTimeout>;
|
||||
rejectBoot?: (reason?: unknown) => void;
|
||||
removeBootListener?: () => void;
|
||||
/** The exact lifecycle transition used by Worker.onmessageerror. */
|
||||
failDecode: () => void;
|
||||
}
|
||||
|
|
@ -67,11 +83,9 @@ export async function installOccServiceStub(page: Page): Promise<void> {
|
|||
let requestsStarted = 0;
|
||||
let requestsPosted = 0;
|
||||
const workerGenerationsStarted: number[] = [];
|
||||
let armedFault: {
|
||||
count: number;
|
||||
kind: 'terminate' | 'messageerror';
|
||||
report: string;
|
||||
} | null = null;
|
||||
let armedFault: { count: number; report: string } | null = null;
|
||||
/** One-shot: the next boot uses a worker that never answers. */
|
||||
let wedgeNextBootArmed: { bootTimeoutMs?: number } | null = null;
|
||||
const retiredGenerations: number[] = [];
|
||||
|
||||
const pendingInGeneration = (generation: number): number => {
|
||||
|
|
@ -94,6 +108,12 @@ export async function installOccServiceStub(page: Page): Promise<void> {
|
|||
if (slot.failed) return;
|
||||
slot.failed = true;
|
||||
retiredGenerations.push(slot.generation);
|
||||
if (slot.bootTimer !== undefined) {
|
||||
clearTimeout(slot.bootTimer);
|
||||
slot.bootTimer = undefined;
|
||||
}
|
||||
slot.removeBootListener?.();
|
||||
slot.removeBootListener = undefined;
|
||||
failPending(slot.generation, report);
|
||||
if (workerSlot === slot) workerSlot = null;
|
||||
try {
|
||||
|
|
@ -101,21 +121,22 @@ export async function installOccServiceStub(page: Page): Promise<void> {
|
|||
} catch {
|
||||
/* already gone */
|
||||
}
|
||||
const reject = slot.rejectBoot;
|
||||
slot.rejectBoot = undefined;
|
||||
reject?.(new Error(report));
|
||||
};
|
||||
|
||||
const maybeTriggerArmedFault = (slot: WorkerSlot): void => {
|
||||
if (!armedFault || slot.failed) return;
|
||||
if (pendingInGeneration(slot.generation) < armedFault.count) return;
|
||||
const { kind, report } = armedFault;
|
||||
const { report } = armedFault;
|
||||
armedFault = null;
|
||||
console.log(`[TEST-OCC] faulting generation ${slot.generation} (${kind}): ${report}`);
|
||||
if (kind === 'messageerror' && slot.worker) {
|
||||
console.log(`[TEST-OCC] faulting generation ${slot.generation} (messageerror): ${report}`);
|
||||
if (slot.worker) {
|
||||
// Synthetic dispatch on Worker is engine-dependent. Invoke
|
||||
// the exact transition installed as the real event handler.
|
||||
slot.failDecode();
|
||||
} else {
|
||||
// Worker.terminate() intentionally emits no error event, so
|
||||
// the hook supplies the fatal lifecycle transition explicitly.
|
||||
retireWorker(slot, report);
|
||||
}
|
||||
};
|
||||
|
|
@ -127,36 +148,53 @@ export async function installOccServiceStub(page: Page): Promise<void> {
|
|||
failed: false,
|
||||
} as WorkerSlot;
|
||||
workerGenerationsStarted.push(slot.generation);
|
||||
workerSlot = slot;
|
||||
|
||||
slot.ready = (async () => {
|
||||
const wedge = wedgeNextBootArmed;
|
||||
wedgeNextBootArmed = null;
|
||||
const bootDeadlineMs = wedge?.bootTimeoutMs ?? bootTimeoutMs;
|
||||
|
||||
// Legible boot (E-22): a worker DEATH shape that never posts
|
||||
// ready OR bootError (importScripts hang, pthread spawn
|
||||
// wedge, OOM-kill) used to hang every request until the
|
||||
// spec's timeout with zero evidence. Bound the boot — same
|
||||
// shape as the ngspice stub and the production service.
|
||||
const bootDeadline = new Promise<never>((_resolve, reject) => {
|
||||
slot.rejectBoot = reject;
|
||||
slot.bootTimer = setTimeout(() => {
|
||||
if (slot.failed || workerSlot !== slot) return;
|
||||
const why = `occ_service boot timed out after ${bootDeadlineMs} ms`;
|
||||
console.log(`[TEST-OCC] ${why} — resetting service`);
|
||||
retireWorker(slot, why);
|
||||
}, bootDeadlineMs);
|
||||
});
|
||||
|
||||
const boot = (async () => {
|
||||
const glue = new URL('occ_service.js', window.location.href).href;
|
||||
console.log(`[TEST-OCC] booting occ_service from ${glue}`);
|
||||
const worker = new Worker(URL.createObjectURL(new Blob(
|
||||
[`self.OCC_GLUE_URL = ${JSON.stringify(glue)};\n`, workerSrc],
|
||||
{ type: 'text/javascript' })));
|
||||
// A wedged boot is a REAL silent Worker (an empty module:
|
||||
// it boots, runs nothing, never posts ready/bootError) —
|
||||
// the importScripts-hang / pthread-wedge shape, engine
|
||||
// independent.
|
||||
const worker = wedge
|
||||
? new Worker('data:text/javascript,/* [TEST-OCC] wedged boot */')
|
||||
: new Worker(URL.createObjectURL(new Blob(
|
||||
[`self.OCC_GLUE_URL = ${JSON.stringify(glue)};\n`, workerSrc],
|
||||
{ type: 'text/javascript' })));
|
||||
slot.worker = worker;
|
||||
let rejectBoot: ((reason?: unknown) => void) | undefined;
|
||||
let removeBootListener: (() => void) | undefined;
|
||||
|
||||
// All fatal transitions settle the boot through the ONE
|
||||
// retirement funnel (which clears the deadline, removes
|
||||
// the boot listener, and rejects the raced promise).
|
||||
worker.onerror = (e) => {
|
||||
const report = `occ_service crashed: ${e.message || 'worker error'}`;
|
||||
console.error(`[TEST-OCC] ${report}; resetting service`);
|
||||
retireWorker(slot, report);
|
||||
removeBootListener?.();
|
||||
removeBootListener = undefined;
|
||||
const reject = rejectBoot;
|
||||
rejectBoot = undefined;
|
||||
reject?.(new Error(report));
|
||||
};
|
||||
slot.failDecode = () => {
|
||||
const report = 'occ_service transport failed: message decode failed';
|
||||
console.error(`[TEST-OCC] ${report}; resetting service`);
|
||||
retireWorker(slot, report);
|
||||
removeBootListener?.();
|
||||
removeBootListener = undefined;
|
||||
const reject = rejectBoot;
|
||||
rejectBoot = undefined;
|
||||
reject?.(new Error(report));
|
||||
};
|
||||
worker.onmessageerror = slot.failDecode;
|
||||
worker.onmessage = (e) => {
|
||||
|
|
@ -169,38 +207,37 @@ export async function installOccServiceStub(page: Page): Promise<void> {
|
|||
request.resolve(res);
|
||||
}
|
||||
};
|
||||
await new Promise<void>((resolve, reject) => {
|
||||
rejectBoot = reject;
|
||||
await new Promise<void>((resolve) => {
|
||||
const onFirst = (e: MessageEvent) => {
|
||||
if (e.data?.ready) {
|
||||
removeBootListener?.();
|
||||
removeBootListener = undefined;
|
||||
rejectBoot = undefined;
|
||||
if (slot.bootTimer !== undefined) {
|
||||
clearTimeout(slot.bootTimer);
|
||||
slot.bootTimer = undefined;
|
||||
}
|
||||
slot.removeBootListener?.();
|
||||
slot.removeBootListener = undefined;
|
||||
slot.rejectBoot = undefined;
|
||||
resolve();
|
||||
} else if (e.data?.bootError) {
|
||||
removeBootListener?.();
|
||||
removeBootListener = undefined;
|
||||
rejectBoot = undefined;
|
||||
const report = `occ_service boot failed: ${String(e.data.bootError)}`;
|
||||
retireWorker(slot, report);
|
||||
reject(new Error(report));
|
||||
retireWorker(slot,
|
||||
`occ_service boot failed: ${String(e.data.bootError)}`);
|
||||
}
|
||||
};
|
||||
worker.addEventListener('message', onFirst);
|
||||
removeBootListener = () => worker.removeEventListener('message', onFirst);
|
||||
slot.removeBootListener = () => worker.removeEventListener('message', onFirst);
|
||||
});
|
||||
if (slot.failed || workerSlot !== slot)
|
||||
throw new Error('occ_service worker retired during boot');
|
||||
console.log('[TEST-OCC] occ_service ready');
|
||||
return slot;
|
||||
})().catch((e) => {
|
||||
})();
|
||||
|
||||
slot.ready = Promise.race([boot, bootDeadline]).catch((e) => {
|
||||
// A late rejection from a retired generation cannot clear
|
||||
// the replacement slot created by a new request.
|
||||
retireWorker(slot, `occ_service unavailable: ${String(e)}`);
|
||||
throw e;
|
||||
});
|
||||
|
||||
workerSlot = slot;
|
||||
}
|
||||
return workerSlot.ready;
|
||||
};
|
||||
|
|
@ -291,12 +328,13 @@ export async function installOccServiceStub(page: Page): Promise<void> {
|
|||
};
|
||||
|
||||
(globalThis as any).__occServiceTestHooks = {
|
||||
/** Arm one deterministic host-side fault after N real posts. */
|
||||
terminateWhenPendingAtLeast(count: number, report = 'occ_service test fault') {
|
||||
if (!Number.isSafeInteger(count) || count < 1)
|
||||
throw new Error('pending threshold must be a positive safe integer');
|
||||
armedFault = { count, kind: 'terminate', report };
|
||||
if (workerSlot) maybeTriggerArmedFault(workerSlot);
|
||||
/** One-shot: wedge the next boot (silent worker, no ready and no
|
||||
* bootError), optionally shortening that boot's deadline. */
|
||||
wedgeNextBoot(bootTimeoutMs?: number) {
|
||||
if (bootTimeoutMs !== undefined
|
||||
&& (!Number.isSafeInteger(bootTimeoutMs) || bootTimeoutMs < 1))
|
||||
throw new Error('bootTimeoutMs must be a positive safe integer');
|
||||
wedgeNextBootArmed = { bootTimeoutMs };
|
||||
},
|
||||
/** Arm the real Worker's production-parity messageerror handler. */
|
||||
messageErrorWhenPendingAtLeast(count: number) {
|
||||
|
|
@ -304,7 +342,6 @@ export async function installOccServiceStub(page: Page): Promise<void> {
|
|||
throw new Error('pending threshold must be a positive safe integer');
|
||||
armedFault = {
|
||||
count,
|
||||
kind: 'messageerror',
|
||||
report: 'occ_service transport failed: message decode failed',
|
||||
};
|
||||
if (workerSlot) maybeTriggerArmedFault(workerSlot);
|
||||
|
|
@ -324,5 +361,5 @@ export async function installOccServiceStub(page: Page): Promise<void> {
|
|||
};
|
||||
|
||||
(globalThis as any).occService = { request };
|
||||
}, OCC_WORKER_SRC);
|
||||
}, { workerSrc: OCC_WORKER_SRC, bootTimeoutMs });
|
||||
}
|
||||
|
|
|
|||
133
tests/kicad/utils/sim-harness.ts
Normal file
133
tests/kicad/utils/sim-harness.ts
Normal file
|
|
@ -0,0 +1,133 @@
|
|||
import type { Page } from '@playwright/test';
|
||||
import { expect } from '@playwright/test';
|
||||
import * as path from 'path';
|
||||
import {
|
||||
clickByTooltip,
|
||||
clickMenuBarItem,
|
||||
clickMenuItemByText,
|
||||
findByTooltip,
|
||||
} from '../../e2e/utils/element-tracker';
|
||||
import { injectFileIntoMemfs } from './fs-inject';
|
||||
|
||||
/**
|
||||
* Shared eeschema-simulator harness (one copy for eeschema-sim.spec.ts and
|
||||
* eeschema-sim-recovery.spec.ts): rectifier project load, Inspect → Simulator
|
||||
* open, and the exact applied-generation run driver.
|
||||
*/
|
||||
|
||||
const RECTIFIER_DIR = path.resolve(__dirname, '..', '..', '..',
|
||||
'kicad', 'demos', 'simulation', 'rectifier');
|
||||
const MEMFS_DIR = '/home/kicad/documents/rectifier';
|
||||
const PROJECT_FILES = ['rectifier.kicad_sch', 'rectifier.kicad_pro', 'diode.mod',
|
||||
'rectifier_schlib.kicad_sym', 'sym-lib-table', 'rectifier.wbk'];
|
||||
|
||||
export async function loadRectifier(page: Page): Promise<void> {
|
||||
for (const f of PROJECT_FILES)
|
||||
await injectFileIntoMemfs(page, path.join(RECTIFIER_DIR, f), `${MEMFS_DIR}/${f}`);
|
||||
|
||||
await page.evaluate(async (sch: string) => {
|
||||
await (window as any).Module.kicadOpenFile(sch);
|
||||
}, `${MEMFS_DIR}/rectifier.kicad_sch`);
|
||||
|
||||
await expect
|
||||
.poll(async () => page.title(), { timeout: 120000 })
|
||||
.toMatch(/rectifier/i);
|
||||
}
|
||||
|
||||
/** Open Inspect → Simulator and return the new top-level window's DOM id. */
|
||||
export async function openSimulator(page: Page): Promise<string> {
|
||||
const idsBefore = await page.$$eval('#window-container [id^="window-"]',
|
||||
(els) => els.map((e) => e.id));
|
||||
|
||||
expect(await clickMenuBarItem(page, 'Inspect'), 'Inspect menu').toBe(true);
|
||||
await clickMenuItemByText(page, 'Simulator');
|
||||
|
||||
await page.waitForFunction((before: string[]) => {
|
||||
const ids = Array.from(
|
||||
document.querySelectorAll('#window-container [id^="window-"]'),
|
||||
(e) => e.id);
|
||||
return ids.some((id) => !before.includes(id));
|
||||
}, idsBefore, { timeout: 60000 });
|
||||
|
||||
const idsAfter = await page.$$eval('#window-container [id^="window-"]',
|
||||
(els) => els.map((e) => e.id));
|
||||
const simWin = idsAfter.find((id) => !idsBefore.includes(id));
|
||||
expect(simWin, 'simulator window appeared').toBeTruthy();
|
||||
return simWin!;
|
||||
}
|
||||
|
||||
/**
|
||||
* Poll until the Run Simulation tool is enabled. The Run tool's
|
||||
* ENABLE(!simRunning) condition is a wxUpdateUIEvent check, and the WASM port
|
||||
* only reliably re-evaluates those when input events pump the loop — nudge
|
||||
* the mouse each poll or the toolbar can hold a stale state forever.
|
||||
*/
|
||||
export async function waitForRunToolEnabled(page: Page, timeout = 60000): Promise<void> {
|
||||
await expect
|
||||
.poll(async () => {
|
||||
await page.mouse.move(4, 4);
|
||||
await page.mouse.move(8, 8);
|
||||
const el = await findByTooltip(page, 'Run Simulation', { elementType: 'tool' });
|
||||
return !!el && el.enabled;
|
||||
}, { message: 'Run Simulation tool must be enabled', timeout })
|
||||
.toBe(true);
|
||||
}
|
||||
|
||||
/**
|
||||
* Run the loaded workbook's analysis and await the exact native run generation
|
||||
* only after its final plot, operating-point, and canvas refresh calls return.
|
||||
*/
|
||||
export async function runSimulation(page: Page): Promise<number> {
|
||||
// The simulator window div appears while the frame ctor is still
|
||||
// suspended in the init RPC; the toolbar registers its tools only after
|
||||
// init completes and the frame first paints.
|
||||
await waitForRunToolEnabled(page);
|
||||
|
||||
const generationCheckpoint = await page.evaluate(() => {
|
||||
const hooks = (globalThis as any).__ngspiceServiceTestHooks;
|
||||
if (!hooks || typeof hooks.appliedGenerationCheckpoint !== 'function'
|
||||
|| typeof hooks.waitForAppliedGenerationAfter !== 'function') {
|
||||
throw new Error('exact ngspice applied-generation hooks are missing');
|
||||
}
|
||||
return hooks.appliedGenerationCheckpoint() as number;
|
||||
});
|
||||
|
||||
expect(await clickByTooltip(page, 'Run Simulation', { elementType: 'tool' }),
|
||||
'Run tool').toBe(true);
|
||||
|
||||
const appliedReceipt = await page.evaluate(async (after: number) => {
|
||||
const hooks = (globalThis as any).__ngspiceServiceTestHooks;
|
||||
return await hooks.waitForAppliedGenerationAfter(after, 120000);
|
||||
}, generationCheckpoint);
|
||||
expect(appliedReceipt.generation, 'the clicked run published a newer applied generation')
|
||||
.toBeGreaterThan(generationCheckpoint);
|
||||
|
||||
// The native receipt fires after the final refreshes. Additionally
|
||||
// require the scheduler to hold no parked ngspice wait — a stale
|
||||
// suspended frame here means the finish path leaked a wait. (The codex
|
||||
// line awaited the execution owner's barrier; that machinery does not
|
||||
// exist on the JSPI line, and wait drainage is its observable
|
||||
// equivalent.)
|
||||
await expect.poll(
|
||||
() => page.evaluate(() => {
|
||||
const scheduler = (globalThis as any).__wxScheduler;
|
||||
return scheduler?.pendingWaits?.('ngspice') ?? -1;
|
||||
}),
|
||||
{ message: 'no ngspice wait may stay parked after the applied receipt', timeout: 30000 },
|
||||
).toBe(0);
|
||||
|
||||
// Vector traffic is result validation only. It is deliberately not used as
|
||||
// completion evidence because periodic OnSimRefresh(false) pulls can look
|
||||
// identical to the final pull at the worker boundary.
|
||||
const vectorReceipt = await page.evaluate(() =>
|
||||
((window as any).__ngspiceLog as Array<{
|
||||
sequence: number; kind: string; error?: string; length?: number;
|
||||
}>).find((entry) => entry.kind === 'get_vec_info'
|
||||
&& entry.error === undefined
|
||||
&& (entry.length ?? -1) >= 101) ?? null,
|
||||
);
|
||||
expect(vectorReceipt, 'the applied run returned a non-trivial successful vector')
|
||||
.not.toBeNull();
|
||||
|
||||
return appliedReceipt.generation;
|
||||
}
|
||||
|
|
@ -39,8 +39,10 @@ export const BOOT_TIMEOUT = 150000;
|
|||
* `(instances (project "trio" …))` entries must match this name. */
|
||||
export const TRIO_DOC = "trio";
|
||||
|
||||
import { hasNativeFailure } from "./native-failure";
|
||||
|
||||
export function hasAbort(l: { consoleLogs: string[]; errors: string[] }): boolean {
|
||||
return [...l.consoleLogs, ...l.errors].some((s) => s.includes("Aborted("));
|
||||
return hasNativeFailure(l);
|
||||
}
|
||||
|
||||
// ── Fixtures ─────────────────────────────────────────────────────────────────
|
||||
|
|
|
|||
98
tests/kicad/utils/wx-dialogs.ts
Normal file
98
tests/kicad/utils/wx-dialogs.ts
Normal file
|
|
@ -0,0 +1,98 @@
|
|||
import type { Page } from '@playwright/test';
|
||||
import { expect } from '@playwright/test';
|
||||
import { clickMenuBarItem, clickMenuItem, waitForRenderedByLabel, waitUntil } from '../../e2e/utils/element-tracker';
|
||||
|
||||
/**
|
||||
* Shared wx dialog/menu drivers for the kicad specs (one copy — previously
|
||||
* duplicated per spec, and the copies had started to drift).
|
||||
*
|
||||
* All clicks are coordinate clicks through the wx element registry: wx
|
||||
* controls are canvas-rendered on this line (no DOM identity exists — nothing
|
||||
* ever produces a data-wx-dom-id attribute), so the registry's geometry is
|
||||
* the one supported click path.
|
||||
*/
|
||||
|
||||
/** Wait for a rendered popup menu to have its items (replaces a fixed post-menu-click sleep). */
|
||||
export async function waitForMenuItems(page: Page): Promise<void> {
|
||||
await waitUntil(
|
||||
page,
|
||||
() => {
|
||||
const r = window.wxElementRegistry;
|
||||
if (!r?.findAllRendered) return false;
|
||||
return r.findAllRendered({ elementType: 'menuitem' }).length > 3;
|
||||
},
|
||||
'popup menu items rendered',
|
||||
);
|
||||
}
|
||||
|
||||
/** Resolve one visible wx button (label or &-mnemonic label) to its registry geometry. */
|
||||
export async function findWxButton(page: Page, label: string): Promise<{ x: number; y: number } | null> {
|
||||
return page.evaluate((wanted: string) => {
|
||||
const registry = window.wxElementRegistry;
|
||||
if (!registry) return null;
|
||||
const el = registry.findAll({ visible: true })
|
||||
.find((e) => (e.label === wanted || e.label === `&${wanted}`)
|
||||
&& (e.typeName ?? '').includes('Button'));
|
||||
return el ? { x: el.centerX, y: el.centerY } : null;
|
||||
}, label);
|
||||
}
|
||||
|
||||
/** Click a visible wx button by label; returns whether it was found. */
|
||||
export async function clickWxButton(page: Page, label: string): Promise<boolean> {
|
||||
const pos = await findWxButton(page, label);
|
||||
if (!pos) return false;
|
||||
await page.mouse.click(pos.x, pos.y);
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Drive File → Export → STEP/GLB/… and wait until the export dialog's Export
|
||||
* button is visible (the dialog object exists before its controls register).
|
||||
*/
|
||||
export async function openStepExportDialog(page: Page): Promise<void> {
|
||||
expect(await clickMenuBarItem(page, 'File'), 'File menu').toBe(true);
|
||||
await waitForMenuItems(page);
|
||||
await waitForRenderedByLabel(page, 'Export', { elementType: 'menuitem' });
|
||||
expect(await clickMenuItem(page, 'Export'), 'Export submenu').toBe(true);
|
||||
// Wait for the SUBMENU's item — waitForMenuItems(>3) is satisfied by
|
||||
// the still-rendered File menu items before the submenu paints.
|
||||
await waitForRenderedByLabel(page, 'STEP/GLB/BREP/XAO/PLY/STL...', { elementType: 'menuitem' });
|
||||
expect(await clickMenuItem(page, 'STEP/GLB/BREP/XAO/PLY/STL...'),
|
||||
'STEP export menu item').toBe(true);
|
||||
await page.waitForFunction(() => {
|
||||
const registry = window.wxElementRegistry;
|
||||
return !!registry && registry.findAll({ visible: true })
|
||||
.some((el) => (el.label === 'Export' || el.label === '&Export')
|
||||
&& (el.typeName ?? '').includes('Button'));
|
||||
}, null, { timeout: 20000 });
|
||||
}
|
||||
|
||||
/** Observable count of parked modal waits (each open wx modal holds one lease). */
|
||||
export async function pendingModalWaits(page: Page): Promise<number> {
|
||||
return page.evaluate(() => {
|
||||
const scheduler = (globalThis as { __wxScheduler?: { pendingWaits?: (kind: string) => number } }).__wxScheduler;
|
||||
return scheduler?.pendingWaits?.('modal') ?? -1;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Dismiss a report dialog that opens on top of the current modal stack (e.g.
|
||||
* the "Export complete" report): wait for its modal lease and its OK button,
|
||||
* click OK, and wait for the lease to release. `baseline` is the modal count
|
||||
* before the report dialog appears.
|
||||
*/
|
||||
export async function dismissReportDialog(page: Page, baseline: number, what: string): Promise<void> {
|
||||
await expect.poll(
|
||||
() => pendingModalWaits(page),
|
||||
{ message: `${what}: report dialog must open (modal lease)`, timeout: 30000 },
|
||||
).toBe(baseline + 1);
|
||||
await expect.poll(
|
||||
() => findWxButton(page, 'OK'),
|
||||
{ message: `${what}: report dialog OK button must render`, timeout: 10000 },
|
||||
).not.toBeNull();
|
||||
expect(await clickWxButton(page, 'OK'), `${what}: dismiss report dialog`).toBe(true);
|
||||
await expect.poll(
|
||||
() => pendingModalWaits(page),
|
||||
{ message: `${what}: report dialog must release its modal lease`, timeout: 10000 },
|
||||
).toBe(baseline);
|
||||
}
|
||||
|
|
@ -31,7 +31,8 @@
|
|||
"3d:test:webgl": "playwright test --project=wx-chromium e2e/3d-webgl.spec.ts",
|
||||
"tools:contract": "tsx tools/cli-contract.ts",
|
||||
"ngspice:worker-batch": "tsx tools/ngspice-worker-batch-unit.ts",
|
||||
"findings-e:contract": "tsx tools/findings-e-source-contract.ts"
|
||||
"findings-e:contract": "tsx tools/findings-e-source-contract.ts",
|
||||
"findings-e:parity": "tsx tools/service-stub-parity.ts"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@playwright/test": "^1.62.1",
|
||||
|
|
|
|||
|
|
@ -22,6 +22,64 @@ const simFrame = read("kicad/eeschema/sim/simulator_frame.cpp");
|
|||
const ngspiceCpp = read("kicad/eeschema/sim/ngspice.cpp");
|
||||
const shim = read("scripts/common/shims/jspi-scheduler.js");
|
||||
|
||||
// --- structural #ifdef scanner ----------------------------------------------
|
||||
// The wasm-only-confinement guarantees are asserted on CODE STRUCTURE (is this
|
||||
// statement lexically inside an `__EMSCRIPTEN__`-conditioned region?), never on
|
||||
// comment text: a comment-string contract fails on rewording with no behavior
|
||||
// change and passes when the guard moves outside the ifdef but the comment
|
||||
// stays — the exact regression it exists to catch.
|
||||
type Cond = "em" | "not-em" | "other";
|
||||
|
||||
function emscriptenLineMap(src: string): boolean[] {
|
||||
const stack: Cond[] = [];
|
||||
return src.split("\n").map((line) => {
|
||||
const t = line.trim();
|
||||
let m: RegExpMatchArray | null;
|
||||
if ((m = t.match(/^#\s*ifdef\s+(\w+)/))) {
|
||||
stack.push(m[1] === "__EMSCRIPTEN__" ? "em" : "other");
|
||||
} else if ((m = t.match(/^#\s*ifndef\s+(\w+)/))) {
|
||||
stack.push(m[1] === "__EMSCRIPTEN__" ? "not-em" : "other");
|
||||
} else if ((m = t.match(/^#\s*if\b(.*)/))) {
|
||||
const cond = m[1];
|
||||
const negated = /!\s*defined\s*\(?\s*__EMSCRIPTEN__/.test(cond);
|
||||
const positive = /defined\s*\(?\s*__EMSCRIPTEN__/.test(cond) && !negated;
|
||||
stack.push(positive ? "em" : negated ? "not-em" : "other");
|
||||
} else if (/^#\s*(else|elif)\b/.test(t)) {
|
||||
const top = stack[stack.length - 1];
|
||||
if (top === "em") stack[stack.length - 1] = "not-em";
|
||||
else if (top === "not-em") stack[stack.length - 1] = "em";
|
||||
} else if (/^#\s*endif\b/.test(t)) {
|
||||
stack.pop();
|
||||
}
|
||||
return stack.includes("em");
|
||||
});
|
||||
}
|
||||
|
||||
/** Line indexes (0-based) of every occurrence of `needle` in `src`. */
|
||||
function occurrenceLines(src: string, needle: string): number[] {
|
||||
const out: number[] = [];
|
||||
src.split("\n").forEach((line, i) => {
|
||||
if (line.includes(needle)) out.push(i);
|
||||
});
|
||||
return out;
|
||||
}
|
||||
|
||||
function assertOccurrences(
|
||||
src: string,
|
||||
map: boolean[],
|
||||
needle: string,
|
||||
expect: { total: number; insideEm: number },
|
||||
label: string,
|
||||
): void {
|
||||
const lines = occurrenceLines(src, needle);
|
||||
assert.equal(lines.length, expect.total,
|
||||
`${label}: expected ${expect.total} occurrence(s) of "${needle}", found ${lines.length}`);
|
||||
const inside = lines.filter((i) => map[i]).length;
|
||||
assert.equal(inside, expect.insideEm,
|
||||
`${label}: ${inside} of ${lines.length} occurrence(s) of "${needle}" are inside an `
|
||||
+ `__EMSCRIPTEN__ region, expected ${expect.insideEm}`);
|
||||
}
|
||||
|
||||
// --- E-5: ngspice event handler bound to exact module identity --------------
|
||||
assert.ok(sharedspice.includes("const installingModule = Module"),
|
||||
"E-5: js_ngspice_install_events must capture the installing module");
|
||||
|
|
@ -61,18 +119,82 @@ for (const symbol of ["runWaitCompletion", "_terminalizeNativeTrap",
|
|||
}
|
||||
|
||||
// --- E-7: per-session run generation, behavioral drops wasm-only ------------
|
||||
for (const token of ["s_nextSimRunGeneration", "allocateSimRunGeneration",
|
||||
"SetExtraLong", "m_lastAppliedSimRunGeneration"]) {
|
||||
assert.ok(simFrame.includes(token),
|
||||
`E-7: simulator_frame.cpp must carry the run-generation mechanism (${token})`);
|
||||
const simMap = emscriptenLineMap(simFrame);
|
||||
|
||||
// The acceptance guards (onSimStarted entry, onSimFinished entry, and the
|
||||
// post-wxYield re-check) are the three `generation != m_simRunGeneration`
|
||||
// comparisons — every one must sit inside an __EMSCRIPTEN__ region.
|
||||
assertOccurrences(simFrame, simMap, "generation != m_simRunGeneration",
|
||||
{ total: 3, insideEm: 3 }, "E-7 acceptance guards");
|
||||
// The unowned-event drop.
|
||||
assertOccurrences(simFrame, simMap, "delete event;",
|
||||
{ total: 1, insideEm: 1 }, "E-7 unowned-event drop");
|
||||
// The bookkeeping stays UNGUARDED by design (inert on native — every reader
|
||||
// is guarded): the generation allocator and the event stamping.
|
||||
assertOccurrences(simFrame, simMap, "= allocateSimRunGeneration()",
|
||||
{ total: 1, insideEm: 0 }, "E-7 bookkeeping (allocator call)");
|
||||
assertOccurrences(simFrame, simMap, "SetExtraLong",
|
||||
{ total: 1, insideEm: 0 }, "E-7 bookkeeping (event stamping)");
|
||||
assert.ok(simFrame.includes("s_nextSimRunGeneration")
|
||||
&& simFrame.includes("m_lastAppliedSimRunGeneration"),
|
||||
"E-7: simulator_frame.cpp must carry the run-generation mechanism");
|
||||
|
||||
// The final-refresh receipt lives at the right altitude: one ifdef'd call in
|
||||
// kicad, the JS hook knowledge in the stub layer.
|
||||
assertOccurrences(simFrame, simMap, "pcbjam_sim_run_applied( generation )",
|
||||
{ total: 1, insideEm: 1 }, "E-7 receipt call");
|
||||
assert.ok(!simFrame.includes("__pcbjamNgspiceFinalRefreshApplied"),
|
||||
"E-7 REGRESSION: the harness hook name is back inside kicad source — it belongs "
|
||||
+ "to wasm/stubs/sharedspice_client.cpp");
|
||||
assert.ok(sharedspice.includes("__pcbjamNgspiceFinalRefreshApplied"),
|
||||
"E-7: sharedspice_client.cpp must implement the final-refresh receipt hook");
|
||||
|
||||
// --- E-12: crash-exit IDLE before RUNNING consumes the pending token --------
|
||||
// `generation = m_pendingRunGeneration.exchange` appears twice: the RUNNING
|
||||
// consumption (unguarded bookkeeping) and the IDLE crash-exit fallback
|
||||
// (behavioral — wasm-only).
|
||||
assertOccurrences(simFrame, simMap, "generation = m_pendingRunGeneration.exchange",
|
||||
{ total: 2, insideEm: 1 }, "E-12 IDLE pending fallback");
|
||||
|
||||
// --- E-13: a failed launch withdraws its token and resets the busy state ----
|
||||
assertOccurrences(simFrame, simMap, "m_reporter->SetRunGeneration( 0 )",
|
||||
{ total: 1, insideEm: 1 }, "E-13 failed-launch reset");
|
||||
|
||||
// --- E-11: get_vec clamps v_length to the transferred arrays + frees on fail -
|
||||
assert.ok(sharedspice.includes("length = Math.min( length, nComp >> 1 )"),
|
||||
"E-11: the vector prepare must clamp v_length to the transferred arrays");
|
||||
assert.ok(/std::free\( vname \);\s*\n\s*std::free\( real \);\s*\n\s*std::free\( comp \);/
|
||||
.test(sharedspice),
|
||||
"E-11: pcbjam_ngGet_Vec_Info must free the prepare's buffers on every failure path");
|
||||
|
||||
// --- E-16: the event handler gates on its INSTALLING module's scheduler -----
|
||||
assert.ok(sharedspice.includes("const installingScheduler = globalThis.__wxScheduler"),
|
||||
"E-16: js_ngspice_install_events must capture the installing scheduler");
|
||||
|
||||
// --- E-15: every wxWasmBeginWait caller bails on a refused token -------------
|
||||
// (The three worker stubs are asserted in the E-8 block above.)
|
||||
for (const [rel, expectedBegins] of [
|
||||
["wxwidgets/src/wasm/fontenum.cpp", 1],
|
||||
["wxwidgets/src/wasm/clipbrd.cpp", 4],
|
||||
["wxwidgets/src/wasm/dialog.cpp", 1],
|
||||
["wxwidgets/src/wasm/evtloop.cpp", 1],
|
||||
["kicad/3d-viewer/3d_cache/pcbjam_model_fetch.cpp", 1],
|
||||
["kicad/pcbnew/pcb_io/pcbjam_fp/pcb_io_pcbjam_fp.cpp", 1],
|
||||
["kicad/eeschema/sch_io/pcbjam_lib/sch_io_pcbjam_lib.cpp", 1],
|
||||
] as const) {
|
||||
const src = read(rel);
|
||||
const begins = (src.match(/=\s*wxWasmBeginWait\s*\(/g) ?? []).length;
|
||||
const guards = (src.match(/if\s*\(\s*(?:token|waitToken)\s*<=\s*0\s*\)/g) ?? []).length;
|
||||
assert.equal(begins, expectedBegins,
|
||||
`E-15: ${rel} should mint ${expectedBegins} wait token(s), found ${begins}`);
|
||||
assert.ok(guards >= begins,
|
||||
`E-15: ${rel} has ${begins} wxWasmBeginWait call(s) but only ${guards} `
|
||||
+ "token<=0 guard(s) — a refused token must never start its request");
|
||||
}
|
||||
for (const symbol of ["terminalize", "resolveRefused"]) {
|
||||
assert.ok(shim.includes(symbol),
|
||||
`E-14/E-15: jspi-scheduler.js must provide ${symbol}`);
|
||||
}
|
||||
assert.equal(
|
||||
(simFrame.match(/Generation acceptance is confined to the wasm build/g) ?? []).length, 2,
|
||||
"E-7: both handler acceptance guards must be confined to the wasm build");
|
||||
assert.ok(simFrame.includes("drop is confined to the wasm build"),
|
||||
"E-7: the unowned-event drop must be confined to the wasm build");
|
||||
assert.ok(simFrame.includes("Wasm-only, findings E-7"),
|
||||
"E-7: the post-wxYield re-check must be confined to the wasm build");
|
||||
|
||||
// --- E-9: destructor unregisters the sharedspice callbacks ------------------
|
||||
assert.ok(/#ifdef __EMSCRIPTEN__[\s\S]{0,400}pcbjam_ngspice_reset_callbacks\( this \)/
|
||||
|
|
|
|||
57
tests/tools/lib/worker-constants.ts
Normal file
57
tests/tools/lib/worker-constants.ts
Normal file
|
|
@ -0,0 +1,57 @@
|
|||
import { readFileSync } from "node:fs";
|
||||
import * as path from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
|
||||
/**
|
||||
* Parse `const NAME = <numeric expr>;` constants out of a JS/TS source — the
|
||||
* ONE source of truth for the ngspice transport numbers. The reducer and the
|
||||
* parity tripwire derive their expectations from here instead of hardcoding
|
||||
* copies that silently go stale when the protocol numbers move.
|
||||
*/
|
||||
const here = path.dirname(fileURLToPath(import.meta.url));
|
||||
export const repoRoot = path.resolve(here, "../../..");
|
||||
|
||||
export function readRepoFile(rel: string): string {
|
||||
return readFileSync(path.join(repoRoot, rel), "utf8");
|
||||
}
|
||||
|
||||
export function parseConstants(
|
||||
source: string,
|
||||
names: readonly string[],
|
||||
label: string,
|
||||
): Record<string, number> {
|
||||
const out: Record<string, number> = {};
|
||||
for (const name of names) {
|
||||
const m = source.match(new RegExp(`const ${name}\\s*=\\s*([^;]+);`));
|
||||
if (!m) throw new Error(`${label}: constant ${name} not found`);
|
||||
const expr = m[1]!.trim();
|
||||
// Strictly digits/arithmetic/underscores — anything else is rejected, so
|
||||
// the Function() evaluation below can only compute a number, never run
|
||||
// code from the scanned source.
|
||||
if (!/^[\d\s*+\-()_]+$/.test(expr)) {
|
||||
throw new Error(`${label}: constant ${name} is not a numeric expression: ${expr}`);
|
||||
}
|
||||
out[name] = Function(`"use strict"; return (${expr});`)() as number;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
export const NGSPICE_WORKER_REL = "web/standalone/src/wasm/ngspice-worker.js";
|
||||
|
||||
export const NGSPICE_WORKER_CONSTANTS = [
|
||||
"MAX_EVENT_BATCH_LINES",
|
||||
"MAX_EVENT_BATCH_UTF8_BYTES",
|
||||
"MAX_EVENT_UNACKED_FRAMES",
|
||||
"MAX_EVENT_UNACKED_UTF8_BYTES",
|
||||
"MAX_DEFERRED_EVENTS",
|
||||
"MAX_DEFERRED_UTF8_BYTES",
|
||||
] as const;
|
||||
|
||||
/** The production worker's transport constants, parsed from its source. */
|
||||
export function ngspiceWorkerConstants(): Record<string, number> {
|
||||
return parseConstants(
|
||||
readRepoFile(NGSPICE_WORKER_REL),
|
||||
NGSPICE_WORKER_CONSTANTS,
|
||||
NGSPICE_WORKER_REL,
|
||||
);
|
||||
}
|
||||
|
|
@ -52,6 +52,38 @@ const EXCLUDED_DIRS = new Set([
|
|||
'scripts',
|
||||
]);
|
||||
|
||||
// Non-playwright gates CI must keep invoking. This lint's per-spec model only
|
||||
// understands "npm run test:*" playwright scripts; these gates (vitest for
|
||||
// web/standalone, the ngspice transport reducer, and the findings-E source/
|
||||
// parity contracts) live outside that model — so pin their literal workflow
|
||||
// invocations here. Deleting a step from a workflow re-fails this lint,
|
||||
// closing the exact "nothing runs it" rot class findings-E was about. (The
|
||||
// vitest include glob auto-covers new *.test.ts files, so per-file coverage
|
||||
// needs no proof.)
|
||||
const NON_PLAYWRIGHT_GATES = [
|
||||
'pnpm --filter @pcbjam/standalone test',
|
||||
'npm run ngspice:worker-batch',
|
||||
'npm run findings-e:contract',
|
||||
'npm run findings-e:parity',
|
||||
];
|
||||
|
||||
function assertNonPlaywrightGates(): void {
|
||||
const bodies: string[] = [];
|
||||
for (const f of fs.readdirSync(WORKFLOWS_DIR)) {
|
||||
if (!/\.ya?ml$/.test(f)) continue;
|
||||
bodies.push(fs.readFileSync(path.join(WORKFLOWS_DIR, f), 'utf8'));
|
||||
}
|
||||
const all = bodies.join('\n');
|
||||
const missing = NON_PLAYWRIGHT_GATES.filter((cmd) => !all.includes(cmd));
|
||||
if (missing.length) {
|
||||
throw new Error(
|
||||
`non-playwright CI gate(s) missing from ${WORKFLOWS_DIR}: ` +
|
||||
missing.map((m) => `"${m}"`).join(', ') +
|
||||
' — a gate nothing invokes protects nothing'
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// ── 1. what CI invokes ────────────────────────────────────────────────────────
|
||||
function ciTestScripts(): string[] {
|
||||
const names = new Set<string>();
|
||||
|
|
@ -141,6 +173,8 @@ function specUniverse(dir = TESTS_ROOT, rel = ''): string[] {
|
|||
}
|
||||
|
||||
// ── run ───────────────────────────────────────────────────────────────────────
|
||||
assertNonPlaywrightGates();
|
||||
|
||||
const invocations = ciTestScripts().map(resolveScript);
|
||||
|
||||
const covered = new Set<string>();
|
||||
|
|
|
|||
|
|
@ -28,12 +28,25 @@ type Rule = {
|
|||
|
||||
const marker = (s: string) => /eslint-disable|documented|dwell/i.test(s);
|
||||
|
||||
// The canonical dwell marker (tests/TESTING.md) is
|
||||
// `// eslint-disable-line -- documented interaction dwell: <why>`
|
||||
// — a marker without the `: <why>` is a blind sleep wearing the uniform.
|
||||
const DWELL_MARKER = /documented interaction dwell/;
|
||||
const DWELL_MARKER_WITH_WHY = /documented interaction dwell:\s*\S/;
|
||||
const bareDwellMarker = (s: string) => DWELL_MARKER.test(s) && !DWELL_MARKER_WITH_WHY.test(s);
|
||||
|
||||
const RULES: Rule[] = [
|
||||
{
|
||||
name: 'no-blind-waitForTimeout',
|
||||
message: 'blind waitForTimeout — use waitUntil/expect.poll/web-first assertion, or annotate a documented interaction dwell',
|
||||
hit: (line, prev) => /\.waitForTimeout\s*\(/.test(line) && !marker(line) && !marker(prev),
|
||||
},
|
||||
{
|
||||
name: 'dwell-marker-needs-why',
|
||||
message: 'dwell marker without its reason — the mandated form is `// eslint-disable-line -- documented interaction dwell: <why>` (tests/TESTING.md)',
|
||||
hit: (line, prev) => /\.waitForTimeout\s*\(/.test(line)
|
||||
&& (bareDwellMarker(line) || (!DWELL_MARKER.test(line) && bareDwellMarker(prev))),
|
||||
},
|
||||
{
|
||||
name: 'no-toHaveScreenshot',
|
||||
message: 'toHaveScreenshot does inline pixel comparison — use stableShot() (offline gate)',
|
||||
|
|
|
|||
|
|
@ -8,6 +8,7 @@ import { readFileSync } from "node:fs";
|
|||
import * as path from "node:path";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import vm from "node:vm";
|
||||
import { ngspiceWorkerConstants } from "./lib/worker-constants.js";
|
||||
|
||||
const here = path.dirname(fileURLToPath(import.meta.url));
|
||||
const repo = path.resolve(here, "../..");
|
||||
|
|
@ -16,10 +17,19 @@ const workerSource = readFileSync(
|
|||
"utf8",
|
||||
);
|
||||
|
||||
// The transport numbers, parsed from the PRODUCTION worker source — the
|
||||
// reducer must never hardcode copies that go stale when the protocol moves.
|
||||
const C = ngspiceWorkerConstants();
|
||||
const BATCH_LINES = C.MAX_EVENT_BATCH_LINES!;
|
||||
const BATCH_BYTES = C.MAX_EVENT_BATCH_UTF8_BYTES!;
|
||||
const WINDOW_FRAMES = C.MAX_EVENT_UNACKED_FRAMES!;
|
||||
const WINDOW_BYTES = C.MAX_EVENT_UNACKED_UTF8_BYTES!;
|
||||
|
||||
type Frame = {
|
||||
id?: number;
|
||||
evt?: { kind: string; lines?: string[]; finished?: boolean };
|
||||
fatal?: string;
|
||||
pendingEvents?: Array<{ evt?: { kind: string; lines?: string[] }; eventBytes?: number }>;
|
||||
res?: { error?: string };
|
||||
eventSequence?: number;
|
||||
eventBytes?: number;
|
||||
|
|
@ -31,7 +41,9 @@ type WorkerHarness = {
|
|||
message(data: unknown): Promise<void>;
|
||||
};
|
||||
|
||||
async function createWorkerHarness(): Promise<WorkerHarness> {
|
||||
async function createWorkerHarness(
|
||||
moduleOverrides: Record<string, any> = {},
|
||||
): Promise<WorkerHarness> {
|
||||
const frames: Frame[] = [];
|
||||
let messageHandler!: (event: { data: unknown }) => Promise<void>;
|
||||
const module: Record<string, any> = {
|
||||
|
|
@ -44,6 +56,7 @@ async function createWorkerHarness(): Promise<WorkerHarness> {
|
|||
allVecs: () => [],
|
||||
running: () => false,
|
||||
cmInputPath: () => undefined,
|
||||
...moduleOverrides,
|
||||
};
|
||||
const workerGlobal: Record<string, unknown> = {
|
||||
NGSPICE_GLUE_URL: "https://pcbjam.test/ngspice_service.js",
|
||||
|
|
@ -63,6 +76,7 @@ async function createWorkerHarness(): Promise<WorkerHarness> {
|
|||
Map,
|
||||
JSON,
|
||||
Promise,
|
||||
TextEncoder,
|
||||
queueMicrotask,
|
||||
importScripts: () => undefined,
|
||||
NgspiceService: () => Promise.resolve(module),
|
||||
|
|
@ -96,21 +110,23 @@ async function acknowledgeAll(harness: WorkerHarness): Promise<void> {
|
|||
|
||||
async function main(): Promise<void> {
|
||||
const bounded = await createWorkerHarness();
|
||||
// 1,025 synchronous lines cannot wait for a microtask: 512, 512 flush on the
|
||||
// line bound, and the final line flushes at the queued microtask.
|
||||
for (let i = 0; i < 1_025; ++i) bounded.emit(0, `line-${i}`, 0, 0);
|
||||
// Two full batches plus one synchronous line cannot wait for a microtask:
|
||||
// both flush on the line bound, and the final line flushes at the queued
|
||||
// microtask.
|
||||
const floodLines = 2 * BATCH_LINES + 1;
|
||||
for (let i = 0; i < floodLines; ++i) bounded.emit(0, `line-${i}`, 0, 0);
|
||||
assert.deepEqual(
|
||||
bounded.frames.map((frame) => frame.evt?.lines?.length),
|
||||
[512, 512],
|
||||
[BATCH_LINES, BATCH_LINES],
|
||||
);
|
||||
await Promise.resolve();
|
||||
assert.deepEqual(
|
||||
bounded.frames.map((frame) => frame.evt?.lines?.length),
|
||||
[512, 512, 1],
|
||||
[BATCH_LINES, BATCH_LINES, 1],
|
||||
);
|
||||
assert.deepEqual(
|
||||
bounded.frames.flatMap((frame) => frame.evt?.lines ?? []),
|
||||
Array.from({ length: 1_025 }, (_, i) => `line-${i}`),
|
||||
Array.from({ length: floodLines }, (_, i) => `line-${i}`),
|
||||
);
|
||||
await acknowledgeAll(bounded);
|
||||
console.log("ok synchronous output flushes in bounded ordered line chunks");
|
||||
|
|
@ -125,10 +141,10 @@ assert.deepEqual(
|
|||
bounded.frames[0]!.evt!.lines!.map((line) => line.at(-1)),
|
||||
["0", "1"],
|
||||
);
|
||||
assert.ok(bounded.frames[0]!.eventBytes! <= 1024 * 1024);
|
||||
assert.ok(bounded.frames[0]!.eventBytes! <= BATCH_BYTES);
|
||||
await Promise.resolve();
|
||||
assert.equal(bounded.frames[1]!.evt!.lines!.length, 1);
|
||||
assert.ok(bounded.frames[1]!.eventBytes! <= 1024 * 1024);
|
||||
assert.ok(bounded.frames[1]!.eventBytes! <= BATCH_BYTES);
|
||||
await acknowledgeAll(bounded);
|
||||
console.log("ok UTF-8 byte pressure flushes before retaining the crossing line");
|
||||
|
||||
|
|
@ -144,10 +160,10 @@ for (let i = 0; i < 100_000; ++i) {
|
|||
}
|
||||
await Promise.resolve();
|
||||
const stormEvents = storm.frames.filter((frame) => frame.evt);
|
||||
assert.ok(stormEvents.length <= 64);
|
||||
assert.ok(stormEvents.length <= WINDOW_FRAMES);
|
||||
assert.ok(
|
||||
stormEvents.reduce((sum, frame) => sum + frame.eventBytes!, 0)
|
||||
<= 8 * 1024 * 1024,
|
||||
<= WINDOW_BYTES,
|
||||
);
|
||||
assert.equal(storm.frames.filter((frame) => frame.fatal).length, 1);
|
||||
assert.match(storm.frames.find((frame) => frame.fatal)!.fatal!, /deferred/);
|
||||
|
|
@ -160,44 +176,119 @@ console.log("ok 100,000 synchronous chunk attempts cannot exceed transport cre
|
|||
// window behind (observed as "event transport exceeded 64 frames" ending the
|
||||
// eeschema second-run spec).
|
||||
const paced = await createWorkerHarness();
|
||||
for (let i = 0; i < 80; ++i) {
|
||||
const pacedTotal = WINDOW_FRAMES + 16;
|
||||
for (let i = 0; i < pacedTotal; ++i) {
|
||||
paced.emit(2, "", i % 2, 0); // bg toggles: one frame per emit, no batching
|
||||
}
|
||||
await Promise.resolve();
|
||||
assert.equal(paced.frames.filter((f) => f.fatal).length, 0,
|
||||
"a full window with a live consumer must not be terminal");
|
||||
assert.equal(paced.frames.filter((f) => f.evt).length, 64,
|
||||
assert.equal(paced.frames.filter((f) => f.evt).length, WINDOW_FRAMES,
|
||||
"exactly the credit window is in flight");
|
||||
await acknowledgeAll(paced);
|
||||
await Promise.resolve();
|
||||
const pacedEvents = paced.frames.filter((f) => f.evt);
|
||||
assert.equal(pacedEvents.length, 80, "deferred frames drained after acks");
|
||||
assert.equal(pacedEvents.length, pacedTotal, "deferred frames drained after acks");
|
||||
assert.deepEqual(
|
||||
pacedEvents.map((f) => f.evt!.finished),
|
||||
Array.from({ length: 80 }, (_, i) => !(i % 2 === 0)),
|
||||
Array.from({ length: pacedTotal }, (_, i) => !(i % 2 === 0)),
|
||||
"deferred frames preserve emission order",
|
||||
);
|
||||
console.log("ok a full credit window defers and drains in order, never terminal");
|
||||
|
||||
const oversize = await createWorkerHarness();
|
||||
const oversizeFatal = `ngspice event line exceeds ${BATCH_BYTES} UTF-8 bytes`;
|
||||
assert.throws(
|
||||
() => oversize.emit(0, "y".repeat(1024 * 1024), 0, 0),
|
||||
/ngspice event line exceeds 1048576 UTF-8 bytes/,
|
||||
() => oversize.emit(0, "y".repeat(BATCH_BYTES), 0, 0),
|
||||
new RegExp(oversizeFatal),
|
||||
);
|
||||
assert.deepEqual(oversize.frames, [{
|
||||
fatal: "ngspice event line exceeds 1048576 UTF-8 bytes",
|
||||
fatal: oversizeFatal,
|
||||
pendingEvents: [],
|
||||
}]);
|
||||
assert.throws(
|
||||
() => oversize.emit(0, "late", 0, 0),
|
||||
/ngspice event line exceeds 1048576 UTF-8 bytes/,
|
||||
new RegExp(oversizeFatal),
|
||||
);
|
||||
await oversize.message({ id: 91, req: { kind: "running" } });
|
||||
assert.deepEqual(oversize.frames.at(-1), {
|
||||
id: 91,
|
||||
res: { error: "ngspice event line exceeds 1048576 UTF-8 bytes" },
|
||||
res: { error: oversizeFatal },
|
||||
});
|
||||
console.log("ok a single over-limit line is never retained and terminalizes requests");
|
||||
|
||||
// E-20: the oversize-line path promises "every earlier line was accepted …
|
||||
// transfer it before refusing this line". With the credit window FULL, that
|
||||
// flush can only DEFER — the terminal stop must ship the deferred frames
|
||||
// inside the fatal notice instead of wiping them (they are typically the last
|
||||
// diagnostics explaining why the run died).
|
||||
const prefixed = await createWorkerHarness();
|
||||
for (let i = 0; i < WINDOW_FRAMES; ++i) prefixed.emit(2, "", i % 2, 0); // fill the window
|
||||
prefixed.emit(0, "accepted-1", 0, 0);
|
||||
prefixed.emit(0, "accepted-2", 0, 0);
|
||||
prefixed.emit(0, "accepted-3", 0, 0); // open batch, flush still queued
|
||||
assert.throws(
|
||||
() => prefixed.emit(0, "y".repeat(BATCH_BYTES), 0, 0),
|
||||
new RegExp(oversizeFatal),
|
||||
);
|
||||
const terminalNotice = prefixed.frames.find((frame) => frame.fatal);
|
||||
assert.ok(terminalNotice, "terminal notice posted");
|
||||
const deliveredLines = [
|
||||
...prefixed.frames.flatMap((frame) => frame.evt?.lines ?? []),
|
||||
...(terminalNotice!.pendingEvents ?? [])
|
||||
.flatMap((entry) => entry.evt?.lines ?? []),
|
||||
];
|
||||
for (const line of ["accepted-1", "accepted-2", "accepted-3"]) {
|
||||
assert.ok(deliveredLines.includes(line),
|
||||
`accepted line "${line}" must reach the host despite the terminal stop`);
|
||||
}
|
||||
console.log("ok the accepted prefix survives a terminal stop under a full window");
|
||||
|
||||
// E-10 recovery: a REPLACEMENT worker serves engine reads before its first
|
||||
// init (the editor's crash-recovery finish pulls vectors right after a
|
||||
// worker death). An uninitialized engine traps on those entries — and a
|
||||
// trapped engine then hangs later requests, parking the finish chain. The
|
||||
// worker must answer the empty shapes itself, never touching the engine.
|
||||
const engineTrap = () => {
|
||||
throw new Error("RuntimeError: indirect call to null (uninitialized engine)");
|
||||
};
|
||||
const preInit = await createWorkerHarness({
|
||||
getVecInfo: engineTrap, curPlot: engineTrap, allPlots: engineTrap,
|
||||
allVecs: engineTrap, running: engineTrap,
|
||||
});
|
||||
await preInit.message({ id: 1, req: { kind: "get_vec_info", name: "time" } });
|
||||
assert.deepEqual(preInit.frames.at(-1), { id: 1, res: { found: false } });
|
||||
await preInit.message({ id: 2, req: { kind: "cur_plot" } });
|
||||
assert.deepEqual(preInit.frames.at(-1), { id: 2, res: { name: "" } });
|
||||
await preInit.message({ id: 3, req: { kind: "all_plots" } });
|
||||
assert.deepEqual(preInit.frames.at(-1), { id: 3, res: { names: [] } });
|
||||
await preInit.message({ id: 4, req: { kind: "running" } });
|
||||
assert.deepEqual(preInit.frames.at(-1), { id: 4, res: { running: false } });
|
||||
// After init, reads reach the engine again (the trapping fake IS called).
|
||||
await preInit.message({ id: 5, req: { kind: "init" } });
|
||||
assert.deepEqual(preInit.frames.at(-1), { id: 5, res: { ret: 0 } });
|
||||
await preInit.message({ id: 6, req: { kind: "get_vec_info", name: "time" } });
|
||||
assert.match(
|
||||
(preInit.frames.at(-1) as { res?: { error?: string } }).res!.error!,
|
||||
/uninitialized engine/,
|
||||
);
|
||||
console.log("ok engine reads answer their empty shapes before the first init");
|
||||
|
||||
// …and engine WRITES lazy-init the fresh engine (the editor issues
|
||||
// cm_input_path/circ before its validate() re-init), with the init request
|
||||
// idempotent per worker engine.
|
||||
let lazyInits = 0;
|
||||
const lazy = await createWorkerHarness({
|
||||
init: () => { lazyInits++; return 0; },
|
||||
});
|
||||
await lazy.message({ id: 1, req: { kind: "circ", lines: ["*", ".end"] } });
|
||||
assert.equal(lazyInits, 1, "first write initialized the engine");
|
||||
assert.deepEqual(lazy.frames.at(-1), { id: 1, res: { ret: 0 } });
|
||||
await lazy.message({ id: 2, req: { kind: "init" } });
|
||||
assert.equal(lazyInits, 1, "init is idempotent per worker engine");
|
||||
assert.deepEqual(lazy.frames.at(-1), { id: 2, res: { ret: 0 } });
|
||||
console.log("ok engine writes lazy-init a fresh engine; init is idempotent");
|
||||
|
||||
const ackMismatch = await createWorkerHarness();
|
||||
ackMismatch.emit(2, "", 0, 0);
|
||||
const credited = ackMismatch.frames[0]!;
|
||||
|
|
|
|||
94
tests/tools/service-stub-parity.ts
Normal file
94
tests/tools/service-stub-parity.ts
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
/**
|
||||
* Stub/production parity tripwire (findings group E guardrail). The e2e
|
||||
* harness drives hand-maintained MIRRORS of the worker services
|
||||
* (tests/kicad/utils/{ngspice,occ}-service.ts) while production ships
|
||||
* web/standalone/src/wasm/{ngspice,occ}-service.ts — a fix landed in one copy
|
||||
* and not the other silently invalidates what the browser specs claim to
|
||||
* prove. Until the copies collapse into one shared lifecycle module (the
|
||||
* deferred refactor), this tool pins the load-bearing invariants both sides
|
||||
* must share, parsing ACTUAL VALUES — never comment text.
|
||||
* Run: npm run findings-e:parity
|
||||
*/
|
||||
import { strict as assert } from "node:assert";
|
||||
import {
|
||||
ngspiceWorkerConstants,
|
||||
parseConstants,
|
||||
readRepoFile,
|
||||
} from "./lib/worker-constants.js";
|
||||
|
||||
const prodNgspice = readRepoFile("web/standalone/src/wasm/ngspice-service.ts");
|
||||
const prodOcc = readRepoFile("web/standalone/src/wasm/occ-service.ts");
|
||||
const stubNgspice = readRepoFile("tests/kicad/utils/ngspice-service.ts");
|
||||
const stubOcc = readRepoFile("tests/kicad/utils/occ-service.ts");
|
||||
const bootTs = readRepoFile("web/standalone/src/wasm/boot.ts");
|
||||
const workerJs = readRepoFile("web/standalone/src/wasm/ngspice-worker.js");
|
||||
|
||||
// --- credit window: worker ≡ production host ≡ harness stub -----------------
|
||||
// The host queue caps must EQUAL the worker's credit window or the protocol
|
||||
// retires healthy workers ("event-frame queue exceeded credit").
|
||||
const worker = ngspiceWorkerConstants();
|
||||
const hostCaps = ["MAX_QUEUED_EVENT_FRAMES", "MAX_QUEUED_EVENT_BYTES"] as const;
|
||||
const prodCaps = parseConstants(prodNgspice, hostCaps, "production ngspice-service.ts");
|
||||
const stubCaps = parseConstants(stubNgspice, hostCaps, "stub ngspice-service.ts");
|
||||
assert.equal(prodCaps.MAX_QUEUED_EVENT_FRAMES, worker.MAX_EVENT_UNACKED_FRAMES,
|
||||
"credit window FRAMES: production host must equal the worker");
|
||||
assert.equal(prodCaps.MAX_QUEUED_EVENT_BYTES, worker.MAX_EVENT_UNACKED_UTF8_BYTES,
|
||||
"credit window BYTES: production host must equal the worker");
|
||||
assert.deepEqual(stubCaps, prodCaps,
|
||||
"credit window: the harness stub must equal the production host");
|
||||
|
||||
// --- E-19: the frame ack survives a throwing handler (both copies) ----------
|
||||
for (const [label, src] of [
|
||||
["production ngspice-service.ts", prodNgspice],
|
||||
["stub ngspice-service.ts", stubNgspice],
|
||||
] as const) {
|
||||
const start = src.indexOf("const dispatchEvt");
|
||||
const end = src.indexOf("deliverTerminalEvents", start);
|
||||
assert.ok(start >= 0 && end > start, `${label}: dispatchEvt body not found`);
|
||||
const body = src.slice(start, end);
|
||||
assert.ok(/finally\s*\{[\s\S]{0,80}?ackEvent\(/.test(body),
|
||||
`E-19 REGRESSION (${label}): dispatchEvt must ack the owned frame in a `
|
||||
+ "finally — a throwing handler leaked one credit unit per throw");
|
||||
}
|
||||
|
||||
// --- E-20: the terminal notice's pendingEvents are consumed (both copies) ---
|
||||
for (const [label, src] of [
|
||||
["production ngspice-service.ts", prodNgspice],
|
||||
["stub ngspice-service.ts", stubNgspice],
|
||||
] as const) {
|
||||
assert.ok(src.includes("deliverTerminalEvents(data.pendingEvents)"),
|
||||
`E-20 (${label}): the fatal branch must deliver the worker's accepted-`
|
||||
+ "prefix pendingEvents before retiring");
|
||||
}
|
||||
assert.ok(workerJs.includes("postMessage({ fatal: reason, pendingEvents })"),
|
||||
"E-20 (ngspice-worker.js): the terminal notice must carry the deferred frames");
|
||||
|
||||
// --- E-10: retirement synthesizes the controlled exit (both copies) ---------
|
||||
assert.ok(/kind: "exit", status: 1, immediate: true, quit: false/.test(prodNgspice),
|
||||
"E-10 (production): retireWorker must synthesize the controlled exit");
|
||||
assert.ok(/kind: 'exit', status: 1, immediate: true, quit: false/.test(stubNgspice),
|
||||
"E-10 (stub): retireWorker must synthesize the controlled exit");
|
||||
|
||||
// --- E-10 recovery: the worker guards pre-init engine access ----------------
|
||||
assert.ok(workerJs.includes("let engineReady") && workerJs.includes("ensureEngine("),
|
||||
"E-10 (ngspice-worker.js): pre-init reads must answer empty shapes and "
|
||||
+ "writes must lazy-init the fresh engine");
|
||||
|
||||
// --- E-22 / E-1: a boot deadline exists in all four lifecycle copies --------
|
||||
for (const [label, src] of [
|
||||
["production ngspice-service.ts", prodNgspice],
|
||||
["production occ-service.ts", prodOcc],
|
||||
["stub ngspice-service.ts", stubNgspice],
|
||||
["stub occ-service.ts", stubOcc],
|
||||
] as const) {
|
||||
assert.ok(src.includes("bootTimer") && src.includes("boot timed out after"),
|
||||
`E-22 REGRESSION (${label}): the boot deadline is gone — a wedged worker `
|
||||
+ "boot hangs every request with zero evidence");
|
||||
}
|
||||
|
||||
// --- E-14: boot wires Module.onAbort to the scheduler's terminal latch ------
|
||||
assert.ok(/onAbort[\s\S]{0,600}?terminalize\?\.\(\s*"emscripten abort"/.test(bootTs),
|
||||
"E-14 (boot.ts): Module.onAbort must latch __wxScheduler.terminalize — the "
|
||||
+ "authoritative abort notification");
|
||||
|
||||
console.log("service-stub-parity: all green");
|
||||
|
|
@ -36,7 +36,7 @@ async function clickTreeRow(page: Page, label: string): Promise<boolean> {
|
|||
}, label);
|
||||
if (!hit) return false;
|
||||
await page.mouse.click(hit.x, hit.y);
|
||||
await page.waitForTimeout(300); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(300); // eslint-disable-line -- documented interaction dwell: tree-row selection commit; no observable
|
||||
return true;
|
||||
}
|
||||
|
||||
|
|
@ -79,7 +79,7 @@ test.fixme(
|
|||
|
||||
// New Footprint → auto-saves into the writable lib (tryToSaveFootprintInLibrary).
|
||||
expect(await clickByTooltip(page, 'New Footprint'), 'New Footprint clicked').toBe(true);
|
||||
await page.waitForTimeout(1500); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(1500); // eslint-disable-line -- documented interaction dwell: New Footprint dialog/creation commit
|
||||
// Belt-and-braces explicit save.
|
||||
await focusCanvas(page);
|
||||
await page.keyboard.press('Control+s');
|
||||
|
|
|
|||
|
|
@ -55,13 +55,13 @@ test.fixme(
|
|||
});
|
||||
expect(hdr, 'Item column header found').not.toBeNull();
|
||||
await page.mouse.click(hdr!.cx, hdr!.cy + hdr!.hgt + 8);
|
||||
await page.waitForTimeout(200); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(200); // eslint-disable-line -- documented interaction dwell: tree focus commit
|
||||
await page.keyboard.press('Home');
|
||||
await page.waitForTimeout(150); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(150); // eslint-disable-line -- documented interaction dwell: tree-nav keystroke commit
|
||||
await page.keyboard.press('ArrowDown');
|
||||
await page.waitForTimeout(150); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(150); // eslint-disable-line -- documented interaction dwell: tree-nav keystroke commit
|
||||
await page.keyboard.press('ArrowUp');
|
||||
await page.waitForTimeout(400); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(400); // eslint-disable-line -- documented interaction dwell: tree selection commit
|
||||
|
||||
expect(await clickByTooltip(page, 'New Symbol...'), 'New Symbol clicked').toBe(true);
|
||||
await stableShot(page, 'symremote-02-newsym.png');
|
||||
|
|
@ -77,7 +77,7 @@ test.fixme(
|
|||
});
|
||||
expect(nameField, 'New Symbol name field present').toBeTruthy();
|
||||
await page.mouse.click(nameField!.cx, nameField!.cy);
|
||||
await page.waitForTimeout(150); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(150); // eslint-disable-line -- documented interaction dwell: name field focus commit
|
||||
await page.keyboard.press('Control+a');
|
||||
await page.keyboard.press('Delete');
|
||||
await page.keyboard.type('RemoteRes', { delay: 40 });
|
||||
|
|
|
|||
|
|
@ -57,13 +57,13 @@ test.fixme(
|
|||
// Click focuses the tree row but doesn't always select it; drive the keyboard
|
||||
// to make the first (only) library row the SELECTED item (GetTargetLibId).
|
||||
await page.mouse.click(hdr!.cx, hdr!.cy + hdr!.hgt + 8); // focus the tree
|
||||
await page.waitForTimeout(200); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(200); // eslint-disable-line -- documented interaction dwell: tree focus commit
|
||||
await page.keyboard.press('Home');
|
||||
await page.waitForTimeout(150); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(150); // eslint-disable-line -- documented interaction dwell: tree-nav keystroke commit
|
||||
await page.keyboard.press('ArrowDown');
|
||||
await page.waitForTimeout(150); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(150); // eslint-disable-line -- documented interaction dwell: tree-nav keystroke commit
|
||||
await page.keyboard.press('ArrowUp');
|
||||
await page.waitForTimeout(400); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(400); // eslint-disable-line -- documented interaction dwell: tree selection commit
|
||||
await stableShot(page, 'symwrite-02-lib-selected.png');
|
||||
|
||||
// New Symbol via the toolbar button (tooltip), proven-clickable in the harness.
|
||||
|
|
@ -91,11 +91,11 @@ test.fixme(
|
|||
const nameField = dlg.texts.find((t) => Math.abs(t.cy - 65) > 30 && Math.abs(t.cy - 87) > 30);
|
||||
expect(nameField, 'New Symbol name field present').toBeTruthy();
|
||||
await page.mouse.click(nameField!.cx, nameField!.cy);
|
||||
await page.waitForTimeout(150); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(150); // eslint-disable-line -- documented interaction dwell: name field focus commit
|
||||
await page.keyboard.press('Control+a');
|
||||
await page.keyboard.press('Delete');
|
||||
await page.keyboard.type(SYM, { delay: 40 });
|
||||
await page.waitForTimeout(300); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(300); // eslint-disable-line -- documented interaction dwell: typed-name registration commit
|
||||
await stableShot(page, 'symwrite-04-name-typed.png');
|
||||
await page.keyboard.press('Enter');
|
||||
await waitUntil(
|
||||
|
|
@ -139,7 +139,7 @@ test.fixme(
|
|||
expect(body).toContain(`(symbol "${savedName}"`);
|
||||
|
||||
// No post-save error dialog (the placeholder-file fix for GetModificationTime).
|
||||
await page.waitForTimeout(500); // eslint-disable-line -- documented interaction dwell
|
||||
await page.waitForTimeout(500); // eslint-disable-line -- documented interaction dwell: negative-assert window for a post-save error dialog
|
||||
const errDialog = await page.evaluate(() =>
|
||||
window.wxElementRegistry
|
||||
.findAll({ visible: true })
|
||||
|
|
|
|||
Loading…
Reference in a new issue