test(bidi): unskip some Firefox BiDi tests

tests/bidi/expectations/moz-firefox-nightly-library.txt

@@ -1,11 +1,5 @@
 library/browsercontext-credentials.spec.ts › should fail without credentials [timeout]
 library/browsercontext-credentials.spec.ts › should work with setHTTPCredentials [timeout]
-library/browsercontext-har.spec.ts › should change document URL after redirected navigation [timeout]
-library/browsercontext-har.spec.ts › should goBack to redirected navigation [timeout]
-library/browsercontext-har.spec.ts › should goForward to redirected navigation [timeout]
-library/browsercontext-har.spec.ts › should ignore boundary when matching multipart/form-data body [timeout]
-library/browsercontext-har.spec.ts › should record overridden requests to har [timeout]
-library/browsercontext-har.spec.ts › should reload redirected navigation [timeout]
 library/browsercontext-network-event.spec.ts › should reject response.finished if context closes [timeout]
 library/browsercontext-page-event.spec.ts › should have about:blank for empty url with domcontentloaded [timeout]
 library/browsertype-connect.spec.ts › launchServer › should be able to connect 20 times to a single server without warnings [timeout]
@@ -36,36 +30,22 @@ library/chromium/launcher.spec.ts › should report console messages from conten
 library/chromium/launcher.spec.ts › should return background pages [timeout]
 library/chromium/launcher.spec.ts › should return background pages when recording video [timeout]
 library/chromium/launcher.spec.ts › should support request/response events when using backgroundPage() [timeout]
-library/defaultbrowsercontext-2.spec.ts › should handle exception [timeout]
-library/defaultbrowsercontext-2.spec.ts › should support geolocation and permissions options [timeout]
 library/fetch-proxy.spec.ts › context request should pick up proxy credentials [timeout]
-library/geolocation.spec.ts › should isolate contexts [timeout]
-library/geolocation.spec.ts › should use context options [timeout]
-library/geolocation.spec.ts › should use context options for popup [timeout]
-library/geolocation.spec.ts › should work @smoke [timeout]
-library/geolocation.spec.ts › watchPosition should be notified [timeout]
-library/headful.spec.ts › should click bottom row w/ infobar in OOPIF [timeout]
 library/inspector/cli-codegen-2.spec.ts › cli codegen › should --test-id-attribute [timeout]
 library/inspector/cli-codegen-2.spec.ts › cli codegen › should not clash pages [timeout]
 library/inspector/cli-codegen-3.spec.ts › cli codegen › should generate frame locators (1) [timeout]
 library/inspector/cli-codegen-3.spec.ts › cli codegen › should generate frame locators (2) [timeout]
 library/inspector/cli-codegen-3.spec.ts › cli codegen › should generate frame locators (3) [timeout]
 library/inspector/cli-codegen-3.spec.ts › cli codegen › should generate frame locators (4) [timeout]
-library/page-clock.spec.ts › popup › should run time before popup [timeout]
-library/page-clock.spec.ts › popup › should tick after popup [timeout]
-library/page-clock.spec.ts › popup › should tick before popup [timeout]
 library/page-event-crash.spec.ts › should emit crash event when page crashes [timeout]
 library/page-event-crash.spec.ts › should throw on any action after page crashes [timeout]
 library/page-event-crash.spec.ts › should cancel waitForEvent when page crashes [timeout]
 library/page-event-crash.spec.ts › should cancel navigation when page crashes [timeout]
 library/page-event-crash.spec.ts › should be able to close context when page crashes [timeout]
 library/popup.spec.ts › should not throw when click closes popup [timeout]
-library/popup.spec.ts › should use viewport size from window features [timeout]
-library/trace-viewer.spec.ts › should serve css without content-type [timeout]
 library/unroute-behavior.spec.ts › context.unroute should not wait for pending handlers to complete [timeout]
 library/unroute-behavior.spec.ts › context.unrouteAll should not wait for pending handlers to complete if behavior is ignoreErrors [timeout]
 library/unroute-behavior.spec.ts › context.unrouteAll should wait for pending handlers to complete [timeout]
