Home | History | Annotate | Download | only in devicepolicy 
      1 /*
      2  * Copyright (C) 2014 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.cts.devicepolicy;
     18 
     19 import com.android.ddmlib.Log.LogLevel;
     20 import com.android.tradefed.device.DeviceNotAvailableException;
     21 import com.android.tradefed.log.LogUtil.CLog;
     22 
     23 import junit.framework.AssertionFailedError;
     24 
     25 import java.util.Collections;
     26 import java.util.concurrent.Callable;
     27 import java.util.concurrent.TimeUnit;
     28 import java.util.regex.Matcher;
     29 import java.util.regex.Pattern;
     30 
     31 /**
     32  * Set of tests for Managed Profile use cases.
     33  */
     34 public class ManagedProfileTest extends BaseDevicePolicyTest {
     35 
     36     private static final String MANAGED_PROFILE_PKG = "com.android.cts.managedprofile";
     37     private static final String MANAGED_PROFILE_APK = "CtsManagedProfileApp.apk";
     38 
     39     private static final String DEVICE_OWNER_PKG = "com.android.cts.deviceowner";
     40     private static final String DEVICE_OWNER_APK = "CtsDeviceOwnerApp.apk";
     41     private static final String DEVICE_OWNER_ADMIN =
     42             DEVICE_OWNER_PKG + ".BaseDeviceOwnerTest$BasicAdminReceiver";
     43 
     44     private static final String INTENT_SENDER_PKG = "com.android.cts.intent.sender";
     45     private static final String INTENT_SENDER_APK = "CtsIntentSenderApp.apk";
     46 
     47     private static final String INTENT_RECEIVER_PKG = "com.android.cts.intent.receiver";
     48     private static final String INTENT_RECEIVER_APK = "CtsIntentReceiverApp.apk";
     49 
     50     private static final String WIFI_CONFIG_CREATOR_APK = "CtsWifiConfigCreator.apk";
     51 
     52     private static final String WIDGET_PROVIDER_APK = "CtsWidgetProviderApp.apk";
     53     private static final String WIDGET_PROVIDER_PKG = "com.android.cts.widgetprovider";
     54 
     55     private static final String DIRECTORY_PROVIDER_APK = "CtsContactDirectoryProvider.apk";
     56     private static final String DIRECTORY_PROVIDER_PKG
     57             = "com.android.cts.contactdirectoryprovider";
     58     private static final String PRIMARY_DIRECTORY_PREFIX = "Primary";
     59     private static final String MANAGED_DIRECTORY_PREFIX = "Managed";
     60     private static final String DIRECTORY_PRIVOIDER_URI
     61             = "content://com.android.cts.contact.directory.provider/";
     62     private static final String SET_CUSTOM_DIRECTORY_PREFIX_METHOD = "set_prefix";
     63 
     64     private static final String NOTIFICATION_APK = "CtsNotificationSenderApp.apk";
     65     private static final String NOTIFICATION_PKG =
     66             "com.android.cts.managedprofiletests.notificationsender";
     67 
     68     private static final String ADMIN_RECEIVER_TEST_CLASS =
     69             MANAGED_PROFILE_PKG + ".BaseManagedProfileTest$BasicAdminReceiver";
     70 
     71     private static final String FEATURE_BLUETOOTH = "android.hardware.bluetooth";
     72     private static final String FEATURE_CAMERA = "android.hardware.camera";
     73     private static final String FEATURE_WIFI = "android.hardware.wifi";
     74     private static final String FEATURE_TELEPHONY = "android.hardware.telephony";
     75     private static final String FEATURE_CONNECTION_SERVICE = "android.software.connectionservice";
     76 
     77     private static final String SIMPLE_APP_APK = "CtsSimpleApp.apk";
     78 
     79     private static final long TIMEOUT_USER_LOCKED_MILLIS = TimeUnit.SECONDS.toMillis(30);
     80 
     81     private static final String PARAM_PROFILE_ID = "profile-id";
     82 
     83     // Password needs to be in sync with ResetPasswordWithTokenTest.PASSWORD1
     84     private static final String RESET_PASSWORD_TEST_DEFAULT_PASSWORD = "123456";
     85 
     86     private static final String PROFILE_CREDENTIAL = "1234";
     87     // This should be sufficiently larger than ProfileTimeoutTestHelper.TIMEOUT_MS
     88     private static final int PROFILE_TIMEOUT_DELAY_MS = 10_000;
     89 
     90     //The maximum time to wait for user to be unlocked.
     91     private static final long USER_UNLOCK_TIMEOUT_NANO = 30_000_000_000L;
     92 
     93     private static final String USER_UNLOCKED_SHELL_OUTPUT = "RUNNING_UNLOCKED";
     94 
     95     private int mParentUserId;
     96 
     97     // ID of the profile we'll create. This will always be a profile of the parent.
     98     private int mProfileUserId;
     99 
    100     private boolean mHasNfcFeature;
    101 
    102     @Override
    103     protected void setUp() throws Exception {
    104         super.setUp();
    105 
    106         // We need multi user to be supported in order to create a profile of the user owner.
    107         mHasFeature = mHasFeature && hasDeviceFeature(
    108                 "android.software.managed_users");
    109         mHasNfcFeature = hasDeviceFeature("android.hardware.nfc");
    110 
    111         if (mHasFeature) {
    112             removeTestUsers();
    113             mParentUserId = mPrimaryUserId;
    114             mProfileUserId = createManagedProfile(mParentUserId);
    115             startUser(mProfileUserId);
    116 
    117             installAppAsUser(MANAGED_PROFILE_APK, mParentUserId);
    118             installAppAsUser(MANAGED_PROFILE_APK, mProfileUserId);
    119             setProfileOwnerOrFail(MANAGED_PROFILE_PKG + "/" + ADMIN_RECEIVER_TEST_CLASS,
    120                     mProfileUserId);
    121             waitForUserUnlock();
    122         }
    123     }
    124 
    125     private void  waitForUserUnlock() throws Exception {
    126         final String command = String.format("am get-started-user-state %d", mProfileUserId);
    127         final long deadline = System.nanoTime() + USER_UNLOCK_TIMEOUT_NANO;
    128         while (System.nanoTime() <= deadline) {
    129             if (getDevice().executeShellCommand(command).startsWith(USER_UNLOCKED_SHELL_OUTPUT)) {
    130                 return;
    131             }
    132             Thread.sleep(100);
    133         }
    134         fail("Profile user is not unlocked.");
    135     }
    136 
    137     @Override
    138     protected void tearDown() throws Exception {
    139         if (mHasFeature) {
    140             removeUser(mProfileUserId);
    141             getDevice().uninstallPackage(MANAGED_PROFILE_PKG);
    142             getDevice().uninstallPackage(INTENT_SENDER_PKG);
    143             getDevice().uninstallPackage(INTENT_RECEIVER_PKG);
    144             getDevice().uninstallPackage(NOTIFICATION_PKG);
    145         }
    146         super.tearDown();
    147     }
    148 
    149     public void testManagedProfileSetup() throws Exception {
    150         if (!mHasFeature) {
    151             return;
    152         }
    153         runDeviceTestsAsUser(
    154                 MANAGED_PROFILE_PKG, MANAGED_PROFILE_PKG + ".ManagedProfileSetupTest",
    155                 mProfileUserId);
    156     }
    157 
    158     public void testWipeDataWithReason() throws Exception {
    159         if (!mHasFeature) {
    160             return;
    161         }
    162         assertTrue(listUsers().contains(mProfileUserId));
    163         sendWipeProfileBroadcast("com.android.cts.managedprofile.WIPE_DATA_WITH_REASON");
    164         // Note: the managed profile is removed by this test, which will make removeUserCommand in
    165         // tearDown() to complain, but that should be OK since its result is not asserted.
    166         assertUserGetsRemoved(mProfileUserId);
    167         // testWipeDataWithReason() removes the managed profile,
    168         // so it needs to separated from other tests.
    169         // Check the notification is presented after work profile got removed, so profile user no
    170         // longer exists, verification should be run in primary user.
    171         runDeviceTestsAsUser(
    172                 MANAGED_PROFILE_PKG,
    173                 ".WipeDataWithReasonVerificationTest",
    174                 mParentUserId);
    175     }
    176 
    177     /**
    178      *  wipeData() test removes the managed profile, so it needs to separated from other tests.
    179      */
    180     public void testWipeData() throws Exception {
    181         if (!mHasFeature) {
    182             return;
    183         }
    184         assertTrue(listUsers().contains(mProfileUserId));
    185         sendWipeProfileBroadcast("com.android.cts.managedprofile.WIPE_DATA");
    186         // Note: the managed profile is removed by this test, which will make removeUserCommand in
    187         // tearDown() to complain, but that should be OK since its result is not asserted.
    188         assertUserGetsRemoved(mProfileUserId);
    189     }
    190 
    191     private void sendWipeProfileBroadcast(String action) throws Exception {
    192         final String cmd = "am broadcast --receiver-foreground --user " + mProfileUserId
    193             + " -a " + action
    194             + " com.android.cts.managedprofile/.WipeDataReceiver";
    195         getDevice().executeShellCommand(cmd);
    196     }
    197 
    198     public void testLockNowWithKeyEviction() throws Exception {
    199         if (!mHasFeature || !mSupportsFbe) {
    200             return;
    201         }
    202         changeUserCredential("1234", null, mProfileUserId);
    203         lockProfile();
    204     }
    205 
    206     private void lockProfile() throws Exception {
    207         final String cmd = "am broadcast --receiver-foreground --user " + mProfileUserId
    208                 + " -a com.android.cts.managedprofile.LOCK_PROFILE"
    209                 + " com.android.cts.managedprofile/.LockProfileReceiver";
    210         getDevice().executeShellCommand(cmd);
    211         waitUntilProfileLocked();
    212     }
    213 
    214     private void waitUntilProfileLocked() throws Exception {
    215         final String cmd = "dumpsys activity | grep 'User #" + mProfileUserId + ": state='";
    216         final Pattern p = Pattern.compile("state=([\\p{Upper}_]+)$");
    217         SuccessCondition userLocked = () -> {
    218             final String activityDump = getDevice().executeShellCommand(cmd);
    219             final Matcher m = p.matcher(activityDump);
    220             return m.find() && m.group(1).equals("RUNNING_LOCKED");
    221         };
    222         tryWaitForSuccess(
    223                 userLocked,
    224                 "The managed profile has not been locked after calling "
    225                         + "lockNow(FLAG_SECURE_USER_DATA)",
    226                 TIMEOUT_USER_LOCKED_MILLIS);
    227     }
    228 
    229     /** Profile should get locked if it is not in foreground no matter what. */
    230     public void testWorkProfileTimeoutBackground() throws Exception {
    231         if (!mHasFeature) {
    232             return;
    233         }
    234         setUpWorkProfileTimeout();
    235 
    236         startDummyActivity(mPrimaryUserId, true);
    237         simulateUserInteraction(PROFILE_TIMEOUT_DELAY_MS);
    238 
    239         verifyOnlyProfileLocked(true);
    240     }
    241 
    242     /** Profile should get locked if it is in foreground but with no user activity. */
    243     public void testWorkProfileTimeoutIdleActivity() throws Exception {
    244         if (!mHasFeature) {
    245             return;
    246         }
    247         setUpWorkProfileTimeout();
    248 
    249         startDummyActivity(mProfileUserId, false);
    250         Thread.sleep(PROFILE_TIMEOUT_DELAY_MS);
    251 
    252         verifyOnlyProfileLocked(true);
    253     }
    254 
    255     /** User activity in profile should prevent it from locking. */
    256     public void testWorkProfileTimeoutUserActivity() throws Exception {
    257         if (!mHasFeature) {
    258             return;
    259         }
    260         setUpWorkProfileTimeout();
    261 
    262         startDummyActivity(mProfileUserId, false);
    263         simulateUserInteraction(PROFILE_TIMEOUT_DELAY_MS);
    264 
    265         verifyOnlyProfileLocked(false);
    266     }
    267 
    268     /** Keep screen on window flag in the profile should prevent it from locking. */
    269     public void testWorkProfileTimeoutKeepScreenOnWindow() throws Exception {
    270         if (!mHasFeature) {
    271             return;
    272         }
    273         setUpWorkProfileTimeout();
    274 
    275         startDummyActivity(mProfileUserId, true);
    276         Thread.sleep(PROFILE_TIMEOUT_DELAY_MS);
    277 
    278         verifyOnlyProfileLocked(false);
    279     }
    280 
    281     private void setUpWorkProfileTimeout() throws DeviceNotAvailableException {
    282         // Set separate challenge.
    283         changeUserCredential(PROFILE_CREDENTIAL, null, mProfileUserId);
    284 
    285         // Make sure the profile is not prematurely locked.
    286         verifyUserCredential(PROFILE_CREDENTIAL, mProfileUserId);
    287         verifyOnlyProfileLocked(false);
    288         // Set profile timeout to 5 seconds.
    289         runProfileTimeoutTest("testSetWorkProfileTimeout", mProfileUserId);
    290     }
    291 
    292     private void verifyOnlyProfileLocked(boolean locked) throws DeviceNotAvailableException {
    293         final String expectedResultTest = locked ? "testDeviceLocked" : "testDeviceNotLocked";
    294         runProfileTimeoutTest(expectedResultTest, mProfileUserId);
    295         // Primary profile shouldn't be locked.
    296         runProfileTimeoutTest("testDeviceNotLocked", mPrimaryUserId);
    297     }
    298 
    299     private void simulateUserInteraction(int timeMs) throws Exception {
    300         final UserActivityEmulator helper = new UserActivityEmulator(getDevice());
    301         for (int i = 0; i < timeMs; i += timeMs/10) {
    302             Thread.sleep(timeMs/10);
    303             helper.tapScreenCenter();
    304         }
    305     }
    306 
    307     private void runProfileTimeoutTest(String method, int userId)
    308             throws DeviceNotAvailableException {
    309         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, MANAGED_PROFILE_PKG + ".ProfileTimeoutTestHelper",
    310                 method, userId);
    311     }
    312 
    313     private void startDummyActivity(int profileUserId, boolean keepScreenOn) throws Exception {
    314         getDevice().executeShellCommand(String.format(
    315                 "am start-activity -W --user %d --ez keep_screen_on %s %s/.TimeoutActivity",
    316                 profileUserId, keepScreenOn, MANAGED_PROFILE_PKG));
    317     }
    318 
    319     public void testMaxOneManagedProfile() throws Exception {
    320         int newUserId = -1;
    321         try {
    322             newUserId = createManagedProfile(mParentUserId);
    323         } catch (AssertionFailedError expected) {
    324         }
    325         if (newUserId > 0) {
    326             removeUser(newUserId);
    327             fail(mHasFeature ? "Device must allow creating only one managed profile"
    328                     : "Device must not allow creating a managed profile");
    329         }
    330     }
    331 
    332     /**
    333      * Verify that removing a managed profile will remove all networks owned by that profile.
    334      */
    335     public void testProfileWifiCleanup() throws Exception {
    336         if (!mHasFeature || !hasDeviceFeature(FEATURE_WIFI)) {
    337             return;
    338         }
    339         installAppAsUser(WIFI_CONFIG_CREATOR_APK, mProfileUserId);
    340 
    341         runDeviceTestsAsUser(
    342                 MANAGED_PROFILE_PKG, ".WifiTest", "testRemoveWifiNetworkIfExists", mParentUserId);
    343 
    344         runDeviceTestsAsUser(
    345                 MANAGED_PROFILE_PKG, ".WifiTest", "testAddWifiNetwork", mProfileUserId);
    346 
    347         // Now delete the user - should undo the effect of testAddWifiNetwork.
    348         removeUser(mProfileUserId);
    349         runDeviceTestsAsUser(
    350                 MANAGED_PROFILE_PKG, ".WifiTest", "testWifiNetworkDoesNotExist",
    351                 mParentUserId);
    352     }
    353 
    354     public void testWifiMacAddress() throws Exception {
    355         if (!mHasFeature || !hasDeviceFeature(FEATURE_WIFI)) {
    356             return;
    357         }
    358         runDeviceTestsAsUser(
    359                 MANAGED_PROFILE_PKG, ".WifiTest", "testCannotGetWifiMacAddress", mProfileUserId);
    360     }
    361 
    362     public void testCrossProfileIntentFilters() throws Exception {
    363         if (!mHasFeature) {
    364             return;
    365         }
    366         // Set up activities: ManagedProfileActivity will only be enabled in the managed profile and
    367         // PrimaryUserActivity only in the primary one
    368         disableActivityForUser("ManagedProfileActivity", mParentUserId);
    369         disableActivityForUser("PrimaryUserActivity", mProfileUserId);
    370 
    371         runDeviceTestsAsUser(MANAGED_PROFILE_PKG,
    372                 MANAGED_PROFILE_PKG + ".ManagedProfileTest", mProfileUserId);
    373 
    374         // Set up filters from primary to managed profile
    375         String command = "am start -W --user " + mProfileUserId  + " " + MANAGED_PROFILE_PKG
    376                 + "/.PrimaryUserFilterSetterActivity";
    377         CLog.d("Output for command " + command + ": "
    378               + getDevice().executeShellCommand(command));
    379         runDeviceTestsAsUser(
    380                 MANAGED_PROFILE_PKG, MANAGED_PROFILE_PKG + ".PrimaryUserTest", mParentUserId);
    381         // TODO: Test with startActivity
    382     }
    383 
    384     public void testDisallowSharingIntoProfileFromProfile() throws Exception {
    385         if (!mHasFeature) {
    386             return;
    387         }
    388         // Set up activities: PrimaryUserActivity will only be enabled in the personal user
    389         // This activity is used to find out the ground truth about the system's cross profile
    390         // intent forwarding activity.
    391         disableActivityForUser("PrimaryUserActivity", mProfileUserId);
    392 
    393         // Tests from the profile side
    394         runDeviceTestsAsUser(MANAGED_PROFILE_PKG,
    395                 ".DisallowSharingIntoProfileTest", "testSharingFromProfile", mProfileUserId);
    396     }
    397 
    398     public void testDisallowSharingIntoProfileFromPersonal() throws Exception {
    399         if (!mHasFeature) {
    400             return;
    401         }
    402         // Set up activities: ManagedProfileActivity will only be enabled in the managed profile
    403         // This activity is used to find out the ground truth about the system's cross profile
    404         // intent forwarding activity.
    405         disableActivityForUser("ManagedProfileActivity", mParentUserId);
    406 
    407         // Tests from the personal side, which is mostly driven from host side.
    408         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".DisallowSharingIntoProfileTest",
    409                 "testSetUp", mProfileUserId);
    410         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".DisallowSharingIntoProfileTest",
    411                 "testDisableSharingIntoProfile", mProfileUserId);
    412         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".DisallowSharingIntoProfileTest",
    413                 "testSharingFromPersonalFails", mParentUserId);
    414         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".DisallowSharingIntoProfileTest",
    415                 "testEnableSharingIntoProfile", mProfileUserId);
    416         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".DisallowSharingIntoProfileTest",
    417                 "testSharingFromPersonalSucceeds", mParentUserId);
    418     }
    419 
    420     public void testAppLinks_verificationStatus() throws Exception {
    421         if (!mHasFeature) {
    422             return;
    423         }
    424         // Disable all pre-existing browsers in the managed profile so they don't interfere with
    425         // intents resolution.
    426         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils",
    427                 "testDisableAllBrowsers", mProfileUserId);
    428         installAppAsUser(INTENT_RECEIVER_APK, mParentUserId);
    429         installAppAsUser(INTENT_SENDER_APK, mParentUserId);
    430         installAppAsUser(INTENT_RECEIVER_APK, mProfileUserId);
    431         installAppAsUser(INTENT_SENDER_APK, mProfileUserId);
    432 
    433         changeVerificationStatus(mParentUserId, INTENT_RECEIVER_PKG, "ask");
    434         changeVerificationStatus(mProfileUserId, INTENT_RECEIVER_PKG, "ask");
    435         // We should have two receivers: IntentReceiverActivity and BrowserActivity in the
    436         // managed profile
    437         assertAppLinkResult("testTwoReceivers");
    438 
    439         changeUserRestrictionOrFail("allow_parent_profile_app_linking", true, mProfileUserId);
    440         // Now we should also have one receiver in the primary user, so three receivers in total.
    441         assertAppLinkResult("testThreeReceivers");
    442 
    443         changeVerificationStatus(mParentUserId, INTENT_RECEIVER_PKG, "never");
    444         // The primary user one has been set to never: we should only have the managed profile ones.
    445         assertAppLinkResult("testTwoReceivers");
    446 
    447         changeVerificationStatus(mProfileUserId, INTENT_RECEIVER_PKG, "never");
    448         // Now there's only the browser in the managed profile left
    449         assertAppLinkResult("testReceivedByBrowserActivityInManaged");
    450 
    451         changeVerificationStatus(mProfileUserId, INTENT_RECEIVER_PKG, "always");
    452         changeVerificationStatus(mParentUserId, INTENT_RECEIVER_PKG, "always");
    453         // We have one always in the primary user and one always in the managed profile: the managed
    454         // profile one should have precedence.
    455         assertAppLinkResult("testReceivedByAppLinkActivityInManaged");
    456     }
    457 
    458     public void testAppLinks_enabledStatus() throws Exception {
    459         if (!mHasFeature) {
    460             return;
    461         }
    462         // Disable all pre-existing browsers in the managed profile so they don't interfere with
    463         // intents resolution.
    464         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils",
    465                 "testDisableAllBrowsers", mProfileUserId);
    466         installAppAsUser(INTENT_RECEIVER_APK, mParentUserId);
    467         installAppAsUser(INTENT_SENDER_APK, mParentUserId);
    468         installAppAsUser(INTENT_RECEIVER_APK, mProfileUserId);
    469         installAppAsUser(INTENT_SENDER_APK, mProfileUserId);
    470 
    471         final String APP_HANDLER_COMPONENT = "com.android.cts.intent.receiver/.AppLinkActivity";
    472 
    473         // allow_parent_profile_app_linking is not set, try different enabled state combinations.
    474         // We should not have app link handler in parent user no matter whether it is enabled.
    475 
    476         disableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT);
    477         disableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT);
    478         assertAppLinkResult("testReceivedByBrowserActivityInManaged");
    479 
    480         enableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT);
    481         disableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT);
    482         assertAppLinkResult("testReceivedByBrowserActivityInManaged");
    483 
    484         disableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT);
    485         enableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT);
    486         assertAppLinkResult("testTwoReceivers");
    487 
    488         enableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT);
    489         enableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT);
    490         assertAppLinkResult("testTwoReceivers");
    491 
    492         // We now set allow_parent_profile_app_linking, and hence we should have the app handler
    493         // in parent user if it is enabled.
    494         changeUserRestrictionOrFail("allow_parent_profile_app_linking", true, mProfileUserId);
    495 
    496         disableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT);
    497         disableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT);
    498         assertAppLinkResult("testReceivedByBrowserActivityInManaged");
    499 
    500         enableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT);
    501         disableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT);
    502         assertAppLinkResult("testTwoReceivers");
    503 
    504         disableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT);
    505         enableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT);
    506         assertAppLinkResult("testTwoReceivers");
    507 
    508         enableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT);
    509         enableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT);
    510         assertAppLinkResult("testThreeReceivers");
    511     }
    512 
    513     public void testSettingsIntents() throws Exception {
    514         if (!mHasFeature) {
    515             return;
    516         }
    517 
    518         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".SettingsIntentsTest",
    519                 mProfileUserId);
    520     }
    521 
    522     public void testCrossProfileContent() throws Exception {
    523         if (!mHasFeature) {
    524             return;
    525         }
    526         installAppAsUser(INTENT_RECEIVER_APK, mParentUserId);
    527         installAppAsUser(INTENT_SENDER_APK, mParentUserId);
    528         installAppAsUser(INTENT_RECEIVER_APK, mProfileUserId);
    529         installAppAsUser(INTENT_SENDER_APK, mProfileUserId);
    530 
    531         // Test from parent to managed
    532         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils",
    533                 "testRemoveAllFilters", mProfileUserId);
    534         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils",
    535                 "testAddManagedCanAccessParentFilters", mProfileUserId);
    536         runDeviceTestsAsUser(INTENT_SENDER_PKG, ".ContentTest", mParentUserId);
    537 
    538         // Test from managed to parent
    539         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils",
    540                 "testRemoveAllFilters", mProfileUserId);
    541         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils",
    542                 "testAddParentCanAccessManagedFilters", mProfileUserId);
    543         runDeviceTestsAsUser(INTENT_SENDER_PKG, ".ContentTest", mProfileUserId);
    544 
    545     }
    546 
    547     public void testCrossProfileNotificationListeners_EmptyWhitelist() throws Exception {
    548         if (!mHasFeature) {
    549             return;
    550         }
    551 
    552         installAppAsUser(NOTIFICATION_APK, mProfileUserId);
    553         installAppAsUser(NOTIFICATION_APK, mParentUserId);
    554 
    555         // Profile owner in the profile sets an empty whitelist
    556         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".NotificationListenerTest",
    557                 "testSetEmptyWhitelist", mProfileUserId,
    558                 Collections.singletonMap(PARAM_PROFILE_ID, Integer.toString(mProfileUserId)));
    559         // Listener outside the profile can only see personal notifications.
    560         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".NotificationListenerTest",
    561                 "testCannotReceiveProfileNotifications", mParentUserId,
    562                 Collections.singletonMap(PARAM_PROFILE_ID, Integer.toString(mProfileUserId)));
    563     }
    564 
    565     public void testCrossProfileNotificationListeners_NullWhitelist() throws Exception {
    566         if (!mHasFeature) {
    567             return;
    568         }
    569 
    570         installAppAsUser(NOTIFICATION_APK, mProfileUserId);
    571         installAppAsUser(NOTIFICATION_APK, mParentUserId);
    572 
    573         // Profile owner in the profile sets a null whitelist
    574         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".NotificationListenerTest",
    575                 "testSetNullWhitelist", mProfileUserId,
    576                 Collections.singletonMap(PARAM_PROFILE_ID, Integer.toString(mProfileUserId)));
    577         // Listener outside the profile can see profile and personal notifications
    578         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".NotificationListenerTest",
    579                 "testCanReceiveNotifications", mParentUserId,
    580                 Collections.singletonMap(PARAM_PROFILE_ID, Integer.toString(mProfileUserId)));
    581     }
    582 
    583     public void testCrossProfileNotificationListeners_InWhitelist() throws Exception {
    584         if (!mHasFeature) {
    585             return;
    586         }
    587 
    588         installAppAsUser(NOTIFICATION_APK, mProfileUserId);
    589         installAppAsUser(NOTIFICATION_APK, mParentUserId);
    590 
    591         // Profile owner in the profile adds listener to the whitelist
    592         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".NotificationListenerTest",
    593                 "testAddListenerToWhitelist", mProfileUserId,
    594                 Collections.singletonMap(PARAM_PROFILE_ID, Integer.toString(mProfileUserId)));
    595         // Listener outside the profile can see profile and personal notifications
    596         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".NotificationListenerTest",
    597                 "testCanReceiveNotifications", mParentUserId,
    598                 Collections.singletonMap(PARAM_PROFILE_ID, Integer.toString(mProfileUserId)));
    599     }
    600 
    601     public void testCrossProfileCopyPaste() throws Exception {
    602         if (!mHasFeature) {
    603             return;
    604         }
    605         installAppAsUser(INTENT_RECEIVER_APK, mParentUserId);
    606         installAppAsUser(INTENT_SENDER_APK, mParentUserId);
    607         installAppAsUser(INTENT_RECEIVER_APK, mProfileUserId);
    608         installAppAsUser(INTENT_SENDER_APK, mProfileUserId);
    609 
    610         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils",
    611                 "testAllowCrossProfileCopyPaste", mProfileUserId);
    612         // Test that managed can see what is copied in the parent.
    613         testCrossProfileCopyPasteInternal(mProfileUserId, true);
    614         // Test that the parent can see what is copied in managed.
    615         testCrossProfileCopyPasteInternal(mParentUserId, true);
    616 
    617         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils",
    618                 "testDisallowCrossProfileCopyPaste", mProfileUserId);
    619         // Test that managed can still see what is copied in the parent.
    620         testCrossProfileCopyPasteInternal(mProfileUserId, true);
    621         // Test that the parent cannot see what is copied in managed.
    622         testCrossProfileCopyPasteInternal(mParentUserId, false);
    623     }
    624 
    625     private void testCrossProfileCopyPasteInternal(int userId, boolean shouldSucceed)
    626             throws DeviceNotAvailableException {
    627         final String direction = (userId == mParentUserId)
    628                 ? "testAddManagedCanAccessParentFilters"
    629                 : "testAddParentCanAccessManagedFilters";
    630         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils",
    631                 "testRemoveAllFilters", mProfileUserId);
    632         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils",
    633                 direction, mProfileUserId);
    634         if (shouldSucceed) {
    635             runDeviceTestsAsUser(INTENT_SENDER_PKG, ".CopyPasteTest",
    636                     "testCanReadAcrossProfiles", userId);
    637             runDeviceTestsAsUser(INTENT_SENDER_PKG, ".CopyPasteTest",
    638                     "testIsNotified", userId);
    639         } else {
    640             runDeviceTestsAsUser(INTENT_SENDER_PKG, ".CopyPasteTest",
    641                     "testCannotReadAcrossProfiles", userId);
    642         }
    643     }
    644 
    645     /** Tests for the API helper class. */
    646     public void testCurrentApiHelper() throws Exception {
    647         if (!mHasFeature) {
    648             return;
    649         }
    650         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CurrentApiHelperTest",
    651                 mProfileUserId);
    652     }
    653 
    654     /** Test: unsupported public APIs are disabled on a parent profile. */
    655     public void testParentProfileApiDisabled() throws Exception {
    656         if (!mHasFeature) {
    657             return;
    658         }
    659         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ParentProfileTest",
    660                 "testParentProfileApiDisabled", mProfileUserId);
    661     }
    662 
    663     // TODO: This test is not specific to managed profiles, but applies to multi-user in general.
    664     // Move it to a MultiUserTest class when there is one. Should probably move
    665     // SetPolicyActivity to a more generic apk too as it might be useful for different kinds
    666     // of tests (same applies to ComponentDisablingActivity).
    667     public void testNoDebuggingFeaturesRestriction() throws Exception {
    668         if (!mHasFeature) {
    669             return;
    670         }
    671         // If adb is running as root, then the adb uid is 0 instead of SHELL_UID,
    672         // so the DISALLOW_DEBUGGING_FEATURES restriction does not work and this test
    673         // fails.
    674         if (getDevice().isAdbRoot()) {
    675             CLog.logAndDisplay(LogLevel.WARN,
    676                     "Cannot test testNoDebuggingFeaturesRestriction() in eng/userdebug build");
    677             return;
    678         }
    679         String restriction = "no_debugging_features";  // UserManager.DISALLOW_DEBUGGING_FEATURES
    680 
    681         changeUserRestrictionOrFail(restriction, true, mProfileUserId);
    682 
    683 
    684         // This should now fail, as the shell is not available to start activities under a different
    685         // user once the restriction is in place.
    686         String addRestrictionCommandOutput =
    687                 changeUserRestriction(restriction, true, mProfileUserId);
    688         assertTrue(
    689                 "Expected SecurityException when starting the activity "
    690                         + addRestrictionCommandOutput,
    691                 addRestrictionCommandOutput.contains("SecurityException"));
    692     }
    693 
    694     // Test the bluetooth API from a managed profile.
    695     public void testBluetooth() throws Exception {
    696         boolean hasBluetooth = hasDeviceFeature(FEATURE_BLUETOOTH);
    697         if (!mHasFeature || !hasBluetooth) {
    698             return ;
    699         }
    700 
    701         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".BluetoothTest",
    702                 "testEnableDisable", mProfileUserId);
    703         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".BluetoothTest",
    704                 "testGetAddress", mProfileUserId);
    705         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".BluetoothTest",
    706                 "testListenUsingRfcommWithServiceRecord", mProfileUserId);
    707         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".BluetoothTest",
    708                 "testGetRemoteDevice", mProfileUserId);
    709     }
    710 
    711     public void testCameraPolicy() throws Exception {
    712         boolean hasCamera = hasDeviceFeature(FEATURE_CAMERA);
    713         if (!mHasFeature || !hasCamera) {
    714             return;
    715         }
    716         try {
    717             setDeviceAdmin(MANAGED_PROFILE_PKG + "/.PrimaryUserDeviceAdmin", mParentUserId);
    718 
    719             // Disable managed profile camera.
    720             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest",
    721                     "testDisableCameraInManagedProfile",
    722                     mProfileUserId);
    723             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest",
    724                     "testIsCameraEnabledInPrimaryProfile",
    725                     mParentUserId);
    726 
    727             // Enable managed profile camera.
    728             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest",
    729                     "testEnableCameraInManagedProfile",
    730                     mProfileUserId);
    731             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest",
    732                     "testIsCameraEnabledInPrimaryProfile",
    733                     mParentUserId);
    734 
    735             // Disable primary profile camera.
    736             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest",
    737                     "testDisableCameraInPrimaryProfile",
    738                     mParentUserId);
    739             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest",
    740                     "testIsCameraEnabledInManagedProfile",
    741                     mProfileUserId);
    742 
    743             // Enable primary profile camera.
    744             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest",
    745                     "testEnableCameraInPrimaryProfile",
    746                     mParentUserId);
    747             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest",
    748                     "testIsCameraEnabledInManagedProfile",
    749                     mProfileUserId);
    750         } finally {
    751             final String adminHelperClass = ".PrimaryUserAdminHelper";
    752             runDeviceTestsAsUser(MANAGED_PROFILE_PKG,
    753                     adminHelperClass, "testClearDeviceAdmin", mParentUserId);
    754         }
    755     }
    756 
    757 
    758     public void testManagedContactsUris() throws Exception {
    759         runManagedContactsTest(new Callable<Void>() {
    760             @Override
    761             public Void call() throws Exception {
    762                 ContactsTestSet contactsTestSet = new ContactsTestSet(ManagedProfileTest.this,
    763                         MANAGED_PROFILE_PKG, mParentUserId, mProfileUserId);
    764 
    765                 contactsTestSet.setCallerIdEnabled(true);
    766                 contactsTestSet.setContactsSearchEnabled(true);
    767                 contactsTestSet.checkIfCanLookupEnterpriseContacts(true);
    768                 contactsTestSet.checkIfCanFilterEnterpriseContacts(true);
    769                 contactsTestSet.checkIfCanFilterSelfContacts();
    770                 return null;
    771             }
    772         });
    773     }
    774 
    775     public void testManagedQuickContacts() throws Exception {
    776         runManagedContactsTest(new Callable<Void>() {
    777             @Override
    778             public Void call() throws Exception {
    779                 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
    780                         "testQuickContact", mParentUserId);
    781                 return null;
    782             }
    783         });
    784     }
    785 
    786     public void testManagedContactsPolicies() throws Exception {
    787         runManagedContactsTest(new Callable<Void>() {
    788             @Override
    789             public Void call() throws Exception {
    790                 ContactsTestSet contactsTestSet = new ContactsTestSet(ManagedProfileTest.this,
    791                         MANAGED_PROFILE_PKG, mParentUserId, mProfileUserId);
    792                 try {
    793                     contactsTestSet.setCallerIdEnabled(true);
    794                     contactsTestSet.setContactsSearchEnabled(false);
    795                     contactsTestSet.checkIfCanLookupEnterpriseContacts(true);
    796                     contactsTestSet.checkIfCanFilterEnterpriseContacts(false);
    797                     contactsTestSet.checkIfCanFilterSelfContacts();
    798                     contactsTestSet.setCallerIdEnabled(false);
    799                     contactsTestSet.setContactsSearchEnabled(true);
    800                     contactsTestSet.checkIfCanLookupEnterpriseContacts(false);
    801                     contactsTestSet.checkIfCanFilterEnterpriseContacts(true);
    802                     contactsTestSet.checkIfCanFilterSelfContacts();
    803                     contactsTestSet.setCallerIdEnabled(false);
    804                     contactsTestSet.setContactsSearchEnabled(false);
    805                     contactsTestSet.checkIfCanLookupEnterpriseContacts(false);
    806                     contactsTestSet.checkIfCanFilterEnterpriseContacts(false);
    807                     contactsTestSet.checkIfCanFilterSelfContacts();
    808                     contactsTestSet.checkIfNoEnterpriseDirectoryFound();
    809                     return null;
    810                 } finally {
    811                     // reset policies
    812                     contactsTestSet.setCallerIdEnabled(true);
    813                     contactsTestSet.setContactsSearchEnabled(true);
    814                 }
    815             }
    816         });
    817     }
    818 
    819     public void testOrganizationInfo() throws Exception {
    820         if (!mHasFeature) {
    821             return;
    822         }
    823         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".OrganizationInfoTest",
    824                 "testDefaultOrganizationColor", mProfileUserId);
    825         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".OrganizationInfoTest",
    826                 "testDefaultOrganizationNameIsNull", mProfileUserId);
    827         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".OrganizationInfoTest",
    828                 mProfileUserId);
    829     }
    830 
    831     public void testPasswordMinimumRestrictions() throws Exception {
    832         if (!mHasFeature) {
    833             return;
    834         }
    835         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PasswordMinimumRestrictionsTest",
    836                 mProfileUserId);
    837     }
    838 
    839     public void testBluetoothContactSharingDisabled() throws Exception {
    840         if (!mHasFeature) {
    841             return;
    842         }
    843         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
    844                 "testSetBluetoothContactSharingDisabled_setterAndGetter", mProfileUserId);
    845     }
    846 
    847     public void testCannotSetProfileOwnerAgain() throws Exception {
    848         if (!mHasFeature) {
    849             return;
    850         }
    851         // verify that we can't set the same admin receiver as profile owner again
    852         assertFalse(setProfileOwner(
    853                 MANAGED_PROFILE_PKG + "/" + ADMIN_RECEIVER_TEST_CLASS, mProfileUserId,
    854                 /*expectFailure*/ true));
    855 
    856         // verify that we can't set a different admin receiver as profile owner
    857         installAppAsUser(DEVICE_OWNER_APK, mProfileUserId);
    858         assertFalse(setProfileOwner(DEVICE_OWNER_PKG + "/" + DEVICE_OWNER_ADMIN, mProfileUserId,
    859                 /*expectFailure*/ true));
    860     }
    861 
    862     public void testCannotSetDeviceOwnerWhenProfilePresent() throws Exception {
    863         if (!mHasFeature) {
    864             return;
    865         }
    866 
    867         try {
    868             installAppAsUser(DEVICE_OWNER_APK, mParentUserId);
    869             assertFalse(setDeviceOwner(DEVICE_OWNER_PKG + "/" + DEVICE_OWNER_ADMIN, mParentUserId,
    870                     /*expectFailure*/ true));
    871         } finally {
    872             // make sure we clean up in case we succeeded in setting the device owner
    873             removeAdmin(DEVICE_OWNER_PKG + "/" + DEVICE_OWNER_ADMIN, mParentUserId);
    874             getDevice().uninstallPackage(DEVICE_OWNER_PKG);
    875         }
    876     }
    877 
    878     public void testNfcRestriction() throws Exception {
    879         if (!mHasFeature || !mHasNfcFeature) {
    880             return;
    881         }
    882 
    883         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".NfcTest",
    884                 "testNfcShareEnabled", mProfileUserId);
    885         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".NfcTest",
    886                 "testNfcShareEnabled", mParentUserId);
    887 
    888         changeUserRestrictionOrFail("no_outgoing_beam" /* UserManager.DISALLOW_OUTGOING_BEAM */,
    889                 true, mProfileUserId);
    890 
    891         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".NfcTest",
    892                 "testNfcShareDisabled", mProfileUserId);
    893         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".NfcTest",
    894                 "testNfcShareEnabled", mParentUserId);
    895     }
    896 
    897     public void testCrossProfileWidgets() throws Exception {
    898         if (!mHasFeature) {
    899             return;
    900         }
    901 
    902         try {
    903             installAppAsUser(WIDGET_PROVIDER_APK, mProfileUserId);
    904             installAppAsUser(WIDGET_PROVIDER_APK, mParentUserId);
    905             getDevice().executeShellCommand("appwidget grantbind --user " + mParentUserId
    906                     + " --package " + WIDGET_PROVIDER_PKG);
    907             setIdleWhitelist(WIDGET_PROVIDER_PKG, true);
    908             startWidgetHostService();
    909 
    910             String commandOutput = changeCrossProfileWidgetForUser(WIDGET_PROVIDER_PKG,
    911                     "add-cross-profile-widget", mProfileUserId);
    912             assertTrue("Command was expected to succeed " + commandOutput,
    913                     commandOutput.contains("Status: ok"));
    914 
    915             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileWidgetTest",
    916                     "testCrossProfileWidgetProviderAdded", mProfileUserId);
    917             runDeviceTestsAsUser(MANAGED_PROFILE_PKG,
    918                     ".CrossProfileWidgetPrimaryUserTest",
    919                     "testHasCrossProfileWidgetProvider_true", mParentUserId);
    920             runDeviceTestsAsUser(MANAGED_PROFILE_PKG,
    921                     ".CrossProfileWidgetPrimaryUserTest",
    922                     "testHostReceivesWidgetUpdates_true", mParentUserId);
    923 
    924             commandOutput = changeCrossProfileWidgetForUser(WIDGET_PROVIDER_PKG,
    925                     "remove-cross-profile-widget", mProfileUserId);
    926             assertTrue("Command was expected to succeed " + commandOutput,
    927                     commandOutput.contains("Status: ok"));
    928 
    929             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileWidgetTest",
    930                     "testCrossProfileWidgetProviderRemoved", mProfileUserId);
    931             runDeviceTestsAsUser(MANAGED_PROFILE_PKG,
    932                     ".CrossProfileWidgetPrimaryUserTest",
    933                     "testHasCrossProfileWidgetProvider_false", mParentUserId);
    934             runDeviceTestsAsUser(MANAGED_PROFILE_PKG,
    935                     ".CrossProfileWidgetPrimaryUserTest",
    936                     "testHostReceivesWidgetUpdates_false", mParentUserId);
    937         } finally {
    938             changeCrossProfileWidgetForUser(WIDGET_PROVIDER_PKG, "remove-cross-profile-widget",
    939                     mProfileUserId);
    940             getDevice().uninstallPackage(WIDGET_PROVIDER_PKG);
    941         }
    942     }
    943 
    944     public void testIsProvisioningAllowed() throws DeviceNotAvailableException {
    945         if (!mHasFeature) {
    946             return;
    947         }
    948         // In Managed profile user when managed profile is provisioned
    949         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PreManagedProfileTest",
    950                 "testIsProvisioningAllowedFalse", mProfileUserId);
    951 
    952         // In parent user when managed profile is provisioned
    953         // It's allowed to provision again by removing the previous profile
    954         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PreManagedProfileTest",
    955                 "testIsProvisioningAllowedTrue", mParentUserId);
    956     }
    957 
    958     private void setDirectoryPrefix(String directoryName, int userId)
    959             throws DeviceNotAvailableException {
    960         String command = "content call --uri " + DIRECTORY_PRIVOIDER_URI
    961                 + " --user " + userId
    962                 + " --method " + SET_CUSTOM_DIRECTORY_PREFIX_METHOD
    963                 + " --arg " + directoryName;
    964         CLog.d("Output for command " + command + ": "
    965                 + getDevice().executeShellCommand(command));
    966     }
    967 
    968     public void testPhoneAccountVisibility() throws Exception  {
    969         if (!mHasFeature) {
    970             return;
    971         }
    972         if (!shouldRunTelecomTest()) {
    973             return;
    974         }
    975         try {
    976             // Register phone account in parent user.
    977             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
    978                     "testRegisterPhoneAccount",
    979                     mParentUserId);
    980             // The phone account should not be visible in managed user.
    981             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
    982                     "testPhoneAccountNotRegistered",
    983                     mProfileUserId);
    984         } finally {
    985             // Unregister the phone account.
    986             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
    987                     "testUnregisterPhoneAccount",
    988                     mParentUserId);
    989         }
    990 
    991         try {
    992             // Register phone account in profile user.
    993             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
    994                     "testRegisterPhoneAccount",
    995                     mProfileUserId);
    996             // The phone account should not be visible in parent user.
    997             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
    998                     "testPhoneAccountNotRegistered",
    999                     mParentUserId);
   1000         } finally {
   1001             // Unregister the phone account.
   1002             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
   1003                     "testUnregisterPhoneAccount",
   1004                     mProfileUserId);
   1005         }
   1006     }
   1007 
   1008     public void testManagedCall() throws Exception {
   1009         if (!mHasFeature) {
   1010             return;
   1011         }
   1012         if (!shouldRunTelecomTest()) {
   1013             return;
   1014         }
   1015         getDevice().setSetting(
   1016             mProfileUserId, "secure", "dialer_default_application", MANAGED_PROFILE_PKG);
   1017 
   1018         // Place a outgoing call through work phone account using TelecomManager and verify the
   1019         // call is inserted properly.
   1020         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
   1021                 "testOutgoingCallUsingTelecomManager",
   1022                 mProfileUserId);
   1023         // Make sure the call is not inserted into parent user.
   1024         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
   1025                 "testEnsureCallNotInserted",
   1026                 mParentUserId);
   1027 
   1028         // Place a outgoing call through work phone account using ACTION_CALL and verify the call
   1029         // is inserted properly.
   1030         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
   1031                 "testOutgoingCallUsingActionCall",
   1032                 mProfileUserId);
   1033         // Make sure the call is not inserted into parent user.
   1034         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
   1035                 "testEnsureCallNotInserted",
   1036                 mParentUserId);
   1037 
   1038         // Add an incoming call with parent user's phone account and verify the call is inserted
   1039         // properly.
   1040         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
   1041                 "testIncomingCall",
   1042                 mProfileUserId);
   1043         // Make sure the call is not inserted into parent user.
   1044         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
   1045                 "testEnsureCallNotInserted",
   1046                 mParentUserId);
   1047 
   1048         // Add an incoming missed call with parent user's phone account and verify the call is
   1049         // inserted properly.
   1050         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
   1051             "testIncomingMissedCall",
   1052             mProfileUserId);
   1053         // Make sure the call is not inserted into parent user.
   1054         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
   1055             "testEnsureCallNotInserted",
   1056             mParentUserId);
   1057     }
   1058 
   1059     private void givePackageWriteSettingsPermission(int userId, String pkg) throws Exception {
   1060         // Allow app to write to settings (for RingtoneManager.setActualDefaultUri to work)
   1061         String command = "appops set --user " + userId + " " + pkg
   1062                 + " android:write_settings allow";
   1063         CLog.d("Output for command " + command + ": " + getDevice().executeShellCommand(command));
   1064     }
   1065 
   1066     public void testRingtoneSync() throws Exception {
   1067         if (!mHasFeature) {
   1068             return;
   1069         }
   1070         givePackageWriteSettingsPermission(mProfileUserId, MANAGED_PROFILE_PKG);
   1071         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".RingtoneSyncTest",
   1072                 "testRingtoneSync", mProfileUserId);
   1073     }
   1074 
   1075     // Test if setting RINGTONE disables sync
   1076     public void testRingtoneSyncAutoDisableRingtone() throws Exception {
   1077         if (!mHasFeature) {
   1078             return;
   1079         }
   1080         givePackageWriteSettingsPermission(mProfileUserId, MANAGED_PROFILE_PKG);
   1081         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".RingtoneSyncTest",
   1082                 "testRingtoneDisableSync", mProfileUserId);
   1083     }
   1084 
   1085     // Test if setting NOTIFICATION disables sync
   1086     public void testRingtoneSyncAutoDisableNotification() throws Exception {
   1087         if (!mHasFeature) {
   1088             return;
   1089         }
   1090         givePackageWriteSettingsPermission(mProfileUserId, MANAGED_PROFILE_PKG);
   1091         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".RingtoneSyncTest",
   1092                 "testNotificationDisableSync", mProfileUserId);
   1093     }
   1094 
   1095     // Test if setting ALARM disables sync
   1096     public void testRingtoneSyncAutoDisableAlarm() throws Exception {
   1097         if (!mHasFeature) {
   1098             return;
   1099         }
   1100         givePackageWriteSettingsPermission(mProfileUserId, MANAGED_PROFILE_PKG);
   1101         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".RingtoneSyncTest",
   1102                 "testAlarmDisableSync", mProfileUserId);
   1103     }
   1104 
   1105     public void testTrustAgentInfo() throws Exception {
   1106         if (!mHasFeature) {
   1107             return;
   1108         }
   1109         // Set and get trust agent config using child dpm instance.
   1110         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".TrustAgentInfoTest",
   1111                 "testSetAndGetTrustAgentConfiguration_child",
   1112                 mProfileUserId);
   1113         // Set and get trust agent config using parent dpm instance.
   1114         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".TrustAgentInfoTest",
   1115                 "testSetAndGetTrustAgentConfiguration_parent",
   1116                 mProfileUserId);
   1117         // Unified case
   1118         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".TrustAgentInfoTest",
   1119                 "testSetTrustAgentConfiguration_bothHaveTrustAgentConfigAndUnified",
   1120                 mProfileUserId);
   1121         // Non-unified case
   1122         try {
   1123             changeUserCredential("1234", null, mProfileUserId);
   1124             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".TrustAgentInfoTest",
   1125                     "testSetTrustAgentConfiguration_bothHaveTrustAgentConfigAndNonUnified",
   1126                     mProfileUserId);
   1127         } finally {
   1128             changeUserCredential(null, "1234", mProfileUserId);
   1129         }
   1130     }
   1131 
   1132     public void testSanityCheck() throws Exception {
   1133         if (!mHasFeature) {
   1134             return;
   1135         }
   1136         // Install SimpleApp in work profile only and check activity in it can be launched.
   1137         installAppAsUser(SIMPLE_APP_APK, mProfileUserId);
   1138         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".SanityTest", mProfileUserId);
   1139     }
   1140 
   1141     public void testBluetoothSharingRestriction() throws Exception {
   1142         final boolean hasBluetooth = hasDeviceFeature(FEATURE_BLUETOOTH);
   1143         if (!mHasFeature || !hasBluetooth) {
   1144             return;
   1145         }
   1146 
   1147         // Primary profile should be able to use bluetooth sharing.
   1148         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".BluetoothSharingRestrictionPrimaryProfileTest",
   1149                 "testBluetoothSharingAvailable", mPrimaryUserId);
   1150 
   1151         // Managed profile owner should be able to control it via DISALLOW_BLUETOOTH_SHARING.
   1152         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".BluetoothSharingRestrictionTest",
   1153                 "testOppDisabledWhenRestrictionSet", mProfileUserId);
   1154     }
   1155 
   1156     public void testResetPasswordWithTokenBeforeUnlock() throws Exception {
   1157         if (!mHasFeature || !mSupportsFbe) {
   1158             return;
   1159         }
   1160 
   1161         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ResetPasswordWithTokenTest",
   1162                 "testSetupWorkProfile", mProfileUserId);
   1163         lockProfile();
   1164         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ResetPasswordWithTokenTest",
   1165                 "testResetPasswordBeforeUnlock", mProfileUserId);
   1166         // Password needs to be in sync with ResetPasswordWithTokenTest.PASSWORD1
   1167         verifyUserCredential(RESET_PASSWORD_TEST_DEFAULT_PASSWORD, mProfileUserId);
   1168     }
   1169 
   1170     /**
   1171      * Test password reset token is still functional after the primary user clears and
   1172      * re-adds back its device lock. This is to detect a regression where the work profile
   1173      * undergoes an untrusted credential reset (causing synthetic password to change, invalidating
   1174      * existing password reset token) if it has unified work challenge and the primary user clears
   1175      * the device lock.
   1176      */
   1177     public void testResetPasswordTokenUsableAfterClearingLock() throws Exception {
   1178         if (!mHasFeature || !mSupportsFbe) {
   1179             return;
   1180         }
   1181         final String devicePassword = "1234";
   1182 
   1183         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ResetPasswordWithTokenTest",
   1184                 "testSetResetPasswordToken", mProfileUserId);
   1185         try {
   1186             changeUserCredential(devicePassword, null, mParentUserId);
   1187             changeUserCredential(null, devicePassword, mParentUserId);
   1188             changeUserCredential(devicePassword, null, mParentUserId);
   1189             lockProfile();
   1190             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ResetPasswordWithTokenTest",
   1191                     "testResetPasswordBeforeUnlock", mProfileUserId);
   1192             verifyUserCredential(RESET_PASSWORD_TEST_DEFAULT_PASSWORD, mProfileUserId);
   1193         } finally {
   1194             changeUserCredential(null, devicePassword, mParentUserId);
   1195             // Cycle the device screen to flush stale password information from keyguard,
   1196             // otherwise it will still ask for the non-existent password.
   1197             // return screen to be on for cts test runs
   1198             executeShellCommand("input keyevent KEYCODE_WAKEUP");
   1199             executeShellCommand("input keyevent KEYCODE_SLEEP");
   1200             executeShellCommand("input keyevent KEYCODE_WAKEUP");
   1201         }
   1202     }
   1203 
   1204     public void testIsUsingUnifiedPassword() throws Exception {
   1205         if (!mHasFeature) {
   1206             return;
   1207         }
   1208 
   1209         // Freshly created profile profile has no separate challenge.
   1210         verifyUnifiedPassword(true);
   1211 
   1212         // Set separate challenge and verify that the API reports it correctly.
   1213         changeUserCredential("1234" /* newCredential */, null /* oldCredential */, mProfileUserId);
   1214         verifyUnifiedPassword(false);
   1215     }
   1216 
   1217     private void verifyUnifiedPassword(boolean unified) throws DeviceNotAvailableException {
   1218         final String testMethod =
   1219                 unified ? "testUsingUnifiedPassword" : "testNotUsingUnifiedPassword";
   1220         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".IsUsingUnifiedPasswordTest",
   1221                 testMethod, mProfileUserId);
   1222     }
   1223 
   1224     private void disableActivityForUser(String activityName, int userId)
   1225             throws DeviceNotAvailableException {
   1226         String command = "am start -W --user " + userId
   1227                 + " --es extra-package " + MANAGED_PROFILE_PKG
   1228                 + " --es extra-class-name " + MANAGED_PROFILE_PKG + "." + activityName
   1229                 + " " + MANAGED_PROFILE_PKG + "/.ComponentDisablingActivity ";
   1230         CLog.d("Output for command " + command + ": "
   1231                 + getDevice().executeShellCommand(command));
   1232     }
   1233 
   1234     private void changeUserRestrictionOrFail(String key, boolean value, int userId)
   1235             throws DeviceNotAvailableException {
   1236         changeUserRestrictionOrFail(key, value, userId, MANAGED_PROFILE_PKG);
   1237     }
   1238 
   1239     private String changeUserRestriction(String key, boolean value, int userId)
   1240             throws DeviceNotAvailableException {
   1241         return changeUserRestriction(key, value, userId, MANAGED_PROFILE_PKG);
   1242     }
   1243 
   1244     private void setIdleWhitelist(String packageName, boolean enabled)
   1245             throws DeviceNotAvailableException {
   1246         String command = "cmd deviceidle whitelist " + (enabled ? "+" : "-") + packageName;
   1247         CLog.d("Output for command " + command + ": "
   1248                 + getDevice().executeShellCommand(command));
   1249     }
   1250 
   1251     private String changeCrossProfileWidgetForUser(String packageName, String command, int userId)
   1252             throws DeviceNotAvailableException {
   1253         String adbCommand = "am start -W --user " + userId
   1254                 + " -c android.intent.category.DEFAULT "
   1255                 + " --es extra-command " + command
   1256                 + " --es extra-package-name " + packageName
   1257                 + " " + MANAGED_PROFILE_PKG + "/.SetPolicyActivity";
   1258         String commandOutput = getDevice().executeShellCommand(adbCommand);
   1259         CLog.d("Output for command " + adbCommand + ": " + commandOutput);
   1260         return commandOutput;
   1261     }
   1262 
   1263     // status should be one of never, undefined, ask, always
   1264     private void changeVerificationStatus(int userId, String packageName, String status)
   1265             throws DeviceNotAvailableException {
   1266         String command = "pm set-app-link --user " + userId + " " + packageName + " " + status;
   1267         CLog.d("Output for command " + command + ": "
   1268                 + getDevice().executeShellCommand(command));
   1269     }
   1270 
   1271     protected void startWidgetHostService() throws Exception {
   1272         String command = "am startservice --user " + mParentUserId
   1273                 + " -a " + WIDGET_PROVIDER_PKG + ".REGISTER_CALLBACK "
   1274                 + "--ei user-extra " + getUserSerialNumber(mProfileUserId)
   1275                 + " " + WIDGET_PROVIDER_PKG + "/.SimpleAppWidgetHostService";
   1276         CLog.d("Output for command " + command + ": "
   1277               + getDevice().executeShellCommand(command));
   1278     }
   1279 
   1280     private void assertAppLinkResult(String methodName) throws DeviceNotAvailableException {
   1281         runDeviceTestsAsUser(INTENT_SENDER_PKG, ".AppLinkTest", methodName,
   1282                 mProfileUserId);
   1283     }
   1284 
   1285     private boolean shouldRunTelecomTest() throws DeviceNotAvailableException {
   1286         return hasDeviceFeature(FEATURE_TELEPHONY) && hasDeviceFeature(FEATURE_CONNECTION_SERVICE);
   1287     }
   1288 
   1289     private void runManagedContactsTest(Callable<Void> callable) throws Exception {
   1290         if (!mHasFeature) {
   1291             return;
   1292         }
   1293 
   1294         try {
   1295             // Allow cross profile contacts search.
   1296             // TODO test both on and off.
   1297             getDevice().executeShellCommand(
   1298                     "settings put --user " + mProfileUserId
   1299                     + " secure managed_profile_contact_remote_search 1");
   1300 
   1301             // Add test account
   1302             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
   1303                     "testAddTestAccount", mParentUserId);
   1304             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
   1305                     "testAddTestAccount", mProfileUserId);
   1306 
   1307             // Install directory provider to both primary and managed profile
   1308             installAppAsUser(DIRECTORY_PROVIDER_APK, mProfileUserId);
   1309             installAppAsUser(DIRECTORY_PROVIDER_APK, mParentUserId);
   1310             setDirectoryPrefix(PRIMARY_DIRECTORY_PREFIX, mParentUserId);
   1311             setDirectoryPrefix(MANAGED_DIRECTORY_PREFIX, mProfileUserId);
   1312 
   1313             // Check enterprise directory API works
   1314             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
   1315                     "testGetDirectoryListInPrimaryProfile", mParentUserId);
   1316 
   1317             // Insert Primary profile Contacts
   1318             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
   1319                     "testPrimaryProfilePhoneAndEmailLookup_insertedAndfound", mParentUserId);
   1320             // Insert Managed profile Contacts
   1321             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
   1322                     "testManagedProfilePhoneAndEmailLookup_insertedAndfound", mProfileUserId);
   1323             // Insert a primary contact with same phone & email as other
   1324             // enterprise contacts
   1325             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
   1326                     "testPrimaryProfileDuplicatedPhoneEmailContact_insertedAndfound",
   1327                     mParentUserId);
   1328             // Insert a enterprise contact with same phone & email as other
   1329             // primary contacts
   1330             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
   1331                     "testManagedProfileDuplicatedPhoneEmailContact_insertedAndfound",
   1332                     mProfileUserId);
   1333 
   1334             callable.call();
   1335 
   1336         } finally {
   1337             // Clean up in managed profile and primary profile
   1338             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
   1339                     "testCurrentProfileContacts_removeContacts", mProfileUserId);
   1340             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
   1341                     "testCurrentProfileContacts_removeContacts", mParentUserId);
   1342             getDevice().uninstallPackage(DIRECTORY_PROVIDER_PKG);
   1343         }
   1344     }
   1345 
   1346 
   1347     /*
   1348      * Container for running ContactsTest under multi-user environment
   1349      */
   1350     private static class ContactsTestSet {
   1351 
   1352         private ManagedProfileTest mManagedProfileTest;
   1353         private String mManagedProfilePackage;
   1354         private int mParentUserId;
   1355         private int mProfileUserId;
   1356 
   1357         public ContactsTestSet(ManagedProfileTest managedProfileTest, String managedProfilePackage,
   1358                 int parentUserId, int profileUserId) {
   1359             mManagedProfileTest = managedProfileTest;
   1360             mManagedProfilePackage = managedProfilePackage;
   1361             mParentUserId = parentUserId;
   1362             mProfileUserId = profileUserId;
   1363         }
   1364 
   1365         private void runDeviceTestsAsUser(String pkgName, String testClassName,
   1366                 String testMethodName, Integer userId) throws DeviceNotAvailableException {
   1367             mManagedProfileTest.runDeviceTestsAsUser(pkgName, testClassName, testMethodName,
   1368                     userId);
   1369         }
   1370 
   1371         // Enable / Disable cross profile caller id
   1372         public void setCallerIdEnabled(boolean enabled) throws DeviceNotAvailableException {
   1373             if (enabled) {
   1374                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1375                         "testSetCrossProfileCallerIdDisabled_false", mProfileUserId);
   1376             } else {
   1377                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1378                         "testSetCrossProfileCallerIdDisabled_true", mProfileUserId);
   1379             }
   1380         }
   1381 
   1382         // Enable / Disable cross profile contacts search
   1383         public void setContactsSearchEnabled(boolean enabled) throws DeviceNotAvailableException {
   1384             if (enabled) {
   1385                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1386                         "testSetCrossProfileContactsSearchDisabled_false", mProfileUserId);
   1387             } else {
   1388                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1389                         "testSetCrossProfileContactsSearchDisabled_true", mProfileUserId);
   1390             }
   1391         }
   1392 
   1393         public void checkIfCanLookupEnterpriseContacts(boolean expected)
   1394                 throws DeviceNotAvailableException {
   1395             // Primary user cannot use ordinary phone/email lookup api to access
   1396             // managed contacts
   1397             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1398                     "testPrimaryProfilePhoneLookup_canNotAccessEnterpriseContact", mParentUserId);
   1399             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1400                     "testPrimaryProfileEmailLookup_canNotAccessEnterpriseContact", mParentUserId);
   1401             // Primary user can use ENTERPRISE_CONTENT_FILTER_URI to access
   1402             // primary contacts
   1403             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1404                     "testPrimaryProfileEnterprisePhoneLookup_canAccessPrimaryContact",
   1405                     mParentUserId);
   1406             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1407                     "testPrimaryProfileEnterpriseEmailLookup_canAccessPrimaryContact",
   1408                     mParentUserId);
   1409             // When there exist contacts with the same phone/email in primary &
   1410             // enterprise,
   1411             // primary user can use ENTERPRISE_CONTENT_FILTER_URI to access the
   1412             // primary contact.
   1413             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1414                     "testPrimaryProfileEnterpriseEmailLookupDuplicated_canAccessPrimaryContact",
   1415                     mParentUserId);
   1416             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1417                     "testPrimaryProfileEnterprisePhoneLookupDuplicated_canAccessPrimaryContact",
   1418                     mParentUserId);
   1419 
   1420             // Managed user cannot use ordinary phone/email lookup api to access
   1421             // primary contacts
   1422             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1423                     "testManagedProfilePhoneLookup_canNotAccessPrimaryContact", mProfileUserId);
   1424             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1425                     "testManagedProfileEmailLookup_canNotAccessPrimaryContact", mProfileUserId);
   1426             // Managed user can use ENTERPRISE_CONTENT_FILTER_URI to access
   1427             // enterprise contacts
   1428             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1429                     "testManagedProfileEnterprisePhoneLookup_canAccessEnterpriseContact",
   1430                     mProfileUserId);
   1431             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1432                     "testManagedProfileEnterpriseEmailLookup_canAccessEnterpriseContact",
   1433                     mProfileUserId);
   1434             // Managed user cannot use ENTERPRISE_CONTENT_FILTER_URI to access
   1435             // primary contacts
   1436             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1437                     "testManagedProfileEnterprisePhoneLookup_canNotAccessPrimaryContact",
   1438                     mProfileUserId);
   1439             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1440                     "testManagedProfileEnterpriseEmailLookup_canNotAccessPrimaryContact",
   1441                     mProfileUserId);
   1442             // When there exist contacts with the same phone/email in primary &
   1443             // enterprise,
   1444             // managed user can use ENTERPRISE_CONTENT_FILTER_URI to access the
   1445             // enterprise contact.
   1446             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1447                     "testManagedProfileEnterpriseEmailLookupDuplicated_canAccessEnterpriseContact",
   1448                     mProfileUserId);
   1449             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1450                     "testManagedProfileEnterprisePhoneLookupDuplicated_canAccessEnterpriseContact",
   1451                     mProfileUserId);
   1452 
   1453             // Check if phone lookup can access primary directories
   1454             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1455                     "testPrimaryProfileEnterprisePhoneLookup_canAccessPrimaryDirectories",
   1456                     mParentUserId);
   1457 
   1458             // Check if email lookup can access primary directories
   1459             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1460                     "testPrimaryProfileEnterpriseEmailLookup_canAccessPrimaryDirectories",
   1461                     mParentUserId);
   1462 
   1463             if (expected) {
   1464                 // Primary user can use ENTERPRISE_CONTENT_FILTER_URI to access
   1465                 // managed profile contacts
   1466                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1467                         "testPrimaryProfileEnterprisePhoneLookup_canAccessEnterpriseContact",
   1468                         mParentUserId);
   1469                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1470                         "testPrimaryProfileEnterpriseEmailLookup_canAccessEnterpriseContact",
   1471                         mParentUserId);
   1472 
   1473                 // Make sure SIP enterprise lookup works too.
   1474                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1475                         "testPrimaryProfileEnterpriseSipLookup_canAccessEnterpriseContact",
   1476                         mParentUserId);
   1477 
   1478                 // Check if phone lookup can access enterprise directories
   1479                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1480                         "testPrimaryProfileEnterprisePhoneLookup_canAccessManagedDirectories",
   1481                         mParentUserId);
   1482 
   1483                 // Check if email lookup can access enterprise directories
   1484                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1485                         "testPrimaryProfileEnterpriseEmailLookup_canAccessManagedDirectories",
   1486                         mParentUserId);
   1487             } else {
   1488                 // Primary user cannot use ENTERPRISE_CONTENT_FILTER_URI to
   1489                 // access managed contacts
   1490                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1491                         "testPrimaryProfileEnterprisePhoneLookup_canNotAccessEnterpriseContact",
   1492                         mParentUserId);
   1493                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1494                         "testPrimaryProfileEnterprisePhoneLookup_canNotAccessManagedDirectories",
   1495                         mParentUserId);
   1496 
   1497                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1498                         "testPrimaryProfileEnterpriseEmailLookup_canNotAccessManagedDirectories",
   1499                         mParentUserId);
   1500                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1501                         "testPrimaryProfileEnterprisePhoneLookup_canNotAccessManagedDirectories",
   1502                         mParentUserId);
   1503             }
   1504         }
   1505 
   1506         public void checkIfCanFilterSelfContacts() throws DeviceNotAvailableException {
   1507             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1508                     "testPrimaryProfileEnterpriseCallableFilter_canAccessPrimaryDirectories",
   1509                     mParentUserId);
   1510             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1511                     "testManagedProfileEnterpriseCallableFilter_canAccessManagedDirectories",
   1512                     mProfileUserId);
   1513 
   1514             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1515                     "testPrimaryProfileEnterpriseEmailFilter_canAccessPrimaryDirectories",
   1516                     mParentUserId);
   1517             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1518                     "testEnterpriseProfileEnterpriseEmailFilter_canAccessManagedDirectories",
   1519                     mProfileUserId);
   1520 
   1521             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1522                     "testPrimaryProfileEnterpriseContactFilter_canAccessPrimaryDirectories",
   1523                     mParentUserId);
   1524             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1525                     "testManagedProfileEnterpriseContactFilter_canAccessManagedDirectories",
   1526                     mProfileUserId);
   1527 
   1528             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1529                     "testPrimaryProfileEnterprisePhoneFilter_canAccessPrimaryDirectories",
   1530                     mParentUserId);
   1531             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1532                     "testManagedProfileEnterprisePhoneFilter_canAccessManagedDirectories",
   1533                     mProfileUserId);
   1534         }
   1535 
   1536         public void checkIfCanFilterEnterpriseContacts(boolean expected)
   1537                 throws DeviceNotAvailableException {
   1538             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1539                     "testFilterUriWhenDirectoryParamMissing", mParentUserId);
   1540             if (expected) {
   1541                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1542                         "testPrimaryProfileEnterpriseCallableFilter_canAccessManagedDirectories",
   1543                         mParentUserId);
   1544                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1545                         "testPrimaryProfileEnterpriseEmailFilter_canAccessManagedDirectories",
   1546                         mParentUserId);
   1547                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1548                         "testPrimaryProfileEnterpriseContactFilter_canAccessManagedDirectories",
   1549                         mParentUserId);
   1550                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1551                         "testPrimaryProfileEnterprisePhoneFilter_canAccessManagedDirectories",
   1552                         mParentUserId);
   1553             } else {
   1554                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1555                         "testPrimaryProfileEnterpriseCallableFilter_canNotAccessManagedDirectories",
   1556                         mParentUserId);
   1557                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1558                         "testPrimaryProfileEnterpriseEmailFilter_canNotAccessManagedDirectories",
   1559                         mParentUserId);
   1560                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1561                         "testPrimaryProfileEnterpriseContactFilter_canNotAccessManagedDirectories",
   1562                         mParentUserId);
   1563                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1564                         "testPrimaryProfileEnterprisePhoneFilter_canNotAccessManagedDirectories",
   1565                         mParentUserId);
   1566             }
   1567         }
   1568 
   1569         public void checkIfNoEnterpriseDirectoryFound() throws DeviceNotAvailableException {
   1570             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
   1571                     "testPrimaryProfileEnterpriseDirectories_canNotAccessManagedDirectories",
   1572                     mParentUserId);
   1573         }
   1574     }
   1575 }
   1576