/* * Copyright (C) 2010 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package android.content.pm; import com.android.ddmlib.AdbCommandRejectedException; import com.android.ddmlib.InstallException; import com.android.ddmlib.Log; import com.android.ddmlib.ShellCommandUnresponsiveException; import com.android.ddmlib.SyncException; import com.android.ddmlib.TimeoutException; import com.android.hosttest.DeviceTestCase; import com.android.hosttest.DeviceTestSuite; import java.io.File; import java.io.IOException; import junit.framework.Test; /** * Set of tests that verify host side install cases */ public class PackageManagerHostTests extends DeviceTestCase { private static final String LOG_TAG = "PackageManagerHostTests"; private PackageManagerHostTestUtils mPMHostUtils = null; private String appPrivatePath = null; private String deviceAppPath = null; private String sdcardAppPath = null; // Various test files and their corresponding package names... // testPushAppPrivate constants // these constants must match values defined in test-apps/SimpleTestApp private static final String SIMPLE_APK = "SimpleTestApp.apk"; private static final String SIMPLE_PKG = "com.android.framework.simpletestapp"; // Apk with install location set to auto private static final String AUTO_LOC_APK = "AutoLocTestApp.apk"; private static final String AUTO_LOC_PKG = "com.android.framework.autoloctestapp"; // Apk with install location set to internalOnly private static final String INTERNAL_LOC_APK = "InternalLocTestApp.apk"; private static final String INTERNAL_LOC_PKG = "com.android.framework.internalloctestapp"; // Apk with install location set to preferExternal private static final String EXTERNAL_LOC_APK = "ExternalLocTestApp.apk"; private static final String EXTERNAL_LOC_PKG = "com.android.framework.externalloctestapp"; // Apk with install location set to auto (2 versions, for update testing) private static final String AUTO_LOC_VERSION_V1_APK = "AutoLocVersionedTestApp_v1.apk"; private static final String AUTO_LOC_VERSION_V2_APK = "AutoLocVersionedTestApp_v2.apk"; private static final String AUTO_LOC_VERSION_PKG = "com.android.framework.autolocversionedtestapp"; // Apk with install location set to preferExternal (2 versions, for update testing) private static final String EXTERNAL_LOC_VERSION_V1_APK = "ExternalLocVersionedTestApp_v1.apk"; private static final String EXTERNAL_LOC_VERSION_V2_APK = "ExternalLocVersionedTestApp_v2.apk"; private static final String EXTERNAL_LOC_VERSION_PKG = "com.android.framework.externallocversionedtestapp"; // Apk with install location set to auto (2 versions, for update testing) private static final String NO_LOC_VERSION_V1_APK = "NoLocVersionedTestApp_v1.apk"; private static final String NO_LOC_VERSION_V2_APK = "NoLocVersionedTestApp_v2.apk"; private static final String NO_LOC_VERSION_PKG = "com.android.framework.nolocversionedtestapp"; // Apk with no install location set private static final String NO_LOC_APK = "NoLocTestApp.apk"; private static final String NO_LOC_PKG = "com.android.framework.noloctestapp"; // Apk with 2 different versions - v1 is set to external, v2 has no location setting private static final String UPDATE_EXTERNAL_LOC_V1_EXT_APK = "UpdateExternalLocTestApp_v1_ext.apk"; private static final String UPDATE_EXTERNAL_LOC_V2_NONE_APK = "UpdateExternalLocTestApp_v2_none.apk"; private static final String UPDATE_EXTERNAL_LOC_PKG = "com.android.framework.updateexternalloctestapp"; // Apk with 2 different versions - v1 is set to external, v2 is set to internalOnly private static final String UPDATE_EXT_TO_INT_LOC_V1_EXT_APK = "UpdateExtToIntLocTestApp_v1_ext.apk"; private static final String UPDATE_EXT_TO_INT_LOC_V2_INT_APK = "UpdateExtToIntLocTestApp_v2_int.apk"; private static final String UPDATE_EXT_TO_INT_LOC_PKG = "com.android.framework.updateexttointloctestapp"; // Apk set to preferExternal, with Access Fine Location permissions set in its manifest private static final String FL_PERMS_APK = "ExternalLocPermsFLTestApp.apk"; private static final String FL_PERMS_PKG = "com.android.framework.externallocpermsfltestapp"; // Apk set to preferExternal, with all permissions set in manifest private static final String ALL_PERMS_APK = "ExternalLocAllPermsTestApp.apk"; private static final String ALL_PERMS_PKG = "com.android.framework.externallocallpermstestapp"; // Apks with the same package name, but install location set to // one of: Internal, External, Auto, or None private static final String VERSATILE_LOC_PKG = "com.android.framework.versatiletestapp"; private static final String VERSATILE_LOC_INTERNAL_APK = "VersatileTestApp_Internal.apk"; private static final String VERSATILE_LOC_EXTERNAL_APK = "VersatileTestApp_External.apk"; private static final String VERSATILE_LOC_AUTO_APK = "VersatileTestApp_Auto.apk"; private static final String VERSATILE_LOC_NONE_APK = "VersatileTestApp_None.apk"; // Apks with shared UserID private static final String SHARED_PERMS_APK = "ExternalSharedPermsTestApp.apk"; private static final String SHARED_PERMS_PKG = "com.android.framework.externalsharedpermstestapp"; private static final String SHARED_PERMS_FL_APK = "ExternalSharedPermsFLTestApp.apk"; private static final String SHARED_PERMS_FL_PKG = "com.android.framework.externalsharedpermsfltestapp"; private static final String SHARED_PERMS_BT_APK = "ExternalSharedPermsBTTestApp.apk"; private static final String SHARED_PERMS_BT_PKG = "com.android.framework.externalsharedpermsbttestapp"; // Apk with shared UserID, but signed with a different cert (the media cert) private static final String SHARED_PERMS_DIFF_KEY_APK = "ExternalSharedPermsDiffKeyTestApp.apk"; private static final String SHARED_PERMS_DIFF_KEY_PKG = "com.android.framework.externalsharedpermsdiffkeytestapp"; @Override protected void setUp() throws Exception { super.setUp(); // ensure apk path has been set before test is run assertNotNull(getTestAppPath()); // setup the PackageManager host tests utilities class, and get various paths we'll need... mPMHostUtils = new PackageManagerHostTestUtils(getDevice()); appPrivatePath = mPMHostUtils.getAppPrivatePath(); deviceAppPath = mPMHostUtils.getDeviceAppPath(); sdcardAppPath = mPMHostUtils.getSDCardAppPath(); // Ensure the default is set to let the system decide where to install apps // (It's ok for individual tests to override and change this during their test, but should // reset it back when they're done) mPMHostUtils.setDevicePreferredInstallLocation( PackageManagerHostTestUtils.InstallLocPreference.AUTO); } /** * Get the absolute file system location of test app with given filename * @param fileName the file name of the test app apk * @return {@link String} of absolute file path */ public String getTestAppFilePath(String fileName) { return String.format("%s%s%s", getTestAppPath(), File.separator, fileName); } public static Test suite() { return new DeviceTestSuite(PackageManagerHostTests.class); } /** * Regression test to verify that pushing an apk to the private app directory doesn't install * the app, and otherwise cause the system to blow up. *
* Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws SyncException if the sync failed for another reason. * @throws InstallException if the install failed. */ public void testPushAppPrivate() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException, SyncException { Log.i(LOG_TAG, "testing pushing an apk to /data/app-private"); final String apkAppPrivatePath = appPrivatePath + SIMPLE_APK; // cleanup test app just in case it was accidently installed getDevice().uninstallPackage(SIMPLE_PKG); mPMHostUtils.executeShellCommand("stop"); mPMHostUtils.pushFile(getTestAppFilePath(SIMPLE_APK), apkAppPrivatePath); // sanity check to make sure file is there assertTrue(mPMHostUtils.doesRemoteFileExist(apkAppPrivatePath)); mPMHostUtils.executeShellCommand("start"); mPMHostUtils.waitForPackageManager(); // grep for package to make sure its not installed assertFalse(mPMHostUtils.doesPackageExist(SIMPLE_PKG)); // ensure it has been deleted from app-private assertFalse(mPMHostUtils.doesRemoteFileExist(apkAppPrivatePath)); } /** * Helper to do a standard install of an apk and verify it installed to the correct location. * * Assumes adb is running as root in device under test. * @param apkName the file name of the test app apk * @param pkgName the package name of the test app apk * @param expectedLocation the file name of the test app apk * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ private void doStandardInstall(String apkName, String pkgName, PackageManagerHostTestUtils.InstallLocation expectedLocation) throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { if (expectedLocation == PackageManagerHostTestUtils.InstallLocation.DEVICE) { mPMHostUtils.installAppAndVerifyExistsOnDevice( getTestAppFilePath(apkName), pkgName, false); } else { mPMHostUtils.installAppAndVerifyExistsOnSDCard( getTestAppFilePath(apkName), pkgName, false); } } /** * Installs the Auto app using the preferred device install location specified, * and verifies it was installed on the device. * * Assumes adb is running as root in device under test. * @param preference the device's preferred location of where to install apps * @param expectedLocation the expected location of where the apk was installed * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void installAppAutoLoc(PackageManagerHostTestUtils.InstallLocPreference preference, PackageManagerHostTestUtils.InstallLocation expectedLocation) throws IOException, InterruptedException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException, InstallException { PackageManagerHostTestUtils.InstallLocPreference savedPref = PackageManagerHostTestUtils.InstallLocPreference.AUTO; try { savedPref = mPMHostUtils.getDevicePreferredInstallLocation(); mPMHostUtils.setDevicePreferredInstallLocation(preference); doStandardInstall(AUTO_LOC_APK, AUTO_LOC_PKG, expectedLocation); } // cleanup test app finally { mPMHostUtils.setDevicePreferredInstallLocation(savedPref); mPMHostUtils.uninstallApp(AUTO_LOC_PKG); } } /** * Regression test to verify that an app with its manifest set to installLocation=auto * will install the app to the device when device's preference is auto. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testInstallAppAutoLocPrefIsAuto() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test installLocation=auto, prefer=auto gets installed on device"); installAppAutoLoc(PackageManagerHostTestUtils.InstallLocPreference.AUTO, PackageManagerHostTestUtils.InstallLocation.DEVICE); } /** * Regression test to verify that an app with its manifest set to installLocation=auto * will install the app to the device when device's preference is internal. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testInstallAppAutoLocPrefIsInternal() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test installLocation=auto, prefer=internal gets installed on device"); installAppAutoLoc(PackageManagerHostTestUtils.InstallLocPreference.INTERNAL, PackageManagerHostTestUtils.InstallLocation.DEVICE); } /** * Regression test to verify that an app with its manifest set to installLocation=auto * will install the app to the SD card when device's preference is external. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testInstallAppAutoLocPrefIsExternal() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test installLocation=auto, prefer=external gets installed on device"); installAppAutoLoc(PackageManagerHostTestUtils.InstallLocPreference.EXTERNAL, PackageManagerHostTestUtils.InstallLocation.DEVICE); } /** * Installs the Internal app using the preferred device install location specified, * and verifies it was installed to the location expected. * * Assumes adb is running as root in device under test. * @param preference the device's preferred location of where to install apps * @param expectedLocation the expected location of where the apk was installed * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the (un)install failed. */ public void installAppInternalLoc(PackageManagerHostTestUtils.InstallLocPreference preference, PackageManagerHostTestUtils.InstallLocation expectedLocation) throws IOException, InterruptedException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException, InstallException { PackageManagerHostTestUtils.InstallLocPreference savedPref = PackageManagerHostTestUtils.InstallLocPreference.AUTO; try { savedPref = mPMHostUtils.getDevicePreferredInstallLocation(); mPMHostUtils.setDevicePreferredInstallLocation(preference); doStandardInstall(INTERNAL_LOC_APK, INTERNAL_LOC_PKG, expectedLocation); } // cleanup test app finally { mPMHostUtils.setDevicePreferredInstallLocation(savedPref); mPMHostUtils.uninstallApp(INTERNAL_LOC_PKG); } } /** * Regression test to verify that an app with its manifest set to installLocation=internalOnly * will install the app to the device when device's preference is auto. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testInstallAppInternalLocPrefIsAuto() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test installLocation=internal, prefer=auto gets installed on device"); installAppInternalLoc(PackageManagerHostTestUtils.InstallLocPreference.AUTO, PackageManagerHostTestUtils.InstallLocation.DEVICE); } /** * Regression test to verify that an app with its manifest set to installLocation=internalOnly * will install the app to the device when device's preference is internal. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testInstallAppInternalLocPrefIsInternal() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test installLocation=internal, prefer=internal is installed on device"); installAppInternalLoc(PackageManagerHostTestUtils.InstallLocPreference.INTERNAL, PackageManagerHostTestUtils.InstallLocation.DEVICE); } /** * Regression test to verify that an app with its manifest set to installLocation=internalOnly * will install the app to the device when device's preference is external. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testInstallAppInternalLocPrefIsExternal() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test installLocation=internal, prefer=external is installed on device"); installAppInternalLoc(PackageManagerHostTestUtils.InstallLocPreference.EXTERNAL, PackageManagerHostTestUtils.InstallLocation.DEVICE); } /** * Regression test to verify that an app with its manifest set to installLocation=preferExternal * will install the app to the SD card. * * Assumes adb is running as root in device under test. * @param preference the device's preferred location of where to install apps * @param expectedLocation the expected location of where the apk was installed * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void installAppExternalLoc(PackageManagerHostTestUtils.InstallLocPreference preference, PackageManagerHostTestUtils.InstallLocation expectedLocation) throws IOException, InterruptedException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException, InstallException { PackageManagerHostTestUtils.InstallLocPreference savedPref = PackageManagerHostTestUtils.InstallLocPreference.AUTO; try { savedPref = mPMHostUtils.getDevicePreferredInstallLocation(); mPMHostUtils.setDevicePreferredInstallLocation(preference); doStandardInstall(EXTERNAL_LOC_APK, EXTERNAL_LOC_PKG, expectedLocation); } // cleanup test app finally { mPMHostUtils.setDevicePreferredInstallLocation(savedPref); mPMHostUtils.uninstallApp(EXTERNAL_LOC_PKG); } } /** * Regression test to verify that an app with its manifest set to installLocation=preferExternal * will install the app to the device when device's preference is auto. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testInstallAppExternalLocPrefIsAuto() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test installLocation=external, pref=auto gets installed on SD Card"); installAppExternalLoc(PackageManagerHostTestUtils.InstallLocPreference.AUTO, PackageManagerHostTestUtils.InstallLocation.SDCARD); } /** * Regression test to verify that an app with its manifest set to installLocation=preferExternal * will install the app to the device when device's preference is internal. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testInstallAppExternalLocPrefIsInternal() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test installLocation=external, pref=internal gets installed on SD Card"); installAppExternalLoc(PackageManagerHostTestUtils.InstallLocPreference.INTERNAL, PackageManagerHostTestUtils.InstallLocation.SDCARD); } /** * Regression test to verify that an app with its manifest set to installLocation=preferExternal * will install the app to the device when device's preference is external. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testInstallAppExternalLocPrefIsExternal() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test installLocation=external, pref=external gets installed on SD Card"); installAppExternalLoc(PackageManagerHostTestUtils.InstallLocPreference.EXTERNAL, PackageManagerHostTestUtils.InstallLocation.SDCARD); } /** * Regression test to verify that an app without installLocation in its manifest * will install the app to the device by default when the system default pref is to let the * system decide. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testInstallAppNoLocPrefIsAuto() throws IOException, InterruptedException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException, InstallException { Log.i(LOG_TAG, "Test an app with no installLocation gets installed on device"); PackageManagerHostTestUtils.InstallLocPreference savedPref = PackageManagerHostTestUtils.InstallLocPreference.AUTO; try { savedPref = mPMHostUtils.getDevicePreferredInstallLocation(); mPMHostUtils.setDevicePreferredInstallLocation( PackageManagerHostTestUtils.InstallLocPreference.AUTO); mPMHostUtils.installAppAndVerifyExistsOnDevice( getTestAppFilePath(NO_LOC_APK), NO_LOC_PKG, false); } // cleanup test app finally { mPMHostUtils.setDevicePreferredInstallLocation(savedPref); mPMHostUtils.uninstallApp(NO_LOC_PKG); } } /** * Regression test to verify that an app without installLocation in its manifest * will install the app to the device by default when the system default pref is to install * external. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testInstallAppNoLocPrefIsExternal() throws IOException, InterruptedException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException, InstallException { Log.i(LOG_TAG, "Test an app with no installLocation gets installed on SD card"); PackageManagerHostTestUtils.InstallLocPreference savedPref = PackageManagerHostTestUtils.InstallLocPreference.AUTO; try { savedPref = mPMHostUtils.getDevicePreferredInstallLocation(); mPMHostUtils.setDevicePreferredInstallLocation( PackageManagerHostTestUtils.InstallLocPreference.EXTERNAL); mPMHostUtils.installAppAndVerifyExistsOnSDCard( getTestAppFilePath(NO_LOC_APK), NO_LOC_PKG, false); } // cleanup test app finally { mPMHostUtils.setDevicePreferredInstallLocation(savedPref); mPMHostUtils.uninstallApp(NO_LOC_PKG); } } /** * Regression test to verify that an app without installLocation in its manifest * will install the app to the device by default when the system default pref is to install * internal. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testInstallAppNoLocPrefIsInternal() throws IOException, InterruptedException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException, InstallException { Log.i(LOG_TAG, "Test an app with no installLocation gets installed on device"); PackageManagerHostTestUtils.InstallLocPreference savedPref = PackageManagerHostTestUtils.InstallLocPreference.AUTO; try { savedPref = mPMHostUtils.getDevicePreferredInstallLocation(); mPMHostUtils.setDevicePreferredInstallLocation( PackageManagerHostTestUtils.InstallLocPreference.INTERNAL); mPMHostUtils.installAppAndVerifyExistsOnDevice( getTestAppFilePath(NO_LOC_APK), NO_LOC_PKG, false); } // cleanup test app finally { mPMHostUtils.setDevicePreferredInstallLocation(savedPref); mPMHostUtils.uninstallApp(NO_LOC_PKG); } } /** * Regression test to verify that an app with its installLocation set to internal that is * forward-locked will get installed to the correct location. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws SyncException if the sync failed for another reason. * @throws InstallException if the install failed. */ public void testInstallFwdLockedAppInternal() throws IOException, InterruptedException, InstallException, SyncException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test an app with installLoc set to Internal gets installed to app-private"); try { mPMHostUtils.installFwdLockedAppAndVerifyExists( getTestAppFilePath(INTERNAL_LOC_APK), INTERNAL_LOC_PKG, false); } // cleanup test app finally { mPMHostUtils.uninstallApp(INTERNAL_LOC_PKG); } } /** * Regression test to verify that an app with its installLocation set to external that is * forward-locked will get installed to the correct location. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws SyncException if the sync failed for another reason. * @throws InstallException if the install failed. */ public void testInstallFwdLockedAppExternal() throws IOException, InterruptedException, InstallException, SyncException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test an app with installLoc set to Internal gets installed to app-private"); try { mPMHostUtils.installFwdLockedAppAndVerifyExists( getTestAppFilePath(INTERNAL_LOC_APK), INTERNAL_LOC_PKG, false); } // cleanup test app finally { mPMHostUtils.uninstallApp(INTERNAL_LOC_PKG); } } /** * Regression test to verify that an app with its installLocation set to external that is * forward-locked will get installed to the correct location. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws SyncException if the sync failed for another reason. * @throws InstallException if the install failed. */ public void testInstallFwdLockedAppAuto() throws IOException, InterruptedException, InstallException, SyncException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test an app with installLoc set to Auto gets installed to app-private"); try { mPMHostUtils.installFwdLockedAppAndVerifyExists( getTestAppFilePath(AUTO_LOC_APK), AUTO_LOC_PKG, false); } // cleanup test app finally { mPMHostUtils.uninstallApp(AUTO_LOC_PKG); } } /** * Regression test to verify that an app with no installLocation set and is * forward-locked installed will get installed to the correct location. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws SyncException if the sync failed for another reason. * @throws InstallException if the install failed. */ public void testInstallFwdLockedAppNone() throws IOException, InterruptedException, InstallException, SyncException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test an app with no installLoc set gets installed to app-private"); try { mPMHostUtils.installFwdLockedAppAndVerifyExists( getTestAppFilePath(NO_LOC_APK), NO_LOC_PKG, false); } // cleanup test app finally { mPMHostUtils.uninstallApp(NO_LOC_PKG); } } /** * Regression test to verify that we can install an app onto the device, * uninstall it, and reinstall it onto the SD card. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ // TODO: This currently relies on the app's manifest to switch from device to // SD card install locations. We might want to make Device's installPackage() // accept a installLocation flag so we can install a package to the // destination of our choosing. public void testReinstallInternalToExternal() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test installing an app first to the device, then to the SD Card"); try { mPMHostUtils.installAppAndVerifyExistsOnDevice( getTestAppFilePath(VERSATILE_LOC_INTERNAL_APK), VERSATILE_LOC_PKG, false); mPMHostUtils.uninstallApp(VERSATILE_LOC_PKG); mPMHostUtils.installAppAndVerifyExistsOnSDCard( getTestAppFilePath(VERSATILE_LOC_EXTERNAL_APK), VERSATILE_LOC_PKG, false); } // cleanup test app finally { mPMHostUtils.uninstallApp(VERSATILE_LOC_PKG); } } /** * Regression test to verify that we can install an app onto the SD Card, * uninstall it, and reinstall it onto the device. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ // TODO: This currently relies on the app's manifest to switch from device to // SD card install locations. We might want to make Device's installPackage() // accept a installLocation flag so we can install a package to the // destination of our choosing. public void testReinstallExternalToInternal() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test installing an app first to the SD Care, then to the device"); try { // install the app externally mPMHostUtils.installAppAndVerifyExistsOnSDCard( getTestAppFilePath(VERSATILE_LOC_EXTERNAL_APK), VERSATILE_LOC_PKG, false); mPMHostUtils.uninstallApp(VERSATILE_LOC_PKG); // then replace the app with one marked for internalOnly mPMHostUtils.installAppAndVerifyExistsOnDevice( getTestAppFilePath(VERSATILE_LOC_INTERNAL_APK), VERSATILE_LOC_PKG, false); } // cleanup test app finally { mPMHostUtils.uninstallApp(VERSATILE_LOC_PKG); } } /** * Regression test to verify that updating an app on the SD card will install * the update onto the SD card as well when location is set to external for both versions * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testUpdateBothExternal() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test updating an app on the SD card stays on the SD card"); try { // install the app externally mPMHostUtils.installAppAndVerifyExistsOnSDCard(getTestAppFilePath( EXTERNAL_LOC_VERSION_V1_APK), EXTERNAL_LOC_VERSION_PKG, false); // now replace the app with one where the location is still set to preferExternal mPMHostUtils.installAppAndVerifyExistsOnSDCard(getTestAppFilePath( EXTERNAL_LOC_VERSION_V2_APK), EXTERNAL_LOC_VERSION_PKG, true); } // cleanup test app finally { mPMHostUtils.uninstallApp(EXTERNAL_LOC_VERSION_PKG); } } /** * Regression test to verify that updating an app on the SD card will install * the update onto the SD card as well when location is not explicitly set in the * updated apps' manifest file. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testUpdateToSDCard() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test updating an app on the SD card stays on the SD card"); try { // install the app externally mPMHostUtils.installAppAndVerifyExistsOnSDCard(getTestAppFilePath( UPDATE_EXTERNAL_LOC_V1_EXT_APK), UPDATE_EXTERNAL_LOC_PKG, false); // now replace the app with one where the location is blank (app should stay external) mPMHostUtils.installAppAndVerifyExistsOnSDCard(getTestAppFilePath( UPDATE_EXTERNAL_LOC_V2_NONE_APK), UPDATE_EXTERNAL_LOC_PKG, true); } // cleanup test app finally { mPMHostUtils.uninstallApp(UPDATE_EXTERNAL_LOC_PKG); } } /** * Regression test to verify that updating an app on the SD card will install * the update onto the device if the manifest has changed to installLocation=internalOnly * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testUpdateSDCardToDevice() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test updating an app on the SD card to the Device through manifest change"); try { // install the app externally mPMHostUtils.installAppAndVerifyExistsOnSDCard(getTestAppFilePath( UPDATE_EXT_TO_INT_LOC_V1_EXT_APK), UPDATE_EXT_TO_INT_LOC_PKG, false); // now replace the app with an update marked for internalOnly...(should move internal) mPMHostUtils.installAppAndVerifyExistsOnDevice(getTestAppFilePath( UPDATE_EXT_TO_INT_LOC_V2_INT_APK), UPDATE_EXT_TO_INT_LOC_PKG, true); } // cleanup test app finally { mPMHostUtils.uninstallApp(UPDATE_EXT_TO_INT_LOC_PKG); } } /** * Regression test to verify that installing and updating a forward-locked app will install * the update onto the device's forward-locked location * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws SyncException if the sync failed for another reason. * @throws InstallException if the install failed. */ public void testInstallAndUpdateExternalLocForwardLockedApp() throws IOException, InterruptedException, InstallException, SyncException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test updating a forward-locked app marked preferExternal"); try { // first try to install the forward-locked app externally mPMHostUtils.installFwdLockedAppAndVerifyExists(getTestAppFilePath( EXTERNAL_LOC_VERSION_V1_APK), EXTERNAL_LOC_VERSION_PKG, false); // now replace the app with an update marked for internalOnly and as forward locked mPMHostUtils.installFwdLockedAppAndVerifyExists(getTestAppFilePath( EXTERNAL_LOC_VERSION_V2_APK), EXTERNAL_LOC_VERSION_PKG, true); } // cleanup test app finally { mPMHostUtils.uninstallApp(EXTERNAL_LOC_VERSION_PKG); } } /** * Regression test to verify that updating a forward-locked app will install * the update onto the device's forward-locked location * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws SyncException if the sync failed for another reason. * @throws InstallException if the install failed. */ public void testInstallAndUpdateNoLocForwardLockedApp() throws IOException, InterruptedException, InstallException, SyncException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test updating a forward-locked app with no installLocation pref set"); try { // install the app mPMHostUtils.installFwdLockedAppAndVerifyExists(getTestAppFilePath( NO_LOC_VERSION_V1_APK), NO_LOC_VERSION_PKG, false); // now replace the app with an update marked for internalOnly... mPMHostUtils.installFwdLockedAppAndVerifyExists(getTestAppFilePath( NO_LOC_VERSION_V2_APK), NO_LOC_VERSION_PKG, true); } // cleanup test app finally { mPMHostUtils.uninstallApp(NO_LOC_VERSION_PKG); } } /** * Regression test to verify that an app with all permissions set can be installed on SD card * and then launched without crashing. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws SyncException if the sync failed for another reason. * @throws InstallException if the install failed. */ public void testInstallAndLaunchAllPermsAppOnSD() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test launching an app with all perms set, installed on SD card"); try { // install the app mPMHostUtils.installAppAndVerifyExistsOnSDCard(getTestAppFilePath( ALL_PERMS_APK), ALL_PERMS_PKG, false); boolean testsPassed = mPMHostUtils.runDeviceTestsDidAllTestsPass(ALL_PERMS_PKG); assert(testsPassed); } // cleanup test app finally { mPMHostUtils.uninstallApp(ALL_PERMS_PKG); } } /** * Regression test to verify that an app with ACCESS_FINE_LOCATION (GPS) permissions can * run without permissions errors. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testInstallAndLaunchFLPermsAppOnSD() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test launching an app with location perms set, installed on SD card"); try { // install the app and verify we can launch it without permissions errors mPMHostUtils.installAppAndVerifyExistsOnSDCard(getTestAppFilePath( SHARED_PERMS_FL_APK), SHARED_PERMS_FL_PKG, false); boolean testsPassed = mPMHostUtils.runDeviceTestsDidAllTestsPass(SHARED_PERMS_FL_PKG); assert(testsPassed); } // cleanup test app finally { mPMHostUtils.uninstallApp(SHARED_PERMS_FL_PKG); } } /** * Regression test to verify that an app with BLUE_TOOTH permissions can * run without permissions errors. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testInstallAndLaunchBTPermsAppOnSD() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test launching an app with bluetooth perms set, installed on SD card"); try { // install the app and verify we can launch it without permissions errors mPMHostUtils.installAppAndVerifyExistsOnSDCard(getTestAppFilePath( SHARED_PERMS_BT_APK), SHARED_PERMS_BT_PKG, false); boolean testsPassed = mPMHostUtils.runDeviceTestsDidAllTestsPass(SHARED_PERMS_BT_PKG); assert(testsPassed); } // cleanup test app finally { mPMHostUtils.uninstallApp(SHARED_PERMS_BT_PKG); } } /** * Regression test to verify that a shared app with no explicit permissions throws a * SecurityException when launched if its other shared apps are not installed. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testInstallAndLaunchSharedPermsAppOnSD_NoPerms() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test launching an app with no explicit perms set, installed on SD card"); try { // Make sure the 2 shared apps with needed permissions are not installed... mPMHostUtils.uninstallApp(SHARED_PERMS_FL_PKG); mPMHostUtils.uninstallApp(SHARED_PERMS_BT_PKG); // now install the app and see if when we launch it we get a permissions error mPMHostUtils.installAppAndVerifyExistsOnSDCard(getTestAppFilePath( SHARED_PERMS_APK), SHARED_PERMS_PKG, false); boolean testsPassed = mPMHostUtils.runDeviceTestsDidAllTestsPass(SHARED_PERMS_PKG); assertEquals("Shared perms app should fail to run", false, testsPassed); } // cleanup test app finally { mPMHostUtils.uninstallApp(SHARED_PERMS_PKG); } } /** * Regression test to verify that a shared app with no explicit permissions can run if its other * shared apps are installed. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testInstallAndLaunchSharedPermsAppOnSD_GrantedPerms() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test launching an app with no explicit perms set, installed on SD card"); try { // install the 2 shared apps with needed permissions first mPMHostUtils.installAppAndVerifyExistsOnSDCard(getTestAppFilePath( SHARED_PERMS_FL_APK), SHARED_PERMS_FL_PKG, false); mPMHostUtils.installAppAndVerifyExistsOnSDCard(getTestAppFilePath( SHARED_PERMS_BT_APK), SHARED_PERMS_BT_PKG, false); // now install the test app and see if we can launch it without errors mPMHostUtils.installAppAndVerifyExistsOnSDCard(getTestAppFilePath( SHARED_PERMS_APK), SHARED_PERMS_PKG, false); boolean testsPassed = mPMHostUtils.runDeviceTestsDidAllTestsPass(SHARED_PERMS_PKG); assert(testsPassed); } // cleanup test app finally { mPMHostUtils.uninstallApp(SHARED_PERMS_PKG); mPMHostUtils.uninstallApp(SHARED_PERMS_BT_PKG); mPMHostUtils.uninstallApp(SHARED_PERMS_FL_PKG); } } /** * Regression test to verify that an app with ACCESS_FINE_LOCATION (GPS) permissions can * run without permissions errors even after a reboot * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testInstallAndLaunchFLPermsAppOnSD_Reboot() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test launching an app with location perms set, installed on SD card"); try { // install the app and verify we can launch it without permissions errors mPMHostUtils.installAppAndVerifyExistsOnSDCard(getTestAppFilePath( SHARED_PERMS_FL_APK), SHARED_PERMS_FL_PKG, false); boolean testsPassed = mPMHostUtils.runDeviceTestsDidAllTestsPass(SHARED_PERMS_FL_PKG); assert(testsPassed); mPMHostUtils.rebootDevice(); testsPassed = mPMHostUtils.runDeviceTestsDidAllTestsPass(SHARED_PERMS_FL_PKG); assert(testsPassed); } // cleanup test app finally { mPMHostUtils.uninstallApp(SHARED_PERMS_FL_PKG); } } /** * Regression test to verify that a shared app with no explicit permissions can run if its other * shared apps are installed, even after a reboot. * * Assumes adb is running as root in device under test. * @throws InterruptedException if the thread was interrupted * @throws TimeoutException in case of a timeout on the connection. * @throws AdbCommandRejectedException if adb rejects the command * @throws ShellCommandUnresponsiveException if the device did not output anything for * a period longer than the max time to output. * @throws IOException if connection to device was lost. * @throws InstallException if the install failed. */ public void testInstallAndLaunchSharedPermsAppOnSD_Reboot() throws IOException, InterruptedException, InstallException, TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException { Log.i(LOG_TAG, "Test launching an app on SD, with no explicit perms set after reboot"); try { // install the 2 shared apps with needed permissions first mPMHostUtils.installAppAndVerifyExistsOnSDCard(getTestAppFilePath( SHARED_PERMS_FL_APK), SHARED_PERMS_FL_PKG, false); mPMHostUtils.installAppAndVerifyExistsOnSDCard(getTestAppFilePath( SHARED_PERMS_BT_APK), SHARED_PERMS_BT_PKG, false); // now install the test app and see if we can launch it without errors mPMHostUtils.installAppAndVerifyExistsOnSDCard(getTestAppFilePath( SHARED_PERMS_APK), SHARED_PERMS_PKG, false); boolean testsPassed = mPMHostUtils.runDeviceTestsDidAllTestsPass(SHARED_PERMS_PKG); assert(testsPassed); // reboot mPMHostUtils.rebootDevice(); // Verify we can still launch the app testsPassed = mPMHostUtils.runDeviceTestsDidAllTestsPass(SHARED_PERMS_PKG); assert(testsPassed); } // cleanup test app finally { mPMHostUtils.uninstallApp(SHARED_PERMS_PKG); mPMHostUtils.uninstallApp(SHARED_PERMS_BT_PKG); mPMHostUtils.uninstallApp(SHARED_PERMS_FL_PKG); } } }