-library/video.spec.ts › screencast › saveAs should throw when no video frames [timeout]
 library/video.spec.ts › screencast › should be 800x450 by default [timeout]
 library/video.spec.ts › screencast › should be 800x600 with null viewport [timeout]
 library/video.spec.ts › screencast › should capture css transformation [timeout]

tests/bidi/expectations/moz-firefox-nightly-page.txt

@@ -4,8 +4,6 @@ page/interception.spec.ts › should intercept worker requests when enabled afte
 page/page-add-init-script.spec.ts › init script should run only once in popup [timeout]
 page/page-basic.spec.ts › should return null if parent page has been closed [timeout]
 page/page-event-console.spec.ts › should trigger correct Log [timeout]
-page/page-event-request.spec.ts › should report navigation requests and responses handled by service worker [timeout]
-page/page-event-request.spec.ts › should report navigation requests and responses handled by service worker with routing [timeout]
 page/page-filechooser.spec.ts › should upload multiple large files [timeout]
 page/page-filechooser.spec.ts › should emit event once [timeout]
 page/page-filechooser.spec.ts › should emit event via prepend [timeout]
@@ -37,7 +35,6 @@ page/workers.spec.ts › should clear upon navigation [timeout]
 page/workers.spec.ts › should dispatch console messages when page has workers [timeout]
 page/workers.spec.ts › should emit created and destroyed events [timeout]
 page/workers.spec.ts › should evaluate [timeout]
-page/workers.spec.ts › should report errors [timeout]
 page/workers.spec.ts › should report network activity [timeout]
 page/workers.spec.ts › should support extra http headers [timeout]
 page/workers.spec.ts › should support offline [timeout]

tests/library/browsercontext-basic.spec.ts

