Merge "Optimize and clean up ScanControllerTest" into main

1 files changed, 319 insertions, 221 deletions

diff --git a/android/app/tests/unit/src/com/android/bluetooth/le_scan/ScanControllerTest.java b/android/app/tests/unit/src/com/android/bluetooth/le_scan/ScanControllerTest.java
index f1d428906b..8b6ec0548d 100644
--- a/android/app/tests/unit/src/com/android/bluetooth/le_scan/ScanControllerTest.java
+++ b/android/app/tests/unit/src/com/android/bluetooth/le_scan/ScanControllerTest.java
@@ -19,6 +19,8 @@ package com.android.bluetooth.le_scan;
 import static android.bluetooth.BluetoothProfile.STATE_CONNECTED;
 import static android.bluetooth.BluetoothProfile.STATE_CONNECTING;
 
+import static androidx.test.platform.app.InstrumentationRegistry.getInstrumentation;
+
 import static com.android.bluetooth.TestUtils.MockitoRule;
 import static com.android.bluetooth.TestUtils.getTestDevice;
 
@@ -55,7 +57,6 @@ import android.platform.test.flag.junit.SetFlagsRule;
 import androidx.test.filters.SmallTest;
 import androidx.test.platform.app.InstrumentationRegistry;
 
-import com.android.bluetooth.TestLooper;
 import com.android.bluetooth.TestUtils;
 import com.android.bluetooth.btservice.AdapterService;
 import com.android.bluetooth.btservice.CompanionManager;
