Adding a few host-based stress tests for Apps on SD.

Change-Id: I0ccb1f3574688f60b6296dac6f6859ba5d0597ea

36 files changed, 2485 insertions, 32 deletions

diff --git a/core/tests/hosttests/src/android/content/pm/PackageManagerHostTestUtils.java b/core/tests/hosttests/src/android/content/pm/PackageManagerHostTestUtils.java
index 8dfa850..2326672 100644
--- a/core/tests/hosttests/src/android/content/pm/PackageManagerHostTestUtils.java
+++ b/core/tests/hosttests/src/android/content/pm/PackageManagerHostTestUtils.java
@@ -16,6 +16,7 @@
 
 package android.content.pm;
 
+import com.android.ddmlib.AndroidDebugBridge;
 import com.android.ddmlib.IDevice;
 import com.android.ddmlib.IShellOutputReceiver;
 import com.android.ddmlib.Log;
@@ -23,11 +24,21 @@ import com.android.ddmlib.MultiLineReceiver;
 import com.android.ddmlib.SyncService;
 import com.android.ddmlib.SyncService.ISyncProgressMonitor;
 import com.android.ddmlib.SyncService.SyncResult;
+import com.android.ddmlib.testrunner.ITestRunListener;
+import com.android.ddmlib.testrunner.RemoteAndroidTestRunner;
+import com.android.ddmlib.testrunner.TestIdentifier;
 import com.android.hosttest.DeviceTestCase;
 import com.android.hosttest.DeviceTestSuite;
 
+import java.io.BufferedReader;
 import java.io.File;
+import java.io.InputStreamReader;
 import java.io.IOException;
+import java.io.StringReader;
+import java.lang.Runtime;
+import java.lang.Process;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import junit.framework.Assert;
 import com.android.hosttest.DeviceTestCase;
