Home | History | Annotate | Download | only in devicepolicy 
      1 /*
      2  * Copyright (C) 2015 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.cts.devicepolicy;
     18 
     19 import static com.android.cts.devicepolicy.metrics.DevicePolicyEventLogVerifier.assertMetricsLogged;
     20 
     21 import android.platform.test.annotations.RequiresDevice;
     22 import android.stats.devicepolicy.EventId;
     23 
     24 import com.android.cts.devicepolicy.metrics.DevicePolicyEventLogVerifier;
     25 import com.android.cts.devicepolicy.metrics.DevicePolicyEventWrapper;
     26 import com.android.tradefed.device.DeviceNotAvailableException;
     27 import com.android.tradefed.log.LogUtil.CLog;
     28 
     29 import com.google.common.collect.ImmutableMap;
     30 
     31 import java.io.File;
     32 import java.io.FileNotFoundException;
     33 import java.util.ArrayList;
     34 import java.util.Arrays;
     35 import java.util.Collections;
     36 import java.util.HashMap;
     37 import java.util.List;
     38 import java.util.Map;
     39 import java.util.stream.Collectors;
     40 
     41 /**
     42  * Set of tests for use cases that apply to profile and device owner.
     43  * This class is the base class of MixedProfileOwnerTest, MixedDeviceOwnerTest and
     44  * MixedManagedProfileOwnerTest and is abstract to avoid running spurious tests.
     45  *
     46  * NOTE: Not all tests are executed in the subclasses.  Sometimes, if a test is not applicable to
     47  * a subclass, they override it with an empty method.
     48  */
     49 public abstract class DeviceAndProfileOwnerTest extends BaseDevicePolicyTest {
     50 
     51     public static final String DEVICE_ADMIN_PKG = "com.android.cts.deviceandprofileowner";
     52     public static final String DEVICE_ADMIN_APK = "CtsDeviceAndProfileOwnerApp.apk";
     53     public static final String ADMIN_RECEIVER_TEST_CLASS
     54             = ".BaseDeviceAdminTest$BasicAdminReceiver";
     55 
     56     private static final String STORAGE_ENCRYPTION_TEST_CLASS = ".StorageEncryptionTest";
     57     private static final String IS_PRIMARY_USER_PARAM = "isPrimaryUser";
     58 
     59     private static final String INTENT_RECEIVER_PKG = "com.android.cts.intent.receiver";
     60     private static final String INTENT_RECEIVER_APK = "CtsIntentReceiverApp.apk";
     61 
     62     private static final String INTENT_SENDER_PKG = "com.android.cts.intent.sender";
     63     private static final String INTENT_SENDER_APK = "CtsIntentSenderApp.apk";
     64 
     65     private static final String PERMISSIONS_APP_PKG = "com.android.cts.permissionapp";
     66     private static final String PERMISSIONS_APP_APK = "CtsPermissionApp.apk";
     67 
     68     private static final String SIMPLE_PRE_M_APP_PKG = "com.android.cts.launcherapps.simplepremapp";
     69     private static final String SIMPLE_PRE_M_APP_APK = "CtsSimplePreMApp.apk";
     70 
     71     private static final String APP_RESTRICTIONS_TARGET_APP_PKG
     72             = "com.android.cts.apprestrictions.targetapp";
     73     private static final String APP_RESTRICTIONS_TARGET_APP_APK = "CtsAppRestrictionsTargetApp.apk";
     74 
     75     private static final String CERT_INSTALLER_PKG = "com.android.cts.certinstaller";
     76     private static final String CERT_INSTALLER_APK = "CtsCertInstallerApp.apk";
     77 
     78     protected static final String DELEGATE_APP_PKG = "com.android.cts.delegate";
     79     private static final String DELEGATE_APP_APK = "CtsDelegateApp.apk";
     80     private static final String DELEGATION_CERT_INSTALL = "delegation-cert-install";
     81     private static final String DELEGATION_APP_RESTRICTIONS = "delegation-app-restrictions";
     82     private static final String DELEGATION_BLOCK_UNINSTALL = "delegation-block-uninstall";
     83     private static final String DELEGATION_PERMISSION_GRANT = "delegation-permission-grant";
     84     private static final String DELEGATION_PACKAGE_ACCESS = "delegation-package-access";
     85     private static final String DELEGATION_ENABLE_SYSTEM_APP = "delegation-enable-system-app";
     86     private static final String DELEGATION_CERT_SELECTION = "delegation-cert-selection";
     87 
     88     protected static final String TEST_APP_APK = "CtsSimpleApp.apk";
     89     private static final String TEST_APP_PKG = "com.android.cts.launcherapps.simpleapp";
     90     protected static final String TEST_APP_LOCATION = "/data/local/tmp/";
     91 
     92     protected static final String PACKAGE_INSTALLER_PKG = "com.android.cts.packageinstaller";
     93     protected static final String PACKAGE_INSTALLER_APK = "CtsPackageInstallerApp.apk";
     94 
     95     private static final String ACCOUNT_MANAGEMENT_PKG
     96             = "com.android.cts.devicepolicy.accountmanagement";
     97     private static final String ACCOUNT_MANAGEMENT_APK = "CtsAccountManagementDevicePolicyApp.apk";
     98 
     99     private static final String VPN_APP_PKG = "com.android.cts.vpnfirewall";
    100     private static final String VPN_APP_APK = "CtsVpnFirewallApp.apk";
    101     private static final String VPN_APP_API23_APK = "CtsVpnFirewallAppApi23.apk";
    102     private static final String VPN_APP_API24_APK = "CtsVpnFirewallAppApi24.apk";
    103     private static final String VPN_APP_NOT_ALWAYS_ON_APK = "CtsVpnFirewallAppNotAlwaysOn.apk";
    104 
    105     private static final String COMMAND_BLOCK_ACCOUNT_TYPE = "block-accounttype";
    106     private static final String COMMAND_UNBLOCK_ACCOUNT_TYPE = "unblock-accounttype";
    107 
    108     private static final String DISALLOW_MODIFY_ACCOUNTS = "no_modify_accounts";
    109     private static final String DISALLOW_REMOVE_USER = "no_remove_user";
    110     private static final String ACCOUNT_TYPE
    111             = "com.android.cts.devicepolicy.accountmanagement.account.type";
    112 
    113     private static final String CUSTOMIZATION_APP_PKG = "com.android.cts.customizationapp";
    114     private static final String CUSTOMIZATION_APP_APK = "CtsCustomizationApp.apk";
    115 
    116     private static final String AUTOFILL_APP_PKG = "com.android.cts.devicepolicy.autofillapp";
    117     private static final String AUTOFILL_APP_APK = "CtsDevicePolicyAutofillApp.apk";
    118 
    119     private static final String CONTENT_CAPTURE_APP_PKG = "com.android.cts.devicepolicy.contentcaptureapp";
    120     private static final String CONTENT_CAPTURE_APP_APK = "CtsDevicePolicyContentCaptureApp.apk";
    121 
    122     private static final String CONTENT_CAPTURE_SERVICE_PKG = "com.android.cts.devicepolicy.contentcaptureservice";
    123     private static final String CONTENT_CAPTURE_SERVICE_APK = "CtsDevicePolicyContentCaptureService.apk";
    124     private static final String CONTENT_SUGGESTIONS_APP_APK =
    125             "CtsDevicePolicyContentSuggestionsApp.apk";
    126 
    127     protected static final String ASSIST_APP_PKG = "com.android.cts.devicepolicy.assistapp";
    128     protected static final String ASSIST_APP_APK = "CtsDevicePolicyAssistApp.apk";
    129 
    130     private static final String PRINTING_APP_PKG = "com.android.cts.devicepolicy.printingapp";
    131     private static final String PRINTING_APP_APK = "CtsDevicePolicyPrintingApp.apk";
    132 
    133     private static final String METERED_DATA_APP_PKG
    134             = "com.android.cts.devicepolicy.meteredtestapp";
    135     private static final String METERED_DATA_APP_APK = "CtsMeteredDataTestApp.apk";
    136 
    137     private static final String ENABLED_NOTIFICATION_POLICY_ACCESS_PACKAGES
    138             = "enabled_notification_policy_access_packages";
    139 
    140     protected static final String ASSIST_INTERACTION_SERVICE =
    141             ASSIST_APP_PKG + "/.MyInteractionService";
    142 
    143     private static final String ARG_ALLOW_FAILURE = "allowFailure";
    144 
    145     private static final String RESTRICT_BACKGROUND_GET_CMD =
    146         "cmd netpolicy get restrict-background";
    147     private static final String RESTRICT_BACKGROUND_ON_CMD =
    148         "cmd netpolicy set restrict-background true";
    149     private static final String RESTRICT_BACKGROUND_OFF_CMD =
    150         "cmd netpolicy set restrict-background false";
    151 
    152     // The following constants were copied from DevicePolicyManager
    153     private static final int PASSWORD_QUALITY_SOMETHING = 0x10000;
    154     private static final int KEYGUARD_DISABLE_FEATURES_NONE = 0;
    155     private static final int KEYGUARD_DISABLE_FINGERPRINT = 1 << 5;
    156     private static final int KEYGUARD_DISABLE_TRUST_AGENTS = 1 << 4;
    157     private static final String DISALLOW_CONFIG_LOCATION = "no_config_location";
    158     private static final String DISALLOW_ADJUST_VOLUME = "no_adjust_volume";
    159     private static final String DISALLOW_AUTOFILL = "no_autofill";
    160     private static final String SKIP_FIRST_USE_HINTS = "skip_first_use_hints";
    161     private static final String DEFAULT_INPUT_METHOD = "default_input_method";
    162     private static final int PERMISSION_POLICY_PROMPT = 0;
    163     private static final int PERMISSION_POLICY_AUTO_GRANT = 1;
    164     private static final int PERMISSION_POLICY_AUTO_DENY = 2;
    165     private static final int PERMISSION_GRANT_STATE_DEFAULT = 0;
    166     private static final int PERMISSION_GRANT_STATE_GRANTED = 1;
    167     private static final int PERMISSION_GRANT_STATE_DENIED = 2;
    168     private static final String PARAM_APP_TO_ENABLE = "app_to_enable";
    169     public static final String RESOLVE_ACTIVITY_CMD = "cmd package resolve-activity --brief %s | tail -n 1";
    170 
    171     // ID of the user all tests are run as. For device owner this will be the primary user, for
    172     // profile owner it is the user id of the created profile.
    173     protected int mUserId;
    174 
    175     @Override
    176     protected void tearDown() throws Exception {
    177         if (mHasFeature) {
    178             getDevice().uninstallPackage(DEVICE_ADMIN_PKG);
    179             getDevice().uninstallPackage(PERMISSIONS_APP_PKG);
    180             getDevice().uninstallPackage(SIMPLE_PRE_M_APP_PKG);
    181             getDevice().uninstallPackage(APP_RESTRICTIONS_TARGET_APP_PKG);
    182             getDevice().uninstallPackage(CERT_INSTALLER_PKG);
    183             getDevice().uninstallPackage(DELEGATE_APP_PKG);
    184             getDevice().uninstallPackage(ACCOUNT_MANAGEMENT_PKG);
    185             getDevice().uninstallPackage(VPN_APP_PKG);
    186             getDevice().uninstallPackage(VPN_APP_API23_APK);
    187             getDevice().uninstallPackage(VPN_APP_API24_APK);
    188             getDevice().uninstallPackage(VPN_APP_NOT_ALWAYS_ON_APK);
    189             getDevice().uninstallPackage(INTENT_RECEIVER_PKG);
    190             getDevice().uninstallPackage(INTENT_SENDER_PKG);
    191             getDevice().uninstallPackage(CUSTOMIZATION_APP_PKG);
    192             getDevice().uninstallPackage(AUTOFILL_APP_PKG);
    193             getDevice().uninstallPackage(CONTENT_CAPTURE_SERVICE_PKG);
    194             getDevice().uninstallPackage(CONTENT_CAPTURE_APP_PKG);
    195             getDevice().uninstallPackage(PRINTING_APP_PKG);
    196             getDevice().uninstallPackage(METERED_DATA_APP_PKG);
    197             getDevice().uninstallPackage(TEST_APP_PKG);
    198 
    199             // Press the HOME key to close any alart dialog that may be shown.
    200             getDevice().executeShellCommand("input keyevent 3");
    201         }
    202         super.tearDown();
    203     }
    204 
    205     public void testCaCertManagement() throws Exception {
    206         if (!mHasFeature) {
    207             return;
    208         }
    209         executeDeviceTestClass(".CaCertManagementTest");
    210     }
    211 
    212     public void testInstallCaCertLogged() throws Exception {
    213         if (!mHasFeature) {
    214             return;
    215         }
    216         assertMetricsLogged(getDevice(), () -> {
    217             executeDeviceTestMethod(".CaCertManagementTest", "testCanInstallAndUninstallACaCert");
    218         }, new DevicePolicyEventWrapper.Builder(EventId.INSTALL_CA_CERT_VALUE)
    219                     .setAdminPackageName(DEVICE_ADMIN_PKG)
    220                     .setBoolean(false)
    221                     .build(),
    222             new DevicePolicyEventWrapper.Builder(EventId.UNINSTALL_CA_CERTS_VALUE)
    223                     .setAdminPackageName(DEVICE_ADMIN_PKG)
    224                     .setBoolean(false)
    225                     .build());
    226     }
    227 
    228     public void testApplicationRestrictionIsRestricted() throws Exception {
    229         if (!mHasFeature) {
    230             return;
    231         }
    232         installAppAsUser(DELEGATE_APP_APK, mUserId);
    233         runDeviceTestsAsUser(DELEGATE_APP_PKG, ".AppRestrictionsIsCallerDelegateHelper",
    234             "testAssertCallerIsNotApplicationRestrictionsManagingPackage", mUserId);
    235         runDeviceTestsAsUser(DEVICE_ADMIN_PKG, ".ApplicationRestrictionsIsCallerDelegateHelper",
    236             "testSetApplicationRestrictionsManagingPackageToDelegate", mUserId);
    237         runDeviceTestsAsUser(DELEGATE_APP_PKG, ".AppRestrictionsIsCallerDelegateHelper",
    238             "testAssertCallerIsApplicationRestrictionsManagingPackage", mUserId);
    239     }
    240 
    241     public void testApplicationRestrictions() throws Exception {
    242         if (!mHasFeature) {
    243             return;
    244         }
    245 
    246         installAppAsUser(DELEGATE_APP_APK, mUserId);
    247         installAppAsUser(APP_RESTRICTIONS_TARGET_APP_APK, mUserId);
    248 
    249         try {
    250             // Only the DPC can manage app restrictions by default.
    251             executeDeviceTestClass(".ApplicationRestrictionsTest");
    252             executeAppRestrictionsManagingPackageTest("testCannotAccessApis");
    253 
    254             // Letting the DELEGATE_APP_PKG manage app restrictions too.
    255             changeApplicationRestrictionsManagingPackage(DELEGATE_APP_PKG);
    256             executeAppRestrictionsManagingPackageTest("testCanAccessApis");
    257             runDeviceTestsAsUser(DELEGATE_APP_PKG, ".GeneralDelegateTest",
    258                     "testSettingAdminComponentNameThrowsException", mUserId);
    259 
    260             // The DPC should still be able to manage app restrictions normally.
    261             executeDeviceTestClass(".ApplicationRestrictionsTest");
    262 
    263             // The app shouldn't be able to manage app restrictions for other users.
    264             int parentUserId = getPrimaryUser();
    265             if (parentUserId != mUserId) {
    266                 installAppAsUser(DELEGATE_APP_APK, parentUserId);
    267                 installAppAsUser(APP_RESTRICTIONS_TARGET_APP_APK, parentUserId);
    268                 runDeviceTestsAsUser(DELEGATE_APP_PKG, ".AppRestrictionsDelegateTest",
    269                         "testCannotAccessApis", parentUserId);
    270             }
    271 
    272             // Revoking the permission for DELEGAYE_APP_PKG to manage restrictions.
    273             changeApplicationRestrictionsManagingPackage(null);
    274             executeAppRestrictionsManagingPackageTest("testCannotAccessApis");
    275 
    276             // The DPC should still be able to manage app restrictions normally.
    277             executeDeviceTestClass(".ApplicationRestrictionsTest");
    278 
    279             assertMetricsLogged(getDevice(), () -> {
    280                 executeDeviceTestMethod(".ApplicationRestrictionsTest",
    281                         "testSetApplicationRestrictions");
    282             }, new DevicePolicyEventWrapper.Builder(EventId.SET_APPLICATION_RESTRICTIONS_VALUE)
    283                     .setAdminPackageName(DEVICE_ADMIN_PKG)
    284                     .setStrings(APP_RESTRICTIONS_TARGET_APP_PKG)
    285                     .build());
    286         } finally {
    287             changeApplicationRestrictionsManagingPackage(null);
    288         }
    289     }
    290 
    291     /**
    292      * Returns a list of delegation tests that should run. Add delegations tests applicable to both
    293      * device owner and profile owners to this method directly. DO or PO specific tests should be
    294      * added to {@link #getAdditionalDelegationTests} in the subclass.
    295      */
    296     private Map<String, DevicePolicyEventWrapper[]> getDelegationTests() {
    297         final Map<String, DevicePolicyEventWrapper[]> result = new HashMap<>();
    298         result.put(".AppRestrictionsDelegateTest", null);
    299         result.put(".CertInstallDelegateTest", null);
    300         result.put(".BlockUninstallDelegateTest", null);
    301         result.put(".PermissionGrantDelegateTest", null);
    302         result.put(".PackageAccessDelegateTest", null);
    303         result.put(".EnableSystemAppDelegateTest", null);
    304         result.putAll(getAdditionalDelegationTests());
    305         return result;
    306     }
    307 
    308     Map<String, DevicePolicyEventWrapper[]> getAdditionalDelegationTests() {
    309         return Collections.<String, DevicePolicyEventWrapper[]>emptyMap();
    310     }
    311 
    312     /**
    313      * Returns a list of delegation scopes that are needed to run delegation tests. Add scopes
    314      * which are applicable to both device owner and profile owners to this method directly.
    315      * DO or PO specific scopes should be added to {@link #getAdditionalDelegationScopes}
    316      * in the subclass.
    317      */
    318     private List<String> getDelegationScopes() {
    319         final List<String> result = new ArrayList<>(Arrays.asList(
    320                 DELEGATION_APP_RESTRICTIONS,
    321                 DELEGATION_CERT_INSTALL,
    322                 DELEGATION_BLOCK_UNINSTALL,
    323                 DELEGATION_PERMISSION_GRANT,
    324                 DELEGATION_PACKAGE_ACCESS,
    325                 DELEGATION_ENABLE_SYSTEM_APP,
    326                 // CERT_SELECTION scope is in the list so it still participates GeneralDelegateTest.
    327                 // But its main functionality test is driven by testDelegationCertSelection() and
    328                 // hence missing from getDelegationTests() on purpose.
    329                 DELEGATION_CERT_SELECTION
    330                 ));
    331         result.addAll(getAdditionalDelegationScopes());
    332         return result;
    333     }
    334 
    335     List<String> getAdditionalDelegationScopes() {
    336         return Collections.<String>emptyList();
    337     }
    338 
    339     /**
    340      * General instructions to add a new delegation test:
    341      * 1. Test primary delegation functionalitiy
    342      *    Implment the delegate's positive/negate functionaility tests in a new test class
    343      *    in CtsDelegateApp.apk. Main entry point are {@code testCanAccessApis} and
    344      *    {@code testCannotAccessApis}. Once implemented, add the delegation scope and the test
    345      *    class name to {@link #getDelegationScopes}, {@link #getDelegationTests} to make the test
    346      *    run on DO/PO/PO on primary user.  If the test should only run on a subset of these
    347      *    combinations, add them to the subclass's {@link #getAdditionalDelegationScopes} and
    348      *    {@link #getDelegationScopes} intead.
    349      *    <p>Alternatively, create a separate hostside method to drive the test, similar to
    350      *    {@link #testDelegationCertSelection}. This is preferred if the delegated functionalities
    351      *    already exist in another app.
    352      * 2. Test access control of DO-only delegation
    353      *    Add the delegation scope to
    354      *    {@code DelegationTest#testDeviceOwnerOnlyDelegationsOnlyPossibleToBeSetByDeviceOwner} to
    355      *    test that only DO can delegate this scope.
    356      * 3. Test behaviour of exclusive delegation
    357      *    Add the delegation scope to {@code DelegationTest#testExclusiveDelegations} to test that
    358      *    the scope can only be delegatd to one app at a time.
    359      */
    360     public void testDelegation() throws Exception {
    361         if (!mHasFeature) {
    362             return;
    363         }
    364 
    365         // Install relevant apps.
    366         installAppAsUser(DELEGATE_APP_APK, mUserId);
    367         installAppAsUser(TEST_APP_APK, mUserId);
    368         installAppAsUser(APP_RESTRICTIONS_TARGET_APP_APK, mUserId);
    369 
    370         try {
    371             final Map<String, DevicePolicyEventWrapper[]> delegationTests = getDelegationTests();
    372             // APIs are not accessible by default.
    373             executeDelegationTests(delegationTests, false /* negative result */);
    374 
    375             // Granting the appropriate delegation scopes makes APIs accessible.
    376             final List<String> scopes = getDelegationScopes();
    377             setDelegatedScopes(DELEGATE_APP_PKG, scopes);
    378             runDeviceTestsAsUser(DELEGATE_APP_PKG, ".GeneralDelegateTest", null, mUserId,
    379                     ImmutableMap.of("scopes", String.join(",", scopes)));
    380             executeDelegationTests(delegationTests, true /* positive result */);
    381 
    382             // APIs are not accessible after revoking delegations.
    383             setDelegatedScopes(DELEGATE_APP_PKG, null);
    384             executeDelegationTests(delegationTests, false /* negative result */);
    385 
    386             // Additional delegation tests.
    387             executeDeviceTestClass(".DelegationTest");
    388 
    389         } finally {
    390             // Remove any remaining delegations.
    391             setDelegatedScopes(DELEGATE_APP_PKG, null);
    392         }
    393     }
    394 
    395     public void testDelegationCertSelection() throws Exception {
    396         if (!mHasFeature) {
    397             return;
    398         }
    399 
    400         installAppAsUser(CERT_INSTALLER_APK, mUserId);
    401         setDelegatedScopes(CERT_INSTALLER_PKG, Arrays.asList(
    402                 DELEGATION_CERT_INSTALL, DELEGATION_CERT_SELECTION));
    403 
    404         assertMetricsLogged(getDevice(), () -> {
    405                 runDeviceTestsAsUser(CERT_INSTALLER_PKG, ".CertSelectionDelegateTest", mUserId);
    406         }, new DevicePolicyEventWrapper.Builder(EventId.CHOOSE_PRIVATE_KEY_ALIAS_VALUE)
    407                 .setAdminPackageName(CERT_INSTALLER_PKG)
    408                 .setBoolean(true)
    409                 .build());
    410     }
    411 
    412     public void testPermissionGrant() throws Exception {
    413         if (!mHasFeature) {
    414             return;
    415         }
    416         installAppPermissionAppAsUser();
    417         executeDeviceTestMethod(".PermissionsTest", "testPermissionGrantState");
    418     }
    419 
    420     public void testPermissionGrant_developmentPermission() throws Exception {
    421         if (!mHasFeature) {
    422             return;
    423         }
    424         installAppPermissionAppAsUser();
    425         executeDeviceTestMethod(
    426                 ".PermissionsTest", "testPermissionGrantState_developmentPermission");
    427     }
    428 
    429     /**
    430      * Require a device for tests that use the network stack. Headless Androids running in
    431      * data centres might need their network rules un-tampered-with in order to keep the ADB / VNC
    432      * connection alive.
    433      *
    434      * This is only a problem on device owner / profile owner running on USER_SYSTEM, because
    435      * network rules for this user will affect UID 0.
    436      */
    437     @RequiresDevice
    438     public void testAlwaysOnVpn() throws Exception {
    439         if (!mHasFeature) {
    440             return;
    441         }
    442         installAppAsUser(VPN_APP_APK, mUserId);
    443         executeDeviceTestClassNoRestrictBackground(".AlwaysOnVpnTest");
    444     }
    445 
    446     @RequiresDevice
    447     public void testAlwaysOnVpnLockDown() throws Exception {
    448         if (!mHasFeature) {
    449             return;
    450         }
    451 
    452         installAppAsUser(VPN_APP_APK, mUserId);
    453         try {
    454             executeDeviceTestMethod(".AlwaysOnVpnMultiStageTest", "testAlwaysOnSet");
    455             forceStopPackageForUser(VPN_APP_PKG, mUserId);
    456             executeDeviceTestMethod(".AlwaysOnVpnMultiStageTest", "testNetworkBlocked");
    457         } finally {
    458             executeDeviceTestMethod(".AlwaysOnVpnMultiStageTest", "testCleanup");
    459         }
    460     }
    461 
    462     @RequiresDevice
    463     public void testAlwaysOnVpnAcrossReboot() throws Exception {
    464         if (!mHasFeature) {
    465             return;
    466         }
    467 
    468         try {
    469             installAppAsUser(VPN_APP_APK, mUserId);
    470             executeDeviceTestMethod(".AlwaysOnVpnMultiStageTest", "testAlwaysOnSetWithWhitelist");
    471             rebootAndWaitUntilReady();
    472             // Make sure profile user initialization is complete before proceeding.
    473             waitForBroadcastIdle();
    474             executeDeviceTestMethod(".AlwaysOnVpnMultiStageTest", "testAlwaysOnSetAfterReboot");
    475         } finally {
    476             executeDeviceTestMethod(".AlwaysOnVpnMultiStageTest", "testCleanup");
    477         }
    478     }
    479 
    480     @RequiresDevice
    481     public void testAlwaysOnVpnPackageUninstalled() throws Exception {
    482         if (!mHasFeature) {
    483             return;
    484         }
    485 
    486         installAppAsUser(VPN_APP_APK, mUserId);
    487         try {
    488             executeDeviceTestMethod(".AlwaysOnVpnMultiStageTest", "testAlwaysOnSet");
    489             getDevice().uninstallPackage(VPN_APP_PKG);
    490             executeDeviceTestMethod(".AlwaysOnVpnMultiStageTest", "testAlwaysOnVpnDisabled");
    491             executeDeviceTestMethod(".AlwaysOnVpnMultiStageTest", "testSetNonExistingPackage");
    492         } finally {
    493             executeDeviceTestMethod(".AlwaysOnVpnMultiStageTest", "testCleanup");
    494         }
    495     }
    496 
    497     @RequiresDevice
    498     public void testAlwaysOnVpnUnsupportedPackage() throws Exception {
    499         if (!mHasFeature) {
    500             return;
    501         }
    502 
    503         try {
    504             // Target SDK = 23: unsupported
    505             installAppAsUser(VPN_APP_API23_APK, mUserId);
    506             executeDeviceTestMethod(".AlwaysOnVpnUnsupportedTest", "testSetUnsupportedVpnAlwaysOn");
    507 
    508             // Target SDK = 24: supported
    509             installAppAsUser(VPN_APP_API24_APK, mUserId);
    510             executeDeviceTestMethod(".AlwaysOnVpnUnsupportedTest", "testSetSupportedVpnAlwaysOn");
    511             executeDeviceTestMethod(".AlwaysOnVpnUnsupportedTest", "testClearAlwaysOnVpn");
    512 
    513             // Explicit opt-out: unsupported
    514             installAppAsUser(VPN_APP_NOT_ALWAYS_ON_APK, mUserId);
    515             executeDeviceTestMethod(".AlwaysOnVpnUnsupportedTest", "testSetUnsupportedVpnAlwaysOn");
    516         } finally {
    517             executeDeviceTestMethod(".AlwaysOnVpnUnsupportedTest", "testClearAlwaysOnVpn");
    518         }
    519     }
    520 
    521     @RequiresDevice
    522     public void testAlwaysOnVpnUnsupportedPackageReplaced() throws Exception {
    523         if (!mHasFeature) {
    524             return;
    525         }
    526 
    527         try {
    528             // Target SDK = 24: supported
    529             executeDeviceTestMethod(".AlwaysOnVpnUnsupportedTest", "testAssertNoAlwaysOnVpn");
    530             installAppAsUser(VPN_APP_API24_APK, mUserId);
    531             executeDeviceTestMethod(".AlwaysOnVpnUnsupportedTest", "testSetSupportedVpnAlwaysOn");
    532             // Update the app to target higher API level, but with manifest opt-out
    533             installAppAsUser(VPN_APP_NOT_ALWAYS_ON_APK, mUserId);
    534             executeDeviceTestMethod(".AlwaysOnVpnUnsupportedTest", "testAssertNoAlwaysOnVpn");
    535         } finally {
    536             executeDeviceTestMethod(".AlwaysOnVpnUnsupportedTest", "testClearAlwaysOnVpn");
    537         }
    538     }
    539 
    540     @RequiresDevice
    541     public void testAlwaysOnVpnPackageLogged() throws Exception {
    542         if (!mHasFeature) {
    543             return;
    544         }
    545         // Will be uninstalled in tearDown().
    546         installAppAsUser(VPN_APP_APK, mUserId);
    547         assertMetricsLogged(getDevice(), () -> {
    548             executeDeviceTestMethod(".AlwaysOnVpnUnsupportedTest", "testSetSupportedVpnAlwaysOn");
    549         }, new DevicePolicyEventWrapper.Builder(EventId.SET_ALWAYS_ON_VPN_PACKAGE_VALUE)
    550                     .setAdminPackageName(DEVICE_ADMIN_PKG)
    551                     .setStrings(VPN_APP_PKG)
    552                     .setBoolean(true)
    553                     .setInt(0)
    554                     .build());
    555     }
    556 
    557     public void testPermissionPolicy() throws Exception {
    558         if (!mHasFeature) {
    559             return;
    560         }
    561         installAppPermissionAppAsUser();
    562         executeDeviceTestMethod(".PermissionsTest", "testPermissionPolicy");
    563     }
    564 
    565     public void testPermissionMixedPolicies() throws Exception {
    566         if (!mHasFeature) {
    567             return;
    568         }
    569         installAppPermissionAppAsUser();
    570         executeDeviceTestMethod(".PermissionsTest", "testPermissionMixedPolicies");
    571     }
    572 
    573     public void testPermissionGrantOfDisallowedPermissionWhileOtherPermIsGranted()
    574             throws Exception {
    575         if (!mHasFeature) {
    576             return;
    577         }
    578         installAppPermissionAppAsUser();
    579         executeDeviceTestMethod(".PermissionsTest",
    580                 "testPermissionGrantOfDisallowedPermissionWhileOtherPermIsGranted");
    581     }
    582 
    583     // Test flakey; suppressed.
    584 //    public void testPermissionPrompts() throws Exception {
    585 //        if (!mHasFeature) {
    586 //            return;
    587 //        }
    588 //        installAppPermissionAppAsUser();
    589 //        executeDeviceTestMethod(".PermissionsTest", "testPermissionPrompts");
    590 //    }
    591 
    592     public void testPermissionAppUpdate() throws Exception {
    593         if (!mHasFeature) {
    594             return;
    595         }
    596         installAppPermissionAppAsUser();
    597         executeDeviceTestMethod(".PermissionsTest", "testPermissionUpdate_setDeniedState");
    598         executeDeviceTestMethod(".PermissionsTest", "testPermissionUpdate_checkDenied");
    599         installAppPermissionAppAsUser();
    600         executeDeviceTestMethod(".PermissionsTest", "testPermissionUpdate_checkDenied");
    601 
    602         assertNull(getDevice().uninstallPackage(PERMISSIONS_APP_PKG));
    603         installAppPermissionAppAsUser();
    604         executeDeviceTestMethod(".PermissionsTest", "testPermissionUpdate_setGrantedState");
    605         executeDeviceTestMethod(".PermissionsTest", "testPermissionUpdate_checkGranted");
    606         installAppPermissionAppAsUser();
    607         executeDeviceTestMethod(".PermissionsTest", "testPermissionUpdate_checkGranted");
    608 
    609         assertNull(getDevice().uninstallPackage(PERMISSIONS_APP_PKG));
    610         installAppPermissionAppAsUser();
    611         executeDeviceTestMethod(".PermissionsTest", "testPermissionUpdate_setAutoDeniedPolicy");
    612         executeDeviceTestMethod(".PermissionsTest", "testPermissionUpdate_checkDenied");
    613         installAppPermissionAppAsUser();
    614         executeDeviceTestMethod(".PermissionsTest", "testPermissionUpdate_checkDenied");
    615 
    616         assertNull(getDevice().uninstallPackage(PERMISSIONS_APP_PKG));
    617         installAppPermissionAppAsUser();
    618         executeDeviceTestMethod(".PermissionsTest", "testPermissionUpdate_setAutoGrantedPolicy");
    619         executeDeviceTestMethod(".PermissionsTest", "testPermissionUpdate_checkGranted");
    620         installAppPermissionAppAsUser();
    621         executeDeviceTestMethod(".PermissionsTest", "testPermissionUpdate_checkGranted");
    622     }
    623 
    624     public void testPermissionGrantPreMApp() throws Exception {
    625         if (!mHasFeature) {
    626             return;
    627         }
    628         installAppAsUser(SIMPLE_PRE_M_APP_APK, mUserId);
    629         executeDeviceTestMethod(".PermissionsTest", "testPermissionGrantStatePreMApp");
    630     }
    631 
    632     public void testPersistentIntentResolving() throws Exception {
    633         if (!mHasFeature) {
    634             return;
    635         }
    636         executeDeviceTestClass(".PersistentIntentResolvingTest");
    637         assertMetricsLogged(getDevice(), () -> {
    638             executeDeviceTestMethod(".PersistentIntentResolvingTest",
    639                     "testAddPersistentPreferredActivityYieldsReceptionAtTarget");
    640         }, new DevicePolicyEventWrapper.Builder(EventId.ADD_PERSISTENT_PREFERRED_ACTIVITY_VALUE)
    641                     .setAdminPackageName(DEVICE_ADMIN_PKG)
    642                     .setStrings(DEVICE_ADMIN_PKG,
    643                             "com.android.cts.deviceandprofileowner.EXAMPLE_ACTION")
    644                     .build());
    645     }
    646 
    647     public void testScreenCaptureDisabled() throws Exception {
    648         if (!mHasFeature) {
    649             return;
    650         }
    651         assertMetricsLogged(getDevice(), () -> {
    652             // We need to ensure that the policy is deactivated for the device owner case, so making
    653             // sure the second test is run even if the first one fails
    654             try {
    655                 setScreenCaptureDisabled(mUserId, true);
    656             } finally {
    657                 setScreenCaptureDisabled(mUserId, false);
    658             }
    659         }, new DevicePolicyEventWrapper.Builder(EventId.SET_SCREEN_CAPTURE_DISABLED_VALUE)
    660                     .setAdminPackageName(DEVICE_ADMIN_PKG)
    661                     .setBoolean(true)
    662                     .build(),
    663             new DevicePolicyEventWrapper.Builder(EventId.SET_SCREEN_CAPTURE_DISABLED_VALUE)
    664                     .setAdminPackageName(DEVICE_ADMIN_PKG)
    665                     .setBoolean(false)
    666                     .build());
    667     }
    668 
    669     public void testScreenCaptureDisabled_assist() throws Exception {
    670         if (!mHasFeature) {
    671             return;
    672         }
    673         try {
    674             // Install and enable assistant, notice that profile can't have assistant.
    675             installAppAsUser(ASSIST_APP_APK, mPrimaryUserId);
    676             setVoiceInteractionService(ASSIST_INTERACTION_SERVICE);
    677             setScreenCaptureDisabled_assist(mUserId, true /* disabled */);
    678         } finally {
    679             setScreenCaptureDisabled_assist(mUserId, false /* disabled */);
    680             clearVoiceInteractionService();
    681         }
    682     }
    683 
    684     public void testSupportMessage() throws Exception {
    685         if (!mHasFeature) {
    686             return;
    687         }
    688         executeDeviceTestClass(".SupportMessageTest");
    689         assertMetricsLogged(getDevice(), () -> {
    690             executeDeviceTestMethod(
    691                     ".SupportMessageTest", "testShortSupportMessageSetGetAndClear");
    692         }, new DevicePolicyEventWrapper.Builder(EventId.SET_SHORT_SUPPORT_MESSAGE_VALUE)
    693                     .setAdminPackageName(DEVICE_ADMIN_PKG)
    694                     .build());
    695         assertMetricsLogged(getDevice(), () -> {
    696             executeDeviceTestMethod(".SupportMessageTest", "testLongSupportMessageSetGetAndClear");
    697         }, new DevicePolicyEventWrapper.Builder(EventId.SET_LONG_SUPPORT_MESSAGE_VALUE)
    698                     .setAdminPackageName(DEVICE_ADMIN_PKG)
    699                     .build());
    700     }
    701 
    702     public void testApplicationHidden() throws Exception {
    703         if (!mHasFeature) {
    704             return;
    705         }
    706         installAppPermissionAppAsUser();
    707         executeDeviceTestClass(".ApplicationHiddenTest");
    708         installAppAsUser(PERMISSIONS_APP_APK, mUserId);
    709         assertMetricsLogged(getDevice(), () -> {
    710             executeDeviceTestMethod(".ApplicationHiddenTest",
    711                     "testSetApplicationHidden");
    712         }, new DevicePolicyEventWrapper.Builder(EventId.SET_APPLICATION_HIDDEN_VALUE)
    713                     .setAdminPackageName(DEVICE_ADMIN_PKG)
    714                     .setBoolean(false)
    715                     .setStrings(PERMISSIONS_APP_PKG, "hidden")
    716                     .build(),
    717             new DevicePolicyEventWrapper.Builder(EventId.SET_APPLICATION_HIDDEN_VALUE)
    718                     .setAdminPackageName(DEVICE_ADMIN_PKG)
    719                     .setBoolean(false)
    720                     .setStrings(PERMISSIONS_APP_PKG, "not_hidden")
    721                     .build());
    722     }
    723 
    724     public void testAccountManagement_deviceAndProfileOwnerAlwaysAllowed() throws Exception {
    725         if (!mHasFeature) {
    726             return;
    727         }
    728 
    729         installAppAsUser(ACCOUNT_MANAGEMENT_APK, mUserId);
    730         executeDeviceTestClass(".AllowedAccountManagementTest");
    731     }
    732 
    733     public void testAccountManagement_userRestrictionAddAccount() throws Exception {
    734         if (!mHasFeature) {
    735             return;
    736         }
    737 
    738         installAppAsUser(ACCOUNT_MANAGEMENT_APK, mUserId);
    739         try {
    740             changeUserRestrictionOrFail(DISALLOW_MODIFY_ACCOUNTS, true, mUserId);
    741             executeAccountTest("testAddAccount_blocked");
    742         } finally {
    743             // Ensure we clear the user restriction
    744             changeUserRestrictionOrFail(DISALLOW_MODIFY_ACCOUNTS, false, mUserId);
    745         }
    746         executeAccountTest("testAddAccount_allowed");
    747     }
    748 
    749     public void testAccountManagement_userRestrictionRemoveAccount() throws Exception {
    750         if (!mHasFeature) {
    751             return;
    752         }
    753 
    754         installAppAsUser(ACCOUNT_MANAGEMENT_APK, mUserId);
    755         try {
    756             changeUserRestrictionOrFail(DISALLOW_MODIFY_ACCOUNTS, true, mUserId);
    757             executeAccountTest("testRemoveAccount_blocked");
    758         } finally {
    759             // Ensure we clear the user restriction
    760             changeUserRestrictionOrFail(DISALLOW_MODIFY_ACCOUNTS, false, mUserId);
    761         }
    762         executeAccountTest("testRemoveAccount_allowed");
    763     }
    764 
    765     public void testAccountManagement_disabledAddAccount() throws Exception {
    766         if (!mHasFeature) {
    767             return;
    768         }
    769 
    770         installAppAsUser(ACCOUNT_MANAGEMENT_APK, mUserId);
    771         try {
    772             changeAccountManagement(COMMAND_BLOCK_ACCOUNT_TYPE, ACCOUNT_TYPE, mUserId);
    773             executeAccountTest("testAddAccount_blocked");
    774         } finally {
    775             // Ensure we remove account management policies
    776             changeAccountManagement(COMMAND_UNBLOCK_ACCOUNT_TYPE, ACCOUNT_TYPE, mUserId);
    777         }
    778         executeAccountTest("testAddAccount_allowed");
    779     }
    780 
    781     public void testAccountManagement_disabledRemoveAccount() throws Exception {
    782         if (!mHasFeature) {
    783             return;
    784         }
    785 
    786         installAppAsUser(ACCOUNT_MANAGEMENT_APK, mUserId);
    787         try {
    788             changeAccountManagement(COMMAND_BLOCK_ACCOUNT_TYPE, ACCOUNT_TYPE, mUserId);
    789             executeAccountTest("testRemoveAccount_blocked");
    790         } finally {
    791             // Ensure we remove account management policies
    792             changeAccountManagement(COMMAND_UNBLOCK_ACCOUNT_TYPE, ACCOUNT_TYPE, mUserId);
    793         }
    794         executeAccountTest("testRemoveAccount_allowed");
    795     }
    796 
    797     public void testDelegatedCertInstaller() throws Exception {
    798         if (!mHasFeature) {
    799             return;
    800         }
    801 
    802         installAppAsUser(CERT_INSTALLER_APK, mUserId);
    803 
    804         boolean isManagedProfile = (mPrimaryUserId != mUserId);
    805 
    806 
    807         runDeviceTestsAsUser(DEVICE_ADMIN_PKG, ".DelegatedCertInstallerTest", mUserId);
    808         assertMetricsLogged(getDevice(), () -> {
    809                 runDeviceTestsAsUser(DEVICE_ADMIN_PKG, ".DelegatedCertInstallerTest",
    810                         "testInstallKeyPair", mUserId);
    811                 }, new DevicePolicyEventWrapper.Builder(EventId.SET_CERT_INSTALLER_PACKAGE_VALUE)
    812                 .setAdminPackageName(DEVICE_ADMIN_PKG)
    813                 .setStrings(CERT_INSTALLER_PKG)
    814                 .build());
    815     }
    816 
    817     public interface DelegatedCertInstallerTestAction {
    818         void run() throws Exception;
    819     }
    820 
    821     protected void setUpDelegatedCertInstallerAndRunTests(DelegatedCertInstallerTestAction test)
    822             throws Exception {
    823         installAppAsUser(CERT_INSTALLER_APK, mUserId);
    824 
    825         try {
    826             runDeviceTestsAsUser(DEVICE_ADMIN_PKG, ".DelegatedCertInstallerHelper",
    827                     "testManualSetCertInstallerDelegate", mUserId);
    828 
    829             test.run();
    830         } finally {
    831             runDeviceTestsAsUser(DEVICE_ADMIN_PKG, ".DelegatedCertInstallerHelper",
    832                     "testManualClearCertInstallerDelegate", mUserId);
    833         }
    834     }
    835 
    836     // This test currently duplicates the testDelegatedCertInstaller, with one difference:
    837     // The Delegated cert installer app is called directly rather than via intents from
    838     // the DelegatedCertinstallerTest.
    839     public void testDelegatedCertInstallerDirectly() throws Exception {
    840         if (!mHasFeature) {
    841             return;
    842         }
    843 
    844         setUpDelegatedCertInstallerAndRunTests(() ->
    845             runDeviceTestsAsUser("com.android.cts.certinstaller",
    846                     ".DirectDelegatedCertInstallerTest", mUserId));
    847     }
    848 
    849     // Sets restrictions and launches non-admin app, that tries to set wallpaper.
    850     // Non-admin apps must not violate any user restriction.
    851     public void testSetWallpaper_disallowed() throws Exception {
    852         // UserManager.DISALLOW_SET_WALLPAPER
    853         final String DISALLOW_SET_WALLPAPER = "no_set_wallpaper";
    854         if (!mHasFeature) {
    855             return;
    856         }
    857 
    858         installAppAsUser(CUSTOMIZATION_APP_APK, mUserId);
    859         try {
    860             changeUserRestrictionOrFail(DISALLOW_SET_WALLPAPER, true, mUserId);
    861             runDeviceTestsAsUser(CUSTOMIZATION_APP_PKG, ".CustomizationTest",
    862                 "testSetWallpaper_disallowed", mUserId);
    863         } finally {
    864             changeUserRestrictionOrFail(DISALLOW_SET_WALLPAPER, false, mUserId);
    865         }
    866     }
    867 
    868     // Runs test with admin privileges. The test methods set all the tested restrictions
    869     // inside. But these restrictions must have no effect on the device/profile owner behavior.
    870     public void testDisallowSetWallpaper_allowed() throws Exception {
    871         if (!mHasFeature) {
    872             return;
    873         }
    874         executeDeviceTestMethod(".CustomizationRestrictionsTest",
    875                 "testDisallowSetWallpaper_allowed");
    876     }
    877 
    878     public void testDisallowAutofill_allowed() throws Exception {
    879         if (!mHasFeature) {
    880             return;
    881         }
    882         boolean hasAutofill = hasDeviceFeature("android.software.autofill");
    883         if (!hasAutofill) {
    884           return;
    885         }
    886         installAppAsUser(AUTOFILL_APP_APK, mUserId);
    887 
    888         executeDeviceTestMethod(".AutofillRestrictionsTest",
    889                 "testDisallowAutofill_allowed");
    890     }
    891 
    892     public void testDisallowContentCapture_allowed() throws Exception {
    893         if (!mHasFeature) {
    894             return;
    895         }
    896 
    897         boolean hasContentCapture = hasService("content_capture");
    898         if (!hasContentCapture) {
    899             return;
    900         }
    901         installAppAsUser(CONTENT_CAPTURE_SERVICE_APK, mUserId);
    902         installAppAsUser(CONTENT_CAPTURE_APP_APK, mUserId);
    903 
    904         setDefaultContentCaptureServiceEnabled(false);
    905         try {
    906             executeDeviceTestMethod(".ContentCaptureRestrictionsTest",
    907                     "testDisallowContentCapture_allowed");
    908         } finally {
    909             setDefaultContentCaptureServiceEnabled(true);
    910         }
    911     }
    912 
    913     public void testDisallowContentSuggestions_allowed() throws Exception {
    914         if (!mHasFeature) {
    915             return;
    916         }
    917 
    918         boolean hasContentSuggestions = hasService("content_suggestions");
    919         if (!hasContentSuggestions) {
    920             return;
    921         }
    922         installAppAsUser(CONTENT_SUGGESTIONS_APP_APK, mUserId);
    923 
    924         setDefaultContentSuggestionsServiceEnabled(false);
    925         try {
    926             executeDeviceTestMethod(".ContentSuggestionsRestrictionsTest",
    927                     "testDisallowContentSuggestions_allowed");
    928         } finally {
    929             setDefaultContentSuggestionsServiceEnabled(true);
    930         }
    931     }
    932 
    933     private void setDefaultContentSuggestionsServiceEnabled(boolean enabled)
    934             throws DeviceNotAvailableException {
    935         CLog.d("setDefaultContentSuggestionsServiceEnabled(" + mUserId + "): " + enabled);
    936         getDevice().executeShellCommand(
    937                 "cmd content_suggestions set default-service-enabled " + mUserId + " " + enabled);
    938     }
    939 
    940     private void setDefaultContentCaptureServiceEnabled(boolean enabled)
    941             throws Exception {
    942         CLog.d("setDefaultServiceEnabled(" + mUserId + "): " + enabled);
    943         getDevice().executeShellCommand(
    944                 "cmd content_capture set default-service-enabled " + mUserId + " " + enabled);
    945     }
    946 
    947     public void testSetMeteredDataDisabledPackages() throws Exception {
    948         if (!mHasFeature) {
    949             return;
    950         }
    951         installAppAsUser(METERED_DATA_APP_APK, mUserId);
    952 
    953         executeDeviceTestClass(".MeteredDataRestrictionTest");
    954     }
    955 
    956     public void testPackageInstallUserRestrictions() throws Exception {
    957         if (!mHasFeature) {
    958             return;
    959         }
    960         boolean mIsWatch = hasDeviceFeature("android.hardware.type.watch");
    961         if (mIsWatch) {
    962             return;
    963         }
    964         // UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES
    965         final String DISALLOW_INSTALL_UNKNOWN_SOURCES = "no_install_unknown_sources";
    966         // UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES_GLOBALLY
    967         final String DISALLOW_INSTALL_UNKNOWN_SOURCES_GLOBALLY =
    968                 "no_install_unknown_sources_globally";
    969         final String PACKAGE_VERIFIER_USER_CONSENT_SETTING = "package_verifier_user_consent";
    970         final String PACKAGE_VERIFIER_ENABLE_SETTING = "package_verifier_enable";
    971         final String SECURE_SETTING_CATEGORY = "secure";
    972         final String GLOBAL_SETTING_CATEGORY = "global";
    973         final File apk = mBuildHelper.getTestFile(TEST_APP_APK);
    974         String packageVerifierEnableSetting = null;
    975         String packageVerifierUserConsentSetting = null;
    976         try {
    977             // Install the test and prepare the test apk.
    978             installAppAsUser(PACKAGE_INSTALLER_APK, mUserId);
    979             assertTrue(getDevice().pushFile(apk, TEST_APP_LOCATION + apk.getName()));
    980             setInstallPackageAppOps(PACKAGE_INSTALLER_PKG, true, mUserId);
    981 
    982             // Add restrictions and test if we can install the apk.
    983             getDevice().uninstallPackage(TEST_APP_PKG);
    984             changeUserRestrictionOrFail(DISALLOW_INSTALL_UNKNOWN_SOURCES, true, mUserId);
    985             runDeviceTestsAsUser(PACKAGE_INSTALLER_PKG, ".ManualPackageInstallTest",
    986                     "testManualInstallBlocked", mUserId);
    987 
    988             // Clear restrictions and test if we can install the apk.
    989             changeUserRestrictionOrFail(DISALLOW_INSTALL_UNKNOWN_SOURCES, false, mUserId);
    990 
    991             // Add global restriction and test if we can install the apk.
    992             getDevice().uninstallPackage(TEST_APP_PKG);
    993             changeUserRestrictionOrFail(DISALLOW_INSTALL_UNKNOWN_SOURCES_GLOBALLY, true, mUserId);
    994             runDeviceTestsAsUser(PACKAGE_INSTALLER_PKG, ".ManualPackageInstallTest",
    995                     "testManualInstallBlocked", mUserId);
    996 
    997             // Clear global restriction and test if we can install the apk.
    998             changeUserRestrictionOrFail(DISALLOW_INSTALL_UNKNOWN_SOURCES_GLOBALLY, false, mUserId);
    999 
   1000             // Disable verifier.
   1001             packageVerifierUserConsentSetting = getSettings(SECURE_SETTING_CATEGORY,
   1002                     PACKAGE_VERIFIER_USER_CONSENT_SETTING, mUserId);
   1003             packageVerifierEnableSetting = getSettings(GLOBAL_SETTING_CATEGORY,
   1004                     PACKAGE_VERIFIER_ENABLE_SETTING, mUserId);
   1005 
   1006             putSettings(SECURE_SETTING_CATEGORY, PACKAGE_VERIFIER_USER_CONSENT_SETTING, "-1",
   1007                     mUserId);
   1008             putSettings(GLOBAL_SETTING_CATEGORY, PACKAGE_VERIFIER_ENABLE_SETTING, "0", mUserId);
   1009             // Skip verifying above setting values as some of them may be overrided.
   1010             runDeviceTestsAsUser(PACKAGE_INSTALLER_PKG, ".ManualPackageInstallTest",
   1011                     "testManualInstallSucceeded", mUserId);
   1012         } finally {
   1013             setInstallPackageAppOps(PACKAGE_INSTALLER_PKG, false, mUserId);
   1014             String command = "rm " + TEST_APP_LOCATION + apk.getName();
   1015             getDevice().executeShellCommand(command);
   1016             getDevice().uninstallPackage(TEST_APP_PKG);
   1017             getDevice().uninstallPackage(PACKAGE_INSTALLER_PKG);
   1018             if (packageVerifierEnableSetting != null) {
   1019                 putSettings(GLOBAL_SETTING_CATEGORY, PACKAGE_VERIFIER_ENABLE_SETTING,
   1020                         packageVerifierEnableSetting, mUserId);
   1021             }
   1022             if (packageVerifierUserConsentSetting != null) {
   1023                 putSettings(SECURE_SETTING_CATEGORY, PACKAGE_VERIFIER_USER_CONSENT_SETTING,
   1024                         packageVerifierUserConsentSetting, mUserId);
   1025             }
   1026         }
   1027     }
   1028 
   1029     public void testAudioRestriction() throws Exception {
   1030         if (!mHasFeature) {
   1031             return;
   1032         }
   1033         // This package may need to toggle zen mode for this test, so allow it to do so.
   1034         allowNotificationPolicyAccess(DEVICE_ADMIN_PKG, mUserId);
   1035         try {
   1036             executeDeviceTestClass(".AudioRestrictionTest");
   1037         } finally {
   1038             disallowNotificationPolicyAccess(DEVICE_ADMIN_PKG, mUserId);
   1039         }
   1040     }
   1041 
   1042     public void testDisallowAdjustVolumeMutedLogged() throws Exception {
   1043         if (!mHasFeature) {
   1044             return;
   1045         }
   1046         assertMetricsLogged(getDevice(), () -> {
   1047             executeDeviceTestMethod(".DevicePolicyLoggingTest",
   1048                     "testDisallowAdjustVolumeMutedLogged");
   1049         }, new DevicePolicyEventWrapper.Builder(EventId.SET_MASTER_VOLUME_MUTED_VALUE)
   1050                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1051                     .setBoolean(true)
   1052                     .build(),
   1053             new DevicePolicyEventWrapper.Builder(EventId.SET_MASTER_VOLUME_MUTED_VALUE)
   1054                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1055                     .setBoolean(false)
   1056                     .build());
   1057     }
   1058 
   1059     public void testSuspendPackage() throws Exception {
   1060         if (!mHasFeature) {
   1061             return;
   1062         }
   1063         installAppAsUser(INTENT_SENDER_APK, mUserId);
   1064         installAppAsUser(INTENT_RECEIVER_APK, mUserId);
   1065         assertMetricsLogged(getDevice(), () -> {
   1066             // Suspend a testing package.
   1067             executeDeviceTestMethod(".SuspendPackageTest",
   1068                     "testSetPackagesSuspended");
   1069         }, new DevicePolicyEventWrapper.Builder(EventId.SET_PACKAGES_SUSPENDED_VALUE)
   1070                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1071                     .setStrings(INTENT_RECEIVER_PKG)
   1072                     .setBoolean(false)
   1073                     .build());
   1074         // Verify that the package is suspended from the PREVIOUS test and that the dialog is shown
   1075         executeSuspendPackageTestMethod("testPackageSuspended");
   1076 
   1077         // Undo the suspend.
   1078         executeDeviceTestMethod(".SuspendPackageTest", "testSetPackagesNotSuspended");
   1079         // Verify that the package is not suspended from the PREVIOUS test and that the app launches
   1080         executeSuspendPackageTestMethod("testPackageNotSuspended");
   1081 
   1082         // Verify we cannot suspend not suspendable packages.
   1083         executeDeviceTestMethod(".SuspendPackageTest", "testSuspendNotSuspendablePackages");
   1084     }
   1085 
   1086     public void testSuspendPackageWithPackageManager() throws Exception {
   1087         if (!mHasFeature) {
   1088             return;
   1089         }
   1090         installAppAsUser(INTENT_SENDER_APK, mUserId);
   1091         installAppAsUser(INTENT_RECEIVER_APK, mUserId);
   1092         // Suspend a testing package with the PackageManager
   1093         executeDeviceTestMethod(".SuspendPackageTest",
   1094                 "testSetPackagesSuspendedWithPackageManager");
   1095         // Verify that the package is suspended from the PREVIOUS test and that the dialog is shown
   1096         executeSuspendPackageTestMethod("testPackageSuspendedWithPackageManager");
   1097 
   1098         // Undo the suspend.
   1099         executeDeviceTestMethod(".SuspendPackageTest", "testSetPackagesNotSuspended");
   1100         // Verify that the package is not suspended from the PREVIOUS test and that the app launches
   1101         executeSuspendPackageTestMethod("testPackageNotSuspended");
   1102     }
   1103 
   1104     public void testTrustAgentInfo() throws Exception {
   1105         if (!mHasFeature || !mHasSecureLockScreen) {
   1106             return;
   1107         }
   1108         executeDeviceTestClass(".TrustAgentInfoTest");
   1109     }
   1110 
   1111     public void testCannotRemoveUserIfRestrictionSet() throws Exception {
   1112         // Outside of the primary user, setting DISALLOW_REMOVE_USER would not work.
   1113         if (!mHasFeature || !canCreateAdditionalUsers(1) || mUserId != getPrimaryUser()) {
   1114             return;
   1115         }
   1116         final int userId = createUser();
   1117         try {
   1118             changeUserRestrictionOrFail(DISALLOW_REMOVE_USER, true, mUserId);
   1119             assertFalse(getDevice().removeUser(userId));
   1120         } finally {
   1121             changeUserRestrictionOrFail(DISALLOW_REMOVE_USER, false, mUserId);
   1122             assertTrue(getDevice().removeUser(userId));
   1123         }
   1124     }
   1125 
   1126     public void testCannotEnableOrDisableDeviceOwnerOrProfileOwner() throws Exception {
   1127         if (!mHasFeature) {
   1128             return;
   1129         }
   1130         // Try to disable a component in device owner/ profile owner.
   1131         String result = disableComponentOrPackage(
   1132                 mUserId, DEVICE_ADMIN_PKG + "/.SetPolicyActivity");
   1133         assertTrue("Should throw SecurityException",
   1134                 result.contains("java.lang.SecurityException"));
   1135         // Try to disable the device owner/ profile owner package.
   1136         result = disableComponentOrPackage(mUserId, DEVICE_ADMIN_PKG);
   1137         assertTrue("Should throw SecurityException",
   1138                 result.contains("java.lang.SecurityException"));
   1139         // Try to enable a component in device owner/ profile owner.
   1140         result = enableComponentOrPackage(
   1141                 mUserId, DEVICE_ADMIN_PKG + "/.SetPolicyActivity");
   1142         assertTrue("Should throw SecurityException",
   1143                 result.contains("java.lang.SecurityException"));
   1144         // Try to enable the device owner/ profile owner package.
   1145         result = enableComponentOrPackage(mUserId, DEVICE_ADMIN_PKG);
   1146         assertTrue("Should throw SecurityException",
   1147                 result.contains("java.lang.SecurityException"));
   1148 
   1149     }
   1150 
   1151     public void testRequiredStrongAuthTimeout() throws Exception {
   1152         if (!mHasFeature || !mHasSecureLockScreen) {
   1153             return;
   1154         }
   1155         executeDeviceTestClass(".RequiredStrongAuthTimeoutTest");
   1156     }
   1157 
   1158     public void testCreateAdminSupportIntent() throws Exception {
   1159         if (!mHasFeature) {
   1160             return;
   1161         }
   1162         executeDeviceTestClass(".PolicyTransparencyTest");
   1163     }
   1164 
   1165     public void testSetCameraDisabledLogged() throws Exception {
   1166         if (!mHasFeature) {
   1167             return;
   1168         }
   1169         assertMetricsLogged(getDevice(), () -> {
   1170             executeDeviceTestMethod(".PolicyTransparencyTest", "testCameraDisabled");
   1171         }, new DevicePolicyEventWrapper.Builder(EventId.SET_CAMERA_DISABLED_VALUE)
   1172                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1173                     .setBoolean(true)
   1174                     .build(),
   1175             new DevicePolicyEventWrapper.Builder(EventId.SET_CAMERA_DISABLED_VALUE)
   1176                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1177                     .setBoolean(false)
   1178                     .build());
   1179     }
   1180 
   1181     public void testResetPasswordWithToken() throws Exception {
   1182         if (!mHasFeature || !mHasSecureLockScreen) {
   1183             return;
   1184         }
   1185         // If ResetPasswordWithTokenTest for managed profile is executed before device owner and
   1186         // primary user profile owner tests, password reset token would have been disabled for
   1187         // the primary user, so executing ResetPasswordWithTokenTest on user 0 would fail. We allow
   1188         // this and do not fail the test in this case.
   1189         // This is the default test for MixedDeviceOwnerTest and MixedProfileOwnerTest,
   1190         // MixedManagedProfileOwnerTest overrides this method to execute the same test more strictly
   1191         // without allowing failures.
   1192         executeResetPasswordWithTokenTests(true);
   1193     }
   1194 
   1195     public void testPasswordSufficientInitially() throws Exception {
   1196         if (!mHasFeature) {
   1197             return;
   1198         }
   1199         executeDeviceTestClass(".PasswordSufficientInitiallyTest");
   1200     }
   1201 
   1202     public void testGetCurrentFailedPasswordAttempts() throws Exception {
   1203         if (!mHasFeature || !mHasSecureLockScreen) {
   1204             return;
   1205         }
   1206         final String testPassword = "1234";
   1207         final String wrongPassword = "12345";
   1208 
   1209         changeUserCredential(testPassword, null /*oldCredential*/, mUserId);
   1210         try {
   1211             // Test that before trying an incorrect password there are 0 failed attempts.
   1212             executeDeviceTestMethod(".GetCurrentFailedPasswordAttemptsTest",
   1213                     "testNoFailedPasswordAttempts");
   1214             // Try an incorrect password.
   1215             assertFalse(verifyUserCredentialIsCorrect(wrongPassword, mUserId));
   1216             // Test that now there is one failed attempt.
   1217             executeDeviceTestMethod(".GetCurrentFailedPasswordAttemptsTest",
   1218                     "testOneFailedPasswordAttempt");
   1219             // Try an incorrect password.
   1220             assertFalse(verifyUserCredentialIsCorrect(wrongPassword, mUserId));
   1221             // Test that now there are two failed attempts.
   1222             executeDeviceTestMethod(".GetCurrentFailedPasswordAttemptsTest",
   1223                     "testTwoFailedPasswordAttempts");
   1224             // TODO: re-enable the test below when b/110945754 is fixed.
   1225             // Try the correct password and check the failed attempts number has been reset to 0.
   1226             // assertTrue(verifyUserCredentialIsCorrect(testPassword, mUserId));
   1227             // executeDeviceTestMethod(".GetCurrentFailedPasswordAttemptsTest",
   1228             //         "testNoFailedPasswordAttempts");
   1229         } finally {
   1230             changeUserCredential(null /*newCredential*/, testPassword, mUserId);
   1231         }
   1232     }
   1233 
   1234     public void testPasswordExpiration() throws Exception {
   1235         if (!mHasFeature || !mHasSecureLockScreen) {
   1236             return;
   1237         }
   1238         executeDeviceTestClass(".PasswordExpirationTest");
   1239     }
   1240 
   1241     public void testGetPasswordExpiration() throws Exception {
   1242         if (!mHasFeature || !mHasSecureLockScreen) {
   1243             return;
   1244         }
   1245         executeDeviceTestMethod(".GetPasswordExpirationTest",
   1246                 "testGetPasswordExpiration");
   1247         try {
   1248             executeDeviceTestMethod(".GetPasswordExpirationTest",
   1249                     "testGetPasswordExpirationUpdatedAfterPasswordReset_beforeReset");
   1250             // Wait for 20 seconds so we can make sure that the expiration date is refreshed later.
   1251             Thread.sleep(20000);
   1252             changeUserCredential("1234", null, mUserId);
   1253             executeDeviceTestMethod(".GetPasswordExpirationTest",
   1254                     "testGetPasswordExpirationUpdatedAfterPasswordReset_afterReset");
   1255         } finally {
   1256             changeUserCredential(null, "1234", mUserId);
   1257         }
   1258     }
   1259 
   1260     public void testPasswordQualityWithoutSecureLockScreen() throws Exception {
   1261         if (!mHasFeature || mHasSecureLockScreen) {
   1262             return;
   1263         }
   1264 
   1265         runDeviceTestsAsUser(DEVICE_ADMIN_PKG, ".UnavailableSecureLockScreenTest", mUserId);
   1266     }
   1267 
   1268     public void testSetSystemSetting() throws Exception {
   1269         if (!mHasFeature) {
   1270             return;
   1271         }
   1272         executeDeviceTestClass(".SetSystemSettingTest");
   1273     }
   1274 
   1275     protected void executeResetPasswordWithTokenTests(Boolean allowFailures) throws Exception {
   1276         runDeviceTestsAsUser(DEVICE_ADMIN_PKG, ".ResetPasswordWithTokenTest", null, mUserId,
   1277                 Collections.singletonMap(ARG_ALLOW_FAILURE, Boolean.toString(allowFailures)));
   1278     }
   1279 
   1280     public void testClearApplicationData_testPkg() throws Exception {
   1281         if (!mHasFeature) {
   1282             return;
   1283         }
   1284         installAppAsUser(INTENT_RECEIVER_APK, mUserId);
   1285         runDeviceTestsAsUser(INTENT_RECEIVER_PKG, INTENT_RECEIVER_PKG + ".ClearApplicationDataTest",
   1286                 "testWriteToSharedPreference", mUserId);
   1287         executeDeviceTestMethod(".ClearApplicationDataTest", "testClearApplicationData_testPkg");
   1288         runDeviceTestsAsUser(INTENT_RECEIVER_PKG, INTENT_RECEIVER_PKG + ".ClearApplicationDataTest",
   1289                 "testSharedPreferenceCleared", mUserId);
   1290     }
   1291 
   1292     public void testClearApplicationData_deviceProvisioning() throws Exception {
   1293         if (!mHasFeature) {
   1294             return;
   1295         }
   1296         // Clearing data of device configuration app should fail
   1297         executeDeviceTestMethod(".ClearApplicationDataTest",
   1298                 "testClearApplicationData_deviceProvisioning");
   1299     }
   1300 
   1301     public void testClearApplicationData_activeAdmin() throws Exception {
   1302         if (!mHasFeature) {
   1303             return;
   1304         }
   1305         // Clearing data of active admin should fail
   1306         executeDeviceTestMethod(".ClearApplicationDataTest",
   1307                 "testClearApplicationData_activeAdmin");
   1308     }
   1309 
   1310     public void testPrintingPolicy() throws Exception {
   1311         if (!mHasFeature) {
   1312             return;
   1313         }
   1314         installAppAsUser(PRINTING_APP_APK, mUserId);
   1315         executeDeviceTestClass(".PrintingPolicyTest");
   1316     }
   1317 
   1318     protected void executeDeviceTestClass(String className) throws Exception {
   1319         runDeviceTestsAsUser(DEVICE_ADMIN_PKG, className, mUserId);
   1320     }
   1321 
   1322     public void testKeyManagement() throws Exception {
   1323         if (!mHasFeature) {
   1324             return;
   1325         }
   1326 
   1327         executeDeviceTestClass(".KeyManagementTest");
   1328     }
   1329 
   1330     public void testInstallKeyPairLogged() throws Exception {
   1331         if (!mHasFeature) {
   1332             return;
   1333         }
   1334 
   1335         assertMetricsLogged(getDevice(), () -> {
   1336                 executeDeviceTestMethod(".KeyManagementTest", "testCanInstallCertChain");
   1337                 }, new DevicePolicyEventWrapper.Builder(EventId.INSTALL_KEY_PAIR_VALUE)
   1338                 .setAdminPackageName(DEVICE_ADMIN_PKG)
   1339                 .setBoolean(false)
   1340                 .build(),
   1341                 new DevicePolicyEventWrapper.Builder(EventId.REMOVE_KEY_PAIR_VALUE)
   1342                 .setAdminPackageName(DEVICE_ADMIN_PKG)
   1343                 .setBoolean(false)
   1344                 .build());
   1345     }
   1346 
   1347     public void testGenerateKeyPairLogged() throws Exception {
   1348         if (!mHasFeature) {
   1349             return;
   1350         }
   1351 
   1352         assertMetricsLogged(getDevice(), () -> {
   1353                 executeDeviceTestMethod(
   1354                         ".KeyManagementTest", "testCanGenerateKeyPairWithKeyAttestation");
   1355                 }, new DevicePolicyEventWrapper.Builder(EventId.GENERATE_KEY_PAIR_VALUE)
   1356                 .setAdminPackageName(DEVICE_ADMIN_PKG)
   1357                 .setBoolean(false)
   1358                 .setInt(0)
   1359                 .setStrings("RSA")
   1360                 .build(),
   1361                 new DevicePolicyEventWrapper.Builder(EventId.GENERATE_KEY_PAIR_VALUE)
   1362                 .setAdminPackageName(DEVICE_ADMIN_PKG)
   1363                 .setBoolean(false)
   1364                 .setInt(0)
   1365                 .setStrings("EC")
   1366                 .build());
   1367 
   1368     }
   1369 
   1370     public void testSetKeyPairCertificateLogged() throws Exception {
   1371         if (!mHasFeature) {
   1372             return;
   1373         }
   1374 
   1375         assertMetricsLogged(getDevice(), () -> {
   1376                 executeDeviceTestMethod(".KeyManagementTest", "testCanSetKeyPairCert");
   1377                 }, new DevicePolicyEventWrapper.Builder(EventId.SET_KEY_PAIR_CERTIFICATE_VALUE)
   1378                 .setAdminPackageName(DEVICE_ADMIN_PKG)
   1379                 .setBoolean(false)
   1380                 .build());
   1381     }
   1382 
   1383     public void testPermittedAccessibilityServices() throws Exception {
   1384         if (!mHasFeature) {
   1385             return;
   1386         }
   1387 
   1388         executeDeviceTestClass(".AccessibilityServicesTest");
   1389         assertMetricsLogged(getDevice(), () -> {
   1390             executeDeviceTestMethod(".AccessibilityServicesTest",
   1391                     "testPermittedAccessibilityServices");
   1392         }, new DevicePolicyEventWrapper
   1393                     .Builder(EventId.SET_PERMITTED_ACCESSIBILITY_SERVICES_VALUE)
   1394                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1395                     .setStrings((String[]) null)
   1396                     .build(),
   1397             new DevicePolicyEventWrapper
   1398                     .Builder(EventId.SET_PERMITTED_ACCESSIBILITY_SERVICES_VALUE)
   1399                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1400                     .setStrings((String[]) null)
   1401                     .build(),
   1402             new DevicePolicyEventWrapper
   1403                     .Builder(EventId.SET_PERMITTED_ACCESSIBILITY_SERVICES_VALUE)
   1404                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1405                     .setStrings("com.google.pkg.one", "com.google.pkg.two")
   1406                     .build());
   1407     }
   1408 
   1409     public void testPermittedInputMethods() throws Exception {
   1410         if (!mHasFeature) {
   1411             return;
   1412         }
   1413 
   1414         executeDeviceTestClass(".InputMethodsTest");
   1415         assertMetricsLogged(getDevice(), () -> {
   1416             executeDeviceTestMethod(".InputMethodsTest",
   1417                     "testPermittedInputMethods");
   1418         }, new DevicePolicyEventWrapper.Builder(EventId.SET_PERMITTED_INPUT_METHODS_VALUE)
   1419                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1420                     .setStrings((String[]) null)
   1421                     .build(),
   1422             new DevicePolicyEventWrapper.Builder(EventId.SET_PERMITTED_INPUT_METHODS_VALUE)
   1423                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1424                     .setStrings((String[]) null)
   1425                     .build(),
   1426             new DevicePolicyEventWrapper.Builder(EventId.SET_PERMITTED_INPUT_METHODS_VALUE)
   1427                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1428                     .setStrings("com.google.pkg.one", "com.google.pkg.two")
   1429                     .build());
   1430     }
   1431 
   1432     public void testSetStorageEncryption() throws Exception {
   1433         if (!mHasFeature) {
   1434             return;
   1435         }
   1436         Map<String, String> params =
   1437                 ImmutableMap.of(IS_PRIMARY_USER_PARAM, String.valueOf(mUserId == mPrimaryUserId));
   1438         runDeviceTestsAsUser(
   1439                 DEVICE_ADMIN_PKG, STORAGE_ENCRYPTION_TEST_CLASS, null, mUserId, params);
   1440     }
   1441 
   1442     public void testPasswordMethodsLogged() throws Exception {
   1443         if (!mHasFeature) {
   1444             return;
   1445         }
   1446 
   1447         assertMetricsLogged(getDevice(), () -> {
   1448             executeDeviceTestMethod(".DevicePolicyLoggingTest", "testPasswordMethodsLogged");
   1449         }, new DevicePolicyEventWrapper.Builder(EventId.SET_PASSWORD_QUALITY_VALUE)
   1450                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1451                     .setInt(PASSWORD_QUALITY_SOMETHING)
   1452                     .setBoolean(false)
   1453                     .build(),
   1454             new DevicePolicyEventWrapper.Builder(EventId.SET_PASSWORD_MINIMUM_LENGTH_VALUE)
   1455                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1456                     .setInt(13)
   1457                     .build(),
   1458             new DevicePolicyEventWrapper.Builder(EventId.SET_PASSWORD_MINIMUM_NUMERIC_VALUE)
   1459                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1460                     .setInt(14)
   1461                     .build(),
   1462             new DevicePolicyEventWrapper.Builder(EventId.SET_PASSWORD_MINIMUM_NON_LETTER_VALUE)
   1463                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1464                     .setInt(15)
   1465                     .build(),
   1466             new DevicePolicyEventWrapper.Builder(EventId.SET_PASSWORD_MINIMUM_LETTERS_VALUE)
   1467                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1468                     .setInt(16)
   1469                     .build(),
   1470             new DevicePolicyEventWrapper.Builder(EventId.SET_PASSWORD_MINIMUM_LOWER_CASE_VALUE)
   1471                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1472                     .setInt(17)
   1473                     .build(),
   1474             new DevicePolicyEventWrapper.Builder(EventId.SET_PASSWORD_MINIMUM_UPPER_CASE_VALUE)
   1475                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1476                     .setInt(18)
   1477                     .build(),
   1478             new DevicePolicyEventWrapper.Builder(EventId.SET_PASSWORD_MINIMUM_SYMBOLS_VALUE)
   1479                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1480                     .setInt(19)
   1481                     .build());
   1482     }
   1483 
   1484     public void testLockNowLogged() throws Exception {
   1485         if (!mHasFeature) {
   1486             return;
   1487         }
   1488         assertMetricsLogged(getDevice(), () -> {
   1489             executeDeviceTestMethod(".DevicePolicyLoggingTest", "testLockNowLogged");
   1490         }, new DevicePolicyEventWrapper.Builder(EventId.LOCK_NOW_VALUE)
   1491                 .setAdminPackageName(DEVICE_ADMIN_PKG)
   1492                 .setInt(0)
   1493                 .build());
   1494     }
   1495 
   1496     public void testSetKeyguardDisabledFeaturesLogged() throws Exception {
   1497         if (!mHasFeature) {
   1498             return;
   1499         }
   1500         assertMetricsLogged(getDevice(), () -> {
   1501             executeDeviceTestMethod(
   1502                     ".DevicePolicyLoggingTest", "testSetKeyguardDisabledFeaturesLogged");
   1503         }, new DevicePolicyEventWrapper.Builder(EventId.SET_KEYGUARD_DISABLED_FEATURES_VALUE)
   1504                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1505                     .setInt(KEYGUARD_DISABLE_FEATURES_NONE)
   1506                     .setBoolean(false)
   1507                     .build(),
   1508             new DevicePolicyEventWrapper.Builder(EventId.SET_KEYGUARD_DISABLED_FEATURES_VALUE)
   1509                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1510                     .setInt(KEYGUARD_DISABLE_FINGERPRINT)
   1511                     .setBoolean(false)
   1512                     .build(),
   1513             new DevicePolicyEventWrapper.Builder(EventId.SET_KEYGUARD_DISABLED_FEATURES_VALUE)
   1514                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1515                     .setInt(KEYGUARD_DISABLE_TRUST_AGENTS)
   1516                     .setBoolean(false)
   1517                     .build(),
   1518             new DevicePolicyEventWrapper.Builder(EventId.SET_KEYGUARD_DISABLED_FEATURES_VALUE)
   1519                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1520                     .setInt(KEYGUARD_DISABLE_FEATURES_NONE)
   1521                     .setBoolean(false)
   1522                     .build());
   1523     }
   1524 
   1525     public void testSetUserRestrictionLogged() throws Exception {
   1526         if (!mHasFeature) {
   1527             return;
   1528         }
   1529         assertMetricsLogged(getDevice(), () -> {
   1530             executeDeviceTestMethod(
   1531                     ".DevicePolicyLoggingTest", "testSetUserRestrictionLogged");
   1532         }, new DevicePolicyEventWrapper.Builder(EventId.ADD_USER_RESTRICTION_VALUE)
   1533                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1534                     .setStrings(DISALLOW_CONFIG_LOCATION)
   1535                     .build(),
   1536             new DevicePolicyEventWrapper.Builder(EventId.REMOVE_USER_RESTRICTION_VALUE)
   1537                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1538                     .setStrings(DISALLOW_CONFIG_LOCATION)
   1539                     .build(),
   1540             new DevicePolicyEventWrapper.Builder(EventId.ADD_USER_RESTRICTION_VALUE)
   1541                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1542                     .setStrings(DISALLOW_ADJUST_VOLUME)
   1543                     .build(),
   1544             new DevicePolicyEventWrapper.Builder(EventId.REMOVE_USER_RESTRICTION_VALUE)
   1545                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1546                     .setStrings(DISALLOW_ADJUST_VOLUME)
   1547                     .build(),
   1548             new DevicePolicyEventWrapper.Builder(EventId.ADD_USER_RESTRICTION_VALUE)
   1549                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1550                     .setStrings(DISALLOW_AUTOFILL)
   1551                     .build(),
   1552             new DevicePolicyEventWrapper.Builder(EventId.REMOVE_USER_RESTRICTION_VALUE)
   1553                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1554                     .setStrings(DISALLOW_AUTOFILL)
   1555                     .build()
   1556         );
   1557     }
   1558 
   1559     public void testSetSecureSettingLogged() throws Exception {
   1560         if (!mHasFeature) {
   1561             return;
   1562         }
   1563         assertMetricsLogged(getDevice(), () -> {
   1564             executeDeviceTestMethod(
   1565                     ".DevicePolicyLoggingTest", "testSetSecureSettingLogged");
   1566         }, new DevicePolicyEventWrapper.Builder(EventId.SET_SECURE_SETTING_VALUE)
   1567                 .setAdminPackageName(DEVICE_ADMIN_PKG)
   1568                 .setStrings(SKIP_FIRST_USE_HINTS, "1")
   1569                 .build(),
   1570             new DevicePolicyEventWrapper.Builder(EventId.SET_SECURE_SETTING_VALUE)
   1571                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1572                     .setStrings(SKIP_FIRST_USE_HINTS, "0")
   1573                     .build(),
   1574             new DevicePolicyEventWrapper.Builder(EventId.SET_SECURE_SETTING_VALUE)
   1575                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1576                     .setStrings(DEFAULT_INPUT_METHOD, "com.example.input")
   1577                     .build()
   1578                     ,
   1579             new DevicePolicyEventWrapper.Builder(EventId.SET_SECURE_SETTING_VALUE)
   1580                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1581                     .setStrings(DEFAULT_INPUT_METHOD)
   1582                     .build());
   1583     }
   1584 
   1585     public void testSetPermissionPolicyLogged() throws Exception {
   1586         if (!mHasFeature) {
   1587             return;
   1588         }
   1589         assertMetricsLogged(getDevice(), () -> {
   1590             executeDeviceTestMethod(
   1591                     ".DevicePolicyLoggingTest", "testSetPermissionPolicyLogged");
   1592         }, new DevicePolicyEventWrapper.Builder(EventId.SET_PERMISSION_POLICY_VALUE)
   1593                 .setAdminPackageName(DEVICE_ADMIN_PKG)
   1594                 .setInt(PERMISSION_POLICY_AUTO_DENY)
   1595                 .setBoolean(false)
   1596                 .build(),
   1597         new DevicePolicyEventWrapper.Builder(EventId.SET_PERMISSION_POLICY_VALUE)
   1598                 .setAdminPackageName(DEVICE_ADMIN_PKG)
   1599                 .setInt(PERMISSION_POLICY_AUTO_GRANT)
   1600                 .setBoolean(false)
   1601                 .build(),
   1602         new DevicePolicyEventWrapper.Builder(EventId.SET_PERMISSION_POLICY_VALUE)
   1603                 .setAdminPackageName(DEVICE_ADMIN_PKG)
   1604                 .setInt(PERMISSION_POLICY_PROMPT)
   1605                 .setBoolean(false)
   1606                 .build());
   1607     }
   1608 
   1609     public void testSetPermissionGrantStateLogged() throws Exception {
   1610         if (!mHasFeature) {
   1611             return;
   1612         }
   1613         installAppPermissionAppAsUser();
   1614         assertMetricsLogged(getDevice(), () -> {
   1615             executeDeviceTestMethod(
   1616                     ".DevicePolicyLoggingTest", "testSetPermissionGrantStateLogged");
   1617         }, new DevicePolicyEventWrapper.Builder(EventId.SET_PERMISSION_GRANT_STATE_VALUE)
   1618                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1619                     .setInt(PERMISSION_GRANT_STATE_GRANTED)
   1620                     .setBoolean(false)
   1621                     .setStrings("android.permission.READ_CONTACTS")
   1622                     .build(),
   1623             new DevicePolicyEventWrapper.Builder(EventId.SET_PERMISSION_GRANT_STATE_VALUE)
   1624                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1625                     .setInt(PERMISSION_GRANT_STATE_DENIED)
   1626                     .setBoolean(false)
   1627                     .setStrings("android.permission.READ_CONTACTS")
   1628                     .build(),
   1629             new DevicePolicyEventWrapper.Builder(EventId.SET_PERMISSION_GRANT_STATE_VALUE)
   1630                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1631                     .setInt(PERMISSION_GRANT_STATE_DEFAULT)
   1632                     .setBoolean(false)
   1633                     .setStrings("android.permission.READ_CONTACTS")
   1634                     .build());
   1635     }
   1636 
   1637     public void testSetAutoTimeRequired() throws Exception {
   1638         if (!mHasFeature) {
   1639             return;
   1640         }
   1641         assertMetricsLogged(getDevice(), () -> {
   1642             executeDeviceTestMethod(".DevicePolicyLoggingTest", "testSetAutoTimeRequired");
   1643         }, new DevicePolicyEventWrapper.Builder(EventId.SET_AUTO_TIME_REQUIRED_VALUE)
   1644                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1645                     .setBoolean(true)
   1646                     .build(),
   1647             new DevicePolicyEventWrapper.Builder(EventId.SET_AUTO_TIME_REQUIRED_VALUE)
   1648                     .setAdminPackageName(DEVICE_ADMIN_PKG)
   1649                     .setBoolean(false)
   1650                     .build());
   1651     }
   1652 
   1653     public void testEnableSystemAppLogged() throws Exception {
   1654         if (!mHasFeature) {
   1655             return;
   1656         }
   1657         final List<String> enabledSystemPackageNames = getEnabledSystemPackageNames();
   1658         // We enable an enabled package to not worry about restoring the state.
   1659         final String systemPackageToEnable = enabledSystemPackageNames.get(0);
   1660         final Map<String, String> params =
   1661                 ImmutableMap.of(PARAM_APP_TO_ENABLE, systemPackageToEnable);
   1662         assertMetricsLogged(getDevice(), () -> {
   1663             runDeviceTestsAsUser(DEVICE_ADMIN_PKG, ".DevicePolicyLoggingTest",
   1664                     "testEnableSystemAppLogged", mUserId, params);
   1665         }, new DevicePolicyEventWrapper.Builder(EventId.ENABLE_SYSTEM_APP_VALUE)
   1666                 .setAdminPackageName(DEVICE_ADMIN_PKG)
   1667                 .setBoolean(false)
   1668                 .setStrings(systemPackageToEnable)
   1669                 .build());
   1670     }
   1671 
   1672     public void testEnableSystemAppWithIntentLogged() throws Exception {
   1673         if (!mHasFeature) {
   1674             return;
   1675         }
   1676         final String systemPackageToEnable = getLaunchableSystemPackage();
   1677         if (systemPackageToEnable == null) {
   1678             return;
   1679         }
   1680         final Map<String, String> params =
   1681                 ImmutableMap.of(PARAM_APP_TO_ENABLE, systemPackageToEnable);
   1682         assertMetricsLogged(getDevice(), () -> {
   1683             runDeviceTestsAsUser(DEVICE_ADMIN_PKG, ".DevicePolicyLoggingTest",
   1684                     "testEnableSystemAppWithIntentLogged", mUserId, params);
   1685         }, new DevicePolicyEventWrapper.Builder(EventId.ENABLE_SYSTEM_APP_WITH_INTENT_VALUE)
   1686                 .setAdminPackageName(DEVICE_ADMIN_PKG)
   1687                 .setBoolean(false)
   1688                 .setStrings("android.intent.action.MAIN")
   1689                 .build());
   1690     }
   1691 
   1692     public void testSetUninstallBlockedLogged() throws Exception {
   1693         if (!mHasFeature) {
   1694             return;
   1695         }
   1696         installAppAsUser(PERMISSIONS_APP_APK, mUserId);
   1697         assertMetricsLogged(getDevice(), () -> {
   1698             executeDeviceTestMethod(".DevicePolicyLoggingTest",
   1699                     "testSetUninstallBlockedLogged");
   1700         }, new DevicePolicyEventWrapper.Builder(EventId.SET_UNINSTALL_BLOCKED_VALUE)
   1701                 .setAdminPackageName(DEVICE_ADMIN_PKG)
   1702                 .setBoolean(false)
   1703                 .setStrings(PERMISSIONS_APP_PKG)
   1704                 .build());
   1705     }
   1706 
   1707     public void testRandomizedWifiMacAddress() throws Exception {
   1708         if (!mHasFeature || !hasDeviceFeature("android.hardware.wifi")) {
   1709             return;
   1710         }
   1711         executeDeviceTestClass(".RandomizedWifiMacAddressTest");
   1712     }
   1713 
   1714     private String getLaunchableSystemPackage() throws DeviceNotAvailableException {
   1715         final List<String> enabledSystemPackageNames = getEnabledSystemPackageNames();
   1716         for (String enabledSystemPackage : enabledSystemPackageNames) {
   1717             final String result = getDevice().executeShellCommand(
   1718                     String.format(RESOLVE_ACTIVITY_CMD, enabledSystemPackage));
   1719             if (!result.contains("No activity found")) {
   1720                 return enabledSystemPackage;
   1721             }
   1722         }
   1723         return null;
   1724     }
   1725 
   1726     private List<String> getEnabledSystemPackageNames() throws DeviceNotAvailableException {
   1727         final String commandResult =
   1728                 getDevice().executeShellCommand("pm list packages -e -s --user " + mUserId);
   1729         final int prefixLength = "package:".length();
   1730         return new ArrayList<>(Arrays.asList(commandResult.split("\n")))
   1731                 .stream()
   1732                 .map(line -> line.substring(prefixLength))
   1733                 .collect(Collectors.toList());
   1734     }
   1735 
   1736     /**
   1737      * Executes a test class on device. Prior to running, turn off background data usage
   1738      * restrictions, and restore the original restrictions after the test.
   1739      */
   1740     private void executeDeviceTestClassNoRestrictBackground(String className) throws Exception {
   1741         boolean originalRestriction = ensureRestrictBackgroundPolicyOff();
   1742         try {
   1743             executeDeviceTestClass(className);
   1744         } catch (Exception e) {
   1745             throw e;
   1746         } finally {
   1747             // if the test throws exception, still restore the policy
   1748             restoreRestrictBackgroundPolicyTo(originalRestriction);
   1749         }
   1750     }
   1751 
   1752     protected void executeDeviceTestMethod(String className, String testName) throws Exception {
   1753         runDeviceTestsAsUser(DEVICE_ADMIN_PKG, className, testName, mUserId);
   1754     }
   1755 
   1756     private void installAppPermissionAppAsUser()
   1757             throws FileNotFoundException, DeviceNotAvailableException {
   1758         installAppAsUser(PERMISSIONS_APP_APK, false, mUserId);
   1759     }
   1760 
   1761     private void executeSuspendPackageTestMethod(String testName) throws Exception {
   1762         runDeviceTestsAsUser(INTENT_SENDER_PKG, ".SuspendPackageTest",
   1763                 testName, mUserId);
   1764     }
   1765 
   1766     private void executeAccountTest(String testName) throws DeviceNotAvailableException {
   1767         runDeviceTestsAsUser(ACCOUNT_MANAGEMENT_PKG, ".AccountManagementTest",
   1768                 testName, mUserId);
   1769         // Send a home intent to dismiss an error dialog.
   1770         String command = "am start -a android.intent.action.MAIN"
   1771                 + " -c android.intent.category.HOME";
   1772         CLog.i("Output for command " + command + ": " + getDevice().executeShellCommand(command));
   1773     }
   1774 
   1775     private void executeAppRestrictionsManagingPackageTest(String testName) throws Exception {
   1776         runDeviceTestsAsUser(DELEGATE_APP_PKG,
   1777                 ".AppRestrictionsDelegateTest", testName, mUserId);
   1778     }
   1779 
   1780     private void executeDelegationTests(Map<String, DevicePolicyEventWrapper[]> delegationTests,
   1781             boolean positive)
   1782             throws Exception {
   1783         for (Map.Entry<String, DevicePolicyEventWrapper[]> entry : delegationTests.entrySet()) {
   1784             final String delegationTestClass = entry.getKey();
   1785             final DevicePolicyEventWrapper[] expectedMetrics = entry.getValue();
   1786             final DevicePolicyEventLogVerifier.Action testRun = () -> {
   1787                 runDeviceTestsAsUser(DELEGATE_APP_PKG, delegationTestClass,
   1788                         positive ? "testCanAccessApis" : "testCannotAccessApis", mUserId);
   1789             };
   1790             if (expectedMetrics != null && positive) {
   1791                 assertMetricsLogged(getDevice(), testRun, expectedMetrics);
   1792             } else {
   1793                 testRun.apply();
   1794             }
   1795         }
   1796     }
   1797 
   1798     private void changeUserRestrictionOrFail(String key, boolean value, int userId)
   1799             throws DeviceNotAvailableException {
   1800         changeUserRestrictionOrFail(key, value, userId, DEVICE_ADMIN_PKG);
   1801     }
   1802 
   1803     private void changeAccountManagement(String command, String accountType, int userId)
   1804             throws DeviceNotAvailableException {
   1805         changePolicyOrFail(command, "--es extra-account-type " + accountType, userId);
   1806     }
   1807 
   1808     private void changeApplicationRestrictionsManagingPackage(String packageName)
   1809             throws DeviceNotAvailableException {
   1810         String packageNameExtra = (packageName != null)
   1811                 ? "--es extra-package-name " + packageName : "";
   1812         changePolicyOrFail("set-app-restrictions-manager", packageNameExtra, mUserId);
   1813     }
   1814 
   1815     protected void setDelegatedScopes(String packageName, List<String> scopes)
   1816             throws DeviceNotAvailableException {
   1817         final String packageNameExtra = "--es extra-package-name " + packageName;
   1818         String scopesExtra = "";
   1819         if (scopes != null && scopes.size() > 0) {
   1820             scopesExtra = "--esa extra-scopes-list " + scopes.get(0);
   1821             for (int i = 1; i < scopes.size(); ++i) {
   1822                 scopesExtra += "," + scopes.get(i);
   1823             }
   1824         }
   1825         final String extras = packageNameExtra + " " + scopesExtra;
   1826 
   1827         changePolicyOrFail("set-delegated-scopes", extras, mUserId);
   1828     }
   1829 
   1830     private void setInstallPackageAppOps(String packageName, boolean allowed, int userId)
   1831             throws DeviceNotAvailableException {
   1832         String command = "appops set --user " + userId + " " + packageName + " " +
   1833                 "REQUEST_INSTALL_PACKAGES "
   1834                 + (allowed ? "allow" : "default");
   1835         CLog.d("Output for command " + command + ": " + getDevice().executeShellCommand(command));
   1836     }
   1837 
   1838     private void changePolicyOrFail(String command, String extras, int userId)
   1839             throws DeviceNotAvailableException {
   1840         changePolicyOrFail(command, extras, userId, DEVICE_ADMIN_PKG);
   1841     }
   1842 
   1843     /**
   1844      * Start SimpleActivity synchronously in a particular user.
   1845      */
   1846     protected void startSimpleActivityAsUser(int userId) throws Exception {
   1847         installAppAsUser(TEST_APP_APK, userId);
   1848         startActivityAsUser(userId, TEST_APP_PKG, TEST_APP_PKG + ".SimpleActivity");
   1849     }
   1850 
   1851     protected void setScreenCaptureDisabled(int userId, boolean disabled) throws Exception {
   1852         String testMethodName = disabled
   1853                 ? "testSetScreenCaptureDisabled_true"
   1854                 : "testSetScreenCaptureDisabled_false";
   1855         executeDeviceTestMethod(".ScreenCaptureDisabledTest", testMethodName);
   1856 
   1857         testMethodName = disabled
   1858                 ? "testScreenCaptureImpossible"
   1859                 : "testScreenCapturePossible";
   1860 
   1861         if (userId == mPrimaryUserId) {
   1862             // If testing for user-0, also make sure the existing screen can't be captured.
   1863             executeDeviceTestMethod(".ScreenCaptureDisabledTest", testMethodName);
   1864         }
   1865 
   1866         startSimpleActivityAsUser(userId);
   1867         executeDeviceTestMethod(".ScreenCaptureDisabledTest", testMethodName);
   1868     }
   1869 
   1870     protected void setScreenCaptureDisabled_assist(int userId, boolean disabled) throws Exception {
   1871         // Set the policy.
   1872         String testMethodName = disabled
   1873                 ? "testSetScreenCaptureDisabled_true"
   1874                 : "testSetScreenCaptureDisabled_false";
   1875         executeDeviceTestMethod(".ScreenCaptureDisabledTest", testMethodName);
   1876         testMethodName = disabled
   1877                 ? "testScreenCaptureImpossible_assist"
   1878                 : "testScreenCapturePossible_assist";
   1879 
   1880         // Check whether the VoiceInteractionService can retrieve the screenshot.
   1881         installAppAsUser(DEVICE_ADMIN_APK, mPrimaryUserId);
   1882 
   1883         if (userId == mPrimaryUserId) {
   1884             // If testing for user-0, also make sure the existing screen can't be captured.
   1885             runDeviceTestsAsUser(
   1886                     DEVICE_ADMIN_PKG,
   1887                     ".AssistScreenCaptureDisabledTest",
   1888                     testMethodName,
   1889                     mPrimaryUserId);
   1890         }
   1891 
   1892         // Make sure the foreground activity is from the target user.
   1893         startSimpleActivityAsUser(userId);
   1894 
   1895         runDeviceTestsAsUser(
   1896                 DEVICE_ADMIN_PKG,
   1897                 ".AssistScreenCaptureDisabledTest",
   1898                 testMethodName,
   1899                 mPrimaryUserId);
   1900     }
   1901 
   1902     /**
   1903      * Allows packageName to manage notification policy configuration, which
   1904      * includes toggling zen mode.
   1905      */
   1906     private void allowNotificationPolicyAccess(String packageName, int userId)
   1907             throws DeviceNotAvailableException {
   1908         List<String> enabledPackages = getEnabledNotificationPolicyPackages(userId);
   1909         if (!enabledPackages.contains(packageName)) {
   1910             enabledPackages.add(packageName);
   1911             setEnabledNotificationPolicyPackages(enabledPackages, userId);
   1912         }
   1913     }
   1914 
   1915     /**
   1916      * Disallows packageName to manage notification policy configuration, which
   1917      * includes toggling zen mode.
   1918      */
   1919     private void disallowNotificationPolicyAccess(String packageName, int userId)
   1920             throws DeviceNotAvailableException {
   1921         List<String> enabledPackages = getEnabledNotificationPolicyPackages(userId);
   1922         if (enabledPackages.contains(packageName)) {
   1923             enabledPackages.remove(packageName);
   1924             setEnabledNotificationPolicyPackages(enabledPackages, userId);
   1925         }
   1926     }
   1927 
   1928     private void setEnabledNotificationPolicyPackages(List<String> packages, int userId)
   1929             throws DeviceNotAvailableException {
   1930         getDevice().setSetting(userId, "secure", ENABLED_NOTIFICATION_POLICY_ACCESS_PACKAGES,
   1931                 String.join(":", packages));
   1932     }
   1933 
   1934     private List<String> getEnabledNotificationPolicyPackages(int userId)
   1935             throws DeviceNotAvailableException {
   1936         String settingValue = getDevice().getSetting(userId, "secure",
   1937                 ENABLED_NOTIFICATION_POLICY_ACCESS_PACKAGES);
   1938         if (settingValue == null) {
   1939             return new ArrayList<String>();
   1940         }
   1941         return new ArrayList<String>(Arrays.asList(settingValue.split(":|\n")));
   1942     }
   1943 
   1944     protected void setVoiceInteractionService(String componentName)
   1945             throws DeviceNotAvailableException {
   1946         getDevice().setSetting(
   1947                 mPrimaryUserId, "secure", "voice_interaction_service", componentName);
   1948         getDevice().setSetting(mPrimaryUserId, "secure", "assist_structure_enabled", "1");
   1949         getDevice().setSetting(mPrimaryUserId, "secure", "assist_screenshot_enabled", "1");
   1950     }
   1951 
   1952     protected void clearVoiceInteractionService() throws DeviceNotAvailableException {
   1953         getDevice().executeShellCommand("settings delete secure voice_interaction_service");
   1954     }
   1955 
   1956     /**
   1957      * Ensure that restrict background policy is off.
   1958      * Returns the original status of restrict background policy.
   1959      */
   1960     private boolean ensureRestrictBackgroundPolicyOff() throws Exception {
   1961         String restriction = getDevice().executeShellCommand(RESTRICT_BACKGROUND_GET_CMD);
   1962         if (restriction.contains("enabled")) {
   1963             getDevice().executeShellCommand(RESTRICT_BACKGROUND_OFF_CMD);
   1964             return true;
   1965         }
   1966         return false;
   1967     }
   1968 
   1969     private void restoreRestrictBackgroundPolicyTo(boolean restricted) throws Exception {
   1970         getDevice().executeShellCommand(
   1971                 restricted ? RESTRICT_BACKGROUND_ON_CMD : RESTRICT_BACKGROUND_OFF_CMD);
   1972     }
   1973 
   1974     // TODO: copied from RequiredServiceRule, which is on compatibility-device-util
   1975     // (and we use compatibility-host-util)
   1976     public boolean hasService(String service) {
   1977         // TODO: ideally should call SystemServiceManager directly, but we would need to open
   1978         // some @Testing APIs for that.
   1979         String command = "service check " + service;
   1980         try {
   1981             String commandOutput = getDevice().executeShellCommand(command);
   1982             return !commandOutput.contains("not found");
   1983         } catch (Exception e) {
   1984             CLog.w("Exception running '" + command + "': " + e);
   1985             return false;
   1986         }
   1987     }
   1988 }
   1989