UNPKG

react-native-device-info/tests/getters.test.ts

Version:
27.7 kBPlain TextView Raw
1import { Platform } from 'react-native';
2import * as RNDeviceInfo from '../src';
3import { clearMemo } from '../src/internal/supported-platform-info';
4let mockNativeModule = jest.requireMock('../src/internal/nativeInterface').default;
5
6function makeTable(name: string) {
return [
  name, // name
  (RNDeviceInfo as any)[name], // asyncGetter
  (RNDeviceInfo as any)[`${name}Sync`], // syncGetter
  mockNativeModule[name], // asyncNativeGetter
  mockNativeModule[`${name}Sync`], // syncNativeGetter
];
14}
15const memoizedStringGetters = [
'getUniqueId',
'getInstanceId',
'getSerialNumber',
'getAndroidId',
'getBuildId',
'getInstallerPackageName',
'getBootloader',
'getDevice',
'getDisplay',
'getFingerprint',
'getHardware',
'getHost',
'getProduct',
'getTags',
'getType',
'getBaseOs',
'getSecurityPatch',
'getCodename',
'getIncremental',
'getInstallReferrer',
36].map(makeTable);
37memoizedStringGetters.push([
'getManufacturer',
RNDeviceInfo.getManufacturer,
RNDeviceInfo.getManufacturerSync,
mockNativeModule.getSystemManufacturer,
mockNativeModule.getSystemManufacturerSync,
43]);
44
45const nonMemoizedStringGetters = [
'getMacAddress',
'getIpAddress',
'getDeviceName',
'getPhoneNumber',
'getCarrier',
51].map(makeTable);
52
53describe('string getters', () => {
describe.each(memoizedStringGetters)(
  '%s*',
  (_name, asyncGetter, syncGetter, asyncNativeGetter, syncNativeGetter) => {
    beforeEach(() => {
      clearMemo();
      Platform.OS = 'android';
      asyncNativeGetter.mockClear();
      syncNativeGetter.mockClear();
    });
63
    it('should have an async version', () => {
      expect(typeof asyncGetter).toBe('function');
    });
67
    it('should have a sync version', () => {
      expect(typeof syncGetter).toBe('function');
    });
71
    it('should call native async module function', async () => {
      const resp = await asyncGetter();
      expect(resp).toEqual('unknown');
      expect(asyncNativeGetter).toHaveBeenCalled();
    });
77
    it('should call native sync module function', () => {
      const resp = syncGetter();
      expect(resp).toEqual('unknown');
      expect(syncNativeGetter).toHaveBeenCalled();
    });
83
    it('should not call native sync module function on unsupported OS', () => {
      Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
      const resp = syncGetter();
      expect(resp).toEqual('unknown');
      expect(syncNativeGetter).not.toHaveBeenCalled();
    });
90
    it('should not call native async module function on unsupported OS', async () => {
      Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
      const resp = await asyncGetter();
      expect(resp).toEqual('unknown');
      expect(asyncNativeGetter).not.toHaveBeenCalled();
    });
97
    it('should use memoized value if there exists one', async () => {
      const resp = await asyncGetter();
      const resp2 = syncGetter();
      expect(resp).toBe(resp2);
      expect(asyncNativeGetter).toHaveBeenCalled();
      expect(syncNativeGetter).not.toHaveBeenCalled();
    });
  }
);
107
describe.each(nonMemoizedStringGetters)(
  '%s*',
  (_name, asyncGetter, syncGetter, asyncNativeGetter, syncNativeGetter) => {
    beforeEach(() => {
      clearMemo();
      Platform.OS = 'android';
      asyncNativeGetter.mockClear();
      syncNativeGetter.mockClear();
    });
117
    it('should have an async version', () => {
      expect(typeof asyncGetter).toBe('function');
    });
121
    it('should have a sync version', () => {
      expect(typeof syncGetter).toBe('function');
    });
125
    it('should call native async module function', async () => {
      const resp = await asyncGetter();
      expect(resp).toEqual('unknown');
      expect(asyncNativeGetter).toHaveBeenCalled();
    });
131
    it('should call native sync module function', () => {
      const resp = syncGetter();
      expect(resp).toEqual('unknown');
      expect(syncNativeGetter).toHaveBeenCalled();
    });
137
    it('should not call native sync module function on unsupported OS', () => {
      Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
      const resp = syncGetter();
      expect(resp).toEqual('unknown');
      expect(syncNativeGetter).not.toHaveBeenCalled();
    });
144
    it('should not call native async module function on unsupported OS', async () => {
      Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
      const resp = await asyncGetter();
      expect(resp).toEqual('unknown');
      expect(asyncNativeGetter).not.toHaveBeenCalled();
    });
  }
);
153
const iosAndroidWindows = [
  'getDeviceId',
  'getModel',
  'getBrand',
  'getSystemVersion',
  'getBundleId',
  'getApplicationName',
  'getBuildNumber',
  'getVersion',
].map((name) => [name, (RNDeviceInfo as any)[name]]);
164
describe.each(iosAndroidWindows)('%s*', (_name, fn) => {
  beforeEach(() => {
    clearMemo();
    Platform.OS = 'android';
  });
  it('should exists as a function', () => {
    expect(typeof fn).toEqual('function');
  });
173
  it.each(['ios', 'android', 'windows'])('supports %s', (os) => {
    Platform.OS = os as any;
    expect(fn()).toEqual('unknown-test');
  });
});
179
const iosAndroid = ['getDeviceType', 'getDeviceTypeSync'].map((name) => [
  name,
  (RNDeviceInfo as any)[name],
]);
184
describe.each(iosAndroid)('%s*', (_name, fn) => {
  beforeEach(() => {
    clearMemo();
    Platform.OS = 'android';
  });
  it('should exists as a function', () => {
    expect(typeof fn).toEqual('function');
  });
193
  it.each(['ios', 'android'])('supports %s', (os) => {
    Platform.OS = os as any;
    expect(fn()).toEqual('unknown-test');
  });
});
199
describe('getMacAddress*', () => {
  beforeEach(() => {
    clearMemo();
    Platform.OS = 'ios';
    mockNativeModule.getMacAddress.mockClear();
    mockNativeModule.getMacAddressSync.mockClear();
  });
207
  it('should return expected value for iOS (async)', async () => {
    const resp = await RNDeviceInfo.getMacAddress();
    expect(resp).toEqual('02:00:00:00:00:00');
  });
212
  it('should not use native module for iOS (async)', async () => {
    await RNDeviceInfo.getMacAddress();
    expect(mockNativeModule.getMacAddress).not.toHaveBeenCalled();
  });
217
  it('should return expected value for iOS (sync)', () => {
    const resp = RNDeviceInfo.getMacAddressSync();
    expect(resp).toEqual('02:00:00:00:00:00');
  });
222
  it('should not use native module for iOS (sync)', () => {
    RNDeviceInfo.getMacAddressSync();
    expect(mockNativeModule.getMacAddressSync).not.toHaveBeenCalled();
  });
});
228
describe('getManufacturer*', () => {
  beforeEach(() => {
    clearMemo();
    Platform.OS = 'ios';
    mockNativeModule.getSystemManufacturer.mockClear();
    mockNativeModule.getSystemManufacturerSync.mockClear();
  });
236
  it('should return expected value for iOS (async)', async () => {
    const resp = await RNDeviceInfo.getManufacturer();
    expect(resp).toEqual('Apple');
  });
241
  it('should not use native module for iOS (async)', async () => {
    await RNDeviceInfo.getManufacturer();
    expect(mockNativeModule.getSystemManufacturer).not.toHaveBeenCalled();
  });
246
  it('should return expected value for iOS (sync)', () => {
    const resp = RNDeviceInfo.getManufacturerSync();
    expect(resp).toEqual('Apple');
  });
251
  it('should not use native module for iOS (sync)', () => {
    RNDeviceInfo.getManufacturerSync();
    expect(mockNativeModule.getSystemManufacturerSync).not.toHaveBeenCalled();
  });
});
257
describe('getDeviceToken', () => {
  beforeEach(() => {
    clearMemo();
    Platform.OS = 'ios';
    mockNativeModule.getDeviceToken.mockClear();
  });
264
  it('should exist as a function', () => {
    expect(typeof RNDeviceInfo.getDeviceToken).toBe('function');
  });
268
  it.each(['ios'])('should call native module for supported OS, %s', async (os) => {
    Platform.OS = os as any;
    await RNDeviceInfo.getDeviceToken();
    expect(mockNativeModule.getDeviceToken).toHaveBeenCalled();
  });
274
  it.each(['android', 'windows', 'web'])(
    'should return default value for unsupported OS, %s',
    async (os) => {
      Platform.OS = os as any;
      expect(await RNDeviceInfo.getDeviceToken()).toEqual('unknown');
      expect(mockNativeModule.getDeviceToken).not.toHaveBeenCalled();
    }
  );
});
284
describe('getUserAgent', () => {
  const getter = RNDeviceInfo.getUserAgent;
  const nativeGetter = mockNativeModule.getUserAgent;
288
  const supportedPlatforms = ['android', 'ios', 'web'];
290
  beforeEach(() => {
    clearMemo();
    nativeGetter.mockClear();
  });
295
  it('should exist as a function', () => {
    expect(typeof getter).toBe('function');
  });
299
  it.each(supportedPlatforms)(
    'should call native async module function for supported platform, %s',
    async (platform) => {
      Platform.OS = platform as any;
      const resp = await getter();
      expect(resp).toEqual('unknown');
      expect(nativeGetter).toHaveBeenCalled();
    }
  );
309
  it('should not call native module function on unsupported OS', async () => {
    Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
    const resp = await getter();
    expect(resp).toEqual('unknown');
    expect(nativeGetter).not.toHaveBeenCalled();
  });
});
317
describe('getUserAgentSync', () => {
  const getter = RNDeviceInfo.getUserAgentSync;
  const nativeGetter = mockNativeModule.getUserAgentSync;
321
  const supportedPlatforms = ['android', 'web'];
323
  beforeEach(() => {
    clearMemo();
    nativeGetter.mockClear();
  });
328
  it('should exist as a function', () => {
    expect(typeof getter).toBe('function');
  });
332
  it.each(supportedPlatforms)(
    'should call native async module function for supported platform, %s',
    (platform) => {
      Platform.OS = platform as any;
      const resp = getter();
      expect(resp).toEqual('unknown');
      expect(nativeGetter).toHaveBeenCalled();
    }
  );
342
  it('should not call native module function on unsupported OS', () => {
    Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
    const resp = getter();
    expect(resp).toEqual('unknown');
    expect(nativeGetter).not.toHaveBeenCalled();
  });
});
350
describe('getSystemName', () => {
  const getter = RNDeviceInfo.getSystemName;
  const supportedPlatforms = [
    ['ios', mockNativeModule.systemName],
    ['android', 'Android'],
    ['windows', 'Windows'],
  ];
358
  beforeEach(() => {
    clearMemo();
  });
362
  it('should exist as a function', () => {
    expect(typeof getter).toBe('function');
  });
366
  it.each(supportedPlatforms)(
    'should call native async module function for supported platform, %s',
    (platform, value) => {
      Platform.OS = platform as any;
      const resp = getter();
      expect(resp).toEqual(value);
    }
  );
375
  it('should not call native module function on unsupported OS', () => {
    Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
    const resp = getter();
    expect(resp).toEqual('unknown');
  });
});
382});
383
384const memoizedNumberGetters = [
'getApiLevel',
'getPreviewSdkInt',
'getFirstInstallTime',
'getLastUpdateTime',
'getTotalMemory',
'getMaxMemory',
391].map(makeTable);
392const nonMemoizedNumberGetters = [
'getUsedMemory',
'getFontScale',
'getFreeDiskStorage',
'getBatteryLevel',
'getTotalDiskCapacity',
398].map(makeTable);
399
400describe('number getters', () => {
describe.each(memoizedNumberGetters)(
  '%s*',
  (_name, asyncGetter, syncGetter, asyncNativeGetter, syncNativeGetter) => {
    beforeEach(() => {
      clearMemo();
      Platform.OS = 'android';
      asyncNativeGetter.mockClear();
      syncNativeGetter.mockClear();
    });
410
    it('should have an async version', () => {
      expect(typeof asyncGetter).toBe('function');
    });
414
    it('should have a sync version', () => {
      expect(typeof syncGetter).toBe('function');
    });
418
    it('should call native async module function', async () => {
      const resp = await asyncGetter();
      expect(resp).toEqual(-1);
      expect(asyncNativeGetter).toHaveBeenCalled();
    });
424
    it('should call native sync module function', () => {
      const resp = syncGetter();
      expect(resp).toEqual(-1);
      expect(syncNativeGetter).toHaveBeenCalled();
    });
430
    it('should not call native sync module function on unsupported OS', () => {
      Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
      const resp = syncGetter();
      expect(resp).toEqual(-1);
      expect(syncNativeGetter).not.toHaveBeenCalled();
    });
437
    it('should not call native async module function on unsupported OS', async () => {
      Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
      const resp = await asyncGetter();
      expect(resp).toEqual(-1);
      expect(asyncNativeGetter).not.toHaveBeenCalled();
    });
444
    it('should use memoized value if there exists one', async () => {
      const resp = await asyncGetter();
      const resp2 = syncGetter();
      expect(resp).toBe(resp2);
      expect(asyncNativeGetter).toHaveBeenCalled();
      expect(syncNativeGetter).not.toHaveBeenCalled();
    });
  }
);
454
describe.each(nonMemoizedNumberGetters)(
  '%s*',
  (_name, asyncGetter, syncGetter, asyncNativeGetter, syncNativeGetter) => {
    beforeEach(() => {
      clearMemo();
      Platform.OS = 'android';
      asyncNativeGetter.mockClear();
      syncNativeGetter.mockClear();
    });
464
    it('should have an async version', () => {
      expect(typeof asyncGetter).toBe('function');
    });
468
    it('should have a sync version', () => {
      expect(typeof syncGetter).toBe('function');
    });
472
    it('should call native async module function', async () => {
      const resp = await asyncGetter();
      expect(resp).toEqual(-1);
      expect(asyncNativeGetter).toHaveBeenCalled();
    });
478
    it('should call native sync module function', () => {
      const resp = syncGetter();
      expect(resp).toEqual(-1);
      expect(syncNativeGetter).toHaveBeenCalled();
    });
484
    it('should not call native sync module function on unsupported OS', () => {
      Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
      const resp = syncGetter();
      expect(resp).toEqual(-1);
      expect(syncNativeGetter).not.toHaveBeenCalled();
    });
491
    it('should not call native async module function on unsupported OS', async () => {
      Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
      const resp = await asyncGetter();
      expect(resp).toEqual(-1);
      expect(asyncNativeGetter).not.toHaveBeenCalled();
    });
  }
);
500});
501
502const memoizedBooleanGetters = ['isEmulator'].map(makeTable);
503const nonMemoizedBooleanGetters = [
'isCameraPresent',
'isPinOrFingerprintSet',
'isBatteryCharging',
'isAirplaneMode',
'isLocationEnabled',
'isHeadphonesConnected',
510].map(makeTable);
511
512describe('boolean getters', () => {
describe.each(memoizedBooleanGetters)(
  '%s*',
  (_name, asyncGetter, syncGetter, asyncNativeGetter, syncNativeGetter) => {
    beforeEach(() => {
      clearMemo();
      Platform.OS = 'android';
      asyncNativeGetter.mockClear();
      syncNativeGetter.mockClear();
    });
522
    it('should have an async version', () => {
      expect(typeof asyncGetter).toBe('function');
    });
526
    it('should have a sync version', () => {
      expect(typeof syncGetter).toBe('function');
    });
530
    it('should call native async module function', async () => {
      const resp = await asyncGetter();
      expect(resp).toEqual(false);
      expect(asyncNativeGetter).toHaveBeenCalled();
    });
536
    it('should call native sync module function', () => {
      const resp = syncGetter();
      expect(resp).toEqual(false);
      expect(syncNativeGetter).toHaveBeenCalled();
    });
542
    it('should not call native sync module function on unsupported OS', () => {
      Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
      const resp = syncGetter();
      expect(resp).toEqual(false);
      expect(syncNativeGetter).not.toHaveBeenCalled();
    });
549
    it('should not call native async module function on unsupported OS', async () => {
      Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
      const resp = await asyncGetter();
      expect(resp).toEqual(false);
      expect(asyncNativeGetter).not.toHaveBeenCalled();
    });
556
    it('should use memoized value if there exists one', async () => {
      const resp = await asyncGetter();
      const resp2 = syncGetter();
      expect(resp).toBe(resp2);
      expect(asyncNativeGetter).toHaveBeenCalled();
      expect(syncNativeGetter).not.toHaveBeenCalled();
    });
  }
);
566
describe.each(nonMemoizedBooleanGetters)(
  '%s*',
  (_name, asyncGetter, syncGetter, asyncNativeGetter, syncNativeGetter) => {
    beforeEach(() => {
      clearMemo();
      Platform.OS = 'android';
      asyncNativeGetter.mockClear();
      syncNativeGetter.mockClear();
    });
576
    it('should have an async version', () => {
      expect(typeof asyncGetter).toBe('function');
    });
580
    it('should have a sync version', () => {
      expect(typeof syncGetter).toBe('function');
    });
584
    it('should call native async module function', async () => {
      const resp = await asyncGetter();
      expect(resp).toEqual(false);
      expect(asyncNativeGetter).toHaveBeenCalled();
    });
590
    it('should call native sync module function', () => {
      const resp = syncGetter();
      expect(resp).toEqual(false);
      expect(syncNativeGetter).toHaveBeenCalled();
    });
596
    it('should not call native sync module function on unsupported OS', () => {
      Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
      const resp = syncGetter();
      expect(resp).toEqual(false);
      expect(syncNativeGetter).not.toHaveBeenCalled();
    });
603
    it('should not call native async module function on unsupported OS', async () => {
      Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
      const resp = await asyncGetter();
      expect(resp).toEqual(false);
      expect(asyncNativeGetter).not.toHaveBeenCalled();
    });
  }
);
612});
613
614const memoizedArrayGetters = [
[
  'supported32BitAbis', // name
  (RNDeviceInfo as any).supported32BitAbis, // asyncGetter
  (RNDeviceInfo as any).supported32BitAbisSync, // syncGetter
  mockNativeModule.getSupported32BitAbis, // asyncNativeGetter
  mockNativeModule.getSupported32BitAbisSync, // syncNativeGetter
],
[
  'supported64BitAbis', // name
  (RNDeviceInfo as any).supported64BitAbis, // asyncGetter
  (RNDeviceInfo as any).supported64BitAbisSync, // syncGetter
  mockNativeModule.getSupported64BitAbis, // asyncNativeGetter
  mockNativeModule.getSupported64BitAbisSync, // syncNativeGetter
],
629];
630
631const nonMemoizedArrayGetters = ['getSystemAvailableFeatures'].map(makeTable);
632
633describe('array getters', () => {
describe.each(memoizedArrayGetters)(
  '%s*',
  (_name, asyncGetter, syncGetter, asyncNativeGetter, syncNativeGetter) => {
    beforeEach(() => {
      clearMemo();
      Platform.OS = 'android';
      asyncNativeGetter.mockClear();
      syncNativeGetter.mockClear();
    });
643
    it('should have an async version', () => {
      expect(typeof asyncGetter).toBe('function');
    });
647
    it('should have a sync version', () => {
      expect(typeof syncGetter).toBe('function');
    });
651
    it('should call native async module function', async () => {
      const resp = await asyncGetter();
      expect(resp).toEqual([]);
      expect(asyncNativeGetter).toHaveBeenCalled();
    });
657
    it('should call native sync module function', () => {
      const resp = syncGetter();
      expect(resp).toEqual([]);
      expect(syncNativeGetter).toHaveBeenCalled();
    });
663
    it('should not call native sync module function on unsupported OS', () => {
      Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
      const resp = syncGetter();
      expect(resp).toEqual([]);
      expect(syncNativeGetter).not.toHaveBeenCalled();
    });
670
    it('should not call native async module function on unsupported OS', async () => {
      Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
      const resp = await asyncGetter();
      expect(resp).toEqual([]);
      expect(asyncNativeGetter).not.toHaveBeenCalled();
    });
677
    it('should use memoized value if there exists one', async () => {
      const resp = await asyncGetter();
      const resp2 = syncGetter();
      expect(resp).toBe(resp2);
      expect(asyncNativeGetter).toHaveBeenCalled();
      expect(syncNativeGetter).not.toHaveBeenCalled();
    });
  }
);
687
describe.each(nonMemoizedArrayGetters)(
  '%s*',
  (_name, asyncGetter, syncGetter, asyncNativeGetter, syncNativeGetter) => {
    beforeEach(() => {
      clearMemo();
      Platform.OS = 'android';
      asyncNativeGetter.mockClear();
      syncNativeGetter.mockClear();
    });
697
    it('should have an async version', () => {
      expect(typeof asyncGetter).toBe('function');
    });
701
    it('should have a sync version', () => {
      expect(typeof syncGetter).toBe('function');
    });
705
    it('should call native async module function', async () => {
      const resp = await asyncGetter();
      expect(resp).toEqual([]);
      expect(asyncNativeGetter).toHaveBeenCalled();
    });
711
    it('should call native sync module function', () => {
      const resp = syncGetter();
      expect(resp).toEqual([]);
      expect(syncNativeGetter).toHaveBeenCalled();
    });
717
    it('should not call native sync module function on unsupported OS', () => {
      Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
      const resp = syncGetter();
      expect(resp).toEqual([]);
      expect(syncNativeGetter).not.toHaveBeenCalled();
    });
724
    it('should not call native async module function on unsupported OS', async () => {
      Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
      const resp = await asyncGetter();
      expect(resp).toEqual([]);
      expect(asyncNativeGetter).not.toHaveBeenCalled();
    });
  }
);
733
describe('isTablet', () => {
  beforeEach(() => {
    clearMemo();
    Platform.OS = 'android';
  });
739
  it('should exist as function', () => {
    expect(typeof RNDeviceInfo.isTablet).toBe('function');
  });
743
  it.each(['android', 'ios', 'windows'])(
    'should support OS, %s, by return getter value',
    (os) => {
      Platform.OS = os as any;
      expect(RNDeviceInfo.isTablet()).toEqual(true);
    }
  );
751
  it.each(['web', 'GLaDOS'])('should return default value for unsupported OS, %s', (os) => {
    Platform.OS = os as any;
    expect(RNDeviceInfo.isTablet()).toEqual(false);
  });
});
757});
758
759describe('Object Getters', () => {
describe('getPowerState*', () => {
  const [, asyncGetter, syncGetter, asyncNativeGetter, syncNativeGetter] = makeTable(
    'getPowerState'
  );
  const supportedPlatforms = ['android', 'ios', 'windows', 'web'];
765
  beforeEach(() => {
    clearMemo();
    asyncNativeGetter.mockClear();
    syncNativeGetter.mockClear();
  });
771
  it('should have an async version', () => {
    expect(typeof asyncGetter).toBe('function');
  });
775
  it('should have a sync version', () => {
    expect(typeof syncGetter).toBe('function');
  });
779
  it.each(supportedPlatforms)(
    'should call native async module function for supported platform, %s',
    async (platform) => {
      Platform.OS = platform as any;
      const resp = await asyncGetter();
      expect(resp).toEqual({});
      expect(asyncNativeGetter).toHaveBeenCalled();
    }
  );
789
  it.each(supportedPlatforms)(
    'should call native sync module function for supported platform, %s',
    (platform) => {
      Platform.OS = platform as any;
      const resp = syncGetter();
      expect(resp).toEqual({});
      expect(syncNativeGetter).toHaveBeenCalled();
    }
  );
799
  it('should not call native sync module function on unsupported OS', () => {
    Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
    const resp = syncGetter();
    expect(resp).toEqual({});
    expect(syncNativeGetter).not.toHaveBeenCalled();
  });
806
  it('should not call native async module function on unsupported OS', async () => {
    Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
    const resp = await asyncGetter();
    expect(resp).toEqual({});
    expect(asyncNativeGetter).not.toHaveBeenCalled();
  });
});
814
describe('getAvailableLocationProviders*', () => {
  const [, asyncGetter, syncGetter, asyncNativeGetter, syncNativeGetter] = makeTable(
    'getAvailableLocationProviders'
  );
  const supportedPlatforms = ['android', 'ios'];
820
  beforeEach(() => {
    clearMemo();
    asyncNativeGetter.mockClear();
    syncNativeGetter.mockClear();
  });
826
  it('should have an async version', () => {
    expect(typeof asyncGetter).toBe('function');
  });
830
  it('should have a sync version', () => {
    expect(typeof syncGetter).toBe('function');
  });
834
  it.each(supportedPlatforms)(
    'should call native async module function for supported platform, %s',
    async (platform) => {
      Platform.OS = platform as any;
      const resp = await asyncGetter();
      expect(resp).toEqual({});
      expect(asyncNativeGetter).toHaveBeenCalled();
    }
  );
844
  it.each(supportedPlatforms)(
    'should call native sync module function for supported platform, %s',
    (platform) => {
      Platform.OS = platform as any;
      const resp = syncGetter();
      expect(resp).toEqual({});
      expect(syncNativeGetter).toHaveBeenCalled();
    }
  );
854
  it('should not call native sync module function on unsupported OS', () => {
    Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
    const resp = syncGetter();
    expect(resp).toEqual({});
    expect(syncNativeGetter).not.toHaveBeenCalled();
  });
861
  it('should not call native async module function on unsupported OS', async () => {
    Platform.OS = 'GLaDOS' as any; // setting OS to something that won't match anything
    const resp = await asyncGetter();
    expect(resp).toEqual({});
    expect(asyncNativeGetter).not.toHaveBeenCalled();
  });
});
869});
1	`import { Platform } from 'react-native';`
2	`import * as RNDeviceInfo from '../src';`
3	`import { clearMemo } from '../src/internal/supported-platform-info';`
4	`let mockNativeModule = jest.requireMock('../src/internal/nativeInterface').default;`
5
6	`function makeTable(name: string) {`
7	`return [`
8	`name, // name`
9	`(RNDeviceInfo as any)[name], // asyncGetter`
10	(RNDeviceInfo as any)[`${name}Sync`], // syncGetter
11	`mockNativeModule[name], // asyncNativeGetter`
12	mockNativeModule[`${name}Sync`], // syncNativeGetter
13	`];`
14	`}`
15	`const memoizedStringGetters = [`
16	`'getUniqueId',`
17	`'getInstanceId',`
18	`'getSerialNumber',`
19	`'getAndroidId',`
20	`'getBuildId',`
21	`'getInstallerPackageName',`
22	`'getBootloader',`
23	`'getDevice',`
24	`'getDisplay',`
25	`'getFingerprint',`
26	`'getHardware',`
27	`'getHost',`
28	`'getProduct',`
29	`'getTags',`
30	`'getType',`
31	`'getBaseOs',`
32	`'getSecurityPatch',`
33	`'getCodename',`
34	`'getIncremental',`
35	`'getInstallReferrer',`
36	`].map(makeTable);`
37	`memoizedStringGetters.push([`
38	`'getManufacturer',`
39	`RNDeviceInfo.getManufacturer,`
40	`RNDeviceInfo.getManufacturerSync,`