ep_webrtc 2.5.35 → 2.5.36

package/static/tests/frontend-new/specs/interface_buttons.spec.ts

@@ -0,0 +1,271 @@
+import {expect, test} from '@playwright/test';
+import {goToNewPadWithParams, installFakeGetUserMedia, setPadPrefsCookie} from '../helper/utils';
+
+// Helpers for inspecting the in-page tracks captured by the fake
+// getUserMedia (see installFakeGetUserMedia({track:true})).
+const tracksInfo = async (page: import('@playwright/test').Page) =>
+    page.evaluate(() => {
+      const w = window as any;
+      const stream: MediaStream | undefined = w.__webrtcLastStream;
+      const a = stream && stream.getAudioTracks()[0];
+      const v = stream && stream.getVideoTracks()[0];
+      return {
+        hasStream: !!stream,
+        audio: a ? {enabled: a.enabled} : null,
+        video: v ? {enabled: v.enabled} : null,
+      };
+    });
+
+test.describe('Test the behavior of the interface buttons: Mute, Video Disable, Enlarge', () => {
+  test.describe('audio and video on by default', () => {
+    test.beforeEach(async ({page, context}) => {
+      test.setTimeout(60_000);
+      await context.clearCookies();
+      await setPadPrefsCookie(page, {
+        rtcEnabled: false,
+        audioEnabledOnStart: true,
+        videoEnabledOnStart: true,
+      });
+      await goToNewPadWithParams(page, {});
+      await installFakeGetUserMedia(page, {track: true});
+      await page.evaluate(() => (window as any).ep_webrtc.activate());
+    });
+
+    test('enlarges then shrinks', async ({page}) => {
+      test.setTimeout(60_000);
+      // i.e., "160.25px" -> 160.25 the number
+      const numFromCss = (s: string | null): number => {
+        expect(s && s.endsWith('px')).toBeTruthy();
+        return Number((s as string).slice(0, -2));
+      };
+
+      await page.waitForFunction(() => {
+        const v = document.querySelector('video') as HTMLElement | null;
+        if (!v) return false;
+        const cs = getComputedStyle(v);
+        const w = parseFloat(cs.width);
+        const h = parseFloat(cs.height);
+        return 159 < w && w < 161 && 119 < h && h < 121;
+      });
+
+      await page.locator('.enlarge-btn').first().evaluate(
+          (el) => (window as any).$(el).click());
+      // Expect grow to 260, 190 (test originally used >259 width and >194 height).
+      await page.waitForFunction(() => {
+        const v = document.querySelector('video') as HTMLElement | null;
+        if (!v) return false;
+        const cs = getComputedStyle(v);
+        return parseFloat(cs.width) > 259 && parseFloat(cs.height) > 194;
+      }, undefined, {timeout: 1000});
+      await page.locator('.enlarge-btn').first().evaluate(
+          (el) => (window as any).$(el).click());
+      // Shrink back to <161, <121.
+      await page.waitForFunction(() => {
+        const v = document.querySelector('video') as HTMLElement | null;
+        if (!v) return false;
+        const cs = getComputedStyle(v);
+        return parseFloat(cs.width) < 161 && parseFloat(cs.height) < 121;
+      }, undefined, {timeout: 1000});
+      // Silence numFromCss "unused" warning by referencing it in a noop.
+      void numFromCss;
+    });
+
+    test('mutes then unmutes', async ({page}) => {
+      test.setTimeout(60_000);
+      const info0 = await tracksInfo(page);
+      expect(info0.audio?.enabled).toBe(true);
+      expect(await page.locator('.audio-btn.muted').count()).toBe(0);
+      expect(await page.locator('.audio-btn').first().getAttribute('title')).toBe('Mute');
+
+      await page.locator('.audio-btn').first().evaluate(
+          (el) => (window as any).$(el).click());
+
+      await page.waitForFunction(() => {
+        const w = window as any;
+        const stream: MediaStream | undefined = w.__webrtcLastStream;
+        const a = stream && stream.getAudioTracks()[0];
+        return document.querySelectorAll('.audio-btn.muted').length === 1 && a && a.enabled === false;
+      }, undefined, {timeout: 3000});
+      expect(await page.locator('.audio-btn').first().getAttribute('title')).toBe('Unmute');
+
+      await page.locator('.audio-btn').first().evaluate(
+          (el) => (window as any).$(el).click());
+      await page.waitForFunction(() => {
+        const w = window as any;
+        const stream: MediaStream | undefined = w.__webrtcLastStream;
+        const a = stream && stream.getAudioTracks()[0];
+        return document.querySelectorAll('.audio-btn.muted').length === 0 && a && a.enabled === true;
+      }, undefined, {timeout: 3000});
+      expect(await page.locator('.audio-btn').first().getAttribute('title')).toBe('Mute');
+    });
+
+    test('disables then enables video', async ({page}) => {
+      test.setTimeout(60_000);
+      const info0 = await tracksInfo(page);
+      expect(info0.video?.enabled).toBe(true);
+      expect(await page.locator('.video-btn.off').count()).toBe(0);
+      expect(await page.locator('.video-btn').first().getAttribute('title'))
+          .toContain('Disable');
+
+      await page.locator('.video-btn').first().evaluate(
+          (el) => (window as any).$(el).click());
+      await page.waitForFunction(() => {
+        const w = window as any;
+        const stream: MediaStream | undefined = w.__webrtcLastStream;
+        const v = stream && stream.getVideoTracks()[0];
+        return document.querySelectorAll('.video-btn.off').length === 1 && v && v.enabled === false;
+      }, undefined, {timeout: 3000});
+      expect(await page.locator('.video-btn').first().getAttribute('title'))
+          .toContain('Enable');
+
+      await page.locator('.video-btn').first().evaluate(
+          (el) => (window as any).$(el).click());
+      await page.waitForFunction(() => {
+        const w = window as any;
+        const stream: MediaStream | undefined = w.__webrtcLastStream;
+        const v = stream && stream.getVideoTracks()[0];
+        return document.querySelectorAll('.video-btn.off').length === 0 && v && v.enabled === true;
+      }, undefined, {timeout: 3000});
+      expect(await page.locator('.video-btn').first().getAttribute('title'))
+          .toContain('Disable');
+    });
+  });
+
+  test.describe('audio and video off by default', () => {
+    test.beforeEach(async ({page, context}) => {
+      test.setTimeout(60_000);
+      await context.clearCookies();
+      await setPadPrefsCookie(page, {
+        rtcEnabled: false,
+        audioEnabledOnStart: false,
+        videoEnabledOnStart: false,
+      });
+      await goToNewPadWithParams(page, {});
+      await installFakeGetUserMedia(page, {track: true});
+      await page.evaluate(() => (window as any).ep_webrtc.activate());
+    });
+
+    test('unmutes then mutes', async ({page}) => {
+      test.setTimeout(60_000);
+      const info0 = await tracksInfo(page);
+      // No getUserMedia call yet because audio/video are off on start.
+      expect(info0.hasStream).toBe(false);
+      expect(await page.locator('.audio-btn.muted').count()).toBe(1);
+      expect(await page.locator('.audio-btn').first().getAttribute('title')).toBe('Unmute');
+
+      await page.locator('.audio-btn').first().evaluate(
+          (el) => (window as any).$(el).click());
+      await page.waitForFunction(() => {
+        const w = window as any;
+        const stream: MediaStream | undefined = w.__webrtcLastStream;
+        const a = stream && stream.getAudioTracks()[0];
+        return document.querySelectorAll('.audio-btn.muted').length === 0 &&
+               a != null && a.enabled;
+      }, undefined, {timeout: 3000});
+      expect(await page.locator('.audio-btn').first().getAttribute('title')).toBe('Mute');
+
+      await page.locator('.audio-btn').first().evaluate(
+          (el) => (window as any).$(el).click());
+      await page.waitForFunction(() => {
+        const w = window as any;
+        const stream: MediaStream | undefined = w.__webrtcLastStream;
+        const a = stream && stream.getAudioTracks()[0];
+        return document.querySelectorAll('.audio-btn.muted').length === 1 &&
+               a && a.enabled === false;
+      }, undefined, {timeout: 3000});
+      expect(await page.locator('.audio-btn').first().getAttribute('title')).toBe('Unmute');
+    });
+
+    test('enables then disables video', async ({page}) => {
+      test.setTimeout(60_000);
+      const info0 = await tracksInfo(page);
+      expect(info0.hasStream).toBe(false);
+      expect(await page.locator('.video-btn.off').count()).toBe(1);
+      expect(await page.locator('.video-btn').first().getAttribute('title'))
+          .toContain('Enable');
+
+      await page.locator('.video-btn').first().evaluate(
+          (el) => (window as any).$(el).click());
+      await page.waitForFunction(() => {
+        const w = window as any;
+        const stream: MediaStream | undefined = w.__webrtcLastStream;
+        const v = stream && stream.getVideoTracks()[0];
+        return document.querySelectorAll('.video-btn.off').length === 0 &&
+               v != null && v.enabled;
+      }, undefined, {timeout: 3000});
+      expect(await page.locator('.video-btn').first().getAttribute('title'))
+          .toContain('Disable');
+
+      await page.locator('.video-btn').first().evaluate(
+          (el) => (window as any).$(el).click());
+      await page.waitForFunction(() => {
+        const w = window as any;
+        const stream: MediaStream | undefined = w.__webrtcLastStream;
+        const v = stream && stream.getVideoTracks()[0];
+        return document.querySelectorAll('.video-btn.off').length === 1 &&
+               v && v.enabled === false;
+      }, undefined, {timeout: 3000});
+      expect(await page.locator('.video-btn').first().getAttribute('title'))
+          .toContain('Enable');
+    });
+  });
+
+  test.describe('audio and video hard-disabled', () => {
+    test.beforeEach(async ({page, context}) => {
+      test.setTimeout(60_000);
+      await context.clearCookies();
+      // Disable WebRTC so we can install fake getUserMedia and tweak settings
+      // before activation.
+      await goToNewPadWithParams(page, {av: false});
+      await page.waitForFunction(
+          () => (window as any).$('#rtcbox').data('initialized'));
+      await page.evaluate(() => {
+        const w = window as any;
+        w.ep_webrtc._settings.audio.disabled = 'hard';
+        w.ep_webrtc._settings.video.disabled = 'hard';
+      });
+      await installFakeGetUserMedia(page, {track: true});
+      await page.evaluate(() => (window as any).ep_webrtc.activate());
+    });
+
+    test('cannot mute or unmute', async ({page}) => {
+      test.setTimeout(60_000);
+      expect(await page.locator('.audio-btn.disallowed').count()).toBe(1);
+      expect(await page.locator('.audio-btn.muted').count()).toBe(1);
+      expect(await page.locator('.audio-btn').first().getAttribute('title'))
+          .toBe('Audio disallowed by admin');
+      const info = await tracksInfo(page);
+      expect(info.hasStream).toBe(false);
+
+      await page.locator('.audio-btn').first().evaluate(
+          (el) => (window as any).$(el).click());
+      await page.waitForTimeout(200);
+      expect(await page.locator('.audio-btn.disallowed').count()).toBe(1);
+      expect(await page.locator('.audio-btn.muted').count()).toBe(1);
+      expect(await page.locator('.audio-btn').first().getAttribute('title'))
+          .toBe('Audio disallowed by admin');
+      const info2 = await tracksInfo(page);
+      expect(info2.hasStream).toBe(false);
+    });
+
+    test('cannot enable or disable video', async ({page}) => {
+      test.setTimeout(60_000);
+      expect(await page.locator('.video-btn.disallowed').count()).toBe(1);
+      expect(await page.locator('.video-btn.off').count()).toBe(1);
+      expect(await page.locator('.video-btn').first().getAttribute('title'))
+          .toBe('Video disallowed by admin');
+      const info = await tracksInfo(page);
+      expect(info.hasStream).toBe(false);
+
+      await page.locator('.video-btn').first().evaluate(
+          (el) => (window as any).$(el).click());
+      await page.waitForTimeout(200);
+      expect(await page.locator('.video-btn.disallowed').count()).toBe(1);
+      expect(await page.locator('.video-btn.off').count()).toBe(1);
+      expect(await page.locator('.video-btn').first().getAttribute('title'))
+          .toBe('Video disallowed by admin');
+      const info2 = await tracksInfo(page);
+      expect(info2.hasStream).toBe(false);
+    });
+  });
+});

