Home | History | Annotate | Download | only in telephony
      1 /*
      2  * Copyright (C) 2015 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License
     15  */
     16 
     17 package com.android.internal.telephony;
     18 
     19 import android.content.pm.ApplicationInfo;
     20 import android.content.pm.IPackageManager;
     21 import android.content.pm.PackageManager;
     22 import android.os.Bundle;
     23 import android.provider.Settings;
     24 import android.telephony.TelephonyManager;
     25 import android.test.InstrumentationTestCase;
     26 import android.test.mock.MockContentProvider;
     27 import android.test.mock.MockContentResolver;
     28 import android.test.suitebuilder.annotation.SmallTest;
     29 import android.util.ArrayMap;
     30 import android.util.ArraySet;
     31 
     32 import org.junit.Test;
     33 import org.mockito.Mock;
     34 import org.mockito.Mockito;
     35 import org.mockito.MockitoAnnotations;
     36 
     37 import java.util.ArrayList;
     38 import java.util.List;
     39 
     40 public class CarrierAppUtilsTest extends InstrumentationTestCase {
     41     private static final String CARRIER_APP = "com.example.carrier";
     42     private static final ArraySet<String> CARRIER_APPS = new ArraySet<>();
     43     static {
     44         CARRIER_APPS.add(CARRIER_APP);
     45     }
     46 
     47     private static final String ASSOCIATED_APP = "com.example.associated";
     48     private static final ArrayMap<String, List<String>> ASSOCIATED_APPS = new ArrayMap<>();
     49     static {
     50         List<String> associatedAppList = new ArrayList<>();
     51         associatedAppList.add(ASSOCIATED_APP);
     52         ASSOCIATED_APPS.put(CARRIER_APP, associatedAppList);
     53     }
     54     private static final int USER_ID = 12345;
     55     private static final String CALLING_PACKAGE = "phone";
     56 
     57     @Mock private IPackageManager mPackageManager;
     58     @Mock private TelephonyManager mTelephonyManager;
     59     private SettingsMockContentProvider mContentProvider;
     60     private MockContentResolver mContentResolver;
     61 
     62     @Override
     63     public void setUp() throws Exception {
     64         super.setUp();
     65         System.setProperty("dexmaker.dexcache",
     66                 getInstrumentation().getTargetContext().getCacheDir().getPath());
     67         Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
     68         MockitoAnnotations.initMocks(this);
     69 
     70         mContentResolver = new MockContentResolver();
     71         mContentProvider = new SettingsMockContentProvider();
     72         mContentResolver.addProvider(Settings.AUTHORITY, mContentProvider);
     73         Settings.Secure.putIntForUser(
     74                 mContentResolver, Settings.Secure.CARRIER_APPS_HANDLED, 0, USER_ID);
     75     }
     76 
     77     /** No apps configured - should do nothing. */
     78     @Test @SmallTest
     79     public void testDisableCarrierAppsUntilPrivileged_EmptyList() {
     80         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
     81                 mTelephonyManager, mContentResolver, USER_ID, new ArraySet<>(),
     82                 ASSOCIATED_APPS);
     83         Mockito.verifyNoMoreInteractions(mPackageManager, mTelephonyManager);
     84     }
     85 
     86     /** Configured app is missing - should do nothing. */
     87     @Test @SmallTest
     88     public void testDisableCarrierAppsUntilPrivileged_MissingApp() throws Exception {
     89         Mockito.when(mPackageManager.getApplicationInfo("com.example.missing.app",
     90                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(null);
     91         ArraySet<String> systemCarrierAppsDisabledUntilUsed = new ArraySet<>();
     92         systemCarrierAppsDisabledUntilUsed.add("com.example.missing.app");
     93         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
     94                 mTelephonyManager, mContentResolver, USER_ID,
     95                 systemCarrierAppsDisabledUntilUsed, ASSOCIATED_APPS);
     96         Mockito.verify(mPackageManager, Mockito.never()).setApplicationEnabledSetting(
     97                 Mockito.anyString(), Mockito.anyInt(), Mockito.anyInt(), Mockito.anyInt(),
     98                 Mockito.anyString());
     99         Mockito.verify(mPackageManager, Mockito.never())
    100                 .grantDefaultPermissionsToEnabledCarrierApps(Mockito.any(String[].class),
    101                         Mockito.anyInt());
    102         Mockito.verifyNoMoreInteractions(mTelephonyManager);
    103     }
    104 
    105     /** Configured app is not bundled with the system - should do nothing. */
    106     @Test @SmallTest
    107     public void testDisableCarrierAppsUntilPrivileged_NonSystemApp() throws Exception {
    108         ApplicationInfo appInfo = new ApplicationInfo();
    109         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    110                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    111         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    112                 mTelephonyManager, mContentResolver, USER_ID, CARRIER_APPS, ASSOCIATED_APPS);
    113         Mockito.verify(mPackageManager, Mockito.never()).setApplicationEnabledSetting(
    114                 Mockito.anyString(), Mockito.anyInt(), Mockito.anyInt(), Mockito.anyInt(),
    115                 Mockito.anyString());
    116         Mockito.verify(mPackageManager, Mockito.never())
    117                 .grantDefaultPermissionsToEnabledCarrierApps(
    118                         Mockito.any(String[].class), Mockito.anyInt());
    119         Mockito.verifyNoMoreInteractions(mTelephonyManager);
    120     }
    121 
    122     /**
    123      * Configured app has privileges, but was disabled by the user - should only grant
    124      * permissions.
    125      */
    126     @Test @SmallTest
    127     public void testDisableCarrierAppsUntilPrivileged_HasPrivileges_DisabledUser()
    128             throws Exception {
    129         ApplicationInfo appInfo = new ApplicationInfo();
    130         appInfo.packageName = CARRIER_APP;
    131         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    132         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER;
    133         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    134                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    135         Mockito.when(mTelephonyManager.checkCarrierPrivilegesForPackageAnyPhone(CARRIER_APP))
    136                 .thenReturn(TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS);
    137         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    138                 mTelephonyManager, mContentResolver, USER_ID, CARRIER_APPS, ASSOCIATED_APPS);
    139         Mockito.verify(mPackageManager, Mockito.never()).setApplicationEnabledSetting(
    140                 Mockito.anyString(), Mockito.anyInt(), Mockito.anyInt(), Mockito.anyInt(),
    141                 Mockito.anyString());
    142         Mockito.verify(mPackageManager).grantDefaultPermissionsToEnabledCarrierApps(
    143                 new String[] {appInfo.packageName}, USER_ID);
    144     }
    145 
    146     /** Configured app has privileges, but was disabled - should only grant permissions. */
    147     @Test @SmallTest
    148     public void testDisableCarrierAppsUntilPrivileged_HasPrivileges_Disabled() throws Exception {
    149         ApplicationInfo appInfo = new ApplicationInfo();
    150         appInfo.packageName = CARRIER_APP;
    151         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    152         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DISABLED;
    153         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    154                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    155         Mockito.when(mTelephonyManager.checkCarrierPrivilegesForPackageAnyPhone(CARRIER_APP))
    156                 .thenReturn(TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS);
    157         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    158                 mTelephonyManager, mContentResolver, USER_ID, CARRIER_APPS, ASSOCIATED_APPS);
    159         Mockito.verify(mPackageManager, Mockito.never()).setApplicationEnabledSetting(
    160                 Mockito.anyString(), Mockito.anyInt(), Mockito.anyInt(), Mockito.anyInt(),
    161                 Mockito.anyString());
    162         Mockito.verify(mPackageManager).grantDefaultPermissionsToEnabledCarrierApps(
    163                 new String[] {appInfo.packageName}, USER_ID);
    164     }
    165 
    166     /** Configured app has privileges, and is already enabled - should only grant permissions. */
    167     @Test @SmallTest
    168     public void testDisableCarrierAppsUntilPrivileged_HasPrivileges_Enabled() throws Exception {
    169         ApplicationInfo appInfo = new ApplicationInfo();
    170         appInfo.packageName = CARRIER_APP;
    171         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    172         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_ENABLED;
    173         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    174                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    175         Mockito.when(mTelephonyManager.checkCarrierPrivilegesForPackageAnyPhone(CARRIER_APP))
    176                 .thenReturn(TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS);
    177         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    178                 mTelephonyManager, mContentResolver, USER_ID, CARRIER_APPS, ASSOCIATED_APPS);
    179         Mockito.verify(mPackageManager, Mockito.never()).setApplicationEnabledSetting(
    180                 Mockito.anyString(), Mockito.anyInt(), Mockito.anyInt(), Mockito.anyInt(),
    181                 Mockito.anyString());
    182         Mockito.verify(mPackageManager).grantDefaultPermissionsToEnabledCarrierApps(
    183                 new String[] {appInfo.packageName}, USER_ID);
    184     }
    185 
    186     /** Configured /data app has privileges - should only grant permissions. */
    187     @Test @SmallTest
    188     public void testDisableCarrierAppsUntilPrivileged_HasPrivileges_UpdatedApp() throws Exception {
    189         ApplicationInfo appInfo = new ApplicationInfo();
    190         appInfo.packageName = CARRIER_APP;
    191         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM | ApplicationInfo.FLAG_UPDATED_SYSTEM_APP;
    192         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_ENABLED;
    193         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    194                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    195         Mockito.when(mTelephonyManager.checkCarrierPrivilegesForPackageAnyPhone(CARRIER_APP))
    196                 .thenReturn(TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS);
    197         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    198                 mTelephonyManager, mContentResolver, USER_ID, CARRIER_APPS, ASSOCIATED_APPS);
    199         Mockito.verify(mPackageManager, Mockito.never()).setApplicationEnabledSetting(
    200                 Mockito.anyString(), Mockito.anyInt(), Mockito.anyInt(), Mockito.anyInt(),
    201                 Mockito.anyString());
    202         Mockito.verify(mPackageManager).grantDefaultPermissionsToEnabledCarrierApps(
    203                 new String[] {appInfo.packageName}, USER_ID);
    204     }
    205 
    206     /**
    207      * Configured app has privileges, and is in the default state - should enable. Associated app
    208      * is missing and should not be touched.
    209      */
    210     @Test @SmallTest
    211     public void testDisableCarrierAppsUntilPrivileged_HasPrivileges_MissingAssociated_Default()
    212             throws Exception {
    213         ApplicationInfo appInfo = new ApplicationInfo();
    214         appInfo.packageName = CARRIER_APP;
    215         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    216         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
    217         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    218                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID))
    219                 .thenReturn(appInfo);
    220         Mockito.when(mTelephonyManager.checkCarrierPrivilegesForPackageAnyPhone(CARRIER_APP))
    221                 .thenReturn(TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS);
    222         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    223                 mTelephonyManager, mContentResolver, USER_ID, CARRIER_APPS, ASSOCIATED_APPS);
    224         Mockito.verify(mPackageManager).setApplicationEnabledSetting(
    225                 CARRIER_APP, PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
    226                 PackageManager.DONT_KILL_APP, USER_ID, CALLING_PACKAGE);
    227         Mockito.verify(mPackageManager, Mockito.never()).setApplicationEnabledSetting(
    228                 ASSOCIATED_APP, PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
    229                 PackageManager.DONT_KILL_APP, USER_ID, CALLING_PACKAGE);
    230         Mockito.verify(mPackageManager).grantDefaultPermissionsToEnabledCarrierApps(
    231                 new String[] {appInfo.packageName}, USER_ID);
    232     }
    233 
    234     /**
    235      * Configured app has privileges, and is in the default state along with associated app - should
    236      * enable both.
    237      */
    238     @Test @SmallTest
    239     public void testDisableCarrierAppsUntilPrivileged_HasPrivileges_Associated_Default()
    240             throws Exception {
    241         // Enabling should be done even if this isn't the first run.
    242         Settings.Secure.putIntForUser(
    243                 mContentResolver, Settings.Secure.CARRIER_APPS_HANDLED, 1, USER_ID);
    244         ApplicationInfo appInfo = new ApplicationInfo();
    245         appInfo.packageName = CARRIER_APP;
    246         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    247         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
    248         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    249                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID))
    250                 .thenReturn(appInfo);
    251         ApplicationInfo associatedAppInfo = new ApplicationInfo();
    252         associatedAppInfo.packageName = ASSOCIATED_APP;
    253         associatedAppInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    254         associatedAppInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
    255         Mockito.when(mPackageManager.getApplicationInfo(ASSOCIATED_APP,
    256                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID))
    257                 .thenReturn(associatedAppInfo);
    258         Mockito.when(mTelephonyManager.checkCarrierPrivilegesForPackageAnyPhone(CARRIER_APP))
    259                 .thenReturn(TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS);
    260         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    261                 mTelephonyManager, mContentResolver, USER_ID, CARRIER_APPS, ASSOCIATED_APPS);
    262         Mockito.verify(mPackageManager).setApplicationEnabledSetting(
    263                 CARRIER_APP, PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
    264                 PackageManager.DONT_KILL_APP, USER_ID, CALLING_PACKAGE);
    265         Mockito.verify(mPackageManager).setApplicationEnabledSetting(
    266                 ASSOCIATED_APP, PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
    267                 PackageManager.DONT_KILL_APP, USER_ID, CALLING_PACKAGE);
    268         Mockito.verify(mPackageManager).grantDefaultPermissionsToEnabledCarrierApps(
    269                 new String[] {appInfo.packageName}, USER_ID);
    270     }
    271 
    272     /**
    273      * Configured app has privileges, and is disabled until used - should enable. Associated app has
    274      * been updated and should not be touched.
    275      */
    276     @Test @SmallTest
    277     public void testDisableCarrierAppsUntilPrivileged_HasPrivileges_UpdatedAssociated_DisabledUntilUsed()
    278             throws Exception {
    279         ApplicationInfo appInfo = new ApplicationInfo();
    280         appInfo.packageName = CARRIER_APP;
    281         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    282         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED;
    283         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    284                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    285         ApplicationInfo associatedAppInfo = new ApplicationInfo();
    286         associatedAppInfo.packageName = ASSOCIATED_APP;
    287         associatedAppInfo.flags |=
    288                 ApplicationInfo.FLAG_SYSTEM | ApplicationInfo.FLAG_UPDATED_SYSTEM_APP;
    289         associatedAppInfo.enabledSetting =
    290                 PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED;
    291         Mockito.when(mPackageManager.getApplicationInfo(ASSOCIATED_APP,
    292                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID))
    293                 .thenReturn(associatedAppInfo);
    294         Mockito.when(mTelephonyManager.checkCarrierPrivilegesForPackageAnyPhone(CARRIER_APP))
    295                 .thenReturn(TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS);
    296         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    297                 mTelephonyManager, mContentResolver, USER_ID, CARRIER_APPS, ASSOCIATED_APPS);
    298         Mockito.verify(mPackageManager).setApplicationEnabledSetting(
    299                 CARRIER_APP, PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
    300                 PackageManager.DONT_KILL_APP, USER_ID, CALLING_PACKAGE);
    301         Mockito.verify(mPackageManager, Mockito.never()).setApplicationEnabledSetting(
    302                 ASSOCIATED_APP, PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
    303                 PackageManager.DONT_KILL_APP, USER_ID, CALLING_PACKAGE);
    304         Mockito.verify(mPackageManager).grantDefaultPermissionsToEnabledCarrierApps(
    305                 new String[] {appInfo.packageName}, USER_ID);
    306     }
    307 
    308     /**
    309      * Configured app has privileges, and is disabled until used along with associated app - should
    310      * enable both.
    311      */
    312     @Test @SmallTest
    313     public void testDisableCarrierAppsUntilPrivileged_HasPrivileges_Associated_DisabledUntilUsed()
    314             throws Exception {
    315         ApplicationInfo appInfo = new ApplicationInfo();
    316         appInfo.packageName = CARRIER_APP;
    317         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    318         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED;
    319         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    320                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    321         ApplicationInfo associatedAppInfo = new ApplicationInfo();
    322         associatedAppInfo.packageName = ASSOCIATED_APP;
    323         associatedAppInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    324         associatedAppInfo.enabledSetting =
    325                 PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED;
    326         Mockito.when(mPackageManager.getApplicationInfo(ASSOCIATED_APP,
    327                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID))
    328                 .thenReturn(associatedAppInfo);
    329         Mockito.when(mTelephonyManager.checkCarrierPrivilegesForPackageAnyPhone(CARRIER_APP))
    330                 .thenReturn(TelephonyManager.CARRIER_PRIVILEGE_STATUS_HAS_ACCESS);
    331         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    332                 mTelephonyManager, mContentResolver, USER_ID, CARRIER_APPS, ASSOCIATED_APPS);
    333         Mockito.verify(mPackageManager).setApplicationEnabledSetting(
    334                 CARRIER_APP, PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
    335                 PackageManager.DONT_KILL_APP, USER_ID, CALLING_PACKAGE);
    336         Mockito.verify(mPackageManager).setApplicationEnabledSetting(
    337                 ASSOCIATED_APP, PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
    338                 PackageManager.DONT_KILL_APP, USER_ID, CALLING_PACKAGE);
    339         Mockito.verify(mPackageManager).grantDefaultPermissionsToEnabledCarrierApps(
    340                 new String[] {appInfo.packageName}, USER_ID);
    341     }
    342 
    343     /** Configured app has no privileges, and was disabled by the user - should do nothing. */
    344     @Test @SmallTest
    345     public void testDisableCarrierAppsUntilPrivileged_NoPrivileges_DisabledUser() throws Exception {
    346         ApplicationInfo appInfo = new ApplicationInfo();
    347         appInfo.packageName = CARRIER_APP;
    348         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    349         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER;
    350         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    351                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    352         Mockito.when(mTelephonyManager.checkCarrierPrivilegesForPackageAnyPhone(CARRIER_APP))
    353                 .thenReturn(TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS);
    354         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    355                 mTelephonyManager, mContentResolver, USER_ID, CARRIER_APPS, ASSOCIATED_APPS);
    356         Mockito.verify(mPackageManager, Mockito.never()).setApplicationEnabledSetting(
    357                 Mockito.anyString(), Mockito.anyInt(), Mockito.anyInt(), Mockito.anyInt(),
    358                 Mockito.anyString());
    359         Mockito.verify(mPackageManager, Mockito.never())
    360                 .grantDefaultPermissionsToEnabledCarrierApps(
    361                         Mockito.any(String[].class), Mockito.anyInt());
    362     }
    363 
    364     /** Telephony is not initialized, and app was disabled by the user - should do nothing. */
    365     @Test @SmallTest
    366     public void testDisableCarrierAppsUntilPrivileged_NullPrivileges_DisabledUser()
    367             throws Exception {
    368         ApplicationInfo appInfo = new ApplicationInfo();
    369         appInfo.packageName = CARRIER_APP;
    370         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    371         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER;
    372         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    373                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    374         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    375                 null /* telephonyManager */, mContentResolver, USER_ID, CARRIER_APPS,
    376                 ASSOCIATED_APPS);
    377         Mockito.verify(mPackageManager, Mockito.never()).setApplicationEnabledSetting(
    378                 Mockito.anyString(), Mockito.anyInt(), Mockito.anyInt(), Mockito.anyInt(),
    379                 Mockito.anyString());
    380         Mockito.verify(mPackageManager, Mockito.never())
    381                 .grantDefaultPermissionsToEnabledCarrierApps(
    382                         Mockito.any(String[].class), Mockito.anyInt());
    383     }
    384 
    385     /** Configured app has no privileges, and was disabled - should do nothing. */
    386     @Test @SmallTest
    387     public void testDisableCarrierAppsUntilPrivileged_NoPrivileges_Disabled() throws Exception {
    388         ApplicationInfo appInfo = new ApplicationInfo();
    389         appInfo.packageName = CARRIER_APP;
    390         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    391         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DISABLED;
    392         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    393                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    394         Mockito.when(mTelephonyManager.checkCarrierPrivilegesForPackageAnyPhone(CARRIER_APP))
    395                 .thenReturn(TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS);
    396         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    397                 mTelephonyManager, mContentResolver, USER_ID, CARRIER_APPS, ASSOCIATED_APPS);
    398         Mockito.verify(mPackageManager, Mockito.never()).setApplicationEnabledSetting(
    399                 Mockito.anyString(), Mockito.anyInt(), Mockito.anyInt(), Mockito.anyInt(),
    400                 Mockito.anyString());
    401         Mockito.verify(mPackageManager, Mockito.never())
    402                 .grantDefaultPermissionsToEnabledCarrierApps(
    403                         Mockito.any(String[].class), Mockito.anyInt());
    404     }
    405 
    406     /** Telephony is not initialized, and app was disabled - should do nothing. */
    407     @Test @SmallTest
    408     public void testDisableCarrierAppsUntilPrivileged_NullPrivileges_Disabled() throws Exception {
    409         ApplicationInfo appInfo = new ApplicationInfo();
    410         appInfo.packageName = CARRIER_APP;
    411         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    412         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DISABLED;
    413         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    414                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    415         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    416                 null /* telephonyManager */, mContentResolver, USER_ID, CARRIER_APPS,
    417                 ASSOCIATED_APPS);
    418         Mockito.verify(mPackageManager, Mockito.never()).setApplicationEnabledSetting(
    419                 Mockito.anyString(), Mockito.anyInt(), Mockito.anyInt(), Mockito.anyInt(),
    420                 Mockito.anyString());
    421         Mockito.verify(mPackageManager, Mockito.never())
    422                 .grantDefaultPermissionsToEnabledCarrierApps(
    423                         Mockito.any(String[].class), Mockito.anyInt());
    424     }
    425 
    426     /** Configured app has no privileges, and is explicitly enabled - should do nothing. */
    427     @Test @SmallTest
    428     public void testDisableCarrierAppsUntilPrivileged_NoPrivileges_Enabled() throws Exception {
    429         ApplicationInfo appInfo = new ApplicationInfo();
    430         appInfo.packageName = CARRIER_APP;
    431         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    432         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_ENABLED;
    433         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    434                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    435         Mockito.when(mTelephonyManager.checkCarrierPrivilegesForPackageAnyPhone(CARRIER_APP))
    436                 .thenReturn(TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS);
    437         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    438                 mTelephonyManager, mContentResolver, USER_ID, CARRIER_APPS, ASSOCIATED_APPS);
    439         Mockito.verify(mPackageManager, Mockito.never()).setApplicationEnabledSetting(
    440                 Mockito.anyString(), Mockito.anyInt(), Mockito.anyInt(), Mockito.anyInt(),
    441                 Mockito.anyString());
    442         Mockito.verify(mPackageManager, Mockito.never())
    443                 .grantDefaultPermissionsToEnabledCarrierApps(
    444                         Mockito.any(String[].class), Mockito.anyInt());
    445     }
    446 
    447     /** Telephony is not initialized, and app is explicitly enabled - should do nothing. */
    448     @Test @SmallTest
    449     public void testDisableCarrierAppsUntilPrivileged_NullPrivileges_Enabled() throws Exception {
    450         ApplicationInfo appInfo = new ApplicationInfo();
    451         appInfo.packageName = CARRIER_APP;
    452         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    453         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_ENABLED;
    454         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    455                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    456         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    457                 null /* telephonyManager */, mContentResolver, USER_ID, CARRIER_APPS,
    458                 ASSOCIATED_APPS);
    459         Mockito.verify(mPackageManager, Mockito.never()).setApplicationEnabledSetting(
    460                 Mockito.anyString(), Mockito.anyInt(), Mockito.anyInt(), Mockito.anyInt(),
    461                 Mockito.anyString());
    462         Mockito.verify(mPackageManager, Mockito.never())
    463                 .grantDefaultPermissionsToEnabledCarrierApps(
    464                         Mockito.any(String[].class), Mockito.anyInt());
    465     }
    466 
    467     /** Configured /data app has no privileges - should do nothing. */
    468     @Test @SmallTest
    469     public void testDisableCarrierAppsUntilPrivileged_NoPrivileges_UpdatedApp() throws Exception {
    470         ApplicationInfo appInfo = new ApplicationInfo();
    471         appInfo.packageName = CARRIER_APP;
    472         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM | ApplicationInfo.FLAG_UPDATED_SYSTEM_APP;
    473         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_ENABLED;
    474         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    475                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    476         Mockito.when(mTelephonyManager.checkCarrierPrivilegesForPackageAnyPhone(CARRIER_APP))
    477                 .thenReturn(TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS);
    478         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    479                 mTelephonyManager, mContentResolver, USER_ID, CARRIER_APPS, ASSOCIATED_APPS);
    480         Mockito.verify(mPackageManager, Mockito.never()).setApplicationEnabledSetting(
    481                 Mockito.anyString(), Mockito.anyInt(), Mockito.anyInt(), Mockito.anyInt(),
    482                 Mockito.anyString());
    483         Mockito.verify(mPackageManager, Mockito.never())
    484                 .grantDefaultPermissionsToEnabledCarrierApps(
    485                         Mockito.any(String[].class), Mockito.anyInt());
    486     }
    487 
    488     /** Telephony is not initialized and app is in /data - should do nothing. */
    489     @Test @SmallTest
    490     public void testDisableCarrierAppsUntilPrivileged_NullPrivileges_UpdatedApp() throws Exception {
    491         ApplicationInfo appInfo = new ApplicationInfo();
    492         appInfo.packageName = CARRIER_APP;
    493         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM | ApplicationInfo.FLAG_UPDATED_SYSTEM_APP;
    494         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_ENABLED;
    495         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    496                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    497         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    498                 null /* telephonyManager */, mContentResolver, USER_ID, CARRIER_APPS,
    499                 ASSOCIATED_APPS);
    500         Mockito.verify(mPackageManager, Mockito.never()).setApplicationEnabledSetting(
    501                 Mockito.anyString(), Mockito.anyInt(), Mockito.anyInt(), Mockito.anyInt(),
    502                 Mockito.anyString());
    503         Mockito.verify(mPackageManager, Mockito.never())
    504                 .grantDefaultPermissionsToEnabledCarrierApps(
    505                         Mockito.any(String[].class), Mockito.anyInt());
    506     }
    507 
    508     /**
    509      * Configured app has no privileges, and is in the default state - should disable until use.
    510      * Associated app is enabled and should not be touched.
    511      */
    512     @Test @SmallTest
    513     public void testDisableCarrierAppsUntilPrivileged_NoPrivileges_EnabledAssociated_Default()
    514             throws Exception {
    515         ApplicationInfo appInfo = new ApplicationInfo();
    516         appInfo.packageName = CARRIER_APP;
    517         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    518         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
    519         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    520                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    521         ApplicationInfo associatedAppInfo = new ApplicationInfo();
    522         associatedAppInfo.packageName = ASSOCIATED_APP;
    523         associatedAppInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    524         associatedAppInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_ENABLED;
    525         Mockito.when(mPackageManager.getApplicationInfo(ASSOCIATED_APP,
    526                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID))
    527                 .thenReturn(associatedAppInfo);
    528         Mockito.when(mTelephonyManager.checkCarrierPrivilegesForPackageAnyPhone(CARRIER_APP))
    529                 .thenReturn(TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS);
    530         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    531                 mTelephonyManager, mContentResolver, USER_ID, CARRIER_APPS, ASSOCIATED_APPS);
    532         Mockito.verify(mPackageManager).setApplicationEnabledSetting(
    533                 CARRIER_APP, PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED, 0, USER_ID,
    534                 CALLING_PACKAGE);
    535         Mockito.verify(mPackageManager, Mockito.never()).setApplicationEnabledSetting(
    536                 ASSOCIATED_APP, PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED, 0,
    537                 USER_ID, CALLING_PACKAGE);
    538         Mockito.verify(mPackageManager, Mockito.never())
    539                 .grantDefaultPermissionsToEnabledCarrierApps(
    540                         Mockito.any(String[].class), Mockito.anyInt());
    541     }
    542 
    543     /**
    544      * Configured app has no privileges, and is in the default state along with associated app -
    545      * should disable both.
    546      */
    547     @Test @SmallTest
    548     public void testDisableCarrierAppsUntilPrivileged_NoPrivileges_Associated_Default()
    549             throws Exception {
    550         ApplicationInfo appInfo = new ApplicationInfo();
    551         appInfo.packageName = CARRIER_APP;
    552         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    553         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
    554         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    555                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    556         ApplicationInfo associatedAppInfo = new ApplicationInfo();
    557         associatedAppInfo.packageName = ASSOCIATED_APP;
    558         associatedAppInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    559         associatedAppInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
    560         Mockito.when(mPackageManager.getApplicationInfo(ASSOCIATED_APP,
    561                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID))
    562                 .thenReturn(associatedAppInfo);
    563         Mockito.when(mTelephonyManager.checkCarrierPrivilegesForPackageAnyPhone(CARRIER_APP))
    564                 .thenReturn(TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS);
    565         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    566                 mTelephonyManager, mContentResolver, USER_ID, CARRIER_APPS, ASSOCIATED_APPS);
    567         Mockito.verify(mPackageManager).setApplicationEnabledSetting(
    568                 CARRIER_APP, PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED, 0, USER_ID,
    569                 CALLING_PACKAGE);
    570         Mockito.verify(mPackageManager).setApplicationEnabledSetting(
    571                 ASSOCIATED_APP, PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED, 0,
    572                 USER_ID, CALLING_PACKAGE);
    573         Mockito.verify(mPackageManager, Mockito.never())
    574                 .grantDefaultPermissionsToEnabledCarrierApps(
    575                         Mockito.any(String[].class), Mockito.anyInt());
    576     }
    577 
    578     /**
    579      * Configured app has no privileges, and is in the default state along with associated app, and
    580      * disabling has already occurred - should only disable configured app.
    581      */
    582     @Test @SmallTest
    583     public void testDisableCarrierAppsUntilPrivileged_NoPrivileges_Associated_Default_AlreadyRun()
    584             throws Exception {
    585         Settings.Secure.putIntForUser(
    586                 mContentResolver, Settings.Secure.CARRIER_APPS_HANDLED, 1, USER_ID);
    587         ApplicationInfo appInfo = new ApplicationInfo();
    588         appInfo.packageName = CARRIER_APP;
    589         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    590         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
    591         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    592                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    593         ApplicationInfo associatedAppInfo = new ApplicationInfo();
    594         associatedAppInfo.packageName = ASSOCIATED_APP;
    595         associatedAppInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    596         associatedAppInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
    597         Mockito.when(mPackageManager.getApplicationInfo(ASSOCIATED_APP,
    598                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID))
    599                 .thenReturn(associatedAppInfo);
    600         Mockito.when(mTelephonyManager.checkCarrierPrivilegesForPackageAnyPhone(CARRIER_APP))
    601                 .thenReturn(TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS);
    602         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    603                 mTelephonyManager, mContentResolver, USER_ID, CARRIER_APPS, ASSOCIATED_APPS);
    604         Mockito.verify(mPackageManager).setApplicationEnabledSetting(
    605                 CARRIER_APP, PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED, 0, USER_ID,
    606                 CALLING_PACKAGE);
    607         Mockito.verify(mPackageManager, Mockito.never()).setApplicationEnabledSetting(
    608                 Mockito.eq(ASSOCIATED_APP), Mockito.anyInt(), Mockito.anyInt(), Mockito.anyInt(),
    609                 Mockito.anyString());
    610         Mockito.verify(mPackageManager, Mockito.never())
    611                 .grantDefaultPermissionsToEnabledCarrierApps(
    612                         Mockito.any(String[].class), Mockito.anyInt());
    613     }
    614 
    615     /** Telephony is not initialized, and app is in the default state - should disable until use. */
    616     @Test @SmallTest
    617     public void testDisableCarrierAppsUntilPrivileged_NullPrivileges_Default() throws Exception {
    618         ApplicationInfo appInfo = new ApplicationInfo();
    619         appInfo.packageName = CARRIER_APP;
    620         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    621         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
    622         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    623                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    624         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    625                 null /* telephonyManager */, mContentResolver, USER_ID, CARRIER_APPS,
    626                 ASSOCIATED_APPS);
    627         Mockito.verify(mPackageManager).setApplicationEnabledSetting(
    628                 CARRIER_APP, PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED, 0, USER_ID,
    629                 CALLING_PACKAGE);
    630         Mockito.verify(mPackageManager, Mockito.never())
    631                 .grantDefaultPermissionsToEnabledCarrierApps(
    632                         Mockito.any(String[].class), Mockito.anyInt());
    633     }
    634 
    635     /** Configured app has no privileges, and is disabled until used - should do nothing. */
    636     @Test @SmallTest
    637     public void testDisableCarrierAppsUntilPrivileged_NoPrivileges_DisabledUntilUsed()
    638             throws Exception {
    639         ApplicationInfo appInfo = new ApplicationInfo();
    640         appInfo.packageName = CARRIER_APP;
    641         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    642         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED;
    643         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    644                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    645         Mockito.when(mTelephonyManager.checkCarrierPrivilegesForPackageAnyPhone(CARRIER_APP))
    646                 .thenReturn(TelephonyManager.CARRIER_PRIVILEGE_STATUS_NO_ACCESS);
    647         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    648                 mTelephonyManager, mContentResolver, USER_ID, CARRIER_APPS, ASSOCIATED_APPS);
    649         Mockito.verify(mPackageManager, Mockito.never()).setApplicationEnabledSetting(
    650                 Mockito.anyString(), Mockito.anyInt(), Mockito.anyInt(), Mockito.anyInt(),
    651                 Mockito.anyString());
    652         Mockito.verify(mPackageManager, Mockito.never())
    653                 .grantDefaultPermissionsToEnabledCarrierApps(
    654                         Mockito.any(String[].class), Mockito.anyInt());
    655     }
    656 
    657     /** Telephony is not initialized, and app is disabled until used - should do nothing. */
    658     @Test @SmallTest
    659     public void testDisableCarrierAppsUntilPrivileged_NullPrivileges_DisabledUntilUsed()
    660             throws Exception {
    661         ApplicationInfo appInfo = new ApplicationInfo();
    662         appInfo.packageName = CARRIER_APP;
    663         appInfo.flags |= ApplicationInfo.FLAG_SYSTEM;
    664         appInfo.enabledSetting = PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED;
    665         Mockito.when(mPackageManager.getApplicationInfo(CARRIER_APP,
    666                 PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS, USER_ID)).thenReturn(appInfo);
    667         CarrierAppUtils.disableCarrierAppsUntilPrivileged(CALLING_PACKAGE, mPackageManager,
    668                 null /* telephonyManager */, mContentResolver, USER_ID, CARRIER_APPS,
    669                 ASSOCIATED_APPS);
    670         Mockito.verify(mPackageManager, Mockito.never()).setApplicationEnabledSetting(
    671                 Mockito.anyString(), Mockito.anyInt(), Mockito.anyInt(), Mockito.anyInt(),
    672                 Mockito.anyString());
    673         Mockito.verify(mPackageManager, Mockito.never())
    674                 .grantDefaultPermissionsToEnabledCarrierApps(
    675                         Mockito.any(String[].class), Mockito.anyInt());
    676     }
    677 
    678     class SettingsMockContentProvider extends MockContentProvider {
    679         private int mExpectedValue;
    680 
    681         @Override
    682         public Bundle call(String method, String request, Bundle args) {
    683             Bundle result = new Bundle();
    684             if (Settings.CALL_METHOD_GET_SECURE.equals(method)) {
    685                 result.putString(Settings.NameValueTable.VALUE, Integer.toString(mExpectedValue));
    686             } else {
    687                 mExpectedValue = Integer.parseInt(args.getString(Settings.NameValueTable.VALUE));
    688             }
    689             return result;
    690         }
    691     }
    692 
    693 }
    694 
    695