Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1a9df7ac authored by Hyundo Moon's avatar Hyundo Moon Committed by Automerger Merge Worker
Browse files

Merge "Set up unit test environment for BassClientService" am: a01109d5 

Original change: https://android-review.googlesource.com/c/platform/packages/modules/Bluetooth/+/2070888



Change-Id: Ic84a3bee0d815a01e54555a700533ede87cefc85
Ignore-AOSP-First: this is an automerge
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents ccd03b13 a01109d5

android/app/src/com/android/bluetooth/bass_client/BassClientService.java

+11 −7
Original line number Diff line number Diff line
@@ -25,7 +25,6 @@ import android.bluetooth.BluetoothStatusCodes; 
import android.bluetooth.BluetoothUuid;

import android.bluetooth.IBluetoothLeBroadcastAssistant;

import android.bluetooth.IBluetoothLeBroadcastAssistantCallback;

import android.bluetooth.le.BluetoothLeScanner;

import android.bluetooth.le.ScanCallback;

import android.bluetooth.le.ScanFilter;

import android.bluetooth.le.ScanRecord;
@@ -260,8 +259,7 @@ public class BassClientService extends ProfileService { 
        }

        synchronized (mStateMachines) {

            for (BassClientStateMachine sm : mStateMachines.values()) {

                sm.doQuit();

                sm.cleanup();

                BassObjectsFactory.getInstance().destroyStateMachine(sm);

            }

            mStateMachines.clear();

        }
@@ -369,8 +367,8 @@ public class BassClientService extends ProfileService { 
                return null;

            }

            log("Creating a new state machine for " + device);

            stateMachine = BassClientStateMachine.make(device,

                    this, mStateMachinesThread.getLooper());

            stateMachine = BassObjectsFactory.getInstance().makeStateMachine(

                    device, this, mStateMachinesThread.getLooper());

            mStateMachines.put(device, stateMachine);

            return stateMachine;

        }
