@onekeyfe/hd-transport-react-native 1.2.0-alpha.65 → 1.2.0-alpha.66

package/src/__tests__/connectTimeout.test.ts

@@ -1,282 +0,0 @@
-import { EventEmitter } from 'events';
-import { BleErrorCode } from 'react-native-ble-plx';
-
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-import ReactNativeBleTransport, {
-  BLE_CONNECT_TIMEOUT_MS,
-  BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD,
-  BLE_GATT_SETUP_TIMEOUT_MS,
-} from '../index';
-
-import messages from '@onekeyfe/hd-transport/messages.json';
-
-jest.mock(
-  'react-native',
-  () => ({
-    Platform: { OS: 'ios', select: (spec: Record<string, unknown>) => spec.ios },
-    PermissionsAndroid: {
-      PERMISSIONS: {},
-      RESULTS: {},
-      request: jest.fn(),
-      requestMultiple: jest.fn(),
-    },
-  }),
-  { virtual: true }
-);
-
-jest.mock('react-native-ble-plx', () => ({
-  BleATTErrorCode: { InvalidHandle: 1, UnlikelyError: 14 },
-  BleError: Error,
-  BleErrorCode: {
-    DeviceDisconnected: 201,
-    OperationStartFailed: 601,
-    DeviceMTUChangeFailed: 401,
-    OperationCancelled: 2,
-    OperationTimedOut: 3,
-    DeviceAlreadyConnected: 203,
-  },
-  BleManager: jest.fn(),
-  ScanMode: { LowLatency: 2 },
-}));
-
-jest.mock('@onekeyfe/react-native-ble-utils', () => ({
-  __esModule: true,
-  default: {
-    getConnectedPeripherals: jest.fn(() => Promise.resolve([])),
-    getBondedPeripherals: jest.fn(() => Promise.resolve([])),
-    pairDevice: jest.fn(() => Promise.resolve()),
-  },
-}));
-
-const UUID = 'stalled-connect-device';
-
-const flush = () =>
-  new Promise(resolve => {
-    setImmediate(resolve);
-  });
-
-async function advanceUntil(settled: () => boolean, totalMs: number, stepMs = 250) {
-  for (let elapsed = 0; elapsed < totalMs; elapsed += stepMs) {
-    jest.advanceTimersByTime(stepMs);
-    // eslint-disable-next-line no-await-in-loop
-    await flush();
-    if (settled()) return;
-  }
-  throw new Error(`fake timers exhausted after ${totalMs}ms before the connect settled`);
-}
-
-/** A device whose native connect() never settles — the observed iOS failure mode. */
-function createHarness(connectImpl: () => Promise<unknown>) {
-  const connect = jest.fn(connectImpl);
-  const writeCharacteristic = {
-    uuid: '00000002-0000-1000-8000-00805f9b34fb',
-    isWritableWithResponse: true,
-  };
-  const notifyCharacteristic = {
-    uuid: '00000003-0000-1000-8000-00805f9b34fb',
-    isNotifiable: true,
-  };
-  const device = {
-    id: UUID,
-    name: 'OneKey Classic',
-    localName: 'OneKey Classic',
-    serviceUUIDs: ['00000001-0000-1000-8000-00805f9b34fb'],
-    isConnected: jest.fn(() => Promise.resolve(false)),
-    cancelConnection: jest.fn(() => Promise.resolve()),
-    connect,
-    discoverAllServicesAndCharacteristics: jest.fn(() => Promise.resolve()),
-    characteristicsForService: jest.fn(() =>
-      Promise.resolve([writeCharacteristic, notifyCharacteristic])
-    ),
-    services: jest.fn(() => Promise.resolve([])),
-    onDisconnected: jest.fn(() => ({ remove: jest.fn() })),
-  };
-  const transport = new ReactNativeBleTransport({ scanTimeout: 1 });
-  const bleManager = {
-    devices: jest.fn(() => Promise.resolve([device])),
-    connectedDevices: jest.fn(() => Promise.resolve([])),
-    connectToDevice: jest.fn(connectImpl),
-    cancelTransaction: jest.fn(() => Promise.resolve()),
-    cancelDeviceConnection: jest.fn(() => Promise.resolve()),
-    onStateChange: jest.fn((listener: (state: string) => void) => {
-      // Dispatch asynchronously: subscribeBleOn wires its own cleanup after
-      // registering, so a synchronous callback would run before it is ready.
-      setImmediate(() => listener('PoweredOn'));
-      return { remove: jest.fn() };
-    }),
-    state: jest.fn(() => Promise.resolve('PoweredOn')),
-    startDeviceScan: jest.fn(),
-    stopDeviceScan: jest.fn(),
-  };
-  (transport as any).blePlxManager = bleManager;
-  transport.init(
-    { debug: jest.fn(), error: jest.fn(), warn: jest.fn() } as any,
-    new EventEmitter()
-  );
-  transport.configure(messages);
-  return { transport, device, bleManager, connect };
-}
-
-describe('BLE connect timeout', () => {
-  beforeAll(() => {
-    jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance'] });
-  });
-
-  afterAll(() => {
-    jest.useRealTimers();
-  });
-
-  afterEach(() => {
-    jest.clearAllTimers();
-    jest.restoreAllMocks();
-  });
-
-  test('a native connect that never settles is bounded instead of blocking forever', async () => {
-    // iOS applies its own connect timeout on a serial queue; when that queue is busy
-    // the timeout never fires and acquire() blocks until the app-level 60s timeout.
-    const { transport } = createHarness(
-      () =>
-        new Promise(() => {
-          // never settles
-        })
-    );
-
-    const errors: Array<{ errorCode?: unknown }> = [];
-    let settled = false;
-    transport.acquire({ uuid: UUID }).catch(e => {
-      errors.push(e);
-      settled = true;
-    });
-    await flush();
-
-    await advanceUntil(() => settled, BLE_CONNECT_TIMEOUT_MS + 5000);
-
-    expect(errors).toHaveLength(1);
-    expect(errors[0]?.errorCode).toBe(HardwareErrorCode.BleConnectedError);
-  });
-
-  test('the connect budget leaves generous headroom over a healthy connect', () => {
-    // Healthy connects finish in ~2-3s (the native budget is 3s); this backstop only
-    // fires when the native timeout itself fails to.
-    expect(BLE_CONNECT_TIMEOUT_MS).toBeGreaterThanOrEqual(6000);
-    expect(BLE_CONNECT_TIMEOUT_MS).toBeLessThanOrEqual(12000);
-  });
-
-  test('a stalled connect is abandoned natively so the next attempt is not cancelled by it', async () => {
-    const { transport, bleManager } = createHarness(
-      () =>
-        new Promise(() => {
-          // never settles
-        })
-    );
-
-    let settled = false;
-    transport.acquire({ uuid: UUID }).catch(() => {
-      settled = true;
-    });
-    await flush();
-    await advanceUntil(() => settled, BLE_CONNECT_TIMEOUT_MS + 5000);
-
-    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(UUID);
-  });
-
-  test('repeated stalled connects recreate the BLE manager', async () => {
-    const { transport, bleManager } = createHarness(
-      () =>
-        new Promise(() => {
-          // never settles
-        })
-    );
-    const destroy = jest.fn();
-    (bleManager as unknown as { destroy: jest.Mock }).destroy = destroy;
-
-    for (let attempt = 0; attempt < BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD; attempt += 1) {
-      let settled = false;
-      transport.acquire({ uuid: UUID }).catch(() => {
-        settled = true;
-      });
-      // eslint-disable-next-line no-await-in-loop
-      await flush();
-      // eslint-disable-next-line no-await-in-loop
-      await advanceUntil(() => settled, BLE_CONNECT_TIMEOUT_MS + 5000);
-    }
-
-    expect(destroy).toHaveBeenCalledTimes(1);
-    expect((transport as unknown as { blePlxManager?: unknown }).blePlxManager).toBeUndefined();
-  });
-
-  test('native connect timeouts contribute to the same manager reset budget', async () => {
-    const { transport, bleManager } = createHarness(() => Promise.resolve());
-    const destroy = jest.fn();
-    (bleManager as unknown as { destroy: jest.Mock }).destroy = destroy;
-    const nativeTimeout = Object.assign(new Error('Operation timed out'), {
-      errorCode: BleErrorCode.OperationTimedOut,
-    });
-
-    for (let attempt = 0; attempt < BLE_CONNECT_TIMEOUT_MANAGER_RESET_THRESHOLD; attempt += 1) {
-      // eslint-disable-next-line no-await-in-loop
-      await expect(
-        (transport as any).connectWithTimeout(UUID, () => Promise.reject(nativeTimeout))
-      ).rejects.toBe(nativeTimeout);
-    }
-
-    expect(destroy).toHaveBeenCalledTimes(1);
-  });
-
-  test('GATT discovery is bounded and abandons the native connection', async () => {
-    const { transport, device, bleManager } = createHarness(() => Promise.resolve());
-    device.discoverAllServicesAndCharacteristics.mockImplementation(
-      () =>
-        new Promise(() => {
-          // never settles
-        })
-    );
-
-    const errors: Array<{ errorCode?: unknown }> = [];
-    let settled = false;
-    (transport as any).resolveCharacteristicsWithTimeout(UUID, device).catch((error: unknown) => {
-      errors.push(error as { errorCode?: unknown });
-      settled = true;
-    });
-    await flush();
-    await advanceUntil(() => settled, BLE_GATT_SETUP_TIMEOUT_MS + 5000);
-
-    expect(errors).toHaveLength(1);
-    expect(errors[0]?.errorCode).toBe(HardwareErrorCode.BleConnectedError);
-    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledWith(UUID);
-  });
-
-  test('a successful GATT retry clears the timeout budget before an abandoned call settles', async () => {
-    const { transport, device, bleManager } = createHarness(() => Promise.resolve());
-    let resolveAbandonedDiscovery: (() => void) | undefined;
-    device.discoverAllServicesAndCharacteristics
-      .mockImplementationOnce(
-        () =>
-          new Promise<void>(resolve => {
-            resolveAbandonedDiscovery = resolve;
-          })
-      )
-      .mockResolvedValueOnce(undefined);
-
-    let firstSettled = false;
-    (transport as any).resolveCharacteristicsWithTimeout(UUID, device).catch(() => {
-      firstSettled = true;
-    });
-    await flush();
-    await advanceUntil(() => firstSettled, BLE_GATT_SETUP_TIMEOUT_MS + 5000);
-
-    await expect(
-      (transport as any).resolveCharacteristicsWithTimeout(UUID, device)
-    ).resolves.toMatchObject({
-      writeCharacteristic: expect.any(Object),
-      notifyCharacteristic: expect.any(Object),
-    });
-
-    resolveAbandonedDiscovery?.();
-    await flush();
-
-    expect(bleManager.cancelDeviceConnection).toHaveBeenCalledTimes(1);
-    expect((transport as any).connectionSetupTimeoutCounts.has(UUID)).toBe(false);
-  });
-});

