react-native-image-stitcher 0.15.2 → 0.16.1

package/src/camera/__tests__/lowMemDevice.test.ts

@@ -1,52 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Unit tests for the pure `isBelowMemThreshold` classifier.
- *
- * The other two exports (`getPhysicalMemoryBytes` and `isLowMemDevice`)
- * read the React Native bridge and can only be exercised on a real
- * device.  This file covers the threshold logic exhaustively so the
- * classification rule is unit-tested without needing the RN runtime.
- */
-
-import {
-  LOW_MEM_THRESHOLD_BYTES,
-  isBelowMemThreshold,
-} from '../lowMemDevice';
-
-
-describe('isBelowMemThreshold', () => {
-  it('returns true for positive byte counts below the threshold', () => {
-    expect(isBelowMemThreshold(1)).toBe(true);
-    expect(isBelowMemThreshold(1024)).toBe(true);
-    expect(isBelowMemThreshold(LOW_MEM_THRESHOLD_BYTES - 1)).toBe(true);
-  });
-
-  it('returns false at exactly the threshold (strict < comparison)', () => {
-    expect(isBelowMemThreshold(LOW_MEM_THRESHOLD_BYTES)).toBe(false);
-  });
-
-  it('returns false for byte counts above the threshold', () => {
-    expect(isBelowMemThreshold(LOW_MEM_THRESHOLD_BYTES + 1)).toBe(false);
-    expect(isBelowMemThreshold(4 * 1024 * 1024 * 1024)).toBe(false);
-    expect(isBelowMemThreshold(Number.MAX_SAFE_INTEGER)).toBe(false);
-  });
-
-  it('returns false for zero (unknown — safe default to high-quality combo)', () => {
-    expect(isBelowMemThreshold(0)).toBe(false);
-  });
-
-  it('returns false for negative values (defensive)', () => {
-    expect(isBelowMemThreshold(-1)).toBe(false);
-    expect(isBelowMemThreshold(-LOW_MEM_THRESHOLD_BYTES)).toBe(false);
-  });
-
-  it('returns false for non-finite values (NaN / Infinity)', () => {
-    expect(isBelowMemThreshold(Number.NaN)).toBe(false);
-    expect(isBelowMemThreshold(Number.POSITIVE_INFINITY)).toBe(false);
-    expect(isBelowMemThreshold(Number.NEGATIVE_INFINITY)).toBe(false);
-  });
-
-  it('threshold is exactly 2 GB', () => {
-    expect(LOW_MEM_THRESHOLD_BYTES).toBe(2 * 1024 * 1024 * 1024);
-  });
-});

package/src/camera/__tests__/selectCaptureDevice.test.ts

