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

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

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

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

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

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

@@ -0,0 +1,69 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+const mocks = vi.hoisted(() => ({
+    spawn: vi.fn(),
+}));
+// The global test/setup.ts mocks '../adb.js' wholesale (including
+// waitForEmulator itself), which is right for consumers of this module but
+// defeats the purpose here: this suite exercises the *real* polling loop
+// (and its private waitWithSignal helper) to catch timer/listener leaks.
+// Re-declaring the mock for this file restores the actual implementation,
+// while `spawn` and `getAdbBinaryPath` (genuine cross-module imports) are
+// swapped out to keep `getDeviceIds()` from touching a real adb binary.
+vi.mock('../adb.js', async () => {
+    const actual = await vi.importActual('../adb.js');
+    return actual;
+});
+vi.mock('../environment.js', async () => {
+    const actual = await vi.importActual('../environment.js');
+    return { ...actual, getAdbBinaryPath: () => '/fake/sdk/platform-tools/adb' };
+});
+vi.mock('@react-native-harness/tools', async () => {
+    const actual = await vi.importActual('@react-native-harness/tools');
+    return { ...actual, spawn: mocks.spawn };
+});
+const { waitForEmulator } = await import('../adb.js');
+afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+});
+describe('waitForEmulator polling', () => {
+    it('does not leak an abort listener per poll iteration when the delay wins', async () => {
+        vi.useFakeTimers();
+        // No matching device on any poll: `adb devices` reports an empty list.
+        mocks.spawn.mockResolvedValue({ stdout: 'List of devices attached\n' });
+        const controller = new AbortController();
+        const addSpy = vi.spyOn(controller.signal, 'addEventListener');
+        const removeSpy = vi.spyOn(controller.signal, 'removeEventListener');
+        const resultPromise = waitForEmulator('Test_AVD', controller.signal);
+        resultPromise.catch(() => undefined);
+        for (let i = 0; i < 3; i += 1) {
+            await vi.advanceTimersByTimeAsync(1_000);
+        }
+        // Regression: each 1s poll iteration used to add an 'abort' listener
+        // to the local waitForAbort helper that was never removed when the
+        // delay (not the abort) won the race, leaking one listener per second
+        // of polling against this session-lifetime signal.
+        expect(addSpy.mock.calls.length).toBeGreaterThanOrEqual(3);
+        const addCallsBeforeAbort = addSpy.mock.calls.length;
+        controller.abort(new Error('teardown'));
+        await expect(resultPromise).rejects.toThrow('teardown');
+        // Every listener added while losing the race — including the one still
+        // pending when the abort itself won — must be removed again.
+        expect(removeSpy).toHaveBeenCalledTimes(addCallsBeforeAbort);
+    });
+    it('clears the pending 1s poll timer when the signal aborts mid-wait', async () => {
+        vi.useFakeTimers();
+        mocks.spawn.mockResolvedValue({ stdout: 'List of devices attached\n' });
+        const controller = new AbortController();
+        const resultPromise = waitForEmulator('Test_AVD', controller.signal);
+        resultPromise.catch(() => undefined);
+        // Let the loop enter its 1s wait, then abort before the timer fires.
+        await vi.advanceTimersByTimeAsync(0);
+        controller.abort(new Error('teardown'));
+        await expect(resultPromise).rejects.toThrow('teardown');
+        // Regression: the bare setTimeout-backed `wait()` used to have no
+        // handle to clear, so it stayed alive in the event loop for the rest
+        // of the 1s interval even after the abort branch won.
+        expect(vi.getTimerCount()).toBe(0);
+    });
+});

package/dist/__tests__/app-session.test.d.ts

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

package/dist/__tests__/app-session.test.d.ts.map

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

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

