@react-native-harness/platform-android 1.3.0 → 1.4.0

package/src/__tests__/instance.test.ts

@@ -3,6 +3,7 @@ import {
   DEFAULT_METRO_PORT,
   type Config as HarnessConfig,
 } from '@react-native-harness/config';
+import type { Subprocess } from '@react-native-harness/tools';
 import {
   getAndroidEmulatorPlatformInstance,
   getAndroidPhysicalDevicePlatformInstance,
@@ -11,6 +12,25 @@ import * as adb from '../adb.js';
 import * as avdConfig from '../avd-config.js';
 import * as sharedPrefs from '../shared-prefs.js';
 import { HarnessAppPathError, HarnessEmulatorConfigError } from '../errors.js';
+import * as emulatorStartup from '../emulator-startup.js';
+const { getEmulatorCpuCores } = emulatorStartup;
+
+const createLogcatProcess = (lines: string[] = []): Subprocess => {
+  // Mirrors nano-spawn's real Subprocess, which is both a Promise and an
+  // async iterable, since app-session.ts relies on it being thenable.
+  const process = Object.assign(Promise.resolve(undefined), {
+    nodeChildProcess: Promise.resolve({
+      kill: vi.fn(),
+    }),
+    [Symbol.asyncIterator]: async function* () {
+      for (const line of lines) {
+        yield line;
+      }
+    },
+  });
+
+  return process as unknown as Subprocess;
+};
 
 const harnessConfig = {
   metroPort: DEFAULT_METRO_PORT,
@@ -27,17 +47,22 @@ describe('Android platform instance', () => {
   beforeEach(async () => {
     vi.restoreAllMocks();
     vi.unstubAllEnvs();
+    vi.useRealTimers();
     vi.spyOn(
       await import('../environment.js'),
-      'ensureAndroidEmulatorAvailable',
+      'ensureAndroidEmulatorAvailable'
     ).mockResolvedValue('/tmp/android-sdk');
+    vi.spyOn(
+      emulatorStartup,
+      'warnIfEmulatorAccelerationUnavailable'
+    ).mockResolvedValue(undefined);
   });
 
   it('reuses a running emulator and does not shut it down on dispose', async () => {
     const ensureAndroidEmulatorEnvironment = vi
       .spyOn(
         await import('../environment.js'),
-        'ensureAndroidEmulatorEnvironment',
+        'ensureAndroidEmulatorEnvironment'
       )
       .mockResolvedValue('/tmp/android-sdk');
     vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['emulator-5554']);
@@ -47,11 +72,12 @@ describe('Android platform instance', () => {
     vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
     vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
     vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
+    vi.spyOn(adb, 'getLogcatTimestamp').mockResolvedValue('01-01 00:00:00.000');
     vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(
-      undefined,
+      undefined
     );
     vi.spyOn(sharedPrefs, 'clearHarnessDebugHttpHost').mockResolvedValue(
-      undefined,
+      undefined
     );
     vi.spyOn(adb, 'stopApp').mockResolvedValue(undefined);
     const stopEmulator = vi.spyOn(adb, 'stopEmulator').mockResolvedValue();
@@ -73,7 +99,7 @@ describe('Android platform instance', () => {
         activityName: '.MainActivity',
       },
       harnessConfig,
-      init,
+      init
     );
 
     await instance.dispose();
@@ -85,7 +111,7 @@ describe('Android platform instance', () => {
   it('creates and boots an emulator when missing and shuts it down on dispose', async () => {
     vi.spyOn(
       await import('../environment.js'),
-      'ensureAndroidEmulatorEnvironment',
+      'ensureAndroidEmulatorEnvironment'
     ).mockResolvedValue('/tmp/android-sdk');
     vi.spyOn(adb, 'getDeviceIds').mockResolvedValue([]);
     vi.spyOn(adb, 'hasAvd').mockResolvedValue(false);
@@ -98,11 +124,12 @@ describe('Android platform instance', () => {
     vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
     vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
     vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
+    vi.spyOn(adb, 'getLogcatTimestamp').mockResolvedValue('01-01 00:00:00.000');
     vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(
-      undefined,
+      undefined
     );
     vi.spyOn(sharedPrefs, 'clearHarnessDebugHttpHost').mockResolvedValue(
-      undefined,
+      undefined
     );
     vi.spyOn(adb, 'stopApp').mockResolvedValue(undefined);
     const stopEmulator = vi.spyOn(adb, 'stopEmulator').mockResolvedValue();
@@ -124,7 +151,7 @@ describe('Android platform instance', () => {
         activityName: '.MainActivity',
       },
       harnessConfig,
-      init,
+      init
     );
 
     expect(createAvd).toHaveBeenCalledWith({
@@ -145,7 +172,7 @@ describe('Android platform instance', () => {
     const ensureAndroidEmulatorEnvironment = vi
       .spyOn(
         await import('../environment.js'),
-        'ensureAndroidEmulatorEnvironment',
+        'ensureAndroidEmulatorEnvironment'
       )
       .mockResolvedValue('/tmp/android-sdk');
     vi.spyOn(adb, 'getDeviceIds').mockResolvedValue([]);
@@ -159,8 +186,9 @@ describe('Android platform instance', () => {
     vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
     vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
     vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
+    vi.spyOn(adb, 'getLogcatTimestamp').mockResolvedValue('01-01 00:00:00.000');
     vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(
-      undefined,
+      undefined
     );
 
     await expect(
@@ -181,8 +209,8 @@ describe('Android platform instance', () => {
           activityName: '.MainActivity',
         },
         harnessConfig,
-        init,
-      ),
+        init
+      )
     ).resolves.toBeDefined();
 
     expect(ensureAndroidEmulatorEnvironment).toHaveBeenCalledWith(35);
@@ -194,11 +222,11 @@ describe('Android platform instance', () => {
     vi.stubEnv('HARNESS_AVD_CACHING', 'true');
     vi.spyOn(
       await import('../environment.js'),
-      'getHostAndroidSystemImageArch',
+      'getHostAndroidSystemImageArch'
     ).mockReturnValue('arm64-v8a');
     vi.spyOn(
       await import('../environment.js'),
-      'ensureAndroidEmulatorEnvironment',
+      'ensureAndroidEmulatorEnvironment'
     ).mockResolvedValue('/tmp/android-sdk');
     vi.spyOn(adb, 'getDeviceIds').mockResolvedValue([]);
     vi.spyOn(adb, 'hasAvd').mockResolvedValue(true);
@@ -208,6 +236,7 @@ describe('Android platform instance', () => {
       hwDeviceName: 'pixel_8',
       diskDataPartitionSize: '1G',
       vmHeapSize: '1G',
+      hwCpuNcore: String(getEmulatorCpuCores()),
     });
     vi.spyOn(adb, 'startEmulator').mockResolvedValue(undefined);
     vi.spyOn(adb, 'waitForBoot').mockResolvedValue('emulator-5554');
@@ -215,8 +244,9 @@ describe('Android platform instance', () => {
     vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
     vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
     vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
+    vi.spyOn(adb, 'getLogcatTimestamp').mockResolvedValue('01-01 00:00:00.000');
     vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(
-      undefined,
+      undefined
     );
 
     await expect(
@@ -238,14 +268,14 @@ describe('Android platform instance', () => {
           activityName: '.MainActivity',
         },
         harnessConfig,
-        init,
-      ),
+        init
+      )
     ).resolves.toBeDefined();
 
     expect(adb.startEmulator).toHaveBeenCalledTimes(1);
     expect(adb.startEmulator).toHaveBeenCalledWith(
       'Pixel_8_API_35',
-      'snapshot-reuse',
+      'snapshot-reuse'
     );
   });
 
@@ -253,7 +283,7 @@ describe('Android platform instance', () => {
     vi.stubEnv('HARNESS_AVD_CACHING', 'true');
     vi.spyOn(
       await import('../environment.js'),
-      'ensureAndroidEmulatorEnvironment',
+      'ensureAndroidEmulatorEnvironment'
     ).mockResolvedValue('/tmp/android-sdk');
     vi.spyOn(adb, 'getDeviceIds').mockResolvedValue([]);
     vi.spyOn(adb, 'hasAvd').mockResolvedValue(true);
@@ -276,8 +306,9 @@ describe('Android platform instance', () => {
     vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
     vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
     vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
+    vi.spyOn(adb, 'getLogcatTimestamp').mockResolvedValue('01-01 00:00:00.000');
     vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(
-      undefined,
+      undefined
     );
 
     await expect(
@@ -299,8 +330,8 @@ describe('Android platform instance', () => {
           activityName: '.MainActivity',
         },
         harnessConfig,
-        init,
-      ),
+        init
+      )
     ).resolves.toBeDefined();
 
     expect(deleteAvd).toHaveBeenCalledWith('Pixel_8_API_35');
@@ -308,17 +339,17 @@ describe('Android platform instance', () => {
     expect(stopEmulator).toHaveBeenCalledWith('emulator-5554');
     expect(waitForEmulatorDisconnect).toHaveBeenCalledWith(
       'emulator-5554',
-      init.signal,
+      init.signal
     );
     expect(adb.startEmulator).toHaveBeenNthCalledWith(
       1,
       'Pixel_8_API_35',
-      'clean-snapshot-generation',
+      'clean-snapshot-generation'
     );
     expect(adb.startEmulator).toHaveBeenNthCalledWith(
       2,
       'Pixel_8_API_35',
-      'snapshot-reuse',
+      'snapshot-reuse'
     );
   });
 
@@ -326,7 +357,7 @@ describe('Android platform instance', () => {
     vi.stubEnv('HARNESS_AVD_CACHING', 'true');
     vi.spyOn(
       await import('../environment.js'),
-      'ensureAndroidEmulatorEnvironment',
+      'ensureAndroidEmulatorEnvironment'
     ).mockResolvedValue('/tmp/android-sdk');
     vi.spyOn(adb, 'getDeviceIds').mockResolvedValue([]);
     vi.spyOn(adb, 'hasAvd').mockResolvedValue(false);
@@ -343,8 +374,9 @@ describe('Android platform instance', () => {
     vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
     vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
     vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
+    vi.spyOn(adb, 'getLogcatTimestamp').mockResolvedValue('01-01 00:00:00.000');
     vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(
-      undefined,
+      undefined
     );
 
     await expect(
@@ -366,24 +398,24 @@ describe('Android platform instance', () => {
           activityName: '.MainActivity',
         },
         harnessConfig,
-        init,
-      ),
+        init
+      )
     ).resolves.toBeDefined();
 
     expect(startEmulator).toHaveBeenNthCalledWith(
       1,
       'Pixel_8_API_35',
-      'clean-snapshot-generation',
+      'clean-snapshot-generation'
     );
     expect(stopEmulator).toHaveBeenCalledWith('emulator-5554');
     expect(waitForEmulatorDisconnect).toHaveBeenCalledWith(
       'emulator-5554',
-      init.signal,
+      init.signal
     );
     expect(startEmulator).toHaveBeenNthCalledWith(
       2,
       'Pixel_8_API_35',
-      'snapshot-reuse',
+      'snapshot-reuse'
     );
   });
 
@@ -411,8 +443,8 @@ describe('Android platform instance', () => {
           activityName: '.MainActivity',
         },
         harnessConfig,
-        init,
-      ),
+        init
+      )
     ).rejects.toBeInstanceOf(HarnessAppPathError);
   });
 
@@ -441,8 +473,8 @@ describe('Android platform instance', () => {
           activityName: '.MainActivity',
         },
         harnessConfig,
-        init,
-      ),
+        init
+      )
     ).rejects.toBeInstanceOf(HarnessAppPathError);
   });
 
@@ -461,15 +493,16 @@ describe('Android platform instance', () => {
           activityName: '.MainActivity',
         },
         harnessConfig,
-        init,
-      ),
+        init
+      )
     ).rejects.toBeInstanceOf(HarnessEmulatorConfigError);
   });
 
-  it('returns a noop emulator app monitor when native crash detection is disabled', async () => {
+  it('creates a real emulator app session when native crash detection is disabled', async () => {
+    vi.useFakeTimers();
     vi.spyOn(
       await import('../environment.js'),
-      'ensureAndroidEmulatorEnvironment',
+      'ensureAndroidEmulatorEnvironment'
     ).mockResolvedValue('/tmp/android-sdk');
     vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['emulator-5554']);
     vi.spyOn(adb, 'getEmulatorName').mockResolvedValue('Pixel_8_API_35');
@@ -478,9 +511,16 @@ describe('Android platform instance', () => {
     vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
     vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
     vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
+    vi.spyOn(adb, 'getLogcatTimestamp').mockResolvedValue('01-01 00:00:00.000');
     vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(
-      undefined,
+      undefined
     );
+    const stopApp = vi.spyOn(adb, 'stopApp').mockResolvedValue(undefined);
+    const startApp = vi.spyOn(adb, 'startApp').mockResolvedValue(undefined);
+    const getAppPid = vi.spyOn(adb, 'getAppPid').mockResolvedValue(4321);
+    const startLogcat = vi
+      .spyOn(adb, 'startLogcat')
+      .mockReturnValue(createLogcatProcess());
 
     const instance = await getAndroidEmulatorPlatformInstance(
       {
@@ -499,20 +539,113 @@ describe('Android platform instance', () => {
         activityName: '.MainActivity',
       },
       harnessConfigWithoutNativeCrashDetection,
-      init,
+      init
     );
 
     const listener = vi.fn();
-    const appMonitor = instance.createAppMonitor();
+    const appSession = await instance.createAppSession();
+    appSession.addListener(listener);
+    await vi.advanceTimersByTimeAsync(0);
 
-    await expect(appMonitor.start()).resolves.toBeUndefined();
-    await expect(appMonitor.stop()).resolves.toBeUndefined();
-    await expect(appMonitor.dispose()).resolves.toBeUndefined();
-    expect(appMonitor.addListener(listener)).toBeUndefined();
-    expect(appMonitor.removeListener(listener)).toBeUndefined();
+    expect(startLogcat).toHaveBeenCalledWith(
+      'emulator-5554',
+      [
+        'logcat',
+        '-v',
+        'threadtime',
+        '-b',
+        'crash',
+        '--uid=10234',
+        '-T',
+        '01-01 00:00:00.000',
+      ],
+      { signal: expect.any(AbortSignal) }
+    );
+    expect(startLogcat.mock.invocationCallOrder[0]).toBeLessThan(
+      startApp.mock.invocationCallOrder[0]
+    );
+    await expect(appSession.getState()).resolves.toEqual({
+      status: 'running',
+      pid: 4321,
+    });
+    expect(getAppPid).toHaveBeenCalled();
+    expect(listener).not.toHaveBeenCalled();
+    expect(appSession.removeListener(listener)).toBeUndefined();
+    await expect(appSession.dispose()).resolves.toBeUndefined();
+    expect(stopApp).toHaveBeenCalled();
   });
 
-  it('returns a noop physical device app monitor when native crash detection is disabled', async () => {
+  it('reports an early Android crash from logcat before a PID poll succeeds', async () => {
+    vi.useFakeTimers();
+    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);
+    vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
+    vi.spyOn(adb, 'getLogcatTimestamp').mockResolvedValue('01-01 00:00:00.000');
+    vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(
+      undefined
+    );
+    vi.spyOn(adb, 'stopApp').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'startApp').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'getAppPid').mockResolvedValue(null);
+    vi.spyOn(adb, 'startLogcat').mockReturnValue(
+      createLogcatProcess([
+        '--------- beginning of crash',
+        'Process: com.harnessplayground, PID: 7777',
+        'FATAL EXCEPTION: main',
+      ])
+    );
+
+    const instance = await 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
+    );
+
+    const listener = vi.fn();
+    const appSession = await instance.createAppSession();
+    appSession.addListener(listener);
+
+    await vi.advanceTimersByTimeAsync(0);
+
+    expect(appSession.getLogs().map((entry) => entry.line)).toEqual([
+      '--------- beginning of crash',
+      'Process: com.harnessplayground, PID: 7777',
+      'FATAL EXCEPTION: main',
+    ]);
+    await expect(appSession.getState()).resolves.toMatchObject({
+      status: 'exited',
+      pid: 7777,
+      reason: 'observed-exit',
+    });
+    expect(listener).toHaveBeenCalledWith({ type: 'app_exited' });
+
+    await appSession.dispose();
+  });
+
+  it('creates a real physical-device app session when native crash detection is disabled', async () => {
+    vi.useFakeTimers();
     vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['012345']);
     vi.spyOn(adb, 'getDeviceInfo').mockResolvedValue({
       manufacturer: 'motorola',
@@ -522,25 +655,16 @@ describe('Android platform instance', () => {
     vi.spyOn(adb, 'reversePort').mockResolvedValue(undefined);
     vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
     vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
+    vi.spyOn(adb, 'getLogcatTimestamp').mockResolvedValue('01-01 00:00:00.000');
     vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(
-      undefined,
+      undefined
     );
-
-    await expect(
-      getAndroidPhysicalDevicePlatformInstance(
-        {
-          name: 'android-device',
-          device: {
-            type: 'physical',
-            manufacturer: 'motorola',
-            model: 'moto g72',
-          },
-          bundleId: 'com.harnessplayground',
-          activityName: '.MainActivity',
-        },
-        harnessConfigWithoutNativeCrashDetection,
-      ),
-    ).resolves.toBeDefined();
+    vi.spyOn(adb, 'stopApp').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'startApp').mockResolvedValue(undefined);
+    vi.spyOn(adb, 'getAppPid').mockResolvedValue(8765);
+    const startLogcat = vi
+      .spyOn(adb, 'startLogcat')
+      .mockReturnValue(createLogcatProcess());
 
     const instance = await getAndroidPhysicalDevicePlatformInstance(
       {
@@ -553,23 +677,41 @@ describe('Android platform instance', () => {
         bundleId: 'com.harnessplayground',
         activityName: '.MainActivity',
       },
-      harnessConfigWithoutNativeCrashDetection,
+      harnessConfigWithoutNativeCrashDetection
     );
 
     const listener = vi.fn();
-    const appMonitor = instance.createAppMonitor();
+    const appSession = await instance.createAppSession();
+    appSession.addListener(listener);
+    await vi.advanceTimersByTimeAsync(0);
 
-    await expect(appMonitor.start()).resolves.toBeUndefined();
-    await expect(appMonitor.stop()).resolves.toBeUndefined();
-    await expect(appMonitor.dispose()).resolves.toBeUndefined();
-    expect(appMonitor.addListener(listener)).toBeUndefined();
-    expect(appMonitor.removeListener(listener)).toBeUndefined();
+    expect(startLogcat).toHaveBeenCalledWith(
+      '012345',
+      [
+        'logcat',
+        '-v',
+        'threadtime',
+        '-b',
+        'crash',
+        '--uid=10234',
+        '-T',
+        '01-01 00:00:00.000',
+      ],
+      { signal: expect.any(AbortSignal) }
+    );
+    await expect(appSession.getState()).resolves.toEqual({
+      status: 'running',
+      pid: 8765,
+    });
+    expect(listener).not.toHaveBeenCalled();
+    expect(appSession.removeListener(listener)).toBeUndefined();
+    await expect(appSession.dispose()).resolves.toBeUndefined();
   });
 
   it('grants permissions when permissions are enabled for emulator', async () => {
     vi.spyOn(
       await import('../environment.js'),
-      'ensureAndroidEmulatorEnvironment',
+      'ensureAndroidEmulatorEnvironment'
     ).mockResolvedValue('/tmp/android-sdk');
     vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['emulator-5554']);
     vi.spyOn(adb, 'getEmulatorName').mockResolvedValue('Pixel_8_API_35');
@@ -579,7 +721,7 @@ describe('Android platform instance', () => {
     vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
     vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
     vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(
-      undefined,
+      undefined
     );
     const grantPermissions = vi
       .spyOn(adb, 'grantPermissions')
@@ -607,19 +749,19 @@ describe('Android platform instance', () => {
         activityName: '.MainActivity',
       },
       harnessConfigWithPermissions,
-      init,
+      init
     );
 
     expect(grantPermissions).toHaveBeenCalledWith(
       'emulator-5554',
-      'com.harnessplayground',
+      'com.harnessplayground'
     );
   });
 
   it('does not grant permissions when permissions are disabled for emulator', async () => {
     vi.spyOn(
       await import('../environment.js'),
-      'ensureAndroidEmulatorEnvironment',
+      'ensureAndroidEmulatorEnvironment'
     ).mockResolvedValue('/tmp/android-sdk');
     vi.spyOn(adb, 'getDeviceIds').mockResolvedValue(['emulator-5554']);
     vi.spyOn(adb, 'getEmulatorName').mockResolvedValue('Pixel_8_API_35');
@@ -629,7 +771,7 @@ describe('Android platform instance', () => {
     vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
     vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
     vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(
-      undefined,
+      undefined
     );
     const grantPermissions = vi
       .spyOn(adb, 'grantPermissions')
@@ -652,7 +794,7 @@ describe('Android platform instance', () => {
         activityName: '.MainActivity',
       },
       harnessConfig,
-      init,
+      init
     );
 
     expect(grantPermissions).not.toHaveBeenCalled();
@@ -669,7 +811,7 @@ describe('Android platform instance', () => {
     vi.spyOn(adb, 'setHideErrorDialogs').mockResolvedValue(undefined);
     vi.spyOn(adb, 'getAppUid').mockResolvedValue(10234);
     vi.spyOn(sharedPrefs, 'applyHarnessDebugHttpHost').mockResolvedValue(
-      undefined,
+      undefined
     );
     const grantPermissions = vi
       .spyOn(adb, 'grantPermissions')
@@ -691,12 +833,12 @@ describe('Android platform instance', () => {
         bundleId: 'com.harnessplayground',
         activityName: '.MainActivity',
       },
-      harnessConfigWithPermissions,
+      harnessConfigWithPermissions
     );
 
     expect(grantPermissions).toHaveBeenCalledWith(
       '012345',
-      'com.harnessplayground',
+      'com.harnessplayground'
     );
   });
 });