xref: /cts/tests/tests/carrierapi/src/android/carrierapi/cts/CarrierApiTest.java

/*
 * Copyright (C) 2016 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 android.carrierapi.cts;

import static android.carrierapi.cts.FcpTemplate.FILE_IDENTIFIER;
import static android.carrierapi.cts.IccUtils.bytesToHexString;
import static android.carrierapi.cts.IccUtils.hexStringToBytes;
import static android.carrierapi.cts.IccUtils.isSeriouslyLetterOrDigit;
import static android.telephony.IccOpenLogicalChannelResponse.INVALID_CHANNEL;
import static android.telephony.IccOpenLogicalChannelResponse.STATUS_MISSING_RESOURCE;
import static android.telephony.IccOpenLogicalChannelResponse.STATUS_NO_ERROR;
import static android.telephony.SubscriptionManager.PHONE_NUMBER_SOURCE_CARRIER;
import static android.telephony.TelephonyManager.DATA_ENABLED_REASON_THERMAL;
import static android.telephony.TelephonyManager.DATA_ENABLED_REASON_USER;

import static com.android.compatibility.common.util.UiccUtil.UiccCertificate.CTS_UICC_2021;

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

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.junit.Assume.assumeFalse;
import static org.junit.Assume.assumeNoException;
import static org.junit.Assume.assumeTrue;

import android.content.BroadcastReceiver;
import android.content.ContentProviderClient;
import android.content.ContentValues;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.database.Cursor;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Build;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.ParcelUuid;
import android.os.PersistableBundle;
import android.platform.test.annotations.SystemUserOnly;
import android.platform.test.flag.junit.CheckFlagsRule;
import android.platform.test.flag.junit.DeviceFlagsValueProvider;
import android.provider.Telephony;
import android.provider.VoicemailContract;
import android.telephony.AccessNetworkConstants;
import android.telephony.AvailableNetworkInfo;
import android.telephony.CarrierConfigManager;
import android.telephony.IccOpenLogicalChannelResponse;
import android.telephony.PhoneStateListener;
import android.telephony.SignalStrengthUpdateRequest;
import android.telephony.SignalThresholdInfo;
import android.telephony.SubscriptionInfo;
import android.telephony.SubscriptionManager;
import android.telephony.SubscriptionPlan;
import android.telephony.TelephonyManager;
import android.telephony.data.NetworkSlicingConfig;
import android.telephony.ims.ImsException;
import android.telephony.ims.ImsManager;
import android.telephony.ims.ImsMmTelManager;
import android.telephony.ims.ImsStateCallback;
import android.telephony.ims.RegistrationManager;
import android.util.Base64;
import android.util.Log;

import androidx.test.runner.AndroidJUnit4;

import com.android.compatibility.common.util.MediaUtils;
import com.android.compatibility.common.util.PollingCheck;
import com.android.compatibility.common.util.ShellIdentityUtils;
import com.android.compatibility.common.util.UiccUtil;
import com.android.internal.telephony.flags.Flags;

import com.google.common.collect.Range;

import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;

import java.io.IOException;
import java.time.ZonedDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Consumer;
import java.util.stream.Collectors;

import javax.annotation.Nonnull;

/**
 * Unit tests for various carrier-related APIs.
 *
 * <p>Test using `atest CtsCarrierApiTestCases:CarrierApiTest` or `make cts -j64 && cts-tradefed run
 * cts -m CtsCarrierApiTestCases --test android.carrierapi.cts.CarrierApiTest`
 */
// TODO(b/130187425): Split CarrierApiTest apart to have separate test classes for functionality
@RunWith(AndroidJUnit4.class)
public class CarrierApiTest extends BaseCarrierApiTest {
    @Rule
    public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();

    private static final String TAG = "CarrierApiTest";

    private TelephonyManager mTelephonyManager;
    private CarrierConfigManager mCarrierConfigManager;
    private SubscriptionManager mSubscriptionManager;
    private ContentProviderClient mVoicemailProvider;
    private ContentProviderClient mStatusProvider;
    private PackageManager mPackageManager;
    private Uri mVoicemailContentUri;
    private Uri mStatusContentUri;
    private String selfPackageName;
    private HandlerThread mListenerThread;
    private ImsManager mImsManager;
    private ImsMmTelManager mMmTelManager;

    private static final int MAX_RETRIES = 10;
    // The minimum allocatable logical channel number, per TS 102 221 Section 11.1.17.1
    private static final int MIN_LOGICAL_CHANNEL = 1;
    // The maximum allocatable logical channel number in the standard range, per TS 102 221 Section
    // 11.1.17.1
    private static final int MAX_LOGICAL_CHANNEL = 3;
    private static final int MAX_LOGICAL_CHANNEL_EXTENDED = 19;
    // Class bytes. The logical channel used should be included for bits b2b1. TS 102 221 Table 11.5
    private static final int CLA_GET_RESPONSE = 0x00;
    private static final int CLA_MANAGE_CHANNEL = 0x00;
    private static final int CLA_READ_BINARY = 0x00;
    private static final int CLA_SELECT = 0x00;
    private static final int CLA_STATUS = 0x80;
    private static final String CLA_STATUS_STRING = "80";
    // APDU Instruction Bytes. TS 102 221 Section 10.1.2
    private static final int COMMAND_GET_RESPONSE = 0xC0;
    private static final int COMMAND_MANAGE_CHANNEL = 0x70;
    private static final int COMMAND_READ_BINARY = 0xB0;
    private static final int COMMAND_SELECT = 0xA4;
    private static final int COMMAND_STATUS = 0xF2;
    private static final String COMMAND_STATUS_STRING = "F2";
    // Status words. TS 102 221 Section 10.2.1
    private static final byte[] STATUS_NORMAL = {(byte) 0x90, (byte) 0x00};
    private static final String STATUS_NORMAL_STRING = "9000";
    private static final String STATUS_BYTES_REMAINING = "61";
    private static final String STATUS_WARNING_A = "62";
    private static final String STATUS_WARNING_B = "63";
    private static final String STATUS_CHANNEL_NOT_SUPPORTED = "6881";
    private static final String STATUS_FILE_NOT_FOUND = "6a82";
    private static final String STATUS_INCORRECT_PARAMETERS = "6a86";
    private static final String STATUS_WRONG_PARAMETERS = "6b00";
    private static final Set<String> INVALID_PARAMETERS_STATUSES =
            new HashSet<>(Arrays.asList(STATUS_INCORRECT_PARAMETERS, STATUS_WRONG_PARAMETERS));
    private static final String STATUS_WRONG_CLASS = "6e00";
    private static final String STATUS_TECHNICAL_PROBLEM = "6f00";
    // File ID for the EF ICCID. TS 102 221
    private static final String ICCID_FILE_ID = "2FE2";
    // File ID for the EF_PL. TS 131 102 Annex A
    private static final String PL_FILE_ID = "2F05";
    // File ID for the master file. TS 102 221
    private static final String MF_FILE_ID = "3F00";
    private static final int MF_FILE_ID_HEX = 0x3F00;
    // File ID for the MF Access Rule Reference. TS 102 221
    private static final String MF_ARR_FILE_ID = "2F06";
    private static final String ALPHA_TAG_A = "tagA";
    private static final String ALPHA_TAG_B = "tagB";
    private static final String NUMBER_A = "1234567890";
    private static final String NUMBER_B = "0987654321";
    private static final String TESTING_PLMN = "12345";
    private static final int PL_ENTRY_LENGTH = 2;
    private static final int HEX_BYTES_PER_CHAR = 2;

    private static final String EAP_SIM_AKA_RAND = "11111111111111111111111111111111";

    // Derived from TS 134 108#8.1.2. Based on EAP_SIM_AKA_RAND and assumed K value of
    // 000102030405060708090A0B0C0D0E0F, per TS 134 108#8.2
    private static final String EAP_AKA_AUTN = "12351417161900001130131215141716";

    // EAP-AKA Response Format: [DB][Length][RES][Length][CK][Length][IK]
    private static final int EAP_AKA_RESPONSE_LENGTH = 1 + 1 + 16 + 1 + 16 + 1 + 16;

    // Derived from TS 134 108#8.1.2. Based on EAP_SIM_AKA_RAND and assumed K value of
    // 000102030405060708090A0B0C0D0E0F, per TS 134 108#8.2.
    // Format: [DB][Length][RES][Length][CK][Length][IK]
    private static final String EXPECTED_EAP_AKA_RESULT =
            "DB10111013121514171619181B1A1D1C1F1E"
                    + "101013121514171619181B1A1D1C1F1E11"
                    + "1013121514171619181B1A1D1C1F1E1110";

    // Derived from TS 134 108#8.1.2 and TS 133 102#6.8.1.2. Based on EAP_SIM_AKA_RAND and assumed K
    // value of 000102030405060708090A0B0C0D0E0F, per TS 134 108#8.2.
    // Format: [Length][SRES][Length][Kc]
    private static final String EXPECTED_EAP_SIM_RESULT = "0400000000080000000000000000";

    private static final int DSDS_PHONE_COUNT = 2;
    private static final String PLMN_A = "123456";
    private static final String PLMN_B = "78901";
    private static final List<String> FPLMN_TEST = Arrays.asList(PLMN_A, PLMN_B);
    private static final int MAX_FPLMN_NUM = 1000;
    private static final int MIN_FPLMN_NUM = 3;

    private static final ZonedDateTime SUB_PLAN_START =
            ZonedDateTime.parse("2024-01-01T00:00:00.000Z");
    private static final ZonedDateTime SUB_PLAN_END =
            ZonedDateTime.parse("2029-12-31T00:00:00.000Z");
    private static final CharSequence SUB_PLAN_TITLE = "CTS test subscription plan";
    private static final CharSequence SUB_PLAN_SUMMARY = "CTS test subscription plan summary";
    private static final long SUB_PLAN_EXPIRATION_DURATION = 36000L;
    private static final long SUB_PLAN_DATA_LIMIT_BYTES = 1200000L;

