@react-native-harness/platform-android 1.2.0-rc.1 → 1.3.0

package/dist/__tests__/adb-id.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=adb-id.test.d.ts.map

package/dist/__tests__/adb-id.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adb-id.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/adb-id.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/adb-id.test.js

@@ -0,0 +1,41 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getAdbId, isAdbIdEmulator } from '../adb-id.js';
+import * as adb from '../adb.js';
+describe('adb id resolution', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('identifies emulator adb ids', () => {
+        expect(isAdbIdEmulator('emulator-5554')).toBe(true);
+        expect(isAdbIdEmulator('device-serial-001')).toBe(false);
+    });
+    it('skips non-emulator ids when resolving an emulator device', async () => {
+        vi.spyOn(adb, 'getDeviceIds').mockResolvedValue([
+            'device-serial-001',
+            'emulator-5554',
+        ]);
+        vi.spyOn(adb, 'getEmulatorName').mockResolvedValue('Test_AVD_API_35');
+        await expect(getAdbId({
+            type: 'emulator',
+            name: 'Test_AVD_API_35',
+        })).resolves.toBe('emulator-5554');
+    });
+    it('resolves matching physical device by manufacturer and model', async () => {
+        vi.spyOn(adb, 'getDeviceIds').mockResolvedValue([
+            'device-serial-001',
+            'emulator-5554',
+        ]);
+        vi.spyOn(adb, 'getDeviceInfo').mockImplementation(async (adbId) => {
+            const results = {
+                'device-serial-001': { manufacturer: 'Acme', model: 'Model A1' },
+                'emulator-5554': { manufacturer: 'Emulator', model: 'Emulator Model' },
+            };
+            return results[adbId] || null;
+        });
+        await expect(getAdbId({
+            type: 'physical',
+            manufacturer: 'acme',
+            model: 'model a1',
+        })).resolves.toBe('device-serial-001');
+    });
+});

package/dist/__tests__/adb.test.js

@@ -1,12 +1,17 @@
 import { EventEmitter } from 'node:events';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 import { PassThrough } from 'node:stream';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { SubprocessError } from '@react-native-harness/tools';
-import { createAvd, deleteAvd, emulatorProcess, getAppUid, getLogcatTimestamp, getStartAppArgs, hasAvd, installApp, startEmulator, uninstallApp, waitForBoot, waitForEmulatorDisconnect, } from '../adb.js';
+vi.unmock('../adb.js');
+import { createAvd, deleteAvd, emulatorProcess, getAppUid, getLogcatTimestamp, getStartAppArgs, hasAvd, installApp, startLogcat, startEmulator, uninstallApp, waitForBoot, waitForEmulatorDisconnect, } from '../adb.js';
 import * as tools from '@react-native-harness/tools';
 import * as environment from '../environment.js';
 import * as avdConfig from '../avd-config.js';
 const createAbortError = () => new DOMException('The operation was aborted', 'AbortError');