@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'vitest';
+import { createAndroidAppSession } from '../app-session.js';
+// Mimics nano-spawn: the async iterator only ends once its abort signal
+// fires, matching how startLogcat's real subprocess reacts to abort.
+const createAbortableLogcatProcess = (signal) => ({
+    [Symbol.asyncIterator]: () => ({
+        next: () => new Promise((resolve) => {
+            if (signal.aborted) {
+                resolve({ done: true, value: undefined });
+                return;
+            }
+            signal.addEventListener('abort', () => resolve({ done: true, value: undefined }), { once: true });
+        }),
+    }),
+    catch: () => undefined,
+});
+describe('createAndroidAppSession', () => {
+    it('combines the session-lifetime signal with its own logcat abort controller', async () => {
+        let capturedSignal;
+        const controller = new AbortController();
+        const session = await createAndroidAppSession({
+            appUid: 1,
+            bundleId: 'com.example',
+            startApp: async () => undefined,
+            stopApp: async () => undefined,
+            getAppPid: async () => null,
+            getLogcatTimestamp: async () => '00:00:00.000',
+            startLogcat: (_args, options) => {
+                capturedSignal = options.signal;
+                return createAbortableLogcatProcess(options.signal);
+            },
+            signal: controller.signal,
+        });
+        expect(capturedSignal?.aborted).toBe(false);
+        controller.abort();
+        expect(capturedSignal?.aborted).toBe(true);
+        await session.dispose();
+    });
+    it('still aborts the logcat signal via dispose() with no external signal provided', async () => {
+        let capturedSignal;
+        const session = await createAndroidAppSession({
+            appUid: 1,
+            bundleId: 'com.example',
+            startApp: async () => undefined,
+            stopApp: async () => undefined,
+            getAppPid: async () => null,
+            getLogcatTimestamp: async () => '00:00:00.000',
+            startLogcat: (_args, options) => {
+                capturedSignal = options.signal;
+                return createAbortableLogcatProcess(options.signal);
+            },
+        });
+        expect(capturedSignal?.aborted).toBe(false);
+        await session.dispose();
+        expect(capturedSignal?.aborted).toBe(true);
+    });
+});

package/dist/__tests__/avd-config.test.js

@@ -1,6 +1,8 @@
 import { describe, expect, it } from 'vitest';
 import { getNormalizedAvdCacheConfig, isAvdCompatible, parseAvdConfig, resolveAvdCachingEnabled, } from '../avd-config.js';
 import { AndroidPlatformConfigSchema } from '../config.js';
