Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

am f541c62b: Merge "Adding a few host-based stress tests for Apps on SD." into froyo

Browse Source 
Merge commit 'f541c62b2649a4b5641df77cda3f409e9ceeb0a2' into froyo-plus-aosp

* commit 'f541c62b2649a4b5641df77cda3f409e9ceeb0a2':
  Adding a few host-based stress tests for Apps on SD.
This commit is contained in:
Neal Nguyen
2010-05-06 12:36:01 -07:00
committed by Android Git Automerger
parent 9dfc697163 f541c62b26
commit e96e235865
36 changed files with 2486 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files

413
core/tests/hosttests/src/android/content/pm/PackageManagerHostTestUtils.java
View File

@@ -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
@@ -89,6 +115,30 @@ public class PackageManagerHostTestUtils extends Assert {
return SDCARD_APP_PATH;
}
/**
* 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
@@ -102,17 +152,47 @@ 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.
*
@@ -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.
@@ -173,13 +253,24 @@ public class PackageManagerHostTestUtils extends Assert {
return doesRemoteFileExistContainingString(SDCARD_APP_PATH, packageName);
}
/**
* 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
@@ -193,20 +284,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}
*/
@@ -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;
}
}
}

732
core/tests/hosttests/src/android/content/pm/PackageManagerHostTests.java
View File