@@ -620,7 +618,8 @@ public class BassClientService extends ProfileService { 
            Log.e(TAG, "startSearchingForSources: Adapter is NULL");

            return;

        }

        BluetoothLeScanner scanner = mBluetoothAdapter.getBluetoothLeScanner();

        BluetoothLeScannerWrapper scanner = BassObjectsFactory.getInstance()

                .getBluetoothLeScannerWrapper(mBluetoothAdapter);

        if (scanner == null) {

            Log.e(TAG, "startLeScan: cannot get BluetoothLeScanner");

            return;
@@ -686,7 +685,12 @@ public class BassClientService extends ProfileService { 
     */

    public void stopSearchingForSources() {

        log("stopSearchingForSources");

        BluetoothLeScanner scanner = mBluetoothAdapter.getBluetoothLeScanner();

        if (mBluetoothAdapter == null) {

            Log.e(TAG, "stopSearchingForSources: Adapter is NULL");

            return;

        }

        BluetoothLeScannerWrapper scanner = BassObjectsFactory.getInstance()

                .getBluetoothLeScannerWrapper(mBluetoothAdapter);

        if (scanner == null) {

            Log.e(TAG, "startLeScan: cannot get BluetoothLeScanner");

            return;

android/app/src/com/android/bluetooth/bass_client/BassClientStateMachine.java

+12 −1
Original line number Diff line number Diff line
@@ -100,7 +100,8 @@ import java.util.Map; 
import java.util.Scanner;

import java.util.stream.IntStream;



class BassClientStateMachine extends StateMachine {

@VisibleForTesting

public class BassClientStateMachine extends StateMachine {

    private static final String TAG = "BassClientStateMachine";

    private static final byte[] REMOTE_SCAN_STOP = {00};

    private static final byte[] REMOTE_SCAN_START = {01};
@@ -201,6 +202,16 @@ class BassClientStateMachine extends StateMachine { 
        return BassclientSm;

    }



    static void destroy(BassClientStateMachine stateMachine) {

        Log.i(TAG, "destroy");

        if (stateMachine == null) {

            Log.w(TAG, "destroy(), stateMachine is null");

            return;

        }

        stateMachine.doQuit();

        stateMachine.cleanup();

    }



    public void doQuit() {

        log("doQuit for device " + mDevice);

        quitNow();

android/app/src/com/android/bluetooth/bass_client/BassObjectsFactory.java

0 → 100644
+96 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2022 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package com.android.bluetooth.bass_client;



import android.bluetooth.BluetoothAdapter;

import android.bluetooth.BluetoothDevice;

import android.os.Looper;

import android.util.Log;



import com.android.bluetooth.Utils;

import com.android.internal.annotations.VisibleForTesting;



/**

 * Factory class for object initialization to help with unit testing

 */

public class BassObjectsFactory {

    private static final String TAG = BassObjectsFactory.class.getSimpleName();

    private static BassObjectsFactory sInstance;

    private static final Object INSTANCE_LOCK = new Object();



    private BassObjectsFactory() {}



    /**

     * Get the singleton instance of object factory

     *

     * @return the singleton instance, guaranteed not null

     */

    public static BassObjectsFactory getInstance() {

        synchronized (INSTANCE_LOCK) {

            if (sInstance == null) {

                sInstance = new BassObjectsFactory();

            }

        }

        return sInstance;

    }



    /**

     * Allow unit tests to substitute BassObjectsFactory with a test instance

     *

     * @param objectsFactory a test instance of the BassObjectsFactory

     */

    @VisibleForTesting

    public static void setInstanceForTesting(BassObjectsFactory objectsFactory) {

        Utils.enforceInstrumentationTestMode();

        synchronized (INSTANCE_LOCK) {

            Log.d(TAG, "setInstanceForTesting(), set to " + objectsFactory);

            sInstance = objectsFactory;

        }

    }



    /**

     * Make a {@link BassClientStateMachine}

     *

     * @param device the remote device associated with this state machine

     * @param svc the bass client service

     * @param looper the thread that the state machine is supposed to run on

     * @return a state machine that is initialized and started, ready to go

     */

    public BassClientStateMachine makeStateMachine(BluetoothDevice device,

            BassClientService svc, Looper looper) {

        return BassClientStateMachine.make(device, svc, looper);

    }



    /**

     * Destroy a state machine

     *

     * @param stateMachine to be destroyed. Cannot be used after this call.

     */

    public void destroyStateMachine(BassClientStateMachine stateMachine) {

        BassClientStateMachine.destroy(stateMachine);

    }



    /**

     * Get a {@link BluetoothLeScannerWrapper} object

     *

     * @param adapter bluetooth adapter

     * @return a bluetooth LE scanner

     */

    public BluetoothLeScannerWrapper getBluetoothLeScannerWrapper(BluetoothAdapter adapter) {

        return new BluetoothLeScannerWrapper(adapter.getBluetoothLeScanner());

    }

}

android/app/src/com/android/bluetooth/bass_client/BluetoothLeScannerWrapper.java

0 → 100644
+51 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2022 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package com.android.bluetooth.bass_client;



import android.bluetooth.le.BluetoothLeScanner;

import android.bluetooth.le.ScanCallback;

import android.bluetooth.le.ScanFilter;

import android.bluetooth.le.ScanSettings;



import java.util.List;



/**

 * Helper class to mock {@link BluetoothLeScanner} which is final.

 */

public class BluetoothLeScannerWrapper {



    BluetoothLeScanner mBluetoothLeScanner;



    BluetoothLeScannerWrapper(BluetoothLeScanner scanner) {

        mBluetoothLeScanner = scanner;

    }



    /**

     * Starts Bluetooth LE scanning

     */

    public void startScan(List<ScanFilter> filters, ScanSettings settings,

            final ScanCallback callback) {

        mBluetoothLeScanner.startScan(filters, settings, callback);

    }



    /**

     * Stops Bluetooth LE scanning

     */

    public void stopScan(ScanCallback callback) {

        mBluetoothLeScanner.stopScan(callback);

    }

}

android/app/tests/unit/src/com/android/bluetooth/bass_client/BassClientServiceTest.java

0 → 100644
+222 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2022 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package com.android.bluetooth.bass_client;



import static com.google.common.truth.Truth.assertThat;



import static org.mockito.ArgumentMatchers.eq;

import static org.mockito.Mockito.any;

import static org.mockito.Mockito.anyString;

import static org.mockito.Mockito.doAnswer;

import static org.mockito.Mockito.doReturn;

import static org.mockito.Mockito.mock;

import static org.mockito.Mockito.never;

import static org.mockito.Mockito.notNull;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.when;



import android.bluetooth.BluetoothAdapter;

import android.bluetooth.BluetoothDevice;

import android.bluetooth.BluetoothProfile;

import android.bluetooth.BluetoothUuid;

import android.bluetooth.le.ScanFilter;

import android.content.Context;

import android.os.ParcelUuid;



import androidx.test.InstrumentationRegistry;

import androidx.test.filters.MediumTest;

import androidx.test.rule.ServiceTestRule;

import androidx.test.runner.AndroidJUnit4;



import com.android.bluetooth.TestUtils;

import com.android.bluetooth.btservice.AdapterService;

import com.android.bluetooth.btservice.storage.DatabaseManager;



import org.junit.After;

import org.junit.Before;

import org.junit.Rule;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;

import org.mockito.Spy;



import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Set;



/**

 * Tests for {@link BassClientService}

 */

@MediumTest

@RunWith(AndroidJUnit4.class)

public class BassClientServiceTest {

    private static final int MAX_HEADSET_CONNECTIONS = 5;

    private static final ParcelUuid[] FAKE_SERVICE_UUIDS = {BluetoothUuid.BASS};

    private static final int ASYNC_CALL_TIMEOUT_MILLIS = 250;



    private final HashMap<BluetoothDevice, BassClientStateMachine> mStateMachines = new HashMap<>();



    private Context mTargetContext;

    private BassClientService mBassClientService;

    private BluetoothAdapter mBluetoothAdapter;

    private BluetoothDevice mCurrentDevice;



    @Rule public final ServiceTestRule mServiceRule = new ServiceTestRule();



    @Spy private BassObjectsFactory mObjectsFactory = BassObjectsFactory.getInstance();

    @Mock private AdapterService mAdapterService;

    @Mock private DatabaseManager mDatabaseManager;

    @Mock private BluetoothLeScannerWrapper mBluetoothLeScannerWrapper;



    @Before

    public void setUp() throws Exception {

        mTargetContext = InstrumentationRegistry.getTargetContext();

        MockitoAnnotations.initMocks(this);

        TestUtils.setAdapterService(mAdapterService);

        BassObjectsFactory.setInstanceForTesting(mObjectsFactory);



        doReturn(new ParcelUuid[]{BluetoothUuid.BASS}).when(mAdapterService)

                .getRemoteUuids(any(BluetoothDevice.class));

        // This line must be called to make sure relevant objects are initialized properly

        mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();



        // Mock methods in AdapterService

        doReturn(FAKE_SERVICE_UUIDS).when(mAdapterService)

                .getRemoteUuids(any(BluetoothDevice.class));

        doReturn(BluetoothDevice.BOND_BONDED).when(mAdapterService)

                .getBondState(any(BluetoothDevice.class));

        doReturn(mDatabaseManager).when(mAdapterService).getDatabase();

        doReturn(true, false).when(mAdapterService).isStartedProfile(anyString());

        doAnswer(invocation -> {

            Set<BluetoothDevice> keys = mStateMachines.keySet();

            return keys.toArray(new BluetoothDevice[keys.size()]);

        }).when(mAdapterService).getBondedDevices();



        // Mock methods in BassObjectsFactory

        doAnswer(invocation -> {

            assertThat(mCurrentDevice).isNotNull();

            final BassClientStateMachine stateMachine = mock(BassClientStateMachine.class);

            mStateMachines.put(mCurrentDevice, stateMachine);

            return stateMachine;

        }).when(mObjectsFactory).makeStateMachine(any(), any(), any());

        doReturn(mBluetoothLeScannerWrapper).when(mObjectsFactory)

                .getBluetoothLeScannerWrapper(any());



        TestUtils.startService(mServiceRule, BassClientService.class);

        mBassClientService = BassClientService.getBassClientService();

        assertThat(mBassClientService).isNotNull();

    }



    @After

    public void tearDown() throws Exception {

        TestUtils.stopService(mServiceRule, BassClientService.class);

        mBassClientService = BassClientService.getBassClientService();

        assertThat(mBassClientService).isNull();

        mStateMachines.clear();

        mCurrentDevice = null;

        BassObjectsFactory.setInstanceForTesting(null);

        TestUtils.clearAdapterService(mAdapterService);

    }



    /**

     * Test to verify that BassClientService can be successfully started

     */

    @Test

    public void testGetBassClientService() {

        assertThat(mBassClientService).isEqualTo(BassClientService.getBassClientService());

        // Verify default connection and audio states

        mCurrentDevice = TestUtils.getTestDevice(mBluetoothAdapter, 0);

        assertThat(mBassClientService.getConnectionState(mCurrentDevice))

                .isEqualTo(BluetoothProfile.STATE_DISCONNECTED);

    }



    /**

     * Test connecting to a test device.

     *  - service.connect() should return false

     *  - bassClientStateMachine.sendMessage(CONNECT) should be called.

     */

    @Test

    public void testConnect() {

        when(mDatabaseManager.getProfileConnectionPolicy(any(BluetoothDevice.class),

                eq(BluetoothProfile.LE_AUDIO_BROADCAST_ASSISTANT)))

                .thenReturn(BluetoothProfile.CONNECTION_POLICY_ALLOWED);

        mCurrentDevice = TestUtils.getTestDevice(mBluetoothAdapter, 0);



        assertThat(mBassClientService.connect(mCurrentDevice)).isTrue();

        verify(mObjectsFactory).makeStateMachine(

                eq(mCurrentDevice), eq(mBassClientService), any());

        BassClientStateMachine stateMachine = mStateMachines.get(mCurrentDevice);

        assertThat(stateMachine).isNotNull();

        verify(stateMachine).sendMessage(BassClientStateMachine.CONNECT);

    }



    /**

     * Test connecting to a null device.

     *  - service.connect() should return false.

     */

    @Test

    public void testConnect_nullDevice() {

        when(mDatabaseManager.getProfileConnectionPolicy(any(BluetoothDevice.class),

                eq(BluetoothProfile.LE_AUDIO_BROADCAST_ASSISTANT)))

                .thenReturn(BluetoothProfile.CONNECTION_POLICY_ALLOWED);

        BluetoothDevice nullDevice = null;



        assertThat(mBassClientService.connect(nullDevice)).isFalse();

    }



    /**

     * Test connecting to a device when the connection policy is unknown.

     *  - service.connect() should return false.

     */

    @Test

    public void testConnect_whenConnectionPolicyIsUnknown() {

        when(mDatabaseManager.getProfileConnectionPolicy(any(BluetoothDevice.class),

                eq(BluetoothProfile.LE_AUDIO_BROADCAST_ASSISTANT)))

                .thenReturn(BluetoothProfile.CONNECTION_POLICY_UNKNOWN);

        mCurrentDevice = TestUtils.getTestDevice(mBluetoothAdapter, 0);

        assertThat(mCurrentDevice).isNotNull();



        assertThat(mBassClientService.connect(mCurrentDevice)).isFalse();

    }



    /**

     * Test whether service.startSearchingForSources() calls BluetoothLeScannerWrapper.startScan().

     */

    @Test

    public void testStartSearchingForSources() {

        List<ScanFilter> scanFilters = new ArrayList<>();

        mBassClientService.startSearchingForSources(scanFilters);



        verify(mBluetoothLeScannerWrapper).startScan(notNull(), notNull(), notNull());

    }



    /**

     * Test whether service.startSearchingForSources() does not call

     * BluetoothLeScannerWrapper.startScan() when the scanner instance cannot be achieved.

     */

    @Test

    public void testStartSearchingForSources_whenScannerIsNull() {

        doReturn(null).when(mObjectsFactory).getBluetoothLeScannerWrapper(any());

        List<ScanFilter> scanFilters = new ArrayList<>();



        mBassClientService.startSearchingForSources(scanFilters);



        verify(mBluetoothLeScannerWrapper, never()).startScan(any(), any(), any());

    }

}