+import { getEmulatorCpuCores } from '../emulator-startup.js';
+const emulatorCpuCores = getEmulatorCpuCores();
 describe('AVD config helpers', () => {
     it('parses snapshot config from Android schema', () => {
         const config = AndroidPlatformConfigSchema.parse({
@@ -59,7 +61,9 @@ abi.type=x86_64
 hw.device.name=pixel_8
 disk.dataPartition.size=1G
 vm.heapSize=512M
+hw.cpu.ncore=${emulatorCpuCores}
 `);
+        expect(avdConfig.hwCpuNcore).toBe(String(emulatorCpuCores));
         expect(isAvdCompatible({
             emulator: {
                 type: 'emulator',
@@ -75,6 +79,59 @@ vm.heapSize=512M
             hostArch: 'x86_64',
         })).toEqual({ compatible: true });
     });
+    it('rejects AVDs missing hw.cpu.ncore', () => {
+        const avdConfig = parseAvdConfig(`
+image.sysdir.1=system-images/android-35/default/x86_64/
+abi.type=x86_64
+hw.device.name=pixel_8
+disk.dataPartition.size=1G
+vm.heapSize=512M
+`);
+        expect(isAvdCompatible({
+            emulator: {
+                type: 'emulator',
+                name: 'Pixel_8_API_35',
+                avd: {
+                    apiLevel: 35,
+                    profile: 'pixel_8',
+                    diskSize: '1G',
+                    heapSize: '512M',
+                },
+            },
+            avdConfig,
+            hostArch: 'x86_64',
+        })).toMatchObject({
+            compatible: false,
+            reason: `CPU core count mismatch: expected ${emulatorCpuCores}, got missing.`,
+        });
+    });
+    it('rejects AVDs with a different hw.cpu.ncore', () => {
+        const avdConfig = parseAvdConfig(`
+image.sysdir.1=system-images/android-35/default/x86_64/
+abi.type=x86_64
+hw.device.name=pixel_8
+disk.dataPartition.size=1G
+vm.heapSize=512M
+hw.cpu.ncore=${emulatorCpuCores === 4 ? 3 : 4}
+`);
+        expect(isAvdCompatible({
+            emulator: {
+                type: 'emulator',
+                name: 'Pixel_8_API_35',
+                avd: {
+                    apiLevel: 35,
+                    profile: 'pixel_8',
+                    diskSize: '1G',
+                    heapSize: '512M',
+                },
+            },
+            avdConfig,
+            hostArch: 'x86_64',
+        })).toMatchObject({
+            compatible: false,
+            reason: `CPU core count mismatch: expected ${emulatorCpuCores}, got ${emulatorCpuCores === 4 ? 3 : 4}.`,
+        });
+    });
     it('accepts disk partition sizes rewritten to bytes', () => {
         const avdConfig = parseAvdConfig(`
 image.sysdir.1=system-images/android-35/default/x86_64/
@@ -82,6 +139,7 @@ abi.type=x86_64
 hw.device.name=pixel_8
 disk.dataPartition.size=6442450944
 vm.heapSize=512M
+hw.cpu.ncore=${emulatorCpuCores}
 `);
         expect(isAvdCompatible({
             emulator: {

package/dist/__tests__/crash-diagnostics.test.d.ts

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

package/dist/__tests__/crash-diagnostics.test.d.ts.map

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

package/dist/__tests__/crash-diagnostics.test.js

@@ -0,0 +1,119 @@
+import { describe, expect, it } from 'vitest';
+import { collectDropboxArtifacts, filterExitInfo, getBestDropboxArtifact, parseDropboxOutput, } from '../crash-diagnostics.js';
+const javaCrashDropbox = `
+Drop box contents: 1 entries
+Max entries: 1000
+========================================
+2026-03-12 10:30:45.123 data_app_crash (text, 500 bytes)
+Process: com.harnessplayground
+PID: 7777
+Package: com.harnessplayground v1 (1.0)
+java.lang.RuntimeException: boom
+\tat com.harnessplayground.MainActivity.onCreate(MainActivity.kt:38)
+`;
+const nativeCrashDropbox = `
+========================================
+2026-03-12 10:31:10.456 data_app_native_crash (text, 800 bytes)
+Process: com.harnessplayground
+PID: 8888
+signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 0xdeadbeef
+Abort message: 'JNI DETECTED ERROR IN APPLICATION'
+backtrace:
+      #00 pc 00001234  /data/app/lib/libapp.so
+`;
+const deviceJavaCrashDropbox = `
+Drop box contents: 8 entries
+Searching for: data_app_crash
+
+========================================
+2026-05-29 10:22:34 data_app_crash (text, 1328 bytes)
+SystemUptimeMs: 79467172
+Process: com.harnessplayground
+PID: 586
+Package: com.harnessplayground v1 (1.0)
+java.lang.RuntimeException: Intentional asynchronous Kotlin crash
+\tat com.harnessplayground.PlaygroundCrashModule.crashFromKotlinAsync(PlaygroundCrashModule.kt:44)
+`;
+describe('collectDropboxArtifacts', () => {
+    it('matches harness playground crashes from merged per-tag dropbox output', async () => {
+        const artifacts = await collectDropboxArtifacts({
+            bundleId: 'com.harnessplayground',
+            getDropboxOutput: async () => deviceJavaCrashDropbox,
+            occurredAt: Date.now(),
+            pid: 586,
+        });
+        expect(artifacts).toHaveLength(1);
+        expect(artifacts[0]).toMatchObject({
+            artifactType: 'dropbox-crash',
+            pid: 586,
+            processName: 'com.harnessplayground',
+        });
+    });
+    it('ignores Dropbox entries older than the session start time', async () => {
+        const artifacts = await collectDropboxArtifacts({
+            bundleId: 'com.harnessplayground',
+            getDropboxOutput: async () => deviceJavaCrashDropbox,
+            minOccurredAt: Date.parse('2026-05-29T10:22:35.000Z'),
+            occurredAt: Date.parse('2026-05-29T10:22:36.000Z'),
+        });
+        expect(artifacts).toHaveLength(0);
+    });
+});
+describe('parseDropboxOutput', () => {
+    it('parses java and native dropbox entries', () => {
+        const entries = parseDropboxOutput(`${javaCrashDropbox}\n${nativeCrashDropbox}`);
+        expect(entries).toHaveLength(2);
+        expect(entries[0]).toMatchObject({
+            tag: 'data_app_crash',
+            pid: 7777,
+        });
+        expect(entries[1]).toMatchObject({
+            tag: 'data_app_native_crash',
+            pid: 8888,
+        });
+        expect(entries[1]?.content).toContain('SIGSEGV');
+    });
+});
+describe('getBestDropboxArtifact', () => {
+    it('prefers the highest-scored artifact', () => {
+        const entries = parseDropboxOutput(`${javaCrashDropbox}\n${nativeCrashDropbox}`);
+        const artifacts = entries.map((entry, index) => ({
+            artifactType: entry.tag === 'data_app_native_crash'
+                ? 'dropbox-native-crash'
+                : 'dropbox-crash',
+            dropboxTag: entry.tag,
+            occurredAt: Date.now(),
+            score: index === 0 ? 100 : 300,
+            summary: entry.content,
+            pid: entry.pid,
+            processName: 'com.harnessplayground',
+        }));
+        expect(getBestDropboxArtifact(artifacts)?.dropboxTag).toBe('data_app_native_crash');
+    });
+});
+describe('filterExitInfo', () => {
+    it('returns matching exit-info records for the target package and pid', () => {
+        const output = `
+ApplicationExitInfo #0:
+  package=com.harnessplayground pid=7777 realUid=10123
+  reason=4 (APP CRASH(NATIVE))
+  timestamp=2026-03-12 10:31:10.456
+ApplicationExitInfo #1:
+  package=com.other.app pid=9999 realUid=10199
+  reason=10 (USER REQUESTED)
+`;
+        const filtered = filterExitInfo({
+            output,
+            bundleId: 'com.harnessplayground',
+            pid: 7777,
+        });
+        expect(filtered).toContain('com.harnessplayground pid=7777');
+        expect(filtered).not.toContain('com.other.app');
+    });
+    it('returns null when no exit-info records exist', () => {
+        expect(filterExitInfo({
+            output: 'No exit info records for com.harnessplayground',
+            bundleId: 'com.harnessplayground',
+        })).toBeNull();
+    });
+});

package/dist/__tests__/crash-reporter.test.d.ts

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

package/dist/__tests__/crash-reporter.test.d.ts.map

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

package/dist/__tests__/crash-reporter.test.js

@@ -0,0 +1,150 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { createAndroidCrashReporter } from '../crash-reporter.js';
+const javaCrashDropbox = `
+========================================
+2026-03-12 10:30:45.123 data_app_crash (text, 500 bytes)
+Process: com.harnessplayground
+PID: 7777
+Package: com.harnessplayground v1 (1.0)
+java.lang.RuntimeException: boom
+\tat com.harnessplayground.MainActivity.onCreate(MainActivity.kt:38)
+`;
+const nativeCrashDropbox = `
+========================================
+2026-03-12 10:31:10.456 data_app_native_crash (text, 800 bytes)
+Process: com.harnessplayground
+PID: 8888
+signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 0xdeadbeef
+Abort message: 'JNI DETECTED ERROR IN APPLICATION'
+backtrace:
+      #00 pc 00001234  /data/app/lib/libapp.so
+`;
+describe('createAndroidCrashReporter', () => {
+    afterEach(() => {
+        vi.useRealTimers();
+    });
+    it('persists the current logcat crash block with the test file path', async () => {
+        vi.useFakeTimers();
+        const persistArtifact = vi.fn(() => '/tmp/.harness/crash-reports/logcat.txt');
+        const reporter = createAndroidCrashReporter({
+            bundleId: 'com.harnessplayground',
+            crashArtifactWriter: {
+                runTimestamp: '2026-03-12T11-35-08-000Z',
+                persistArtifact,
+            },
+            getLogs: () => [
+                { line: 'ordinary crash-buffer line', occurredAt: 1_000 },
+                { line: '--------- beginning of crash', occurredAt: 1_100 },
+                {
+                    line: 'Process: com.harnessplayground, PID: 7777',
+                    occurredAt: 1_100,
+                },
+                { line: 'FATAL EXCEPTION: main', occurredAt: 1_100 },
+            ],
+        });
+        const detailsPromise = reporter.getCrashDetails({
+            occurredAt: 1_100,
+            pid: 7777,
+            testFilePath: '/test/native-crash.test.ts',
+        });
+        await vi.advanceTimersByTimeAsync(100);
+        const details = await detailsPromise;
+        expect(details).toMatchObject({
+            artifactType: 'logcat',
+            artifactPath: '/tmp/.harness/crash-reports/logcat.txt',
+            pid: 7777,
+            processName: 'com.harnessplayground',
+        });
+        expect(persistArtifact).toHaveBeenCalledWith({
+            artifactKind: 'logcat',
+            testFilePath: '/test/native-crash.test.ts',
+            source: {
+                kind: 'text',
+                fileName: 'logcat.txt',
+                text: [
+                    '--------- beginning of crash',
+                    'Process: com.harnessplayground, PID: 7777',
+                    'FATAL EXCEPTION: main',
+                    '',
+                ].join('\n'),
+            },
+        });
+    });
+    it('adds dropbox artifacts as enrichment when logcat evidence is available', async () => {
+        vi.useFakeTimers();
+        const persistArtifact = vi
+            .fn()
+            .mockImplementation(({ artifactKind }) => {
+            return `/tmp/.harness/crash-reports/${artifactKind}.txt`;
+        });
+        const reporter = createAndroidCrashReporter({
+            bundleId: 'com.harnessplayground',
+            crashArtifactWriter: {
+                runTimestamp: '2026-03-12T11-35-08-000Z',
+                persistArtifact,
+            },
+            getLogs: () => [
+                { line: '--------- beginning of crash', occurredAt: 1_100 },
+                {
+                    line: 'Process: com.harnessplayground, PID: 7777',
+                    occurredAt: 1_100,
+                },
+                { line: 'FATAL EXCEPTION: main', occurredAt: 1_100 },
+            ],
+            getDropboxOutput: async () => javaCrashDropbox,
+            getExitInfo: async () => 'ApplicationExitInfo #0:\n  package=com.harnessplayground pid=7777 reason=4 (APP CRASH(NATIVE))',
+        });
+        const detailsPromise = reporter.getCrashDetails({
+            occurredAt: 1_100,
+            pid: 7777,
+            testFilePath: '/test/native-crash.test.ts',
+        });
+        await vi.advanceTimersByTimeAsync(100);
+        const details = await detailsPromise;
+        expect(details).toMatchObject({
+            artifactType: 'logcat',
+            artifactPath: '/tmp/.harness/crash-reports/logcat.txt',
+        });
+        expect(details?.enrichmentArtifacts).toEqual(expect.arrayContaining([
+            {
+                artifactType: 'dropbox-crash',
+                artifactPath: '/tmp/.harness/crash-reports/dropbox-crash.txt',
+            },
+            {
+                artifactType: 'exit-info',
+                artifactPath: '/tmp/.harness/crash-reports/exit-info.txt',
+            },
+        ]));
+    });
+    it('falls back to native dropbox evidence when logcat is empty', async () => {
+        vi.useFakeTimers();
+        const persistArtifact = vi
+            .fn()
+            .mockImplementation(({ artifactKind }) => {
+            return `/tmp/.harness/crash-reports/${artifactKind}.txt`;
+        });
+        const reporter = createAndroidCrashReporter({
+            bundleId: 'com.harnessplayground',
+            crashArtifactWriter: {
+                runTimestamp: '2026-03-12T11-35-08-000Z',
+                persistArtifact,
+            },
+            getLogs: () => [],
+            getDropboxOutput: async () => nativeCrashDropbox,
+        });
+        const detailsPromise = reporter.getCrashDetails({
+            occurredAt: 1_100,
+            pid: 8888,
+            testFilePath: '/test/native-crash.test.ts',
+        });
+        await vi.advanceTimersByTimeAsync(100);
+        const details = await detailsPromise;
+        expect(details).toMatchObject({
+            artifactType: 'dropbox-native-crash',
+            artifactPath: '/tmp/.harness/crash-reports/dropbox-native-crash.txt',
+            pid: 8888,
+            signal: 'SIGSEGV',
+            processName: 'com.harnessplayground',
+        });
+    });
+});

package/dist/__tests__/emulator-startup.test.js

@@ -1,20 +1,47 @@
 import { describe, expect, it } from 'vitest';
-import { getEmulatorStartupArgs } from '../emulator-startup.js';
+import { getEmulatorCpuCores, getEmulatorStartupArgs, isAccelerationUsable, } from '../emulator-startup.js';
+import { getDeviceCoreBudget } from '@react-native-harness/tools';
+import os from 'node:os';
+describe('getEmulatorCpuCores', () => {
+    it('uses the shared device-core budget for the current host', () => {
+        expect(getEmulatorCpuCores()).toBe(getDeviceCoreBudget(os.availableParallelism()));
+    });
+});
 describe('emulator startup modes', () => {
     it('builds default boot args', () => {
         expect(getEmulatorStartupArgs('Pixel_8_API_35', 'default-boot')).toEqual(expect.arrayContaining([
             '@Pixel_8_API_35',
             '-no-snapshot-load',
             '-no-snapshot-save',
+            '-no-metrics',
         ]));
         expect(getEmulatorStartupArgs('Pixel_8_API_35', 'default-boot')).not.toEqual(expect.arrayContaining(['-camera-back', 'none']));
     });
     it('builds clean snapshot generation args', () => {
-        expect(getEmulatorStartupArgs('Pixel_8_API_35', 'clean-snapshot-generation')).toEqual(expect.arrayContaining(['@Pixel_8_API_35', '-no-snapshot-load']));
+        expect(getEmulatorStartupArgs('Pixel_8_API_35', 'clean-snapshot-generation')).toEqual(expect.arrayContaining([
+            '@Pixel_8_API_35',
+            '-no-snapshot-load',
+            '-no-metrics',
+        ]));
         expect(getEmulatorStartupArgs('Pixel_8_API_35', 'clean-snapshot-generation')).not.toContain('-no-snapshot-save');
     });
     it('builds snapshot reuse args', () => {
-        expect(getEmulatorStartupArgs('Pixel_8_API_35', 'snapshot-reuse')).toEqual(expect.arrayContaining(['@Pixel_8_API_35', '-no-snapshot-save']));
+        expect(getEmulatorStartupArgs('Pixel_8_API_35', 'snapshot-reuse')).toEqual(expect.arrayContaining([
+            '@Pixel_8_API_35',
+            '-no-snapshot-save',
+            '-no-metrics',
+        ]));
         expect(getEmulatorStartupArgs('Pixel_8_API_35', 'snapshot-reuse')).not.toContain('-no-snapshot-load');
     });
 });
+describe('isAccelerationUsable', () => {
+    it('returns true when the emulator reports acceleration is usable', () => {
+        expect(isAccelerationUsable('accel:\n0\nKVM (version 12) is installed and usable.\naccel\n')).toBe(true);
+    });
+    it('returns false when acceleration is disabled', () => {
+        expect(isAccelerationUsable('accel:\n0\nKVM is not installed on this machine.\naccel\n')).toBe(false);
+    });
+    it('returns false for empty output', () => {
+        expect(isAccelerationUsable('')).toBe(false);
+    });
+});