@@ -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,35 +181,346 @@ 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 {
if (expectedLocation == PackageManagerHostTestUtils.InstallLocation.DEVICE) {
mPMHostUtils.installAppAndVerifyExistsOnDevice(
getTestAppFilePath(apkName), pkgName, false);
}
else {
mPMHostUtils.installAppAndVerifyExistsOnSDCard(
getTestAppFilePath(apkName), pkgName, false);
}
}
/**
* Installs the Auto app using the preferred device install location specified,
* and verifies it was installed on the device.
* <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 {
mPMHostUtils.installAppAndVerifyExistsOnDevice(
getTestAppFilePath(AUTO_LOC_APK), AUTO_LOC_PKG, false);
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 testInstallAppInternalLoc() throws IOException, InterruptedException {
Log.i(LOG_TAG, "Test an app with installLocation=internalOnly gets installed on device");
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 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 {
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 installAppExternalLoc(PackageManagerHostTestUtils.InstallLocPreference preference,
PackageManagerHostTestUtils.InstallLocation expectedLocation)
throws IOException, InterruptedException {
PackageManagerHostTestUtils.InstallLocPreference savedPref =
PackageManagerHostTestUtils.InstallLocPreference.AUTO;
try {
savedPref = mPMHostUtils.getDevicePreferredInstallLocation();
mPMHostUtils.setDevicePreferredInstallLocation(preference);
doStandardInstall(EXTERNAL_LOC_APK, EXTERNAL_LOC_PKG, expectedLocation);
}
// cleanup test app
finally {
mPMHostUtils.setDevicePreferredInstallLocation(savedPref);
mPMHostUtils.uninstallApp(EXTERNAL_LOC_PKG);
}
}
/**
* Regression test to verify that an app with its manifest set to installLocation=preferExternal
* will install the app to the device when device's preference is auto.
* <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
@@ -176,21 +530,65 @@ public class PackageManagerHostTests extends DeviceTestCase {
}
/**
* Regression test to verify that an app with its manifest set to installLocation=preferExternal
* will install the app to the SD card.
* 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 testInstallAppExternalLoc() throws IOException, InterruptedException {
Log.i(LOG_TAG, "Test an app with installLocation=preferExternal gets installed on SD Card");
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.installAppAndVerifyExistsOnSDCard(
getTestAppFilePath(EXTERNAL_LOC_APK), EXTERNAL_LOC_PKG, false);
mPMHostUtils.installFwdLockedAppAndVerifyExists(
getTestAppFilePath(INTERNAL_LOC_APK), INTERNAL_LOC_PKG, false);
}
// cleanup test app
finally {
mPMHostUtils.uninstallApp(EXTERNAL_LOC_PKG);
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);
}
}
@@ -199,6 +597,8 @@ public class PackageManagerHostTests extends DeviceTestCase {
* 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()
@@ -248,12 +650,39 @@ 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);
}
}
}

286
core/tests/hosttests/src/android/content/pm/PackageManagerStressHostTests.java Normal file
View File

@@ -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));
}
}
}
}

27
core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v1/Android.mk Normal file
View File

@@ -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)

24
core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v1/AndroidManifest.xml Normal file
View File

@@ -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>

26
core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v1/src/com/android/framework/autolocversionedtestapp/AutoLocVersionedTestAppActivity.java Normal file
View File

@@ -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 {
}

27
core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v2/Android.mk Normal file
View File

@@ -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)

24
core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v2/AndroidManifest.xml Normal file
View File

@@ -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>

26
core/tests/hosttests/test-apps/AutoLocVersionedTestApp_v2/src/com/android/framework/autolocversionedtestapp/AutoLocVersionedTestAppActivity.java Normal file
View File

@@ -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 {
}

27
core/tests/hosttests/test-apps/ExternalLocAllPermsTestApp/Android.mk Normal file
View File

@@ -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)

138
core/tests/hosttests/test-apps/ExternalLocAllPermsTestApp/AndroidManifest.xml Normal file
View File

@@ -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>

31
core/tests/hosttests/test-apps/ExternalLocAllPermsTestApp/src/com/android/framework/externallocallpermstestapp/ExternalLocAllPermsTest.java Normal file
View File

@@ -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() {
}
}

27
core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v1/Android.mk Normal file
View File

@@ -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)

24
core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v1/AndroidManifest.xml Normal file
View File

@@ -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>

26
core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v1/src/com/android/framework/externallocversionedtestapp/ExternalLocVersionedTestAppActivity.java Normal file
View File

@@ -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 {
}

27
core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v2/Android.mk Normal file
View File

@@ -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)

24
core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v2/AndroidManifest.xml Normal file
View File

@@ -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>

26
core/tests/hosttests/test-apps/ExternalLocVersionedTestApp_v2/src/com/android/framework/externallocversionedtestapp/ExternalLocVersionedTestAppActivity.java Normal file
View File

@@ -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 {
}

27
core/tests/hosttests/test-apps/ExternalSharedPerms/Android.mk Normal file
View File

@@ -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)

32
core/tests/hosttests/test-apps/ExternalSharedPerms/AndroidManifest.xml Normal file
View File

@@ -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>

54
core/tests/hosttests/test-apps/ExternalSharedPerms/src/com/android/framework/externalsharedpermstestapp/ExternalSharedPermsTest.java Normal file
View File

@@ -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();
}
}
}

27
core/tests/hosttests/test-apps/ExternalSharedPermsBT/Android.mk Normal file
View File

@@ -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)

35
core/tests/hosttests/test-apps/ExternalSharedPermsBT/AndroidManifest.xml Normal file
View File

@@ -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>

38
core/tests/hosttests/test-apps/ExternalSharedPermsBT/src/com/android/framework/externalsharedpermsbttestapp/ExternalSharedPermsBTTest.java Normal file
View File

@@ -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();
}
}
}

29
core/tests/hosttests/test-apps/ExternalSharedPermsDiffKey/Android.mk Normal file
View File

@@ -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)

32
core/tests/hosttests/test-apps/ExternalSharedPermsDiffKey/AndroidManifest.xml Normal file
View File

@@ -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>

53
core/tests/hosttests/test-apps/ExternalSharedPermsDiffKey/src/com/android/framework/externalsharedpermsdiffkeytestapp/ExternalSharedPermsDiffKeyTest.java Normal file
View File

@@ -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");
}
}

27
core/tests/hosttests/test-apps/ExternalSharedPermsFL/Android.mk Normal file
View File

@@ -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)

34
core/tests/hosttests/test-apps/ExternalSharedPermsFL/AndroidManifest.xml Normal file
View File

@@ -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>

44
core/tests/hosttests/test-apps/ExternalSharedPermsFL/src/com/android/framework/externalsharedpermsfltestapp/ExternalSharedPermsFLTest.java Normal file
View File

@@ -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) {}
}
);
}
}

27
core/tests/hosttests/test-apps/NoLocVersionedTestApp_v1/Android.mk Normal file
View File

@@ -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)

23
core/tests/hosttests/test-apps/NoLocVersionedTestApp_v1/AndroidManifest.xml Normal file
View File

@@ -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>

26
core/tests/hosttests/test-apps/NoLocVersionedTestApp_v1/src/com/android/framework/nolocversionedtestapp/NoLocVersionedTestAppActivity.java Normal file
View File

@@ -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 {
}

27
core/tests/hosttests/test-apps/NoLocVersionedTestApp_v2/Android.mk Normal file
View File

@@ -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)

23
core/tests/hosttests/test-apps/NoLocVersionedTestApp_v2/AndroidManifest.xml Normal file
View File

@@ -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>

26
core/tests/hosttests/test-apps/NoLocVersionedTestApp_v2/src/com/android/framework/nolocversionedtestapp/NoLocVersionedTestAppActivity.java Normal file
View File

@@ -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 {
}