@@ -79,23 +80,30 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
+import java.util.UUID;
 
 /** Test cases for {@link ScanController}. */
 @SmallTest
 @RunWith(TestParameterInjector.class)
 public class ScanControllerTest {
+
     @Rule public final MockitoRule mMockitoRule = new MockitoRule();
     @Rule public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
 
-    @Mock private ScannerMap mScannerMap;
-    @Mock private ScannerMap.ScannerApp mApp;
-    @Mock private PeriodicScanManager mPeriodicScanManager;
-    @Mock private ScanManager mScanManager;
-    @Mock private Resources mResources;
-    @Mock private AdapterService mAdapterService;
     @Mock private GattObjectsFactory mGattObjectsFactory;
     @Mock private ScanObjectsFactory mScanObjectsFactory;
+    @Mock private AdapterService mAdapterService;
     @Mock private GattNativeInterface mNativeInterface;
+    @Mock private PeriodicScanManager mPeriodicScanManager;
+    @Mock private Resources mResources;
+    @Mock private ScanManager mScanManager;
+    @Mock private ScannerMap mScannerMap;
+    @Mock private ScannerMap.ScannerApp mApp;
+
+    private static final int TEST_SCANNER_ID = 1;
+    private static final int TEST_STATUS = 0;
+    private static final int TEST_ACTION = 1;
+    private static final int TEST_CLIENT_IF = 2;
 
     private final BluetoothAdapter mAdapter =
             InstrumentationRegistry.getInstrumentation()
@@ -104,11 +112,10 @@ public class ScanControllerTest {
                     .getAdapter();
     private final BluetoothDevice mDevice = getTestDevice(89);
     private final AttributionSource mAttributionSource = mAdapter.getAttributionSource();
-    private final Context mContext =
-            InstrumentationRegistry.getInstrumentation().getTargetContext();
+    private final Context mContext = getInstrumentation().getTargetContext();
 
-    private ScanController mScanController;
     private CompanionManager mBtCompanionManager;
+    private ScanController mScanController;
 
     @Before
     public void setUp() throws Exception {
@@ -120,7 +127,6 @@ public class ScanControllerTest {
                 .when(mScanObjectsFactory)
                 .createScanManager(any(), any(), any(), any());
         doReturn(mPeriodicScanManager).when(mScanObjectsFactory).createPeriodicScanManager();
-
         doReturn(mResources).when(mAdapterService).getResources();
         doReturn(mContext.getPackageManager()).when(mAdapterService).getPackageManager();
         doReturn(mContext.getSharedPreferences("ScanControllerTest", Context.MODE_PRIVATE))
@@ -133,9 +139,6 @@ public class ScanControllerTest {
         mBtCompanionManager = new CompanionManager(mAdapterService, null);
         doReturn(mBtCompanionManager).when(mAdapterService).getCompanionManager();
 
-        TestLooper testLooper = new TestLooper();
-        testLooper.startAutoDispatch();
-
         mScanController = new ScanController(mAdapterService);
         mScanController.setScannerMap(mScannerMap);
     }
@@ -143,183 +146,21 @@ public class ScanControllerTest {
     @After
     public void tearDown() throws Exception {
         mScanController.cleanup();
-
         GattObjectsFactory.setInstanceForTesting(null);
         ScanObjectsFactory.setInstanceForTesting(null);
     }
 
     @Test
-    public void testParseBatchTimestamp() {
-        long timestampNanos = mScanController.parseTimestampNanos(new byte[] {-54, 7});
-        assertThat(timestampNanos).isEqualTo(99700000000L);
-    }
-
-    @Test
-    public void continuePiStartScan() {
-        int scannerId = 1;
-
-        ScanController.PendingIntentInfo pii =
-                new ScanController.PendingIntentInfo(
-                        null, new ScanSettings.Builder().build(), null, null, 0);
-        mApp.mInfo = pii;
-
-        AppScanStats appScanStats = mock(AppScanStats.class);
-        doReturn(appScanStats).when(mScannerMap).getAppScanStatsById(scannerId);
-
-        mScanController.continuePiStartScan(scannerId, mApp);
-
-        verify(appScanStats)
-                .recordScanStart(pii.settings(), pii.filters(), false, false, scannerId, null);
-        verify(mScanManager).startScan(any());
-    }
-
-    @Test
-    public void continuePiStartScanCheckUid() {
-        int scannerId = 1;
-
-        ScanController.PendingIntentInfo pii =
-                new ScanController.PendingIntentInfo(
-                        null, new ScanSettings.Builder().build(), null, null, 123);
-        mApp.mInfo = pii;
-
-        AppScanStats appScanStats = mock(AppScanStats.class);
-        doReturn(appScanStats).when(mScannerMap).getAppScanStatsById(scannerId);
-
-        mScanController.continuePiStartScan(scannerId, mApp);
-
-        verify(appScanStats)
-                .recordScanStart(pii.settings(), pii.filters(), false, false, scannerId, null);
+    public void notifyProfileConnectionStateChange_notify_scanManager() {
+        mScanController.notifyProfileConnectionStateChange(
+                BluetoothProfile.A2DP, STATE_CONNECTING, STATE_CONNECTED);
         verify(mScanManager)
-                .startScan(
-                        argThat(
-                                new ArgumentMatcher<ScanClient>() {
-                                    @Override
-                                    public boolean matches(ScanClient client) {
-                                        return pii.callingUid() == client.mAppUid;
-                                    }
-                                }));
-    }
-
-    @Test
-    public void onBatchScanReportsInternal_deliverBatchScan_full(
-            @TestParameter boolean expectResults) throws RemoteException {
-        int status = 1;
-        int scannerId = 2;
-        int reportType = ScanManager.SCAN_RESULT_TYPE_FULL;
-        int numRecords = 1;
-        byte[] recordData =
-                new byte[] {
-                    0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00, 0x00, 0x00
-                };
-
-        Set<ScanClient> scanClientSet = new HashSet<>();
-        ScanClient scanClient = new ScanClient(scannerId);
-        scanClient.mAssociatedDevices = new ArrayList<>();
-        if (expectResults) {
-            scanClient.mHasScanWithoutLocationPermission = true;
-        }
-        scanClientSet.add(scanClient);
-        doReturn(scanClientSet).when(mScanManager).getFullBatchScanQueue();
-        doReturn(mApp).when(mScannerMap).getById(scanClient.mScannerId);
-        IScannerCallback callback = mock(IScannerCallback.class);
-        mApp.mCallback = callback;
-
-        mScanController.onBatchScanReportsInternal(
-                status, scannerId, reportType, numRecords, recordData);
-        verify(mScanManager).callbackDone(scannerId, status);
-        if (expectResults) {
-            verify(callback).onBatchScanResults(any());
-        } else {
-            verify(callback, never()).onBatchScanResults(any());
-        }
-    }
-
-    @Test
-    public void onBatchScanReportsInternal_deliverBatchScan_truncated(
-            @TestParameter boolean expectResults) throws RemoteException {
-        int status = 1;
-        int scannerId = 2;
-        int reportType = ScanManager.SCAN_RESULT_TYPE_TRUNCATED;
-        int numRecords = 1;
-        byte[] recordData =
-                new byte[] {
-                    0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x04, 0x02, 0x02, 0x00, 0x00, 0x02
-                };
-
-        Set<ScanClient> scanClientSet = new HashSet<>();
-        ScanClient scanClient = new ScanClient(scannerId);
-        scanClient.mAssociatedDevices = new ArrayList<>();
-        if (expectResults) {
-            scanClient.mAssociatedDevices.add("02:00:00:00:00:00");
-        }
-        scanClientSet.add(scanClient);
-        doReturn(scanClientSet).when(mScanManager).getBatchScanQueue();
-        doReturn(mApp).when(mScannerMap).getById(scanClient.mScannerId);
-        IScannerCallback callback = mock(IScannerCallback.class);
-        mApp.mCallback = callback;
-
-        mScanController.onBatchScanReportsInternal(
-                status, scannerId, reportType, numRecords, recordData);
-        verify(mScanManager).callbackDone(scannerId, status);
-        if (expectResults) {
-            verify(callback).onBatchScanResults(any());
-        } else {
-            verify(callback, never()).onBatchScanResults(any());
-        }
-    }
-
-    @Test
-    public void enforceReportDelayFloor() {
-        long reportDelayFloorHigher = ScanController.DEFAULT_REPORT_DELAY_FLOOR + 1;
-        ScanSettings scanSettings =
-                new ScanSettings.Builder().setReportDelay(reportDelayFloorHigher).build();
-
-        ScanSettings newScanSettings = mScanController.enforceReportDelayFloor(scanSettings);
-
-        assertThat(newScanSettings.getReportDelayMillis())
-                .isEqualTo(scanSettings.getReportDelayMillis());
-
-        ScanSettings scanSettingsFloor = new ScanSettings.Builder().setReportDelay(1).build();
-
-        ScanSettings newScanSettingsFloor =
-                mScanController.enforceReportDelayFloor(scanSettingsFloor);
-
-        assertThat(newScanSettingsFloor.getReportDelayMillis())
-                .isEqualTo(ScanController.DEFAULT_REPORT_DELAY_FLOOR);
-    }
-
-    @Test
-    public void registerScanner() throws Exception {
-        IScannerCallback callback = mock(IScannerCallback.class);
-        WorkSource workSource = mock(WorkSource.class);
-
-        AppScanStats appScanStats = mock(AppScanStats.class);
-        doReturn(appScanStats).when(mScannerMap).getAppScanStatsByUid(Binder.getCallingUid());
-
-        mScanController.registerScanner(callback, workSource, mAttributionSource);
-        verify(mScannerMap)
-                .add(
-                        any(),
-                        eq(mAttributionSource),
-                        eq(workSource),
-                        eq(callback),
-                        any(),
-                        eq(mScanController));
-        verify(mScanManager).registerScanner(any());
-    }
-
-    @Test
-    public void flushPendingBatchResults() {
-        int scannerId = 3;
-
-        mScanController.flushPendingBatchResults(scannerId, mAttributionSource);
-        verify(mScanManager).flushBatchScanResults(new ScanClient(scannerId));
+                .handleBluetoothProfileConnectionStateChanged(
+                        BluetoothProfile.A2DP, STATE_CONNECTING, STATE_CONNECTED);
     }
 
     @Test
     public void onScanResult_remoteException_clientDied() throws Exception {
-        int scannerId = 1;
-
         int eventType = 0;
         int addressType = 0;
         String address = "02:00:00:00:00:00";
@@ -331,22 +172,19 @@ public class ScanControllerTest {
         int periodicAdvInt = 0;
         byte[] advData = new byte[0];
 
-        ScanClient scanClient = new ScanClient(scannerId);
+        ScanClient scanClient = new ScanClient(TEST_SCANNER_ID);
         scanClient.mHasNetworkSettingsPermission = true;
         scanClient.mSettings =
                 new ScanSettings.Builder()
                         .setCallbackType(ScanSettings.CALLBACK_TYPE_ALL_MATCHES)
                         .setLegacy(false)
                         .build();
-
         AppScanStats appScanStats = mock(AppScanStats.class);
         IScannerCallback callback = mock(IScannerCallback.class);
-
         mApp.mCallback = callback;
         mApp.mAppScanStats = appScanStats;
         scanClient.mStats = appScanStats;
         Set<ScanClient> scanClientSet = Collections.singleton(scanClient);
-
         doReturn(address).when(mAdapterService).getIdentityAddress(anyString());
         doReturn(scanClientSet).when(mScanManager).getRegularScanQueue();
         doReturn(mApp).when(mScannerMap).getById(scanClient.mScannerId);
@@ -369,66 +207,179 @@ public class ScanControllerTest {
                 address);
 
         assertThat(scanClient.mAppDied).isTrue();
-        verify(appScanStats).recordScanStop(scannerId);
+        verify(appScanStats).recordScanStop(TEST_SCANNER_ID);
     }
 
     @Test
-    public void registerSync() {
-        ScanResult scanResult = new ScanResult(mDevice, 1, 2, 3, 4, 5, 6, 7, null, 8);
-        int skip = 1;
-        int timeout = 2;
-        IPeriodicAdvertisingCallback callback = mock(IPeriodicAdvertisingCallback.class);
+    public void onScannerRegistered_success_callback() throws RemoteException {
+        long uuidLsb = 12345L;
+        long uuidMsb = 67890L;
+        UUID uuid = new UUID(uuidMsb, uuidLsb);
+        IScannerCallback callback = mock(IScannerCallback.class);
+        mApp.mCallback = callback;
+        doReturn(mApp).when(mScannerMap).getByUuid(uuid);
 
-        mScanController.registerSync(scanResult, skip, timeout, callback, mAttributionSource);
-        verify(mPeriodicScanManager).startSync(scanResult, skip, timeout, callback);
+        mScanController.onScannerRegistered(TEST_STATUS, TEST_SCANNER_ID, uuidLsb, uuidMsb);
+
+        verify(mApp).linkToDeath(any());
+        verify(callback).onScannerRegistered(TEST_STATUS, TEST_SCANNER_ID);
+        assertThat(mApp.mId).isEqualTo(TEST_SCANNER_ID);
     }
 
     @Test
-    public void transferSync() {
-        int serviceData = 1;
-        int syncHandle = 2;
+    public void onScanFilterEnableDisabled_callbackDone_scanManager() {
+        mScanController.onScanFilterEnableDisabled(TEST_ACTION, TEST_STATUS, TEST_CLIENT_IF);
+        verify(mScanManager).callbackDone(TEST_CLIENT_IF, TEST_STATUS);
+    }
 
-        mScanController.transferSync(mDevice, serviceData, syncHandle, mAttributionSource);
-        verify(mPeriodicScanManager).transferSync(mDevice, serviceData, syncHandle);
+    @Test
+    public void onScanFilterParamsConfigured_callbackDone_scanManager() {
+        int availableSpace = 3;
+
+        mScanController.onScanFilterParamsConfigured(
+                TEST_ACTION, TEST_STATUS, TEST_CLIENT_IF, availableSpace);
+        verify(mScanManager).callbackDone(TEST_CLIENT_IF, TEST_STATUS);
     }
 
     @Test
-    public void transferSetInfo() {
-        int serviceData = 1;
-        int advHandle = 2;
-        IPeriodicAdvertisingCallback callback = mock(IPeriodicAdvertisingCallback.class);
+    public void onScanFilterConfig_callbackDone_scanManager() {
+        int filterType = 3;
+        int availableSpace = 4;
 
-        mScanController.transferSetInfo(
-                mDevice, serviceData, advHandle, callback, mAttributionSource);
-        verify(mPeriodicScanManager).transferSetInfo(mDevice, serviceData, advHandle, callback);
+        mScanController.onScanFilterConfig(
+                TEST_ACTION, TEST_STATUS, TEST_CLIENT_IF, filterType, availableSpace);
+        verify(mScanManager).callbackDone(TEST_CLIENT_IF, TEST_STATUS);
     }
 
     @Test
-    public void unregisterSync() {
-        IPeriodicAdvertisingCallback callback = mock(IPeriodicAdvertisingCallback.class);
+    public void onBatchScanStorageConfigured_callbackDone_scanManager() {
+        mScanController.onBatchScanStorageConfigured(TEST_STATUS, TEST_CLIENT_IF);
+        verify(mScanManager).callbackDone(TEST_CLIENT_IF, TEST_STATUS);
+    }
 
-        mScanController.unregisterSync(callback, mAttributionSource);
-        verify(mPeriodicScanManager).stopSync(callback);
+    @Test
+    public void onBatchScanStartStopped_callbackDone_scanManager() {
+        int startStopAction = 0;
+
+        mScanController.onBatchScanStartStopped(startStopAction, TEST_STATUS, TEST_CLIENT_IF);
+        verify(mScanManager).callbackDone(TEST_CLIENT_IF, TEST_STATUS);
     }
 
     @Test
-    public void profileConnectionStateChanged_notifyScanManager() {
-        mScanController.notifyProfileConnectionStateChange(
-                BluetoothProfile.A2DP, STATE_CONNECTING, STATE_CONNECTED);
-        verify(mScanManager)
-                .handleBluetoothProfileConnectionStateChanged(
-                        BluetoothProfile.A2DP, STATE_CONNECTING, STATE_CONNECTED);
+    public void onBatchScanReportsInternal_deliverBatchScan(
+            @TestParameter boolean expectResults, @TestParameter boolean isTruncated)
+            throws RemoteException {
+        int reportType =
+                isTruncated
+                        ? ScanManager.SCAN_RESULT_TYPE_TRUNCATED
+                        : ScanManager.SCAN_RESULT_TYPE_FULL;
+        int numRecords = 1;
+        final byte[] recordData;
+        if (isTruncated) {
+            recordData =
+                    new byte[] {
+                        0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x04, 0x02, 0x02, 0x00, 0x00, 0x02
+                    };
+        } else {
+            recordData =
+                    new byte[] {
+                        0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x00, 0x00, 0x00, 0x00
+                    };
+        }
+
+        Set<ScanClient> scanClientSet = new HashSet<>();
+        ScanClient scanClient = new ScanClient(TEST_SCANNER_ID);
+        scanClient.mAssociatedDevices = new ArrayList<>();
+        if (expectResults) {
+            if (isTruncated) {
+                scanClient.mAssociatedDevices.add("02:00:00:00:00:00");
+            } else {
+                scanClient.mHasScanWithoutLocationPermission = true;
+            }
+        }
+        scanClientSet.add(scanClient);
+        if (isTruncated) {
+            doReturn(scanClientSet).when(mScanManager).getBatchScanQueue();
+        } else {
+            doReturn(scanClientSet).when(mScanManager).getFullBatchScanQueue();
+        }
+        doReturn(mApp).when(mScannerMap).getById(scanClient.mScannerId);
+        IScannerCallback callback = mock(IScannerCallback.class);
+        mApp.mCallback = callback;
+
+        mScanController.onBatchScanReportsInternal(
+                TEST_STATUS, TEST_SCANNER_ID, reportType, numRecords, recordData);
+        verify(mScanManager).callbackDone(TEST_SCANNER_ID, TEST_STATUS);
+        if (expectResults) {
+            verify(callback).onBatchScanResults(any());
+        } else {
+            verify(callback, never()).onBatchScanResults(any());
+        }
     }
 
     @Test
-    public void onTrackAdvFoundLost() throws Exception {
-        int scannerId = 1;
+    public void parseTimestampNanos() {
+        long timestampNanos = mScanController.parseTimestampNanos(new byte[] {-54, 7});
+        assertThat(timestampNanos).isEqualTo(99700000000L);
+    }
+
+    @Test
+    public void createOnTrackAdvFoundLostObject() {
         int advPacketLen = 1;
         byte[] advPacket = new byte[] {0x02};
         int scanResponseLen = 3;
         byte[] scanResponse = new byte[] {0x04};
         int filtIndex = 5;
+        int advState = ScanController.ADVT_STATE_ONFOUND;
+        int advInfoPresent = 7;
+        String address = "00:11:22:33:FF:EE";
+        int addrType = BluetoothDevice.ADDRESS_TYPE_RANDOM;
+        int txPower = 9;
+        int rssiValue = 10;
+        int timeStamp = 11;
+
+        AdvtFilterOnFoundOnLostInfo advtFilterOnFoundOnLostInfo =
+                new AdvtFilterOnFoundOnLostInfo(
+                        TEST_SCANNER_ID,
+                        advPacketLen,
+                        ByteString.copyFrom(advPacket),
+                        scanResponseLen,
+                        ByteString.copyFrom(scanResponse),
+                        filtIndex,
+                        advState,
+                        advInfoPresent,
+                        address,
+                        addrType,
+                        txPower,
+                        rssiValue,
+                        timeStamp);
 
+        AdvtFilterOnFoundOnLostInfo advtFilterOnFoundOnLostInfoCreated =
+                mScanController.createOnTrackAdvFoundLostObject(
+                        TEST_SCANNER_ID,
+                        advPacketLen,
+                        advPacket,
+                        scanResponseLen,
+                        scanResponse,
+                        filtIndex,
+                        advState,
+                        advInfoPresent,
+                        address,
+                        addrType,
+                        txPower,
+                        rssiValue,
+                        timeStamp);
+
+        assertThat(advtFilterOnFoundOnLostInfo).isEqualTo(advtFilterOnFoundOnLostInfoCreated);
+    }
+
+    @Test
+    public void onTrackAdvFoundLost() throws RemoteException {
+        int advPacketLen = 1;
+        byte[] advPacket = new byte[] {0x02};
+        int scanResponseLen = 3;
+        byte[] scanResponse = new byte[] {0x04};
+        int filtIndex = 5;
         int advState = ScanController.ADVT_STATE_ONFOUND;
         int advInfoPresent = 7;
         String address = "00:11:22:33:FF:EE";
@@ -437,7 +388,7 @@ public class ScanControllerTest {
         int rssiValue = 10;
         int timeStamp = 11;
 
-        ScanClient scanClient = new ScanClient(scannerId);
+        ScanClient scanClient = new ScanClient(TEST_SCANNER_ID);
         scanClient.mHasNetworkSettingsPermission = true;
         scanClient.mSettings =
                 new ScanSettings.Builder()
@@ -448,15 +399,14 @@ public class ScanControllerTest {
 
         ScannerMap.ScannerApp app = mock(ScannerMap.ScannerApp.class);
         IScannerCallback callback = mock(IScannerCallback.class);
-
         app.mCallback = callback;
 
-        doReturn(app).when(mScannerMap).getById(scannerId);
+        doReturn(app).when(mScannerMap).getById(TEST_SCANNER_ID);
         doReturn(scanClientSet).when(mScanManager).getRegularScanQueue();
 
         AdvtFilterOnFoundOnLostInfo advtFilterOnFoundOnLostInfo =
                 new AdvtFilterOnFoundOnLostInfo(
-                        scannerId,
+                        TEST_SCANNER_ID,
                         advPacketLen,
                         ByteString.copyFrom(advPacket),
                         scanResponseLen,
@@ -477,4 +427,152 @@ public class ScanControllerTest {
         assertThat(result.getValue().getDevice().getAddress()).isEqualTo(address);
         assertThat(result.getValue().getDevice().getAddressType()).isEqualTo(addrType);
     }
+
+    @Test
+    public void registerScanner() {
+        IScannerCallback callback = mock(IScannerCallback.class);
+        WorkSource workSource = mock(WorkSource.class);
+        AppScanStats appScanStats = mock(AppScanStats.class);
+        doReturn(appScanStats).when(mScannerMap).getAppScanStatsByUid(Binder.getCallingUid());
+
+        mScanController.registerScanner(callback, workSource, mAttributionSource);
+        verify(mScannerMap)
+                .add(
+                        any(),
+                        eq(mAttributionSource),
+                        eq(workSource),
+                        eq(callback),
+                        any(),
+                        eq(mScanController));
+        verify(mScanManager).registerScanner(any());
+    }
+
+    @Test
+    public void unregisterScanner() {
+        mScanController.unregisterScanner(TEST_SCANNER_ID, mAttributionSource);
+
+        verify(mScannerMap).remove(TEST_SCANNER_ID);
+        verify(mScanManager).unregisterScanner(TEST_SCANNER_ID);
+    }
+
+    @Test
+    public void continuePiStartScan() {
+        ScanController.PendingIntentInfo pii =
+                new ScanController.PendingIntentInfo(
+                        null, new ScanSettings.Builder().build(), null, null, 0);
+        mApp.mInfo = pii;
+
+        AppScanStats appScanStats = mock(AppScanStats.class);
+        doReturn(appScanStats).when(mScannerMap).getAppScanStatsById(TEST_SCANNER_ID);
+
+        mScanController.continuePiStartScan(TEST_SCANNER_ID, mApp);
+
+        verify(appScanStats)
+                .recordScanStart(
+                        pii.settings(), pii.filters(), false, false, TEST_SCANNER_ID, null);
+        verify(mScanManager).startScan(any());
+    }
+
+    @Test
+    public void continuePiStartScanCheckUid() {
+        ScanController.PendingIntentInfo pii =
+                new ScanController.PendingIntentInfo(
+                        null, new ScanSettings.Builder().build(), null, null, 123);
+        mApp.mInfo = pii;
+
+        AppScanStats appScanStats = mock(AppScanStats.class);
+        doReturn(appScanStats).when(mScannerMap).getAppScanStatsById(TEST_SCANNER_ID);
+
+        mScanController.continuePiStartScan(TEST_SCANNER_ID, mApp);
+
+        verify(appScanStats)
+                .recordScanStart(
+                        pii.settings(), pii.filters(), false, false, TEST_SCANNER_ID, null);
+        verify(mScanManager)
+                .startScan(
+                        argThat(
+                                new ArgumentMatcher<ScanClient>() {
+                                    @Override
+                                    public boolean matches(ScanClient client) {
+                                        return pii.callingUid() == client.mAppUid;
+                                    }
+                                }));
+    }
+
+    @Test
+    public void flushPendingBatchResults() {
+        mScanController.flushPendingBatchResults(TEST_SCANNER_ID, mAttributionSource);
+        verify(mScanManager).flushBatchScanResults(new ScanClient(TEST_SCANNER_ID));
+    }
+
+    @Test
+    public void registerSync() {
+        ScanResult scanResult = new ScanResult(mDevice, 1, 2, 3, 4, 5, 6, 7, null, 8);
+        int skip = 1;
+        int timeout = 2;
+        IPeriodicAdvertisingCallback callback = mock(IPeriodicAdvertisingCallback.class);
+
+        mScanController.registerSync(scanResult, skip, timeout, callback, mAttributionSource);
+        verify(mPeriodicScanManager).startSync(scanResult, skip, timeout, callback);
+    }
+
+    @Test
+    public void unregisterSync() {
+        IPeriodicAdvertisingCallback callback = mock(IPeriodicAdvertisingCallback.class);
+
+        mScanController.unregisterSync(callback, mAttributionSource);
+        verify(mPeriodicScanManager).stopSync(callback);
+    }
+
+    @Test
+    public void transferSync() {
+        int serviceData = 1;
+        int syncHandle = 2;
+
+        mScanController.transferSync(mDevice, serviceData, syncHandle, mAttributionSource);
+        verify(mPeriodicScanManager).transferSync(mDevice, serviceData, syncHandle);
+    }
+
+    @Test
+    public void transferSetInfo() {
+        int serviceData = 1;
+        int advHandle = 2;
+        IPeriodicAdvertisingCallback callback = mock(IPeriodicAdvertisingCallback.class);
+
+        mScanController.transferSetInfo(
+                mDevice, serviceData, advHandle, callback, mAttributionSource);
+        verify(mPeriodicScanManager).transferSetInfo(mDevice, serviceData, advHandle, callback);
+    }
+
+    @Test
+    public void enforceReportDelayFloor() {
+        long reportDelayFloorHigher = ScanController.DEFAULT_REPORT_DELAY_FLOOR + 1;
+        ScanSettings scanSettings =
+                new ScanSettings.Builder().setReportDelay(reportDelayFloorHigher).build();
+        ScanSettings newScanSettings = mScanController.enforceReportDelayFloor(scanSettings);
+
+        assertThat(newScanSettings.getReportDelayMillis())
+                .isEqualTo(scanSettings.getReportDelayMillis());
+
+        ScanSettings scanSettingsFloor = new ScanSettings.Builder().setReportDelay(1).build();
+        ScanSettings newScanSettingsFloor =
+                mScanController.enforceReportDelayFloor(scanSettingsFloor);
+
+        assertThat(newScanSettingsFloor.getReportDelayMillis())
+                .isEqualTo(ScanController.DEFAULT_REPORT_DELAY_FLOOR);
+    }
+
+    @Test
+    public void dumpRegisterId_doesNotCrash() {
+        StringBuilder sb = new StringBuilder();
+        mScanController.dumpRegisterId(sb);
+        assertThat(sb.toString()).isNotNull();
+    }
+
+    @Test
+    public void dump_doesNotCrash() {
+        StringBuilder sb = new StringBuilder();
+        mScanController.dump(sb);
+        assertThat(sb.toString()).isNotNull();
+    }
 }