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

Merge "Clean up host tests that have been moved to TF."

Browse Source
This commit is contained in:
Tsu Chiang Chuang
2012-06-14 12:26:50 -07:00
committed by Android (Google) Code Review
parent 7e6aea713e 723118c9e1
commit e446e6c9fd
6 changed files with 0 additions and 2640 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
core/tests/hosttests/Android.mk
View File

@@ -16,17 +16,5 @@ LOCAL_PATH := $(call my-dir)
include $(CLEAR_VARS)
#LOCAL_TEST_TYPE := hostSideOnly
# Only compile source java files in this apk.
LOCAL_SRC_FILES := $(call all-java-files-under, src)
LOCAL_MODULE := FrameworkCoreHostTests
LOCAL_JAVA_LIBRARIES := hosttestlib ddmlib-prebuilt junit
include $(BUILD_HOST_JAVA_LIBRARY)
# Build the test APKs using their own makefiles
include $(call all-makefiles-under,$(LOCAL_PATH))

6
core/tests/hosttests/README
View File

@@ -1,6 +0,0 @@
This dir contains tests which run on a host machine, and test aspects of
package install etc via adb.
To run, do:
runtest framework-core-host

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

@@ -1,891 +0,0 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.content.pm;
import com.android.ddmlib.AdbCommandRejectedException;
import com.android.ddmlib.AndroidDebugBridge;
import com.android.ddmlib.IDevice;
import com.android.ddmlib.IShellOutputReceiver;
import com.android.ddmlib.InstallException;
import com.android.ddmlib.Log;
import com.android.ddmlib.MultiLineReceiver;
import com.android.ddmlib.ShellCommandUnresponsiveException;
import com.android.ddmlib.SyncException;
import com.android.ddmlib.TimeoutException;
import com.android.ddmlib.SyncService.ISyncProgressMonitor;
import com.android.ddmlib.testrunner.ITestRunListener;
import com.android.ddmlib.testrunner.RemoteAndroidTestRunner;
import com.android.ddmlib.testrunner.TestIdentifier;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StringReader;
import java.lang.Runtime;
import java.lang.Process;
import java.util.Hashtable;
import java.util.Map;
import java.util.Map.Entry;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import junit.framework.Assert;
/**
* Set of tests that verify host side install cases
*/
public class PackageManagerHostTestUtils extends Assert {
private static final String LOG_TAG = "PackageManagerHostTests";
private IDevice mDevice = null;
// TODO: get this value from Android Environment instead of hardcoding
private static final String APP_PRIVATE_PATH = "/data/app-private/";
private static final String DEVICE_APP_PATH = "/data/app/";
private static final String SDCARD_APP_PATH = "/mnt/secure/asec/";
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
* @param the device to use when performing operations
*/
public PackageManagerHostTestUtils(IDevice device)
{
mDevice = device;
}
/**
* Disable default constructor
*/
private PackageManagerHostTestUtils() {}
/**
* Returns the path on the device of forward-locked apps.
*
* @return path of forward-locked apps on the device
*/
public static String getAppPrivatePath() {
return APP_PRIVATE_PATH;
}
/**
* Returns the path on the device of normal apps.
*
* @return path of forward-locked apps on the device
*/
public static String getDeviceAppPath() {
return DEVICE_APP_PATH;
}
/**
* Returns the path of apps installed on the SD card.
*
* @return path of forward-locked apps on the device
*/
public static String getSDCardAppPath() {
return SDCARD_APP_PATH;
}
/**
* Helper method to run tests and return the listener that collected the results.
*
* For the optional params, pass null to use the default values.
* @param pkgName Android application package for tests
* @param className (optional) The class containing the method to test
* @param methodName (optional) The method in the class of which to test
* @param runnerName (optional) The name of the TestRunner of the test on the device to be run
* @param params (optional) Any additional parameters to pass into the Test Runner
* @throws TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
* @throws IOException if connection to device was lost.
* @return the {@link CollectingTestRunListener}
*/
private CollectingTestRunListener doRunTests(String pkgName, String className,
String methodName, String runnerName, Map<String, String> params) throws IOException,
TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException {
RemoteAndroidTestRunner testRunner = new RemoteAndroidTestRunner(pkgName, runnerName,
mDevice);
if (className != null && methodName != null) {
testRunner.setMethodName(className, methodName);
}
// Add in any additional args to pass into the test
if (params != null) {
for (Entry<String, String> argPair : params.entrySet()) {
testRunner.addInstrumentationArg(argPair.getKey(), argPair.getValue());
}
}
CollectingTestRunListener listener = new CollectingTestRunListener();
try {
testRunner.run(listener);
} catch (IOException ioe) {
Log.w(LOG_TAG, "encountered IOException " + ioe);
}
return listener;
}
/**
* Runs the specified packages tests, and returns whether all tests passed or not.
*
* @param pkgName Android application package for tests
* @param className The class containing the method to test
* @param methodName The method in the class of which to test
* @param runnerName The name of the TestRunner of the test on the device to be run
* @param params Any additional parameters to pass into the Test Runner
* @return true if test passed, false otherwise.
*/
public boolean runDeviceTestsDidAllTestsPass(String pkgName, String className,
String methodName, String runnerName, Map<String, String> params) throws IOException,
TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException {
CollectingTestRunListener listener = doRunTests(pkgName, className, methodName,
runnerName, params);
return listener.didAllTestsPass();
}
/**
* Runs the specified packages tests, and returns whether all tests passed or not.
*
* @param pkgName Android application package for tests
* @throws TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
* @throws IOException if connection to device was lost.
* @return true if every test passed, false otherwise.
*/
public boolean runDeviceTestsDidAllTestsPass(String pkgName) throws IOException,
TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException {
CollectingTestRunListener listener = doRunTests(pkgName, null, null, null, null);
return listener.didAllTestsPass();
}
/**
* Helper method to push a file to device
* @param apkAppPrivatePath
* @throws TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws IOException if connection to device was lost.
* @throws SyncException if the sync failed for another reason.
*/
public void pushFile(final String localFilePath, final String destFilePath)
throws IOException, SyncException, TimeoutException, AdbCommandRejectedException {
mDevice.getSyncService().pushFile(localFilePath,
destFilePath, new NullSyncProgressMonitor());
}
/**
* 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 if connection to device was lost.
* @throws InstallException if the install failed
*/
public void installFile(final String localFilePath, final boolean replace) throws IOException,
InstallException {
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 if connection to device was lost.
* @throws InstallException if the install failed
*/
public String installFileFail(final String localFilePath, final boolean replace)
throws IOException, InstallException {
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 TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
* @throws IOException if connection to device was lost.
* @throws SyncException if the sync failed for another reason.
* @throws InstallException if the install failed.
*/
public String installFileForwardLocked(final String localFilePath, final boolean replace)
throws IOException, SyncException, TimeoutException, AdbCommandRejectedException,
ShellCommandUnresponsiveException, InstallException {
String remoteFilePath = mDevice.syncPackageToDevice(localFilePath);
InstallReceiver receiver = new InstallReceiver();
String cmd = String.format(replace ? "pm install -r -l \"%1$s\"" :
"pm install -l \"%1$s\"", remoteFilePath);
mDevice.executeShellCommand(cmd, receiver);
mDevice.removeRemotePackage(remoteFilePath);
return receiver.getErrorMessage();
}
/**
* Helper method to determine if file on device exists.
*
* @param destPath the absolute path of file on device to check
* @return <code>true</code> if file exists, <code>false</code> otherwise.
* @throws TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
* @throws IOException if connection to device was lost.
*/
public boolean doesRemoteFileExist(String destPath) throws IOException, TimeoutException,
AdbCommandRejectedException, ShellCommandUnresponsiveException {
String lsGrep = executeShellCommand(String.format("ls %s", destPath));
return !lsGrep.contains("No such file or directory");
}
/**
* Helper method to determine if file exists on the device containing a given string.
*
* @param destPath the absolute path of the file
* @return <code>true</code> if file exists containing given string,
* <code>false</code> otherwise.
* @throws TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
* @throws IOException if connection to device was lost.
*/
public boolean doesRemoteFileExistContainingString(String destPath, String searchString)
throws IOException, TimeoutException, AdbCommandRejectedException,
ShellCommandUnresponsiveException {
String lsResult = executeShellCommand(String.format("ls %s", destPath));
return lsResult.contains(searchString);
}
/**
* Helper method to determine if package on device exists.
*
* @param packageName the Android manifest package to check.
* @return <code>true</code> if package exists, <code>false</code> otherwise
* @throws TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
* @throws IOException if connection to device was lost.
*/
public boolean doesPackageExist(String packageName) throws IOException, TimeoutException,
AdbCommandRejectedException, ShellCommandUnresponsiveException {
String pkgGrep = executeShellCommand(String.format("pm path %s", packageName));
return pkgGrep.contains("package:");
}
/**
* 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 TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
* @throws IOException if connection to device was lost.
*/
public boolean doesAppExistOnDevice(String packageName) throws IOException, TimeoutException,
AdbCommandRejectedException, ShellCommandUnresponsiveException {
return doesRemoteFileExistContainingString(DEVICE_APP_PATH, packageName);
}
/**
* 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.
* @throws TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
* @throws IOException if connection to device was lost.
*/
public boolean doesAppExistOnSDCard(String packageName) throws IOException, TimeoutException,
AdbCommandRejectedException, ShellCommandUnresponsiveException {
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 TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
* @throws IOException if connection to device was lost.
*/
public boolean doesAppExistAsForwardLocked(String packageName) throws IOException,
TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException {
return doesRemoteFileExistContainingString(APP_PRIVATE_PATH, packageName);
}
/**
* Waits for device's package manager to respond.
*
* @throws InterruptedException
* @throws TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
* @throws IOException if connection to device was lost.
*/
public void waitForPackageManager() throws InterruptedException, IOException, TimeoutException,
AdbCommandRejectedException, ShellCommandUnresponsiveException {
Log.i(LOG_TAG, "waiting for device");
int currentWaitTime = 0;
// poll the package manager until it returns something for android
while (!doesPackageExist("android")) {
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();
}
}
}
/**
* 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 TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
* @throws IOException if connection to device was lost.
*/
public void waitForApp(String packageName) throws InterruptedException, IOException,
TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException {
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 TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
* @throws IOException if connection to device was lost.
*/
public String executeShellCommand(String command) throws IOException, TimeoutException,
AdbCommandRejectedException, ShellCommandUnresponsiveException {
Log.i(LOG_TAG, String.format("adb shell %s", command));
CollectingOutputReceiver receiver = new CollectingOutputReceiver();
mDevice.executeShellCommand(command, receiver);
String output = receiver.getOutput();
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 TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
* @throws IOException if connection to device was lost.
*/
public void runAdbRoot() throws IOException, InterruptedException, TimeoutException,
AdbCommandRejectedException, ShellCommandUnresponsiveException {
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 InterruptedException
* @throws TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
* @throws IOException if connection to device was lost.
*/
public void rebootDevice() throws IOException, InterruptedException, TimeoutException,
AdbCommandRejectedException, ShellCommandUnresponsiveException {
String command = "reboot"; // no need for -s since mDevice is already tied to a device
Log.i(LOG_TAG, command);
CollectingOutputReceiver receiver = new CollectingOutputReceiver();
mDevice.executeShellCommand(command, receiver);
String output = receiver.getOutput();
Log.i(LOG_TAG, String.format("Result: %s", output));
waitForDeviceToComeOnline(); // wait for device to come online
runAdbRoot();
}
/**
* A {@link IShellOutputReceiver} which collects the whole shell output into one {@link String}
*/
private class CollectingOutputReceiver extends MultiLineReceiver {
private StringBuffer mOutputBuffer = new StringBuffer();
public String getOutput() {
return mOutputBuffer.toString();
}
@Override
public void processNewLines(String[] lines) {
for (String line: lines) {
mOutputBuffer.append(line);
mOutputBuffer.append("\n");
}
}
public boolean isCancelled() {
return false;
}
}
private class NullSyncProgressMonitor implements ISyncProgressMonitor {
public void advance(int work) {
// ignore
}
public boolean isCanceled() {
// ignore
return false;
}
public void start(int totalWork) {
// ignore
}
public void startSubTask(String name) {
// ignore
}
public void stop() {
// ignore
}
}
// For collecting results from running device tests
public static class CollectingTestRunListener implements ITestRunListener {
private boolean mAllTestsPassed = true;
private String mTestRunErrorMessage = null;
public void testEnded(TestIdentifier test, Map<String, String> metrics) {
// 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, Map<String, String> resultBundle) {
// ignore
}
public void testRunFailed(String errorMessage) {
Log.w(LOG_TAG, String.format("test run failed: %s", errorMessage));
mAllTestsPassed = false;
mTestRunErrorMessage = errorMessage;
}
public void testRunStarted(String runName, 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.
* <p/>
* Assumes adb is running as root in device under test.
*
* @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 InterruptedException if the thread was interrupted
* @throws TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
* @throws IOException if connection to device was lost.
* @throws InstallException if the install failed.
*/
public void installAppAndVerifyExistsOnSDCard(String apkPath, String pkgName, boolean overwrite)
throws IOException, InterruptedException, InstallException, TimeoutException,
AdbCommandRejectedException, ShellCommandUnresponsiveException {
// 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));
}
installFile(apkPath, overwrite);
assertTrue(doesAppExistOnSDCard(pkgName));
assertFalse(doesAppExistOnDevice(pkgName));
waitForPackageManager();
// grep for package to make sure it is installed
assertTrue(doesPackageExist(pkgName));
}
/**
* Helper method for installing an app to wherever is specified in its manifest, and
* then verifying the app was installed onto device.
* <p/>
* Assumes adb is running as root in device under test.
*
* @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 InterruptedException if the thread was interrupted
* @throws TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
* @throws IOException if connection to device was lost.
* @throws InstallException if the install failed.
*/
public void installAppAndVerifyExistsOnDevice(String apkPath, String pkgName, boolean overwrite)
throws IOException, InterruptedException, InstallException, TimeoutException,
AdbCommandRejectedException, ShellCommandUnresponsiveException {
// 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));
}
installFile(apkPath, overwrite);
assertFalse(doesAppExistOnSDCard(pkgName));
assertTrue(doesAppExistOnDevice(pkgName));
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.
* <p/>
* Assumes adb is running as root in device under test.
*
* @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 InterruptedException if the thread was interrupted
* @throws IOException if connection to device was lost.
* @throws InstallException if the install failed.
* @throws TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
*/
public void installFwdLockedAppAndVerifyExists(String apkPath,
String pkgName, boolean overwrite) throws IOException, InterruptedException,
InstallException, SyncException, TimeoutException, AdbCommandRejectedException,
ShellCommandUnresponsiveException {
// 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));
}
/**
* Helper method for uninstalling an app.
* <p/>
* Assumes adb is running as root in device under test.
*
* @param pkgName package name to uninstall
* @throws InterruptedException if the thread was interrupted
* @throws TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
* @throws IOException if connection to device was lost.
* @throws InstallException if the uninstall failed.
*/
public void uninstallApp(String pkgName) throws IOException, InterruptedException,
InstallException, TimeoutException, AdbCommandRejectedException,
ShellCommandUnresponsiveException {
mDevice.uninstallPackage(pkgName);
// make sure its not installed anymore
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.
* <p/>
* Assumes adb is running as root in device under test.
*
* @throws TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
* @throws IOException if connection to device was lost.
* @throws InstallException if the uninstall failed.
*/
public void wipeNonSystemApps() throws IOException, TimeoutException,
AdbCommandRejectedException, ShellCommandUnresponsiveException, InstallException {
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.
* @throws TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
* @throws IOException if connection to device was lost.
*/
public void setDevicePreferredInstallLocation(InstallLocPreference pref) throws IOException,
TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException {
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.
* @throws TimeoutException in case of a timeout on the connection.
* @throws AdbCommandRejectedException if adb rejects the command
* @throws ShellCommandUnresponsiveException if the device did not output anything for
* a period longer than the max time to output.
* @throws IOException if connection to device was lost.
*/
public InstallLocPreference getDevicePreferredInstallLocation() throws IOException,
TimeoutException, AdbCommandRejectedException, ShellCommandUnresponsiveException {
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;
}
}
}

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

File diff suppressed because it is too large Load Diff

297
core/tests/hosttests/src/android/content/pm/PackageManagerStressHostTests.java
View File

@@ -1,297 +0,0 @@
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.content.pm;
import com.android.ddmlib.AdbCommandRejectedException;
import com.android.ddmlib.InstallException;
import com.android.ddmlib.Log;
import com.android.ddmlib.ShellCommandUnresponsiveException;
import com.android.ddmlib.TimeoutException;
import com.android.hosttest.DeviceTestCase;
import com.android.hosttest.DeviceTestSuite;
import java.io.File;
import java.io.IOException;
import junit.framework.Test;
/**
* Set of tests that verify host side 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,
InstallException, TimeoutException, AdbCommandRejectedException,
ShellCommandUnresponsiveException {
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,
InstallException, TimeoutException, AdbCommandRejectedException,
ShellCommandUnresponsiveException {
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,
InstallException, TimeoutException, AdbCommandRejectedException,
ShellCommandUnresponsiveException {
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,
InstallException, TimeoutException, AdbCommandRejectedException,
ShellCommandUnresponsiveException {
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));
}
}
}
}

210
core/tests/hosttests/src/android/net/DownloadManagerHostTests.java
View File

@@ -1,210 +0,0 @@
/*
* 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.net;
import android.content.pm.PackageManagerHostTestUtils;
import com.android.ddmlib.Log;
import com.android.hosttest.DeviceTestCase;
import com.android.hosttest.DeviceTestSuite;
import java.io.File;
import java.util.Hashtable;
import junit.framework.Test;
/**
* Host-based tests of the DownloadManager API. (Uses a device-based app to actually invoke the
* various tests.)
*/
public class DownloadManagerHostTests extends DeviceTestCase {
protected PackageManagerHostTestUtils mPMUtils = null;
private static final String LOG_TAG = "android.net.DownloadManagerHostTests";
private static final String FILE_DOWNLOAD_APK = "DownloadManagerTestApp.apk";
private static final String FILE_DOWNLOAD_PKG = "com.android.frameworks.downloadmanagertests";
private static final String FILE_DOWNLOAD_CLASS =
"com.android.frameworks.downloadmanagertests.DownloadManagerTestApp";
private static final String DOWNLOAD_TEST_RUNNER_NAME =
"com.android.frameworks.downloadmanagertests.DownloadManagerTestRunner";
// Extra parameters to pass to the TestRunner
private static final String EXTERNAL_DOWNLOAD_URI_KEY = "external_download_uri";
// Note: External environment variable ANDROID_TEST_EXTERNAL_URI must be set to point to the
// external URI under which the files downloaded by the tests can be found. Note that the Uri
// must be accessible by the device during a test run. Correspondingly,
// ANDROID_TEST_EXTERNAL_LARGE_URI should point to the external URI of the folder containing
// large files.
private static String externalDownloadUriValue = null;
Hashtable<String, String> mExtraParams = null;
public static Test suite() {
return new DeviceTestSuite(DownloadManagerHostTests.class);
}
@Override
protected void setUp() throws Exception {
super.setUp();
// ensure apk path has been set before test is run
assertNotNull(getTestAppPath());
mPMUtils = new PackageManagerHostTestUtils(getDevice());
externalDownloadUriValue = System.getenv("ANDROID_TEST_EXTERNAL_URI");
assertNotNull(externalDownloadUriValue);
mExtraParams = getExtraParams();
}
/**
* Helper function to get extra params that can be used to pass into the helper app.
*/
protected Hashtable<String, String> getExtraParams() {
Hashtable<String, String> extraParams = new Hashtable<String, String>();
extraParams.put(EXTERNAL_DOWNLOAD_URI_KEY, externalDownloadUriValue);
return extraParams;
}
/**
* Tests that a large download over WiFi
* @throws Exception if the test failed at any point
*/
public void testLargeDownloadOverWiFi() throws Exception {
mPMUtils.installAppAndVerifyExistsOnDevice(String.format("%s%s%s", getTestAppPath(),
File.separator, FILE_DOWNLOAD_APK), FILE_DOWNLOAD_PKG, true);
boolean testPassed = mPMUtils.runDeviceTestsDidAllTestsPass(FILE_DOWNLOAD_PKG,
FILE_DOWNLOAD_CLASS, "runLargeDownloadOverWiFi", DOWNLOAD_TEST_RUNNER_NAME,
mExtraParams);
assertTrue("Failed to install large file over WiFi in < 10 minutes!", testPassed);
}
/**
* Spawns a device-based function to initiate a download on the device, reboots the device,
* then waits and verifies the download succeeded.
*
* @throws Exception if the test failed at any point
*/
public void testDownloadManagerSingleReboot() throws Exception {
mPMUtils.installAppAndVerifyExistsOnDevice(String.format("%s%s%s", getTestAppPath(),
File.separator, FILE_DOWNLOAD_APK), FILE_DOWNLOAD_PKG, true);
boolean testPassed = mPMUtils.runDeviceTestsDidAllTestsPass(FILE_DOWNLOAD_PKG,
FILE_DOWNLOAD_CLASS, "initiateDownload", DOWNLOAD_TEST_RUNNER_NAME,
mExtraParams);
assertTrue("Failed to initiate download properly!", testPassed);
mPMUtils.rebootDevice();
testPassed = mPMUtils.runDeviceTestsDidAllTestsPass(FILE_DOWNLOAD_PKG,
FILE_DOWNLOAD_CLASS, "verifyFileDownloadSucceeded", DOWNLOAD_TEST_RUNNER_NAME,
mExtraParams);
assertTrue("Failed to verify initiated download completed properyly!", testPassed);
}
/**
* Spawns a device-based function to initiate a download on the device, reboots the device three
* times (using different intervals), then waits and verifies the download succeeded.
*
* @throws Exception if the test failed at any point
*/
public void testDownloadManagerMultipleReboots() throws Exception {
mPMUtils.installAppAndVerifyExistsOnDevice(String.format("%s%s%s", getTestAppPath(),
File.separator, FILE_DOWNLOAD_APK), FILE_DOWNLOAD_PKG, true);
boolean testPassed = mPMUtils.runDeviceTestsDidAllTestsPass(FILE_DOWNLOAD_PKG,
FILE_DOWNLOAD_CLASS, "initiateDownload", DOWNLOAD_TEST_RUNNER_NAME,
mExtraParams);
assertTrue("Failed to initiate download properly!", testPassed);
Thread.sleep(5000);
// Do 3 random reboots - after 13, 9, and 19 seconds
Log.i(LOG_TAG, "First reboot...");
mPMUtils.rebootDevice();
Thread.sleep(13000);
Log.i(LOG_TAG, "Second reboot...");
mPMUtils.rebootDevice();
Thread.sleep(9000);
Log.i(LOG_TAG, "Third reboot...");
mPMUtils.rebootDevice();
Thread.sleep(19000);
testPassed = mPMUtils.runDeviceTestsDidAllTestsPass(FILE_DOWNLOAD_PKG,
FILE_DOWNLOAD_CLASS, "verifyFileDownloadSucceeded", DOWNLOAD_TEST_RUNNER_NAME,
mExtraParams);
assertTrue("Failed to verify initiated download completed properyly!", testPassed);
}
/**
* Spawns a device-based function to test download while WiFi is enabled/disabled multiple times
* during the download.
*
* @throws Exception if the test failed at any point
*/
public void testDownloadMultipleWiFiEnableDisable() throws Exception {
mPMUtils.installAppAndVerifyExistsOnDevice(String.format("%s%s%s", getTestAppPath(),
File.separator, FILE_DOWNLOAD_APK), FILE_DOWNLOAD_PKG, true);
boolean testPassed = mPMUtils.runDeviceTestsDidAllTestsPass(FILE_DOWNLOAD_PKG,
FILE_DOWNLOAD_CLASS, "runDownloadMultipleWiFiEnableDisable",
DOWNLOAD_TEST_RUNNER_NAME, mExtraParams);
assertTrue(testPassed);
}
/**
* Spawns a device-based function to test switching on/off both airplane mode and WiFi
*
* @throws Exception if the test failed at any point
*/
public void testDownloadMultipleSwitching() throws Exception {
mPMUtils.installAppAndVerifyExistsOnDevice(String.format("%s%s%s", getTestAppPath(),
File.separator, FILE_DOWNLOAD_APK), FILE_DOWNLOAD_PKG, true);
boolean testPassed = mPMUtils.runDeviceTestsDidAllTestsPass(FILE_DOWNLOAD_PKG,
FILE_DOWNLOAD_CLASS, "runDownloadMultipleSwitching",
DOWNLOAD_TEST_RUNNER_NAME, mExtraParams);
assertTrue(testPassed);
}
/**
* Spawns a device-based function to test switching on/off airplane mode multiple times
*
* @throws Exception if the test failed at any point
*/
public void testDownloadMultipleAirplaneModeEnableDisable() throws Exception {
mPMUtils.installAppAndVerifyExistsOnDevice(String.format("%s%s%s", getTestAppPath(),
File.separator, FILE_DOWNLOAD_APK), FILE_DOWNLOAD_PKG, true);
boolean testPassed = mPMUtils.runDeviceTestsDidAllTestsPass(FILE_DOWNLOAD_PKG,
FILE_DOWNLOAD_CLASS, "runDownloadMultipleAirplaneModeEnableDisable",
DOWNLOAD_TEST_RUNNER_NAME, mExtraParams);
assertTrue(testPassed);
}
/**
* Spawns a device-based function to test 15 concurrent downloads of 5,000,000-byte files
*
* @throws Exception if the test failed at any point
*/
public void testDownloadMultipleSimultaneously() throws Exception {
mPMUtils.installAppAndVerifyExistsOnDevice(String.format("%s%s%s", getTestAppPath(),
File.separator, FILE_DOWNLOAD_APK), FILE_DOWNLOAD_PKG, true);
boolean testPassed = mPMUtils.runDeviceTestsDidAllTestsPass(FILE_DOWNLOAD_PKG,
FILE_DOWNLOAD_CLASS, "runDownloadMultipleSimultaneously",
DOWNLOAD_TEST_RUNNER_NAME, mExtraParams);
assertTrue(testPassed);
}
}