@@ -47,6 +58,21 @@ public class PackageManagerHostTestUtils extends Assert {
 
     private static final int MAX_WAIT_FOR_DEVICE_TIME = 120 * 1000;
     private static final int WAIT_FOR_DEVICE_POLL_TIME = 10 * 1000;
+    private static final int MAX_WAIT_FOR_APP_LAUNCH_TIME = 60 * 1000;
+    private static final int WAIT_FOR_APP_LAUNCH_POLL_TIME = 5 * 1000;
+
+    // Install preference on the device-side
+    public static enum InstallLocPreference {
+        AUTO,
+        INTERNAL,
+        EXTERNAL
+    }
+
+    // Actual install location
+    public static enum InstallLocation {
+        DEVICE,
+        SDCARD
+    }
 
     /**
      * Constructor takes the device to use
@@ -90,6 +116,30 @@ public class PackageManagerHostTestUtils extends Assert {
     }
 
     /**
+     * Helper method to run tests and return the listener that collected the results.
+     * @param pkgName Android application package for tests
+     * @return the {@link CollectingTestRunListener}
+     */
+    private CollectingTestRunListener doRunTests(String pkgName) {
+        RemoteAndroidTestRunner testRunner = new RemoteAndroidTestRunner(
+                pkgName, mDevice);
+        CollectingTestRunListener listener = new CollectingTestRunListener();
+        testRunner.run(listener);
+        return listener;
+    }
+
+    /**
+     * Runs the specified packages tests, and returns whether all tests passed or not.
+     *
+     * @param pkgName Android application package for tests
+     * @return true if every test passed, false otherwise.
+     */
+    public boolean runDeviceTestsDidAllTestsPass(String pkgName) {
+        CollectingTestRunListener listener = doRunTests(pkgName);
+        return listener.didAllTestsPass();
+    }
+
+    /**
      * Helper method to push a file to device
      * @param apkAppPrivatePath
      * @throws IOException
@@ -102,18 +152,48 @@ public class PackageManagerHostTestUtils extends Assert {
     }
 
     /**
-     * Helper method to install a file to device
+     * Helper method to install a file
      * @param localFilePath the absolute file system path to file on local host to install
      * @param reinstall set to <code>true</code> if re-install of app should be performed
      * @throws IOException
      */
-    public void installFile(final String localFilePath, final boolean replace)
-            throws IOException {
+    public void installFile(final String localFilePath, final boolean replace) throws IOException {
         String result = mDevice.installPackage(localFilePath, replace);
         assertEquals(null, result);
     }
 
     /**
+     * Helper method to install a file that should not be install-able
+     * @param localFilePath the absolute file system path to file on local host to install
+     * @param reinstall set to <code>true</code> if re-install of app should be performed
+     * @return the string output of the failed install attempt
+     * @throws IOException
+     */
+    public String installFileFail(final String localFilePath, final boolean replace)
+            throws IOException {
+        String result = mDevice.installPackage(localFilePath, replace);
+        assertNotNull(result);
+        return result;
+    }
+
+    /**
+     * Helper method to install a file to device as forward locked
+     * @param localFilePath the absolute file system path to file on local host to install
+     * @param reinstall set to <code>true</code> if re-install of app should be performed
+     * @throws IOException
+     */
+    public String installFileForwardLocked(final String localFilePath, final boolean replace)
+            throws IOException {
+        String remoteFilePath = mDevice.syncPackageToDevice(localFilePath);
+        InstallReceiver receiver = new InstallReceiver();
+        String cmd = String.format(replace ? "pm install -r -l \"%1$s\"" :
+                "pm install -l \"%1$s\"", remoteFilePath);
+        mDevice.executeShellCommand(cmd, receiver);
+        mDevice.removeRemotePackage(remoteFilePath);
+        return receiver.getErrorMessage();
+    }
+
+    /**
      * Helper method to determine if file on device exists.
      *
      * @param destPath the absolute path of file on device to check
@@ -128,7 +208,7 @@ public class PackageManagerHostTestUtils extends Assert {
     /**
      * Helper method to determine if file exists on the device containing a given string.
      *
-     * @param destPath the
+     * @param destPath the absolute path of the file
      * @return <code>true</code> if file exists containing given string,
      *         <code>false</code> otherwise.
      * @throws IOException if adb shell command failed
@@ -152,18 +232,18 @@ public class PackageManagerHostTestUtils extends Assert {
     }
 
     /**
-     * Helper method to determine if app was installed on device.
+     * Determines if app was installed on device.
      *
      * @param packageName package name to check for
      * @return <code>true</code> if file exists, <code>false</code> otherwise.
      * @throws IOException if adb shell command failed
      */
-    private boolean doesAppExistOnDevice(String packageName) throws IOException {
+    public boolean doesAppExistOnDevice(String packageName) throws IOException {
         return doesRemoteFileExistContainingString(DEVICE_APP_PATH, packageName);
     }
 
     /**
-     * Helper method to determine if app was installed on SD card.
+     * Determines if app was installed on SD card.
      *
      * @param packageName package name to check for
      * @return <code>true</code> if file exists, <code>false</code> otherwise.
@@ -174,12 +254,23 @@ public class PackageManagerHostTestUtils extends Assert {
     }
 
     /**
+     * Helper method to determine if app was installed on SD card.
+     *
+     * @param packageName package name to check for
+     * @return <code>true</code> if file exists, <code>false</code> otherwise.
+     * @throws IOException if adb shell command failed
+     */
+    public boolean doesAppExistAsForwardLocked(String packageName) throws IOException {
+        return doesRemoteFileExistContainingString(APP_PRIVATE_PATH, packageName);
+    }
+
+    /**
      * Waits for device's package manager to respond.
      *
      * @throws InterruptedException
      * @throws IOException
      */
-    public void waitForDevice() throws InterruptedException, IOException {
+    public void waitForPackageManager() throws InterruptedException, IOException {
         Log.i(LOG_TAG, "waiting for device");
         int currentWaitTime = 0;
         // poll the package manager until it returns something for android
@@ -194,20 +285,125 @@ public class PackageManagerHostTestUtils extends Assert {
     }
 
     /**
+     * Helper to determine if the device is currently online and visible via ADB.
+     *
+     * @return true iff the device is currently available to ADB and online, false otherwise.
+     */
+    private boolean deviceIsOnline() {
+        AndroidDebugBridge bridge = AndroidDebugBridge.getBridge();
+        IDevice[] devices = bridge.getDevices();
+
+        for (IDevice device : devices) {
+            // only online if the device appears in the devices list, and its state is online
+            if ((mDevice != null) &&
+                    mDevice.getSerialNumber().equals(device.getSerialNumber()) &&
+                    device.isOnline()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Waits for device to be online (visible to ADB) before returning, or times out if we've
+     * waited too long. Note that this only means the device is visible via ADB, not that
+     * PackageManager is fully up and running yet.
+     *
+     * @throws InterruptedException
+     * @throws IOException
+     */
+    public void waitForDeviceToComeOnline() throws InterruptedException, IOException {
+        Log.i(LOG_TAG, "waiting for device to be online");
+        int currentWaitTime = 0;
+
+        // poll ADB until we see the device is online
+        while (!deviceIsOnline()) {
+            Thread.sleep(WAIT_FOR_DEVICE_POLL_TIME);
+            currentWaitTime += WAIT_FOR_DEVICE_POLL_TIME;
+            if (currentWaitTime > MAX_WAIT_FOR_DEVICE_TIME) {
+                Log.e(LOG_TAG, "time out waiting for device");
+                throw new InterruptedException();
+            }
+        }
+        // Note: if we try to access the device too quickly after it is "officially" online,
+        // there are sometimes strange issues where it's actually not quite ready yet,
+        // so we pause for a bit once more before actually returning.
+        Thread.sleep(WAIT_FOR_DEVICE_POLL_TIME);
+    }
+
+    /**
+     * Queries package manager and waits until a package is launched (or times out)
+     *
+     * @param packageName The name of the package to wait to load
+     * @throws InterruptedException
+     * @throws IOException
+     */
+    public void waitForApp(String packageName) throws InterruptedException, IOException {
+        Log.i(LOG_TAG, "waiting for app to launch");
+        int currentWaitTime = 0;
+        // poll the package manager until it returns something for the package we're looking for
+        while (!doesPackageExist(packageName)) {
+            Thread.sleep(WAIT_FOR_APP_LAUNCH_POLL_TIME);
+            currentWaitTime += WAIT_FOR_APP_LAUNCH_POLL_TIME;
+            if (currentWaitTime > MAX_WAIT_FOR_APP_LAUNCH_TIME) {
+                Log.e(LOG_TAG, "time out waiting for app to launch: " + packageName);
+                throw new InterruptedException();
+            }
+        }
+    }
+
+    /**
      * Helper method which executes a adb shell command and returns output as a {@link String}
      * @return the output of the command
      * @throws IOException
      */
     public String executeShellCommand(String command) throws IOException {
-        Log.d(LOG_TAG, String.format("adb shell %s", command));
+        Log.i(LOG_TAG, String.format("adb shell %s", command));
         CollectingOutputReceiver receiver = new CollectingOutputReceiver();
         mDevice.executeShellCommand(command, receiver);
         String output = receiver.getOutput();
-        Log.d(LOG_TAG, String.format("Result: %s", output));
+        Log.i(LOG_TAG, String.format("Result: %s", output));
         return output;
     }
 
     /**
+     * Helper method ensures we are in root mode on the host side. It returns only after
+     * PackageManager is actually up and running.
+     * @throws IOException
+     */
+    public void runAdbRoot() throws IOException, InterruptedException {
+        Log.i(LOG_TAG, "adb root");
+        Runtime runtime = Runtime.getRuntime();
+        Process process = runtime.exec("adb root"); // adb should be in the path
+        BufferedReader output = new BufferedReader(new InputStreamReader(process.getInputStream()));
+
+        String nextLine = null;
+        while (null != (nextLine = output.readLine())) {
+            Log.i(LOG_TAG, nextLine);
+        }
+        process.waitFor();
+        waitForDeviceToComeOnline();
+        waitForPackageManager(); // now wait for package manager to actually load
+    }
+
+    /**
+     * Helper method which reboots the device and returns once the device is online again
+     * and package manager is up and running (note this function is synchronous to callers).
+     * @throws IOException
+     * @throws InterruptedException
+     */
+    public void rebootDevice() throws IOException, InterruptedException {
+        String command = "reboot"; // no need for -s since mDevice is already tied to a device
+        Log.i(LOG_TAG, command);
+        CollectingOutputReceiver receiver = new CollectingOutputReceiver();
+        mDevice.executeShellCommand(command, receiver);
+        String output = receiver.getOutput();
+        Log.i(LOG_TAG, String.format("Result: %s", output));
+        waitForDeviceToComeOnline(); // wait for device to come online
+        runAdbRoot();
+    }
+
+    /**
      * A {@link IShellOutputReceiver} which collects the whole shell output into one {@link String}
      */
     private class CollectingOutputReceiver extends MultiLineReceiver {
@@ -255,6 +451,97 @@ public class PackageManagerHostTestUtils extends Assert {
         }
     }
 
+    // For collecting results from running device tests
+    private static class CollectingTestRunListener implements ITestRunListener {
+
+        private boolean mAllTestsPassed = true;
+        private String mTestRunErrorMessage = null;
+
+        public void testEnded(TestIdentifier test) {
+            // ignore
+        }
+
+        public void testFailed(TestFailure status, TestIdentifier test,
+                String trace) {
+            Log.w(LOG_TAG, String.format("%s#%s failed: %s", test.getClassName(),
+                    test.getTestName(), trace));
+            mAllTestsPassed = false;
+        }
+
+        public void testRunEnded(long elapsedTime) {
+            // ignore
+        }
+
+        public void testRunFailed(String errorMessage) {
+            Log.w(LOG_TAG, String.format("test run failed: %s", errorMessage));
+            mAllTestsPassed = false;
+            mTestRunErrorMessage = errorMessage;
+        }
+
+        public void testRunStarted(int testCount) {
+            // ignore
+        }
+
+        public void testRunStopped(long elapsedTime) {
+            // ignore
+        }
+
+        public void testStarted(TestIdentifier test) {
+            // ignore
+        }
+
+        boolean didAllTestsPass() {
+            return mAllTestsPassed;
+        }
+
+        /**
+         * Get the test run failure error message.
+         * @return the test run failure error message or <code>null</code> if test run completed.
+         */
+        String getTestRunErrorMessage() {
+            return mTestRunErrorMessage;
+        }
+    }
+
+    /**
+     * Output receiver for "pm install package.apk" command line.
+     *
+     */
+    private static final class InstallReceiver extends MultiLineReceiver {
+
+        private static final String SUCCESS_OUTPUT = "Success"; //$NON-NLS-1$
+        private static final Pattern FAILURE_PATTERN = Pattern.compile("Failure\\s+\\[(.*)\\]"); //$NON-NLS-1$
+
+        private String mErrorMessage = null;
+
+        public InstallReceiver() {
+        }
+
+        @Override
+        public void processNewLines(String[] lines) {
+            for (String line : lines) {
+                if (line.length() > 0) {
+                    if (line.startsWith(SUCCESS_OUTPUT)) {
+                        mErrorMessage = null;
+                    } else {
+                        Matcher m = FAILURE_PATTERN.matcher(line);
+                        if (m.matches()) {
+                            mErrorMessage = m.group(1);
+                        }
+                    }
+                }
+            }
+        }
+
+        public boolean isCancelled() {
+            return false;
+        }
+
+        public String getErrorMessage() {
+            return mErrorMessage;
+        }
+    }
+
     /**
      * Helper method for installing an app to wherever is specified in its manifest, and
      * then verifying the app was installed onto SD Card.
@@ -280,7 +567,7 @@ public class PackageManagerHostTestUtils extends Assert {
         installFile(apkPath, overwrite);
         assertTrue(doesAppExistOnSDCard(pkgName));
         assertFalse(doesAppExistOnDevice(pkgName));
-        waitForDevice();
+        waitForPackageManager();
 
         // grep for package to make sure it is installed
         assertTrue(doesPackageExist(pkgName));
@@ -311,7 +598,39 @@ public class PackageManagerHostTestUtils extends Assert {
         installFile(apkPath, overwrite);
         assertFalse(doesAppExistOnSDCard(pkgName));
         assertTrue(doesAppExistOnDevice(pkgName));
-        waitForDevice();
+        waitForPackageManager();
+
+        // grep for package to make sure it is installed
+        assertTrue(doesPackageExist(pkgName));
+    }
+
+    /**
+     * Helper method for installing an app as forward-locked, and
+     * then verifying the app was installed in the proper forward-locked location.
+     *
+     * @param the path of the apk to install
+     * @param the name of the package
+     * @param <code>true</code> if the app should be overwritten, <code>false</code> otherwise
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     */
+    public void installFwdLockedAppAndVerifyExists(String apkPath,
+            String pkgName, boolean overwrite) throws IOException, InterruptedException {
+        // Start with a clean slate if we're not overwriting
+        if (!overwrite) {
+            // cleanup test app just in case it already exists
+            mDevice.uninstallPackage(pkgName);
+            // grep for package to make sure its not installed
+            assertFalse(doesPackageExist(pkgName));
+        }
+
+        String result = installFileForwardLocked(apkPath, overwrite);
+        assertEquals(null, result);
+        assertTrue(doesAppExistAsForwardLocked(pkgName));
+        assertFalse(doesAppExistOnSDCard(pkgName));
+        waitForPackageManager();
 
         // grep for package to make sure it is installed
         assertTrue(doesPackageExist(pkgName));
@@ -332,4 +651,74 @@ public class PackageManagerHostTestUtils extends Assert {
         assertFalse(doesPackageExist(pkgName));
     }
 
+    /**
+     * Helper method for clearing any installed non-system apps.
+     * Useful ensuring no non-system apps are installed, and for cleaning up stale files that
+     * may be lingering on the system for whatever reason.
+     *
+     * @throws IOException if adb shell command failed
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     */
+    public void wipeNonSystemApps() throws IOException {
+      String allInstalledPackages = executeShellCommand("pm list packages -f");
+      BufferedReader outputReader = new BufferedReader(new StringReader(allInstalledPackages));
+
+      // First use Package Manager to uninstall all non-system apps
+      String currentLine = null;
+      while ((currentLine = outputReader.readLine()) != null) {
+          // Skip over any system apps...
+          if (currentLine.contains("/system/")) {
+              continue;
+          }
+          String packageName = currentLine.substring(currentLine.indexOf('=') + 1);
+          mDevice.uninstallPackage(packageName);
+      }
+      // Make sure there are no stale app files under these directories
+      executeShellCommand(String.format("rm %s*", SDCARD_APP_PATH, "*"));
+      executeShellCommand(String.format("rm %s*", DEVICE_APP_PATH, "*"));
+      executeShellCommand(String.format("rm %s*", APP_PRIVATE_PATH, "*"));
+    }
+
+    /**
+     * Sets the device's install location preference.
+     *
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     */
+    public void setDevicePreferredInstallLocation(InstallLocPreference pref) throws IOException {
+        String command = "pm setInstallLocation %d";
+        int locValue = 0;
+        switch (pref) {
+            case INTERNAL:
+                locValue = 1;
+                break;
+            case EXTERNAL:
+                locValue = 2;
+                break;
+            default: // AUTO
+                locValue = 0;
+                break;
+        }
+        executeShellCommand(String.format(command, locValue));
+    }
+
+    /**
+     * Gets the device's install location preference.
+     *
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     */
+    public InstallLocPreference getDevicePreferredInstallLocation() throws IOException {
+        String result = executeShellCommand("pm getInstallLocation");
+        if (result.indexOf('0') != -1) {
+            return InstallLocPreference.AUTO;
+        }
+        else if (result.indexOf('1') != -1) {
+            return InstallLocPreference.INTERNAL;
+        }
+        else {
+            return InstallLocPreference.EXTERNAL;
+        }
+    }
 }
diff --git a/core/tests/hosttests/src/android/content/pm/PackageManagerHostTests.java b/core/tests/hosttests/src/android/content/pm/PackageManagerHostTests.java
index 90ddc3a..1b797d5 100644
--- a/core/tests/hosttests/src/android/content/pm/PackageManagerHostTests.java
+++ b/core/tests/hosttests/src/android/content/pm/PackageManagerHostTests.java
@@ -59,6 +59,21 @@ public class PackageManagerHostTests extends DeviceTestCase {
     // 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";
@@ -76,6 +91,12 @@ public class PackageManagerHostTests extends DeviceTestCase {
             = "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";
@@ -83,6 +104,20 @@ public class PackageManagerHostTests extends DeviceTestCase {
     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 {
@@ -95,6 +130,12 @@ public class PackageManagerHostTests extends DeviceTestCase {
         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);
     }
 
     /**
@@ -115,6 +156,8 @@ public class PackageManagerHostTests extends DeviceTestCase {
      * the app, and otherwise cause the system to blow up.
      * <p/>
      * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
      */
     public void testPushAppPrivate() throws IOException, InterruptedException {
         Log.i(LOG_TAG, "testing pushing an apk to /data/app-private");
@@ -129,7 +172,7 @@ public class PackageManagerHostTests extends DeviceTestCase {
         assertTrue(mPMHostUtils.doesRemoteFileExist(apkAppPrivatePath));
         mPMHostUtils.executeShellCommand("start");
 
-        mPMHostUtils.waitForDevice();
+        mPMHostUtils.waitForPackageManager();
 
         // grep for package to make sure its not installed
         assertFalse(mPMHostUtils.doesPackageExist(SIMPLE_PKG));
@@ -138,67 +181,424 @@ public class PackageManagerHostTests extends DeviceTestCase {
     }
 
     /**
-     * Regression test to verify that an app with its manifest set to installLocation=auto
-     * will install the app to the device.
+     * Helper to do a standard install of an apk and verify it installed to the correct location.
      * <p/>
      * 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 IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
      */
-    public void testInstallAppAutoLoc() throws IOException, InterruptedException {
-        Log.i(LOG_TAG, "Test an app with installLocation=auto gets installed on device");
+    private void doStandardInstall(String apkName, String pkgName,
+            PackageManagerHostTestUtils.InstallLocation expectedLocation)
+            throws IOException, InterruptedException {
 
-        try {
+        if (expectedLocation == PackageManagerHostTestUtils.InstallLocation.DEVICE) {
             mPMHostUtils.installAppAndVerifyExistsOnDevice(
-                    getTestAppFilePath(AUTO_LOC_APK), AUTO_LOC_PKG, false);
+                    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.
+     * <p/>
+     * 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 IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void installAppAutoLoc(PackageManagerHostTestUtils.InstallLocPreference preference,
+            PackageManagerHostTestUtils.InstallLocation expectedLocation)
+            throws IOException, InterruptedException {
+
+        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=internalOnly
-     * will install the app to the 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 auto.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallAppAutoLocPrefIsAuto() throws IOException, InterruptedException {
+        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.
      * <p/>
      * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
      */
-    public void testInstallAppInternalLoc() throws IOException, InterruptedException {
-        Log.i(LOG_TAG, "Test an app with installLocation=internalOnly gets installed on device");
+    public void testInstallAppAutoLocPrefIsInternal() throws IOException, InterruptedException {
+        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.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallAppAutoLocPrefIsExternal() throws IOException, InterruptedException {
+        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.
+     * <p/>
+     * 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 IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void installAppInternalLoc(PackageManagerHostTestUtils.InstallLocPreference preference,
+            PackageManagerHostTestUtils.InstallLocation expectedLocation)
+            throws IOException, InterruptedException {
+
+        PackageManagerHostTestUtils.InstallLocPreference savedPref =
+            PackageManagerHostTestUtils.InstallLocPreference.AUTO;
 
         try {
-            mPMHostUtils.installAppAndVerifyExistsOnDevice(
-                    getTestAppFilePath(INTERNAL_LOC_APK), INTERNAL_LOC_PKG, false);
+            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.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallAppInternalLocPrefIsAuto() throws IOException, InterruptedException {
+        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.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallAppInternalLocPrefIsInternal() throws IOException, InterruptedException {
+        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.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallAppInternalLocPrefIsExternal() throws IOException, InterruptedException {
+        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.
      * <p/>
      * 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 IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
      */
-    public void testInstallAppExternalLoc() throws IOException, InterruptedException {
-        Log.i(LOG_TAG, "Test an app with installLocation=preferExternal gets installed on SD Card");
+    public void installAppExternalLoc(PackageManagerHostTestUtils.InstallLocPreference preference,
+            PackageManagerHostTestUtils.InstallLocation expectedLocation)
+            throws IOException, InterruptedException {
+
+        PackageManagerHostTestUtils.InstallLocPreference savedPref =
+            PackageManagerHostTestUtils.InstallLocPreference.AUTO;
 
         try {
-            mPMHostUtils.installAppAndVerifyExistsOnSDCard(
-                    getTestAppFilePath(EXTERNAL_LOC_APK), EXTERNAL_LOC_PKG, false);
+            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.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallAppExternalLocPrefIsAuto() throws IOException, InterruptedException {
+        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.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallAppExternalLocPrefIsInternal() throws IOException, InterruptedException {
+        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.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallAppExternalLocPrefIsExternal() throws IOException, InterruptedException {
+        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.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallAppNoLocPrefIsAuto() throws IOException, InterruptedException {
+        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.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallAppNoLocPrefIsExternal() throws IOException, InterruptedException {
+        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.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallAppNoLocPrefIsInternal() throws IOException, InterruptedException {
+        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.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallFwdLockedAppInternal() throws IOException, InterruptedException {
+        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.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallFwdLockedAppExternal() throws IOException, InterruptedException {
+        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.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallFwdLockedAppAuto() throws IOException, InterruptedException {
+        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.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallFwdLockedAppNone() throws IOException, InterruptedException {
+        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.
      * <p/>
      * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
      */
     // 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()
@@ -225,6 +625,8 @@ public class PackageManagerHostTests extends DeviceTestCase {
      * uninstall it, and reinstall it onto the device.
      * <p/>
      * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
      */
     // 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()
@@ -250,10 +652,37 @@ public class PackageManagerHostTests extends DeviceTestCase {
 
     /**
      * 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
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testUpdateBothExternal() throws IOException, InterruptedException {
+        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.
      * <p/>
      * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
      */
     public void testUpdateToSDCard() throws IOException, InterruptedException {
         Log.i(LOG_TAG, "Test updating an app on the SD card stays on the SD card");
@@ -274,10 +703,11 @@ public class PackageManagerHostTests extends DeviceTestCase {
 
     /**
      * 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.
+     * the update onto the device if the manifest has changed to installLocation=internalOnly
      * <p/>
      * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
      */
     public void testUpdateSDCardToDevice() throws IOException, InterruptedException {
         Log.i(LOG_TAG, "Test updating an app on the SD card to the Device through manifest change");
@@ -286,7 +716,7 @@ public class PackageManagerHostTests extends DeviceTestCase {
             // 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...
+            // 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);
         }
@@ -295,4 +725,264 @@ public class PackageManagerHostTests extends DeviceTestCase {
             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
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallAndUpdateExternalLocForwardLockedApp()
+            throws IOException, InterruptedException {
+        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
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallAndUpdateNoLocForwardLockedApp()
+            throws IOException, InterruptedException {
+        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.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallAndLaunchAllPermsAppOnSD()
+            throws IOException, InterruptedException {
+        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.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallAndLaunchFLPermsAppOnSD()
+            throws IOException, InterruptedException {
+        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.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallAndLaunchBTPermsAppOnSD()
+            throws IOException, InterruptedException {
+        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.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallAndLaunchSharedPermsAppOnSD_NoPerms()
+            throws IOException, InterruptedException {
+        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.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallAndLaunchSharedPermsAppOnSD_GrantedPerms()
+            throws IOException, InterruptedException {
+        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
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallAndLaunchFLPermsAppOnSD_Reboot()
+            throws IOException, InterruptedException {
+        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.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     * @throws IOException if adb shell command failed
+     * @throws InterruptedException if the thread was interrupted
+     */
+    public void testInstallAndLaunchSharedPermsAppOnSD_Reboot()
+            throws IOException, InterruptedException {
+        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);
+        }
+    }
 }
diff --git a/core/tests/hosttests/src/android/content/pm/PackageManagerStressHostTests.java b/core/tests/hosttests/src/android/content/pm/PackageManagerStressHostTests.java
new file mode 100644
index 0000000..715c55b
--- /dev/null
+++ b/core/tests/hosttests/src/android/content/pm/PackageManagerStressHostTests.java
@@ -0,0 +1,286 @@
+/*
+ * 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.IDevice;
+import com.android.ddmlib.Log;
+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 stress scenarios (large apps, multiple upgrades, etc.)
+ */
+public class PackageManagerStressHostTests extends DeviceTestCase {
+
+    private static final String LOG_TAG = "PackageManagerStressHostTests";
+    private PackageManagerHostTestUtils mPMHostUtils = null;
+
+    // Path to the app repository and various subdirectories of it
+    // Note: These stress tests require large apks that cannot be checked into the tree.
+    // These variables define static locations that point to existing APKs (not built from
+    // the tree) which can be used by the the stress tests in this file.
+    private static final String LARGE_APPS_DIRECTORY_NAME = "largeApps";
+    private static final String MISC_APPS_DIRECTORY_NAME = "miscApps";
+    private static final String VERSIONED_APPS_DIRECTORY_NAME = "versionedApps";
+    private static final String MANY_APPS_DIRECTORY_NAME = "manyApps";
+
+    // Note: An external environment variable "ANDROID_TEST_APP_REPOSITORY" must be set
+    // which points to the root location of the app respository.
+    private static String AppRepositoryPath = null;
+
+    // Large apps (>1mb) - filenames and their corresponding package names:
+    private static enum APK {
+            FILENAME,
+            PACKAGENAME;
+    }
+    private static final String[][] LARGE_APPS = {
+       {"External1mb.apk", "com.appsonsd.mytests.External1mb"},
+       {"External2mb.apk", "com.appsonsd.mytests.External2mb"},
+       {"External3mb.apk", "com.appsonsd.mytests.External3mb"},
+       {"External4mb.apk", "com.appsonsd.mytests.External4mb"},
+       {"External5mb.apk", "com.appsonsd.mytests.External5mb"},
+       {"External6mb.apk", "com.appsonsd.mytests.External6mb"},
+       {"External7mb.apk", "com.appsonsd.mytests.External7mb"},
+       {"External8mb.apk", "com.appsonsd.mytests.External8mb"},
+       {"External9mb.apk", "com.appsonsd.mytests.External9mb"},
+       {"External10mb.apk", "com.appsonsd.mytests.External10mb"},
+       {"External16mb.apk", "com.appsonsd.mytests.External16mb"},
+       {"External28mb.apk", "com.appsonsd.mytests.External28mb"},
+       {"External34mb.apk", "com.appsonsd.mytests.External34mb"},
+       {"External46mb.apk", "com.appsonsd.mytests.External46mb"},
+       {"External58mb.apk", "com.appsonsd.mytests.External58mb"},
+       {"External65mb.apk", "com.appsonsd.mytests.External65mb"},
+       {"External72mb.apk", "com.appsonsd.mytests.External72mb"},
+       {"External79mb.apk", "com.appsonsd.mytests.External79mb"},
+       {"External86mb.apk", "com.appsonsd.mytests.External86mb"},
+       {"External93mb.apk", "com.appsonsd.mytests.External93mb"}};
+
+    // Various test files and their corresponding package names
+    private static final String AUTO_LOC_APK = "Auto241kb.apk";
+    private static final String AUTO_LOC_PKG = "com.appsonsd.mytests.Auto241kb";
+    private static final String INTERNAL_LOC_APK = "Internal781kb.apk";
+    private static final String INTERNAL_LOC_PKG = "com.appsonsd.mytests.Internal781kb";
+    private static final String EXTERNAL_LOC_APK = "External931kb.apk";
+    private static final String EXTERNAL_LOC_PKG = "com.appsonsd.mytests.External931kb";
+    private static final String NO_LOC_APK = "Internal751kb_EclairSDK.apk";
+    private static final String NO_LOC_PKG = "com.appsonsd.mytests.Internal751kb_EclairSDK";
+    // Versioned test apps
+    private static final String VERSIONED_APPS_FILENAME_PREFIX = "External455kb_v";
+    private static final String VERSIONED_APPS_PKG = "com.appsonsd.mytests.External455kb";
+    private static final int VERSIONED_APPS_START_VERSION = 1;  // inclusive
+    private static final int VERSIONED_APPS_END_VERSION = 250;  // inclusive
+    // Large number of app installs
+    // @TODO: increase the max when we can install more apps
+    private static final int MANY_APPS_START = 1;
+    private static final int MANY_APPS_END = 100;
+    private static final String MANY_APPS_PKG_PREFIX = "com.appsonsd.mytests.External49kb_";
+    private static final String MANY_APPS_APK_PREFIX = "External49kb_";
+
+    public static Test suite() {
+        return new DeviceTestSuite(PackageManagerStressHostTests.class);
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+
+        // setup the PackageManager host tests utilities class, and get various paths we'll need...
+        mPMHostUtils = new PackageManagerHostTestUtils(getDevice());
+        AppRepositoryPath = System.getenv("ANDROID_TEST_APP_REPOSITORY");
+        assertNotNull(AppRepositoryPath);
+
+        // Make sure path ends with a separator
+        if (!AppRepositoryPath.endsWith(File.separator)) {
+            AppRepositoryPath += File.separator;
+        }
+    }
+
+    /**
+     * Get the absolute file system location of repository test app with given filename
+     * @param fileName the file name of the test app apk
+     * @return {@link String} of absolute file path
+     */
+    private String getRepositoryTestAppFilePath(String fileDirectory, String fileName) {
+        return String.format("%s%s%s%s", AppRepositoryPath, fileDirectory,
+                File.separator, fileName);
+    }
+
+    /**
+     * 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);
+    }
+
+    /**
+     * Stress test to verify that we can update an app multiple times on the SD card.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     */
+    public void testUpdateAppManyTimesOnSD() throws IOException, InterruptedException {
+        Log.i(LOG_TAG, "Test updating an app on SD numerous times");
+
+        // cleanup test app just in case it already exists
+        mPMHostUtils.uninstallApp(VERSIONED_APPS_PKG);
+        // grep for package to make sure its not installed
+        assertFalse(mPMHostUtils.doesPackageExist(VERSIONED_APPS_PKG));
+
+        try {
+            for (int i = VERSIONED_APPS_START_VERSION; i <= VERSIONED_APPS_END_VERSION; ++i) {
+                String currentApkName = String.format("%s%d.apk",
+                        VERSIONED_APPS_FILENAME_PREFIX, i);
+
+                Log.i(LOG_TAG, "Installing app " + currentApkName);
+                mPMHostUtils.installFile(getRepositoryTestAppFilePath(VERSIONED_APPS_DIRECTORY_NAME,
+                        currentApkName), true);
+                mPMHostUtils.waitForPackageManager();
+                assertTrue(mPMHostUtils.doesAppExistOnSDCard(VERSIONED_APPS_PKG));
+                assertTrue(mPMHostUtils.doesPackageExist(VERSIONED_APPS_PKG));
+            }
+        }
+        finally {
+            // cleanup test app
+            mPMHostUtils.uninstallApp(VERSIONED_APPS_PKG);
+            // grep for package to make sure its not installed
+            assertFalse(mPMHostUtils.doesPackageExist(VERSIONED_APPS_PKG));
+        }
+    }
+
+    /**
+     * Stress test to verify that an app can be installed, uninstalled, and
+     * reinstalled on SD many times.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     */
+    public void testUninstallReinstallAppOnSDManyTimes() throws IOException, InterruptedException {
+        Log.i(LOG_TAG, "Test updating an app on the SD card stays on the SD card");
+
+        // cleanup test app just in case it was already exists
+        mPMHostUtils.uninstallApp(EXTERNAL_LOC_PKG);
+        // grep for package to make sure its not installed
+        assertFalse(mPMHostUtils.doesPackageExist(EXTERNAL_LOC_PKG));
+
+        for (int i = 0; i <= 500; ++i) {
+            Log.i(LOG_TAG, "Installing app");
+
+            try {
+                // install the app
+                mPMHostUtils.installFile(getRepositoryTestAppFilePath(MISC_APPS_DIRECTORY_NAME,
+                        EXTERNAL_LOC_APK), false);
+                mPMHostUtils.waitForPackageManager();
+                assertTrue(mPMHostUtils.doesAppExistOnSDCard(EXTERNAL_LOC_PKG));
+                assertTrue(mPMHostUtils.doesPackageExist(EXTERNAL_LOC_PKG));
+            }
+            finally {
+                // now uninstall the app
+                Log.i(LOG_TAG, "Uninstalling app");
+                mPMHostUtils.uninstallApp(EXTERNAL_LOC_PKG);
+                mPMHostUtils.waitForPackageManager();
+                assertFalse(mPMHostUtils.doesPackageExist(EXTERNAL_LOC_PKG));
+            }
+        }
+    }
+
+    /**
+     * Stress test to verify that we can install, 20 large apps (>1mb each)
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     */
+    public void testInstallManyLargeAppsOnSD() throws IOException, InterruptedException {
+        Log.i(LOG_TAG, "Test installing 20 large apps onto the sd card");
+
+        try {
+            // Install all the large apps
+            for (int i=0; i < LARGE_APPS.length; ++i) {
+                String apkName = LARGE_APPS[i][APK.FILENAME.ordinal()];
+                String pkgName = LARGE_APPS[i][APK.PACKAGENAME.ordinal()];
+
+                // cleanup test app just in case it already exists
+                mPMHostUtils.uninstallApp(pkgName);
+                // grep for package to make sure its not installed
+                assertFalse(mPMHostUtils.doesPackageExist(pkgName));
+
+                Log.i(LOG_TAG, "Installing app " + apkName);
+                // install the app
+                mPMHostUtils.installFile(getRepositoryTestAppFilePath(LARGE_APPS_DIRECTORY_NAME,
+                        apkName), false);
+                mPMHostUtils.waitForPackageManager();
+                assertTrue(mPMHostUtils.doesAppExistOnSDCard(pkgName));
+                assertTrue(mPMHostUtils.doesPackageExist(pkgName));
+            }
+        }
+        finally {
+            // Cleanup - ensure we uninstall all large apps if they were installed
+            for (int i=0; i < LARGE_APPS.length; ++i) {
+                String apkName = LARGE_APPS[i][APK.FILENAME.ordinal()];
+                String pkgName = LARGE_APPS[i][APK.PACKAGENAME.ordinal()];
+
+                Log.i(LOG_TAG, "Uninstalling app " + apkName);
+                // cleanup test app just in case it was accidently installed
+                mPMHostUtils.uninstallApp(pkgName);
+                // grep for package to make sure its not installed anymore
+                assertFalse(mPMHostUtils.doesPackageExist(pkgName));
+                assertFalse(mPMHostUtils.doesAppExistOnSDCard(pkgName));
+            }
+        }
+    }
+
+    /**
+     * Stress test to verify that we can install many small apps onto SD.
+     * <p/>
+     * Assumes adb is running as root in device under test.
+     */
+    public void testInstallManyAppsOnSD() throws IOException, InterruptedException {
+        Log.i(LOG_TAG, "Test installing 500 small apps onto SD");
+
+        try {
+            for (int i = MANY_APPS_START; i <= MANY_APPS_END; ++i) {
+                String currentPkgName = String.format("%s%d", MANY_APPS_PKG_PREFIX, i);
+
+                // cleanup test app just in case it already exists
+                mPMHostUtils.uninstallApp(currentPkgName);
+                // grep for package to make sure its not installed
+                assertFalse(mPMHostUtils.doesPackageExist(currentPkgName));
+
+                String currentApkName = String.format("%s%d.apk", MANY_APPS_APK_PREFIX, i);
+                Log.i(LOG_TAG, "Installing app " + currentApkName);
+                mPMHostUtils.installFile(getRepositoryTestAppFilePath(MANY_APPS_DIRECTORY_NAME,
+                        currentApkName), true);
+                mPMHostUtils.waitForPackageManager();
+                assertTrue(mPMHostUtils.doesAppExistOnSDCard(currentPkgName));
+                assertTrue(mPMHostUtils.doesPackageExist(currentPkgName));
+            }
+        }
+        finally {
+            for (int i = MANY_APPS_START; i <= MANY_APPS_END; ++i) {
+                String currentPkgName = String.format("%s%d", MANY_APPS_PKG_PREFIX, i);
+
+                // cleanup test app
+                mPMHostUtils.uninstallApp(currentPkgName);
+                // grep for package to make sure its not installed
+                assertFalse(mPMHostUtils.doesPackageExist(currentPkgName));
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v1/Android.mk b/core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v1/Android.mk
new file mode 100644
index 0000000..a887bac
--- /dev/null
+++ b/core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v1/Android.mk
@@ -0,0 +1,27 @@
+# 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.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_SDK_VERSION := current
+
+LOCAL_PACKAGE_NAME := AutoLocVersionedTestApp_v1
+
+include $(BUILD_PACKAGE)
diff --git a/core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v1/AndroidManifest.xml b/core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v1/AndroidManifest.xml
new file mode 100644
index 0000000..867871d
--- /dev/null
+++ b/core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v1/AndroidManifest.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+       package="com.android.framework.autolocversionedtestapp"
+       android:installLocation="auto"
+       android:versionCode="1"
+       android:versionName="1.0">
+
+    <application android:label="AutoLocVersionedTestApp_v1"/>
+
+</manifest>
diff --git a/core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v1/src/com/android/framework/autolocversionedtestapp/AutoLocVersionedTestAppActivity.java b/core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v1/src/com/android/framework/autolocversionedtestapp/AutoLocVersionedTestAppActivity.java
new file mode 100644
index 0000000..49575b7
--- /dev/null
+++ b/core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v1/src/com/android/framework/autolocversionedtestapp/AutoLocVersionedTestAppActivity.java
@@ -0,0 +1,26 @@
+/*
+ * 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 com.android.framework.autolocversionedtestapp;
+
+import android.app.Activity;
+import android.os.Bundle;
+
+/**
+ * Empty activity, not needed for this test
+ */
+public class AutoLocVersionedTestAppActivity extends Activity {
+
+}
diff --git a/core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v2/Android.mk b/core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v2/Android.mk
new file mode 100644
index 0000000..69084bf
--- /dev/null
+++ b/core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v2/Android.mk
@@ -0,0 +1,27 @@
+# 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.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_SDK_VERSION := current
+
+LOCAL_PACKAGE_NAME := AutoLocVersionedTestApp_v2
+
+include $(BUILD_PACKAGE)
diff --git a/core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v2/AndroidManifest.xml b/core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v2/AndroidManifest.xml
new file mode 100644
index 0000000..98e5606
--- /dev/null
+++ b/core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v2/AndroidManifest.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+       package="com.android.framework.autolocversionedtestapp"
+       android:installLocation="auto"
+       android:versionCode="2"
+       android:versionName="2.0">
+
+    <application android:label="AutoLocVersionedTestApp_v2"/>
+
+</manifest>
diff --git a/core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v2/src/com/android/framework/autolocversionedtestapp/AutoLocVersionedTestAppActivity.java b/core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v2/src/com/android/framework/autolocversionedtestapp/AutoLocVersionedTestAppActivity.java
new file mode 100644
index 0000000..49575b7
--- /dev/null
+++ b/core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v2/src/com/android/framework/autolocversionedtestapp/AutoLocVersionedTestAppActivity.java
@@ -0,0 +1,26 @@
+/*
+ * 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 com.android.framework.autolocversionedtestapp;
+
+import android.app.Activity;
+import android.os.Bundle;
+
+/**
+ * Empty activity, not needed for this test
+ */
+public class AutoLocVersionedTestAppActivity extends Activity {
+
+}
diff --git a/core/tests/hosttests/test-apps/ExternalLocAllPermsTestApp/Android.mk b/core/tests/hosttests/test-apps/ExternalLocAllPermsTestApp/Android.mk
new file mode 100644
index 0000000..c70c1d3
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalLocAllPermsTestApp/Android.mk
@@ -0,0 +1,27 @@
+# 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.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_SDK_VERSION := current
+
+LOCAL_PACKAGE_NAME := ExternalLocAllPermsTestApp
+
+include $(BUILD_PACKAGE)
diff --git a/core/tests/hosttests/test-apps/ExternalLocAllPermsTestApp/AndroidManifest.xml b/core/tests/hosttests/test-apps/ExternalLocAllPermsTestApp/AndroidManifest.xml
new file mode 100644
index 0000000..0c502c0
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalLocAllPermsTestApp/AndroidManifest.xml
@@ -0,0 +1,138 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+       package="com.android.framework.externallocallpermstestapp"
+       android:installLocation="preferExternal">
+
+    <uses-permission android:name="android.permission.ACCESS_CHECKIN_PROPERTIES" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_LOCATION_EXTRA_COMMANDS" />
+    <uses-permission android:name="android.permission.ACCESS_MOCK_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.ACCESS_SURFACE_FLINGER" />
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+    <uses-permission android:name="android.permission.ACCOUNT_MANAGER" />
+    <uses-permission android:name="android.permission.AUTHENTICATE_ACCOUNTS" />
+    <uses-permission android:name="android.permission.BATTERY_STATS" />
+    <uses-permission android:name="android.permission.BIND_APPWIDGET" />
+    <uses-permission android:name="android.permission.BIND_INPUT_METHOD" />
+    <uses-permission android:name="android.permission.BLUETOOTH" />
+    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
+    <uses-permission android:name="android.permission.BRICK" />
+    <uses-permission android:name="android.permission.BROADCAST_PACKAGE_REMOVED" />
+    <uses-permission android:name="android.permission.BROADCAST_SMS" />
+    <uses-permission android:name="android.permission.BROADCAST_STICKY" />
+    <uses-permission android:name="android.permission.BROADCAST_WAP_PUSH" />
+    <uses-permission android:name="android.permission.CALL_PHONE" />
+    <uses-permission android:name="android.permission.CALL_PRIVILEGED" />
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.CHANGE_COMPONENT_ENABLED_STATE" />
+    <uses-permission android:name="android.permission.CHANGE_CONFIGURATION" />
+    <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.CHANGE_WIFI_MULTICAST_STATE" />
+    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
+    <uses-permission android:name="android.permission.CLEAR_APP_CACHE" />
+    <uses-permission android:name="android.permission.CLEAR_APP_USER_DATA" />
+    <uses-permission android:name="android.permission.CONTROL_LOCATION_UPDATES" />
+    <uses-permission android:name="android.permission.DELETE_CACHE_FILES" />
+    <uses-permission android:name="android.permission.DELETE_PACKAGES" />
+    <uses-permission android:name="android.permission.DEVICE_POWER" />
+    <uses-permission android:name="android.permission.DIAGNOSTIC" />
+    <uses-permission android:name="android.permission.DISABLE_KEYGUARD" />
+    <uses-permission android:name="android.permission.DUMP" />
+    <uses-permission android:name="android.permission.EXPAND_STATUS_BAR" />
+    <uses-permission android:name="android.permission.FACTORY_TEST" />
+    <uses-permission android:name="android.permission.FLASHLIGHT" />
+    <uses-permission android:name="android.permission.FORCE_BACK" />
+    <uses-permission android:name="android.permission.GET_ACCOUNTS" />
+    <uses-permission android:name="android.permission.GET_PACKAGE_SIZE" />
+    <uses-permission android:name="android.permission.GET_TASKS" />
+    <uses-permission android:name="android.permission.GLOBAL_SEARCH" />
+    <uses-permission android:name="android.permission.HARDWARE_TEST" />
+    <uses-permission android:name="android.permission.INJECT_EVENTS" />
+    <uses-permission android:name="android.permission.INSTALL_LOCATION_PROVIDER" />
+    <uses-permission android:name="android.permission.INSTALL_PACKAGES" />
+    <uses-permission android:name="android.permission.INTERNAL_SYSTEM_WINDOW" />
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.MANAGE_ACCOUNTS" />
+    <uses-permission android:name="android.permission.MANAGE_APP_TOKENS" />
+    <uses-permission android:name="android.permission.MASTER_CLEAR" />
+    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+    <uses-permission android:name="android.permission.MODIFY_PHONE_STATE" />
+    <uses-permission android:name="android.permission.MOUNT_FORMAT_FILESYSTEMS" />
+    <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS" />
+    <uses-permission android:name="android.permission.PERSISTENT_ACTIVITY" />
+    <uses-permission android:name="android.permission.PROCESS_OUTGOING_CALLS" />
+    <uses-permission android:name="android.permission.READ_CALENDAR" />
+    <uses-permission android:name="android.permission.READ_CONTACTS" />
+    <uses-permission android:name="android.permission.READ_FRAME_BUFFER" />
+    <uses-permission android:name="android.permission.READ_HISTORY_BOOKMARKS" />
+    <uses-permission android:name="android.permission.READ_INPUT_STATE" />
+    <uses-permission android:name="android.permission.READ_LOGS" />
+    <uses-permission android:name="android.permission.READ_OWNER_DATA" />
+    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
+    <uses-permission android:name="android.permission.READ_SMS" />
+    <uses-permission android:name="android.permission.READ_SYNC_SETTINGS" />
+    <uses-permission android:name="android.permission.READ_SYNC_STATS" />
+    <uses-permission android:name="android.permission.REBOOT" />
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+    <uses-permission android:name="android.permission.RECEIVE_MMS" />
+    <uses-permission android:name="android.permission.RECEIVE_SMS" />
+    <uses-permission android:name="android.permission.RECEIVE_WAP_PUSH" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.REORDER_TASKS" />
+    <uses-permission android:name="android.permission.RESTART_PACKAGES" />
+    <uses-permission android:name="android.permission.SEND_SMS" />
+    <uses-permission android:name="android.permission.SET_ACTIVITY_WATCHER" />
+    <uses-permission android:name="android.permission.SET_ALWAYS_FINISH" />
+    <uses-permission android:name="android.permission.SET_ANIMATION_SCALE" />
+    <uses-permission android:name="android.permission.SET_DEBUG_APP" />
+    <uses-permission android:name="android.permission.SET_ORIENTATION" />
+    <uses-permission android:name="android.permission.SET_PREFERRED_APPLICATIONS" />
+    <uses-permission android:name="android.permission.SET_PROCESS_LIMIT" />
+    <uses-permission android:name="android.permission.SET_TIME_ZONE" />
+    <uses-permission android:name="android.permission.SET_WALLPAPER" />
+    <uses-permission android:name="android.permission.SET_WALLPAPER_HINTS" />
+    <uses-permission android:name="android.permission.SIGNAL_PERSISTENT_PROCESSES" />
+    <uses-permission android:name="android.permission.STATUS_BAR" />
+    <uses-permission android:name="android.permission.SUBSCRIBED_FEEDS_READ" />
+    <uses-permission android:name="android.permission.SUBSCRIBED_FEEDS_WRITE" />
+    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
+    <uses-permission android:name="android.permission.UPDATE_DEVICE_STATS" />
+    <uses-permission android:name="android.permission.USE_CREDENTIALS" />
+    <uses-permission android:name="android.permission.VIBRATE" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="android.permission.WRITE_APN_SETTINGS" />
+    <uses-permission android:name="android.permission.WRITE_CALENDAR" />
+    <uses-permission android:name="android.permission.WRITE_CONTACTS" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.WRITE_GSERVICES" />
+    <uses-permission android:name="android.permission.WRITE_HISTORY_BOOKMARKS" />
+    <uses-permission android:name="android.permission.WRITE_OWNER_DATA" />
+    <uses-permission android:name="android.permission.WRITE_SECURE_SETTINGS" />
+    <uses-permission android:name="android.permission.WRITE_SETTINGS" />
+    <uses-permission android:name="android.permission.WRITE_SMS" />
+    <uses-permission android:name="android.permission.WRITE_SYNC_SETTINGS" />
+
+    <application>
+        <uses-library android:name="android.test.runner" />
+    </application>
+
+    <instrumentation android:name="android.test.InstrumentationTestRunner"
+                     android:targetPackage="com.android.framework.externallocallpermstestapp"
+                     android:label="Test for instrumentation with an app granted all permissions" />
+</manifest>
diff --git a/core/tests/hosttests/test-apps/ExternalLocAllPermsTestApp/src/com/android/framework/externallocallpermstestapp/ExternalLocAllPermsTest.java b/core/tests/hosttests/test-apps/ExternalLocAllPermsTestApp/src/com/android/framework/externallocallpermstestapp/ExternalLocAllPermsTest.java
new file mode 100644
index 0000000..8456255
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalLocAllPermsTestApp/src/com/android/framework/externallocallpermstestapp/ExternalLocAllPermsTest.java
@@ -0,0 +1,31 @@
+/*
+ * 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 com.android.framework.externallocallpermstestapp;
+
+import android.app.Activity;
+import android.os.Bundle;
+
+import junit.framework.TestCase;
+
+
+public class ExternalLocAllPermsTest extends TestCase {
+    /**
+     * Test method that should get run. Doesn't need to actually do anything here,
+     * we just need to verify the test runs without errors.
+     */
+    public void testInstrumentationCanRun() {
+    }
+}
diff --git a/core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v1/Android.mk b/core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v1/Android.mk
new file mode 100644
index 0000000..05f62cd
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v1/Android.mk
@@ -0,0 +1,27 @@
+# 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.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_SDK_VERSION := current
+
+LOCAL_PACKAGE_NAME := ExternalLocVersionedTestApp_v1
+
+include $(BUILD_PACKAGE)
diff --git a/core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v1/AndroidManifest.xml b/core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v1/AndroidManifest.xml
new file mode 100644
index 0000000..84bd5df
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v1/AndroidManifest.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+       package="com.android.framework.externallocversionedtestapp"
+       android:installLocation="preferExternal"
+       android:versionCode="1"
+       android:versionName="1.0">
+
+    <application android:label="ExternalLocVersionedTestApp_v1"/>
+
+</manifest>
diff --git a/core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v1/src/com/android/framework/externallocversionedtestapp/ExternalLocVersionedTestAppActivity.java b/core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v1/src/com/android/framework/externallocversionedtestapp/ExternalLocVersionedTestAppActivity.java
new file mode 100644
index 0000000..a7487c2
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v1/src/com/android/framework/externallocversionedtestapp/ExternalLocVersionedTestAppActivity.java
@@ -0,0 +1,26 @@
+/*
+ * 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 com.android.framework.externallocversionedtestapp;
+
+import android.app.Activity;
+import android.os.Bundle;
+
+/**
+ * Empty activity, not needed for this test
+ */
+public class ExternalLocVersionedTestAppActivity extends Activity {
+
+}
diff --git a/core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v2/Android.mk b/core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v2/Android.mk
new file mode 100644
index 0000000..aa31759
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v2/Android.mk
@@ -0,0 +1,27 @@
+# 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.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_SDK_VERSION := current
+
+LOCAL_PACKAGE_NAME := ExternalLocVersionedTestApp_v2
+
+include $(BUILD_PACKAGE)
diff --git a/core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v2/AndroidManifest.xml b/core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v2/AndroidManifest.xml
new file mode 100644
index 0000000..7acba15
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v2/AndroidManifest.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+       package="com.android.framework.externallocversionedtestapp"
+       android:installLocation="preferExternal"
+       android:versionCode="2"
+       android:versionName="2.0">
+
+    <application android:label="ExternalLocVersionedTestApp_v2"/>
+
+</manifest>
diff --git a/core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v2/src/com/android/framework/externallocversionedtestapp/ExternalLocVersionedTestAppActivity.java b/core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v2/src/com/android/framework/externallocversionedtestapp/ExternalLocVersionedTestAppActivity.java
new file mode 100644
index 0000000..a7487c2
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v2/src/com/android/framework/externallocversionedtestapp/ExternalLocVersionedTestAppActivity.java
@@ -0,0 +1,26 @@
+/*
+ * 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 com.android.framework.externallocversionedtestapp;
+
+import android.app.Activity;
+import android.os.Bundle;
+
+/**
+ * Empty activity, not needed for this test
+ */
+public class ExternalLocVersionedTestAppActivity extends Activity {
+
+}
diff --git a/core/tests/hosttests/test-apps/ExternalSharedPerms/Android.mk b/core/tests/hosttests/test-apps/ExternalSharedPerms/Android.mk
new file mode 100644
index 0000000..7946e1a
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalSharedPerms/Android.mk
@@ -0,0 +1,27 @@
+# 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.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_SDK_VERSION := current
+
+LOCAL_PACKAGE_NAME := ExternalSharedPermsTestApp
+
+include $(BUILD_PACKAGE)
diff --git a/core/tests/hosttests/test-apps/ExternalSharedPerms/AndroidManifest.xml b/core/tests/hosttests/test-apps/ExternalSharedPerms/AndroidManifest.xml
new file mode 100644
index 0000000..263a0fb
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalSharedPerms/AndroidManifest.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+       package="com.android.framework.externalsharedpermstestapp"
+       android:installLocation="preferExternal"
+       android:versionCode="1"
+       android:versionName="1.0"
+       android:sharedUserId="com.android.framework.externalsharedpermstestapp">
+
+    <application>
+        <uses-library android:name="android.test.runner" />
+    </application>
+
+    <instrumentation android:name="android.test.InstrumentationTestRunner"
+                     android:targetPackage="com.android.framework.externalsharedpermstestapp"
+                     android:label="Test for instrumentation with an external app with shared permissions (BT and FL)" />
+</manifest>
+
+
diff --git a/core/tests/hosttests/test-apps/ExternalSharedPerms/src/com/android/framework/externalsharedpermstestapp/ExternalSharedPermsTest.java b/core/tests/hosttests/test-apps/ExternalSharedPerms/src/com/android/framework/externalsharedpermstestapp/ExternalSharedPermsTest.java
new file mode 100644
index 0000000..da9600c
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalSharedPerms/src/com/android/framework/externalsharedpermstestapp/ExternalSharedPermsTest.java
@@ -0,0 +1,54 @@
+/*
+ * 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 com.android.framework.externalsharedpermstestapp;
+
+import android.bluetooth.BluetoothAdapter;
+import android.content.Context;
+import android.location.Location;
+import android.location.LocationListener;
+import android.location.LocationManager;
+import android.os.Bundle;
+
+import android.util.Log;
+
+import android.test.InstrumentationTestCase;
+
+public class ExternalSharedPermsTest extends InstrumentationTestCase
+{
+    private static final int REQUEST_ENABLE_BT = 2;
+
+    /** The use of location manager and bluetooth below are simply to simulate an app that
+     *  tries to use them, so we can verify whether permissions are granted and accessible.
+     * */
+    public void testRunLocationAndBluetooth()
+    {
+        LocationManager locationManager = (LocationManager)getInstrumentation().getContext(
+                ).getSystemService(Context.LOCATION_SERVICE);
+        locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0,
+                new LocationListener() {
+                        public void onLocationChanged(Location location) {}
+                        public void onProviderDisabled(String provider) {}
+                        public void onProviderEnabled(String provider) {}
+                        public void onStatusChanged(String provider, int status, Bundle extras) {}
+                }
+        );
+        BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+
+        if ((mBluetoothAdapter != null) && (!mBluetoothAdapter.isEnabled())) {
+            mBluetoothAdapter.getName();
+        }
+    }
+}
diff --git a/core/tests/hosttests/test-apps/ExternalSharedPermsBT/Android.mk b/core/tests/hosttests/test-apps/ExternalSharedPermsBT/Android.mk
new file mode 100644
index 0000000..657d0a4
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalSharedPermsBT/Android.mk
@@ -0,0 +1,27 @@
+# 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.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_SDK_VERSION := current
+
+LOCAL_PACKAGE_NAME := ExternalSharedPermsBTTestApp
+
+include $(BUILD_PACKAGE)
diff --git a/core/tests/hosttests/test-apps/ExternalSharedPermsBT/AndroidManifest.xml b/core/tests/hosttests/test-apps/ExternalSharedPermsBT/AndroidManifest.xml
new file mode 100644
index 0000000..98f7177
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalSharedPermsBT/AndroidManifest.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+       package="com.android.framework.externalsharedpermsbttestapp"
+       android:installLocation="preferExternal"
+       android:versionCode="1"
+       android:versionName="1.0"
+       android:sharedUserId="com.android.framework.externalsharedpermstestapp">
+
+    <uses-permission android:name="android.permission.BLUETOOTH" />
+
+    <application>
+        <uses-library android:name="android.test.runner" />
+    </application>
+
+    <instrumentation android:name="android.test.InstrumentationTestRunner"
+                     android:targetPackage="com.android.framework.externalsharedpermsbttestapp"
+                     android:label="Test for instrumentation with an external app granted BLUETOOTH permissions" />
+
+</manifest>
+
+
diff --git a/core/tests/hosttests/test-apps/ExternalSharedPermsBT/src/com/android/framework/externalsharedpermsbttestapp/ExternalSharedPermsBTTest.java b/core/tests/hosttests/test-apps/ExternalSharedPermsBT/src/com/android/framework/externalsharedpermsbttestapp/ExternalSharedPermsBTTest.java
new file mode 100644
index 0000000..c7bcdfc
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalSharedPermsBT/src/com/android/framework/externalsharedpermsbttestapp/ExternalSharedPermsBTTest.java
@@ -0,0 +1,38 @@
+/*
+ * 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 com.android.framework.externalsharedpermsbttestapp;
+
+import android.bluetooth.BluetoothAdapter;
+
+import android.test.InstrumentationTestCase;
+
+public class ExternalSharedPermsBTTest extends InstrumentationTestCase
+{
+    private static final int REQUEST_ENABLE_BT = 2;
+
+    /** The use of bluetooth below is simply to simulate an activity that tries to use bluetooth
+     *  upon creation, so we can verify whether permissions are granted and accessible to the
+     *  activity once it launches.
+     * */
+    public void testRunBluetooth()
+    {
+        BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+
+        if ((mBluetoothAdapter != null) && (!mBluetoothAdapter.isEnabled())) {
+            mBluetoothAdapter.getName();
+        }
+    }
+}
diff --git a/core/tests/hosttests/test-apps/ExternalSharedPermsDiffKey/Android.mk b/core/tests/hosttests/test-apps/ExternalSharedPermsDiffKey/Android.mk
new file mode 100644
index 0000000..d4450dc
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalSharedPermsDiffKey/Android.mk
@@ -0,0 +1,29 @@
+# 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.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_SDK_VERSION := current
+
+LOCAL_PACKAGE_NAME := ExternalSharedPermsDiffKeyTestApp
+
+LOCAL_CERTIFICATE := media
+
+include $(BUILD_PACKAGE)
diff --git a/core/tests/hosttests/test-apps/ExternalSharedPermsDiffKey/AndroidManifest.xml b/core/tests/hosttests/test-apps/ExternalSharedPermsDiffKey/AndroidManifest.xml
new file mode 100644
index 0000000..d0e8fb9
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalSharedPermsDiffKey/AndroidManifest.xml
@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+       package="com.android.framework.externalsharedpermsdiffkeytestapp"
+       android:installLocation="preferExternal"
+       android:versionCode="1"
+       android:versionName="1.0"
+       android:sharedUserId="com.android.framework.externalsharedpermstestapp">
+
+    <application>
+        <uses-library android:name="android.test.runner" />
+    </application>
+
+    <instrumentation android:name="android.test.InstrumentationTestRunner"
+                     android:targetPackage="com.android.framework.externalsharedpermsdiffkeytestapp"
+                     android:label="Test for instrumentation with an app with shared permissions but signed by different key" />
+</manifest>
+
+
diff --git a/core/tests/hosttests/test-apps/ExternalSharedPermsDiffKey/src/com/android/framework/externalsharedpermsdiffkeytestapp/ExternalSharedPermsDiffKeyTest.java b/core/tests/hosttests/test-apps/ExternalSharedPermsDiffKey/src/com/android/framework/externalsharedpermsdiffkeytestapp/ExternalSharedPermsDiffKeyTest.java
new file mode 100644
index 0000000..adc906a
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalSharedPermsDiffKey/src/com/android/framework/externalsharedpermsdiffkeytestapp/ExternalSharedPermsDiffKeyTest.java
@@ -0,0 +1,53 @@
+/*
+ * 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 com.android.framework.externalsharedpermsdiffkeytestapp;
+
+import android.bluetooth.BluetoothAdapter;
+import android.content.Context;
+import android.os.Bundle;
+import android.location.Location;
+import android.location.LocationListener;
+import android.location.LocationManager;
+
+import android.test.InstrumentationTestCase;
+
+public class ExternalSharedPermsDiffKeyTest extends InstrumentationTestCase
+{
+    private static final int REQUEST_ENABLE_BT = 2;
+
+    /** The use of location manager and bluetooth below are simply to simulate an app that
+     *  tries to use them, so we can verify whether permissions are granted and accessible.
+     * */
+    public void testRunBluetoothAndFineLocation()
+    {
+        LocationManager locationManager = (LocationManager)getInstrumentation().getContext(
+                ).getSystemService(Context.LOCATION_SERVICE);
+        locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0,
+                new LocationListener() {
+                        public void onLocationChanged(Location location) {}
+                        public void onProviderDisabled(String provider) {}
+                        public void onProviderEnabled(String provider) {}
+                        public void onStatusChanged(String provider, int status, Bundle extras) {}
+                }
+        );
+        BluetoothAdapter mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+
+        if ((mBluetoothAdapter != null) && (!mBluetoothAdapter.isEnabled())) {
+            mBluetoothAdapter.getName();
+        }
+        fail("this app was signed by a different cert and should crash/fail to run by now");
+    }
+}
diff --git a/core/tests/hosttests/test-apps/ExternalSharedPermsFL/Android.mk b/core/tests/hosttests/test-apps/ExternalSharedPermsFL/Android.mk
new file mode 100644
index 0000000..8154862
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalSharedPermsFL/Android.mk
@@ -0,0 +1,27 @@
+# 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.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_SDK_VERSION := current
+
+LOCAL_PACKAGE_NAME := ExternalSharedPermsFLTestApp
+
+include $(BUILD_PACKAGE)
diff --git a/core/tests/hosttests/test-apps/ExternalSharedPermsFL/AndroidManifest.xml b/core/tests/hosttests/test-apps/ExternalSharedPermsFL/AndroidManifest.xml
new file mode 100644
index 0000000..15cc912
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalSharedPermsFL/AndroidManifest.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+       package="com.android.framework.externalsharedpermsfltestapp"
+       android:installLocation="preferExternal"
+       android:versionCode="1"
+       android:versionName="1.0"
+       android:sharedUserId="com.android.framework.externalsharedpermstestapp">
+
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+
+    <application>
+        <uses-library android:name="android.test.runner" />
+    </application>
+
+    <instrumentation android:name="android.test.InstrumentationTestRunner"
+                     android:targetPackage="com.android.framework.externalsharedpermsfltestapp"
+                     android:label="Test for instrumentation with an app granted FINE_LOCATION permissions" />
+</manifest>
+
+
diff --git a/core/tests/hosttests/test-apps/ExternalSharedPermsFL/src/com/android/framework/externalsharedpermsfltestapp/ExternalSharedPermsFLTest.java b/core/tests/hosttests/test-apps/ExternalSharedPermsFL/src/com/android/framework/externalsharedpermsfltestapp/ExternalSharedPermsFLTest.java
new file mode 100644
index 0000000..307034e
--- /dev/null
+++ b/core/tests/hosttests/test-apps/ExternalSharedPermsFL/src/com/android/framework/externalsharedpermsfltestapp/ExternalSharedPermsFLTest.java
@@ -0,0 +1,44 @@
+/*
+ * 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 com.android.framework.externalsharedpermsfltestapp;
+
+import android.content.Context;
+import android.os.Bundle;
+import android.location.Location;
+import android.location.LocationListener;
+import android.location.LocationManager;
+
+import android.test.InstrumentationTestCase;
+
+public class ExternalSharedPermsFLTest extends InstrumentationTestCase
+{
+    /** The use of location manager below is simply to simulate an app that
+     *  tries to use it, so we can verify whether permissions are granted and accessible.
+     * */
+    public void testRunFineLocation()
+    {
+        LocationManager locationManager = (LocationManager)getInstrumentation().getContext(
+                ).getSystemService(Context.LOCATION_SERVICE);
+        locationManager.requestLocationUpdates(LocationManager.GPS_PROVIDER, 0, 0,
+                new LocationListener() {
+                        public void onLocationChanged(Location location) {}
+                        public void onProviderDisabled(String provider) {}
+                        public void onProviderEnabled(String provider) {}
+                        public void onStatusChanged(String provider, int status, Bundle extras) {}
+                }
+        );
+    }
+}
diff --git a/core/tests/hosttests/test-apps/NoLocVersionedTestApp_v1/Android.mk b/core/tests/hosttests/test-apps/NoLocVersionedTestApp_v1/Android.mk
new file mode 100644
index 0000000..36413ee
--- /dev/null
+++ b/core/tests/hosttests/test-apps/NoLocVersionedTestApp_v1/Android.mk
@@ -0,0 +1,27 @@
+# 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.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_SDK_VERSION := current
+
+LOCAL_PACKAGE_NAME := NoLocVersionedTestApp_v1
+
+include $(BUILD_PACKAGE)
diff --git a/core/tests/hosttests/test-apps/NoLocVersionedTestApp_v1/AndroidManifest.xml b/core/tests/hosttests/test-apps/NoLocVersionedTestApp_v1/AndroidManifest.xml
new file mode 100644
index 0000000..c98f1c2
--- /dev/null
+++ b/core/tests/hosttests/test-apps/NoLocVersionedTestApp_v1/AndroidManifest.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+       package="com.android.framework.nolocversionedtestapp"
+       android:versionCode="1"
+       android:versionName="1.0">
+
+    <application android:label="NoLocVersionedTestApp_v1"/>
+
+</manifest>
diff --git a/core/tests/hosttests/test-apps/NoLocVersionedTestApp_v1/src/com/android/framework/nolocversionedtestapp/NoLocVersionedTestAppActivity.java b/core/tests/hosttests/test-apps/NoLocVersionedTestApp_v1/src/com/android/framework/nolocversionedtestapp/NoLocVersionedTestAppActivity.java
new file mode 100644
index 0000000..0540e5a
--- /dev/null
+++ b/core/tests/hosttests/test-apps/NoLocVersionedTestApp_v1/src/com/android/framework/nolocversionedtestapp/NoLocVersionedTestAppActivity.java
@@ -0,0 +1,26 @@
+/*
+ * 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 com.android.framework.nolocversionedtestapp;
+
+import android.app.Activity;
+import android.os.Bundle;
+
+/**
+ * Empty activity, not needed for this test
+ */
+public class NoLocVersionedTestAppActivity extends Activity {
+
+}
diff --git a/core/tests/hosttests/test-apps/NoLocVersionedTestApp_v2/Android.mk b/core/tests/hosttests/test-apps/NoLocVersionedTestApp_v2/Android.mk
new file mode 100644
index 0000000..27d03b0
--- /dev/null
+++ b/core/tests/hosttests/test-apps/NoLocVersionedTestApp_v2/Android.mk
@@ -0,0 +1,27 @@
+# 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.
+
+LOCAL_PATH:= $(call my-dir)
+
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_SRC_FILES := $(call all-java-files-under, src)
+
+LOCAL_SDK_VERSION := current
+
+LOCAL_PACKAGE_NAME := NoLocVersionedTestApp_v2
+
+include $(BUILD_PACKAGE)
diff --git a/core/tests/hosttests/test-apps/NoLocVersionedTestApp_v2/AndroidManifest.xml b/core/tests/hosttests/test-apps/NoLocVersionedTestApp_v2/AndroidManifest.xml
new file mode 100644
index 0000000..1af1e68
--- /dev/null
+++ b/core/tests/hosttests/test-apps/NoLocVersionedTestApp_v2/AndroidManifest.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+       package="com.android.framework.nolocversionedtestapp"
+       android:versionCode="2"
+       android:versionName="2.0">
+
+    <application android:label="NoLocVersionedTestApp_v2"/>
+
+</manifest>
diff --git a/core/tests/hosttests/test-apps/NoLocVersionedTestApp_v2/src/com/android/framework/nolocversionedtestapp/NoLocVersionedTestAppActivity.java b/core/tests/hosttests/test-apps/NoLocVersionedTestApp_v2/src/com/android/framework/nolocversionedtestapp/NoLocVersionedTestAppActivity.java
new file mode 100644
index 0000000..0540e5a
--- /dev/null
+++ b/core/tests/hosttests/test-apps/NoLocVersionedTestApp_v2/src/com/android/framework/nolocversionedtestapp/NoLocVersionedTestAppActivity.java
@@ -0,0 +1,26 @@
+/*
+ * 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 com.android.framework.nolocversionedtestapp;
+
+import android.app.Activity;
+import android.os.Bundle;
+
+/**
+ * Empty activity, not needed for this test
+ */
+public class NoLocVersionedTestAppActivity extends Activity {
+
+}