test: cleanup tests and configs after last folio update (#6463)

tests/android/androidTest.ts

@@ -15,7 +15,7 @@
  */
 
 import type { AndroidDevice } from '../../index';
-import { CommonArgs, baseTest } from './baseTest';
+import { CommonArgs, baseTest } from '../config/baseTest';
 import * as folio from 'folio';
 export { expect } from 'folio';
 

tests/android/browser.spec.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { androidTest as test, expect } from '../config/androidTest';
+import { androidTest as test, expect } from './androidTest';
 
 test('androidDevice.model', async function({ androidDevice }) {
   expect(androidDevice.model()).toBe('sdk_gphone_x86_arm');

tests/android/device.spec.ts

@@ -16,7 +16,7 @@
 
 import fs from 'fs';
 import { PNG } from 'pngjs';
-import { androidTest as test, expect } from '../config/androidTest';
+import { androidTest as test, expect } from './androidTest';
 
 test('androidDevice.shell', async function({ androidDevice }) {
   const output = await androidDevice.shell('echo 123');

tests/android/webview.spec.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { androidTest as test, expect } from '../config/androidTest';
+import { androidTest as test, expect } from './androidTest';
 
 test('androidDevice.webView', async function({ androidDevice }) {
   expect(androidDevice.webViews().length).toBe(0);

tests/chromium/chromium.spec.ts

@@ -19,18 +19,15 @@ import { contextTest as test, expect } from '../config/browserTest';
 import { playwrightTest } from '../config/browserTest';
 import http from 'http';
 
-test.describe('chromium', () => {
+test('should create a worker from a service worker', async ({page, server}) => {
-  test.skip(({ browserName }) => browserName !== 'chromium');
-
-  test('should create a worker from a service worker', async ({page, server}) => {
   const [worker] = await Promise.all([
     page.context().waitForEvent('serviceworker'),
     page.goto(server.PREFIX + '/serviceworkers/empty/sw.html')
   ]);
   expect(await worker.evaluate(() => self.toString())).toBe('[object ServiceWorkerGlobalScope]');
-  });
+});
 
-  test('serviceWorkers() should return current workers', async ({page, server}) => {
+test('serviceWorkers() should return current workers', async ({page, server}) => {
   const context = page.context();
   const [worker1] = await Promise.all([
     context.waitForEvent('serviceworker'),
@@ -47,9 +44,9 @@ test.describe('chromium', () => {
   expect(workers.length).toBe(2);
   expect(workers).toContain(worker1);
   expect(workers).toContain(worker2);
-  });
+});
 
-  test('should not create a worker from a shared worker', async ({page, server}) => {
+test('should not create a worker from a shared worker', async ({page, server}) => {
   await page.goto(server.EMPTY_PAGE);
   let serviceWorkerCreated;
   page.context().once('serviceworker', () => serviceWorkerCreated = true);
@@ -57,9 +54,9 @@ test.describe('chromium', () => {
     new SharedWorker('data:text/javascript,console.log("hi")');
   });
   expect(serviceWorkerCreated).not.toBeTruthy();
-  });
+});
 
-  test('Page.route should work with intervention headers', async ({server, page}) => {
+test('Page.route should work with intervention headers', async ({server, page}) => {
   server.setRoute('/intervention', (req, res) => res.end(`
     <script>
       document.write('<script src="${server.CROSS_PROCESS_PREFIX}/intervention.js">' + '</scr' + 'ipt>');
@@ -77,13 +74,9 @@ test.describe('chromium', () => {
   // Check for feature URL substring rather than https://www.chromestatus.com to
   // make it work with Edgium.
   expect(serverRequest.headers.intervention).toContain('feature/5718547946799104');
-  });
 });
 
-playwrightTest.describe('chromium', () => {
+playwrightTest('should close service worker together with the context', async ({browserType, browserOptions, server}) => {
-  playwrightTest.skip(({ browserName }) => browserName !== 'chromium');
-
-  playwrightTest('should close service worker together with the context', async ({browserType, browserOptions, server}) => {
   const browser = await browserType.launch(browserOptions);
   const context = await browser.newContext();
   const page = await context.newPage();
@@ -97,9 +90,9 @@ playwrightTest.describe('chromium', () => {
   await context.close();
   expect(messages.join('|')).toBe('worker|context');
   await browser.close();
-  });
+});
 
-  playwrightTest('should connect to an existing cdp session', async ({ browserType, browserOptions }, testInfo) => {
+playwrightTest('should connect to an existing cdp session', async ({ browserType, browserOptions }, testInfo) => {
   const port = 9339 + testInfo.workerIndex;
   const browserServer = await browserType.launch({
     ...browserOptions,
@@ -115,9 +108,9 @@ playwrightTest.describe('chromium', () => {
   } finally {
     await browserServer.close();
   }
-  });
+});
 
-  playwrightTest('should connect to an existing cdp session twice', async ({ browserType, browserOptions, server }, testInfo) => {
+playwrightTest('should connect to an existing cdp session twice', async ({ browserType, browserOptions, server }, testInfo) => {
   const port = 9339 + testInfo.workerIndex;
   const browserServer = await browserType.launch({
     ...browserOptions,
@@ -150,9 +143,9 @@ playwrightTest.describe('chromium', () => {
   } finally {
     await browserServer.close();
   }
-  });
+});
 
-  playwrightTest('should connect to existing service workers', async ({browserType, browserOptions, server}, testInfo) => {
+playwrightTest('should connect to existing service workers', async ({browserType, browserOptions, server}, testInfo) => {
   const port = 9339 + testInfo.workerIndex;
   const browserServer = await browserType.launch({
     ...browserOptions,
@@ -180,8 +173,9 @@ playwrightTest.describe('chromium', () => {
   } finally {
     await browserServer.close();
   }
-  });
+});
-  playwrightTest('should connect over a ws endpoint', async ({browserType, browserOptions, server}, testInfo) => {
+
+playwrightTest('should connect over a ws endpoint', async ({browserType, browserOptions, server}, testInfo) => {
   const port = 9339 + testInfo.workerIndex;
   const browserServer = await browserType.launch({
     ...browserOptions,
@@ -212,8 +206,9 @@ playwrightTest.describe('chromium', () => {
   } finally {
     await browserServer.close();
   }
-  });
+});
-  playwrightTest('should send extra headers with connect request', async ({browserType, browserOptions, server}, testInfo) => {
+
+playwrightTest('should send extra headers with connect request', async ({browserType, browserOptions, server}, testInfo) => {
   {
     const [request] = await Promise.all([
       server.waitForWebSocketConnectionRequest(),
@@ -242,5 +237,4 @@ playwrightTest.describe('chromium', () => {
     expect(request.headers['user-agent']).toBe('Playwright');
     expect(request.headers['foo']).toBe('bar');
   }
-  });
 });

tests/chromium/css-coverage.spec.ts

@@ -16,10 +16,7 @@
 
 import { contextTest as it, expect } from '../config/browserTest';
 
-it.describe('CSS Coverage', () => {
+it('should work', async function({page, server}) {
-  it.skip(({ browserName }) => browserName !== 'chromium');
-
-  it('should work', async function({page, server}) {
   await page.coverage.startCSSCoverage();
   await page.goto(server.PREFIX + '/csscoverage/simple.html');
   const coverage = await page.coverage.stopCSSCoverage();
@@ -30,17 +27,17 @@ it.describe('CSS Coverage', () => {
   ]);
   const range = coverage[0].ranges[0];
   expect(coverage[0].text.substring(range.start, range.end)).toBe('div { color: green; }');
-  });
+});
 
-  it('should report sourceURLs', async function({page, server}) {
+it('should report sourceURLs', async function({page, server}) {
   await page.coverage.startCSSCoverage();
   await page.goto(server.PREFIX + '/csscoverage/sourceurl.html');
   const coverage = await page.coverage.stopCSSCoverage();
   expect(coverage.length).toBe(1);
   expect(coverage[0].url).toBe('nicename.css');
-  });
+});
 
-  it('should report multiple stylesheets', async function({page, server}) {
+it('should report multiple stylesheets', async function({page, server}) {
   await page.coverage.startCSSCoverage();
   await page.goto(server.PREFIX + '/csscoverage/multiple.html');
   const coverage = await page.coverage.stopCSSCoverage();
@@ -48,18 +45,18 @@ it.describe('CSS Coverage', () => {
   coverage.sort((a, b) => a.url.localeCompare(b.url));
   expect(coverage[0].url).toContain('/csscoverage/stylesheet1.css');
   expect(coverage[1].url).toContain('/csscoverage/stylesheet2.css');
-  });
+});
 
-  it('should report stylesheets that have no coverage', async function({page, server}) {
+it('should report stylesheets that have no coverage', async function({page, server}) {
   await page.coverage.startCSSCoverage();
   await page.goto(server.PREFIX + '/csscoverage/unused.html');
   const coverage = await page.coverage.stopCSSCoverage();
   expect(coverage.length).toBe(1);
   expect(coverage[0].url).toBe('unused.css');
   expect(coverage[0].ranges.length).toBe(0);
-  });
+});
 
-  it('should work with media queries', async function({page, server}) {
+it('should work with media queries', async function({page, server}) {
   await page.coverage.startCSSCoverage();
   await page.goto(server.PREFIX + '/csscoverage/media.html');
   const coverage = await page.coverage.stopCSSCoverage();
@@ -68,9 +65,9 @@ it.describe('CSS Coverage', () => {
   expect(coverage[0].ranges).toEqual([
     {start: 17, end: 38}
   ]);
-  });
+});
 
-  it('should work with complicated usecases', async function({page, server}) {
+it('should work with complicated usecases', async function({page, server}) {
   await page.coverage.startCSSCoverage();
   await page.goto(server.PREFIX + '/csscoverage/involved.html');
   const coverage: any = await page.coverage.stopCSSCoverage();
@@ -92,9 +89,9 @@ it.describe('CSS Coverage', () => {
         }
       ]
   );
-  });
+});
 
-  it('should ignore injected stylesheets', async function({page, server}) {
+it('should ignore injected stylesheets', async function({page, server}) {
   await page.coverage.startCSSCoverage();
   await page.addStyleTag({content: 'body { margin: 10px;}'});
   // trigger style recalc
@@ -102,25 +99,25 @@ it.describe('CSS Coverage', () => {
   expect(margin).toBe('10px');
   const coverage = await page.coverage.stopCSSCoverage();
   expect(coverage.length).toBe(0);
-  });
+});
 
-  it('should report stylesheets across navigations', async function({page, server}) {
+it('should report stylesheets across navigations', async function({page, server}) {
   await page.coverage.startCSSCoverage({resetOnNavigation: false});
   await page.goto(server.PREFIX + '/csscoverage/multiple.html');
   await page.goto(server.EMPTY_PAGE);
   const coverage = await page.coverage.stopCSSCoverage();
   expect(coverage.length).toBe(2);
-  });
+});
 
-  it('should NOT report scripts across navigations', async function({page, server}) {
+it('should NOT report scripts across navigations', async function({page, server}) {
   await page.coverage.startCSSCoverage(); // Enabled by default.
   await page.goto(server.PREFIX + '/csscoverage/multiple.html');
   await page.goto(server.EMPTY_PAGE);
   const coverage = await page.coverage.stopCSSCoverage();
   expect(coverage.length).toBe(0);
-  });
+});
 
-  it('should work with a recently loaded stylesheet', async function({page, server}) {
+it('should work with a recently loaded stylesheet', async function({page, server}) {
   await page.coverage.startCSSCoverage();
   await page.evaluate(async url => {
     document.body.textContent = 'hello, world';
@@ -134,5 +131,4 @@ it.describe('CSS Coverage', () => {
   }, server.PREFIX + '/csscoverage/stylesheet1.css');
   const coverage = await page.coverage.stopCSSCoverage();
   expect(coverage.length).toBe(1);
-  });
 });

tests/chromium/js-coverage.spec.ts

@@ -16,42 +16,39 @@
 
 import { contextTest as it, expect } from '../config/browserTest';
 
-it.describe('JS Coverage', () => {
+it('should work', async function({page, server}) {
-  it.skip(({ browserName }) => browserName !== 'chromium');
-
-  it('should work', async function({page, server}) {
   await page.coverage.startJSCoverage();
   await page.goto(server.PREFIX + '/jscoverage/simple.html', { waitUntil: 'load' });
   const coverage = await page.coverage.stopJSCoverage();
   expect(coverage.length).toBe(1);
   expect(coverage[0].url).toContain('/jscoverage/simple.html');
   expect(coverage[0].functions.find(f => f.functionName === 'foo').ranges[0].count).toEqual(1);
-  });
+});
 
-  it('should report sourceURLs', async function({page, server}) {
+it('should report sourceURLs', async function({page, server}) {
   await page.coverage.startJSCoverage();
   await page.goto(server.PREFIX + '/jscoverage/sourceurl.html');
   const coverage = await page.coverage.stopJSCoverage();
   expect(coverage.length).toBe(1);
   expect(coverage[0].url).toBe('nicename.js');
-  });
+});
 
-  it('should ignore eval() scripts by default', async function({page, server}) {
+it('should ignore eval() scripts by default', async function({page, server}) {
   await page.coverage.startJSCoverage();
   await page.goto(server.PREFIX + '/jscoverage/eval.html');
   const coverage = await page.coverage.stopJSCoverage();
   expect(coverage.length).toBe(1);
-  });
+});
 
-  it('shouldn\'t ignore eval() scripts if reportAnonymousScripts is true', async function({page, server}) {
+it('shouldn\'t ignore eval() scripts if reportAnonymousScripts is true', async function({page, server}) {
   await page.coverage.startJSCoverage({reportAnonymousScripts: true});
   await page.goto(server.PREFIX + '/jscoverage/eval.html');
   const coverage = await page.coverage.stopJSCoverage();
   expect(coverage.find(entry => entry.url === '').source).toBe('console.log("foo")');
   expect(coverage.length).toBe(2);
-  });
+});
 
-  it('should report multiple scripts', async function({page, server}) {
+it('should report multiple scripts', async function({page, server}) {
   await page.coverage.startJSCoverage();
   await page.goto(server.PREFIX + '/jscoverage/multiple.html');
   const coverage = await page.coverage.stopJSCoverage();
@@ -59,30 +56,29 @@ it.describe('JS Coverage', () => {
   coverage.sort((a, b) => a.url.localeCompare(b.url));
   expect(coverage[0].url).toContain('/jscoverage/script1.js');
   expect(coverage[1].url).toContain('/jscoverage/script2.js');
-  });
+});
 
-  it('should report scripts across navigations when disabled', async function({page, server}) {
+it('should report scripts across navigations when disabled', async function({page, server}) {
   await page.coverage.startJSCoverage({resetOnNavigation: false});
   await page.goto(server.PREFIX + '/jscoverage/multiple.html');
   await page.goto(server.EMPTY_PAGE);
   const coverage = await page.coverage.stopJSCoverage();
   expect(coverage.length).toBe(2);
-  });
+});
 
-  it('should NOT report scripts across navigations when enabled', async function({page, server}) {
+it('should NOT report scripts across navigations when enabled', async function({page, server}) {
   await page.coverage.startJSCoverage(); // Enabled by default.
   await page.goto(server.PREFIX + '/jscoverage/multiple.html');
   await page.goto(server.EMPTY_PAGE);
   const coverage = await page.coverage.stopJSCoverage();
   expect(coverage.length).toBe(0);
-  });
+});
 
-  it('should not hang when there is a debugger statement', async function({page, server}) {
+it('should not hang when there is a debugger statement', async function({page, server}) {
   await page.coverage.startJSCoverage();
   await page.goto(server.EMPTY_PAGE);
   await page.evaluate(() => {
     debugger; // eslint-disable-line no-debugger
   });
   await page.coverage.stopJSCoverage();
-  });
 });

tests/chromium/launcher.spec.ts

@@ -16,8 +16,6 @@
 
 import { playwrightTest as it, expect } from '../config/browserTest';
 
-it.skip(({ browserName }) => browserName !== 'chromium');
-
 it('should throw with remote-debugging-pipe argument', async ({browserType, browserOptions, mode}) => {
   it.skip(mode !== 'default');
 

tests/chromium/oopif.spec.ts

@@ -14,42 +14,18 @@
  * limitations under the License.
  */
 
-import { playwrightTest, expect } from '../config/browserTest';
+import { contextTest as it, expect } from '../config/browserTest';
-import type { Page } from '../../index';
 
-const it = playwrightTest.extend({
+it.useOptions({ launchOptions: { args: ['--site-per-process'] } });
-  async beforeAll({ browserType, browserOptions, browserName }) {
-    const browser = await browserType.launch({
-      ...browserOptions,
-      args: browserName === 'chromium' ? (browserOptions.args || []).concat(['--site-per-process']) : browserOptions.args,
-    });
-    this.browser = browser;
-    return { browser };
-  },
-  async beforeEach() {
-    const page = await this.browser.newPage() as Page;
-    this.page = page;
-    return { page };
-  },
-  async afterEach() {
-    await this.page.close();
-  },
-  async afterAll() {
-    await this.browser.close();
-  },
-});
 
-it.describe('oopif', () => {
+it('should report oopif frames', async function({page, browser, server}) {
-  it.skip(({ browserName }) => browserName !== 'chromium');
-
-  it('should report oopif frames', async function({page, browser, server}) {
   await page.goto(server.PREFIX + '/dynamic-oopif.html');
   expect(await countOOPIFs(browser)).toBe(1);
   expect(page.frames().length).toBe(2);
   expect(await page.frames()[1].evaluate(() => '' + location.href)).toBe(server.CROSS_PROCESS_PREFIX + '/grid.html');
-  });
+});
 
-  it('should handle oopif detach', async function({page, browser, server}) {
+it('should handle oopif detach', async function({page, browser, server}) {
   await page.goto(server.PREFIX + '/dynamic-oopif.html');
   expect(await countOOPIFs(browser)).toBe(1);
   expect(page.frames().length).toBe(2);
@@ -60,9 +36,9 @@ it.describe('oopif', () => {
     page.evaluate(() => document.querySelector('iframe').remove()),
   ]);
   expect(detachedFrame).toBe(frame);
-  });
+});
 
-  it('should handle remote -> local -> remote transitions', async function({page, browser, server}) {
+it('should handle remote -> local -> remote transitions', async function({page, browser, server}) {
   await page.goto(server.PREFIX + '/dynamic-oopif.html');
   expect(page.frames().length).toBe(2);
   expect(await countOOPIFs(browser)).toBe(1);
@@ -79,9 +55,9 @@ it.describe('oopif', () => {
   ]);
   expect(await page.frames()[1].evaluate(() => '' + location.href)).toBe(server.CROSS_PROCESS_PREFIX + '/grid.html');
   expect(await countOOPIFs(browser)).toBe(1);
-  });
+});
 
-  it('should get the proper viewport', async ({page, browser, server}) => {
+it('should get the proper viewport', async ({page, browser, server}) => {
   it.fixme();
 
   expect(page.viewportSize()).toEqual({width: 1280, height: 720});
@@ -100,9 +76,9 @@ it.describe('oopif', () => {
   expect(await oopif.evaluate(() => matchMedia('(device-width: 123px)').matches)).toBe(true);
   expect(await oopif.evaluate(() => matchMedia('(device-height: 456px)').matches)).toBe(true);
   expect(await oopif.evaluate(() => 'ontouchstart' in window)).toBe(false);
-  });
+});
 
-  it('should expose function', async ({page, browser, server}) => {
+it('should expose function', async ({page, browser, server}) => {
   await page.goto(server.PREFIX + '/dynamic-oopif.html');
   expect(page.frames().length).toBe(2);
   expect(await countOOPIFs(browser)).toBe(1);
@@ -112,9 +88,9 @@ it.describe('oopif', () => {
     return await window['mul'](9, 4);
   });
   expect(result).toBe(36);
-  });
+});
 
-  it('should emulate media', async ({page, browser, server}) => {
+it('should emulate media', async ({page, browser, server}) => {
   await page.goto(server.PREFIX + '/dynamic-oopif.html');
   expect(page.frames().length).toBe(2);
   expect(await countOOPIFs(browser)).toBe(1);
@@ -122,9 +98,9 @@ it.describe('oopif', () => {
   expect(await oopif.evaluate(() => matchMedia('(prefers-color-scheme: dark)').matches)).toBe(false);
   await page.emulateMedia({ colorScheme: 'dark' });
   expect(await oopif.evaluate(() => matchMedia('(prefers-color-scheme: dark)').matches)).toBe(true);
-  });
+});
 
-  it('should emulate offline', async ({page, browser, server}) => {
+it('should emulate offline', async ({page, browser, server}) => {
   await page.goto(server.PREFIX + '/dynamic-oopif.html');
   expect(page.frames().length).toBe(2);
   expect(await countOOPIFs(browser)).toBe(1);
@@ -132,9 +108,9 @@ it.describe('oopif', () => {
   expect(await oopif.evaluate(() => navigator.onLine)).toBe(true);
   await page.context().setOffline(true);
   expect(await oopif.evaluate(() => navigator.onLine)).toBe(false);
-  });
+});
 
-  it('should support context options', async ({browser, server, playwright}) => {
+it('should support context options', async ({browser, server, playwright}) => {
   const iPhone = playwright.devices['iPhone 6'];
   const context = await browser.newContext({ ...iPhone, timezoneId: 'America/Jamaica', locale: 'fr-CH', userAgent: 'UA' });
   const page = await context.newPage();
@@ -154,9 +130,9 @@ it.describe('oopif', () => {
   expect(request.headers['user-agent']).toBe('UA');
 
   await context.close();
-  });
+});
 
-  it('should respect route', async ({page, browser, server}) => {
+it('should respect route', async ({page, browser, server}) => {
   let intercepted = false;
   await page.route('**/digits/0.png', route => {
     intercepted = true;
@@ -166,23 +142,23 @@ it.describe('oopif', () => {
   expect(page.frames().length).toBe(2);
   expect(await countOOPIFs(browser)).toBe(1);
   expect(intercepted).toBe(true);
-  });
+});
 
-  it('should take screenshot', async ({page, browser, server}) => {
+it('should take screenshot', async ({page, browser, server}) => {
   await page.setViewportSize({width: 500, height: 500});
   await page.goto(server.PREFIX + '/dynamic-oopif.html');
   expect(page.frames().length).toBe(2);
   expect(await countOOPIFs(browser)).toBe(1);
   expect(await page.screenshot()).toMatchSnapshot('screenshot-oopif.png', { threshold: 0.3 });
-  });
+});
 
-  it('should load oopif iframes with subresources and route', async function({page, browser, server}) {
+it('should load oopif iframes with subresources and route', async function({page, browser, server}) {
   await page.route('**/*', route => route.continue());
   await page.goto(server.PREFIX + '/dynamic-oopif.html');
   expect(await countOOPIFs(browser)).toBe(1);
-  });
+});
 
-  it('should report main requests', async function({page, browser, server}) {
+it('should report main requests', async function({page, browser, server}) {
   const requestFrames = [];
   page.on('request', r => requestFrames.push(r.frame()));
   const finishedFrames = [];
@@ -218,9 +194,9 @@ it.describe('oopif', () => {
   expect(finishedFrames[1]).toBe(child);
   expect(requestFrames[2]).toBe(grandChild);
   expect(finishedFrames[2]).toBe(grandChild);
-  });
+});
 
-  it('should support exposeFunction', async function({page, browser, server}) {
+it('should support exposeFunction', async function({page, browser, server}) {
   await page.context().exposeFunction('dec', a => a - 1);
   await page.exposeFunction('inc', a => a + 1);
   await page.goto(server.PREFIX + '/dynamic-oopif.html');
@@ -230,9 +206,9 @@ it.describe('oopif', () => {
   expect(await page.frames()[1].evaluate(() => window['inc'](4))).toBe(5);
   expect(await page.frames()[0].evaluate(() => window['dec'](3))).toBe(2);
   expect(await page.frames()[1].evaluate(() => window['dec'](4))).toBe(3);
-  });
+});
 
-  it('should support addInitScript', async function({page, browser, server}) {
+it('should support addInitScript', async function({page, browser, server}) {
   await page.context().addInitScript(() => window['bar'] = 17);
   await page.addInitScript(() => window['foo'] = 42);
   await page.goto(server.PREFIX + '/dynamic-oopif.html');
@@ -242,16 +218,16 @@ it.describe('oopif', () => {
   expect(await page.frames()[1].evaluate(() => window['foo'])).toBe(42);
   expect(await page.frames()[0].evaluate(() => window['bar'])).toBe(17);
   expect(await page.frames()[1].evaluate(() => window['bar'])).toBe(17);
-  });
+});
-  // @see https://github.com/microsoft/playwright/issues/1240
+// @see https://github.com/microsoft/playwright/issues/1240
-  it('should click a button when it overlays oopif', async function({page, browser, server}) {
+it('should click a button when it overlays oopif', async function({page, browser, server}) {
   await page.goto(server.PREFIX + '/button-overlay-oopif.html');
   expect(await countOOPIFs(browser)).toBe(1);
   await page.click('button');
   expect(await page.evaluate(() => window['BUTTON_CLICKED'])).toBe(true);
-  });
+});
 
-  it('should report google.com frame with headful', async ({browserType, browserOptions, server}) => {
+it('should report google.com frame with headful', async ({browserType, browserOptions, server}) => {
   // @see https://github.com/GoogleChrome/puppeteer/issues/2548
   // https://google.com is isolated by default in Chromium embedder.
   const browser = await browserType.launch({...browserOptions, headless: false});
@@ -274,9 +250,9 @@ it.describe('oopif', () => {
     'https://google.com/'
   ]);
   await browser.close();
-  });
+});
 
-  it('ElementHandle.boundingBox() should work', async function({page, browser, server}) {
+it('ElementHandle.boundingBox() should work', async function({page, browser, server}) {
   await page.goto(server.PREFIX + '/dynamic-oopif.html');
   await page.$eval('iframe', iframe => {
     iframe.style.width = '500px';
@@ -297,9 +273,9 @@ it.describe('oopif', () => {
   expect(await countOOPIFs(browser)).toBe(0);
   const handle2 = await page.frames()[1].$('.box:nth-of-type(13)');
   expect(await handle2.boundingBox()).toEqual({ x: 100 + 42, y: 50 + 17, width: 50, height: 50 });
-  });
+});
 
-  it('should click', async function({page, browser, server}) {
+it('should click', async function({page, browser, server}) {
   await page.goto(server.PREFIX + '/dynamic-oopif.html');
   await page.$eval('iframe', iframe => {
     iframe.style.width = '500px';
@@ -314,7 +290,6 @@ it.describe('oopif', () => {
   await handle1.evaluate(div => div.addEventListener('click', () => window['_clicked'] = true, false));
   await handle1.click();
   expect(await handle1.evaluate(() => window['_clicked'])).toBe(true);
-  });
 });
 
 async function countOOPIFs(browser) {

tests/chromium/session.spec.ts

@@ -17,10 +17,7 @@
 import { contextTest as it, expect } from '../config/browserTest';
 import { browserTest } from '../config/browserTest';
 
-it.describe('session', () => {
+it('should work', async function({page}) {
-  it.skip(({ browserName }) => browserName !== 'chromium');
-
-  it('should work', async function({page}) {
   const client = await page.context().newCDPSession(page);
 
   await Promise.all([
@@ -29,24 +26,24 @@ it.describe('session', () => {
   ]);
   const foo = await page.evaluate(() => window['foo']);
   expect(foo).toBe('bar');
-  });
+});
 
-  it('should send events', async function({page, server}) {
+it('should send events', async function({page, server}) {
   const client = await page.context().newCDPSession(page);
   await client.send('Network.enable');
   const events = [];
   client.on('Network.requestWillBeSent', event => events.push(event));
   await page.goto(server.EMPTY_PAGE);
   expect(events.length).toBe(1);
-  });
+});
 
-  it('should only accept a page', async function({page}) {
+it('should only accept a page', async function({page}) {
   // @ts-expect-error newCDPSession expects a Page
   const error = await page.context().newCDPSession(page.context()).catch(e => e);
   expect(error.message).toContain('page: expected Page');
-  });
+});
 
-  it('should enable and disable domains independently', async function({page}) {
+it('should enable and disable domains independently', async function({page}) {
   const client = await page.context().newCDPSession(page);
   await client.send('Runtime.enable');
   await client.send('Debugger.enable');
@@ -62,9 +59,9 @@ it.describe('session', () => {
     })),
     page.evaluate('//# sourceURL=foo.js')
   ]);
-  });
+});
 
-  it('should be able to detach session', async function({page}) {
+it('should be able to detach session', async function({page}) {
   const client = await page.context().newCDPSession(page);
   await client.send('Runtime.enable');
   const evalResponse = await client.send('Runtime.evaluate', {expression: '1 + 2', returnByValue: true});
@@ -77,9 +74,9 @@ it.describe('session', () => {
     error = e;
   }
   expect(error.message).toContain('Target page, context or browser has been closed');
-  });
+});
 
-  it('should throw nice errors', async function({page}) {
+it('should throw nice errors', async function({page}) {
   const client = await page.context().newCDPSession(page);
   const error = await theSourceOfTheProblems().catch(error => error);
   expect(error.stack).toContain('theSourceOfTheProblems');
@@ -89,22 +86,18 @@ it.describe('session', () => {
     // @ts-expect-error invalid command
     await client.send('ThisCommand.DoesNotExist');
   }
-  });
 });
 
-browserTest.describe('session', () => {
+browserTest('should not break page.close()', async function({browser}) {
-  browserTest.skip(({ browserName }) => browserName !== 'chromium');
-
-  browserTest('should not break page.close()', async function({browser}) {
   const context = await browser.newContext();
   const page = await context.newPage();
   const session = await page.context().newCDPSession(page);
   await session.detach();
   await page.close();
   await context.close();
-  });
+});
 
-  browserTest('should detach when page closes', async function({browser}) {
+browserTest('should detach when page closes', async function({browser}) {
   const context = await browser.newContext();
   const page = await context.newPage();
   const session = await context.newCDPSession(page);
@@ -113,9 +106,9 @@ browserTest.describe('session', () => {
   await session.detach().catch(e => error = e);
   expect(error).toBeTruthy();
   await context.close();
-  });
+});
 
-  browserTest('should work with newBrowserCDPSession', async function({browser}) {
+browserTest('should work with newBrowserCDPSession', async function({browser}) {
   const session = await browser.newBrowserCDPSession();
 
   const version = await session.send('Browser.getVersion');
@@ -127,5 +120,4 @@ browserTest.describe('session', () => {
   expect(gotEvent).toBe(true);
 
   await session.detach();
-  });
 });

tests/chromium/tracing.spec.ts

@@ -18,10 +18,7 @@ import { browserTest as it, expect } from '../config/browserTest';
 import fs from 'fs';
 import path from 'path';
 
-it.describe('tracing', () => {
+it('should output a trace', async ({browser, server}, testInfo) => {
-  it.skip(({ browserName }) => browserName !== 'chromium');
-
-  it('should output a trace', async ({browser, server}, testInfo) => {
   const page = await browser.newPage();
   const outputTraceFile = testInfo.outputPath(path.join(`trace.json`));
   await browser.startTracing(page, {screenshots: true, path: outputTraceFile});
@@ -29,9 +26,9 @@ it.describe('tracing', () => {
   await browser.stopTracing();
   expect(fs.existsSync(outputTraceFile)).toBe(true);
   await page.close();
-  });
+});
 
-  it('should create directories as needed', async ({browser, server}, testInfo) => {
+it('should create directories as needed', async ({browser, server}, testInfo) => {
   const page = await browser.newPage();
   const filePath = testInfo.outputPath(path.join('these', 'are', 'directories', 'trace.json'));
   await browser.startTracing(page, {screenshots: true, path: filePath});
@@ -39,9 +36,9 @@ it.describe('tracing', () => {
   await browser.stopTracing();
   expect(fs.existsSync(filePath)).toBe(true);
   await page.close();
-  });
+});
 
-  it('should run with custom categories if provided', async ({browser}, testInfo) => {
+it('should run with custom categories if provided', async ({browser}, testInfo) => {
   const page = await browser.newPage();
   const outputTraceFile = testInfo.outputPath(path.join(`trace.json`));
   await browser.startTracing(page, {path: outputTraceFile, categories: ['disabled-by-default-v8.cpu_profiler.hires']});
@@ -50,9 +47,9 @@ it.describe('tracing', () => {
   const traceJson = JSON.parse(fs.readFileSync(outputTraceFile).toString());
   expect(traceJson.metadata['trace-config']).toContain('disabled-by-default-v8.cpu_profiler.hires');
   await page.close();
-  });
+});
 
-  it('should throw if tracing on two pages', async ({browser}, testInfo) => {
+it('should throw if tracing on two pages', async ({browser}, testInfo) => {
   const page = await browser.newPage();
   const outputTraceFile = testInfo.outputPath(path.join(`trace.json`));
   await browser.startTracing(page, {path: outputTraceFile});
@@ -63,9 +60,9 @@ it.describe('tracing', () => {
   expect(error).toBeTruthy();
   await browser.stopTracing();
   await page.close();
-  });
+});
 
-  it('should return a buffer', async ({browser, server}, testInfo) => {
+it('should return a buffer', async ({browser, server}, testInfo) => {
   const page = await browser.newPage();
   const outputTraceFile = testInfo.outputPath(path.join(`trace.json`));
   await browser.startTracing(page, {screenshots: true, path: outputTraceFile});
@@ -74,23 +71,22 @@ it.describe('tracing', () => {
   const buf = fs.readFileSync(outputTraceFile);
   expect(trace.toString()).toEqual(buf.toString());
   await page.close();
-  });
+});
 
-  it('should work without options', async ({browser, server}) => {
+it('should work without options', async ({browser, server}) => {
   const page = await browser.newPage();
   await browser.startTracing(page);
   await page.goto(server.PREFIX + '/grid.html');
   const trace = await browser.stopTracing();
   expect(trace).toBeTruthy();
   await page.close();
-  });
+});
 
-  it('should support a buffer without a path', async ({browser, server}) => {
+it('should support a buffer without a path', async ({browser, server}) => {
   const page = await browser.newPage();
   await browser.startTracing(page, {screenshots: true});
   await page.goto(server.PREFIX + '/grid.html');
   const trace = await browser.stopTracing();
   expect(trace.toString()).toContain('screenshot');
   await page.close();
-  });
 });

tests/config/android.config.ts

@@ -17,7 +17,7 @@
 import * as folio from 'folio';
 import * as path from 'path';
 import { test as pageTest } from '../page/pageTest';
-import { AndroidEnv } from './androidTest';
+import { AndroidEnv } from '../android/androidTest';
 import type { BrowserContext } from '../../index';
 import { PlaywrightEnvOptions } from './browserTest';
 import { CommonOptions } from './baseTest';

tests/config/default.config.ts

@@ -95,14 +95,17 @@ const config: folio.Config<AllOptions> = {
   projects: [],
 };
 
-for (const browserName of ['chromium', 'webkit', 'firefox'] as BrowserName[]) {
+const browserNames = ['chromium', 'webkit', 'firefox'] as BrowserName[];
+for (const browserName of browserNames) {
   const executablePath = getExecutablePath(browserName);
   if (executablePath && (process.env.FOLIO_WORKER_INDEX === undefined || process.env.FOLIO_WORKER_INDEX === ''))
     console.error(`Using executable at ${executablePath}`);
+  const testIgnore: RegExp[] = browserNames.filter(b => b !== browserName).map(b => new RegExp(b));
+  testIgnore.push(/android/, /electron/);
   config.projects.push({
     name: browserName,
     testDir,
-    testIgnore: [/android/, /electron/],
+    testIgnore,
     options: {
       mode: (process.env.PWTEST_MODE || 'default') as ('default' | 'driver' | 'service'),
       browserName,

tests/config/electron.config.ts

@@ -16,7 +16,7 @@
 
 import * as folio from 'folio';
 import * as path from 'path';
-import { ElectronEnv } from './electronTest';
+import { ElectronEnv } from '../electron/electronTest';
 import { test as pageTest } from '../page/pageTest';
 import { PlaywrightEnvOptions } from './browserTest';
 import { CommonOptions } from './baseTest';

tests/electron/electron-app.spec.ts

@@ -16,11 +16,12 @@
 
 import type { BrowserWindow } from 'electron';
 import path from 'path';
-import { electronTest as test, baseElectronTest as baseTest, expect } from '../config/electronTest';
+import { electronTest as test, expect } from './electronTest';
+import { baseTest } from '../config/baseTest';
 
 baseTest('should fire close event', async ({ playwright }) => {
   const electronApp = await playwright._electron.launch({
-    args: [path.join(__dirname, '..', 'config', 'electron-app.js')],
+    args: [path.join(__dirname, 'electron-app.js')],
   });
   const events = [];
   electronApp.on('close', () => events.push('application'));
@@ -34,7 +35,7 @@ baseTest('should fire close event', async ({ playwright }) => {
 
 test('should script application', async ({ electronApp }) => {
   const appPath = await electronApp.evaluate(async ({ app }) => app.getAppPath());
-  expect(appPath).toBe(path.resolve(__dirname, '..', 'config'));
+  expect(appPath).toBe(path.resolve(__dirname));
 });
 
 test('should return windows', async ({ electronApp, newWindow }) => {
@@ -92,14 +93,14 @@ test('should have a clipboard instance', async ({ electronApp }) => {
 
 test('should test app that opens window fast', async ({ playwright }) => {
   const electronApp = await playwright._electron.launch({
-    args: [path.join(__dirname, '..', 'config', 'electron-window-app.js')],
+    args: [path.join(__dirname, 'electron-window-app.js')],
   });
   await electronApp.close();
 });
 
 test('should return browser window', async ({ playwright }) => {
   const electronApp = await playwright._electron.launch({
-    args: [path.join(__dirname, '..', 'config', 'electron-window-app.js')],
+    args: [path.join(__dirname, 'electron-window-app.js')],
   });
   const page = await electronApp.waitForEvent('window');
   const bwHandle = await electronApp.browserWindow(page);

tests/electron/electron-window.spec.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { electronTest as test, expect } from '../config/electronTest';
+import { electronTest as test, expect } from './electronTest';
 
 test('should click the button', async ({newWindow, server}) => {
   const window = await newWindow();

tests/electron/electronTest.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import { baseTest, CommonArgs } from './baseTest';
+import { baseTest, CommonArgs } from '../config/baseTest';
 import { ElectronApplication, Page } from '../../index';
 import * as folio from 'folio';
 import * as path from 'path';
@@ -79,5 +79,4 @@ export class ElectronEnv {
   }
 }
 
-export const baseElectronTest = baseTest;
 export const electronTest = baseTest.extend(new ElectronEnv());

tests/firefox/launcher.spec.ts

@@ -17,8 +17,6 @@
 import { playwrightTest as it, expect } from '../config/browserTest';
 
 it('should pass firefox user preferences', async ({browserType, browserOptions, browserName}) => {
-  it.skip(browserName !== 'firefox');
-
   const browser = await browserType.launch({
     ...browserOptions,
     firefoxUserPrefs: {

tests/inspector/cli-codegen-1.spec.ts

@@ -14,8 +14,7 @@
  * limitations under the License.
  */
 
-import { cliTest as test, expect } from '../config/cliTest';
+import { test, expect } from './inspectorTest';
-import * as http from 'http';
 
 test.describe('cli codegen', () => {
   test.skip(({ mode }) => mode !== 'default');
@@ -58,14 +57,14 @@ await page.ClickAsync("text=Submit");`);
     expect(message.text()).toBe('click');
   });
 
-  test('should click after same-document navigation', async ({ page, openRecorder, httpServer }) => {
+  test('should click after same-document navigation', async ({ page, openRecorder, server }) => {
     const recorder = await openRecorder();
 
-    httpServer.setHandler((req: http.IncomingMessage, res: http.ServerResponse) => {
+    server.setRoute('/foo.html', (req, res) => {
       res.setHeader('Content-Type', 'text/html; charset=utf-8');
       res.end('');
     });
-    await recorder.setContentAndWait(`<button onclick="console.log('click')">Submit</button>`, httpServer.PREFIX + '/foo.html');
+    await recorder.setContentAndWait(`<button onclick="console.log('click')">Submit</button>`, server.PREFIX + '/foo.html');
     await Promise.all([
       page.waitForNavigation(),
       page.evaluate(() => history.pushState({}, '', '/url.html')),

tests/inspector/cli-codegen-2.spec.ts

@@ -14,8 +14,7 @@
  * limitations under the License.
  */
 
-import { cliTest as test, expect } from '../config/cliTest';
+import { test, expect } from './inspectorTest';
-import * as http from 'http';
 import * as url from 'url';
 
 test.describe('cli codegen', () => {
@@ -228,10 +227,10 @@ await page.SetInputFilesAsync(\"input[type=\\\"file\\\"]\", new[] {  });`);
 
   });
 
-  test('should download files', async ({ page, openRecorder, httpServer }) => {
+  test('should download files', async ({ page, openRecorder, server }) => {
     const recorder = await openRecorder();
 
-    httpServer.setHandler((req: http.IncomingMessage, res: http.ServerResponse) => {
+    server.setRoute('/download', (req, res) => {
       const pathName = url.parse(req.url!).path;
       if (pathName === '/download') {
         res.setHeader('Content-Type', 'application/octet-stream');
@@ -243,8 +242,8 @@ await page.SetInputFilesAsync(\"input[type=\\\"file\\\"]\", new[] {  });`);
       }
     });
     await recorder.setContentAndWait(`
-      <a href="${httpServer.PREFIX}/download" download>Download</a>
+      <a href="${server.PREFIX}/download" download>Download</a>
-    `, httpServer.PREFIX);
+    `, server.PREFIX);
     await recorder.hoverOverElement('text=Download');
     await Promise.all([
       page.waitForEvent('download'),
@@ -338,23 +337,19 @@ await page.ClickAsync(\"text=click me\");`);
 
   });
 
-  test('should handle history.postData', async ({ page, openRecorder, httpServer }) => {
+  test('should handle history.postData', async ({ page, openRecorder, server }) => {
     const recorder = await openRecorder();
 
-    httpServer.setHandler((req: http.IncomingMessage, res: http.ServerResponse) => {
-      res.setHeader('Content-Type', 'text/html; charset=utf-8');
-      res.end('Hello world');
-    });
     await recorder.setContentAndWait(`
     <script>
     let seqNum = 0;
     function pushState() {
-      history.pushState({}, 'title', '${httpServer.PREFIX}/#seqNum=' + (++seqNum));
+      history.pushState({}, 'title', '${server.PREFIX}/#seqNum=' + (++seqNum));
     }
-    </script>`, httpServer.PREFIX);
+    </script>`, server.PREFIX);
     for (let i = 1; i < 3; ++i) {
       await page.evaluate('pushState()');
-      await recorder.waitForOutput('<javascript>', `await page.goto('${httpServer.PREFIX}/#seqNum=${i}');`);
+      await recorder.waitForOutput('<javascript>', `await page.goto('${server.PREFIX}/#seqNum=${i}');`);
     }
   });
 
@@ -581,23 +576,23 @@ await page.GetFrame(name: \"two\").ClickAsync(\"text=Hi, I'm frame\");`);
 await page.GetFrame(url: \"http://localhost:${server.PORT}/frames/frame.html\").ClickAsync(\"text=Hi, I'm frame\");`);
   });
 
-  test('should record navigations after identical pushState', async ({ page, openRecorder, httpServer }) => {
+  test('should record navigations after identical pushState', async ({ page, openRecorder, server }) => {
     const recorder = await openRecorder();
-    httpServer.setHandler((req: http.IncomingMessage, res: http.ServerResponse) => {
+    server.setRoute('/page2.html', (req, res) => {
       res.setHeader('Content-Type', 'text/html; charset=utf-8');
       res.end('Hello world');
     });
     await recorder.setContentAndWait(`
     <script>
     function pushState() {
-      history.pushState({}, 'title', '${httpServer.PREFIX}');
+      history.pushState({}, 'title', '${server.PREFIX}');
     }
-    </script>`, httpServer.PREFIX);
+    </script>`, server.PREFIX);
     for (let i = 1; i < 3; ++i)
       await page.evaluate('pushState()');
 
-    await page.goto(httpServer.PREFIX + '/page2.html');
+    await page.goto(server.PREFIX + '/page2.html');
-    await recorder.waitForOutput('<javascript>', `await page.goto('${httpServer.PREFIX}/page2.html');`);
+    await recorder.waitForOutput('<javascript>', `await page.goto('${server.PREFIX}/page2.html');`);
   });
 
   test('should record slow navigation signal after mouse move', async ({ page, openRecorder, server }) => {

tests/inspector/cli-codegen-csharp.spec.ts

@@ -16,7 +16,7 @@
 
 import path from 'path';
 import fs from 'fs';
-import { cliTest as test, expect } from '../config/cliTest';
+import { test, expect } from './inspectorTest';
 
 const emptyHTML = new URL('file://' + path.join(__dirname, '..', 'assets', 'empty.html')).toString();
 const launchOptions = (channel: string) => {

tests/inspector/cli-codegen-java.spec.ts

@@ -16,7 +16,7 @@
 
 import fs from 'fs';
 import path from 'path';
-import { cliTest as test, expect } from '../config/cliTest';
+import { test, expect } from './inspectorTest';
 
 const emptyHTML = new URL('file://' + path.join(__dirname, '..', 'assets', 'empty.html')).toString();
 const launchOptions = (channel: string) => {

tests/inspector/cli-codegen-javascript.spec.ts

@@ -16,7 +16,7 @@
 
 import fs from 'fs';
 import path from 'path';
-import { cliTest as test, expect } from '../config/cliTest';
+import { test, expect } from './inspectorTest';
 
 const emptyHTML = new URL('file://' + path.join(__dirname, '..', 'assets', 'empty.html')).toString();
 

tests/inspector/cli-codegen-python-async.spec.ts

@@ -16,7 +16,7 @@
 
 import fs from 'fs';
 import path from 'path';
-import { cliTest as test, expect } from '../config/cliTest';
+import { test, expect } from './inspectorTest';
 
 const emptyHTML = new URL('file://' + path.join(__dirname, '..', 'assets', 'empty.html')).toString();
 const launchOptions = (channel: string) => {

tests/inspector/cli-codegen-python.spec.ts

@@ -16,7 +16,7 @@
 
 import fs from 'fs';
 import path from 'path';
-import { cliTest as test, expect } from '../config/cliTest';
+import { test, expect } from './inspectorTest';
 
 const emptyHTML = new URL('file://' + path.join(__dirname, '..', 'assets', 'empty.html')).toString();
 const launchOptions = (channel: string) => {

tests/inspector/inspectorTest.ts

@@ -14,9 +14,8 @@
  * limitations under the License.
  */
 
-import { contextTest } from './browserTest';
+import { contextTest } from '../config/browserTest';
 import type { Page } from '../../index';
-import * as http from 'http';
 import * as path from 'path';
 import type { Source } from '../../src/server/supplements/recorder/recorderTypes';
 import { ChildProcess, spawn } from 'child_process';
@@ -24,23 +23,15 @@ import { chromium } from '../../index';
 import * as folio from 'folio';
 export { expect } from 'folio';
 
-interface CLIHTTPServer {
-  setHandler: (handler: http.RequestListener) => void;
-  PREFIX: string;
-}
-
 type CLITestArgs = {
-  httpServer: CLIHTTPServer;
   recorderPageGetter: () => Promise<Page>;
   openRecorder: () => Promise<Recorder>;
   runCLI: (args: string[]) => CLIMock;
 };
 
-export const cliTest = contextTest.extend({
+export const test = contextTest.extend({
   async beforeAll({}, workerInfo: folio.WorkerInfo) {
-    this._port = 10907 + workerInfo.workerIndex * 2;
+    process.env.PWTEST_RECORDER_PORT = String(10907 + workerInfo.workerIndex);
-    this._server = http.createServer((req: http.IncomingMessage, res: http.ServerResponse) => this._handler(req, res)).listen(this._port);
-    process.env.PWTEST_RECORDER_PORT = String(this._port + 1);
   },
 
   async beforeEach({ page, context, toImpl, browserName, browserChannel, headful, mode }, testInfo: folio.TestInfo): Promise<CLITestArgs> {
@@ -54,10 +45,6 @@ export const cliTest = contextTest.extend({
       return c.pages()[0] || await c.waitForEvent('page');
     };
     return {
-      httpServer: {
-        setHandler: newHandler => this._handler = newHandler,
-        PREFIX: `http://127.0.0.1:${this._port}`,
-      },
       runCLI: (cliArgs: string[]) => {
         this._cli = new CLIMock(browserName, browserChannel, !headful, cliArgs);
         return this._cli;
@@ -76,13 +63,6 @@ export const cliTest = contextTest.extend({
       this._cli = undefined;
     }
   },
-
-  async afterAll({}, workerInfo: folio.WorkerInfo) {
-    if (this._server) {
-      this._server.close();
-      this._server = undefined;
-    }
-  },
 });
 
 class Recorder {

tests/inspector/pause.spec.ts

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-import { Page } from '../index';
+import { Page } from '../../index';
-import { cliTest as it, expect } from './config/cliTest';
+import { test as it, expect } from './inspectorTest';
 
 it.describe('pause', () => {
   it.skip(({ mode }) => mode !== 'default');