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

Commit 14db3a08 authored by William Escande's avatar William Escande
Browse files

Move AdapterService*Test to truth assert

Bug: 292141273
Bug: 291815510
Test: atest AdapterServiceFactoryResetTest
Test: atest AdapterServiceTest
Test: atest AdapterServiceRestartTest
Change-Id: I94be95f61867fef4ca87bfb2c2b2a51a4212c829
parent b9b7a764
Loading
Loading
Loading
Loading
+1 −0
Original line number Original line Diff line number Diff line
@@ -28,6 +28,7 @@ java_defaults {
        "androidx.test.rules",
        "androidx.test.rules",
        "androidx.test.uiautomator_uiautomator",
        "androidx.test.uiautomator_uiautomator",
        "framework-bluetooth-pre-jarjar",
        "framework-bluetooth-pre-jarjar",
        "frameworks-base-testutils",
        "gson",
        "gson",
        "mockito-target",
        "mockito-target",
        "truth-prebuilt",
        "truth-prebuilt",
+37 −40
Original line number Original line Diff line number Diff line
@@ -18,6 +18,8 @@ package com.android.bluetooth.btservice;


import static android.Manifest.permission.BLUETOOTH_SCAN;
import static android.Manifest.permission.BLUETOOTH_SCAN;


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

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;
import static org.mockito.Mockito.*;


@@ -88,7 +90,6 @@ import com.android.internal.app.IBatteryStats;


import org.junit.After;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Ignore;
@@ -97,7 +98,6 @@ import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.MockitoAnnotations;


import java.util.Arrays;
import java.util.HashMap;
import java.util.HashMap;


@MediumTest
@MediumTest
@@ -188,15 +188,14 @@ public class AdapterServiceFactoryResetTest {
        if (Looper.myLooper() == null) {
        if (Looper.myLooper() == null) {
            Looper.prepare();
            Looper.prepare();
        }
        }
        Assert.assertNotNull(Looper.myLooper());
        assertThat(Looper.myLooper()).isNotNull();
        AdapterService adapterService = new AdapterService();
        AdapterService adapterService = new AdapterService();
        adapterService.initNative(false /* is_restricted */, false /* is_common_criteria_mode */,
        adapterService.initNative(false /* is_restricted */, false /* is_common_criteria_mode */,
                0 /* config_compare_result */, new String[0], false, "");
                0 /* config_compare_result */, new String[0], false, "");
        adapterService.cleanupNative();
        adapterService.cleanupNative();
        HashMap<String, HashMap<String, String>> adapterConfig = TestUtils.readAdapterConfig();
        HashMap<String, HashMap<String, String>> adapterConfig = TestUtils.readAdapterConfig();
        Assert.assertNotNull(adapterConfig);
        assertThat(adapterConfig).isNotNull();
        Assert.assertNotNull("metrics salt is null: " + adapterConfig.toString(),
        assertThat(AdapterServiceTest.getMetricsSalt(adapterConfig)).isNotNull();
                AdapterServiceTest.getMetricsSalt(adapterConfig));
    }
    }


    <T> void mockGetSystemService(String serviceName, Class<T> serviceClass, T mockService) {
    <T> void mockGetSystemService(String serviceName, Class<T> serviceClass, T mockService) {
@@ -211,7 +210,7 @@ public class AdapterServiceFactoryResetTest {
        if (Looper.myLooper() == null) {
        if (Looper.myLooper() == null) {
            Looper.prepare();
            Looper.prepare();
        }
        }
        Assert.assertNotNull(Looper.myLooper());
        assertThat(Looper.myLooper()).isNotNull();


        // Dispatch all async work through instrumentation so we can wait until
        // Dispatch all async work through instrumentation so we can wait until
        // it's drained below
        // it's drained below
@@ -332,7 +331,7 @@ public class AdapterServiceFactoryResetTest {
        mServiceBinder.registerCallback(mIBluetoothCallback, mAttributionSource);
        mServiceBinder.registerCallback(mIBluetoothCallback, mAttributionSource);


        mAdapterConfig = TestUtils.readAdapterConfig();
        mAdapterConfig = TestUtils.readAdapterConfig();
        Assert.assertNotNull(mAdapterConfig);
        assertThat(mAdapterConfig).isNotNull();
    }
    }


    @After
    @After
@@ -365,7 +364,7 @@ public class AdapterServiceFactoryResetTest {


    private void doEnable() {
    private void doEnable() {
        Log.e("AdapterServiceTest", "doEnable() start");
        Log.e("AdapterServiceTest", "doEnable() start");
        Assert.assertFalse(mAdapterService.getState() == BluetoothAdapter.STATE_ON);
        assertThat(mAdapterService.getState()).isNotEqualTo(BluetoothAdapter.STATE_ON);


        mAdapterService.enable(false);
        mAdapterService.enable(false);


@@ -412,9 +411,11 @@ public class AdapterServiceFactoryResetTest {
        verify(mMockContext, timeout(CONTEXT_SWITCH_MS).times(2))
        verify(mMockContext, timeout(CONTEXT_SWITCH_MS).times(2))
                .sendBroadcast(any(), eq(BLUETOOTH_SCAN), any(Bundle.class));
                .sendBroadcast(any(), eq(BLUETOOTH_SCAN), any(Bundle.class));
        final int scanMode = mServiceBinder.getScanMode(mAttributionSource);
        final int scanMode = mServiceBinder.getScanMode(mAttributionSource);
        Assert.assertTrue(scanMode == BluetoothAdapter.SCAN_MODE_CONNECTABLE
        assertThat(
                || scanMode == BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE);
                        scanMode == BluetoothAdapter.SCAN_MODE_CONNECTABLE
        Assert.assertTrue(mAdapterService.getState() == BluetoothAdapter.STATE_ON);
                                || scanMode == BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE)
                .isTrue();
        assertThat(mAdapterService.getState()).isEqualTo(BluetoothAdapter.STATE_ON);


        Log.e("AdapterServiceTest", "doEnable() complete success");
        Log.e("AdapterServiceTest", "doEnable() complete success");
    }
    }
@@ -438,29 +439,26 @@ public class AdapterServiceFactoryResetTest {
            + " after factory reset")
            + " after factory reset")
    @Test
    @Test
    public void testObfuscateBluetoothAddress_FactoryReset() {
    public void testObfuscateBluetoothAddress_FactoryReset() {
        Assert.assertFalse(mAdapterService.getState() == BluetoothAdapter.STATE_ON);
        assertThat(mAdapterService.getState()).isNotEqualTo(BluetoothAdapter.STATE_ON);
        BluetoothDevice device = TestUtils.getTestDevice(BluetoothAdapter.getDefaultAdapter(), 0);
        BluetoothDevice device = TestUtils.getTestDevice(BluetoothAdapter.getDefaultAdapter(), 0);
        byte[] obfuscatedAddress1 = mAdapterService.obfuscateAddress(device);
        byte[] obfuscatedAddress1 = mAdapterService.obfuscateAddress(device);
        Assert.assertTrue(obfuscatedAddress1.length > 0);
        assertThat(obfuscatedAddress1).isNotEmpty();
        Assert.assertFalse(AdapterServiceTest.isByteArrayAllZero(obfuscatedAddress1));
        assertThat(AdapterServiceTest.isByteArrayAllZero(obfuscatedAddress1)).isFalse();
        mServiceBinder.factoryReset(mAttributionSource);
        mServiceBinder.factoryReset(mAttributionSource);
        byte[] obfuscatedAddress2 = mAdapterService.obfuscateAddress(device);
        byte[] obfuscatedAddress2 = mAdapterService.obfuscateAddress(device);
        Assert.assertTrue(obfuscatedAddress2.length > 0);
        assertThat(obfuscatedAddress2).isNotEmpty();
        Assert.assertFalse(AdapterServiceTest.isByteArrayAllZero(obfuscatedAddress2));
        assertThat(AdapterServiceTest.isByteArrayAllZero(obfuscatedAddress2)).isFalse();
        Assert.assertFalse(Arrays.equals(obfuscatedAddress2,
        assertThat(obfuscatedAddress2).isNotEqualTo(obfuscatedAddress1);
                obfuscatedAddress1));
        doEnable();
        doEnable();
        byte[] obfuscatedAddress3 = mAdapterService.obfuscateAddress(device);
        byte[] obfuscatedAddress3 = mAdapterService.obfuscateAddress(device);
        Assert.assertTrue(obfuscatedAddress3.length > 0);
        assertThat(obfuscatedAddress3).isNotEmpty();
        Assert.assertFalse(AdapterServiceTest.isByteArrayAllZero(obfuscatedAddress3));
        assertThat(AdapterServiceTest.isByteArrayAllZero(obfuscatedAddress3)).isFalse();
        Assert.assertArrayEquals(obfuscatedAddress3,
        assertThat(obfuscatedAddress3).isEqualTo(obfuscatedAddress2);
                obfuscatedAddress2);
        mServiceBinder.factoryReset(mAttributionSource);
        mServiceBinder.factoryReset(mAttributionSource);
        byte[] obfuscatedAddress4 = mAdapterService.obfuscateAddress(device);
        byte[] obfuscatedAddress4 = mAdapterService.obfuscateAddress(device);
        Assert.assertTrue(obfuscatedAddress4.length > 0);
        assertThat(obfuscatedAddress4).isNotEmpty();
        Assert.assertFalse(AdapterServiceTest.isByteArrayAllZero(obfuscatedAddress4));
        assertThat(AdapterServiceTest.isByteArrayAllZero(obfuscatedAddress4)).isFalse();
        Assert.assertFalse(Arrays.equals(obfuscatedAddress4,
        assertThat(obfuscatedAddress4).isNotEqualTo(obfuscatedAddress3);
                obfuscatedAddress3));
    }
    }


    /**
    /**
@@ -468,25 +466,24 @@ public class AdapterServiceFactoryResetTest {
     * native layer
     * native layer
     */
     */
    @Test
    @Test
    public void testObfuscateBluetoothAddress_FactoryResetAndReloadNativeLayer() throws
    public void testObfuscateBluetoothAddress_FactoryResetAndReloadNativeLayer()
            PackageManager.NameNotFoundException {
            throws PackageManager.NameNotFoundException {
        byte[] metricsSalt1 = AdapterServiceTest.getMetricsSalt(mAdapterConfig);
        byte[] metricsSalt1 = AdapterServiceTest.getMetricsSalt(mAdapterConfig);
        Assert.assertNotNull(metricsSalt1);
        assertThat(metricsSalt1).isNotNull();
        Assert.assertFalse(mAdapterService.getState() == BluetoothAdapter.STATE_ON);
        assertThat(mAdapterService.getState()).isNotEqualTo(BluetoothAdapter.STATE_ON);
        BluetoothDevice device = TestUtils.getTestDevice(BluetoothAdapter.getDefaultAdapter(), 0);
        BluetoothDevice device = TestUtils.getTestDevice(BluetoothAdapter.getDefaultAdapter(), 0);
        byte[] obfuscatedAddress1 = mAdapterService.obfuscateAddress(device);
        byte[] obfuscatedAddress1 = mAdapterService.obfuscateAddress(device);
        Assert.assertTrue(obfuscatedAddress1.length > 0);
        assertThat(obfuscatedAddress1).isNotEmpty();
        Assert.assertFalse(AdapterServiceTest.isByteArrayAllZero(obfuscatedAddress1));
        assertThat(AdapterServiceTest.isByteArrayAllZero(obfuscatedAddress1)).isFalse();
        Assert.assertArrayEquals(AdapterServiceTest.obfuscateInJava(metricsSalt1, device),
        assertThat(AdapterServiceTest.obfuscateInJava(metricsSalt1, device))
                obfuscatedAddress1);
                .isEqualTo(obfuscatedAddress1);
        mServiceBinder.factoryReset(mAttributionSource);
        mServiceBinder.factoryReset(mAttributionSource);
        tearDown();
        tearDown();
        setUp();
        setUp();
        // Cannot verify metrics salt since it is not written to disk until native cleanup
        // Cannot verify metrics salt since it is not written to disk until native cleanup
        byte[] obfuscatedAddress2 = mAdapterService.obfuscateAddress(device);
        byte[] obfuscatedAddress2 = mAdapterService.obfuscateAddress(device);
        Assert.assertTrue(obfuscatedAddress2.length > 0);
        assertThat(obfuscatedAddress2).isNotEmpty();
        Assert.assertFalse(AdapterServiceTest.isByteArrayAllZero(obfuscatedAddress2));
        assertThat(AdapterServiceTest.isByteArrayAllZero(obfuscatedAddress2)).isFalse();
        Assert.assertFalse(Arrays.equals(obfuscatedAddress2,
        assertThat(obfuscatedAddress2).isNotEqualTo(obfuscatedAddress1);
                obfuscatedAddress1));
    }
    }
}
}
+24 −26
Original line number Original line Diff line number Diff line
@@ -16,6 +16,8 @@


package com.android.bluetooth.btservice;
package com.android.bluetooth.btservice;


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

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;
import static org.mockito.Mockito.*;


@@ -85,7 +87,6 @@ import com.android.internal.app.IBatteryStats;


import org.junit.After;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.AfterClass;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.Test;
@@ -174,15 +175,14 @@ public class AdapterServiceRestartTest {
        if (Looper.myLooper() == null) {
        if (Looper.myLooper() == null) {
            Looper.prepare();
            Looper.prepare();
        }
        }
        Assert.assertNotNull(Looper.myLooper());
        assertThat(Looper.myLooper()).isNotNull();
        AdapterService adapterService = new AdapterService();
        AdapterService adapterService = new AdapterService();
        adapterService.initNative(false /* is_restricted */, false /* is_common_criteria_mode */,
        adapterService.initNative(false /* is_restricted */, false /* is_common_criteria_mode */,
                0 /* config_compare_result */, new String[0], false, "");
                0 /* config_compare_result */, new String[0], false, "");
        adapterService.cleanupNative();
        adapterService.cleanupNative();
        HashMap<String, HashMap<String, String>> adapterConfig = TestUtils.readAdapterConfig();
        HashMap<String, HashMap<String, String>> adapterConfig = TestUtils.readAdapterConfig();
        Assert.assertNotNull(adapterConfig);
        assertThat(adapterConfig).isNotNull();
        Assert.assertNotNull("metrics salt is null: " + adapterConfig.toString(),
        assertThat(AdapterServiceTest.getMetricsSalt(adapterConfig)).isNotNull();
                AdapterServiceTest.getMetricsSalt(adapterConfig));
    }
    }


    <T> void mockGetSystemService(String serviceName, Class<T> serviceClass, T mockService) {
    <T> void mockGetSystemService(String serviceName, Class<T> serviceClass, T mockService) {
@@ -197,7 +197,7 @@ public class AdapterServiceRestartTest {
        if (Looper.myLooper() == null) {
        if (Looper.myLooper() == null) {
            Looper.prepare();
            Looper.prepare();
        }
        }
        Assert.assertNotNull(Looper.myLooper());
        assertThat(Looper.myLooper()).isNotNull();


        // Dispatch all async work through instrumentation so we can wait until
        // Dispatch all async work through instrumentation so we can wait until
        // it's drained below
        // it's drained below
@@ -312,7 +312,7 @@ public class AdapterServiceRestartTest {
        mServiceBinder.registerCallback(mIBluetoothCallback, mAttributionSource);
        mServiceBinder.registerCallback(mIBluetoothCallback, mAttributionSource);


        mAdapterConfig = TestUtils.readAdapterConfig();
        mAdapterConfig = TestUtils.readAdapterConfig();
        Assert.assertNotNull(mAdapterConfig);
        assertThat(mAdapterConfig).isNotNull();
    }
    }


    @After
    @After
@@ -345,27 +345,26 @@ public class AdapterServiceRestartTest {
            Log.e("AdapterServiceTest", "Sleep interrupted: " + e);
            Log.e("AdapterServiceTest", "Sleep interrupted: " + e);
        }
        }
        byte[] metricsSalt = AdapterServiceTest.getMetricsSalt(mAdapterConfig);
        byte[] metricsSalt = AdapterServiceTest.getMetricsSalt(mAdapterConfig);
        Assert.assertNotNull(metricsSalt);
        assertThat(metricsSalt).isNotNull();
        Assert.assertFalse(mAdapterService.getState() == BluetoothAdapter.STATE_ON);
        assertThat(mAdapterService.getState()).isEqualTo(BluetoothAdapter.STATE_OFF);
        BluetoothDevice device = TestUtils.getTestDevice(BluetoothAdapter.getDefaultAdapter(), 0);
        BluetoothDevice device = TestUtils.getTestDevice(BluetoothAdapter.getDefaultAdapter(), 0);
        byte[] obfuscatedAddress1 = mAdapterService.obfuscateAddress(device);
        byte[] obfuscatedAddress1 = mAdapterService.obfuscateAddress(device);
        Assert.assertTrue(obfuscatedAddress1.length > 0);
        assertThat(obfuscatedAddress1).isNotEmpty();
        Assert.assertFalse(AdapterServiceTest.isByteArrayAllZero(obfuscatedAddress1));
        assertThat(AdapterServiceTest.isByteArrayAllZero(obfuscatedAddress1)).isFalse();
        Assert.assertArrayEquals(AdapterServiceTest.obfuscateInJava(metricsSalt, device),
        assertThat(AdapterServiceTest.obfuscateInJava(metricsSalt, device))
                obfuscatedAddress1);
                .isEqualTo(obfuscatedAddress1);
        tearDown();
        tearDown();
        setUp();
        setUp();


        byte[] metricsSalt2 = AdapterServiceTest.getMetricsSalt(mAdapterConfig);
        byte[] metricsSalt2 = AdapterServiceTest.getMetricsSalt(mAdapterConfig);
        Assert.assertNotNull(metricsSalt2);
        assertThat(metricsSalt2).isNotNull();
        Assert.assertArrayEquals(metricsSalt, metricsSalt2);
        assertThat(metricsSalt).isEqualTo(metricsSalt2);


        Assert.assertFalse(mAdapterService.getState() == BluetoothAdapter.STATE_ON);
        assertThat(mAdapterService.getState()).isEqualTo(BluetoothAdapter.STATE_OFF);
        byte[] obfuscatedAddress2 = mAdapterService.obfuscateAddress(device);
        byte[] obfuscatedAddress2 = mAdapterService.obfuscateAddress(device);
        Assert.assertTrue(obfuscatedAddress2.length > 0);
        assertThat(obfuscatedAddress2).isNotEmpty();
        Assert.assertFalse(AdapterServiceTest.isByteArrayAllZero(obfuscatedAddress2));
        assertThat(AdapterServiceTest.isByteArrayAllZero(obfuscatedAddress2)).isFalse();
        Assert.assertArrayEquals(obfuscatedAddress2,
        assertThat(obfuscatedAddress2).isEqualTo(obfuscatedAddress1);
                obfuscatedAddress1);
    }
    }


    /**
    /**
@@ -375,14 +374,13 @@ public class AdapterServiceRestartTest {
    @Test
    @Test
    public void testgetMetricId_PersistentBetweenAdapterServiceInitialization() throws
    public void testgetMetricId_PersistentBetweenAdapterServiceInitialization() throws
            PackageManager.NameNotFoundException {
            PackageManager.NameNotFoundException {
        Assert.assertFalse(mAdapterService.getState() == BluetoothAdapter.STATE_ON);
        assertThat(mAdapterService.getState()).isEqualTo(BluetoothAdapter.STATE_OFF);
        BluetoothDevice device = TestUtils.getTestDevice(BluetoothAdapter.getDefaultAdapter(), 0);
        BluetoothDevice device = TestUtils.getTestDevice(BluetoothAdapter.getDefaultAdapter(), 0);
        int id1 = mAdapterService.getMetricId(device);
        int initialMetricId = mAdapterService.getMetricId(device);
        Assert.assertTrue(id1 > 0);
        assertThat(initialMetricId).isGreaterThan(0);
        tearDown();
        tearDown();
        setUp();
        setUp();
        Assert.assertFalse(mAdapterService.getState() == BluetoothAdapter.STATE_ON);
        assertThat(mAdapterService.getState()).isEqualTo(BluetoothAdapter.STATE_OFF);
        int id2 = mAdapterService.getMetricId(device);
        assertThat(mAdapterService.getMetricId(device)).isEqualTo(initialMetricId);
        Assert.assertEquals(id2, id1);
    }
    }
}
}
+67 −72

File changed.

Preview size limit exceeded, changes collapsed.