+let sdkRoot;
 const createMockChildProcess = () => {
     const process = new EventEmitter();
     process.stdout = new PassThrough();
@@ -16,6 +21,14 @@ const createMockChildProcess = () => {
 };
 beforeEach(() => {
     vi.restoreAllMocks();
+    vi.unstubAllEnvs();
+    sdkRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'android-sdk-'));
+    fs.mkdirSync(path.join(sdkRoot, 'emulator'), { recursive: true });
+    fs.writeFileSync(path.join(sdkRoot, 'emulator', 'emulator'), '');
+    fs.mkdirSync(path.join(sdkRoot, 'platform-tools'), { recursive: true });
+    fs.writeFileSync(path.join(sdkRoot, 'platform-tools', 'adb'), '');
+    vi.stubEnv('ANDROID_HOME', sdkRoot);
+    vi.spyOn(environment, 'ensureAndroidEmulatorAvailable').mockResolvedValue(sdkRoot);
 });
 describe('getStartAppArgs', () => {
     it('maps supported extras to adb am start flags', () => {
@@ -81,8 +94,31 @@ describe('getStartAppArgs', () => {
             "+'%m-%d %H:%M:%S.000'",
         ]);
     });
+    it('starts logcat using the resolved adb binary path', async () => {
+        const subprocess = {};
+        const spawnSpy = vi.spyOn(tools, 'spawn').mockReturnValue(subprocess);
+        expect(startLogcat('emulator-5554', [
+            'logcat',
+            '-v',
+            'threadtime',
+            '-b',
+            'crash',
+        ])).toBe(subprocess);
+        expect(spawnSpy).toHaveBeenCalledWith(expect.stringMatching(/adb$/), [
+            '-s',
+            'emulator-5554',
+            'logcat',
+            '-v',
+            'threadtime',
+            '-b',
+            'crash',
+        ], {
+            stdout: 'pipe',
+            stderr: 'pipe',
+        });
+    });
     it('checks whether an AVD exists', async () => {
-        vi.spyOn(tools, 'spawn').mockResolvedValueOnce({
+        vi.spyOn(tools, 'spawn').mockResolvedValue({
             stdout: 'Pixel_6_API_33\nPixel_8_API_35\n',
         });
         await expect(hasAvd('Pixel_8_API_35')).resolves.toBe(true);
@@ -365,17 +401,24 @@ describe('getStartAppArgs', () => {
     });
     it('aborts while waiting for boot completion', async () => {
         vi.useFakeTimers();
-        const spawnSpy = vi.spyOn(tools, 'spawn');
-        spawnSpy
-            .mockResolvedValueOnce({
-            stdout: 'List of devices attached\nemulator-5554\tdevice\n',
-        })
-            .mockResolvedValueOnce({
-            stdout: 'Pixel_8_API_35\n',
-        })
-            .mockResolvedValueOnce({
-            stdout: '0\n',
-        });
+        vi.spyOn(tools, 'spawn').mockImplementation((async (_file, args) => {
+            if (args?.[0] === 'devices') {
+                return {
+                    stdout: 'List of devices attached\nemulator-5554\tdevice\n',
+                };
+            }
+            if (args?.includes('emu') && args?.includes('avd') && args?.includes('name')) {
+                return {
+                    stdout: 'Pixel_8_API_35\n',
+                };
+            }
+            if (args?.includes('getprop')) {
+                return {
+                    stdout: '0\n',
+                };
+            }
+            throw new Error(`Unexpected adb call: ${args?.join(' ')}`);
+        }));
         const controller = new AbortController();
         const waitPromise = waitForBoot('Pixel_8_API_35', controller.signal);
         await vi.advanceTimersByTimeAsync(1000);

package/dist/__tests__/app-monitor.test.js

@@ -1,17 +1,7 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import fs from 'node:fs';
-import path from 'node:path';
-import { tmpdir } from 'node:os';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { NativeCrashError } from '@react-native-harness/platforms';
 import { createAndroidAppMonitor, createAndroidLogEvent } from '../app-monitor.js';
-import * as tools from '@react-native-harness/tools';
-import { createCrashArtifactWriter } from '@react-native-harness/tools';
-const createMockSubprocess = () => ({
-    nodeChildProcess: Promise.resolve({
-        kill: vi.fn(),
-    }),
-    // eslint-disable-next-line @typescript-eslint/no-empty-function
-    [Symbol.asyncIterator]: async function* () { },
-});
+import * as adb from '../adb.js';
 const createStreamingSubprocess = (chunks) => ({
     nodeChildProcess: Promise.resolve({
         kill: vi.fn(),
@@ -25,178 +15,243 @@ const createStreamingSubprocess = (chunks) => ({
         }
     },
 });
-const artifactRoot = fs.mkdtempSync(path.join(tmpdir(), 'rn-harness-android-monitor-artifacts-'));
-afterEach(() => {
-    fs.rmSync(artifactRoot, { recursive: true, force: true });
-    fs.mkdirSync(artifactRoot, { recursive: true });
-});
 describe('createAndroidLogEvent', () => {
-    it('extracts crash details from fatal signal log lines', () => {
-        const event = createAndroidLogEvent('03-12 11:35:08.000  1234  1234 F libc    : Fatal signal 11 (SIGSEGV), code 1 (SEGV_MAPERR) in tid 1234 (com.harnessplayground), pid 1234 (com.harnessplayground)', 'com.harnessplayground');
+    it('detects confirmation-grade am_crash events', () => {
+        const event = createAndroidLogEvent('05-20 12:00:00.200  1000  1000 I am_crash: [0,1234,com.harnessplayground,123,java.lang.IllegalStateException,boom]', 'com.harnessplayground');
         expect(event).toMatchObject({
-            type: 'possible_crash',
-            source: 'logs',
+            type: 'crash_confirmed',
             crashDetails: {
+                platform: 'android',
+                kind: 'java-exception',
+                confidence: 'high',
                 source: 'logs',
-                signal: 'SIGSEGV',
-                summary: '03-12 11:35:08.000  1234  1234 F libc    : Fatal signal 11 (SIGSEGV), code 1 (SEGV_MAPERR) in tid 1234 (com.harnessplayground), pid 1234 (com.harnessplayground)',
             },
         });
     });
-    it('extracts process and pid when AndroidRuntime reports a crash', () => {
-        const event = createAndroidLogEvent('03-12 11:35:09.000  1234  1234 E AndroidRuntime: Process: com.harnessplayground, PID: 1234', 'com.harnessplayground');
-        expect(event).toMatchObject({
-            type: 'possible_crash',
-            pid: 1234,
-            crashDetails: {
-                processName: 'com.harnessplayground',
-                pid: 1234,
-            },
-        });
+});
+describe('createAndroidAppMonitor', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        vi.useFakeTimers();
+        vi.spyOn(adb, 'getLogcatTimestamp').mockResolvedValue('05-20 12:00:00.000');
     });
-    it('starts logcat from the current device timestamp', async () => {
-        const spawnSpy = vi.spyOn(tools, 'spawn');
-        spawnSpy.mockImplementation(((file, args) => {
-            if (file === 'adb' && args?.includes('date')) {
-                return {
-                    stdout: '03-12 11:35:08.000\n',
-                };
-            }
-            return createMockSubprocess();
-        }));
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('starts logcat with crash, main, system, and events buffers', async () => {
+        const startLogcat = vi
+            .spyOn(adb, 'startLogcat')
+            .mockReturnValue(createStreamingSubprocess([]));
         const monitor = createAndroidAppMonitor({
             adbId: 'emulator-5554',
             bundleId: 'com.harnessplayground',
             appUid: 10234,
+            isAppRunning: async () => true,
         });
         await monitor.start();
         await monitor.stop();
-        expect(spawnSpy).toHaveBeenNthCalledWith(2, 'adb', [
-            '-s',
-            'emulator-5554',
+        expect(startLogcat).toHaveBeenCalledWith('emulator-5554', [
             'logcat',
-            '-v',
-            'threadtime',
             '-b',
             'crash',
-            '--uid=10234',
+            '-b',
+            'main',
+            '-b',
+            'system',
+            '-b',
+            'events',
+            '-v',
+            'threadtime',
             '-T',
-            '03-12 11:35:08.000',
-        ], {
-            stdout: 'pipe',
-            stderr: 'pipe',
-        });
+            '05-20 12:00:00.000',
+        ]);
     });
-    it('hydrates crash details with stack lines that arrive after the first crash event', async () => {
-        const spawnSpy = vi.spyOn(tools, 'spawn');
-        spawnSpy.mockImplementation(((file, args) => {
-            if (file === 'adb' && args?.includes('date')) {
-                return {
-                    stdout: '03-12 10:44:40.000\n',
-                };
-            }
-            return createStreamingSubprocess([
-                { line: '--------- beginning of crash' },
-                {
-                    line: '03-12 10:44:40.420 13861 13861 E AndroidRuntime: Process: com.harnessplayground, PID: 13861',
-                },
-                {
-                    line: '03-12 10:44:40.421 13861 13861 E AndroidRuntime: java.lang.RuntimeException: boom',
-                    delayMs: 25,
-                },
-                {
-                    line: '03-12 10:44:40.422 13861 13861 E AndroidRuntime:     at com.harnessplayground.MainActivity.onCreate(MainActivity.kt:42)',
-                    delayMs: 25,
-                },
-            ]);
+    it('reports app lifecycle and crash events through the reporter', async () => {
+        vi.spyOn(adb, 'startLogcat').mockReturnValue(createStreamingSubprocess([
+            {
+                line: '05-20 12:00:00.000  1234  1234 I ActivityManager: Start proc 1234:com.harnessplayground/u0a123 for activity',
+            },
+            {
+                line: '05-20 12:00:00.100  1234  1234 E AndroidRuntime: Process: com.harnessplayground, PID: 1234',
+            },
+            {
+                line: '05-20 12:00:00.200  1000  1000 I am_crash: [0,1234,com.harnessplayground,123,java.lang.IllegalStateException,boom]',
+            },
+        ]));
+        const eventReporter = vi.fn();
+        const monitor = createAndroidAppMonitor({
+            adbId: 'emulator-5554',
+            bundleId: 'com.harnessplayground',
+            appUid: 10234,
+            isAppRunning: async () => true,
+            eventReporter,
+        });
+        const crashWatch = monitor.watch('example.test.ts', 'startup');
+        crashWatch.promise.catch(() => undefined);
+        monitor.launchRequested({
+            type: 'launch_requested',
+            launchId: 'launch-1',
+            at: Date.now(),
+            reason: 'start',
+        });
+        await monitor.start();
+        await vi.advanceTimersByTimeAsync(100);
+        expect(eventReporter).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'app:started',
+            appPlatform: 'android',
+            targetIdentifier: 'emulator-5554',
+            launchId: 'launch-1',
+        }));
+        expect(eventReporter).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'app:crash-suspected',
+            appPlatform: 'android',
+            processName: 'com.harnessplayground',
         }));
+        expect(eventReporter).toHaveBeenCalledWith(expect.objectContaining({
+            type: 'app:crash-confirmed',
+            appPlatform: 'android',
+            processName: 'com.harnessplayground',
+        }));
+        await monitor.stop();
+    });
+    it('rejects the watch for Java crashes when am_crash arrives even if the process still looks alive', async () => {
+        vi.spyOn(adb, 'startLogcat').mockReturnValue(createStreamingSubprocess([
+            {
+                line: '05-20 12:00:00.000  1234  1234 I ActivityManager: Start proc 1234:com.harnessplayground/u0a123 for activity',
+            },
+            {
+                line: '05-20 12:00:00.100  1234  1234 E AndroidRuntime: FATAL EXCEPTION: main',
+            },
+            {
+                line: '05-20 12:00:00.101  1234  1234 E AndroidRuntime: Process: com.harnessplayground, PID: 1234',
+            },
+            {
+                line: '05-20 12:00:00.102  1234  1234 E AndroidRuntime: java.lang.IllegalStateException: Intentional pre-RN startup crash',
+            },
+            {
+                line: '05-20 12:00:00.103  1234  1234 E AndroidRuntime:     at com.harnessplayground.MainActivity.onCreate(MainActivity.kt:42)',
+            },
+            {
+                line: '05-20 12:00:00.200  1000  1000 I am_crash: [0,1234,com.harnessplayground,123,java.lang.IllegalStateException,Intentional pre-RN startup crash]',
+            },
+        ]));
         const monitor = createAndroidAppMonitor({
             adbId: 'emulator-5554',
             bundleId: 'com.harnessplayground',
             appUid: 10234,
+            isAppRunning: async () => true,
         });
+        const crashWatch = monitor.watch('example.test.ts', 'startup');
+        crashWatch.promise.catch(() => undefined);
         await monitor.start();
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        const details = await monitor.getCrashDetails({
-            pid: 13861,
-            occurredAt: Date.now(),
+        await vi.advanceTimersByTimeAsync(100);
+        await expect(crashWatch.promise).rejects.toMatchObject({
+            testFilePath: 'example.test.ts',
+            details: {
+                phase: 'startup',
+                platform: 'android',
+                kind: 'java-exception',
+                confidence: 'high',
+                processName: 'com.harnessplayground',
+                pid: 1234,
+                exceptionType: 'java.lang.IllegalStateException: Intentional pre-RN startup crash',
+            },
         });
+        await expect(crashWatch.promise).rejects.toBeInstanceOf(NativeCrashError);
         await monitor.stop();
-        expect(details?.rawLines).toEqual([
-            '--------- beginning of crash',
-            '03-12 10:44:40.420 13861 13861 E AndroidRuntime: Process: com.harnessplayground, PID: 13861',
-            '03-12 10:44:40.421 13861 13861 E AndroidRuntime: java.lang.RuntimeException: boom',
-            '03-12 10:44:40.422 13861 13861 E AndroidRuntime:     at com.harnessplayground.MainActivity.onCreate(MainActivity.kt:42)',
-        ]);
     });
-    it('persists resolved Android crash blocks into .harness', async () => {
-        const spawnSpy = vi.spyOn(tools, 'spawn');
-        spawnSpy.mockImplementation(((file, args) => {
-            if (file === 'adb' && args?.includes('date')) {
-                return {
-                    stdout: '03-12 10:44:40.000\n',
-                };
-            }
-            return createStreamingSubprocess([
-                { line: '--------- beginning of crash' },
-                {
-                    line: '03-12 10:44:40.420 13861 13861 E AndroidRuntime: Process: com.harnessplayground, PID: 13861',
-                },
-                {
-                    line: '03-12 10:44:40.421 13861 13861 E AndroidRuntime: java.lang.RuntimeException: boom',
-                    delayMs: 20,
-                },
-            ]);
-        }));
+    it('rejects the watch when a suspected crash is followed by process exit', async () => {
+        vi.spyOn(adb, 'startLogcat').mockReturnValue(createStreamingSubprocess([
+            {
+                line: '05-20 12:00:00.101  1234  1234 E AndroidRuntime: Process: com.harnessplayground, PID: 1234',
+            },
+            {
+                line: '05-20 12:00:00.102  1234  1234 E AndroidRuntime: java.lang.IllegalStateException: Intentional delayed startup crash',
+            },
+        ]));
+        const isAppRunning = vi
+            .fn()
+            .mockResolvedValueOnce(true)
+            .mockResolvedValueOnce(false)
+            .mockResolvedValue(false);
         const monitor = createAndroidAppMonitor({
             adbId: 'emulator-5554',
             bundleId: 'com.harnessplayground',
             appUid: 10234,
-            crashArtifactWriter: createCrashArtifactWriter({
-                runnerName: 'android',
-                platformId: 'android',
-                rootDir: path.join(artifactRoot, '.harness', 'crash-reports'),
-                runTimestamp: '2026-03-12T11-35-08-000Z',
-            }),
+            isAppRunning,
         });
+        const crashWatch = monitor.watch('example.test.ts', 'execution');
+        crashWatch.promise.catch(() => undefined);
         await monitor.start();
-        await new Promise((resolve) => setTimeout(resolve, 10));
-        const details = await monitor.getCrashDetails({
-            pid: 13861,
-            occurredAt: Date.now(),
+        await vi.advanceTimersByTimeAsync(350);
+        await expect(crashWatch.promise).rejects.toMatchObject({
+            details: {
+                phase: 'execution',
+                platform: 'android',
+                kind: 'java-exception',
+                processName: 'com.harnessplayground',
+                pid: 1234,
+            },
         });
         await monitor.stop();
-        expect(details?.artifactPath).toContain('/.harness/crash-reports/');
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        expect(fs.readFileSync(details.artifactPath, 'utf8')).toContain('RuntimeException: boom');
     });
-    it('can be started again after timestamp lookup fails', async () => {
-        const spawnSpy = vi.spyOn(tools, 'spawn');
-        const timestampError = new Error('date failed');
-        spawnSpy.mockImplementation(((file, args) => {
-            if (file === 'adb' && args?.includes('date')) {
-                if (spawnSpy.mock.calls.filter(([calledFile, calledArgs]) => calledFile === 'adb' &&
-                    Array.isArray(calledArgs) &&
-                    calledArgs.includes('date')).length === 1) {
-                    throw timestampError;
-                }
-                return {
-                    stdout: '03-12 11:35:08.000\n',
-                };
-            }
-            return createMockSubprocess();
-        }));
+    it('does not reject the watch when the process exits without a recent crash signal', async () => {
+        vi.spyOn(adb, 'startLogcat').mockReturnValue(createStreamingSubprocess([]));
+        const isAppRunning = vi
+            .fn()
+            .mockResolvedValueOnce(true)
+            .mockResolvedValueOnce(false)
+            .mockResolvedValue(false);
         const monitor = createAndroidAppMonitor({
             adbId: 'emulator-5554',
             bundleId: 'com.harnessplayground',
             appUid: 10234,
+            isAppRunning,
+        });
+        const crashWatch = monitor.watch('example.test.ts', 'execution');
+        let settled = false;
+        const watchHandled = crashWatch.promise.catch(() => {
+            settled = true;
+        });
+        await monitor.start();
+        await vi.advanceTimersByTimeAsync(600);
+        expect(settled).toBe(false);
+        crashWatch.cancel();
+        await monitor.stop();
+        await watchHandled;
+    });
+    it('suppresses process-exit confirmation during a controlled stop window', async () => {
+        vi.spyOn(adb, 'startLogcat').mockReturnValue(createStreamingSubprocess([
+            {
+                line: '05-20 12:00:00.101  1234  1234 E AndroidRuntime: Process: com.harnessplayground, PID: 1234',
+            },
+        ]));
+        const isAppRunning = vi
+            .fn()
+            .mockResolvedValueOnce(true)
+            .mockResolvedValueOnce(false)
+            .mockResolvedValue(false);
+        const monitor = createAndroidAppMonitor({
+            adbId: 'emulator-5554',
+            bundleId: 'com.harnessplayground',
+            appUid: 10234,
+            isAppRunning,
+        });
+        const crashWatch = monitor.watch('example.test.ts', 'execution');
+        let settled = false;
+        const watchHandled = crashWatch.promise.catch(() => {
+            settled = true;
+        });
+        await monitor.start();
+        monitor.stopRequested({
+            type: 'stop_requested',
+            at: Date.now(),
+            reason: 'manual',
         });
-        await expect(monitor.start()).rejects.toThrow(timestampError);
-        await expect(monitor.start()).resolves.toBeUndefined();
+        await vi.advanceTimersByTimeAsync(400);
+        expect(settled).toBe(false);
+        crashWatch.cancel();
         await monitor.stop();
-        expect(spawnSpy.mock.calls.some(([file, args]) => file === 'adb' &&
-            Array.isArray(args) &&
-            args.includes('logcat') &&
-            args.includes('--uid=10234'))).toBe(true);
+        await watchHandled;
     });
 });

package/dist/__tests__/instance.test.js

@@ -1,8 +1,5 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { DEFAULT_METRO_PORT, } from '@react-native-harness/config';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
 import { getAndroidEmulatorPlatformInstance, getAndroidPhysicalDevicePlatformInstance, } from '../instance.js';
 import * as adb from '../adb.js';
 import * as avdConfig from '../avd-config.js';
@@ -19,9 +16,10 @@ const init = {
     signal: new AbortController().signal,
 };
 describe('Android platform instance', () => {
-    beforeEach(() => {
+    beforeEach(async () => {
         vi.restoreAllMocks();
         vi.unstubAllEnvs();
+        vi.spyOn(await import('../environment.js'), 'ensureAndroidEmulatorAvailable').mockResolvedValue('/tmp/android-sdk');
     });
     it('reuses a running emulator and does not shut it down on dispose', async () => {
         const ensureAndroidEmulatorEnvironment = vi
@@ -137,6 +135,7 @@ describe('Android platform instance', () => {
     });
     it('reuses a compatible cached AVD snapshot when caching is enabled', async () => {
         vi.stubEnv('HARNESS_AVD_CACHING', 'true');
+        vi.spyOn(await import('../environment.js'), 'getHostAndroidSystemImageArch').mockReturnValue('arm64-v8a');
         vi.spyOn(await import('../environment.js'), 'ensureAndroidEmulatorEnvironment').mockResolvedValue('/tmp/android-sdk');
         vi.spyOn(adb, 'getDeviceIds').mockResolvedValue([]);
         vi.spyOn(adb, 'hasAvd').mockResolvedValue(true);
@@ -261,74 +260,6 @@ describe('Android platform instance', () => {
         expect(waitForEmulatorDisconnect).toHaveBeenCalledWith('emulator-5554', init.signal);
         expect(startEmulator).toHaveBeenNthCalledWith(2, 'Pixel_8_API_35', 'snapshot-reuse');
     });
-    it('installs the app from HARNESS_APP_PATH when missing', async () => {
-        const appPath = path.join(os.tmpdir(), 'HarnessPlayground.apk');
-        fs.writeFileSync(appPath, 'apk');
-        vi.stubEnv('HARNESS_APP_PATH', appPath);
-        vi.spyOn(await import('../environment.js'), 'ensureAndroidEmulatorEnvironment').mockResolvedValue('/tmp/android-sdk');
-        vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['emulator-5554']);
-        vi.spyOn(adb, 'getEmulatorName').mockResolvedValue('Pixel_8_API_35');
-        vi.spyOn(adb, 'waitForBoot').mockResolvedValue('emulator-5554');
-        vi.spyOn(adb, 'isAppInstalled').mockResolvedValue(false);
-        const installApp = vi.spyOn(adb, 'installApp').mockResolvedValue(undefined);
-        vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
-        vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
-        vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
-        vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(undefined);
-        await expect(getAndroidEmulatorPlatformInstance({
-            name: 'android',
-            device: {
-                type: 'emulator',
-                name: 'Pixel_8_API_35',
-                avd: {
-                    apiLevel: 35,
-                    profile: 'pixel_8',
-                    diskSize: '1G',
-                    heapSize: '1G',
-                },
-            },
-            bundleId: 'com.harnessplayground',
-            activityName: '.MainActivity',
-        }, harnessConfig, init)).resolves.toBeDefined();
-        expect(installApp).toHaveBeenCalledWith('emulator-5554', appPath);
-        fs.rmSync(appPath, { force: true });
-    });
-    it('reinstalls the app from HARNESS_APP_PATH when already installed', async () => {
-        const appPath = path.join(os.tmpdir(), 'HarnessPlayground-installed.apk');
-        fs.writeFileSync(appPath, 'apk');
-        vi.stubEnv('HARNESS_APP_PATH', appPath);
-        vi.spyOn(await import('../environment.js'), 'ensureAndroidEmulatorEnvironment').mockResolvedValue('/tmp/android-sdk');
-        vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['emulator-5554']);
-        vi.spyOn(adb, 'getEmulatorName').mockResolvedValue('Pixel_8_API_35');
-        vi.spyOn(adb, 'waitForBoot').mockResolvedValue('emulator-5554');
-        vi.spyOn(adb, 'isAppInstalled').mockResolvedValue(true);
-        const uninstallApp = vi
-            .spyOn(adb, 'uninstallApp')
-            .mockResolvedValue(undefined);
-        const installApp = vi.spyOn(adb, 'installApp').mockResolvedValue(undefined);
-        vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
-        vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
-        vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
-        vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(undefined);
-        await expect(getAndroidEmulatorPlatformInstance({
-            name: 'android',
-            device: {
-                type: 'emulator',
-                name: 'Pixel_8_API_35',
-                avd: {
-                    apiLevel: 35,
-                    profile: 'pixel_8',
-                    diskSize: '1G',
-                    heapSize: '1G',
-                },
-            },
-            bundleId: 'com.harnessplayground',
-            activityName: '.MainActivity',
-        }, harnessConfig, init)).resolves.toBeDefined();
-        expect(uninstallApp).toHaveBeenCalledWith('emulator-5554', 'com.harnessplayground');
-        expect(installApp).toHaveBeenCalledWith('emulator-5554', appPath);
-        fs.rmSync(appPath, { force: true });
-    });
     it('throws a HarnessAppPathError when HARNESS_APP_PATH is missing', async () => {
         vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['emulator-5554']);
         vi.spyOn(adb, 'getEmulatorName').mockResolvedValue('Pixel_8_API_35');