package/src/__tests__/protocolReprobe.test.ts

@@ -1,133 +0,0 @@
-import ReactNativeBleTransport, { PROTOCOL_REPROBE_FALLBACK_ATTEMPTS } from '../index';
-
-import messages from '@onekeyfe/hd-transport/messages.json';
-
-jest.mock(
-  'react-native',
-  () => ({
-    Platform: { OS: 'ios', select: (spec: Record<string, unknown>) => spec.ios },
-    PermissionsAndroid: {
-      PERMISSIONS: {},
-      RESULTS: {},
-      request: jest.fn(),
-      requestMultiple: jest.fn(),
-    },
-  }),
-  { virtual: true }
-);
-
-jest.mock('react-native-ble-plx', () => ({
-  BleATTErrorCode: { InvalidHandle: 1, UnlikelyError: 14 },
-  BleError: Error,
-  BleErrorCode: { DeviceDisconnected: 201, OperationStartFailed: 601 },
-  BleManager: jest.fn(),
-  ScanMode: { LowLatency: 2 },
-}));
-
-jest.mock('@onekeyfe/react-native-ble-utils', () => ({
-  __esModule: true,
-  default: {
-    getConnectedPeripherals: jest.fn(() => Promise.resolve([])),
-    getBondedPeripherals: jest.fn(() => Promise.resolve([])),
-    pairDevice: jest.fn(() => Promise.resolve()),
-  },
-}));
-
-const UUID = 'reprobe-device';
-
-/** Drive detectProtocol with stubbed probes so we can observe which are attempted. */
-function createHarness({ v1, v2 }: { v1: boolean; v2: boolean }) {
-  const transport = new ReactNativeBleTransport({});
-  transport.configure(messages);
-  const probeV1 = jest.fn(() => {
-    if (v1) {
-      (transport as any).deviceProtocol.set(UUID, 'V1');
-    }
-    return Promise.resolve(v1);
-  });
-  const probeV2 = jest.fn(() => {
-    if (v2) {
-      (transport as any).deviceProtocol.set(UUID, 'V2');
-    }
-    return Promise.resolve(v2);
-  });
-  (transport as any).probeProtocolV1 = probeV1;
-  (transport as any).probeProtocolV2 = probeV2;
-  (transport as any).resetProbeStateAfterProtocolProbe = jest.fn(() => Promise.resolve());
-  return { transport, probeV1, probeV2 };
-}
-
-const detect = (transport: ReactNativeBleTransport) =>
-  (transport as any).detectProtocol(UUID, undefined, undefined, () =>
-    Promise.resolve()
-  ) as Promise<string>;
-
-describe('protocol re-probe after a known device goes away', () => {
-  test('an unknown device still probes both protocols', async () => {
-    const { transport, probeV1, probeV2 } = createHarness({ v1: false, v2: false });
-
-    await expect(detect(transport)).rejects.toBeDefined();
-
-    expect(probeV1).toHaveBeenCalledTimes(1);
-    expect(probeV2).toHaveBeenCalledTimes(1);
-  });
-
-  test('a device already known to speak V1 does not pay the V2 probe while it is away', async () => {
-    const known = createHarness({ v1: true, v2: false });
-    // First detection confirms V1 (this is the session that just talked to the device).
-    await expect(detect(known.transport)).resolves.toBe('V1');
-
-    // The device now reboots after a firmware install: V1 stops answering.
-    (known.transport as any).deviceProtocol.delete(UUID);
-    const probeV1 = jest.fn(() => Promise.resolve(false));
-    const probeV2 = jest.fn(() => Promise.resolve(false));
-    (known.transport as any).probeProtocolV1 = probeV1;
-    (known.transport as any).probeProtocolV2 = probeV2;
-
-    await expect(detect(known.transport)).rejects.toBeDefined();
-
-    expect(probeV1).toHaveBeenCalledTimes(1);
-    // The 10s Protocol V2 ping is pure waste for a device we just spoke V1 to.
-    expect(probeV2).not.toHaveBeenCalled();
-  });
-
-  test('after repeated failures it re-probes every protocol again', async () => {
-    const known = createHarness({ v1: true, v2: false });
-    await expect(detect(known.transport)).resolves.toBe('V1');
-
-    (known.transport as any).deviceProtocol.delete(UUID);
-    const probeV1 = jest.fn(() => Promise.resolve(false));
-    const probeV2 = jest.fn(() => Promise.resolve(false));
-    (known.transport as any).probeProtocolV1 = probeV1;
-    (known.transport as any).probeProtocolV2 = probeV2;
-
-    for (let attempt = 0; attempt < PROTOCOL_REPROBE_FALLBACK_ATTEMPTS; attempt += 1) {
-      // eslint-disable-next-line no-await-in-loop
-      await expect(detect(known.transport)).rejects.toBeDefined();
-    }
-    expect(probeV2).not.toHaveBeenCalled();
-
-    // The device may genuinely have changed protocol, so the shortcut must expire.
-    await expect(detect(known.transport)).rejects.toBeDefined();
-    expect(probeV2).toHaveBeenCalled();
-  });
-
-  test('a successful detection clears the failure streak', async () => {
-    const known = createHarness({ v1: true, v2: false });
-    await expect(detect(known.transport)).resolves.toBe('V1');
-    (known.transport as any).deviceProtocol.delete(UUID);
-
-    const failingV1 = jest.fn(() => Promise.resolve(false));
-    (known.transport as any).probeProtocolV1 = failingV1;
-    await expect(detect(known.transport)).rejects.toBeDefined();
-
-    // Device comes back.
-    (known.transport as any).probeProtocolV1 = jest.fn(() => {
-      (known.transport as any).deviceProtocol.set(UUID, 'V1');
-      return Promise.resolve(true);
-    });
-    await expect(detect(known.transport)).resolves.toBe('V1');
-
-    expect((known.transport as any).protocolReprobeFailures.get(UUID)).toBeUndefined();
-  });
-});

