204 lines
8.8 KiB
TypeScript
204 lines
8.8 KiB
TypeScript
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';
|
|
|
|
/**
|
|
* eeschema simulator end-to-end (docs/features/ngspice-split/): the historic
|
|
* kill-point was SIMULATOR_FRAME never opening (no dlopen for libngspice);
|
|
* now NGSPICE binds the sharedspice client stub and the engine runs in the
|
|
* lazy ngspice_service worker. These specs drive the REAL UI path:
|
|
* project open → Inspect → Simulator → Run → plot, asserting the RPC/event
|
|
* plumbing (window.__ngspiceEvents / __ngspiceLog from the harness provider,
|
|
* tests/kicad/utils/ngspice-service.ts) and the rendered result.
|
|
*
|
|
* Fixture: the complete kicad demo rectifier project — its 1N4148 lives in a
|
|
* sibling diode.mod pulled in via `.include`, so a passing transient also
|
|
* proves the client stub's netlist file shipping (a missing model fails the
|
|
* 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((sch: string) => {
|
|
(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 wait for the background run to
|
|
// finish (the bg 'finished' event lands after ngspice's thread joins).
|
|
async function runSimulation(page: import('@playwright/test').Page): Promise<void> {
|
|
const evtsBefore = await page.evaluate(
|
|
() => (window as any).__ngspiceEvents.length as 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 expect
|
|
.poll(async () => {
|
|
const el = await findByTooltip(page, 'Run Simulation', { elementType: 'tool' });
|
|
return !!el && el.enabled;
|
|
}, { timeout: 60000 })
|
|
.toBe(true);
|
|
|
|
expect(await clickByTooltip(page, 'Run Simulation', { elementType: 'tool' }),
|
|
'Run tool').toBe(true);
|
|
|
|
await page.waitForFunction((n: number) => {
|
|
const evts = (window as any).__ngspiceEvents as Array<{ kind: string; finished?: boolean }>;
|
|
return evts.slice(n).some((e) => e.kind === 'bg' && e.finished === true);
|
|
}, evtsBefore, { timeout: 120000 });
|
|
}
|
|
|
|
function distinctColors(png: PNG): number {
|
|
const colors = new Set<number>();
|
|
// 8x8 grid sampling, same spirit as the 3d-viewer render check.
|
|
const stepX = Math.max(1, Math.floor(png.width / 8));
|
|
const stepY = Math.max(1, Math.floor(png.height / 8));
|
|
|
|
for (let y = 0; y < png.height; y += stepY) {
|
|
for (let x = 0; x < png.width; x += stepX) {
|
|
const i = (png.width * y + x) << 2;
|
|
colors.add((png.data[i] << 16) | (png.data[i + 1] << 8) | png.data[i + 2]);
|
|
}
|
|
}
|
|
return colors.size;
|
|
}
|
|
|
|
test.describe('eeschema simulator', () => {
|
|
test.describe.configure({ mode: 'serial' });
|
|
test.setTimeout(300000);
|
|
|
|
test('Inspect → Simulator opens the frame; service fetches lazily', async ({ page, testLogger }) => {
|
|
const ngspiceFetches: string[] = [];
|
|
page.on('request', (r) => {
|
|
if (r.url().includes('ngspice_service')) ngspiceFetches.push(r.url());
|
|
});
|
|
|
|
await page.goto('/kicad/eeschema.html');
|
|
await waitForEditorReady(page);
|
|
await loadRectifier(page);
|
|
|
|
expect(ngspiceFetches,
|
|
'ngspice_service must NOT be fetched before the simulator opens')
|
|
.toHaveLength(0);
|
|
|
|
await openSimulator(page);
|
|
await stableShot(page, 'eeschema-sim-frame.png');
|
|
|
|
// NGSPICE::init_dll ran inside the frame ctor → the client stub's init
|
|
// RPC booted the worker.
|
|
expect(ngspiceFetches.length,
|
|
'ngspice_service fetched lazily by the simulator open')
|
|
.toBeGreaterThan(0);
|
|
|
|
const all = [...testLogger.consoleLogs, ...testLogger.errors];
|
|
expect(all.filter((l) => l.includes('Aborted(')), 'no aborts').toHaveLength(0);
|
|
});
|
|
|
|
test('transient run: live console stream, vectors reach the plot, plot renders', async ({ page, testLogger }) => {
|
|
await page.goto('/kicad/eeschema.html');
|
|
await waitForEditorReady(page);
|
|
await loadRectifier(page);
|
|
const simWin = await openSimulator(page);
|
|
|
|
await runSimulation(page);
|
|
|
|
const evts = await page.evaluate(() => (window as any).__ngspiceEvents as Array<{
|
|
kind: string; lines?: string[]; finished?: boolean; t: number }>);
|
|
|
|
// Live streaming: console/status output must precede the finish event.
|
|
const finishT = evts.filter((e) => e.kind === 'bg' && e.finished).map((e) => e.t)[0];
|
|
const streamed = evts.filter(
|
|
(e) => (e.kind === 'char' || e.kind === 'stat') && e.t <= finishT);
|
|
expect(streamed.length, 'ngspice output streamed during the run')
|
|
.toBeGreaterThan(3);
|
|
|
|
// The model shipped via .include resolved (a miss fails the run with
|
|
// "unable to find definition" and produces no transient).
|
|
const charText = evts.flatMap((e) => e.lines ?? []).join('\n');
|
|
expect(charText, 'no missing-model errors').not.toMatch(/unable to find definition/i);
|
|
|
|
// The plot pulled real vector data through get_vec_info.
|
|
const vecPulls = await page.evaluate(() =>
|
|
((window as any).__ngspiceLog as Array<{ kind: string; length?: number }>)
|
|
.filter((l) => l.kind === 'get_vec_info' && (l.length ?? 0) > 100).length);
|
|
expect(vecPulls, 'plot fetched transient vectors').toBeGreaterThan(0);
|
|
|
|
// The plot area rendered something beyond a flat background.
|
|
const shot = await page.locator(`#${simWin}`).screenshot({
|
|
scale: 'css', animations: 'disabled' });
|
|
const png = PNG.sync.read(shot);
|
|
expect(distinctColors(png), 'plot window shows structure (axes/trace)')
|
|
.toBeGreaterThan(6);
|
|
|
|
await stableShot(page, 'eeschema-sim-plot.png');
|
|
|
|
const all = [...testLogger.consoleLogs, ...testLogger.errors];
|
|
expect(all.filter((l) => l.includes('Aborted(')), 'no aborts').toHaveLength(0);
|
|
const corruption = all.filter((l) =>
|
|
l.includes('index out of bounds') || l.includes('indirect call to null')
|
|
|| l.includes('uncaught exception: unwind'));
|
|
expect(corruption, 'no asyncify corruption').toHaveLength(0);
|
|
});
|
|
|
|
test('a second run after the first succeeds (engine reset path)', async ({ page, testLogger }) => {
|
|
await page.goto('/kicad/eeschema.html');
|
|
await waitForEditorReady(page);
|
|
await loadRectifier(page);
|
|
await openSimulator(page);
|
|
|
|
await runSimulation(page);
|
|
await runSimulation(page);
|
|
|
|
const finishCount = await page.evaluate(() =>
|
|
((window as any).__ngspiceEvents as Array<{ kind: string; finished?: boolean }>)
|
|
.filter((e) => e.kind === 'bg' && e.finished === true).length);
|
|
expect(finishCount, 'two completed runs').toBeGreaterThanOrEqual(2);
|
|
|
|
const all = [...testLogger.consoleLogs, ...testLogger.errors];
|
|
expect(all.filter((l) => l.includes('Aborted(')), 'no aborts').toHaveLength(0);
|
|
});
|
|
});
|