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.concurrent.Callable;
26 import java.util.concurrent.TimeUnit;
27 import java.util.regex.Matcher;
28 import java.util.regex.Pattern;
29 
30 /**
31  * Set of tests for Managed Profile use cases.
32  */
33 public class ManagedProfileTest extends BaseDevicePolicyTest {
34 
35     private static final String MANAGED_PROFILE_PKG = "com.android.cts.managedprofile";
36     private static final String MANAGED_PROFILE_APK = "CtsManagedProfileApp.apk";
37 
38     private static final String DEVICE_OWNER_PKG = "com.android.cts.deviceowner";
39     private static final String DEVICE_OWNER_APK = "CtsDeviceOwnerApp.apk";
40     private static final String DEVICE_OWNER_ADMIN =
41             DEVICE_OWNER_PKG + ".BaseDeviceOwnerTest$BasicAdminReceiver";
42 
43     private static final String INTENT_SENDER_PKG = "com.android.cts.intent.sender";
44     private static final String INTENT_SENDER_APK = "CtsIntentSenderApp.apk";
45 
46     private static final String INTENT_RECEIVER_PKG = "com.android.cts.intent.receiver";
47     private static final String INTENT_RECEIVER_APK = "CtsIntentReceiverApp.apk";
48 
49     private static final String WIFI_CONFIG_CREATOR_PKG = "com.android.cts.wificonfigcreator";
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 ADMIN_RECEIVER_TEST_CLASS =
65             MANAGED_PROFILE_PKG + ".BaseManagedProfileTest$BasicAdminReceiver";
66 
67     private static final String FEATURE_BLUETOOTH = "android.hardware.bluetooth";
68     private static final String FEATURE_CAMERA = "android.hardware.camera";
69     private static final String FEATURE_WIFI = "android.hardware.wifi";
70     private static final String FEATURE_TELEPHONY = "android.hardware.telephony";
71     private static final String FEATURE_CONNECTION_SERVICE = "android.software.connectionservice";
72 
73     private static final String SIMPLE_APP_APK = "CtsSimpleApp.apk";
74     private static final String SIMPLE_APP_PKG = "com.android.cts.launcherapps.simpleapp";
75 
76     private static final long TIMEOUT_USER_LOCKED_MILLIS = TimeUnit.SECONDS.toMillis(15);
77 
78     private int mParentUserId;
79 
80     // ID of the profile we'll create. This will always be a profile of the parent.
81     private int mProfileUserId;
82     private String mPackageVerifier;
83 
84     private boolean mHasNfcFeature;
85 
86     @Override
setUp()87     protected void setUp() throws Exception {
88         super.setUp();
89 
90         // We need multi user to be supported in order to create a profile of the user owner.
91         mHasFeature = mHasFeature && hasDeviceFeature(
92                 "android.software.managed_users");
93         mHasNfcFeature = hasDeviceFeature("android.hardware.nfc");
94 
95         if (mHasFeature) {
96             removeTestUsers();
97             mParentUserId = mPrimaryUserId;
98             mProfileUserId = createManagedProfile(mParentUserId);
99 
100             installAppAsUser(MANAGED_PROFILE_APK, mParentUserId);
101             installAppAsUser(MANAGED_PROFILE_APK, mProfileUserId);
102             setProfileOwnerOrFail(MANAGED_PROFILE_PKG + "/" + ADMIN_RECEIVER_TEST_CLASS,
103                     mProfileUserId);
104             startUser(mProfileUserId);
105         }
106     }
107 
108     @Override
tearDown()109     protected void tearDown() throws Exception {
110         if (mHasFeature) {
111             removeUser(mProfileUserId);
112             getDevice().uninstallPackage(MANAGED_PROFILE_PKG);
113             getDevice().uninstallPackage(INTENT_SENDER_PKG);
114             getDevice().uninstallPackage(INTENT_RECEIVER_PKG);
115         }
116         super.tearDown();
117     }
118 
testManagedProfileSetup()119     public void testManagedProfileSetup() throws Exception {
120         if (!mHasFeature) {
121             return;
122         }
123         runDeviceTestsAsUser(
124                 MANAGED_PROFILE_PKG, MANAGED_PROFILE_PKG + ".ManagedProfileSetupTest",
125                 mProfileUserId);
126     }
127 
128     /**
129      *  wipeData() test removes the managed profile, so it needs to separated from other tests.
130      */
testWipeData()131     public void testWipeData() throws Exception {
132         if (!mHasFeature) {
133             return;
134         }
135         assertTrue(listUsers().contains(mProfileUserId));
136         runDeviceTestsAsUser(
137                 MANAGED_PROFILE_PKG, MANAGED_PROFILE_PKG + ".WipeDataTest", mProfileUserId);
138         // Note: the managed profile is removed by this test, which will make removeUserCommand in
139         // tearDown() to complain, but that should be OK since its result is not asserted.
140         assertUserGetsRemoved(mProfileUserId);
141     }
142 
testLockNowWithKeyEviction()143     public void testLockNowWithKeyEviction() throws Exception {
144         if (!mHasFeature || !mSupportsFbe) {
145             return;
146         }
147         changeUserCredential("1234", null, mProfileUserId);
148         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, MANAGED_PROFILE_PKG + ".LockNowTest",
149                 "testLockNowWithKeyEviction", mProfileUserId);
150         final String cmd = "dumpsys activity | grep 'User #" + mProfileUserId + ": state='";
151         final Pattern p = Pattern.compile("state=([\\p{Upper}_]+)$");
152         SuccessCondition userLocked = () -> {
153             final String activityDump = getDevice().executeShellCommand(cmd);
154             final Matcher m = p.matcher(activityDump);
155             return m.find() && m.group(1).equals("RUNNING_LOCKED");
156         };
157         tryWaitForSuccess(
158                 userLocked,
159                 "The managed profile has not been locked after calling "
160                         + "lockNow(FLAG_SECURE_USER_DATA)",
161                 TIMEOUT_USER_LOCKED_MILLIS);
162     }
163 
testMaxOneManagedProfile()164     public void testMaxOneManagedProfile() throws Exception {
165         int newUserId = -1;
166         try {
167             newUserId = createManagedProfile(mParentUserId);
168         } catch (AssertionFailedError expected) {
169         }
170         if (newUserId > 0) {
171             removeUser(newUserId);
172             fail(mHasFeature ? "Device must allow creating only one managed profile"
173                     : "Device must not allow creating a managed profile");
174         }
175     }
176 
177     /**
178      * Verify that removing a managed profile will remove all networks owned by that profile.
179      */
testProfileWifiCleanup()180     public void testProfileWifiCleanup() throws Exception {
181         if (!mHasFeature || !hasDeviceFeature(FEATURE_WIFI)) {
182             return;
183         }
184         installAppAsUser(WIFI_CONFIG_CREATOR_APK, mProfileUserId);
185 
186         runDeviceTestsAsUser(
187                 MANAGED_PROFILE_PKG, ".WifiTest", "testRemoveWifiNetworkIfExists", mParentUserId);
188 
189         runDeviceTestsAsUser(
190                 MANAGED_PROFILE_PKG, ".WifiTest", "testAddWifiNetwork", mProfileUserId);
191 
192         // Now delete the user - should undo the effect of testAddWifiNetwork.
193         removeUser(mProfileUserId);
194         runDeviceTestsAsUser(
195                 MANAGED_PROFILE_PKG, ".WifiTest", "testWifiNetworkDoesNotExist",
196                 mParentUserId);
197     }
198 
testWifiMacAddress()199     public void testWifiMacAddress() throws Exception {
200         if (!mHasFeature || !hasDeviceFeature(FEATURE_WIFI)) {
201             return;
202         }
203         runDeviceTestsAsUser(
204                 MANAGED_PROFILE_PKG, ".WifiTest", "testCannotGetWifiMacAddress", mProfileUserId);
205     }
206 
testCrossProfileIntentFilters()207     public void testCrossProfileIntentFilters() throws Exception {
208         if (!mHasFeature) {
209             return;
210         }
211         // Set up activities: ManagedProfileActivity will only be enabled in the managed profile and
212         // PrimaryUserActivity only in the primary one
213         disableActivityForUser("ManagedProfileActivity", mParentUserId);
214         disableActivityForUser("PrimaryUserActivity", mProfileUserId);
215 
216         runDeviceTestsAsUser(MANAGED_PROFILE_PKG,
217                 MANAGED_PROFILE_PKG + ".ManagedProfileTest", mProfileUserId);
218 
219         // Set up filters from primary to managed profile
220         String command = "am start -W --user " + mProfileUserId  + " " + MANAGED_PROFILE_PKG
221                 + "/.PrimaryUserFilterSetterActivity";
222         CLog.d("Output for command " + command + ": "
223               + getDevice().executeShellCommand(command));
224         runDeviceTestsAsUser(
225                 MANAGED_PROFILE_PKG, MANAGED_PROFILE_PKG + ".PrimaryUserTest", mParentUserId);
226         // TODO: Test with startActivity
227     }
228 
testAppLinks_verificationStatus()229     public void testAppLinks_verificationStatus() throws Exception {
230         if (!mHasFeature) {
231             return;
232         }
233         // Disable all pre-existing browsers in the managed profile so they don't interfere with
234         // intents resolution.
235         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils",
236                 "testDisableAllBrowsers", mProfileUserId);
237         installAppAsUser(INTENT_RECEIVER_APK, mParentUserId);
238         installAppAsUser(INTENT_SENDER_APK, mParentUserId);
239         installAppAsUser(INTENT_RECEIVER_APK, mProfileUserId);
240         installAppAsUser(INTENT_SENDER_APK, mProfileUserId);
241 
242         changeVerificationStatus(mParentUserId, INTENT_RECEIVER_PKG, "ask");
243         changeVerificationStatus(mProfileUserId, INTENT_RECEIVER_PKG, "ask");
244         // We should have two receivers: IntentReceiverActivity and BrowserActivity in the
245         // managed profile
246         assertAppLinkResult("testTwoReceivers");
247 
248         changeUserRestrictionOrFail("allow_parent_profile_app_linking", true, mProfileUserId);
249         // Now we should also have one receiver in the primary user, so three receivers in total.
250         assertAppLinkResult("testThreeReceivers");
251 
252         changeVerificationStatus(mParentUserId, INTENT_RECEIVER_PKG, "never");
253         // The primary user one has been set to never: we should only have the managed profile ones.
254         assertAppLinkResult("testTwoReceivers");
255 
256         changeVerificationStatus(mProfileUserId, INTENT_RECEIVER_PKG, "never");
257         // Now there's only the browser in the managed profile left
258         assertAppLinkResult("testReceivedByBrowserActivityInManaged");
259 
260         changeVerificationStatus(mProfileUserId, INTENT_RECEIVER_PKG, "always");
261         changeVerificationStatus(mParentUserId, INTENT_RECEIVER_PKG, "always");
262         // We have one always in the primary user and one always in the managed profile: the managed
263         // profile one should have precedence.
264         assertAppLinkResult("testReceivedByAppLinkActivityInManaged");
265     }
266 
testAppLinks_enabledStatus()267     public void testAppLinks_enabledStatus() throws Exception {
268         if (!mHasFeature) {
269             return;
270         }
271         // Disable all pre-existing browsers in the managed profile so they don't interfere with
272         // intents resolution.
273         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils",
274                 "testDisableAllBrowsers", mProfileUserId);
275         installAppAsUser(INTENT_RECEIVER_APK, mParentUserId);
276         installAppAsUser(INTENT_SENDER_APK, mParentUserId);
277         installAppAsUser(INTENT_RECEIVER_APK, mProfileUserId);
278         installAppAsUser(INTENT_SENDER_APK, mProfileUserId);
279 
280         final String APP_HANDLER_COMPONENT = "com.android.cts.intent.receiver/.AppLinkActivity";
281 
282         // allow_parent_profile_app_linking is not set, try different enabled state combinations.
283         // We should not have app link handler in parent user no matter whether it is enabled.
284 
285         disableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT);
286         disableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT);
287         assertAppLinkResult("testReceivedByBrowserActivityInManaged");
288 
289         enableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT);
290         disableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT);
291         assertAppLinkResult("testReceivedByBrowserActivityInManaged");
292 
293         disableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT);
294         enableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT);
295         assertAppLinkResult("testTwoReceivers");
296 
297         enableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT);
298         enableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT);
299         assertAppLinkResult("testTwoReceivers");
300 
301         // We now set allow_parent_profile_app_linking, and hence we should have the app handler
302         // in parent user if it is enabled.
303         changeUserRestrictionOrFail("allow_parent_profile_app_linking", true, mProfileUserId);
304 
305         disableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT);
306         disableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT);
307         assertAppLinkResult("testReceivedByBrowserActivityInManaged");
308 
309         enableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT);
310         disableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT);
311         assertAppLinkResult("testTwoReceivers");
312 
313         disableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT);
314         enableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT);
315         assertAppLinkResult("testTwoReceivers");
316 
317         enableComponentOrPackage(mParentUserId, APP_HANDLER_COMPONENT);
318         enableComponentOrPackage(mProfileUserId, APP_HANDLER_COMPONENT);
319         assertAppLinkResult("testThreeReceivers");
320     }
321 
testSettingsIntents()322     public void testSettingsIntents() throws Exception {
323         if (!mHasFeature) {
324             return;
325         }
326 
327         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".SettingsIntentsTest",
328                 mProfileUserId);
329     }
330 
testCrossProfileContent()331     public void testCrossProfileContent() throws Exception {
332         if (!mHasFeature) {
333             return;
334         }
335         installAppAsUser(INTENT_RECEIVER_APK, mParentUserId);
336         installAppAsUser(INTENT_SENDER_APK, mParentUserId);
337         installAppAsUser(INTENT_RECEIVER_APK, mProfileUserId);
338         installAppAsUser(INTENT_SENDER_APK, mProfileUserId);
339 
340         // Test from parent to managed
341         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils",
342                 "testRemoveAllFilters", mProfileUserId);
343         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils",
344                 "testAddManagedCanAccessParentFilters", mProfileUserId);
345         runDeviceTestsAsUser(INTENT_SENDER_PKG, ".ContentTest", mParentUserId);
346 
347         // Test from managed to parent
348         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils",
349                 "testRemoveAllFilters", mProfileUserId);
350         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils",
351                 "testAddParentCanAccessManagedFilters", mProfileUserId);
352         runDeviceTestsAsUser(INTENT_SENDER_PKG, ".ContentTest", mProfileUserId);
353 
354     }
355 
testCrossProfileCopyPaste()356     public void testCrossProfileCopyPaste() throws Exception {
357         if (!mHasFeature) {
358             return;
359         }
360         installAppAsUser(INTENT_RECEIVER_APK, mParentUserId);
361         installAppAsUser(INTENT_SENDER_APK, mParentUserId);
362         installAppAsUser(INTENT_RECEIVER_APK, mProfileUserId);
363         installAppAsUser(INTENT_SENDER_APK, mProfileUserId);
364 
365         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils",
366                 "testAllowCrossProfileCopyPaste", mProfileUserId);
367         // Test that managed can see what is copied in the parent.
368         testCrossProfileCopyPasteInternal(mProfileUserId, true);
369         // Test that the parent can see what is copied in managed.
370         testCrossProfileCopyPasteInternal(mParentUserId, true);
371 
372         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils",
373                 "testDisallowCrossProfileCopyPaste", mProfileUserId);
374         // Test that managed can still see what is copied in the parent.
375         testCrossProfileCopyPasteInternal(mProfileUserId, true);
376         // Test that the parent cannot see what is copied in managed.
377         testCrossProfileCopyPasteInternal(mParentUserId, false);
378     }
379 
testCrossProfileCopyPasteInternal(int userId, boolean shouldSucceed)380     private void testCrossProfileCopyPasteInternal(int userId, boolean shouldSucceed)
381             throws DeviceNotAvailableException {
382         final String direction = (userId == mParentUserId)
383                 ? "testAddManagedCanAccessParentFilters"
384                 : "testAddParentCanAccessManagedFilters";
385         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils",
386                 "testRemoveAllFilters", mProfileUserId);
387         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileUtils",
388                 direction, mProfileUserId);
389         if (shouldSucceed) {
390             runDeviceTestsAsUser(INTENT_SENDER_PKG, ".CopyPasteTest",
391                     "testCanReadAcrossProfiles", userId);
392             runDeviceTestsAsUser(INTENT_SENDER_PKG, ".CopyPasteTest",
393                     "testIsNotified", userId);
394         } else {
395             runDeviceTestsAsUser(INTENT_SENDER_PKG, ".CopyPasteTest",
396                     "testCannotReadAcrossProfiles", userId);
397         }
398     }
399 
400     /** Tests for the API helper class. */
testCurrentApiHelper()401     public void testCurrentApiHelper() throws Exception {
402         if (!mHasFeature) {
403             return;
404         }
405         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CurrentApiHelperTest",
406                 mProfileUserId);
407     }
408 
409     /** Test: unsupported public APIs are disabled on a parent profile. */
testParentProfileApiDisabled()410     public void testParentProfileApiDisabled() throws Exception {
411         if (!mHasFeature) {
412             return;
413         }
414         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ParentProfileTest",
415                 "testParentProfileApiDisabled", mProfileUserId);
416     }
417 
418     // TODO: This test is not specific to managed profiles, but applies to multi-user in general.
419     // Move it to a MultiUserTest class when there is one. Should probably move
420     // SetPolicyActivity to a more generic apk too as it might be useful for different kinds
421     // of tests (same applies to ComponentDisablingActivity).
testNoDebuggingFeaturesRestriction()422     public void testNoDebuggingFeaturesRestriction() throws Exception {
423         if (!mHasFeature) {
424             return;
425         }
426         // If adb is running as root, then the adb uid is 0 instead of SHELL_UID,
427         // so the DISALLOW_DEBUGGING_FEATURES restriction does not work and this test
428         // fails.
429         if (getDevice().isAdbRoot()) {
430             CLog.logAndDisplay(LogLevel.WARN,
431                     "Cannot test testNoDebuggingFeaturesRestriction() in eng/userdebug build");
432             return;
433         }
434         String restriction = "no_debugging_features";  // UserManager.DISALLOW_DEBUGGING_FEATURES
435 
436         changeUserRestrictionOrFail(restriction, true, mProfileUserId);
437 
438 
439         // This should now fail, as the shell is not available to start activities under a different
440         // user once the restriction is in place.
441         String addRestrictionCommandOutput =
442                 changeUserRestriction(restriction, true, mProfileUserId);
443         assertTrue(
444                 "Expected SecurityException when starting the activity "
445                         + addRestrictionCommandOutput,
446                 addRestrictionCommandOutput.contains("SecurityException"));
447     }
448 
449     // Test the bluetooth API from a managed profile.
testBluetooth()450     public void testBluetooth() throws Exception {
451         boolean hasBluetooth = hasDeviceFeature(FEATURE_BLUETOOTH);
452         if (!mHasFeature || !hasBluetooth) {
453             return ;
454         }
455 
456         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".BluetoothTest",
457                 "testEnableDisable", mProfileUserId);
458         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".BluetoothTest",
459                 "testGetAddress", mProfileUserId);
460         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".BluetoothTest",
461                 "testListenUsingRfcommWithServiceRecord", mProfileUserId);
462         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".BluetoothTest",
463                 "testGetRemoteDevice", mProfileUserId);
464     }
465 
testCameraPolicy()466     public void testCameraPolicy() throws Exception {
467         boolean hasCamera = hasDeviceFeature(FEATURE_CAMERA);
468         if (!mHasFeature || !hasCamera) {
469             return;
470         }
471         try {
472             setDeviceAdmin(MANAGED_PROFILE_PKG + "/.PrimaryUserDeviceAdmin", mParentUserId);
473 
474             // Disable managed profile camera.
475             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest",
476                     "testDisableCameraInManagedProfile",
477                     mProfileUserId);
478             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest",
479                     "testIsCameraEnabledInPrimaryProfile",
480                     mParentUserId);
481 
482             // Enable managed profile camera.
483             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest",
484                     "testEnableCameraInManagedProfile",
485                     mProfileUserId);
486             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest",
487                     "testIsCameraEnabledInPrimaryProfile",
488                     mParentUserId);
489 
490             // Disable primary profile camera.
491             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest",
492                     "testDisableCameraInPrimaryProfile",
493                     mParentUserId);
494             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest",
495                     "testIsCameraEnabledInManagedProfile",
496                     mProfileUserId);
497 
498             // Enable primary profile camera.
499             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest",
500                     "testEnableCameraInPrimaryProfile",
501                     mParentUserId);
502             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CameraPolicyTest",
503                     "testIsCameraEnabledInManagedProfile",
504                     mProfileUserId);
505         } finally {
506             final String adminHelperClass = ".PrimaryUserAdminHelper";
507             runDeviceTestsAsUser(MANAGED_PROFILE_PKG,
508                     adminHelperClass, "testClearDeviceAdmin", mParentUserId);
509         }
510     }
511 
512 
testManagedContactsUris()513     public void testManagedContactsUris() throws Exception {
514         runManagedContactsTest(new Callable<Void>() {
515             @Override
516             public Void call() throws Exception {
517                 ContactsTestSet contactsTestSet = new ContactsTestSet(ManagedProfileTest.this,
518                         MANAGED_PROFILE_PKG, mParentUserId, mProfileUserId);
519 
520                 contactsTestSet.setCallerIdEnabled(true);
521                 contactsTestSet.setContactsSearchEnabled(true);
522                 contactsTestSet.checkIfCanLookupEnterpriseContacts(true);
523                 contactsTestSet.checkIfCanFilterEnterpriseContacts(true);
524                 contactsTestSet.checkIfCanFilterSelfContacts();
525                 return null;
526             }
527         });
528     }
529 
testManagedQuickContacts()530     public void testManagedQuickContacts() throws Exception {
531         runManagedContactsTest(new Callable<Void>() {
532             @Override
533             public Void call() throws Exception {
534                 runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
535                         "testQuickContact", mParentUserId);
536                 return null;
537             }
538         });
539     }
540 
testManagedContactsPolicies()541     public void testManagedContactsPolicies() throws Exception {
542         runManagedContactsTest(new Callable<Void>() {
543             @Override
544             public Void call() throws Exception {
545                 ContactsTestSet contactsTestSet = new ContactsTestSet(ManagedProfileTest.this,
546                         MANAGED_PROFILE_PKG, mParentUserId, mProfileUserId);
547                 try {
548                     contactsTestSet.setCallerIdEnabled(true);
549                     contactsTestSet.setContactsSearchEnabled(false);
550                     contactsTestSet.checkIfCanLookupEnterpriseContacts(true);
551                     contactsTestSet.checkIfCanFilterEnterpriseContacts(false);
552                     contactsTestSet.checkIfCanFilterSelfContacts();
553                     contactsTestSet.setCallerIdEnabled(false);
554                     contactsTestSet.setContactsSearchEnabled(true);
555                     contactsTestSet.checkIfCanLookupEnterpriseContacts(false);
556                     contactsTestSet.checkIfCanFilterEnterpriseContacts(true);
557                     contactsTestSet.checkIfCanFilterSelfContacts();
558                     contactsTestSet.setCallerIdEnabled(false);
559                     contactsTestSet.setContactsSearchEnabled(false);
560                     contactsTestSet.checkIfCanLookupEnterpriseContacts(false);
561                     contactsTestSet.checkIfCanFilterEnterpriseContacts(false);
562                     contactsTestSet.checkIfCanFilterSelfContacts();
563                     contactsTestSet.checkIfNoEnterpriseDirectoryFound();
564                     return null;
565                 } finally {
566                     // reset policies
567                     contactsTestSet.setCallerIdEnabled(true);
568                     contactsTestSet.setContactsSearchEnabled(true);
569                 }
570             }
571         });
572     }
573 
testOrganizationInfo()574     public void testOrganizationInfo() throws Exception {
575         if (!mHasFeature) {
576             return;
577         }
578         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".OrganizationInfoTest",
579                 "testDefaultOrganizationColor", mProfileUserId);
580         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".OrganizationInfoTest",
581                 "testDefaultOrganizationNameIsNull", mProfileUserId);
582         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".OrganizationInfoTest",
583                 mProfileUserId);
584     }
585 
testPasswordMinimumRestrictions()586     public void testPasswordMinimumRestrictions() throws Exception {
587         if (!mHasFeature) {
588             return;
589         }
590         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PasswordMinimumRestrictionsTest",
591                 mProfileUserId);
592     }
593 
testBluetoothContactSharingDisabled()594     public void testBluetoothContactSharingDisabled() throws Exception {
595         if (!mHasFeature) {
596             return;
597         }
598         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
599                 "testSetBluetoothContactSharingDisabled_setterAndGetter", mProfileUserId);
600     }
601 
testCannotSetProfileOwnerAgain()602     public void testCannotSetProfileOwnerAgain() throws Exception {
603         if (!mHasFeature) {
604             return;
605         }
606         // verify that we can't set the same admin receiver as profile owner again
607         assertFalse(setProfileOwner(
608                 MANAGED_PROFILE_PKG + "/" + ADMIN_RECEIVER_TEST_CLASS, mProfileUserId,
609                 /*expectFailure*/ true));
610 
611         // verify that we can't set a different admin receiver as profile owner
612         installAppAsUser(DEVICE_OWNER_APK, mProfileUserId);
613         assertFalse(setProfileOwner(DEVICE_OWNER_PKG + "/" + DEVICE_OWNER_ADMIN, mProfileUserId,
614                 /*expectFailure*/ true));
615     }
616 
testCannotSetDeviceOwnerWhenProfilePresent()617     public void testCannotSetDeviceOwnerWhenProfilePresent() throws Exception {
618         if (!mHasFeature) {
619             return;
620         }
621 
622         try {
623             installAppAsUser(DEVICE_OWNER_APK, mParentUserId);
624             assertFalse(setDeviceOwner(DEVICE_OWNER_PKG + "/" + DEVICE_OWNER_ADMIN, mParentUserId,
625                     /*expectFailure*/ true));
626         } finally {
627             // make sure we clean up in case we succeeded in setting the device owner
628             removeAdmin(DEVICE_OWNER_PKG + "/" + DEVICE_OWNER_ADMIN, mParentUserId);
629             getDevice().uninstallPackage(DEVICE_OWNER_PKG);
630         }
631     }
632 
testNfcRestriction()633     public void testNfcRestriction() throws Exception {
634         if (!mHasFeature || !mHasNfcFeature) {
635             return;
636         }
637 
638         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".NfcTest",
639                 "testNfcShareEnabled", mProfileUserId);
640         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".NfcTest",
641                 "testNfcShareEnabled", mParentUserId);
642 
643         changeUserRestrictionOrFail("no_outgoing_beam" /* UserManager.DISALLOW_OUTGOING_BEAM */,
644                 true, mProfileUserId);
645 
646         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".NfcTest",
647                 "testNfcShareDisabled", mProfileUserId);
648         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".NfcTest",
649                 "testNfcShareEnabled", mParentUserId);
650     }
651 
testCrossProfileWidgets()652     public void testCrossProfileWidgets() throws Exception {
653         if (!mHasFeature) {
654             return;
655         }
656 
657         try {
658             installAppAsUser(WIDGET_PROVIDER_APK, mProfileUserId);
659             installAppAsUser(WIDGET_PROVIDER_APK, mParentUserId);
660             getDevice().executeShellCommand("appwidget grantbind --user " + mParentUserId
661                     + " --package " + WIDGET_PROVIDER_PKG);
662             setIdleWhitelist(WIDGET_PROVIDER_PKG, true);
663             startWidgetHostService();
664 
665             String commandOutput = changeCrossProfileWidgetForUser(WIDGET_PROVIDER_PKG,
666                     "add-cross-profile-widget", mProfileUserId);
667             assertTrue("Command was expected to succeed " + commandOutput,
668                     commandOutput.contains("Status: ok"));
669 
670             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileWidgetTest",
671                     "testCrossProfileWidgetProviderAdded", mProfileUserId);
672             runDeviceTestsAsUser(MANAGED_PROFILE_PKG,
673                     ".CrossProfileWidgetPrimaryUserTest",
674                     "testHasCrossProfileWidgetProvider_true", mParentUserId);
675             runDeviceTestsAsUser(MANAGED_PROFILE_PKG,
676                     ".CrossProfileWidgetPrimaryUserTest",
677                     "testHostReceivesWidgetUpdates_true", mParentUserId);
678 
679             commandOutput = changeCrossProfileWidgetForUser(WIDGET_PROVIDER_PKG,
680                     "remove-cross-profile-widget", mProfileUserId);
681             assertTrue("Command was expected to succeed " + commandOutput,
682                     commandOutput.contains("Status: ok"));
683 
684             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".CrossProfileWidgetTest",
685                     "testCrossProfileWidgetProviderRemoved", mProfileUserId);
686             runDeviceTestsAsUser(MANAGED_PROFILE_PKG,
687                     ".CrossProfileWidgetPrimaryUserTest",
688                     "testHasCrossProfileWidgetProvider_false", mParentUserId);
689             runDeviceTestsAsUser(MANAGED_PROFILE_PKG,
690                     ".CrossProfileWidgetPrimaryUserTest",
691                     "testHostReceivesWidgetUpdates_false", mParentUserId);
692         } finally {
693             changeCrossProfileWidgetForUser(WIDGET_PROVIDER_PKG, "remove-cross-profile-widget",
694                     mProfileUserId);
695             getDevice().uninstallPackage(WIDGET_PROVIDER_PKG);
696         }
697     }
698 
testIsProvisioningAllowed()699     public void testIsProvisioningAllowed() throws DeviceNotAvailableException {
700         if (!mHasFeature) {
701             return;
702         }
703         // In Managed profile user when managed profile is provisioned
704         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PreManagedProfileTest",
705                 "testIsProvisioningAllowedFalse", mProfileUserId);
706 
707         // In parent user when managed profile is provisioned
708         // It's allowed to provision again by removing the previous profile
709         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PreManagedProfileTest",
710                 "testIsProvisioningAllowedTrue", mParentUserId);
711     }
712 
setDirectoryPrefix(String directoryName, int userId)713     private void setDirectoryPrefix(String directoryName, int userId)
714             throws DeviceNotAvailableException {
715         String command = "content call --uri " + DIRECTORY_PRIVOIDER_URI
716                 + " --user " + userId
717                 + " --method " + SET_CUSTOM_DIRECTORY_PREFIX_METHOD
718                 + " --arg " + directoryName;
719         CLog.d("Output for command " + command + ": "
720                 + getDevice().executeShellCommand(command));
721     }
722 
testPhoneAccountVisibility()723     public void testPhoneAccountVisibility() throws Exception  {
724         if (!mHasFeature) {
725             return;
726         }
727         if (!shouldRunTelecomTest()) {
728             return;
729         }
730         try {
731             // Register phone account in parent user.
732             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
733                     "testRegisterPhoneAccount",
734                     mParentUserId);
735             // The phone account should not be visible in managed user.
736             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
737                     "testPhoneAccountNotRegistered",
738                     mProfileUserId);
739         } finally {
740             // Unregister the phone account.
741             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
742                     "testUnregisterPhoneAccount",
743                     mParentUserId);
744         }
745 
746         try {
747             // Register phone account in profile user.
748             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
749                     "testRegisterPhoneAccount",
750                     mProfileUserId);
751             // The phone account should not be visible in parent user.
752             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
753                     "testPhoneAccountNotRegistered",
754                     mParentUserId);
755         } finally {
756             // Unregister the phone account.
757             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
758                     "testUnregisterPhoneAccount",
759                     mProfileUserId);
760         }
761     }
762 
testManagedCall()763     public void testManagedCall() throws Exception {
764         if (!mHasFeature) {
765             return;
766         }
767         if (!shouldRunTelecomTest()) {
768             return;
769         }
770         // Place a outgoing call through work phone account using TelecomManager and verify the
771         // call is inserted properly.
772         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
773                 "testOutgoingCallUsingTelecomManager",
774                 mProfileUserId);
775         // Make sure the call is not inserted into parent user.
776         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
777                 "testEnsureCallNotInserted",
778                 mParentUserId);
779 
780         // Place a outgoing call through work phone account using ACTION_CALL and verify the call
781         // is inserted properly.
782         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
783                 "testOutgoingCallUsingActionCall",
784                 mProfileUserId);
785         // Make sure the call is not inserted into parent user.
786         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
787                 "testEnsureCallNotInserted",
788                 mParentUserId);
789 
790         // Add an incoming call with parent user's phone account and verify the call is inserted
791         // properly.
792         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
793                 "testIncomingCall",
794                 mProfileUserId);
795         // Make sure the call is not inserted into parent user.
796         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".PhoneAccountTest",
797                 "testEnsureCallNotInserted",
798                 mParentUserId);
799     }
800 
givePackageWriteSettingsPermission(int userId, String pkg)801     private void givePackageWriteSettingsPermission(int userId, String pkg) throws Exception {
802         // Allow app to write to settings (for RingtoneManager.setActualDefaultUri to work)
803         String command = "appops set --user " + userId + " " + pkg
804                 + " android:write_settings allow";
805         CLog.d("Output for command " + command + ": " + getDevice().executeShellCommand(command));
806     }
807 
testRingtoneSync()808     public void testRingtoneSync() throws Exception {
809         if (!mHasFeature) {
810             return;
811         }
812         givePackageWriteSettingsPermission(mProfileUserId, MANAGED_PROFILE_PKG);
813         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".RingtoneSyncTest",
814                 "testRingtoneSync", mProfileUserId);
815     }
816 
817     // Test if setting RINGTONE disables sync
testRingtoneSyncAutoDisableRingtone()818     public void testRingtoneSyncAutoDisableRingtone() throws Exception {
819         if (!mHasFeature) {
820             return;
821         }
822         givePackageWriteSettingsPermission(mProfileUserId, MANAGED_PROFILE_PKG);
823         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".RingtoneSyncTest",
824                 "testRingtoneDisableSync", mProfileUserId);
825     }
826 
827     // Test if setting NOTIFICATION disables sync
testRingtoneSyncAutoDisableNotification()828     public void testRingtoneSyncAutoDisableNotification() throws Exception {
829         if (!mHasFeature) {
830             return;
831         }
832         givePackageWriteSettingsPermission(mProfileUserId, MANAGED_PROFILE_PKG);
833         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".RingtoneSyncTest",
834                 "testNotificationDisableSync", mProfileUserId);
835     }
836 
837     // Test if setting ALARM disables sync
testRingtoneSyncAutoDisableAlarm()838     public void testRingtoneSyncAutoDisableAlarm() throws Exception {
839         if (!mHasFeature) {
840             return;
841         }
842         givePackageWriteSettingsPermission(mProfileUserId, MANAGED_PROFILE_PKG);
843         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".RingtoneSyncTest",
844                 "testAlarmDisableSync", mProfileUserId);
845     }
846 
testTrustAgentInfo()847     public void testTrustAgentInfo() throws Exception {
848         if (!mHasFeature) {
849             return;
850         }
851         // Set and get trust agent config using child dpm instance.
852         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".TrustAgentInfoTest",
853                 "testSetAndGetTrustAgentConfiguration_child",
854                 mProfileUserId);
855         // Set and get trust agent config using parent dpm instance.
856         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".TrustAgentInfoTest",
857                 "testSetAndGetTrustAgentConfiguration_parent",
858                 mProfileUserId);
859         // Unified case
860         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".TrustAgentInfoTest",
861                 "testSetTrustAgentConfiguration_bothHaveTrustAgentConfigAndUnified",
862                 mProfileUserId);
863         // Non-unified case
864         try {
865             changeUserCredential("1234", null, mProfileUserId);
866             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".TrustAgentInfoTest",
867                     "testSetTrustAgentConfiguration_bothHaveTrustAgentConfigAndNonUnified",
868                     mProfileUserId);
869         } finally {
870             changeUserCredential(null, "1234", mProfileUserId);
871         }
872     }
873 
testSanityCheck()874     public void testSanityCheck() throws Exception {
875         if (!mHasFeature) {
876             return;
877         }
878         // Install SimpleApp in work profile only and check activity in it can be launched.
879         installAppAsUser(SIMPLE_APP_APK, mProfileUserId);
880         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".SanityTest", mProfileUserId);
881     }
882 
testBluetoothSharingRestriction()883     public void testBluetoothSharingRestriction() throws Exception {
884         final boolean hasBluetooth = hasDeviceFeature(FEATURE_BLUETOOTH);
885         if (!mHasFeature || !hasBluetooth) {
886             return;
887         }
888 
889         // Primary profile should be able to use bluetooth sharing.
890         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".BluetoothSharingRestrictionPrimaryProfileTest",
891                 "testBluetoothSharingAvailable", mPrimaryUserId);
892 
893         // Managed profile owner should be able to control it via DISALLOW_BLUETOOTH_SHARING.
894         runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".BluetoothSharingRestrictionTest",
895                 "testOppDisabledWhenRestrictionSet", mProfileUserId);
896     }
897 
disableActivityForUser(String activityName, int userId)898     private void disableActivityForUser(String activityName, int userId)
899             throws DeviceNotAvailableException {
900         String command = "am start -W --user " + userId
901                 + " --es extra-package " + MANAGED_PROFILE_PKG
902                 + " --es extra-class-name " + MANAGED_PROFILE_PKG + "." + activityName
903                 + " " + MANAGED_PROFILE_PKG + "/.ComponentDisablingActivity ";
904         CLog.d("Output for command " + command + ": "
905                 + getDevice().executeShellCommand(command));
906     }
907 
changeUserRestrictionOrFail(String key, boolean value, int userId)908     private void changeUserRestrictionOrFail(String key, boolean value, int userId)
909             throws DeviceNotAvailableException {
910         changeUserRestrictionOrFail(key, value, userId, MANAGED_PROFILE_PKG);
911     }
912 
changeUserRestriction(String key, boolean value, int userId)913     private String changeUserRestriction(String key, boolean value, int userId)
914             throws DeviceNotAvailableException {
915         return changeUserRestriction(key, value, userId, MANAGED_PROFILE_PKG);
916     }
917 
setIdleWhitelist(String packageName, boolean enabled)918     private void setIdleWhitelist(String packageName, boolean enabled)
919             throws DeviceNotAvailableException {
920         String command = "cmd deviceidle whitelist " + (enabled ? "+" : "-") + packageName;
921         CLog.d("Output for command " + command + ": "
922                 + getDevice().executeShellCommand(command));
923     }
924 
changeCrossProfileWidgetForUser(String packageName, String command, int userId)925     private String changeCrossProfileWidgetForUser(String packageName, String command, int userId)
926             throws DeviceNotAvailableException {
927         String adbCommand = "am start -W --user " + userId
928                 + " -c android.intent.category.DEFAULT "
929                 + " --es extra-command " + command
930                 + " --es extra-package-name " + packageName
931                 + " " + MANAGED_PROFILE_PKG + "/.SetPolicyActivity";
932         String commandOutput = getDevice().executeShellCommand(adbCommand);
933         CLog.d("Output for command " + adbCommand + ": " + commandOutput);
934         return commandOutput;
935     }
936 
937     // status should be one of never, undefined, ask, always
changeVerificationStatus(int userId, String packageName, String status)938     private void changeVerificationStatus(int userId, String packageName, String status)
939             throws DeviceNotAvailableException {
940         String command = "pm set-app-link --user " + userId + " " + packageName + " " + status;
941         CLog.d("Output for command " + command + ": "
942                 + getDevice().executeShellCommand(command));
943     }
944 
startWidgetHostService()945     protected void startWidgetHostService() throws Exception {
946         String command = "am startservice --user " + mParentUserId
947                 + " -a " + WIDGET_PROVIDER_PKG + ".REGISTER_CALLBACK "
948                 + "--ei user-extra " + getUserSerialNumber(mProfileUserId)
949                 + " " + WIDGET_PROVIDER_PKG + "/.SimpleAppWidgetHostService";
950         CLog.d("Output for command " + command + ": "
951               + getDevice().executeShellCommand(command));
952     }
953 
assertAppLinkResult(String methodName)954     private void assertAppLinkResult(String methodName) throws DeviceNotAvailableException {
955         runDeviceTestsAsUser(INTENT_SENDER_PKG, ".AppLinkTest", methodName,
956                 mProfileUserId);
957     }
958 
shouldRunTelecomTest()959     private boolean shouldRunTelecomTest() throws DeviceNotAvailableException {
960         return hasDeviceFeature(FEATURE_TELEPHONY) && hasDeviceFeature(FEATURE_CONNECTION_SERVICE);
961     }
962 
runManagedContactsTest(Callable<Void> callable)963     private void runManagedContactsTest(Callable<Void> callable) throws Exception {
964         if (!mHasFeature) {
965             return;
966         }
967 
968         try {
969             // Allow cross profile contacts search.
970             // TODO test both on and off.
971             getDevice().executeShellCommand(
972                     "settings put --user " + mProfileUserId
973                     + " secure managed_profile_contact_remote_search 1");
974 
975             // Add test account
976             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
977                     "testAddTestAccount", mParentUserId);
978             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
979                     "testAddTestAccount", mProfileUserId);
980 
981             // Install directory provider to both primary and managed profile
982             installAppAsUser(DIRECTORY_PROVIDER_APK, mProfileUserId);
983             installAppAsUser(DIRECTORY_PROVIDER_APK, mParentUserId);
984             setDirectoryPrefix(PRIMARY_DIRECTORY_PREFIX, mParentUserId);
985             setDirectoryPrefix(MANAGED_DIRECTORY_PREFIX, mProfileUserId);
986 
987             // Check enterprise directory API works
988             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
989                     "testGetDirectoryListInPrimaryProfile", mParentUserId);
990 
991             // Insert Primary profile Contacts
992             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
993                     "testPrimaryProfilePhoneAndEmailLookup_insertedAndfound", mParentUserId);
994             // Insert Managed profile Contacts
995             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
996                     "testManagedProfilePhoneAndEmailLookup_insertedAndfound", mProfileUserId);
997             // Insert a primary contact with same phone & email as other
998             // enterprise contacts
999             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
1000                     "testPrimaryProfileDuplicatedPhoneEmailContact_insertedAndfound",
1001                     mParentUserId);
1002             // Insert a enterprise contact with same phone & email as other
1003             // primary contacts
1004             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
1005                     "testManagedProfileDuplicatedPhoneEmailContact_insertedAndfound",
1006                     mProfileUserId);
1007 
1008             callable.call();
1009 
1010         } finally {
1011             // Clean up in managed profile and primary profile
1012             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
1013                     "testCurrentProfileContacts_removeContacts", mProfileUserId);
1014             runDeviceTestsAsUser(MANAGED_PROFILE_PKG, ".ContactsTest",
1015                     "testCurrentProfileContacts_removeContacts", mParentUserId);
1016             getDevice().uninstallPackage(DIRECTORY_PROVIDER_PKG);
1017         }
1018     }
1019 
1020 
1021     /*
1022      * Container for running ContactsTest under multi-user environment
1023      */
1024     private static class ContactsTestSet {
1025 
1026         private ManagedProfileTest mManagedProfileTest;
1027         private String mManagedProfilePackage;
1028         private int mParentUserId;
1029         private int mProfileUserId;
1030 
ContactsTestSet(ManagedProfileTest managedProfileTest, String managedProfilePackage, int parentUserId, int profileUserId)1031         public ContactsTestSet(ManagedProfileTest managedProfileTest, String managedProfilePackage,
1032                 int parentUserId, int profileUserId) {
1033             mManagedProfileTest = managedProfileTest;
1034             mManagedProfilePackage = managedProfilePackage;
1035             mParentUserId = parentUserId;
1036             mProfileUserId = profileUserId;
1037         }
1038 
runDeviceTestsAsUser(String pkgName, String testClassName, String testMethodName, Integer userId)1039         private void runDeviceTestsAsUser(String pkgName, String testClassName,
1040                 String testMethodName, Integer userId) throws DeviceNotAvailableException {
1041             mManagedProfileTest.runDeviceTestsAsUser(pkgName, testClassName, testMethodName,
1042                     userId);
1043         }
1044 
1045         // Enable / Disable cross profile caller id
setCallerIdEnabled(boolean enabled)1046         public void setCallerIdEnabled(boolean enabled) throws DeviceNotAvailableException {
1047             if (enabled) {
1048                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1049                         "testSetCrossProfileCallerIdDisabled_false", mProfileUserId);
1050             } else {
1051                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1052                         "testSetCrossProfileCallerIdDisabled_true", mProfileUserId);
1053             }
1054         }
1055 
1056         // Enable / Disable cross profile contacts search
setContactsSearchEnabled(boolean enabled)1057         public void setContactsSearchEnabled(boolean enabled) throws DeviceNotAvailableException {
1058             if (enabled) {
1059                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1060                         "testSetCrossProfileContactsSearchDisabled_false", mProfileUserId);
1061             } else {
1062                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1063                         "testSetCrossProfileContactsSearchDisabled_true", mProfileUserId);
1064             }
1065         }
1066 
checkIfCanLookupEnterpriseContacts(boolean expected)1067         public void checkIfCanLookupEnterpriseContacts(boolean expected)
1068                 throws DeviceNotAvailableException {
1069             // Primary user cannot use ordinary phone/email lookup api to access
1070             // managed contacts
1071             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1072                     "testPrimaryProfilePhoneLookup_canNotAccessEnterpriseContact", mParentUserId);
1073             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1074                     "testPrimaryProfileEmailLookup_canNotAccessEnterpriseContact", mParentUserId);
1075             // Primary user can use ENTERPRISE_CONTENT_FILTER_URI to access
1076             // primary contacts
1077             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1078                     "testPrimaryProfileEnterprisePhoneLookup_canAccessPrimaryContact",
1079                     mParentUserId);
1080             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1081                     "testPrimaryProfileEnterpriseEmailLookup_canAccessPrimaryContact",
1082                     mParentUserId);
1083             // When there exist contacts with the same phone/email in primary &
1084             // enterprise,
1085             // primary user can use ENTERPRISE_CONTENT_FILTER_URI to access the
1086             // primary contact.
1087             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1088                     "testPrimaryProfileEnterpriseEmailLookupDuplicated_canAccessPrimaryContact",
1089                     mParentUserId);
1090             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1091                     "testPrimaryProfileEnterprisePhoneLookupDuplicated_canAccessPrimaryContact",
1092                     mParentUserId);
1093 
1094             // Managed user cannot use ordinary phone/email lookup api to access
1095             // primary contacts
1096             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1097                     "testManagedProfilePhoneLookup_canNotAccessPrimaryContact", mProfileUserId);
1098             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1099                     "testManagedProfileEmailLookup_canNotAccessPrimaryContact", mProfileUserId);
1100             // Managed user can use ENTERPRISE_CONTENT_FILTER_URI to access
1101             // enterprise contacts
1102             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1103                     "testManagedProfileEnterprisePhoneLookup_canAccessEnterpriseContact",
1104                     mProfileUserId);
1105             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1106                     "testManagedProfileEnterpriseEmailLookup_canAccessEnterpriseContact",
1107                     mProfileUserId);
1108             // Managed user cannot use ENTERPRISE_CONTENT_FILTER_URI to access
1109             // primary contacts
1110             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1111                     "testManagedProfileEnterprisePhoneLookup_canNotAccessPrimaryContact",
1112                     mProfileUserId);
1113             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1114                     "testManagedProfileEnterpriseEmailLookup_canNotAccessPrimaryContact",
1115                     mProfileUserId);
1116             // When there exist contacts with the same phone/email in primary &
1117             // enterprise,
1118             // managed user can use ENTERPRISE_CONTENT_FILTER_URI to access the
1119             // enterprise contact.
1120             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1121                     "testManagedProfileEnterpriseEmailLookupDuplicated_canAccessEnterpriseContact",
1122                     mProfileUserId);
1123             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1124                     "testManagedProfileEnterprisePhoneLookupDuplicated_canAccessEnterpriseContact",
1125                     mProfileUserId);
1126 
1127             // Check if phone lookup can access primary directories
1128             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1129                     "testPrimaryProfileEnterprisePhoneLookup_canAccessPrimaryDirectories",
1130                     mParentUserId);
1131 
1132             // Check if email lookup can access primary directories
1133             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1134                     "testPrimaryProfileEnterpriseEmailLookup_canAccessPrimaryDirectories",
1135                     mParentUserId);
1136 
1137             if (expected) {
1138                 // Primary user can use ENTERPRISE_CONTENT_FILTER_URI to access
1139                 // managed profile contacts
1140                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1141                         "testPrimaryProfileEnterprisePhoneLookup_canAccessEnterpriseContact",
1142                         mParentUserId);
1143                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1144                         "testPrimaryProfileEnterpriseEmailLookup_canAccessEnterpriseContact",
1145                         mParentUserId);
1146 
1147                 // Make sure SIP enterprise lookup works too.
1148                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1149                         "testPrimaryProfileEnterpriseSipLookup_canAccessEnterpriseContact",
1150                         mParentUserId);
1151 
1152                 // Check if phone lookup can access enterprise directories
1153                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1154                         "testPrimaryProfileEnterprisePhoneLookup_canAccessManagedDirectories",
1155                         mParentUserId);
1156 
1157                 // Check if email lookup can access enterprise directories
1158                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1159                         "testPrimaryProfileEnterpriseEmailLookup_canAccessManagedDirectories",
1160                         mParentUserId);
1161             } else {
1162                 // Primary user cannot use ENTERPRISE_CONTENT_FILTER_URI to
1163                 // access managed contacts
1164                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1165                         "testPrimaryProfileEnterprisePhoneLookup_canNotAccessEnterpriseContact",
1166                         mParentUserId);
1167                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1168                         "testPrimaryProfileEnterprisePhoneLookup_canNotAccessManagedDirectories",
1169                         mParentUserId);
1170 
1171                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1172                         "testPrimaryProfileEnterpriseEmailLookup_canNotAccessManagedDirectories",
1173                         mParentUserId);
1174                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1175                         "testPrimaryProfileEnterprisePhoneLookup_canNotAccessManagedDirectories",
1176                         mParentUserId);
1177             }
1178         }
1179 
checkIfCanFilterSelfContacts()1180         public void checkIfCanFilterSelfContacts() throws DeviceNotAvailableException {
1181             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1182                     "testPrimaryProfileEnterpriseCallableFilter_canAccessPrimaryDirectories",
1183                     mParentUserId);
1184             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1185                     "testManagedProfileEnterpriseCallableFilter_canAccessManagedDirectories",
1186                     mProfileUserId);
1187 
1188             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1189                     "testPrimaryProfileEnterpriseEmailFilter_canAccessPrimaryDirectories",
1190                     mParentUserId);
1191             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1192                     "testEnterpriseProfileEnterpriseEmailFilter_canAccessManagedDirectories",
1193                     mProfileUserId);
1194 
1195             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1196                     "testPrimaryProfileEnterpriseContactFilter_canAccessPrimaryDirectories",
1197                     mParentUserId);
1198             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1199                     "testManagedProfileEnterpriseContactFilter_canAccessManagedDirectories",
1200                     mProfileUserId);
1201 
1202             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1203                     "testPrimaryProfileEnterprisePhoneFilter_canAccessPrimaryDirectories",
1204                     mParentUserId);
1205             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1206                     "testManagedProfileEnterprisePhoneFilter_canAccessManagedDirectories",
1207                     mProfileUserId);
1208         }
1209 
checkIfCanFilterEnterpriseContacts(boolean expected)1210         public void checkIfCanFilterEnterpriseContacts(boolean expected)
1211                 throws DeviceNotAvailableException {
1212             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1213                     "testFilterUriWhenDirectoryParamMissing", mParentUserId);
1214             if (expected) {
1215                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1216                         "testPrimaryProfileEnterpriseCallableFilter_canAccessManagedDirectories",
1217                         mParentUserId);
1218                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1219                         "testPrimaryProfileEnterpriseEmailFilter_canAccessManagedDirectories",
1220                         mParentUserId);
1221                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1222                         "testPrimaryProfileEnterpriseContactFilter_canAccessManagedDirectories",
1223                         mParentUserId);
1224                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1225                         "testPrimaryProfileEnterprisePhoneFilter_canAccessManagedDirectories",
1226                         mParentUserId);
1227             } else {
1228                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1229                         "testPrimaryProfileEnterpriseCallableFilter_canNotAccessManagedDirectories",
1230                         mParentUserId);
1231                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1232                         "testPrimaryProfileEnterpriseEmailFilter_canNotAccessManagedDirectories",
1233                         mParentUserId);
1234                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1235                         "testPrimaryProfileEnterpriseContactFilter_canNotAccessManagedDirectories",
1236                         mParentUserId);
1237                 runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1238                         "testPrimaryProfileEnterprisePhoneFilter_canNotAccessManagedDirectories",
1239                         mParentUserId);
1240             }
1241         }
1242 
checkIfNoEnterpriseDirectoryFound()1243         public void checkIfNoEnterpriseDirectoryFound() throws DeviceNotAvailableException {
1244             runDeviceTestsAsUser(mManagedProfilePackage, ".ContactsTest",
1245                     "testPrimaryProfileEnterpriseDirectories_canNotAccessManagedDirectories",
1246                     mParentUserId);
1247         }
1248     }
1249 }
1250