@@ -1,210 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Unit tests for `selectCaptureDevice` + `zoomForLens` — the pure
- * capability-aware back-camera selection (v0.13.2).
- *
- * Covers the device matrix from the plan
- * (docs/plans/2026-06-01-v0.13.2-multilens-device-selection.md),
- * including the critical edge cases:
- *   - ultra-wide ONLY inside a multi-cam device (Symptom 1 fix)
- *   - ultra-wide ONLY as a standalone device (Android; must NOT regress)
- *   - ultra-wide present BOTH ways (prefer multicam)
- *
- * Pure — no mocks needed; we build synthetic DeviceLike lists.
- */
-
-import {
-  selectCaptureDevice,
-  zoomForLens,
-  type DeviceLike,
-} from '../selectCaptureDevice';
-
-// ── Synthetic device builders ───────────────────────────────────────
-let idCounter = 0;
-function dev(partial: Partial<DeviceLike>): DeviceLike {
-  idCounter += 1;
-  return {
-    id: `dev-${idCounter}`,
-    position: 'back',
-    physicalDevices: ['wide-angle-camera'],
-    isMultiCam: false,
-    hasTorch: true,
-    minZoom: 1,
-    neutralZoom: 1,
-    maxZoom: 10,
-    ...partial,
-  };
-}
-
-const tripleCam = (p: Partial<DeviceLike> = {}) =>
-  dev({
-    physicalDevices: ['ultra-wide-angle-camera', 'wide-angle-camera', 'telephoto-camera'],
-    isMultiCam: true,
-    hasTorch: true,
-    minZoom: 0.5,
-    neutralZoom: 1,
-    maxZoom: 30,
-    ...p,
-  });
-const dualWide = (p: Partial<DeviceLike> = {}) =>
-  dev({
-    physicalDevices: ['ultra-wide-angle-camera', 'wide-angle-camera'],
-    isMultiCam: true,
-    hasTorch: true,
-    minZoom: 0.5,
-    neutralZoom: 1,
-    maxZoom: 6,
-    ...p,
-  });
-const standaloneWide = (p: Partial<DeviceLike> = {}) =>
-  dev({ physicalDevices: ['wide-angle-camera'], isMultiCam: false, hasTorch: true, ...p });
-const standaloneUltraWide = (p: Partial<DeviceLike> = {}) =>
-  dev({ physicalDevices: ['ultra-wide-angle-camera'], isMultiCam: false, hasTorch: false, ...p });
-
-describe('selectCaptureDevice', () => {
-  it('picks the MULTICAM device when one spans wide + ultra-wide (triple cam)', () => {
-    const triple = tripleCam();
-    const sel = selectCaptureDevice([triple, standaloneWide(), standaloneUltraWide()]);
-    expect(sel.mode).toBe('multicam');
-    expect(sel.device).toBe(triple);
-    expect(sel.ultraWideDevice).toBeNull();
-    expect(sel.has0_5x).toBe(true);
-    expect(sel.hasTorch).toBe(true);
-  });
-
-  it('picks the MULTICAM device for a dual-wide grouping', () => {
-    const dual = dualWide();
-    const sel = selectCaptureDevice([dual, standaloneWide()]);
-    expect(sel.mode).toBe('multicam');
-    expect(sel.device).toBe(dual);
-    expect(sel.has0_5x).toBe(true);
-  });
-
-  it('SYMPTOM 1 FIX: ultra-wide ONLY in a multi-cam device → multicam (not wide fallback)', () => {
-    // The exact bug: a phone where ultra-wide is bundled in a multicam
-    // device and there is NO standalone ultra-wide.  Old single-lens
-    // filter fell back to wide-angle; we must pick the multicam.
-    const dual = dualWide();
-    const wide = standaloneWide();
-    const sel = selectCaptureDevice([wide, dual]);
-    expect(sel.mode).toBe('multicam');
-    expect(sel.device).toBe(dual);
-    expect(sel.has0_5x).toBe(true);
-  });
-
-  it('EDGE: ultra-wide ONLY as a standalone device (Android) → standalone-uw (no regression)', () => {
-    // No multicam grouping at all.  Must still expose 0.5× via the
-    // standalone ultra-wide, mounting the wide-angle as primary.
-    const wide = standaloneWide();
-    const uw = standaloneUltraWide();
-    const sel = selectCaptureDevice([wide, uw]);
-    expect(sel.mode).toBe('standalone-uw');
-    expect(sel.device).toBe(wide); // primary = torch-bearing wide
-    expect(sel.ultraWideDevice).toBe(uw);
-    expect(sel.has0_5x).toBe(true);
-    expect(sel.hasTorch).toBe(true); // the 1× mount has a torch
-  });
-
-  it('EDGE: ultra-wide present BOTH standalone AND in multicam → prefer multicam', () => {
-    const dual = dualWide();
-    const wide = standaloneWide();
-    const uw = standaloneUltraWide();
-    const sel = selectCaptureDevice([uw, wide, dual]);
-    expect(sel.mode).toBe('multicam');
-    expect(sel.device).toBe(dual);
-  });
-
-  it('wide-angle ONLY (no ultra-wide anywhere) → wide-only, no 0.5×', () => {
-    const wide = standaloneWide();
-    const sel = selectCaptureDevice([wide]);
-    expect(sel.mode).toBe('wide-only');
-    expect(sel.device).toBe(wide);
-    expect(sel.has0_5x).toBe(false);
-    expect(sel.ultraWideDevice).toBeNull();
-  });
-
-  it('prefers a TORCH-bearing multicam device over a torchless one', () => {
-    const noTorch = dualWide({ hasTorch: false });
-    const withTorch = tripleCam({ hasTorch: true });
-    const sel = selectCaptureDevice([noTorch, withTorch]);
-    expect(sel.mode).toBe('multicam');
-    expect(sel.device).toBe(withTorch);
-    expect(sel.hasTorch).toBe(true);
-  });
-
-  it('ignores front-facing devices', () => {
-    const front = dev({ position: 'front', physicalDevices: ['ultra-wide-angle-camera', 'wide-angle-camera'], isMultiCam: true });
-    const backWide = standaloneWide();
-    const sel = selectCaptureDevice([front, backWide]);
-    expect(sel.mode).toBe('wide-only'); // front multicam doesn't count
-    expect(sel.device).toBe(backWide);
-  });
-
-  it('empty device list → null device, wide-only, no 0.5×', () => {
-    const sel = selectCaptureDevice([]);
-    expect(sel.device).toBeNull();
-    expect(sel.mode).toBe('wide-only');
-    expect(sel.has0_5x).toBe(false);
-    expect(sel.hasTorch).toBe(false);
-  });
-
-  it('standalone-uw: primary prefers a torch-bearing wide when multiple wides exist', () => {
-    const wideNoTorch = standaloneWide({ hasTorch: false });
-    const wideTorch = standaloneWide({ hasTorch: true });
-    const uw = standaloneUltraWide();
-    const sel = selectCaptureDevice([wideNoTorch, uw, wideTorch]);
-    expect(sel.mode).toBe('standalone-uw');
-    expect(sel.device).toBe(wideTorch);
-    expect(sel.hasTorch).toBe(true);
-  });
-
-  it('S24: multicam LISTS ultra-wide but zoom cannot reach it (minZoom~1) + standalone uw swaps', () => {
-    // Samsung/Camera2: the logical device lists the ultra-wide but its zoom
-    // range starts at 1.0, so zoom cannot reach it.  A separate ultra-wide id
-    // exists -> keep the multicam for 1x (torch) and swap to the standalone
-    // ultra-wide on 0.5x.
-    const multicamNoReach = dualWide({ minZoom: 1, hasTorch: true });
-    const uw = standaloneUltraWide();
-    const sel = selectCaptureDevice([multicamNoReach, uw]);
-    expect(sel.mode).toBe('standalone-uw');
-    expect(sel.device).toBe(multicamNoReach); // 1x primary keeps the torch
-    expect(sel.ultraWideDevice).toBe(uw); // 0.5x swaps to the real ultra-wide
-    expect(sel.has0_5x).toBe(true);
-    expect(sel.hasTorch).toBe(true);
-  });
-
-  it('multicam lists ultra-wide, zoom cannot reach (minZoom~1), NO standalone uw -> hide', () => {
-    // The ultra-wide exists ONLY inside a non-zoomable logical device with no
-    // separate id to swap to -> undeliverable -> hide the chooser.
-    const multicamNoReach = dualWide({ minZoom: 1 });
-    const sel = selectCaptureDevice([multicamNoReach]);
-    expect(sel.mode).toBe('wide-only');
-    expect(sel.has0_5x).toBe(false);
-    expect(sel.ultraWideDevice).toBeNull();
-  });
-
-  it('minZoom threshold: <=0.7 zoom-switches, >0.7 falls through to swap', () => {
-    const atThreshold = dualWide({ minZoom: 0.7 });
-    expect(selectCaptureDevice([atThreshold]).mode).toBe('multicam');
-    const aboveThreshold = dualWide({ minZoom: 0.71 });
-    const uw = standaloneUltraWide();
-    expect(selectCaptureDevice([aboveThreshold, uw]).mode).toBe('standalone-uw');
-  });
-});
-
-describe('zoomForLens (multicam lens→zoom mapping)', () => {
-  const d = { minZoom: 0.5, neutralZoom: 1 };
-
-  it('maps 0.5× to the device minZoom (ultra-wide end)', () => {
-    expect(zoomForLens(d, '0.5x')).toBe(0.5);
-  });
-
-  it('maps 1× to the device neutralZoom (wide-angle baseline)', () => {
-    expect(zoomForLens(d, '1x')).toBe(1);
-  });
-
-  it('handles a device whose neutralZoom differs from 1', () => {
-    expect(zoomForLens({ minZoom: 0.6, neutralZoom: 2 }, '1x')).toBe(2);
-    expect(zoomForLens({ minZoom: 0.6, neutralZoom: 2 }, '0.5x')).toBe(0.6);
-  });
-});