@@ -255,8 +255,8 @@ it('should be able to navigate after disabling javascript', async ({ browser, se
   await context.close();
 });
 
-it('should not hang on promises after disabling javascript', async ({ browserName, contextFactory }) => {
-  it.fixme(browserName === 'firefox');
+it('should not hang on promises after disabling javascript', async ({ browserName, contextFactory, channel }) => {
+  it.fixme(browserName === 'firefox' && !channel?.startsWith('moz-firefox'));
   const context = await contextFactory({ javaScriptEnabled: false });
   const page = await context.newPage();
   expect(await page.evaluate(() => 1)).toBe(1);

tests/library/browsercontext-device.spec.ts

@@ -18,7 +18,7 @@
 import { browserTest as it, expect } from '../config/browserTest';
 
 it.describe('device', () => {
-  it.skip(({ browserName }) => browserName === 'firefox');
+  it.skip(({ browserName, channel }) => browserName === 'firefox' && !channel?.startsWith('moz-firefox'));
 
   it('should work @smoke', async ({ playwright, browser, server }) => {
     const iPhone = playwright.devices['iPhone 6'];

tests/library/browsercontext-events.spec.ts

@@ -52,8 +52,8 @@ test('console event should work in popup', async ({ page }) => {
   expect(message.page()).toBe(popup);
 });
 
-test('console event should work in popup 2', async ({ page, browserName }) => {
-  test.fixme(browserName === 'firefox', 'console message from javascript: url is not reported at all');
+test('console event should work in popup 2', async ({ page, browserName, channel }) => {
+  test.fixme(browserName === 'firefox' && !channel?.startsWith('moz-firefox'), 'console message from javascript: url is not reported at all');
 
   const [, message, popup] = await Promise.all([
     page.evaluate(async () => {
@@ -69,8 +69,8 @@ test('console event should work in popup 2', async ({ page, browserName }) => {
   expect(message.page()).toBe(popup);
 });
 
-test('console event should work in immediately closed popup', async ({ page, browserName }) => {
-  test.fixme(browserName === 'firefox', 'console message is not reported at all');
+test('console event should work in immediately closed popup', async ({ page, browserName, channel }) => {
+  test.fixme(browserName === 'firefox' && !channel?.startsWith('moz-firefox'), 'console message is not reported at all');
 
   const [, message, popup] = await Promise.all([
     page.evaluate(async () => {

tests/library/browsercontext-pages.spec.ts

@@ -79,8 +79,8 @@ it('should click the button with deviceScaleFactor set', async ({ browser, serve
   await context.close();
 });
 
-it('should click the button with offset with page scale', async ({ browser, server, browserName }) => {
-  it.skip(browserName === 'firefox');
+it('should click the button with offset with page scale', async ({ browser, server, browserName, channel }) => {
+  it.skip(browserName === 'firefox' && !channel?.startsWith('moz-firefox'));
 
   const context = await browser.newContext({ viewport: { width: 400, height: 400 }, isMobile: true });
   const page = await context.newPage();
@@ -102,8 +102,8 @@ it('should click the button with offset with page scale', async ({ browser, serv
   await context.close();
 });
 
-it('should return bounding box with page scale', async ({ browser, server, browserName }) => {
-  it.skip(browserName === 'firefox');
+it('should return bounding box with page scale', async ({ browser, server, browserName, channel }) => {
+  it.skip(browserName === 'firefox' && !channel?.startsWith('moz-firefox'));
 
   const context = await browser.newContext({ viewport: { width: 400, height: 400 }, isMobile: true });
   const page = await context.newPage();

tests/library/browsercontext-viewport-mobile.spec.ts

@@ -18,7 +18,7 @@
 import { browserTest as it, expect } from '../config/browserTest';
 
 it.describe('mobile viewport', () => {
-  it.skip(({ browserName }) => browserName === 'firefox');
+  it.skip(({ browserName, channel }) => browserName === 'firefox' && !channel?.startsWith('moz-firefox'));
 
   it('should support mobile emulation', async ({ playwright, browser, server }) => {
     const iPhone = playwright.devices['iPhone 6'];

tests/library/browsercontext-viewport.spec.ts

@@ -186,9 +186,9 @@ browserTest('should be able to get correct orientation angle on non-mobile devic
   await context.close();
 });
 
-it('should set window.screen.orientation.type for mobile devices', async ({ contextFactory, browserName, server }) => {
+it('should set window.screen.orientation.type for mobile devices', async ({ contextFactory, browserName, server, channel }) => {
   it.info().annotations.push({ type: 'issue', description: 'https://github.com/microsoft/playwright/issues/31151' });
-  it.skip(browserName === 'firefox', 'Firefox does not support mobile emulation');
+  it.skip(browserName === 'firefox' && !channel?.startsWith('moz-firefox'), 'Firefox does not support mobile emulation');
   const context = await contextFactory(devices['iPhone 14']);
   const page = await context.newPage();
   await page.goto(server.PREFIX + '/index.html');

tests/library/browsertype-launch.spec.ts

@@ -53,8 +53,8 @@ it('should throw if port option is passed for persistent context', async ({ brow
   expect(error!.message).toContain('Cannot specify a port without launching as a server.');
 });
 
-it('should throw if page argument is passed', async ({ browserType, browserName }) => {
-  it.skip(browserName === 'firefox');
+it('should throw if page argument is passed', async ({ browserType, browserName, channel }) => {
+  it.skip(browserName === 'firefox' && !channel?.startsWith('moz-firefox'));
 
   let waitError: Error | undefined;
   await browserType.launch({ args: ['http://example.com'] }).catch(e => waitError = e);

tests/library/defaultbrowsercontext-2.spec.ts

@@ -148,8 +148,8 @@ it('should have default URL when launching browser', async ({ launchPersistent }
   expect(urls).toEqual(['about:blank']);
 });
 
-it('should throw if page argument is passed', async ({ browserType, server, createUserDataDir, browserName }) => {
-  it.skip(browserName === 'firefox');
+it('should throw if page argument is passed', async ({ browserType, server, createUserDataDir, browserName, channel }) => {
+  it.skip(browserName === 'firefox' && !channel?.startsWith('moz-firefox'));
 
   const options = { args: [server.EMPTY_PAGE] };
   const error = await browserType.launchPersistentContext(await createUserDataDir(), options).catch(e => e);

tests/library/emulation-focus.spec.ts

@@ -199,10 +199,10 @@ browserTest('should not fire blur events when interacting with more than one pag
   expect(await page2.evaluate(() => !!window['gotBlur'])).toBe(false);
 });
 
-browserTest('should trigger hover state concurrently', async ({ browserType, browserName, headless }) => {
+browserTest('should trigger hover state concurrently', async ({ browserType, browserName, headless, channel }) => {
   browserTest.info().annotations.push({ type: 'issue', description: 'https://github.com/microsoft/playwright/issues/27969' });
   browserTest.skip(!headless, 'headed messes up with hover');
-  browserTest.fixme(browserName === 'firefox');
+  browserTest.fixme(browserName === 'firefox' && !channel?.startsWith('moz-firefox'));
 
   const browser1 = await browserType.launch();
   const context1 = await browser1.newContext();

tests/library/headful.spec.ts

@@ -288,9 +288,9 @@ it('should click bottom row w/ infobar in OOPIF', async ({ browserName, launchPe
   expect(await page.frames()[1].evaluate('window._clicked')).toBe(true);
 });
 
-it('headless and headful should use same default fonts', async ({ page, browserName, browserType }) => {
+it('headless and headful should use same default fonts', async ({ page, browserName, browserType, channel }) => {
   it.info().annotations.push({ type: 'issue', description: 'https://github.com/microsoft/playwright/issues/11177' });
-  it.skip(browserName === 'firefox', 'Text is misaligned in headed vs headless');
+  it.skip(browserName === 'firefox' && !channel?.startsWith('moz-firefox'), 'Text is misaligned in headed vs headless');
 
   const genericFontFamilies = [
     'standard',

tests/library/resource-timing.spec.ts

@@ -100,9 +100,9 @@ it('should work for redirect', async ({ contextFactory, browserName, server }) =
   await context.close();
 });
 
-it('should work when serving from memory cache', async ({ contextFactory, server, browserName }) => {
+it('should work when serving from memory cache', async ({ contextFactory, server, browserName, channel }) => {
   it.info().annotations.push({ type: 'issue', description: 'https://github.com/microsoft/playwright-java/issues/1080' });
-  it.fixme(browserName === 'firefox', 'Response event is not fired in Firefox');
+  it.fixme(browserName === 'firefox' && !channel?.startsWith('moz-firefox'), 'Response event is not fired in Firefox');
   server.setRoute('/one-style.css', (req, res) => {
     res.writeHead(200, {
       'Content-Type': 'text/css',

tests/library/screenshot.spec.ts

@@ -202,8 +202,8 @@ browserTest.describe('page screenshot', () => {
 browserTest.describe('element screenshot', () => {
   browserTest.skip(({ browserName, headless }) => browserName === 'firefox' && !headless);
 
-  browserTest('element screenshot should work with a mobile viewport', async ({ browser, server, browserName }) => {
-    browserTest.skip(browserName === 'firefox');
+  browserTest('element screenshot should work with a mobile viewport', async ({ browser, server, browserName, channel }) => {
+    browserTest.skip(browserName === 'firefox' && !channel?.startsWith('moz-firefox'));
 
     const context = await browser.newContext({ viewport: { width: 320, height: 480 }, isMobile: true });
     const page = await context.newPage();
@@ -215,8 +215,8 @@ browserTest.describe('element screenshot', () => {
     await context.close();
   });
 
-  browserTest('element screenshot should work with device scale factor', async ({ browser, server, browserName, isMac }) => {
-    browserTest.skip(browserName === 'firefox');
+  browserTest('element screenshot should work with device scale factor', async ({ browser, server, browserName, channel }) => {
+    browserTest.skip(browserName === 'firefox' && !channel?.startsWith('moz-firefox'));
 
     const context = await browser.newContext({ viewport: { width: 320, height: 480 }, deviceScaleFactor: 2 });
     const page = await context.newPage();

tests/library/trace-viewer.spec.ts

@@ -1698,8 +1698,8 @@ test('canvas clipping in iframe', async ({ runAndTrace, page, server }) => {
   await expect(canvas).toHaveAttribute('title', 'Canvas contents are displayed on a best-effort basis based on viewport screenshots taken during test execution.');
 });
 
-test('should show only one pointer with multilevel iframes', async ({ page, runAndTrace, server, browserName }) => {
-  test.fixme(browserName === 'firefox', 'Elements in iframe are not marked');
+test('should show only one pointer with multilevel iframes', async ({ page, runAndTrace, server, browserName, channel }) => {
+  test.fixme(browserName === 'firefox' && !channel?.startsWith('moz-firefox'), 'Elements in iframe are not marked');
 
   server.setRoute('/level-0.html', (req, res) => {
     res.writeHead(200, { 'Content-Type': 'text/html' });

tests/page/frame-goto.spec.ts

@@ -43,9 +43,9 @@ it('should reject when frame detaches', async ({ page, server, browserName }) =>
     expect(error.message.toLowerCase()).toContain('frame was detached');
 });
 
-it('should continue after client redirect', async ({ page, server, isAndroid, browserName }) => {
+it('should continue after client redirect', async ({ page, server, isAndroid, browserName, channel }) => {
   it.fixme(isAndroid);
-  it.fixme(browserName === 'firefox', 'script.js is requested before navigationCommitted arrives');
+  it.fixme(browserName === 'firefox' && !channel?.startsWith('moz-firefox'), 'script.js is requested before navigationCommitted arrives');
 
   server.setRoute('/frames/script.js', () => {});
   const url = server.PREFIX + '/frames/child-redirect.html';

tests/page/page-event-load.spec.ts

@@ -17,9 +17,9 @@
 import { test as it, expect } from './pageTest';
 
 
-it('should fire once', async ({ page, server, browserName }) => {
+it('should fire once', async ({ page, server, browserName, channel }) => {
   it.info().annotations.push({ type: 'issue', description: 'https://github.com/microsoft/playwright/issues/15086' });
-  it.fixme(browserName === 'firefox', 'Firefox sometimes double fires.');
+  it.fixme(browserName === 'firefox' && !channel?.startsWith('moz-firefox'), 'Firefox sometimes double fires.');
 
   let count = 0;
   page.on('load', () => count++);
@@ -28,9 +28,9 @@ it('should fire once', async ({ page, server, browserName }) => {
   expect(count).toBe(1);
 });
 
-it('should fire once with iframe navigation', async ({ page, server, browserName }) => {
+it('should fire once with iframe navigation', async ({ page, server, browserName, channel }) => {
   it.info().annotations.push({ type: 'issue', description: 'https://github.com/microsoft/playwright/issues/15086' });
-  it.fixme(browserName === 'firefox', 'Firefox sometimes double fires.');
+  it.fixme(browserName === 'firefox' && !channel?.startsWith('moz-firefox'), 'Firefox sometimes double fires.');
 
   let requestCount = 0;
   server.setRoute('/tracker', (_, res) => {

tests/page/page-fill.spec.ts

@@ -201,8 +201,8 @@ it('should fill contenteditable', async ({ page, server }) => {
   expect(await page.$eval('div[contenteditable]', div => div.textContent)).toBe('some value');
 });
 
-it('should fill contenteditable with new lines', async ({ page, server, browserName }) => {
-  it.fixme(browserName === 'firefox', 'Firefox does not handle new lines in contenteditable');
+it('should fill contenteditable with new lines', async ({ page, server, browserName, channel }) => {
+  it.fixme(browserName === 'firefox' && !channel?.startsWith('moz-firefox'), 'Firefox does not handle new lines in contenteditable');
 
   await page.goto(server.EMPTY_PAGE);
   await page.setContent(`<div contenteditable="true"></div>`);

tests/page/page-focus.spec.ts

@@ -16,8 +16,8 @@
 
 import { test as it, expect } from './pageTest';
 
-it('should work @smoke', async function({ page, browserName }) {
-  it.skip(browserName === 'firefox');
+it('should work @smoke', async function({ page, browserName, channel }) {
+  it.skip(browserName === 'firefox' && !channel?.startsWith('moz-firefox'));
 
   await page.setContent(`<div id=d1 tabIndex=0></div>`);
   expect(await page.evaluate(() => document.activeElement.nodeName)).toBe('BODY');