package/src/__tests__/staleCallTimeout.test.ts

@@ -1,211 +0,0 @@
-import { HardwareErrorCode } from '@onekeyfe/hd-shared';
-
-import ReactNativeBleTransport from '../index';
-
-import messages from '@onekeyfe/hd-transport/messages.json';
-
-jest.mock(
-  'react-native',
-  () => ({
-    Platform: { OS: 'ios', select: (spec: Record<string, unknown>) => spec.ios },
-    PermissionsAndroid: {
-      PERMISSIONS: {},
-      RESULTS: {},
-      request: jest.fn(),
-      requestMultiple: jest.fn(),
-    },
-  }),
-  { virtual: true }
-);
-
-jest.mock('react-native-ble-plx', () => ({
-  BleATTErrorCode: { InvalidHandle: 1 },
-  BleError: Error,
-  BleErrorCode: { DeviceDisconnected: 201, OperationStartFailed: 601 },
-  BleManager: jest.fn(),
-  ScanMode: { LowLatency: 2 },
-}));
-
-jest.mock('@onekeyfe/react-native-ble-utils', () => ({
-  __esModule: true,
-  default: {
-    getConnectedPeripherals: jest.fn(() => Promise.resolve([])),
-    getBondedPeripherals: jest.fn(() => Promise.resolve([])),
-    pairDevice: jest.fn(() => Promise.resolve()),
-  },
-}));
-
-const UUID = 'stale-timeout-device';
-
-const flush = () =>
-  new Promise(resolve => {
-    setImmediate(resolve);
-  });
-
-function createHarness() {
-  const t = new ReactNativeBleTransport({});
-  t.configure(messages);
-  (t as any).deviceProtocol.set(UUID, 'V1');
-  const writeWithoutResponse = jest.fn(() => Promise.resolve());
-  const fakeBleTransport = {
-    writeCharacteristic: { writeWithoutResponse },
-    writeWithRetry: jest.fn(() => Promise.resolve()),
-  };
-  (t as any).getCachedTransport = () => fakeBleTransport;
-  const disconnectSpy = jest.spyOn(t, 'disconnect').mockResolvedValue(undefined);
-  return { t, disconnectSpy, writeWithoutResponse };
-}
-
-describe('Protocol V1 stale call timeout', () => {
-  beforeAll(() => {
-    jest.useFakeTimers({ doNotFake: ['setImmediate', 'performance'] });
-  });
-
-  afterAll(() => {
-    jest.useRealTimers();
-  });
-
-  afterEach(() => {
-    jest.clearAllTimers();
-    jest.restoreAllMocks();
-  });
-
-  test('superseded Initialize timeout does not tear down the shared transport', async () => {
-    const { t, disconnectSpy } = createHarness();
-
-    // Initialize #1: written while the device reboots, never answered.
-    const firstErrors: unknown[] = [];
-    const first = t.call(UUID, 'Initialize', {}, { timeoutMs: 25000 });
-    first.catch(e => firstErrors.push(e));
-    await flush();
-
-    // Initialize #2 (forceRun) supersedes #1 three seconds later.
-    jest.advanceTimersByTime(3000);
-    const secondErrors: unknown[] = [];
-    const second = t.call(UUID, 'Initialize', {}, { timeoutMs: 25000 });
-    second.catch(e => secondErrors.push(e));
-    await flush();
-
-    // The device answers Initialize #2 (settle its deferred at the transport seam).
-    expect(t.runPromise).not.toBeNull();
-    t.runPromise?.reject(new Error('settled by device response'));
-    await flush();
-
-    // FirmwareUpload is now the active call on the same transport, awaiting its response.
-    const uploadErrors: unknown[] = [];
-    const upload = t.call(UUID, 'FirmwareUpload', { payload: Buffer.alloc(300) });
-    upload.catch(e => uploadErrors.push(e));
-    await flush();
-    jest.advanceTimersByTime(100); // firmware upload flush delay
-    await flush();
-
-    // Initialize #1's 25s response timer elapses while the upload is in flight.
-    jest.advanceTimersByTime(25000);
-    await flush();
-
-    expect(disconnectSpy).not.toHaveBeenCalled();
-    expect(firstErrors).toHaveLength(1);
-    expect(uploadErrors).toHaveLength(0);
-  });
-
-  test('forceRun supersede settles the previous pending call immediately', async () => {
-    const { t } = createHarness();
-
-    const firstErrors: Array<{ errorCode?: unknown }> = [];
-    const first = t.call(UUID, 'Initialize', {}, { timeoutMs: 25000 });
-    first.catch(e => firstErrors.push(e));
-    await flush();
-
-    const second = t.call(UUID, 'Initialize', {}, { timeoutMs: 25000 });
-    second.catch(() => undefined);
-    await flush();
-
-    expect(firstErrors).toHaveLength(1);
-    expect(firstErrors[0]?.errorCode).toBe(HardwareErrorCode.BleForceCleanRunPromise);
-
-    t.runPromise?.reject(new Error('settle second call'));
-    await flush();
-  });
-
-  test('late write failure of a superseded call keeps the successor as owner', async () => {
-    const { t, disconnectSpy } = createHarness();
-
-    // First call's write hangs; its promise is controlled by the test.
-    let rejectFirstWrite: ((e: Error) => void) | undefined;
-    const fakeBleTransport = {
-      writeCharacteristic: {
-        writeWithoutResponse: jest
-          .fn()
-          .mockImplementationOnce(
-            () =>
-              new Promise((_resolve, reject) => {
-                rejectFirstWrite = reject;
-              })
-          )
-          .mockImplementation(() => Promise.resolve()),
-      },
-      writeWithRetry: jest.fn(() => Promise.resolve()),
-    };
-    (t as any).getCachedTransport = () => fakeBleTransport;
-
-    const firstErrors: unknown[] = [];
-    const first = t.call(UUID, 'Initialize', {}, { timeoutMs: 25000 });
-    first.catch(e => firstErrors.push(e));
-    await flush();
-
-    // forceRun successor takes ownership while the first call is stuck writing.
-    const secondErrors: unknown[] = [];
-    const second = t.call(UUID, 'Initialize', {}, { timeoutMs: 5000 });
-    second.catch(e => secondErrors.push(e));
-    await flush();
-
-    // The first call's write now fails late; it must not clear the successor's slot.
-    rejectFirstWrite?.(new Error('late write failure'));
-    await flush();
-
-    expect(t.runPromise).not.toBeNull();
-
-    // The successor's genuine timeout must still tear the connection down.
-    jest.advanceTimersByTime(5000);
-    await flush();
-
-    expect(disconnectSpy).toHaveBeenCalledTimes(1);
-    expect(secondErrors).toHaveLength(1);
-  });
-
-  test('orphan timer left behind by cancel() must not disconnect the transport', async () => {
-    const { t, disconnectSpy } = createHarness();
-
-    // cancel() nulls the ownership slot without settling the deferred, so the
-    // call's response timer stays armed (reachable via DeviceCommands.dispose).
-    const errors: Array<{ errorCode?: unknown }> = [];
-    const p = t.call(UUID, 'GetFeatures', {}, { timeoutMs: 5000 });
-    p.catch(e => errors.push(e));
-    await flush();
-
-    t.cancel();
-
-    jest.advanceTimersByTime(5000);
-    await flush();
-
-    expect(disconnectSpy).not.toHaveBeenCalled();
-    expect(errors).toHaveLength(1);
-    expect(errors[0]?.errorCode).toBe(HardwareErrorCode.BleTimeoutError);
-  });
-
-  test('timeout on the active call still disconnects the transport', async () => {
-    const { t, disconnectSpy } = createHarness();
-
-    const errors: Array<{ errorCode?: unknown }> = [];
-    const p = t.call(UUID, 'GetFeatures', {}, { timeoutMs: 5000 });
-    p.catch(e => errors.push(e));
-    await flush();
-
-    jest.advanceTimersByTime(5000);
-    await flush();
-
-    expect(disconnectSpy).toHaveBeenCalledTimes(1);
-    expect(errors).toHaveLength(1);
-    expect(errors[0]?.errorCode).toBe(HardwareErrorCode.BleTimeoutError);
-  });
-});