package/static/tests/frontend-new/specs/race_conditions.spec.ts

@@ -0,0 +1,271 @@
+import {expect, test} from '@playwright/test';
+import {goToNewPadWithParams, installFakeGetUserMedia, setPadPrefsCookie} from '../helper/utils';
+
+// 1:1 port of static/tests/frontend/specs/race_conditions.js. The
+// per-iteration assertions about track identity/readyState live inside
+// page.evaluate() so we can compare track object identity in browser
+// context.
+
+test.describe('Race conditions that leave audio/video track enabled', () => {
+  for (const enabledOnStart of [false, true]) {
+    test.describe(`audio and video ${enabledOnStart ? 'en' : 'dis'}abled on start`, () => {
+      test.beforeEach(async ({page, context}) => {
+        test.setTimeout(60_000);
+        await context.clearCookies();
+        await setPadPrefsCookie(page, {
+          audioEnabledOnStart: enabledOnStart,
+          videoEnabledOnStart: enabledOnStart,
+        });
+        // Disable WebRTC so we can install a fake getUserMedia() before it is called.
+        await goToNewPadWithParams(page, {av: false});
+        await installFakeGetUserMedia(page);
+        await page.locator('#options-enablertc').evaluate(
+            (el) => (window as any).$(el).click());
+        await page.waitForFunction(
+            () => (window as any).$('#rtcbox').data('initialized'));
+        await page.waitForFunction(() => document.querySelector('video') != null);
+        const initOk = await page.evaluate((enabledOnStart) => {
+          const w = window as any;
+          const ownVideoId = `video_${w.ep_webrtc.getUserId().replace(/\./g, '_')}`;
+          const $interface = w.$(`#interface_${ownVideoId}`);
+          if ($interface.length !== 1) return false;
+          if (w.$('.audio-btn').length !== 1) return false;
+          if (w.$('.video-btn').length !== 1) return false;
+          return true;
+        }, enabledOnStart);
+        expect(initOk).toBe(true);
+        await page.waitForFunction((enabledOnStart) => {
+          const v = document.querySelector('video') as HTMLVideoElement | null;
+          const stream = v && (v.srcObject as MediaStream | null);
+          return stream != null && (!enabledOnStart || stream.getTracks().length === 2);
+        }, enabledOnStart);
+        // assertTracks() initial check.
+        const ok = await page.evaluate((enabledOnStart) => {
+          const w = window as any;
+          const v = document.querySelector('video') as HTMLVideoElement;
+          const stream = v.srcObject as MediaStream;
+          if (enabledOnStart) {
+            if (stream.getTracks().length !== 2) return false;
+            if (!stream.getTracks().every((t) => t.enabled)) return false;
+          } else if (stream.getTracks().some((t) => t.enabled)) {
+            return false;
+          }
+          const audio = stream.getAudioTracks()[0];
+          const video = stream.getVideoTracks()[0];
+          if (w.$('.audio-btn').hasClass('muted') !== (audio == null || !audio.enabled)) return false;
+          if (w.$('.video-btn').hasClass('off') !== (video == null || !video.enabled)) return false;
+          return true;
+        }, enabledOnStart);
+        expect(ok).toBe(true);
+      });
+
+      test('deactivate, click, activate', async ({page}) => {
+        test.setTimeout(60_000);
+        for (let i = 0; i < 10; ++i) {
+          const ok = await page.evaluate(async (enabledOnStart) => {
+            const w = window as any;
+            const v = document.querySelector('video') as HTMLVideoElement;
+            const oldStream = v.srcObject as MediaStream;
+            const [oldA] = oldStream.getAudioTracks();
+            const [oldV] = oldStream.getVideoTracks();
+            await w.ep_webrtc.deactivate();
+            w.$('.audio-btn').click();
+            w.$('.video-btn').click();
+            await w.ep_webrtc.activate();
+            const v2 = document.querySelector('video') as HTMLVideoElement;
+            const stream = v2.srcObject as MediaStream;
+            const audio = stream.getAudioTracks()[0];
+            const video = stream.getVideoTracks()[0];
+            const aBtnOk = w.$('.audio-btn').hasClass('muted') === (audio == null || !audio.enabled);
+            const vBtnOk = w.$('.video-btn').hasClass('off') === (video == null || !video.enabled);
+            if (!aBtnOk || !vBtnOk) return {ok: false};
+            if (enabledOnStart) {
+              if (stream.getTracks().length !== 2) return {ok: false};
+              if (!stream.getTracks().every((t) => t.enabled)) return {ok: false};
+            } else if (stream.getTracks().some((t) => t.enabled)) {
+              return {ok: false};
+            }
+            const [newA] = stream.getAudioTracks();
+            const [newV] = stream.getVideoTracks();
+            if (enabledOnStart) {
+              if (newA === oldA) return {ok: false};
+              if (oldA.readyState !== 'ended') return {ok: false};
+              if (newA.readyState !== 'live') return {ok: false};
+              if (newV === oldV) return {ok: false};
+              if (oldV.readyState !== 'ended') return {ok: false};
+              if (newV.readyState !== 'live') return {ok: false};
+            }
+            return {ok: true};
+          }, enabledOnStart);
+          expect(ok.ok).toBe(true);
+        }
+      });
+
+      test('click, deactivate, activate', async ({page}) => {
+        test.setTimeout(60_000);
+        for (let i = 0; i < 10; ++i) {
+          const ok = await page.evaluate(async (enabledOnStart) => {
+            const w = window as any;
+            const v = document.querySelector('video') as HTMLVideoElement;
+            const oldStream = v.srcObject as MediaStream;
+            const [oldA] = oldStream.getAudioTracks();
+            const [oldV] = oldStream.getVideoTracks();
+            w.$('.audio-btn').click();
+            w.$('.video-btn').click();
+            await w.ep_webrtc.deactivate();
+            await w.ep_webrtc.activate();
+            const v2 = document.querySelector('video') as HTMLVideoElement;
+            const stream = v2.srcObject as MediaStream;
+            const audio = stream.getAudioTracks()[0];
+            const video = stream.getVideoTracks()[0];
+            const aBtnOk = w.$('.audio-btn').hasClass('muted') === (audio == null || !audio.enabled);
+            const vBtnOk = w.$('.video-btn').hasClass('off') === (video == null || !video.enabled);
+            if (!aBtnOk || !vBtnOk) return {ok: false};
+            if (enabledOnStart) {
+              if (stream.getTracks().length !== 2) return {ok: false};
+              if (!stream.getTracks().every((t) => t.enabled)) return {ok: false};
+            } else if (stream.getTracks().some((t) => t.enabled)) {
+              return {ok: false};
+            }
+            const [newA] = stream.getAudioTracks();
+            const [newV] = stream.getVideoTracks();
+            if (enabledOnStart) {
+              if (newA === oldA) return {ok: false};
+              if (oldA.readyState !== 'ended') return {ok: false};
+              if (newA.readyState !== 'live') return {ok: false};
+              if (newV === oldV) return {ok: false};
+              if (oldV.readyState !== 'ended') return {ok: false};
+              if (newV.readyState !== 'live') return {ok: false};
+            }
+            return {ok: true};
+          }, enabledOnStart);
+          expect(ok.ok).toBe(true);
+        }
+      });
+
+      test('deactivate, activate, click', async ({page}) => {
+        test.setTimeout(60_000);
+        for (let i = 0; i < 10; ++i) {
+          const ok = await page.evaluate(async (enabledOnStart) => {
+            const w = window as any;
+            const v = document.querySelector('video') as HTMLVideoElement;
+            const oldStream = v.srcObject as MediaStream;
+            const [oldA] = oldStream.getAudioTracks();
+            const [oldV] = oldStream.getVideoTracks();
+            await w.ep_webrtc.deactivate();
+            const p = w.ep_webrtc.activate();
+            // Wait for interface-container to be present (legacy waitForPromise).
+            const t0 = Date.now();
+            while (w.$('.interface-container').length !== 1) {
+              if (Date.now() - t0 > 2000) return {ok: false, reason: 'no interface'};
+              await new Promise((r) => setTimeout(r, 10));
+            }
+            w.$('.audio-btn').click();
+            w.$('.video-btn').click();
+            await Promise.all([
+              p,
+              w.$('.audio-btn').data('idle')('click'),
+              w.$('.video-btn').data('idle')('click'),
+            ]);
+            // assertTracks(!enabledOnStart)
+            const v2 = document.querySelector('video') as HTMLVideoElement;
+            const stream = v2.srcObject as MediaStream;
+            const audio = stream.getAudioTracks()[0];
+            const video = stream.getVideoTracks()[0];
+            const expectEnabled = !enabledOnStart;
+            if (expectEnabled) {
+              if (stream.getTracks().length !== 2) return {ok: false};
+              if (!stream.getTracks().every((t) => t.enabled)) return {ok: false};
+            } else if (stream.getTracks().some((t) => t.enabled)) {
+              return {ok: false};
+            }
+            if (w.$('.audio-btn').hasClass('muted') !== (audio == null || !audio.enabled)) return {ok: false};
+            if (w.$('.video-btn').hasClass('off') !== (video == null || !video.enabled)) return {ok: false};
+            const [newA] = stream.getAudioTracks();
+            const [newV] = stream.getVideoTracks();
+            if (newA === oldA) return {ok: false};
+            if (oldA != null && oldA.readyState !== 'ended') return {ok: false};
+            if (newA != null && newA.readyState !== 'live') return {ok: false};
+            if (newV === oldV) return {ok: false};
+            if (oldV != null && oldV.readyState !== 'ended') return {ok: false};
+            if (newV != null && newV.readyState !== 'live') return {ok: false};
+            return {ok: true};
+          }, enabledOnStart);
+          expect(ok.ok).toBe(true);
+        }
+      });
+
+      test('click while reactivate', async ({page}) => {
+        test.setTimeout(60_000);
+        for (let i = 0; i < 10; i++) {
+          const ok = await page.evaluate(async (enabledOnStart) => {
+            const w = window as any;
+            const v = document.querySelector('video') as HTMLVideoElement;
+            const oldStream = v.srcObject as MediaStream;
+            const [oldA] = oldStream.getAudioTracks();
+            const [oldV] = oldStream.getVideoTracks();
+
+            await w.ep_webrtc.deactivate();
+            const p = w.ep_webrtc.activate();
+            w.$('.audio-btn').click();
+            w.$('.video-btn').click();
+            await Promise.all([
+              p,
+              w.$('.audio-btn').data('idle')(),
+              w.$('.video-btn').data('idle')(),
+            ]);
+            const v2 = document.querySelector('video') as HTMLVideoElement;
+            const stream = v2.srcObject as MediaStream;
+            const audio = stream.getAudioTracks()[0];
+            const video = stream.getVideoTracks()[0];
+            const expectEnabled = !enabledOnStart;
+            if (expectEnabled) {
+              if (stream.getTracks().length !== 2) return {ok: false};
+              if (!stream.getTracks().every((t) => t.enabled)) return {ok: false};
+            } else if (stream.getTracks().some((t) => t.enabled)) {
+              return {ok: false};
+            }
+            if (w.$('.audio-btn').hasClass('muted') !== (audio == null || !audio.enabled)) return {ok: false};
+            if (w.$('.video-btn').hasClass('off') !== (video == null || !video.enabled)) return {ok: false};
+            const [newA] = stream.getAudioTracks();
+            const [newV] = stream.getVideoTracks();
+            if (!enabledOnStart) {
+              if (newA === oldA) return {ok: false};
+              if (oldA != null && oldA.readyState !== 'ended') return {ok: false};
+              if (newA != null && newA.readyState !== 'live') return {ok: false};
+              if (newV === oldV) return {ok: false};
+              if (oldV != null && oldV.readyState !== 'ended') return {ok: false};
+              if (newV != null && newV.readyState !== 'live') return {ok: false};
+            }
+            return {ok: true};
+          }, enabledOnStart);
+          expect(ok.ok).toBe(true);
+        }
+      });
+
+      test('many clicks', async ({page}) => {
+        test.setTimeout(60_000);
+        for (let i = 0; i < 10; ++i) {
+          const ok = await page.evaluate(async ({i, enabledOnStart}) => {
+            const w = window as any;
+            w.$('.audio-btn').click();
+            w.$('.audio-btn').click();
+            w.$('.audio-btn').click();
+            w.$('.video-btn').click();
+            w.$('.video-btn').click();
+            await Promise.all([
+              w.$('.audio-btn').data('idle')(),
+              w.$('.video-btn').data('idle')(),
+            ]);
+            const aMuted = w.$('.audio-btn').hasClass('muted');
+            const vOff = w.$('.video-btn').hasClass('off');
+            const wantA = ((i + 1) * 3 + (enabledOnStart ? 1 : 0)) % 2 === 0;
+            const wantV = ((i + 1) * 2 + (enabledOnStart ? 1 : 0)) % 2 === 0;
+            return aMuted === wantA && vOff === wantV;
+          }, {i, enabledOnStart});
+          expect(ok).toBe(true);
+        }
+      });
+    });
+  }
+});