    @Before
    public void setUp() throws Exception {
        Context context = getContext();
        mTelephonyManager = context.getSystemService(TelephonyManager.class);
        mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class);
        mSubscriptionManager = context.getSystemService(SubscriptionManager.class);
        selfPackageName = context.getPackageName();
        mVoicemailContentUri = VoicemailContract.Voicemails.buildSourceUri(selfPackageName);
        mVoicemailProvider =
                context.getContentResolver().acquireContentProviderClient(mVoicemailContentUri);
        mStatusContentUri = VoicemailContract.Status.buildSourceUri(selfPackageName);
        mStatusProvider =
                context.getContentResolver().acquireContentProviderClient(mStatusContentUri);
        mPackageManager = context.getPackageManager();
        mImsManager = context.getSystemService(ImsManager.class);
        if (mImsManager != null) {
            final int subId = SubscriptionManager.getDefaultSubscriptionId();
            mMmTelManager = mImsManager.getImsMmTelManager(subId);
        }
        mListenerThread = new HandlerThread("CarrierApiTest");
        mListenerThread.start();
    }

    @After
    public void tearDown() throws Exception {
        if (!werePreconditionsSatisfied()) return;

        if (mListenerThread != null) {
            mListenerThread.quit();
        }
        try {
            mStatusProvider.delete(mStatusContentUri, null, null);
            mVoicemailProvider.delete(mVoicemailContentUri, null, null);
        } catch (Exception e) {
            Log.w(TAG, "Failed to clean up voicemail tables in tearDown", e);
        }
    }

    @Test
    public void testSimCardPresent() {
        assertWithMessage("This test requires a SIM card")
                .that(mTelephonyManager.getSimState())
                .isNotEqualTo(TelephonyManager.SIM_STATE_ABSENT);
    }

    @Test
    public void testHasCarrierPrivileges() {
        assertWithMessage(NO_CARRIER_PRIVILEGES_FAILURE_MESSAGE)
                .that(mTelephonyManager.hasCarrierPrivileges())
                .isTrue();
    }

    private static void assertUpdateAvailableNetworkSuccess(int value) {
        assertThat(value).isEqualTo(TelephonyManager.UPDATE_AVAILABLE_NETWORKS_SUCCESS);
    }

    private static void assertUpdateAvailableNetworkNoOpportunisticSubAvailable(int value) {
        assertThat(value)
                .isEqualTo(
                        TelephonyManager.UPDATE_AVAILABLE_NETWORKS_NO_OPPORTUNISTIC_SUB_AVAILABLE);
    }

    private static void assertSetOpportunisticSubSuccess(int value) {
        assertThat(value).isEqualTo(TelephonyManager.SET_OPPORTUNISTIC_SUB_SUCCESS);
    }

    private int getFirstActivateCarrierPrivilegedSubscriptionId() {
        int subId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
        List<SubscriptionInfo> subscriptionInfos =
                mSubscriptionManager.getActiveSubscriptionInfoList();
        if (subscriptionInfos != null) {
            for (SubscriptionInfo info : subscriptionInfos) {
                TelephonyManager telephonyManager =
                        mTelephonyManager.createForSubscriptionId(info.getSubscriptionId());
                if (telephonyManager.hasCarrierPrivileges()) {
                    subId = info.getSubscriptionId();
                    return subId;
                }
            }
        }
        return subId;
    }

    @Test
    public void testUpdateAvailableNetworksWithCarrierPrivilege() {
        int subIdWithCarrierPrivilege = getFirstActivateCarrierPrivilegedSubscriptionId();
        int activeSubscriptionInfoCount =
                ShellIdentityUtils.invokeMethodWithShellPermissions(
                        mSubscriptionManager, (tm) -> tm.getActiveSubscriptionInfoCount());
        if (mTelephonyManager.getPhoneCount() == 1) {
            return;
        }

        /* TODO: b/145993690 */
        if (mTelephonyManager.getPhoneCount() == 2 && activeSubscriptionInfoCount != 2) {
            /* This test requires two SIM cards */
            return;
        }
        if (subIdWithCarrierPrivilege == SubscriptionManager.INVALID_SUBSCRIPTION_ID) {
            /* This test requires SIM with carrier privilege */
            return;
        }

        List<SubscriptionInfo> subscriptionInfoList =
                mSubscriptionManager.getOpportunisticSubscriptions();
        List<String> mccMncs = new ArrayList<String>();
        List<Integer> bands = new ArrayList<Integer>();
        List<AvailableNetworkInfo> availableNetworkInfos = new ArrayList<AvailableNetworkInfo>();
        Consumer<Integer> callbackSuccess = CarrierApiTest::assertUpdateAvailableNetworkSuccess;
        Consumer<Integer> callbackNoOpportunisticSubAvailable =
                CarrierApiTest::assertUpdateAvailableNetworkNoOpportunisticSubAvailable;
        Consumer<Integer> setOpCallbackSuccess = CarrierApiTest::assertSetOpportunisticSubSuccess;
        if (subscriptionInfoList == null
                || subscriptionInfoList.size() == 0
                || !mSubscriptionManager.isActiveSubscriptionId(
                        subscriptionInfoList.get(0).getSubscriptionId())) {
            try {
                AvailableNetworkInfo availableNetworkInfo =
                        new AvailableNetworkInfo(
                                subIdWithCarrierPrivilege,
                                AvailableNetworkInfo.PRIORITY_HIGH,
                                mccMncs,
                                bands);
                availableNetworkInfos.add(availableNetworkInfo);
                // Call updateAvailableNetworks without opportunistic subscription.
                // callbackNoOpportunisticSubAvailable is expected to be triggered
                // and the return value will be checked against
                // UPDATE_AVAILABLE_NETWORKS_NO_OPPORTUNISTIC_SUB_AVAILABLE
                mTelephonyManager.updateAvailableNetworks(
                        availableNetworkInfos,
                        AsyncTask.SERIAL_EXECUTOR,
                        callbackNoOpportunisticSubAvailable);
            } finally {
                // clear all the operations at the end of test.
                availableNetworkInfos.clear();
                mTelephonyManager.updateAvailableNetworks(
                        availableNetworkInfos,
                        AsyncTask.SERIAL_EXECUTOR,
                        callbackNoOpportunisticSubAvailable);
            }
        } else {
            // This is case of DSDS phone, one active opportunistic subscription and one
            // active primary subscription.
            int resultSubId;
            try {
                AvailableNetworkInfo availableNetworkInfo =
                        new AvailableNetworkInfo(
                                subscriptionInfoList.get(0).getSubscriptionId(),
                                AvailableNetworkInfo.PRIORITY_HIGH,
                                mccMncs,
                                bands);
                availableNetworkInfos.add(availableNetworkInfo);
                mTelephonyManager.updateAvailableNetworks(
                        availableNetworkInfos, AsyncTask.SERIAL_EXECUTOR, callbackSuccess);
                // wait for the data change to take effect
                waitForMs(500);
                // Call setPreferredData and reconfirm with getPreferred data
                // that the same is updated.
                int preferSubId = subscriptionInfoList.get(0).getSubscriptionId();
                mTelephonyManager.setPreferredOpportunisticDataSubscription(
                        preferSubId, false, AsyncTask.SERIAL_EXECUTOR, setOpCallbackSuccess);
                // wait for the data change to take effect
                waitForMs(500);
                resultSubId = mTelephonyManager.getPreferredOpportunisticDataSubscription();
                assertThat(resultSubId).isEqualTo(preferSubId);
            } finally {
                // clear all the operations at the end of test.
                availableNetworkInfos.clear();
                mTelephonyManager.updateAvailableNetworks(
                        availableNetworkInfos, AsyncTask.SERIAL_EXECUTOR, callbackSuccess);
                waitForMs(500);
                mTelephonyManager.setPreferredOpportunisticDataSubscription(
                        SubscriptionManager.DEFAULT_SUBSCRIPTION_ID,
                        false,
                        AsyncTask.SERIAL_EXECUTOR,
                        callbackSuccess);
                waitForMs(500);
                resultSubId = mTelephonyManager.getPreferredOpportunisticDataSubscription();
                assertThat(resultSubId).isEqualTo(SubscriptionManager.DEFAULT_SUBSCRIPTION_ID);
            }
        }
    }

    public static void waitForMs(long ms) {
        try {
            Thread.sleep(ms);
        } catch (InterruptedException e) {
            Log.d(TAG, "InterruptedException while waiting: " + e);
        }
    }

    @Test
    public void testGetIccAuthentication() {
        // EAP-SIM rand is 16 bytes.
        String base64Challenge = "ECcTqwuo6OfY8ddFRboD9WM=";
        String base64Challenge2 = "EMNxjsFrPCpm+KcgCmQGnwQ=";

        try {
            assertWithMessage("getIccAuthentication should return null for empty data.")
                    .that(
                            mTelephonyManager.getIccAuthentication(
                                    TelephonyManager.APPTYPE_USIM,
                                    TelephonyManager.AUTHTYPE_EAP_AKA,
                                    ""))
                    .isNull();
            String response =
                    mTelephonyManager.getIccAuthentication(
                            TelephonyManager.APPTYPE_USIM,
                            TelephonyManager.AUTHTYPE_EAP_SIM,
                            base64Challenge);
            assertWithMessage("UICC returned null for EAP-SIM auth").that(response).isNotNull();
            // response is base64 encoded. After decoding, the value should be:
            // 1 length byte + SRES(4 bytes) + 1 length byte + Kc(8 bytes)
            byte[] result = android.util.Base64.decode(response, android.util.Base64.DEFAULT);
            assertThat(result).hasLength(14);
            String response2 =
                    mTelephonyManager.getIccAuthentication(
                            TelephonyManager.APPTYPE_USIM,
                            TelephonyManager.AUTHTYPE_EAP_SIM,
                            base64Challenge2);
            assertWithMessage("Two responses must be different")
                    .that(response)
                    .isNotEqualTo(response2);
        } catch (UnsupportedOperationException e) {
            assumeNoException("EAP-SIM/AKA not supported", e);
        } catch (SecurityException e) {
            fail(NO_CARRIER_PRIVILEGES_FAILURE_MESSAGE);
        }
    }

    @Test
    @SystemUserOnly(reason = "b/177921545, broadcast sent only to primary user")
    public void testSendDialerSpecialCode() {
        assumeTrue(hasTelephonyCalling());

        IntentReceiver intentReceiver = new IntentReceiver();
        final IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(Telephony.Sms.Intents.SECRET_CODE_ACTION);
        intentFilter.addDataScheme("android_secret_code");

        Context context = getContext();
        context.registerReceiver(intentReceiver, intentFilter);
        try {
            mTelephonyManager.sendDialerSpecialCode("4636");
            assertWithMessage(
                            "Did not receive expected Intent: "
                                    + Telephony.Sms.Intents.SECRET_CODE_ACTION)
                    .that(intentReceiver.waitForReceive())
                    .isTrue();
        } catch (SecurityException e) {
            fail(NO_CARRIER_PRIVILEGES_FAILURE_MESSAGE);
        } catch (InterruptedException e) {
            Log.d(TAG, "Broadcast receiver wait was interrupted.");
        } finally {
            context.unregisterReceiver(intentReceiver);
        }
    }

    @Test
    public void testSubscriptionInfoListing() {
        try {
            assertThat(mSubscriptionManager.getActiveSubscriptionInfoCount()).isGreaterThan(0);
            List<SubscriptionInfo> subInfoList =
                    mSubscriptionManager.getActiveSubscriptionInfoList();
            assertWithMessage("getActiveSubscriptionInfoList() returned null")
                    .that(subInfoList)
                    .isNotNull();
            assertWithMessage("getActiveSubscriptionInfoList() returned an empty list")
                    .that(subInfoList)
                    .isNotEmpty();
            for (SubscriptionInfo info : subInfoList) {
                TelephonyManager tm =
                        mTelephonyManager.createForSubscriptionId(info.getSubscriptionId());
                assertWithMessage(
                                "getActiveSubscriptionInfoList() returned an inaccessible"
                                        + " subscription")
                        .that(tm.hasCarrierPrivileges())
                        .isTrue();

                // Check other APIs to make sure they are accessible and return consistent info.
                SubscriptionInfo infoForSlot =
                        mSubscriptionManager.getActiveSubscriptionInfoForSimSlotIndex(
                                info.getSimSlotIndex());
                assertWithMessage("getActiveSubscriptionInfoForSimSlotIndex() returned null")
                        .that(infoForSlot)
                        .isNotNull();
                assertWithMessage(
                                "getActiveSubscriptionInfoForSimSlotIndex() returned inconsistent"
                                        + " info")
                        .that(infoForSlot.getSubscriptionId())
                        .isEqualTo(info.getSubscriptionId());

                SubscriptionInfo infoForSubId =
                        mSubscriptionManager.getActiveSubscriptionInfo(info.getSubscriptionId());
                assertWithMessage("getActiveSubscriptionInfo() returned null")
                        .that(infoForSubId)
                        .isNotNull();
                assertWithMessage("getActiveSubscriptionInfo() returned inconsistent info")
                        .that(infoForSubId.getSubscriptionId())
                        .isEqualTo(info.getSubscriptionId());
            }
        } catch (SecurityException e) {
            fail(NO_CARRIER_PRIVILEGES_FAILURE_MESSAGE);
        }
    }

    @Test
    public void testCarrierConfigIsAccessible() {
        try {
            PersistableBundle bundle = mCarrierConfigManager.getConfig();
            assertWithMessage("CarrierConfigManager#getConfig() returned null")
                    .that(bundle)
                    .isNotNull();
            assertWithMessage("CarrierConfigManager#getConfig() returned empty bundle")
                    .that(bundle.isEmpty())
                    .isFalse();

            int subId = SubscriptionManager.getDefaultSubscriptionId();
            bundle = mCarrierConfigManager.getConfigForSubId(subId);
            assertWithMessage("CarrierConfigManager#getConfigForSubId() returned null")
                    .that(bundle)
                    .isNotNull();
            assertWithMessage("CarrierConfigManager#getConfigForSubId() returned empty bundle")
                    .that(bundle.isEmpty())
                    .isFalse();
        } catch (SecurityException e) {
            fail(NO_CARRIER_PRIVILEGES_FAILURE_MESSAGE);
        }
    }

    @Test
    public void testTelephonyApisAreAccessibleWithFeatureMapping() {
        // The following methods may return any value depending on the state of the device. Simply
        // call them to make sure they do not throw any exceptions. Methods that return a device
        // identifier will be accessible to apps with carrier privileges in Q, but this may change
        // in a future release.
        try {
            mTelephonyManager.getDeviceId();
            mTelephonyManager.getDeviceSoftwareVersion();
            mTelephonyManager.getImei();

            if (hasFeature(PackageManager.FEATURE_TELEPHONY_CDMA)) {
                mTelephonyManager.getMeid();
            }
            if (hasFeature(PackageManager.FEATURE_TELEPHONY_SUBSCRIPTION)) {
                mTelephonyManager.getNai();
                mTelephonyManager.getSimSerialNumber();
                mTelephonyManager.getSubscriberId();
                mTelephonyManager.getGroupIdLevel1();
                mTelephonyManager.getLine1Number();
                mTelephonyManager.getForbiddenPlmns();
                mTelephonyManager.setForbiddenPlmns(new ArrayList<String>());
                // TODO(b/235490259): test all slots once TM#isModemEnabledForSlot allows
                mTelephonyManager.isModemEnabledForSlot(
                        SubscriptionManager.getSlotIndex(mTelephonyManager.getSubscriptionId()));
            }
            if (hasFeature(PackageManager.FEATURE_TELEPHONY_RADIO_ACCESS)) {
                mTelephonyManager.getDataNetworkType();
                mTelephonyManager.getServiceState();
                mTelephonyManager.getManualNetworkSelectionPlmn();
            }
            if (hasFeature(PackageManager.FEATURE_TELEPHONY_CALLING)) {
                mTelephonyManager.getVoiceNetworkType();
                mTelephonyManager.getVoiceMailNumber();
                mTelephonyManager.getVisualVoicemailPackageName();
                mTelephonyManager.getVoiceMailAlphaTag();
            }
        } catch (SecurityException e) {
            fail(NO_CARRIER_PRIVILEGES_FAILURE_MESSAGE);
        }
    }

    @Test
    public void testImsApisAreAccessibleWithFeatureMapping() {
        assumeTrue(hasFeature(PackageManager.FEATURE_TELEPHONY_IMS));
        final int subId = mTelephonyManager.getSubscriptionId();
        try {
            mMmTelManager.createForSubscriptionId(subId);

            RegistrationManager.RegistrationCallback rc =
                    new RegistrationManager.RegistrationCallback() {};
            try {
                mMmTelManager.registerImsRegistrationCallback(r -> r.run(), rc);
            } catch (ImsException ignored) {
            } finally {
                mMmTelManager.unregisterImsRegistrationCallback(rc);
            }
            if (Flags.emergencyRegistrationState()) {
                try {
                    mMmTelManager.registerImsEmergencyRegistrationCallback(r -> r.run(), rc);
                } catch (ImsException ignored) {
                } finally {
                    mMmTelManager.unregisterImsEmergencyRegistrationCallback(rc);
                }
            }

            mMmTelManager.getRegistrationTransportType(r -> r.run(), (i) -> {});

            ImsMmTelManager.CapabilityCallback cc =
                    new ImsMmTelManager.CapabilityCallback() {};
            try {
                mMmTelManager.registerMmTelCapabilityCallback(r -> r.run(), cc);
            } catch (ImsException ignored) {
            } finally {
                mMmTelManager.unregisterMmTelCapabilityCallback(cc);
            }

            mMmTelManager.isAdvancedCallingSettingEnabled();
            mMmTelManager.isVtSettingEnabled();
            mMmTelManager.setVoWiFiSettingEnabled(mMmTelManager.isVoWiFiSettingEnabled());

            try {
                mMmTelManager.setCrossSimCallingEnabled(
                        mMmTelManager.isCrossSimCallingEnabled());
            } catch (ImsException ignored) {
            }

            mMmTelManager.setVoWiFiRoamingSettingEnabled(
                    mMmTelManager.isVoWiFiRoamingSettingEnabled());
            mMmTelManager.setVoWiFiModeSetting(mMmTelManager.getVoWiFiModeSetting());
            mMmTelManager.isTtyOverVolteEnabled();

            ImsStateCallback ic = new ImsStateCallback() {
                @Override
                public void onUnavailable(int reason) {
                }
                @Override
                public void onAvailable() {
                }
                @Override
                public void onError() {
                }
            };
            try {
                mMmTelManager.registerImsStateCallback(r -> r.run(), ic);
            } catch (ImsException ignored) {
            } finally {
                mMmTelManager.unregisterImsStateCallback(ic);
            }
        } catch (SecurityException e) {
            fail(NO_CARRIER_PRIVILEGES_FAILURE_MESSAGE);
        }
    }

    @Test
    public void testVoicemailTableIsAccessible() throws Exception {
        ContentValues value = new ContentValues();
        value.put(VoicemailContract.Voicemails.NUMBER, "0123456789");
        value.put(VoicemailContract.Voicemails.SOURCE_PACKAGE, selfPackageName);
        try {
            Uri uri = mVoicemailProvider.insert(mVoicemailContentUri, value);
            assertThat(uri).isNotNull();
            Cursor cursor =
                    mVoicemailProvider.query(
                            uri,
                            new String[] {
                                VoicemailContract.Voicemails.NUMBER,
                                VoicemailContract.Voicemails.SOURCE_PACKAGE
                            },
                            null,
                            null,
                            null);
            assertThat(cursor).isNotNull();
            assertThat(cursor.moveToFirst()).isTrue();
            assertThat(cursor.getString(0)).isEqualTo("0123456789");
            assertThat(cursor.getString(1)).isEqualTo(selfPackageName);
            assertThat(cursor.moveToNext()).isFalse();
        } catch (SecurityException e) {
            fail(NO_CARRIER_PRIVILEGES_FAILURE_MESSAGE);
        }
    }

    @Test
    public void testVoicemailStatusTableIsAccessible() throws Exception {
        ContentValues value = new ContentValues();
        value.put(
                VoicemailContract.Status.CONFIGURATION_STATE,
                VoicemailContract.Status.CONFIGURATION_STATE_OK);
        value.put(VoicemailContract.Status.SOURCE_PACKAGE, selfPackageName);
        try {
            Uri uri = mStatusProvider.insert(mStatusContentUri, value);
            assertThat(uri).isNotNull();
            Cursor cursor =
                    mVoicemailProvider.query(
                            uri,
                            new String[] {
                                VoicemailContract.Status.CONFIGURATION_STATE,
                                VoicemailContract.Status.SOURCE_PACKAGE
                            },
                            null,
                            null,
                            null);
            assertThat(cursor).isNotNull();
            assertThat(cursor.moveToFirst()).isTrue();
            assertThat(cursor.getInt(0)).isEqualTo(VoicemailContract.Status.CONFIGURATION_STATE_OK);
            assertThat(cursor.getString(1)).isEqualTo(selfPackageName);
            assertThat(cursor.moveToNext()).isFalse();
        } catch (SecurityException e) {
            fail(NO_CARRIER_PRIVILEGES_FAILURE_MESSAGE);
        }
    }

    static final int READ_PHONE_STATE_LISTENERS =
            PhoneStateListener.LISTEN_CALL_FORWARDING_INDICATOR
                    | PhoneStateListener.LISTEN_MESSAGE_WAITING_INDICATOR
                    | PhoneStateListener.LISTEN_EMERGENCY_NUMBER_LIST;

    static final int READ_PRECISE_PHONE_STATE_LISTENERS =
            PhoneStateListener.LISTEN_PRECISE_DATA_CONNECTION_STATE
                    | PhoneStateListener.LISTEN_CALL_DISCONNECT_CAUSES
                    | PhoneStateListener.LISTEN_IMS_CALL_DISCONNECT_CAUSES
                    | PhoneStateListener.LISTEN_REGISTRATION_FAILURE
                    | PhoneStateListener.LISTEN_BARRING_INFO;

    static final int CARRIER_PRIVILEGE_LISTENERS =
            READ_PHONE_STATE_LISTENERS | READ_PRECISE_PHONE_STATE_LISTENERS;

    @Test
    public void testGetManualNetworkSelectionPlmnPersisted() throws Exception {
        if (mTelephonyManager.getPhoneType() != TelephonyManager.PHONE_TYPE_GSM) return;

        try {
            mTelephonyManager.setNetworkSelectionModeManual(
                    TESTING_PLMN /* operatorNumeric */, true /* persistSelection */);
            String plmn = mTelephonyManager.getManualNetworkSelectionPlmn();
            assertThat(plmn).isEqualTo(TESTING_PLMN);
        } finally {
            mTelephonyManager.setNetworkSelectionModeAutomatic();
        }
    }

    @Test
    public void testPhoneStateListener() throws Exception {
        PhoneStateListener psl = new PhoneStateListener((Runnable r) -> {});
        try {
            mTelephonyManager.listen(psl, CARRIER_PRIVILEGE_LISTENERS);
        } finally {
            mTelephonyManager.listen(psl, PhoneStateListener.LISTEN_NONE);
        }
    }

    @Test
    public void testIsManualNetworkSelectionAllowed() throws Exception {
        if (mTelephonyManager.getPhoneType() != TelephonyManager.PHONE_TYPE_GSM) return;

        try {
            assertThat(mTelephonyManager.isManualNetworkSelectionAllowed()).isTrue();
        } catch (SecurityException e) {
            fail(NO_CARRIER_PRIVILEGES_FAILURE_MESSAGE);
        }
    }

    @Test
    public void testGetNetworkSelectionMode() throws Exception {
        try {
            ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(
                    mTelephonyManager, (tm) -> tm.setNetworkSelectionModeAutomatic());
            int networkMode = mTelephonyManager.getNetworkSelectionMode();
            assertThat(networkMode).isEqualTo(TelephonyManager.NETWORK_SELECTION_MODE_AUTO);
        } catch (SecurityException e) {
            fail(NO_CARRIER_PRIVILEGES_FAILURE_MESSAGE);
        }
    }

    @Test
    public void testSubscriptionInfoChangeListener() throws Exception {
        final AtomicReference<SecurityException> error = new AtomicReference<>();
        final CountDownLatch latch = new CountDownLatch(1);
        new Handler(mListenerThread.getLooper())
                .post(
                        () -> {
                            SubscriptionManager.OnSubscriptionsChangedListener listener =
                                    new SubscriptionManager.OnSubscriptionsChangedListener();
                            try {
                                mSubscriptionManager.addOnSubscriptionsChangedListener(listener);
                            } catch (SecurityException e) {
                                error.set(e);
                            } finally {
                                mSubscriptionManager.removeOnSubscriptionsChangedListener(listener);
                                latch.countDown();
                            }
                        });
        assertWithMessage("Test timed out").that(latch.await(30L, TimeUnit.SECONDS)).isTrue();
        if (error.get() != null) {
            fail(NO_CARRIER_PRIVILEGES_FAILURE_MESSAGE);
        }
    }

    /**
     * Test that it's possible to open logical channels to the ICC. This mirrors the Manage Channel
     * command described in TS 102 221 Section 11.1.17.
     */
    @Test
    public void testIccOpenLogicalChannel() {
        // The AID here doesn't matter - we just need to open a valid connection. In this case, the
        // specified AID ("") opens a channel and selects the MF.
        IccOpenLogicalChannelResponse response = mTelephonyManager.iccOpenLogicalChannel("");
        assertThat(response.getStatus()).isEqualTo(STATUS_NO_ERROR);
        final int logicalChannel = response.getChannel();
        try {
            verifyValidIccOpenLogicalChannelResponse(response);
        } finally {
            mTelephonyManager.iccCloseLogicalChannel(logicalChannel);
        }
    }

    @Test
    public void testIccOpenLogicalChannelWithValidP2() {
        // {@link TelephonyManager#iccOpenLogicalChannel} sends a Manage Channel (open) APDU
        // followed by a Select APDU with the given AID and p2 values. See Open Mobile API
        // Specification v3.2 Section 6.2.7.h and TS 102 221 for details.
        int p2 = 0x0C; // '0C' for no data returned (TS 102 221 Section 11.1.1.2)
        IccOpenLogicalChannelResponse response = mTelephonyManager.iccOpenLogicalChannel("", p2);
        assertThat(response.getStatus()).isEqualTo(STATUS_NO_ERROR);
        final int logicalChannel = response.getChannel();
        try {
            verifyValidIccOpenLogicalChannelResponse(response);
        } finally {
            mTelephonyManager.iccCloseLogicalChannel(logicalChannel);
        }
    }

    @Test
    public void testIccOpenLogicalChannelWithInvalidP2() {
        // Valid p2 values are defined in TS 102 221 Table 11.2. Per Table 11.2, 0xF0 should be
        // invalid. Any p2 values that produce non '9000'/'62xx'/'63xx' status words are treated as
        // an error and the channel is not opened. Due to compatibility issues with older devices,
        // this check is only enabled for new devices launching on Q+.
        if (Build.VERSION.DEVICE_INITIAL_SDK_INT >= Build.VERSION_CODES.Q) {
            int p2 = 0xF0;
            IccOpenLogicalChannelResponse response =
                    mTelephonyManager.iccOpenLogicalChannel("", p2);
            final int logicalChannel = response.getChannel();
            assertThat(logicalChannel).isEqualTo(INVALID_CHANNEL);
            assertThat(response.getStatus()).isNotEqualTo(STATUS_NO_ERROR);
        }
    }

    @Test
    public void testIccOpenTooManyLogicalChannels() throws IOException {
        Set<Integer> channels = new HashSet<Integer>();
        boolean failedOnce = false;
        try {
            for (int i = MIN_LOGICAL_CHANNEL; i <= MAX_LOGICAL_CHANNEL_EXTENDED + 1; i++) {
                IccOpenLogicalChannelResponse response =
                        mTelephonyManager.iccOpenLogicalChannel("");
                int channel = response.getChannel();
                if (channel > 0) {
                    // TODO(b/375102360): CF should implement handling more than one logical channel
                    assumeFalse(channels.contains(channel) && MediaUtils.onCuttlefish());
                    assertWithMessage("Logical channel " + channel + " was returned twice")
                            .that(channels.add(channel)).isTrue();
                }
                if (response.getStatus() == STATUS_MISSING_RESOURCE) {
                    assertThat(response.getSelectResponse()).isNull();
                    assertThat(channel).isEqualTo(INVALID_CHANNEL);
                    failedOnce = true;
                    break;
                }
                assertThat(response.getStatus()).isEqualTo(STATUS_NO_ERROR);
                assertThat(response.getSelectResponse()).isEqualTo(STATUS_NORMAL);
                assertThat(channel).isIn(Range.closed(MIN_LOGICAL_CHANNEL,
                        MAX_LOGICAL_CHANNEL_EXTENDED));
            }
        } finally {
            for (Integer channel : channels) {
                mTelephonyManager.iccCloseLogicalChannel(channel);
            }
        }
        assertTrue(failedOnce);

        // Make sure you can open logical channel after closing old ones.
        testIccOpenLogicalChannel();
    }

    /**
     * Test that it's possible to close logical channels to the ICC. This follows the Manage Channel
     * command described in TS 102 221 Section 11.1.17.
     */
    @Test
    public void testIccCloseLogicalChannel() {
        // The directory here doesn't matter - we just need to open a valid connection that can
        // later be closed. In this case, the specified AID ("") opens a channel and selects the MF.
        IccOpenLogicalChannelResponse response = mTelephonyManager.iccOpenLogicalChannel("");

        // Check that the select command succeeded. This ensures that the logical channel is indeed
        // open.
        assertThat(response.getSelectResponse()).isEqualTo(STATUS_NORMAL);
        assertThat(mTelephonyManager.iccCloseLogicalChannel(response.getChannel())).isTrue();

        // Close opened channel twice.
        try {
            boolean result = mTelephonyManager.iccCloseLogicalChannel(response.getChannel());
            assertThat(result).isFalse();
        } catch (IllegalArgumentException ex) {
            //IllegalArgumentException is expected sometimes because of different behaviour of modem
        }

        // Channel 0 is guaranteed to be always available and cannot be closed, per TS 102 221
        // Section 11.1.17
        try {
            mTelephonyManager.iccCloseLogicalChannel(0);
            fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException ex) {
            // IllegalArgumentException is expected
        }
    }

    /**
     * This test ensures that valid APDU instructions can be sent and processed by the ICC. To do
     * so, APDUs are sent to: - get the status of the MF - select the Access Rule Reference (ARR)
     * for the MF - get the FCP template response for the select
     */
    @Test
    public void testIccTransmitApduLogicalChannel() {
        // An open LC is required for transmitting APDU commands. This opens an LC to the MF.
        IccOpenLogicalChannelResponse iccOpenLogicalChannelResponse =
                mTelephonyManager.iccOpenLogicalChannel("");
        assertThat(iccOpenLogicalChannelResponse.getStatus()).isEqualTo(STATUS_NO_ERROR);

        // Get the status of the current directory. This should match the MF. TS 102 221 Section
        // 11.1.2
        final int logicalChannel = iccOpenLogicalChannelResponse.getChannel();

        try {
            int cla = CLA_STATUS;
            int p1 = 0; // no indication of application status
            int p2 = 0; // same response parameters as the SELECT in the iccOpenLogicalChannel()
            // above
            int p3 = 0; // length of 'data' payload
            String data = "";
            String response =
                    mTelephonyManager.iccTransmitApduLogicalChannel(
                            logicalChannel, cla, COMMAND_STATUS, p1, p2, p3, data);
            FcpTemplate fcpTemplate = FcpTemplate.parseFcpTemplate(response);
            // Check that the FCP Template's file ID matches the MF
            assertThat(containsFileId(fcpTemplate, MF_FILE_ID)).isTrue();
            assertThat(fcpTemplate.getStatus()).isEqualTo(STATUS_NORMAL_STRING);

            // Select the Access Rule Reference for the MF. Similar to the MF, this will exist
            // across all SIM cards. TS 102 221 Section 11.1.1
            cla = CLA_SELECT;
            p1 = 0; // select EF by FID
            p2 = 0x04; // requesting FCP template
            p3 = 2; // data (FID to be selected) is 2 bytes
            data = MF_ARR_FILE_ID;
            response =
                    mTelephonyManager.iccTransmitApduLogicalChannel(
                            logicalChannel, cla, COMMAND_SELECT, p1, p2, p3, data);

            // Devices launching with Q or later must immediately return the FCP template from the
            // previous SELECT command. Some devices that launched before Q return TPDUs (instead of
            // APDUs) - these devices must issue a subsequent GET RESPONSE command to get the FCP
            // template.
            if (Build.VERSION.DEVICE_INITIAL_SDK_INT < Build.VERSION_CODES.Q) {
                // Conditionally need to send GET RESPONSE apdu based on response from
                // TelephonyManager
                if (response.startsWith(STATUS_BYTES_REMAINING)) {
                    // Read the FCP template from the ICC. TS 102 221 Section 12.1.1
                    cla = CLA_GET_RESPONSE;
                    p1 = 0;
                    p2 = 0;
                    p3 = 0;
                    data = "";
                    response =
                            mTelephonyManager.iccTransmitApduLogicalChannel(
                                    logicalChannel, cla, COMMAND_GET_RESPONSE, p1, p2, p3, data);
                }
            }

            fcpTemplate = FcpTemplate.parseFcpTemplate(response);
            // Check that the FCP Template's file ID matches the selected ARR
            assertThat(containsFileId(fcpTemplate, MF_ARR_FILE_ID)).isTrue();
            assertThat(fcpTemplate.getStatus()).isEqualTo(STATUS_NORMAL_STRING);
        } finally {
            mTelephonyManager.iccCloseLogicalChannel(logicalChannel);
        }
    }

    /**
     * Tests several invalid APDU instructions over a logical channel and makes sure appropriate
     * errors are returned from the UICC.
     */
    @Test
    public void testIccTransmitApduLogicalChannelWithInvalidInputs() {
        // An open LC is required for transmitting apdu commands. This opens an LC to the MF.
        IccOpenLogicalChannelResponse iccOpenLogicalChannelResponse =
                mTelephonyManager.iccOpenLogicalChannel("");
        assertThat(iccOpenLogicalChannelResponse.getStatus()).isEqualTo(STATUS_NO_ERROR);
        final int logicalChannel = iccOpenLogicalChannelResponse.getChannel();

        try {
            // Make some invalid APDU commands and make sure they fail as expected.
            // Use an invalid p1 value for Status apdu
            int cla = CLA_STATUS | logicalChannel;
            int p1 = 0xFF; // only '00', '01', and '02' are allowed
            int p2 = 0; // same response parameters as the SELECT in the iccOpenLogicalChannel()
            // above
            int p3 = 0; // length of 'data' payload
            String data = "";
            String response =
                    mTelephonyManager.iccTransmitApduLogicalChannel(
                            logicalChannel, cla, COMMAND_STATUS, p1, p2, p3, data);
            assertThat(INVALID_PARAMETERS_STATUSES.contains(response)).isTrue();

            // Select a file that doesn't exist
            cla = CLA_SELECT;
            p1 = 0x00; // select by file ID
            p2 = 0x0C; // no data returned
            p3 = 0x02; // length of 'data' payload
            data = "FFFF"; // invalid file ID
            response =
                    mTelephonyManager.iccTransmitApduLogicalChannel(
                            logicalChannel, cla, COMMAND_SELECT, p1, p2, p3, data);
            assertThat(response).isEqualTo(STATUS_FILE_NOT_FOUND);

            // Manage channel with incorrect p1 parameter
            cla = CLA_MANAGE_CHANNEL | logicalChannel;
            p1 = 0x83; // Only '80' or '00' allowed for Manage Channel p1
            p2 = logicalChannel; // channel to be closed
            p3 = 0; // length of 'data' payload
            data = "";
            response =
                    mTelephonyManager.iccTransmitApduLogicalChannel(
                            logicalChannel, cla, COMMAND_MANAGE_CHANNEL, p1, p2, p3, data);
            assertThat(isErrorResponse(response)).isTrue();

            // Use an incorrect class byte for Status apdu
            cla = 0xFF;
            p1 = 0; // no indication of application status
            p2 = 0; // same response parameters as the SELECT in the iccOpenLogicalChannel() above
            p3 = 0; // length of 'data' payload
            data = "";
            response =
                    mTelephonyManager.iccTransmitApduLogicalChannel(
                            logicalChannel, cla, COMMAND_STATUS, p1, p2, p3, data);
            assertThat(response).isEqualTo(STATUS_WRONG_CLASS);

            // Provide a data field that is longer than described for Select apdu
            cla = CLA_SELECT | logicalChannel;
            p1 = 0; // select by file ID
            p2 = 0x0C; // no data returned
            p3 = 0x04; // data passed is actually 2 bytes long
            data = "3F00"; // valid ID
            response =
                    mTelephonyManager.iccTransmitApduLogicalChannel(
                            logicalChannel, cla, COMMAND_SELECT, p1, p2, p3, data);
            assertThat(isErrorResponse(response)).isTrue();

            // Use an invalid instruction
            cla = 0;
            p1 = 0;
            p2 = 0;
            p3 = 0;
            data = "";
            int invalidInstruction = 0xFF; // see TS 102 221 Table 10.5 for valid instructions
            response =
                    mTelephonyManager.iccTransmitApduLogicalChannel(
                            logicalChannel, cla, invalidInstruction, p1, p2, p3, data);
            assertThat(isErrorResponse(response)).isTrue();
        } finally {
            mTelephonyManager.iccCloseLogicalChannel(logicalChannel);
        }
    }

    @Test
    public void testIccTransmitApduLogicalChannelWithInvalidChannel() throws IOException {
        IccOpenLogicalChannelResponse iccOpenLogicalChannelResponse =
                mTelephonyManager.iccOpenLogicalChannel("");
        assertThat(iccOpenLogicalChannelResponse.getStatus()).isEqualTo(STATUS_NO_ERROR);
        final int closedCh = iccOpenLogicalChannelResponse.getChannel();
        mTelephonyManager.iccCloseLogicalChannel(closedCh);

        int[] badChannels = {
            // use after close
            closedCh,

            // common wrong values
            -2,
            -1,
            50,
            100,

            // int8_t max and max + 1
            127,
            128,

            // uint8_t max - 1 to + 2,
            254,
            255,
            256,
            257,

            // int16_t max and max + 1,
            32767,
            32768,

            // uint16_t max + 1,
            65536,

            // int32_t max
            2147483647,
        };

        for (int channel : badChannels) {
            String response = mTelephonyManager.iccTransmitApduLogicalChannel(
                    channel, CLA_STATUS, COMMAND_STATUS, 0, 0, 0, "");
            assertWithMessage("Unexpected response when transmitting on invalid channel " + channel)
                    .that(response)
                    .isAnyOf(STATUS_CHANNEL_NOT_SUPPORTED, STATUS_TECHNICAL_PROBLEM);
        }
    }

    /**
     * This test ensures that files can be read off the UICC. This helps to test the SIM booting
     * process, as it process involves several file-reads. The ICCID is one of the first files read.
     */
    @Test
    public void testApduFileRead() {
        // Open a logical channel and select the MF.
        IccOpenLogicalChannelResponse iccOpenLogicalChannel =
                mTelephonyManager.iccOpenLogicalChannel("");
        assertThat(iccOpenLogicalChannel.getStatus()).isEqualTo(STATUS_NO_ERROR);
        final int logicalChannel = iccOpenLogicalChannel.getChannel();

        try {
            // Select the ICCID. TS 102 221 Section 13.2
            int p1 = 0; // select by file ID
            int p2 = 0x0C; // no data returned
            int p3 = 2; // length of 'data' payload
            String response =
                    mTelephonyManager.iccTransmitApduLogicalChannel(
                            logicalChannel, CLA_SELECT, COMMAND_SELECT, p1, p2, p3, ICCID_FILE_ID);
            assertThat(response).isEqualTo(STATUS_NORMAL_STRING);

            // Read the contents of the ICCID.
            p1 = 0; // 0-byte offset
            p2 = 0; // 0-byte offset
            p3 = 0; // length of 'data' payload
            response =
                    mTelephonyManager.iccTransmitApduLogicalChannel(
                            logicalChannel, CLA_READ_BINARY, COMMAND_READ_BINARY, p1, p2, p3, "");
            assertThat(response).endsWith(STATUS_NORMAL_STRING);
        } finally {
            mTelephonyManager.iccCloseLogicalChannel(logicalChannel);
        }
    }

    // ETSI TS 102 221 13.2
    private void verifyValidIccId(String iccid) {
        assertThat(iccid).hasLength(20);
    }

    // ETSI TS 102 221 13.3
    private void verifyValidPl(String pl) {
        final int hexEntryLength = PL_ENTRY_LENGTH * HEX_BYTES_PER_CHAR;
        assertThat(pl.length() % hexEntryLength).isEqualTo(0);
        assertThat(pl.length()).isAtLeast(hexEntryLength);
        for (int i = 0; i < pl.length(); i += hexEntryLength) {
            String langHex = pl.substring(i, i + hexEntryLength);
            assertThat(langHex).hasLength(hexEntryLength);

            byte[] lang = hexStringToBytes(langHex);
            assertThat(lang).hasLength(PL_ENTRY_LENGTH);
            int ch1 = Byte.toUnsignedInt(lang[0]);
            int ch2 = Byte.toUnsignedInt(lang[1]);
            if (ch1 == 0xFF && ch2 == 0xFF) continue;

            assertTrue("Language code is not alphanumeric: " + langHex,
                    isSeriouslyLetterOrDigit(ch1) && isSeriouslyLetterOrDigit(ch2));
        }
    }

    private IccOpenLogicalChannelResponse openLogicalChannelWithRetries(String aid) {
        for (int retries = 0; retries < MAX_RETRIES; retries++) {
            IccOpenLogicalChannelResponse response = mTelephonyManager.iccOpenLogicalChannel(aid);
            if (response.getStatus() != STATUS_MISSING_RESOURCE) return response;
            assertThat(response.getChannel()).isEqualTo(INVALID_CHANNEL);
            try {
                // Let's give other processes time to finish and release occupied channels.
                Thread.sleep(100);
            } catch (InterruptedException ex) {
                break;
            }
        }
        fail("Couldn't open logical channel: no resources");
        return null;
    }

    /**
     * This test verifies if two files can be read off the UICC at the same time through two
     * different channels.
     */
    @Test
    public void testApduFileReadTwoChannels() throws IOException {
        int channel1 = INVALID_CHANNEL;
        int channel2 = INVALID_CHANNEL;
        try {
            IccOpenLogicalChannelResponse channel1rsp = openLogicalChannelWithRetries("");
            verifyValidIccOpenLogicalChannelResponse(channel1rsp);
            channel1 = channel1rsp.getChannel();

            IccOpenLogicalChannelResponse channel2rsp = openLogicalChannelWithRetries("");
            verifyValidIccOpenLogicalChannelResponse(channel2rsp);
            channel2 = channel2rsp.getChannel();

            // TODO(b/375102360): CF should implement handling more than one logical channel
            assumeFalse(channel1 == channel2 && MediaUtils.onCuttlefish());
            assertWithMessage("Two concurrently opened channels should be different")
                    .that(channel2).isNotEqualTo(channel1);

            // p1, p2, p3 - see testApduFileRead
            String selResponse = mTelephonyManager.iccTransmitApduLogicalChannel(
                    channel1, CLA_SELECT, COMMAND_SELECT, 0, 0x0C, 2, PL_FILE_ID);
            assertThat(selResponse).isEqualTo(STATUS_NORMAL_STRING);

            selResponse = mTelephonyManager.iccTransmitApduLogicalChannel(
                    channel2, CLA_SELECT, COMMAND_SELECT, 0, 0x0C, 2, ICCID_FILE_ID);
            assertThat(selResponse).isEqualTo(STATUS_NORMAL_STRING);

            // Read from two channels out of order -- SELECT command shouldn't affect other channels
            String contents2 = mTelephonyManager.iccTransmitApduLogicalChannel(
                    channel2, CLA_READ_BINARY, COMMAND_READ_BINARY, 0, 0, 0, "");
            assertThat(contents2).endsWith(STATUS_NORMAL_STRING);

            String contents1 = mTelephonyManager.iccTransmitApduLogicalChannel(
                    channel1, CLA_READ_BINARY, COMMAND_READ_BINARY, 0, 0, 0, "");
            assertThat(contents1).endsWith(STATUS_NORMAL_STRING);

            assertWithMessage("Contents of EF_PL and EF_ICCID shouldn't be the same")
                    .that(contents1).isNotEqualTo(contents2);
            verifyValidPl(contents1.substring(0, contents1.length() - 4));
            verifyValidIccId(contents2.substring(0, contents2.length() - 4));
        } finally {
            if (channel1 != INVALID_CHANNEL) {
                mTelephonyManager.iccCloseLogicalChannel(channel1);
            }
            if (channel2 != INVALID_CHANNEL && channel1 != channel2) {
                mTelephonyManager.iccCloseLogicalChannel(channel2);
            }
        }
    }

    /** This test sends several valid APDU commands over the basic channel (channel 0). */
    @Test
    public void testIccTransmitApduBasicChannel() {
        // select the MF
        int cla = CLA_SELECT;
        int p1 = 0; // select EF by FID
        int p2 = 0x0C; // requesting FCP template
        int p3 = 2; // length of 'data' payload
        String data = MF_FILE_ID;
        String response =
                mTelephonyManager.iccTransmitApduBasicChannel(
                        cla, COMMAND_SELECT, p1, p2, p3, data);
        assertThat(response).isEqualTo(STATUS_NORMAL_STRING);

        // get the Status of the current file/directory
        cla = CLA_STATUS;
        p1 = 0; // no indication of application status
        p2 = 0; // same response parameters as the SELECT in the iccOpenLogicalChannel() above
        p3 = 0; // length of 'data' payload
        data = "";
        response =
                mTelephonyManager.iccTransmitApduBasicChannel(
                        cla, COMMAND_STATUS, p1, p2, p3, data);
        FcpTemplate fcpTemplate = FcpTemplate.parseFcpTemplate(response);
        assertThat(containsFileId(fcpTemplate, MF_FILE_ID)).isTrue();

        // Manually open a logical channel
        cla = CLA_MANAGE_CHANNEL;
        p1 = 0; // open a logical channel
        p2 = 0; // '00' for open command
        p3 = 0; // length of data payload
        data = "";
        response =
                mTelephonyManager.iccTransmitApduBasicChannel(
                        cla, COMMAND_MANAGE_CHANNEL, p1, p2, p3, data);
        // response is in the format | 1 byte: channel number | 2 bytes: status word |
        String responseStatus = response.substring(response.length() - 4);
        assertThat(responseStatus).isEqualTo(STATUS_NORMAL_STRING);

        // Close the open channel
        byte[] responseBytes = hexStringToBytes(response);
        int channel = responseBytes[0];
        cla = CLA_MANAGE_CHANNEL;
        p1 = 0x80; // close a logical channel
        p2 = channel; // the channel to be closed
        p3 = 0; // length of data payload
        data = "";
        response =
                mTelephonyManager.iccTransmitApduBasicChannel(
                        cla, COMMAND_MANAGE_CHANNEL, p1, p2, p3, data);
        assertThat(response).isEqualTo(STATUS_NORMAL_STRING);
    }

    /**
     * This test verifies that {@link TelephonyManager#setLine1NumberForDisplay(String, String)}
     * correctly sets the Line 1 alpha tag and number when called, and the phone number
     * of {@link SubscriptionManager#PHONE_NUMBER_SOURCE_CARRIER}.
     */
    @Test
    public void testLine1NumberForDisplay() {
        int subId = SubscriptionManager.getDefaultSubscriptionId();
        // Cache original alpha tag and number values.
        String originalAlphaTag = mTelephonyManager.getLine1AlphaTag();
        String originalNumber = mTelephonyManager.getLine1Number();

        try {
            // clear any potentially overridden values and cache defaults
            mTelephonyManager.setLine1NumberForDisplay(null, null);
            String defaultAlphaTag = mTelephonyManager.getLine1AlphaTag();
            String defaultNumber = mTelephonyManager.getLine1Number();

            assertThat(mTelephonyManager.setLine1NumberForDisplay(ALPHA_TAG_A, NUMBER_A)).isTrue();
            assertThat(mTelephonyManager.getLine1AlphaTag()).isEqualTo(ALPHA_TAG_A);
            assertThat(mTelephonyManager.getLine1Number()).isEqualTo(NUMBER_A);
            assertThat(mSubscriptionManager.getPhoneNumber(subId, PHONE_NUMBER_SOURCE_CARRIER))
                    .isEqualTo(NUMBER_A);

            assertThat(mTelephonyManager.setLine1NumberForDisplay(ALPHA_TAG_B, NUMBER_B)).isTrue();
            assertThat(mTelephonyManager.getLine1AlphaTag()).isEqualTo(ALPHA_TAG_B);
            assertThat(mTelephonyManager.getLine1Number()).isEqualTo(NUMBER_B);
            assertThat(mSubscriptionManager.getPhoneNumber(subId, PHONE_NUMBER_SOURCE_CARRIER))
                    .isEqualTo(NUMBER_B);

            // null is used to clear the Line 1 alpha tag and number values.
            assertThat(mTelephonyManager.setLine1NumberForDisplay(null, null)).isTrue();
            assertThat(mTelephonyManager.getLine1AlphaTag()).isEqualTo(defaultAlphaTag);
            assertThat(mTelephonyManager.getLine1Number()).isEqualTo(defaultNumber);
            assertThat(mSubscriptionManager.getPhoneNumber(subId, PHONE_NUMBER_SOURCE_CARRIER))
                    .isEqualTo("");
        } finally {
            // Reset original alpha tag and number values.
            mTelephonyManager.setLine1NumberForDisplay(originalAlphaTag, originalNumber);
        }
    }

    /**
     * This test verifies that {@link TelephonyManager#setVoiceMailNumber(String, String)} correctly
     * sets the VoiceMail alpha tag and number when called.
     */
    @Test
    public void testVoiceMailNumber() {
        assumeTrue(hasTelephonyCalling());

        // Cache original alpha tag and number values.
        String originalAlphaTag = mTelephonyManager.getVoiceMailAlphaTag();
        String originalNumber = mTelephonyManager.getVoiceMailNumber();

        try {
            assertThat(mTelephonyManager.setVoiceMailNumber(ALPHA_TAG_A, NUMBER_A)).isTrue();
            assertThat(mTelephonyManager.getVoiceMailAlphaTag()).isEqualTo(ALPHA_TAG_A);
            assertThat(mTelephonyManager.getVoiceMailNumber()).isEqualTo(NUMBER_A);

            assertThat(mTelephonyManager.setVoiceMailNumber(ALPHA_TAG_B, NUMBER_B)).isTrue();
            assertThat(mTelephonyManager.getVoiceMailAlphaTag()).isEqualTo(ALPHA_TAG_B);
            assertThat(mTelephonyManager.getVoiceMailNumber()).isEqualTo(NUMBER_B);
        } finally {
            // Reset original alpha tag and number values.
            mTelephonyManager.setVoiceMailNumber(originalAlphaTag, originalNumber);
        }
    }

    /**
     * This test verifies that {@link SubscriptionManager#createSubscriptionGroup(List)} correctly
     * create a group with the given subscription id.
     *
     * <p>This also verifies that {@link SubscriptionManager#removeSubscriptionsFromGroup(List,
     * ParcelUuid)} correctly remove the given subscription group.
     */
    @Test
    public void testCreateAndRemoveSubscriptionGroup() {
        // Set subscription group with current sub Id.
        int subId = SubscriptionManager.getDefaultSubscriptionId();
        List<Integer> subGroup = Arrays.asList(subId);
        ParcelUuid uuid = mSubscriptionManager.createSubscriptionGroup(subGroup);

        // Getting subscriptions in group.
        List<SubscriptionInfo> infoList = mSubscriptionManager.getSubscriptionsInGroup(uuid);

        try {
            assertThat(infoList).hasSize(1);
            assertThat(infoList.get(0).getGroupUuid()).isEqualTo(uuid);
            assertThat(infoList.get(0).getSubscriptionId()).isEqualTo(subId);
        } finally {
            // Verify that the given subGroup has been removed.
            mSubscriptionManager.removeSubscriptionsFromGroup(subGroup, uuid);
            infoList = mSubscriptionManager.getSubscriptionsInGroup(uuid);
            assertThat(infoList).isEmpty();
        }
    }

    @Test
    public void testAddSubscriptionToExistingGroupForMultipleSims() {
        if (mTelephonyManager.getPhoneCount() < DSDS_PHONE_COUNT
                || mSubscriptionManager.getActiveSubscriptionInfoList().size() < DSDS_PHONE_COUNT) {
            // This test requires at least two active subscriptions.
            return;
        }

        // Set subscription group with current sub Id.
        int subId = SubscriptionManager.getDefaultSubscriptionId();
        if (subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) return;
        ParcelUuid uuid = ShellIdentityUtils.invokeMethodWithShellPermissions(mSubscriptionManager,
                (sm) -> sm.createSubscriptionGroup(Arrays.asList(subId)));

        try {
            // Get all active subscriptions.
            List<SubscriptionInfo> activeSubInfos =
                    ShellIdentityUtils.invokeMethodWithShellPermissions(mSubscriptionManager,
                    (sm) -> sm.getActiveSubscriptionInfoList());

            List<Integer> activeSubGroup = getSubscriptionIdList(activeSubInfos);
            activeSubGroup.removeIf(id -> id == subId);

            ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(mSubscriptionManager,
                    (sm) -> sm.addSubscriptionsIntoGroup(activeSubGroup, uuid));

            List<Integer> infoList = ShellIdentityUtils.invokeMethodWithShellPermissions(
                    mSubscriptionManager,
                    (sm) -> getSubscriptionIdList(sm.getSubscriptionsInGroup(uuid)));

            activeSubGroup.add(subId);
            assertThat(infoList).containsExactlyElementsIn(activeSubGroup);
        } finally {
            removeSubscriptionsFromGroup(uuid);
        }
    }

    /**
     * This test verifies that {@link SubscriptionManager#addSubscriptionsIntoGroup(List,
     * ParcelUuid)}} correctly add some additional subscriptions to the existing group.
     *
     * <p>This test required the device has more than one subscription.
     */
    @Test
    public void testAddSubscriptionToExistingGroupForEsim() {
        assumeTrue(hasFeature(PackageManager.FEATURE_TELEPHONY_SUBSCRIPTION));
        assumeTrue(hasFeature(PackageManager.FEATURE_TELEPHONY_EUICC));
        // Set subscription group with current sub Id.
        int subId = SubscriptionManager.getDefaultSubscriptionId();
        if (subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) return;
        ParcelUuid uuid = mSubscriptionManager.createSubscriptionGroup(Arrays.asList(subId));

        try {
            // Get all accessible eSim subscription.
            List<SubscriptionInfo> accessibleSubInfos =
                    mSubscriptionManager.getAccessibleSubscriptionInfoList();
            if (accessibleSubInfos != null && accessibleSubInfos.size() > 1) {
                List<Integer> accessibleSubGroup = getSubscriptionIdList(accessibleSubInfos);
                accessibleSubGroup.removeIf(id -> id == subId);

                mSubscriptionManager.addSubscriptionsIntoGroup(accessibleSubGroup, uuid);

                List<Integer> infoList =
                        getSubscriptionIdList(mSubscriptionManager.getSubscriptionsInGroup(uuid));
                accessibleSubGroup.add(subId);
                assertThat(infoList).containsExactlyElementsIn(accessibleSubGroup);
            }
        } finally {
            removeSubscriptionsFromGroup(uuid);
        }
    }

    /**
     * This test verifies that {@link SubscriptionManager#setOpportunistic(boolean, int)} correctly
     * set the opportunistic property of the given subscription.
     */
    @Test
    public void testOpportunistic() {
        int subId = SubscriptionManager.getDefaultSubscriptionId();
        if (subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) return;
        SubscriptionInfo info = mSubscriptionManager.getActiveSubscriptionInfo(subId);
        boolean oldOpportunistic = info.isOpportunistic();
        boolean newOpportunistic = !oldOpportunistic;

        try {
            // Mark the given subscription as opportunistic subscription.
            assertThat(mSubscriptionManager.setOpportunistic(newOpportunistic, subId)).isTrue();

            // Verify that the given subscription is opportunistic subscription.
            info = mSubscriptionManager.getActiveSubscriptionInfo(subId);
            assertThat(info.isOpportunistic()).isEqualTo(newOpportunistic);
        } finally {
            // Set back to original opportunistic property.
            mSubscriptionManager.setOpportunistic(oldOpportunistic, subId);
            info = mSubscriptionManager.getActiveSubscriptionInfo(subId);
            assertThat(info.isOpportunistic()).isEqualTo(oldOpportunistic);

            // As opportunistic subscription can not be the default data/voice/sms subscription,
            // when the test case set the active subscription as opportunistic, the default
            // subscription may set to INVALID_SUBSCRIPTION_ID. Although at the end, the test case
            // tries to recover it, it may take time to fully take effort and fail the following
            // test case. Add a polling check of carrier privilege on default subscription here to
            // make sure default subscription has recovered before ending the case.
            PollingCheck.waitFor(5000, () -> getContext().getSystemService(TelephonyManager.class)
                    .hasCarrierPrivileges(),
                    "Timeout when waiting to gain carrier privileges again.");
        }
    }

    /**
     * This test verifies that {@link TelephonyManager#iccExchangeSimIO(int, int, int, int, int,
     * String)} correctly transmits iccIO commands to the UICC card. First, the MF is selected via a
     * SELECT apdu via the basic channel, then a STATUS AT-command is sent.
     */
    @Test
    public void testIccExchangeSimIO() {
        // select the MF first. This makes sure the next STATUS AT-command returns a FCP template
        // for the right file.
        int cla = CLA_SELECT;
        int p1 = 0; // select EF by FID
        int p2 = 0x0C; // requesting FCP template
        int p3 = 2; // length of 'data' payload
        String data = MF_FILE_ID;
        String response =
                mTelephonyManager.iccTransmitApduBasicChannel(
                        cla, COMMAND_SELECT, p1, p2, p3, data);
        assertThat(response).isEqualTo(STATUS_NORMAL_STRING);

        // The iccExchangeSimIO command implements the +CRSM command defined in TS 27.007 section
        // 8.18. A STATUS command is sent and the returned value will be an FCP template.
        byte[] result =
                mTelephonyManager.iccExchangeSimIO(
                        0, // fileId: not required for STATUS
                        COMMAND_STATUS, // command: STATUS
                        0, // p1: not required for STATUS
                        0, // p2: not required for STATUS
                        0, // p3: not required for STATUS
                        ""); // filePath: not required for STATUS
        String resultString = bytesToHexString(result);
        FcpTemplate fcpTemplate = FcpTemplate.parseFcpTemplate(resultString);
        assertThat(containsFileId(fcpTemplate, MF_FILE_ID)).isTrue();
        assertWithMessage("iccExchangeSimIO returned non-normal Status byte: %s", resultString)
                .that(fcpTemplate.getStatus())
                .isEqualTo(STATUS_NORMAL_STRING);
    }

    /**
     * This test checks that a STATUS apdu can be sent as an encapsulated envelope to the UICC via
     * {@link TelephonyManager#sendEnvelopeWithStatus(String)}.
     */
    @Test
    public void testSendEnvelopeWithStatus() {
        // STATUS apdu as hex String
        String envelope =
                CLA_STATUS_STRING
                        + COMMAND_STATUS_STRING
                        + "00" // p1: no indication of application status
                        + "00"; // p2: identical parameters to
        String response = mTelephonyManager.sendEnvelopeWithStatus(envelope);

        // TODO(b/137963715): add more specific assertions on response from TelMan#sendEnvelope
        assertWithMessage("sendEnvelopeWithStatus is null for envelope=%s", envelope)
                .that(response)
                .isNotNull();
    }

    /**
     * This test checks that applications with carrier privilege can set/clear signal strength
     * update request via {@link
     * TelephonyManager#setSignalStrengthUpdateRequest(SignalStrengthUpdateRequest)} and {@link
     * TelephonyManager#clearSignalStrengthUpdateRequest} without {@link
     * android.Manifest.permission#MODIFY_PHONE_STATE MODIFY_PHONE_STATE}.
     */
    @Test
    public void testSetClearSignalStrengthUpdateRequest() {
        final SignalStrengthUpdateRequest request =
                new SignalStrengthUpdateRequest.Builder()
                        .setSignalThresholdInfos(
                                List.of(
                                        new SignalThresholdInfo.Builder()
                                                .setRadioAccessNetworkType(
                                                        AccessNetworkConstants.AccessNetworkType
                                                                .GERAN)
                                                .setSignalMeasurementType(
                                                        SignalThresholdInfo
                                                                .SIGNAL_MEASUREMENT_TYPE_RSSI)
                                                .setThresholds(new int[] {-113, -103, -97, -51})
                                                .setHysteresisDb(1)
                                                .build()))
                        .setReportingRequestedWhileIdle(true)
                        .build();
        try {
            mTelephonyManager.setSignalStrengthUpdateRequest(request);
        } finally {
            mTelephonyManager.clearSignalStrengthUpdateRequest(request);
        }
    }

    private void verifyValidIccOpenLogicalChannelResponse(IccOpenLogicalChannelResponse response) {
        assertThat(response.getStatus()).isEqualTo(STATUS_NO_ERROR);
        assertThat(response.getSelectResponse()).isEqualTo(STATUS_NORMAL);

        // The assigned channel should be between the min and max allowed channel numbers
        int channel = response.getChannel();
        assertThat(channel).isIn(Range.closed(MIN_LOGICAL_CHANNEL, MAX_LOGICAL_CHANNEL));
    }

    private void removeSubscriptionsFromGroup(ParcelUuid uuid) {
        List<SubscriptionInfo> infoList = ShellIdentityUtils.invokeMethodWithShellPermissions(
                mSubscriptionManager,
                (sm) -> (sm.getSubscriptionsInGroup(uuid)));
        if (!infoList.isEmpty()) {
            List<Integer> subscriptionIdList = getSubscriptionIdList(infoList);
            ShellIdentityUtils.invokeMethodWithShellPermissionsNoReturn(mSubscriptionManager,
                    (sm) -> sm.removeSubscriptionsFromGroup(subscriptionIdList, uuid));
        }
        infoList = ShellIdentityUtils.invokeMethodWithShellPermissions(
                mSubscriptionManager,
                (sm) -> (sm.getSubscriptionsInGroup(uuid)));
        assertThat(infoList).isEmpty();
    }

    private List<Integer> getSubscriptionIdList(List<SubscriptionInfo> subInfoList) {
        if (subInfoList == null || subInfoList.isEmpty()) return Collections.EMPTY_LIST;
        return subInfoList.stream()
                .map(info -> info.getSubscriptionId())
                .collect(Collectors.toList());
    }

    /**
     * Checks whether the a {@code fcpTemplate} contains the given {@code fileId}.
     *
     * @param fcpTemplate The FCP Template to be checked.
     * @param fileId The file ID that is being searched for
     * @return true iff fcpTemplate contains fileId.
     */
    private boolean containsFileId(FcpTemplate fcpTemplate, String fileId) {
        return fcpTemplate.getTlvs().stream()
                .anyMatch(tlv -> tlv.getTag() == FILE_IDENTIFIER && tlv.getValue().equals(fileId));
    }

    /**
     * Returns true iff {@code response} indicates an error with the previous APDU.
     *
     * @param response The APDU response to be checked.
     * @return true iff the given response indicates an error occurred
     */
    private boolean isErrorResponse(@Nonnull String response) {
        return !(STATUS_NORMAL_STRING.equals(response)
                || response.startsWith(STATUS_WARNING_A)
                || response.startsWith(STATUS_WARNING_B)
                || response.startsWith(STATUS_BYTES_REMAINING));
    }

    private static class IntentReceiver extends BroadcastReceiver {
        private final CountDownLatch mReceiveLatch = new CountDownLatch(1);

        @Override
        public void onReceive(Context context, Intent intent) {
            mReceiveLatch.countDown();
        }

        public boolean waitForReceive() throws InterruptedException {
            return mReceiveLatch.await(30, TimeUnit.SECONDS);
        }
    }

    @Test
    public void testEapSimAuthentication() {
        assumeTrue(
                "testEapSimAuthentication requires a 2021 CTS UICC or newer",
                UiccUtil.uiccHasCertificate(CTS_UICC_2021));
        // K: '000102030405060708090A0B0C0D0E0F', defined by TS 134 108#8.2
        // n: 128 (Bits to use for RES value)
        // Format: [Length][RAND]
        String challenge = "10" + EAP_SIM_AKA_RAND;
        String base64Challenge = Base64.encodeToString(hexStringToBytes(challenge), Base64.NO_WRAP);
        String base64Response = null;
        try {
            base64Response = mTelephonyManager.getIccAuthentication(
                    TelephonyManager.APPTYPE_USIM,
                    TelephonyManager.AUTHTYPE_EAP_SIM,
                    base64Challenge);
        } catch (UnsupportedOperationException e) {
            assumeNoException("EAP-SIM not supported", e);
        }
        assertWithMessage("UICC returned null for EAP-SIM auth").that(base64Response).isNotNull();
        byte[] response = Base64.decode(base64Response, Base64.DEFAULT);
        assertWithMessage("Results for AUTHTYPE_EAP_SIM failed")
                .that(response)
                .isEqualTo(hexStringToBytes(EXPECTED_EAP_SIM_RESULT));
    }

    @Test
    public void testEapAkaAuthentication() {
        // Wear devices do not yet support EapAkaAuthentication, so skip this test for now
        // TODO: use REQUEST_NOT_SUPPORTED on Wear instead of skipping this test
        if (isWear()) {
            return;
        }
        assumeTrue(
                "testEapAkaAuthentication requires a 2021 CTS UICC or newer",
                UiccUtil.uiccHasCertificate(CTS_UICC_2021));
        // K: '000102030405060708090A0B0C0D0E0F', defined by TS 134 108#8.2
        // n: 128 (Bits to use for RES value)
        // Format: [Length][Rand][Length][Autn]
        String challenge = "10" + EAP_SIM_AKA_RAND + "10" + EAP_AKA_AUTN;
        String base64Challenge = Base64.encodeToString(hexStringToBytes(challenge), Base64.NO_WRAP);
        String base64Response = null;
        try {
            base64Response = mTelephonyManager.getIccAuthentication(
                    TelephonyManager.APPTYPE_USIM,
                    TelephonyManager.AUTHTYPE_EAP_AKA,
                    base64Challenge);
        } catch (UnsupportedOperationException ex) {
            assumeNoException("EAP-AKA not supported", ex);
        }

        assertWithMessage("UICC returned null for EAP-AKA auth").that(base64Response).isNotNull();
        byte[] response = Base64.decode(base64Response, Base64.NO_WRAP);

        // response may be formatted as: [DB][Length][RES][Length][CK][Length][IK][Length][Kc]
        byte[] akaResponse = Arrays.copyOfRange(response, 0, EAP_AKA_RESPONSE_LENGTH);
        assertWithMessage("Results for AUTHTYPE_EAP_AKA failed")
                .that(akaResponse)
                .isEqualTo(hexStringToBytes(EXPECTED_EAP_AKA_RESULT));
    }

    /**
     * This test checks that applications with carrier privilege can set/get data enable
     * state.
     */
    @Test
    public void testDataEnableRequest() {
        for (int i = DATA_ENABLED_REASON_USER; i <= DATA_ENABLED_REASON_THERMAL; i++) {
            mTelephonyManager.isDataEnabledForReason(i);
        }
        boolean isDataEnabled = mTelephonyManager.isDataEnabledForReason(
                TelephonyManager.DATA_ENABLED_REASON_CARRIER);
        mTelephonyManager.setDataEnabledForReason(
                TelephonyManager.DATA_ENABLED_REASON_CARRIER, !isDataEnabled);
        mTelephonyManager.setDataEnabledForReason(
                TelephonyManager.DATA_ENABLED_REASON_CARRIER, isDataEnabled);
    }

    /**
     * This test checks that applications with carrier privileges can get network slicing
     * configuration.
     */
    @Test
    public void testGetNetworkSlicingConfiguration() {
        CompletableFuture<NetworkSlicingConfig> resultFuture = new CompletableFuture<>();
        mTelephonyManager.getNetworkSlicingConfiguration(
                AsyncTask.SERIAL_EXECUTOR, resultFuture::complete);
    }

    private boolean isWear() {
        return getContext().getPackageManager().hasSystemFeature(PackageManager.FEATURE_WATCH);
    }

    /** Checks whether the telephony feature is supported. */
    private boolean hasFeature(String feature) {
        return mPackageManager == null ? false : mPackageManager.hasSystemFeature(feature);
    }

    /**
     * Tests that the device properly sets and pads the contents of EF_FPLMN
     */
    @Test
    public void testSetForbiddenPlmns() {
        assumeTrue(supportSetFplmn());

        String[] originalFplmns = mTelephonyManager.getForbiddenPlmns();
        assertNotNull(originalFplmns);
        try {
            int numFplmnsSet = mTelephonyManager.setForbiddenPlmns(FPLMN_TEST);
            String[] writtenFplmns = mTelephonyManager.getForbiddenPlmns();
            assertEquals("Wrong return value for setFplmns with less than required fplmns: "
                    + numFplmnsSet, FPLMN_TEST.size(), numFplmnsSet);
            assertEquals("Wrong Fplmns content written", FPLMN_TEST, Arrays.asList(writtenFplmns));
        } finally {
            // Restore
            mTelephonyManager.setForbiddenPlmns(Arrays.asList(originalFplmns));
        }
    }

    /**
     * Tests that the device properly truncates the contents of EF_FPLMN when provided size
     * is too big.
     */
    @Test
    public void testSetForbiddenPlmnsTruncate() {
        assumeTrue(supportSetFplmn());

        String[] originalFplmns = mTelephonyManager.getForbiddenPlmns();
        assertNotNull(originalFplmns);
        try {
            List<String> targetFplmns = new ArrayList<>();
            for (int i = 0; i < MIN_FPLMN_NUM; i++) {
                targetFplmns.add(PLMN_A);
            }
            for (int i = MIN_FPLMN_NUM; i < MAX_FPLMN_NUM; i++) {
                targetFplmns.add(PLMN_B);
            }
            int numFplmnsSet = mTelephonyManager.setForbiddenPlmns(targetFplmns);
            String[] writtenFplmns = mTelephonyManager.getForbiddenPlmns();
            assertTrue("Wrong return value for setFplmns with overflowing fplmns: " + numFplmnsSet,
                    numFplmnsSet < MAX_FPLMN_NUM);
            assertEquals("Number of Fplmns set does not equal number of Fplmns available",
                    numFplmnsSet, writtenFplmns.length);
            assertEquals("Wrong Fplmns content written", targetFplmns.subList(0, numFplmnsSet),
                    Arrays.asList(writtenFplmns));
        } finally {
            // Restore
            mTelephonyManager.setForbiddenPlmns(Arrays.asList(originalFplmns));
        }
    }

    /**
     * Tests that the device properly deletes the contents of EF_FPLMN
     */
    @Test
    public void testSetForbiddenPlmnsDelete() {
        assumeTrue(supportSetFplmn());

        String[] originalFplmns = mTelephonyManager.getForbiddenPlmns();
        assertNotNull(originalFplmns);
        try {
            // Support test for empty SIM
            List<String> targetDummyFplmns = new ArrayList<>();
            for (int i = 0; i < MIN_FPLMN_NUM; i++) {
                targetDummyFplmns.add(PLMN_A);
            }
            mTelephonyManager.setForbiddenPlmns(targetDummyFplmns);
            String[] writtenDummyFplmns = mTelephonyManager.getForbiddenPlmns();
            assertEquals(targetDummyFplmns, Arrays.asList(writtenDummyFplmns));

            List<String> targetFplmns = new ArrayList<>();
            int numFplmnsSet = mTelephonyManager.setForbiddenPlmns(targetFplmns);
            String[] writtenFplmns = mTelephonyManager.getForbiddenPlmns();
            assertEquals("Wrong return value for setFplmns with empty list", 0, numFplmnsSet);
            assertEquals("Wrong number of Fplmns written", 0, writtenFplmns.length);
            // TODO wait for 10 minutes or so for the FPLMNS list to grow back
        } finally {
            // Restore
            mTelephonyManager.setForbiddenPlmns(Arrays.asList(originalFplmns));
        }
    }

    /**
     * Tests that setForbiddenPlmns properly handles null input
     */
    @Test
    public void testSetForbiddenPlmnsVoid() {
        assumeTrue(supportSetFplmn());

        String[] originalFplmns = mTelephonyManager.getForbiddenPlmns();
        assertNotNull(originalFplmns);
        try {
            mTelephonyManager.setForbiddenPlmns(null);
            fail("Expected IllegalArgumentException. Null input is not allowed");
        } catch (IllegalArgumentException expected) {
        } finally {
            mTelephonyManager.setForbiddenPlmns(Arrays.asList(originalFplmns));
        }
    }

    @Test
    public void testSetAndGetSubscriptionPlan() {
        final int subId = getFirstActivateCarrierPrivilegedSubscriptionId();
        // This test case requires subscription with carrier privileges
        assumeFalse(subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID);

        final SubscriptionPlan plan = createTestSubscriptionPlan();
        try {
            mSubscriptionManager.setSubscriptionPlans(
                    subId, List.of(plan), SUB_PLAN_EXPIRATION_DURATION);
        } catch (SecurityException se) {
            fail("setSubscriptionPlans with carrier privilege throws " + se);
        }

        try {
            List<SubscriptionPlan> plans = mSubscriptionManager.getSubscriptionPlans(subId);
            assertThat(plans).isNotEmpty();
            SubscriptionPlan retrievedPlan = plans.get(0);
            assertThat(retrievedPlan).isEqualTo(plan);
        } catch (SecurityException se) {
            fail("getSubscriptionPlans with carrier privilege throws " + se);
        }
    }

    @Test
    public void testSetSubscriptionOverrideUnmetered() {
        final int subId = getFirstActivateCarrierPrivilegedSubscriptionId();
        // This test case requires subscription with carrier privileges
        assumeFalse(subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID);

        try {
            mSubscriptionManager.setSubscriptionOverrideUnmetered(
                    subId, true, SUB_PLAN_EXPIRATION_DURATION);
        } catch (SecurityException se) {
            fail("setSubscriptionOverrideUnmetered with carrier privilege throws " + se);
        }
    }

    @Test
    public void testSetSubscriptionOverrideCongested() {
        final int subId = getFirstActivateCarrierPrivilegedSubscriptionId();
        // This test case requires subscription with carrier privileges
        assumeFalse(subId == SubscriptionManager.INVALID_SUBSCRIPTION_ID);

        SubscriptionPlan plan = createTestSubscriptionPlan();
        try {
            mSubscriptionManager.setSubscriptionPlans(
                    subId, List.of(plan), SUB_PLAN_EXPIRATION_DURATION);
            mSubscriptionManager.setSubscriptionOverrideCongested(
                    subId, true, SUB_PLAN_EXPIRATION_DURATION);
        } catch (SecurityException se) {
            fail("setSubscriptionOverrideCongested with carrier privilege throws " + se);
        }
    }

    /**
     * Verify that the phone is supporting the action of setForbiddenPlmn.
     *
     * @return whether to proceed the test
     */
    private boolean supportSetFplmn() {
        if (!hasFeature(PackageManager.FEATURE_TELEPHONY_SUBSCRIPTION)) {
            return false;
        }
        return mTelephonyManager.getPhoneType() == TelephonyManager.PHONE_TYPE_GSM;
    }

    private SubscriptionPlan createTestSubscriptionPlan() {
        return SubscriptionPlan.Builder.createNonrecurring(SUB_PLAN_START, SUB_PLAN_END)
                .setDataLimit(SUB_PLAN_DATA_LIMIT_BYTES, SubscriptionPlan.LIMIT_BEHAVIOR_THROTTLED)
                .setTitle(SUB_PLAN_TITLE)
                .setSummary(SUB_PLAN_SUMMARY)
                .build();
    }
}