package/src/camera/__tests__/useContentRotation.test.ts

@@ -1,89 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Unit tests for `contentRotationDeg` — the pure rotation computation
- * behind `useContentRotation`, which keeps control content (AR toggle,
- * lens/zoom pill, flash, thumbnails) upright relative to gravity
- * regardless of host portrait-lock state.
- *
- * Covers the full truth table from the hook's docstring plus the
- * mid-rotation transients (jsLandscape=true with a non-landscape device
- * reading, which can briefly happen while the OS catches up).
- *
- * Pure-TS test per jest.config.js.  `useContentRotation` transitively
- * imports `useDeviceOrientation` → `react-native-sensors` (an ES module
- * the no-RN-preset jest infra can't parse), so stub it before importing
- * the SUT.  We only call the pure `contentRotationDeg` export.
- */
-
-jest.mock('react-native-sensors', () => ({
-  accelerometer: { subscribe: jest.fn(() => ({ unsubscribe: jest.fn() })) },
-  gyroscope: { subscribe: jest.fn(() => ({ unsubscribe: jest.fn() })) },
-  setUpdateIntervalForType: jest.fn(),
-  SensorTypes: { accelerometer: 'accelerometer', gyroscope: 'gyroscope' },
-}));
-
-import { contentRotationDeg } from '../useContentRotation';
-
-describe('contentRotationDeg', () => {
-  // Locked-portrait host: jsLandscape is ALWAYS false (window dims stay
-  // portrait regardless of device tilt).  The OS doesn't rotate the
-  // framebuffer, so content rotation must match device-physical for
-  // labels to read upright.  THIS is the case task #5b targets.
-
-  it('locked-portrait + device-portrait → 0° (no-op)', () => {
-    expect(contentRotationDeg(false, 'portrait')).toBe(0);
-  });
-
-  it('locked-portrait + device-landscape-left → 90° (CW)', () => {
-    expect(contentRotationDeg(false, 'landscape-left')).toBe(90);
-  });
-
-  it('locked-portrait + device-landscape-right → -90° (CCW)', () => {
-    expect(contentRotationDeg(false, 'landscape-right')).toBe(-90);
-  });
-
-  it('locked-portrait + device-upside-down → 180°', () => {
-    expect(contentRotationDeg(false, 'portrait-upside-down')).toBe(180);
-  });
-
-  // Non-locked host + device-landscape: OS rotated the framebuffer for
-  // us; we must NOT double-rotate.  Net rotation must be 0.
-
-  it('non-locked + device-landscape-left (jsLandscape=true) → 0°', () => {
-    expect(contentRotationDeg(true, 'landscape-left')).toBe(0);
-  });
-
-  it('non-locked + device-landscape-right (jsLandscape=true) → 0°', () => {
-    expect(contentRotationDeg(true, 'landscape-right')).toBe(0);
-  });
-
-  it('non-locked + device-portrait (jsLandscape=false) → 0°', () => {
-    expect(contentRotationDeg(false, 'portrait')).toBe(0);
-  });
-
-  // Mid-rotation transients: jsLandscape=true with a non-landscape
-  // device reading.  Falls through to 0 framebuffer rotation and
-  // applies device rotation directly; settles once the transient clears.
-
-  it('jsLandscape=true mid-rotation with device-portrait → 0°', () => {
-    expect(contentRotationDeg(true, 'portrait')).toBe(0);
-  });
-
-  it('jsLandscape=true mid-rotation with device-upside-down → 180°', () => {
-    expect(contentRotationDeg(true, 'portrait-upside-down')).toBe(180);
-  });
-
-  it('all returned values are in {0, 90, -90, 180} (no off-by-360°)', () => {
-    const orientations = [
-      'portrait',
-      'portrait-upside-down',
-      'landscape-left',
-      'landscape-right',
-    ] as const;
-    for (const o of orientations) {
-      for (const jsl of [true, false]) {
-        expect([0, 90, -90, 180]).toContain(contentRotationDeg(jsl, o));
-      }
-    }
-  });
-});

package/src/camera/__tests__/useOrientationDrift.test.ts

@@ -1,169 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/**
- * Unit tests for `useOrientationDrift` — exercises the pure
- * state-transition function `_computeDriftStateForTests` directly.
- *
- * Why not test the hook end-to-end via render: the lib's jest
- * config is `preset: 'ts-jest'` + `testEnvironment: 'node'` — no
- * React Native preset, no `@testing-library/react-native`.  See the
- * jest.config.js header comment: "If we ever add component-render
- * tests we'd flip to the RN preset then."  The component-render
- * tests for `<OrientationDriftModal>`, `<PanoramaBandOverlay>`,
- * `<ViewportCropOverlay>`, and `<Camera>` composition (all called
- * out in the v0.12 plan) will all need that flip.  Setting it up
- * is grouped in Phase 5 of the plan (Tests) rather than scattered
- * across each PR.  For PR-1, the pure state-transition function
- * carries the full behavioural contract — same approach
- * `useThrottledFrameProcessor.test.ts` uses for its throttle gate.
- *
- * The 5 cases below cover the full state machine per the plan
- * (lines 119, 277):
- *
- *   (a) no change → not drifted
- *   (b) orientation changes during active=true → drifted
- *   (c) drift state survives further changes (latching)
- *   (d) inactive → captureOrientation undefined
- *   (e) active resets snapshot (false → true → false → true cycle)
- */
-
-// Mock `react-native-sensors` BEFORE importing the SUT.  The hook
-// itself transitively pulls in `useDeviceOrientation` which imports
-// `accelerometer` from `react-native-sensors` — an ES module that
-// jest can't parse without the RN preset (which jest.config.js
-// intentionally avoids; see config header comment).  We're only
-// testing the pure transition function below, but TS imports are
-// transitive so we still need to silence the chain.
-jest.mock('react-native-sensors', () => ({
-  accelerometer: { subscribe: jest.fn(() => ({ unsubscribe: jest.fn() })) },
-  setUpdateIntervalForType: jest.fn(),
-  SensorTypes: { accelerometer: 'accelerometer' },
-}));
-
-// eslint-disable-next-line import/first
-import { _computeDriftStateForTests } from '../useOrientationDrift';
-
-const INITIAL = { captureOrientation: undefined, drifted: false };
-
-describe('_computeDriftStateForTests (useOrientationDrift core logic)', () => {
-  describe('(a) no change → not drifted', () => {
-    it('stays in initial state when active is false from the start', () => {
-      const next = _computeDriftStateForTests(INITIAL, false, 'portrait');
-      expect(next).toEqual({ captureOrientation: undefined, drifted: false });
-    });
-
-    it('snapshots orientation when active flips true, drifted starts false', () => {
-      const next = _computeDriftStateForTests(INITIAL, true, 'portrait');
-      expect(next).toEqual({ captureOrientation: 'portrait', drifted: false });
-    });
-
-    it('stays clean when active=true and orientation does not change', () => {
-      const after1 = _computeDriftStateForTests(INITIAL, true, 'portrait');
-      const after2 = _computeDriftStateForTests(after1, true, 'portrait');
-      const after3 = _computeDriftStateForTests(after2, true, 'portrait');
-      expect(after3).toEqual({ captureOrientation: 'portrait', drifted: false });
-      // Reference equality: once steady, returns the prev ref so
-      // React's setState becomes a no-op (no re-render).
-      expect(after2).toBe(after1);
-      expect(after3).toBe(after2);
-    });
-  });
-
-  describe('(b) orientation changes during active=true → drifted', () => {
-    it('latches drifted=true when orientation changes mid-active', () => {
-      const after1 = _computeDriftStateForTests(INITIAL, true, 'portrait');
-      const after2 = _computeDriftStateForTests(after1, true, 'landscape-left');
-      expect(after2).toEqual({ captureOrientation: 'portrait', drifted: true });
-    });
-
-    it('captures the ORIGINAL orientation in captureOrientation, not the new one', () => {
-      const after1 = _computeDriftStateForTests(INITIAL, true, 'portrait');
-      const after2 = _computeDriftStateForTests(after1, true, 'landscape-right');
-      // captureOrientation MUST remain the snapshot (portrait), not
-      // the current rotation — that's how the drift modal copy
-      // ("captured in PORTRAIT, now LANDSCAPE-RIGHT") works.
-      expect(after2.captureOrientation).toBe('portrait');
-    });
-
-    it('detects drift to any of the 3 other orientations', () => {
-      const cases: Array<['portrait', 'portrait-upside-down' | 'landscape-left' | 'landscape-right']> = [
-        ['portrait', 'portrait-upside-down'],
-        ['portrait', 'landscape-left'],
-        ['portrait', 'landscape-right'],
-      ];
-      for (const [captured, drifted] of cases) {
-        const after1 = _computeDriftStateForTests(INITIAL, true, captured);
-        const after2 = _computeDriftStateForTests(after1, true, drifted);
-        expect(after2.drifted).toBe(true);
-      }
-    });
-  });
-
-  describe('(c) drift state survives further changes (latching)', () => {
-    it('stays drifted even if the user rotates back to the captured orientation', () => {
-      // User rotates portrait → landscape (drift triggers) → portrait
-      // (back to original).  The flag MUST stay latched.  Rationale:
-      // the engine docstring says cross-mode capture is "best-effort,
-      // not supported" — a brief rotation pollutes the buffer even
-      // if the user rotates back, so the safe action is decisive
-      // abandonment regardless of post-detection orientation.
-      const after1 = _computeDriftStateForTests(INITIAL, true, 'portrait');
-      const after2 = _computeDriftStateForTests(after1, true, 'landscape-left');
-      const after3 = _computeDriftStateForTests(after2, true, 'portrait');
-      expect(after3).toEqual({ captureOrientation: 'portrait', drifted: true });
-    });
-
-    it('stays drifted across multiple subsequent orientation changes', () => {
-      const after1 = _computeDriftStateForTests(INITIAL, true, 'portrait');
-      const after2 = _computeDriftStateForTests(after1, true, 'landscape-left');
-      const after3 = _computeDriftStateForTests(after2, true, 'landscape-right');
-      const after4 = _computeDriftStateForTests(after3, true, 'portrait-upside-down');
-      expect(after4.drifted).toBe(true);
-      expect(after4.captureOrientation).toBe('portrait');
-    });
-  });
-
-  describe('(d) inactive → captureOrientation undefined', () => {
-    it('clears the snapshot when active flips back to false', () => {
-      const after1 = _computeDriftStateForTests(INITIAL, true, 'portrait');
-      const after2 = _computeDriftStateForTests(after1, false, 'portrait');
-      expect(after2).toEqual({ captureOrientation: undefined, drifted: false });
-    });
-
-    it('clears the drift flag when active flips back to false', () => {
-      const after1 = _computeDriftStateForTests(INITIAL, true, 'portrait');
-      const after2 = _computeDriftStateForTests(after1, true, 'landscape-left');
-      expect(after2.drifted).toBe(true);
-      const after3 = _computeDriftStateForTests(after2, false, 'landscape-left');
-      expect(after3).toEqual({ captureOrientation: undefined, drifted: false });
-    });
-
-    it('is idempotent — no state change when inactive and already clear', () => {
-      const after1 = _computeDriftStateForTests(INITIAL, false, 'portrait');
-      const after2 = _computeDriftStateForTests(after1, false, 'landscape-left');
-      // Same ref → setState becomes a no-op.
-      expect(after2).toBe(after1);
-    });
-  });
-
-  describe('(e) active resets snapshot', () => {
-    it('re-snapshots on a fresh active cycle (false → true → false → true)', () => {
-      // Cycle 1: capture in portrait, drift.
-      const c1a = _computeDriftStateForTests(INITIAL, true, 'portrait');
-      const c1b = _computeDriftStateForTests(c1a, true, 'landscape-left');
-      expect(c1b).toEqual({ captureOrientation: 'portrait', drifted: true });
-
-      // Stop the capture.
-      const cleared = _computeDriftStateForTests(c1b, false, 'landscape-left');
-      expect(cleared).toEqual({ captureOrientation: undefined, drifted: false });
-
-      // Cycle 2: re-capture, now in landscape-left.  Snapshot
-      // should be landscape-left, NOT carry over the old portrait.
-      const c2a = _computeDriftStateForTests(cleared, true, 'landscape-left');
-      expect(c2a).toEqual({ captureOrientation: 'landscape-left', drifted: false });
-
-      // And staying in landscape-left should not drift.
-      const c2b = _computeDriftStateForTests(c2a, true, 'landscape-left');
-      expect(c2b.drifted).toBe(false);
-    });
-  });
-});