Skip to content

3D engine that AI agents drive

Wait on renderer polls, not wall-clock timers, in the dispose tests (#2433)

Nguyen Xuan An6e3b6caf6318
diff --git a/tests/helpers/dev-server-browser.js b/tests/helpers/dev-server-browser.js
index 7950b1d4..85d95196 100644
--- a/tests/helpers/dev-server-browser.js
+++ b/tests/helpers/dev-server-browser.js
@@ -4,8 +4,10 @@ import { freePort } from './free-port.js';
const CHROME_ARGUMENTS = ['--use-angle=swiftshader', '--enable-unsafe-swiftshader', '--enable-webgl', '--ignore-gpu-blocklist'];
-async function startServer(port) {
+async function startServer(port, serverLog) {
const server = spawn(process.execPath, ['node_modules/vite/bin/vite.js', '--host', '127.0.0.1', '--port', String(port), '--strictPort'], { windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] });
+ server.stdout.on('data', (data) => serverLog.push(data.toString()));
+ server.stderr.on('data', (data) => serverLog.push(data.toString()));
await new Promise((resolve, reject) => {
const timeout = setTimeout(() => reject(new Error('The dev server did not start.')), 30000);
server.stdout.on('data', (data) => {
@@ -37,6 +39,19 @@ export function skipOrThrow(testContext, message) {
testContext.skip(message);
}
+// What the browser saw go wrong (a failed or rejected request, a console error), so a failure that only shows as "Failed to fetch" names the request behind it.
+function watchPageProblems(page) {
+ const problems = [];
+ page.on('requestfailed', (request) => problems.push(`request failed: ${request.url()} ${request.failure()?.errorText}`));
+ page.on('response', (response) => {
+ if (response.status() >= 400) problems.push(`response ${response.status()}: ${response.url()}`);
+ });
+ page.on('console', (message) => {
+ if (message.type() === 'error') problems.push(`console error: ${message.text()}`);
+ });
+ return problems;
+}
+
/**
* Runs `body(page)` on the dev server's page in headless Chrome and cleans up.
* Where Chrome or playwright is missing the test skips on a developer machine and fails on CI, where Chrome is required.
@@ -50,7 +65,8 @@ export async function withDevServerPage(testContext, body) {
return;
}
const port = await freePort();
- const server = await startServer(port);
+ const serverLog = [];
+ const server = await startServer(port, serverLog);
let browser;
try {
try {
@@ -60,8 +76,14 @@ export async function withDevServerPage(testContext, body) {
return;
}
const page = await browser.newPage({ viewport: { width: 128, height: 128 } });
+ const pageProblems = watchPageProblems(page);
await page.goto(`http://127.0.0.1:${port}/`);
- await body(page);
+ try {
+ await body(page);
+ } catch (error) {
+ error.message += `\nDev server output:\n${serverLog.join('').trim()}\nPage problems:\n${pageProblems.join('\n')}`;
+ throw error;
+ }
} finally {
await browser?.close();
server.kill();
diff --git a/tests/renderer-dispose-lifecycle.test.js b/tests/renderer-dispose-lifecycle.test.js
index 1b2dc8ea..c8b2952c 100644
--- a/tests/renderer-dispose-lifecycle.test.js
+++ b/tests/renderer-dispose-lifecycle.test.js
@@ -61,9 +61,25 @@ const SIMULATE_SLOW_LINKS_ON_DEMAND = `
const realGetProgramParameter = context.getProgramParameter.bind(context);
context.getProgramParameter = (program, parameter) => (parameter === 0x91B1 ? !context.linksAreSlow : realGetProgramParameter(program, parameter));
`;
-// Resolves 'settled' when the promise finishes, or 'hung' when it is still waiting after the timeout.
+// Counts every read of the completion status, which is how both waits in the renderer poll a link. The renderer polls on its own 8 ms timer, so the
+// tests wait on these reads (an event of the renderer) and never on a wall clock, which a loaded machine stretches without bound.
+const COUNT_COMPLETION_POLLS = `
+ context.completionPolls = 0;
+ const pollWaiters = [];
+ const parameterBeforeCounting = context.getProgramParameter.bind(context);
+ context.getProgramParameter = (program, parameter) => {
+ if (parameter === 0x91B1) {
+ context.completionPolls += 1;
+ for (const waiter of pollWaiters.filter(entry => entry.count <= context.completionPolls)) waiter.resolve();
+ }
+ return parameterBeforeCounting(program, parameter);
+ };
+ context.untilCompletionPolls = (count) => (context.completionPolls >= count ? Promise.resolve() : new Promise(resolve => pollWaiters.push({ count, resolve })));
+`;
+// Resolves 'settled' when the promise finishes, or 'hung' when the renderer has polled this many more times without finishing. A renderer that ignores dispose
+// keeps polling, so the poll count catches it the same way on a fast and on a loaded machine.
const SETTLES_OR_HANGS = `
- const settlement = (promise) => Promise.race([promise.then(() => 'settled'), new Promise(resolve => setTimeout(() => resolve('hung'), 1500))]);
+ const settlement = (promise) => Promise.race([promise.then(() => 'settled'), context.untilCompletionPolls(context.completionPolls + 20).then(() => 'hung')]);
`;
test('dispose before programsReady deletes the pending programs and shaders', async (testContext) => {
@@ -84,9 +100,9 @@ test('programsReady after dispose builds nothing on the disposed renderer', asyn
test('dispose while programsReady is waiting settles it without building', async (testContext) => {
await withDevServerPage(testContext, async (page) => {
- const result = await liveObjectsAfter(page, `${SIMULATE_SLOW_DRIVER}${SETTLES_OR_HANGS}
+ const result = await liveObjectsAfter(page, `${SIMULATE_SLOW_DRIVER}${COUNT_COMPLETION_POLLS}${SETTLES_OR_HANGS}
const ready = renderer.programsReady();
- await new Promise(resolve => setTimeout(resolve, 50));
+ await Promise.race([context.untilCompletionPolls(context.completionPolls + 2), ready]);
renderer.dispose();
if (await settlement(ready) !== 'settled') throw new Error('programsReady kept waiting after dispose');
`);
@@ -97,9 +113,9 @@ test('dispose while programsReady is waiting settles it without building', async
test('dispose while prepareFrame is waiting resolves false without building', async (testContext) => {
await withDevServerPage(testContext, async (page) => {
- const result = await liveObjectsAfter(page, `${SIMULATE_SLOW_DRIVER}${SETTLES_OR_HANGS}
+ const result = await liveObjectsAfter(page, `${SIMULATE_SLOW_DRIVER}${COUNT_COMPLETION_POLLS}${SETTLES_OR_HANGS}
const prepared = renderer.prepareFrame({});
- await new Promise(resolve => setTimeout(resolve, 50));
+ await Promise.race([context.untilCompletionPolls(context.completionPolls + 2), prepared]);
renderer.dispose();
if (await settlement(prepared) !== 'settled') throw new Error('prepareFrame kept waiting after dispose');
if (await prepared !== false) throw new Error('prepareFrame must resolve false on a disposed renderer');
@@ -114,7 +130,7 @@ const AMBIENT_OCCLUSION_FRAME = '{ eye: [3, 2, 3], effects: { ambientOcclusion:
test('dispose while prepareFrame waits for a program started by its own draw resolves false without drawing', async (testContext) => {
await withDevServerPage(testContext, async (page) => {
- const result = await liveObjectsAfter(page, `${SIMULATE_SLOW_LINKS_ON_DEMAND}${SETTLES_OR_HANGS}
+ const result = await liveObjectsAfter(page, `${SIMULATE_SLOW_LINKS_ON_DEMAND}${COUNT_COMPLETION_POLLS}${SETTLES_OR_HANGS}
await renderer.programsReady();
context.linksAreSlow = true;
const linkStatusReads = new Set();
@@ -136,8 +152,9 @@ test('dispose while prepareFrame waits for a program started by its own draw res
return deleteBeforeSpy(program);
};
const errorsBefore = context.getError();
+ const pollsBeforeFrame = context.completionPolls;
const prepared = renderer.prepareFrame(${AMBIENT_OCCLUSION_FRAME});
- await new Promise(resolve => setTimeout(resolve, 50));
+ await Promise.race([context.untilCompletionPolls(pollsBeforeFrame + 3), prepared]);
if (await Promise.race([prepared, 'waiting']) !== 'waiting') throw new Error('the frame never waited for a program, got ' + await prepared);
// The links stay slow after dispose, so only the disposed guard in the second wait can end it.
renderer.dispose();
@@ -198,8 +215,9 @@ test('resize on a lost context returns without the dimensions error', async (tes
await withDevServerPage(testContext, async (page) => {
const result = await liveObjectsAfter(page, `
await renderer.programsReady();
+ const contextLost = new Promise(resolve => context.canvas.addEventListener('webglcontextlost', resolve, { once: true }));
context.getExtension('WEBGL_lose_context').loseContext();
- await new Promise(resolve => setTimeout(resolve, 50));
+ await contextLost;
renderer.resize();
renderer.render({ eye: [3, 2, 3] });
renderer.dispose();