PackageManagerTestspublic class PackageManagerTests extends android.test.AndroidTestCase
| Fields Summary |
|---|
| private static final boolean | localLOGV | | public static final String | TAG | | public final long | MAX_WAIT_TIME | | public final long | WAIT_TIME_INCR | | private static final String | SECURE_CONTAINERS_PREFIX | | private static final int | APP_INSTALL_AUTO | | private static final int | APP_INSTALL_DEVICE | | private static final int | APP_INSTALL_SDCARD | | private boolean | mOrigState | | private static final int | INSTALL_LOC_INT | | private static final int | INSTALL_LOC_SD | | private static final int | INSTALL_LOC_ERR | | static final String | PERM_PACKAGE | | static final String | PERM_DEFINED | | static final String | PERM_UNDEFINED | | static final String | PERM_USED | | static final String | PERM_NOTUSED | | static final String[] | BASE_PERMISSIONS_DEFINED | | static final String[] | BASE_PERMISSIONS_UNDEFINED | | static final String[] | BASE_PERMISSIONS_USED | | static final String[] | BASE_PERMISSIONS_NOTUSED | | static final String[] | BASE_PERMISSIONS_SIGUSED | | private int | APP1_UNSIGNED | | private int | APP1_CERT1 | | private int | APP1_CERT2 | | private int | APP1_CERT1_CERT2 | | private int | APP1_CERT3_CERT4 | | private int | APP1_CERT3 | | private int | APP2_UNSIGNED | | private int | APP2_CERT1 | | private int | APP2_CERT2 | | private int | APP2_CERT1_CERT2 | | private int | APP2_CERT3 | | private int | SHARED1_UNSIGNED | | private int | SHARED1_CERT1 | | private int | SHARED1_CERT2 | | private int | SHARED1_CERT1_CERT2 | | private int | SHARED2_UNSIGNED | | private int | SHARED2_CERT1 | | private int | SHARED2_CERT2 | | private int | SHARED2_CERT1_CERT2 |
| Methods Summary |
|---|
| private void | assertDirOwnerGroupPermsIfExists(java.lang.String reason, int uid, int gid, int perms, java.lang.String path)
if (!new File(path).exists()) {
return;
}
final StructStat stat;
try {
stat = Os.lstat(path);
} catch (ErrnoException e) {
throw new AssertionError(reason + "\n" + "Got: " + path + " does not exist");
}
StringBuilder sb = new StringBuilder();
if (!S_ISDIR(stat.st_mode)) {
sb.append("\nExpected type: ");
sb.append(S_IFDIR);
sb.append("\ngot type: ");
sb.append((stat.st_mode & S_IFMT));
}
if (stat.st_uid != uid) {
sb.append("\nExpected owner: ");
sb.append(uid);
sb.append("\nGot owner: ");
sb.append(stat.st_uid);
}
if (stat.st_gid != gid) {
sb.append("\nExpected group: ");
sb.append(gid);
sb.append("\nGot group: ");
sb.append(stat.st_gid);
}
if ((stat.st_mode & ~S_IFMT) != perms) {
sb.append("\nExpected permissions: ");
sb.append(Integer.toOctalString(perms));
sb.append("\nGot permissions: ");
sb.append(Integer.toOctalString(stat.st_mode & ~S_IFMT));
}
if (sb.length() > 0) {
throw new AssertionError(reason + sb.toString());
}
| | private void | assertInstall(PackageParser.Package pkg, int flags, int expInstallLocation)
try {
String pkgName = pkg.packageName;
ApplicationInfo info = getPm().getApplicationInfo(pkgName, 0);
assertNotNull(info);
assertEquals(pkgName, info.packageName);
File dataDir = Environment.getDataDirectory();
String appInstallPath = new File(dataDir, "app").getPath();
String drmInstallPath = new File(dataDir, "app-private").getPath();
File srcDir = new File(info.sourceDir);
String srcPath = srcDir.getParentFile().getParent();
File publicSrcDir = new File(info.publicSourceDir);
String publicSrcPath = publicSrcDir.getParentFile().getParent();
long pkgLen = new File(info.sourceDir).length();
String expectedLibPath = new File(new File(info.sourceDir).getParentFile(), "lib")
.getPath();
int rLoc = getInstallLoc(flags, expInstallLocation, pkgLen);
if (rLoc == INSTALL_LOC_INT) {
if ((flags & PackageManager.INSTALL_FORWARD_LOCK) != 0) {
assertTrue("The application should be installed forward locked",
(info.flags & ApplicationInfo.FLAG_FORWARD_LOCK) != 0);
assertStartsWith("The APK path should point to the ASEC",
SECURE_CONTAINERS_PREFIX, srcPath);
assertStartsWith("The public APK path should point to the ASEC",
SECURE_CONTAINERS_PREFIX, publicSrcPath);
assertStartsWith("The native library path should point to the ASEC",
SECURE_CONTAINERS_PREFIX, info.nativeLibraryDir);
try {
String compatLib = new File(info.dataDir + "/lib").getCanonicalPath();
assertEquals("The compatibility lib directory should be a symbolic link to "
+ info.nativeLibraryDir,
info.nativeLibraryDir, compatLib);
} catch (IOException e) {
fail("compat check: Can't read " + info.dataDir + "/lib");
}
} else {
assertFalse((info.flags & ApplicationInfo.FLAG_FORWARD_LOCK) != 0);
assertEquals(appInstallPath, srcPath);
assertEquals(appInstallPath, publicSrcPath);
assertStartsWith("Native library should point to shared lib directory",
expectedLibPath, info.nativeLibraryDir);
assertDirOwnerGroupPermsIfExists(
"Native library directory should be owned by system:system and 0755",
Process.SYSTEM_UID, Process.SYSTEM_UID,
S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH,
info.nativeLibraryDir);
}
assertFalse((info.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0);
// Make sure the native library dir is not a symlink
final File nativeLibDir = new File(info.nativeLibraryDir);
if (nativeLibDir.exists()) {
try {
assertEquals("Native library dir should not be a symlink",
info.nativeLibraryDir, nativeLibDir.getCanonicalPath());
} catch (IOException e) {
fail("Can't read " + nativeLibDir.getPath());
}
}
} else if (rLoc == INSTALL_LOC_SD) {
if ((flags & PackageManager.INSTALL_FORWARD_LOCK) != 0) {
assertTrue("The application should be installed forward locked",
(info.flags & ApplicationInfo.FLAG_FORWARD_LOCK) != 0);
} else {
assertFalse("The application should not be installed forward locked",
(info.flags & ApplicationInfo.FLAG_FORWARD_LOCK) != 0);
}
assertTrue("Application flags (" + info.flags
+ ") should contain FLAG_EXTERNAL_STORAGE",
(info.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0);
// Might need to check:
// ((info.flags & ApplicationInfo.FLAG_FORWARD_LOCK) != 0)
assertStartsWith("The APK path should point to the ASEC",
SECURE_CONTAINERS_PREFIX, srcPath);
assertStartsWith("The public APK path should point to the ASEC",
SECURE_CONTAINERS_PREFIX, publicSrcPath);
assertStartsWith("The native library path should point to the ASEC",
SECURE_CONTAINERS_PREFIX, info.nativeLibraryDir);
// Make sure the native library in /data/data/<app>/lib is a
// symlink to the ASEC
final File nativeLibSymLink = new File(info.dataDir, "lib");
assertTrue("Native library symlink should exist at " + nativeLibSymLink.getPath(),
nativeLibSymLink.exists());
try {
assertEquals(nativeLibSymLink.getPath() + " should be a symlink to "
+ info.nativeLibraryDir, info.nativeLibraryDir,
nativeLibSymLink.getCanonicalPath());
} catch (IOException e) {
fail("Can't read " + nativeLibSymLink.getPath());
}
} else {
// TODO handle error. Install should have failed.
fail("Install should have failed");
}
} catch (NameNotFoundException e) {
failStr("failed with exception : " + e);
}
| | private void | assertNotInstalled(java.lang.String pkgName)
try {
ApplicationInfo info = getPm().getApplicationInfo(pkgName, 0);
fail(pkgName + " shouldnt be installed");
} catch (NameNotFoundException e) {
}
UserManager um = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
List<UserInfo> users = um.getUsers();
for (UserInfo user : users) {
String dataDir = PackageManager.getDataDirForUser(user.id, pkgName);
assertFalse("Application data directory should not exist: " + dataDir,
new File(dataDir).exists());
}
| | private void | assertPermissions(java.lang.String[] cmds)
final PackageManager pm = getPm();
String pkg = null;
PackageInfo pkgInfo = null;
String mode = PERM_DEFINED;
int i = 0;
while (i < cmds.length) {
String cmd = cmds[i++];
if (cmd == PERM_PACKAGE) {
pkg = cmds[i++];
try {
pkgInfo = pm.getPackageInfo(pkg,
PackageManager.GET_PERMISSIONS
| PackageManager.GET_UNINSTALLED_PACKAGES);
} catch (NameNotFoundException e) {
pkgInfo = null;
}
} else if (cmd == PERM_DEFINED || cmd == PERM_UNDEFINED
|| cmd == PERM_USED || cmd == PERM_NOTUSED) {
mode = cmds[i++];
} else {
if (mode == PERM_DEFINED) {
try {
PermissionInfo pi = pm.getPermissionInfo(cmd, 0);
assertNotNull(pi);
assertEquals(pi.packageName, pkg);
assertEquals(pi.name, cmd);
assertNotNull(pkgInfo);
boolean found = false;
for (int j = 0; j < pkgInfo.permissions.length && !found; j++) {
if (pkgInfo.permissions[j].name.equals(cmd)) {
found = true;
}
}
if (!found) {
fail("Permission not found: " + cmd);
}
} catch (NameNotFoundException e) {
throw new RuntimeException(e);
}
} else if (mode == PERM_UNDEFINED) {
try {
pm.getPermissionInfo(cmd, 0);
throw new RuntimeException("Permission exists: " + cmd);
} catch (NameNotFoundException e) {
}
if (pkgInfo != null) {
boolean found = false;
for (int j = 0; j < pkgInfo.permissions.length && !found; j++) {
if (pkgInfo.permissions[j].name.equals(cmd)) {
found = true;
}
}
if (found) {
fail("Permission still exists: " + cmd);
}
}
} else if (mode == PERM_USED || mode == PERM_NOTUSED) {
boolean found = false;
for (int j = 0; j < pkgInfo.requestedPermissions.length && !found; j++) {
if (pkgInfo.requestedPermissions[j].equals(cmd)) {
found = true;
}
}
if (!found) {
fail("Permission not requested: " + cmd);
}
if (mode == PERM_USED) {
if (pm.checkPermission(cmd, pkg) != PackageManager.PERMISSION_GRANTED) {
fail("Permission not granted: " + cmd);
}
} else {
if (pm.checkPermission(cmd, pkg) != PackageManager.PERMISSION_DENIED) {
fail("Permission granted: " + cmd);
}
}
}
}
}
| | private static void | assertStartsWith(java.lang.String prefix, java.lang.String actual)
assertStartsWith("", prefix, actual);
| | private static void | assertStartsWith(java.lang.String description, java.lang.String prefix, java.lang.String actual)
if (!actual.startsWith(prefix)) {
StringBuilder sb = new StringBuilder(description);
sb.append("\nExpected prefix: ");
sb.append(prefix);
sb.append("\n got: ");
sb.append(actual);
sb.append('\n");
throw new AssertionError(sb.toString());
}
| | private static void | assertUninstalled(ApplicationInfo info)
File nativeLibraryFile = new File(info.nativeLibraryDir);
assertFalse("Native library directory should be erased", nativeLibraryFile.exists());
| | private boolean | checkInt(long pkgLen)
StatFs intStats = new StatFs(Environment.getDataDirectory().getPath());
long intSize = (long) intStats.getBlockCount() * (long) intStats.getBlockSize();
long iSize = (long) intStats.getAvailableBlocks() * (long) intStats.getBlockSize();
// TODO check for thresholds here?
return pkgLen <= iSize;
| | boolean | checkMediaState(java.lang.String desired)
try {
String mPath = Environment.getExternalStorageDirectory().getPath();
String actual = getMs().getVolumeState(mPath);
if (desired.equals(actual)) {
return true;
} else {
return false;
}
} catch (RemoteException e) {
Log.e(TAG, "Exception while checking media state", e);
return false;
}
| | private boolean | checkSd(long pkgLen)
String status = Environment.getExternalStorageState();
if (!status.equals(Environment.MEDIA_MOUNTED)) {
return false;
}
long sdSize = -1;
StatFs sdStats = new StatFs(Environment.getExternalStorageDirectory().getPath());
sdSize = (long) sdStats.getAvailableBlocks() * (long) sdStats.getBlockSize();
// TODO check for thresholds here
return pkgLen <= sdSize;
| | private void | checkSharedSignatures(int apk1, int apk2, boolean cleanUp, boolean fail, int retCode, int expMatchResult)
String apk1Name = "install1.apk";
String apk2Name = "install2.apk";
PackageParser.Package pkg1 = getParsedPackage(apk1Name, apk1);
PackageParser.Package pkg2 = getParsedPackage(apk2Name, apk2);
try {
// Clean up before testing first.
cleanUpInstall(pkg1.packageName);
cleanUpInstall(pkg2.packageName);
installFromRawResource(apk1Name, apk1, 0, false, false, -1,
PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
if (fail) {
installFromRawResource(apk2Name, apk2, 0, false, true, retCode,
PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
} else {
installFromRawResource(apk2Name, apk2, 0, false, false, -1,
PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
int match = mContext.getPackageManager().checkSignatures(pkg1.packageName,
pkg2.packageName);
assertEquals(expMatchResult, match);
}
} finally {
if (cleanUp) {
cleanUpInstall(pkg1.packageName);
cleanUpInstall(pkg2.packageName);
}
}
| | private void | checkSignatures(int apk1, int apk2, int expMatchResult)The following tests are related to testing the checkSignatures api.
checkSharedSignatures(apk1, apk2, true, false, -1, expMatchResult);
| | void | cleanUpInstall(android.content.pm.PackageManagerTests$InstallParams ip)
if (ip == null) {
return;
}
Runtime.getRuntime().gc();
final String packageName = ip.pkg.packageName;
Log.i(TAG, "Deleting package : " + packageName);
ApplicationInfo info = null;
try {
info = getPm().getApplicationInfo(packageName, PackageManager.GET_UNINSTALLED_PACKAGES);
} catch (NameNotFoundException ignored) {
}
DeleteObserver observer = new DeleteObserver(packageName);
getPm().deletePackage(packageName, observer, PackageManager.DELETE_ALL_USERS);
observer.waitForCompletion(MAX_WAIT_TIME);
try {
if (info != null) {
assertUninstalled(info);
}
} finally {
File outFile = new File(ip.pkg.codePath);
if (outFile != null && outFile.exists()) {
outFile.delete();
}
}
| | private void | cleanUpInstall(java.lang.String pkgName)
if (pkgName == null) {
return;
}
Log.i(TAG, "Deleting package : " + pkgName);
try {
ApplicationInfo info = getPm().getApplicationInfo(pkgName,
PackageManager.GET_UNINSTALLED_PACKAGES);
if (info != null) {
DeleteObserver observer = new DeleteObserver(pkgName);
getPm().deletePackage(pkgName, observer, PackageManager.DELETE_ALL_USERS);
observer.waitForCompletion(MAX_WAIT_TIME);
assertUninstalled(info);
}
} catch (NameNotFoundException e) {
}
| | public void | deleteFromRawResource(int iFlags, int dFlags)
InstallParams ip = sampleInstallFromRawResource(iFlags, false);
boolean retainData = ((dFlags & PackageManager.DELETE_KEEP_DATA) != 0);
GenericReceiver receiver = new DeleteReceiver(ip.pkg.packageName);
try {
assertTrue(invokeDeletePackage(ip.pkg.packageName, dFlags, receiver));
ApplicationInfo info = null;
Log.i(TAG, "okay4");
try {
info = getPm().getApplicationInfo(ip.pkg.packageName,
PackageManager.GET_UNINSTALLED_PACKAGES);
} catch (NameNotFoundException e) {
info = null;
}
if (retainData) {
assertNotNull(info);
assertEquals(info.packageName, ip.pkg.packageName);
File file = new File(info.dataDir);
assertTrue(file.exists());
} else {
assertNull(info);
}
} catch (Exception e) {
failStr(e);
} finally {
cleanUpInstall(ip);
}
| | void | failStr(java.lang.String errMsg)
Log.w(TAG, "errMsg=" + errMsg);
fail(errMsg);
| | void | failStr(java.lang.Exception e)
failStr(e.getMessage());
| | private int | getDefaultInstallLoc()
int origDefaultLoc = PackageInfo.INSTALL_LOCATION_AUTO;
try {
origDefaultLoc = Settings.Global.getInt(mContext.getContentResolver(),
Settings.Global.DEFAULT_INSTALL_LOCATION);
} catch (SettingNotFoundException e1) {
}
return origDefaultLoc;
| | private int | getExpectedInstallLocation(int userSetting)
int iloc = PackageInfo.INSTALL_LOCATION_UNSPECIFIED;
boolean enable = getUserSettingSetInstallLocation();
if (enable) {
if (userSetting == PackageHelper.APP_INSTALL_AUTO) {
iloc = PackageInfo.INSTALL_LOCATION_AUTO;
} else if (userSetting == PackageHelper.APP_INSTALL_EXTERNAL) {
iloc = PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL;
} else if (userSetting == PackageHelper.APP_INSTALL_INTERNAL) {
iloc = PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY;
}
}
return iloc;
| | private IPackageManager | getIPm()
IPackageManager ipm = IPackageManager.Stub.asInterface(
ServiceManager.getService("package"));
return ipm;
| | private int | getInstallLoc(int flags, int expInstallLocation, long pkgLen)
// Flags explicitly over ride everything else.
if ((flags & PackageManager.INSTALL_EXTERNAL) != 0) {
return INSTALL_LOC_SD;
} else if ((flags & PackageManager.INSTALL_INTERNAL) != 0) {
return INSTALL_LOC_INT;
}
// Manifest option takes precedence next
if (expInstallLocation == PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL) {
if (checkSd(pkgLen)) {
return INSTALL_LOC_SD;
}
if (checkInt(pkgLen)) {
return INSTALL_LOC_INT;
}
return INSTALL_LOC_ERR;
}
if (expInstallLocation == PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY) {
if (checkInt(pkgLen)) {
return INSTALL_LOC_INT;
}
return INSTALL_LOC_ERR;
}
if (expInstallLocation == PackageInfo.INSTALL_LOCATION_AUTO) {
// Check for free memory internally
if (checkInt(pkgLen)) {
return INSTALL_LOC_INT;
}
// Check for free memory externally
if (checkSd(pkgLen)) {
return INSTALL_LOC_SD;
}
return INSTALL_LOC_ERR;
}
// Check for settings preference.
boolean checkSd = false;
int userPref = getDefaultInstallLoc();
if (userPref == APP_INSTALL_DEVICE) {
if (checkInt(pkgLen)) {
return INSTALL_LOC_INT;
}
return INSTALL_LOC_ERR;
} else if (userPref == APP_INSTALL_SDCARD) {
if (checkSd(pkgLen)) {
return INSTALL_LOC_SD;
}
return INSTALL_LOC_ERR;
}
// Default system policy for apps with no manifest option specified.
// Check for free memory internally
if (checkInt(pkgLen)) {
return INSTALL_LOC_INT;
}
return INSTALL_LOC_ERR;
| | android.net.Uri | getInstallablePackage(int fileResId, java.io.File outFile)
Resources res = mContext.getResources();
InputStream is = null;
try {
is = res.openRawResource(fileResId);
} catch (NotFoundException e) {
failStr("Failed to load resource with id: " + fileResId);
}
FileUtils.setPermissions(outFile.getPath(),
FileUtils.S_IRWXU | FileUtils.S_IRWXG | FileUtils.S_IRWXO,
-1, -1);
assertTrue(FileUtils.copyToFile(is, outFile));
FileUtils.setPermissions(outFile.getPath(),
FileUtils.S_IRWXU | FileUtils.S_IRWXG | FileUtils.S_IRWXO,
-1, -1);
return Uri.fromFile(outFile);
| | android.os.storage.IMountService | getMs()
IBinder service = ServiceManager.getService("mount");
if (service != null) {
return IMountService.Stub.asInterface(service);
} else {
Log.e(TAG, "Can't get mount service");
}
return null;
| | private PackageParser.Package | getParsedPackage(java.lang.String outFileName, int rawResId)
PackageManager pm = mContext.getPackageManager();
File filesDir = mContext.getFilesDir();
File outFile = new File(filesDir, outFileName);
Uri packageURI = getInstallablePackage(rawResId, outFile);
PackageParser.Package pkg = parsePackage(packageURI);
return pkg;
| | private PackageManager | getPm()
return mContext.getPackageManager();
| | private boolean | getUserSettingSetInstallLocation()
try {
return Settings.Global.getInt(
mContext.getContentResolver(), Settings.Global.SET_INSTALL_LOCATION) != 0;
} catch (SettingNotFoundException e1) {
}
return false;
| | private void | installFromRawResource(android.content.pm.PackageManagerTests$InstallParams ip, int flags, boolean cleanUp, boolean fail, int result, int expInstallLocation)
PackageManager pm = mContext.getPackageManager();
PackageParser.Package pkg = ip.pkg;
Uri packageURI = ip.packageURI;
if ((flags & PackageManager.INSTALL_REPLACE_EXISTING) == 0) {
// Make sure the package doesn't exist
try {
ApplicationInfo appInfo = pm.getApplicationInfo(pkg.packageName,
PackageManager.GET_UNINSTALLED_PACKAGES);
GenericReceiver receiver = new DeleteReceiver(pkg.packageName);
invokeDeletePackage(pkg.packageName, 0, receiver);
} catch (NameNotFoundException e) {
}
}
try {
if (fail) {
invokeInstallPackageFail(packageURI, flags, result);
if ((flags & PackageManager.INSTALL_REPLACE_EXISTING) == 0) {
assertNotInstalled(pkg.packageName);
}
} else {
InstallReceiver receiver = new InstallReceiver(pkg.packageName);
invokeInstallPackage(packageURI, flags, receiver, true);
// Verify installed information
assertInstall(pkg, flags, expInstallLocation);
}
} finally {
if (cleanUp) {
cleanUpInstall(ip);
}
}
| | private android.content.pm.PackageManagerTests$InstallParams | installFromRawResource(java.lang.String outFileName, int rawResId, int flags, boolean cleanUp, boolean fail, int result, int expInstallLocation)
InstallParams ip = new InstallParams(outFileName, rawResId);
installFromRawResource(ip, flags, cleanUp, fail, result, expInstallLocation);
return ip;
| | public boolean | invokeDeletePackage(java.lang.String pkgName, int flags, android.content.pm.PackageManagerTests$GenericReceiver receiver)
ApplicationInfo info = getPm().getApplicationInfo(pkgName,
PackageManager.GET_UNINSTALLED_PACKAGES);
mContext.registerReceiver(receiver, receiver.filter);
try {
DeleteObserver observer = new DeleteObserver(pkgName);
getPm().deletePackage(pkgName, observer, flags | PackageManager.DELETE_ALL_USERS);
observer.waitForCompletion(MAX_WAIT_TIME);
assertUninstalled(info);
// Verify we received the broadcast
// TODO replace this with a CountDownLatch
synchronized (receiver) {
long waitTime = 0;
while ((!receiver.isDone()) && (waitTime < MAX_WAIT_TIME)) {
receiver.wait(WAIT_TIME_INCR);
waitTime += WAIT_TIME_INCR;
}
if (!receiver.isDone()) {
throw new Exception("Timed out waiting for PACKAGE_REMOVED notification");
}
}
return receiver.received;
} finally {
mContext.unregisterReceiver(receiver);
}
| | public void | invokeInstallPackage(android.net.Uri packageURI, int flags, android.content.pm.PackageManagerTests$GenericReceiver receiver, boolean shouldSucceed)
TestInstallObserver observer = new TestInstallObserver();
mContext.registerReceiver(receiver, receiver.filter);
try {
// Wait on observer
synchronized (observer) {
synchronized (receiver) {
getPm().installPackage(packageURI, observer, flags, null);
long waitTime = 0;
while ((!observer.isDone()) && (waitTime < MAX_WAIT_TIME)) {
try {
observer.wait(WAIT_TIME_INCR);
waitTime += WAIT_TIME_INCR;
} catch (InterruptedException e) {
Log.i(TAG, "Interrupted during sleep", e);
}
}
if (!observer.isDone()) {
fail("Timed out waiting for packageInstalled callback");
}
if (shouldSucceed) {
if (observer.returnCode != PackageManager.INSTALL_SUCCEEDED) {
fail("Package installation should have succeeded, but got code "
+ observer.returnCode);
}
} else {
if (observer.returnCode == PackageManager.INSTALL_SUCCEEDED) {
fail("Package installation should fail");
}
/*
* We'll never expect get a notification since we
* shouldn't succeed.
*/
return;
}
// Verify we received the broadcast
waitTime = 0;
while ((!receiver.isDone()) && (waitTime < MAX_WAIT_TIME)) {
try {
receiver.wait(WAIT_TIME_INCR);
waitTime += WAIT_TIME_INCR;
} catch (InterruptedException e) {
Log.i(TAG, "Interrupted during sleep", e);
}
}
if (!receiver.isDone()) {
fail("Timed out waiting for PACKAGE_ADDED notification");
}
}
}
} finally {
mContext.unregisterReceiver(receiver);
}
| | public void | invokeInstallPackageFail(android.net.Uri packageURI, int flags, int expectedResult)
TestInstallObserver observer = new TestInstallObserver();
try {
// Wait on observer
synchronized (observer) {
getPm().installPackage(packageURI, observer, flags, null);
long waitTime = 0;
while ((!observer.isDone()) && (waitTime < MAX_WAIT_TIME)) {
try {
observer.wait(WAIT_TIME_INCR);
waitTime += WAIT_TIME_INCR;
} catch (InterruptedException e) {
Log.i(TAG, "Interrupted during sleep", e);
}
}
if (!observer.isDone()) {
fail("Timed out waiting for packageInstalled callback");
}
assertEquals(expectedResult, observer.returnCode);
}
} finally {
}
| | public boolean | invokeMovePackage(java.lang.String pkgName, int flags, android.content.pm.PackageManagerTests$GenericReceiver receiver)
PackageMoveObserver observer = new PackageMoveObserver(pkgName);
final boolean received = false;
mContext.registerReceiver(receiver, receiver.filter);
try {
// Wait on observer
synchronized (observer) {
synchronized (receiver) {
getPm().movePackage(pkgName, observer, flags);
long waitTime = 0;
while ((!observer.isDone()) && (waitTime < MAX_WAIT_TIME)) {
observer.wait(WAIT_TIME_INCR);
waitTime += WAIT_TIME_INCR;
}
if (!observer.isDone()) {
throw new Exception("Timed out waiting for pkgmove callback");
}
if (observer.returnCode != PackageManager.MOVE_SUCCEEDED) {
return false;
}
// Verify we received the broadcast
waitTime = 0;
while ((!receiver.isDone()) && (waitTime < MAX_WAIT_TIME)) {
receiver.wait(WAIT_TIME_INCR);
waitTime += WAIT_TIME_INCR;
}
if (!receiver.isDone()) {
throw new Exception("Timed out waiting for MOVE notifications");
}
return receiver.received;
}
}
} finally {
mContext.unregisterReceiver(receiver);
}
| | private boolean | invokeMovePackageFail(java.lang.String pkgName, int flags, int errCode)
PackageMoveObserver observer = new PackageMoveObserver(pkgName);
try {
// Wait on observer
synchronized (observer) {
getPm().movePackage(pkgName, observer, flags);
long waitTime = 0;
while ((!observer.isDone()) && (waitTime < MAX_WAIT_TIME)) {
observer.wait(WAIT_TIME_INCR);
waitTime += WAIT_TIME_INCR;
}
if (!observer.isDone()) {
throw new Exception("Timed out waiting for pkgmove callback");
}
assertEquals(errCode, observer.returnCode);
}
} finally {
}
return true;
| | private boolean | mountFromRawResource()
// Install pkg on sdcard
InstallParams ip = sampleInstallFromRawResource(PackageManager.INSTALL_EXTERNAL, false);
if (localLOGV) Log.i(TAG, "Installed pkg on sdcard");
boolean origState = checkMediaState(Environment.MEDIA_MOUNTED);
boolean registeredReceiver = false;
SdMountReceiver receiver = new SdMountReceiver(new String[]{ip.pkg.packageName});
try {
if (localLOGV) Log.i(TAG, "Unmounting media");
// Unmount media
assertTrue(unmountMedia());
if (localLOGV) Log.i(TAG, "Unmounted media");
// Register receiver here
PackageManager pm = getPm();
mContext.registerReceiver(receiver, receiver.filter);
registeredReceiver = true;
// Wait on receiver
synchronized (receiver) {
if (localLOGV) Log.i(TAG, "Mounting media");
// Mount media again
assertTrue(mountMedia());
if (localLOGV) Log.i(TAG, "Mounted media");
if (localLOGV) Log.i(TAG, "Waiting for notification");
long waitTime = 0;
// Verify we received the broadcast
waitTime = 0;
while ((!receiver.isDone()) && (waitTime < MAX_WAIT_TIME)) {
receiver.wait(WAIT_TIME_INCR);
waitTime += WAIT_TIME_INCR;
}
if(!receiver.isDone()) {
failStr("Timed out waiting for EXTERNAL_APPLICATIONS notification");
}
return receiver.received;
}
} catch (InterruptedException e) {
failStr(e);
return false;
} finally {
if (registeredReceiver) {
mContext.unregisterReceiver(receiver);
}
// Restore original media state
if (origState) {
mountMedia();
} else {
unmountMedia();
}
if (localLOGV) Log.i(TAG, "Cleaning up install");
cleanUpInstall(ip);
}
| | boolean | mountMedia()
// We can't mount emulated storage.
if (Environment.isExternalStorageEmulated()) {
return true;
}
if (checkMediaState(Environment.MEDIA_MOUNTED)) {
return true;
}
final String path = Environment.getExternalStorageDirectory().toString();
StorageListener observer = new StorageListener(Environment.MEDIA_MOUNTED);
StorageManager sm = (StorageManager) mContext.getSystemService(Context.STORAGE_SERVICE);
sm.registerListener(observer);
try {
// Wait on observer
synchronized (observer) {
int ret = getMs().mountVolume(path);
if (ret != StorageResultCode.OperationSucceeded) {
throw new Exception("Could not mount the media");
}
long waitTime = 0;
while ((!observer.isDone()) && (waitTime < MAX_WAIT_TIME)) {
observer.wait(WAIT_TIME_INCR);
waitTime += WAIT_TIME_INCR;
}
if (!observer.isDone()) {
throw new Exception("Timed out waiting for unmount media notification");
}
return true;
}
} catch (Exception e) {
Log.e(TAG, "Exception : " + e);
return false;
} finally {
sm.unregisterListener(observer);
}
| | private void | moveFromRawResource(java.lang.String outFileName, int rawResId, int installFlags, int moveFlags, boolean cleanUp, boolean fail, int result)
int origDefaultLoc = getDefaultInstallLoc();
InstallParams ip = null;
try {
setInstallLoc(PackageHelper.APP_INSTALL_AUTO);
// Install first
ip = installFromRawResource("install.apk", rawResId, installFlags, false,
false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
ApplicationInfo oldAppInfo = getPm().getApplicationInfo(ip.pkg.packageName, 0);
if (fail) {
assertTrue(invokeMovePackageFail(ip.pkg.packageName, moveFlags, result));
ApplicationInfo info = getPm().getApplicationInfo(ip.pkg.packageName, 0);
assertNotNull(info);
assertEquals(oldAppInfo.flags, info.flags);
} else {
// Create receiver based on expRetCode
MoveReceiver receiver = new MoveReceiver(ip.pkg.packageName);
boolean retCode = invokeMovePackage(ip.pkg.packageName, moveFlags, receiver);
assertTrue(retCode);
ApplicationInfo info = getPm().getApplicationInfo(ip.pkg.packageName, 0);
assertNotNull("ApplicationInfo for recently installed application should exist",
info);
if ((moveFlags & PackageManager.MOVE_INTERNAL) != 0) {
assertTrue("ApplicationInfo.FLAG_EXTERNAL_STORAGE flag should NOT be set",
(info.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) == 0);
assertStartsWith("Native library dir should be in dataDir",
info.dataDir, info.nativeLibraryDir);
} else if ((moveFlags & PackageManager.MOVE_EXTERNAL_MEDIA) != 0) {
assertTrue("ApplicationInfo.FLAG_EXTERNAL_STORAGE flag should be set",
(info.flags & ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0);
assertStartsWith("Native library dir should point to ASEC",
SECURE_CONTAINERS_PREFIX, info.nativeLibraryDir);
final File nativeLibSymLink = new File(info.dataDir, "lib");
assertStartsWith("The data directory should have a 'lib' symlink that points to the ASEC container",
SECURE_CONTAINERS_PREFIX, nativeLibSymLink.getCanonicalPath());
}
}
} catch (NameNotFoundException e) {
failStr("Pkg hasnt been installed correctly");
} catch (Exception e) {
failStr("Failed with exception : " + e);
} finally {
if (ip != null) {
cleanUpInstall(ip);
}
// Restore default install location
setInstallLoc(origDefaultLoc);
}
| | private PackageParser.Package | parsePackage(android.net.Uri packageURI)
final String archiveFilePath = packageURI.getPath();
PackageParser packageParser = new PackageParser();
File sourceFile = new File(archiveFilePath);
PackageParser.Package pkg = packageParser.parseMonolithicPackage(sourceFile, 0);
packageParser = null;
return pkg;
| | private android.content.pm.PackageManagerTests$InstallParams | replaceCerts(int apk1, int apk2, boolean cleanUp, boolean fail, int retCode)
int rFlags = PackageManager.INSTALL_REPLACE_EXISTING;
String apk1Name = "install1.apk";
String apk2Name = "install2.apk";
PackageParser.Package pkg1 = getParsedPackage(apk1Name, apk1);
try {
InstallParams ip = installFromRawResource(apk1Name, apk1, 0, false,
false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
installFromRawResource(apk2Name, apk2, rFlags, false,
fail, retCode, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
return ip;
} catch (Exception e) {
failStr(e.getMessage());
} finally {
if (cleanUp) {
cleanUpInstall(pkg1.packageName);
}
}
return null;
| | private android.content.pm.PackageManagerTests$InstallParams | sampleInstallFromRawResource(int flags, boolean cleanUp)
return installFromRawResource("install.apk", R.raw.install, flags, cleanUp, false, -1,
PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
| | private void | sampleMoveFromRawResource(int installFlags, int moveFlags, boolean fail, int result)
moveFromRawResource("install.apk",
R.raw.install, installFlags, moveFlags, true,
fail, result);
| | private void | sampleReplaceFromRawResource(int flags)
InstallParams ip = sampleInstallFromRawResource(flags, false);
boolean replace = ((flags & PackageManager.INSTALL_REPLACE_EXISTING) != 0);
Log.i(TAG, "replace=" + replace);
GenericReceiver receiver;
if (replace) {
receiver = new ReplaceReceiver(ip.pkg.packageName);
Log.i(TAG, "Creating replaceReceiver");
} else {
receiver = new InstallReceiver(ip.pkg.packageName);
}
try {
invokeInstallPackage(ip.packageURI, flags, receiver, replace);
if (replace) {
assertInstall(ip.pkg, flags, ip.pkg.installLocation);
}
} finally {
cleanUpInstall(ip);
}
| | private void | setExistingXUserX(int userSetting, int iFlags, int iloc)
int rFlags = PackageManager.INSTALL_REPLACE_EXISTING;
// First install.
installFromRawResource("install.apk", R.raw.install,
iFlags,
false,
false, -1,
PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
int origSetting = getDefaultInstallLoc();
try {
// Set user setting
setInstallLoc(userSetting);
// Replace now
installFromRawResource("install.apk", R.raw.install,
rFlags,
true,
false, -1,
iloc);
} finally {
setInstallLoc(origSetting);
}
| | private void | setInstallLoc(int loc)
Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.DEFAULT_INSTALL_LOCATION, loc);
| | protected void | setUp()
super.setUp();
mOrigState = checkMediaState(Environment.MEDIA_MOUNTED);
if (!mountMedia()) {
Log.i(TAG, "sdcard not mounted? Some of these tests might fail");
}
| | private void | setUserSettingSetInstallLocation(boolean value)
Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.SET_INSTALL_LOCATION, value ? 1 : 0);
| | private void | setUserX(boolean enable, int userSetting, int iloc)
boolean origUserSetting = getUserSettingSetInstallLocation();
int origSetting = getDefaultInstallLoc();
try {
setUserSettingSetInstallLocation(enable);
// Set user setting
setInstallLoc(userSetting);
// Replace now
installFromRawResource("install.apk", R.raw.install,
0,
true,
false, -1,
iloc);
} finally {
// Restore original setting
setUserSettingSetInstallLocation(origUserSetting);
setInstallLoc(origSetting);
}
| | protected void | tearDown()
// Restore media state.
boolean newState = checkMediaState(Environment.MEDIA_MOUNTED);
if (newState != mOrigState) {
if (mOrigState) {
mountMedia();
} else {
unmountMedia();
}
}
super.tearDown();
| | public void | testCheckSignaturesAllMatch()
int apk1 = APP1_CERT1_CERT2;
int apk2 = APP2_CERT1_CERT2;
checkSignatures(apk1, apk2, PackageManager.SIGNATURE_MATCH);
| | public void | testCheckSignaturesMoreMatch()
int apk1 = APP1_CERT1;
int apk2 = APP2_CERT1_CERT2;
checkSignatures(apk1, apk2, PackageManager.SIGNATURE_NO_MATCH);
| | public void | testCheckSignaturesNoMatch()
int apk1 = APP1_CERT1;
int apk2 = APP2_CERT2;
checkSignatures(apk1, apk2, PackageManager.SIGNATURE_NO_MATCH);
| | public void | testCheckSignaturesSharedAllMatch()
int apk1 = SHARED1_CERT1_CERT2;
int apk2 = SHARED2_CERT1_CERT2;
boolean fail = false;
int retCode = -1;
int expMatchResult = PackageManager.SIGNATURE_MATCH;
checkSharedSignatures(apk1, apk2, true, fail, retCode, expMatchResult);
| | public void | testCheckSignaturesSharedNoMatch()
int apk1 = SHARED1_CERT1;
int apk2 = SHARED2_CERT2;
boolean fail = true;
int retCode = PackageManager.INSTALL_FAILED_SHARED_USER_INCOMPATIBLE;
int expMatchResult = -1;
checkSharedSignatures(apk1, apk2, true, fail, retCode, expMatchResult);
| | public void | testCheckSignaturesSharedSomeMatch1()
int apk1 = SHARED1_CERT1_CERT2;
int apk2 = SHARED2_CERT1;
boolean fail = true;
int retCode = PackageManager.INSTALL_FAILED_SHARED_USER_INCOMPATIBLE;
int expMatchResult = -1;
checkSharedSignatures(apk1, apk2, true, fail, retCode, expMatchResult);
| | public void | testCheckSignaturesSharedSomeMatch2()
int apk1 = SHARED1_CERT1_CERT2;
int apk2 = SHARED2_CERT2;
boolean fail = true;
int retCode = PackageManager.INSTALL_FAILED_SHARED_USER_INCOMPATIBLE;
int expMatchResult = -1;
checkSharedSignatures(apk1, apk2, true, fail, retCode, expMatchResult);
| | public void | testCheckSignaturesSharedUnknown()
int apk1 = SHARED1_CERT1_CERT2;
int apk2 = SHARED2_CERT1_CERT2;
String apk1Name = "install1.apk";
String apk2Name = "install2.apk";
InstallParams ip1 = null;
try {
ip1 = installFromRawResource(apk1Name, apk1, 0, false,
false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
PackageManager pm = mContext.getPackageManager();
// Delete app2
PackageParser.Package pkg = getParsedPackage(apk2Name, apk2);
getPm().deletePackage(pkg.packageName, null, PackageManager.DELETE_ALL_USERS);
// Check signatures now
int match = mContext.getPackageManager().checkSignatures(
ip1.pkg.packageName, pkg.packageName);
assertEquals(PackageManager.SIGNATURE_UNKNOWN_PACKAGE, match);
} finally {
if (ip1 != null) {
cleanUpInstall(ip1);
}
}
| | public void | testCheckSignaturesSomeMatch1()
int apk1 = APP1_CERT1_CERT2;
int apk2 = APP2_CERT1;
checkSignatures(apk1, apk2, PackageManager.SIGNATURE_NO_MATCH);
| | public void | testCheckSignaturesSomeMatch2()
int apk1 = APP1_CERT1_CERT2;
int apk2 = APP2_CERT2;
checkSignatures(apk1, apk2, PackageManager.SIGNATURE_NO_MATCH);
| | public void | testCheckSignaturesUnknown()
int apk1 = APP1_CERT1_CERT2;
int apk2 = APP2_CERT1_CERT2;
String apk1Name = "install1.apk";
String apk2Name = "install2.apk";
InstallParams ip1 = null;
try {
ip1 = installFromRawResource(apk1Name, apk1, 0, false,
false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
PackageManager pm = mContext.getPackageManager();
// Delete app2
File filesDir = mContext.getFilesDir();
File outFile = new File(filesDir, apk2Name);
int rawResId = apk2;
Uri packageURI = getInstallablePackage(rawResId, outFile);
PackageParser.Package pkg = parsePackage(packageURI);
getPm().deletePackage(pkg.packageName, null, PackageManager.DELETE_ALL_USERS);
// Check signatures now
int match = mContext.getPackageManager().checkSignatures(
ip1.pkg.packageName, pkg.packageName);
assertEquals(PackageManager.SIGNATURE_UNKNOWN_PACKAGE, match);
} finally {
if (ip1 != null) {
cleanUpInstall(ip1);
}
}
| | public void | testDeleteFwdLockedInternal()
deleteFromRawResource(PackageManager.INSTALL_FORWARD_LOCK, 0);
| | public void | testDeleteFwdLockedInternalRetainData()
deleteFromRawResource(PackageManager.INSTALL_FORWARD_LOCK, PackageManager.DELETE_KEEP_DATA);
| | public void | testDeleteNormalInternal()
deleteFromRawResource(0, 0);
| | public void | testDeleteNormalInternalRetainData()
deleteFromRawResource(0, PackageManager.DELETE_KEEP_DATA);
| | public void | testDeleteSdcard()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
deleteFromRawResource(PackageManager.INSTALL_EXTERNAL, 0);
| | public void | testDeleteSdcardRetainData()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
deleteFromRawResource(PackageManager.INSTALL_EXTERNAL, PackageManager.DELETE_KEEP_DATA);
| | public void | testExistingEUserA()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int userSetting = PackageHelper.APP_INSTALL_AUTO;
int iFlags = PackageManager.INSTALL_EXTERNAL;
setExistingXUserX(userSetting, iFlags, PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL);
| | public void | testExistingEUserE()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int userSetting = PackageHelper.APP_INSTALL_EXTERNAL;
int iFlags = PackageManager.INSTALL_EXTERNAL;
setExistingXUserX(userSetting, iFlags, PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL);
| | public void | testExistingEUserI()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int userSetting = PackageHelper.APP_INSTALL_INTERNAL;
int iFlags = PackageManager.INSTALL_EXTERNAL;
setExistingXUserX(userSetting, iFlags, PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL);
| | public void | testExistingIUserA()
int userSetting = PackageHelper.APP_INSTALL_AUTO;
int iFlags = PackageManager.INSTALL_INTERNAL;
setExistingXUserX(userSetting, iFlags, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
| | public void | testExistingIUserE()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int userSetting = PackageHelper.APP_INSTALL_EXTERNAL;
int iFlags = PackageManager.INSTALL_INTERNAL;
setExistingXUserX(userSetting, iFlags, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
| | public void | testExistingIUserI()
int userSetting = PackageHelper.APP_INSTALL_INTERNAL;
int iFlags = PackageManager.INSTALL_INTERNAL;
setExistingXUserX(userSetting, iFlags, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
| | public void | testFlagE()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
sampleInstallFromRawResource(PackageManager.INSTALL_EXTERNAL, true);
| | public void | testFlagEExistingE()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int iFlags = PackageManager.INSTALL_EXTERNAL;
int rFlags = PackageManager.INSTALL_EXTERNAL | PackageManager.INSTALL_REPLACE_EXISTING;
// First install.
installFromRawResource("install.apk", R.raw.install,
iFlags,
false,
false, -1,
-1);
// Replace now
installFromRawResource("install.apk", R.raw.install,
rFlags,
true,
false, -1,
-1);
| | public void | testFlagEExistingI()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int iFlags = PackageManager.INSTALL_INTERNAL;
int rFlags = PackageManager.INSTALL_EXTERNAL | PackageManager.INSTALL_REPLACE_EXISTING;
// First install.
installFromRawResource("install.apk", R.raw.install,
iFlags,
false,
false, -1,
-1);
// Replace now
installFromRawResource("install.apk", R.raw.install,
rFlags,
true,
false, -1,
-1);
| | public void | testFlagEF()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
sampleInstallFromRawResource(PackageManager.INSTALL_FORWARD_LOCK
| PackageManager.INSTALL_EXTERNAL, true);
| | public void | testFlagEManifestA()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
installFromRawResource("install.apk", R.raw.install_loc_auto,
PackageManager.INSTALL_EXTERNAL,
true,
false, -1,
PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL);
| | public void | testFlagEManifestE()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
installFromRawResource("install.apk", R.raw.install_loc_sdcard,
PackageManager.INSTALL_EXTERNAL,
true,
false, -1,
PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL);
| | public void | testFlagEManifestI()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
installFromRawResource("install.apk", R.raw.install_loc_internal,
PackageManager.INSTALL_EXTERNAL,
true,
false, -1,
PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL);
| | public void | testFlagF()
sampleInstallFromRawResource(PackageManager.INSTALL_FORWARD_LOCK, true);
| | public void | testFlagFExistingE()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int iFlags = PackageManager.INSTALL_EXTERNAL;
int rFlags = PackageManager.INSTALL_FORWARD_LOCK | PackageManager.INSTALL_REPLACE_EXISTING;
// First install.
installFromRawResource("install.apk", R.raw.install,
iFlags,
false,
false, -1,
-1);
// Replace now
installFromRawResource("install.apk", R.raw.install,
rFlags,
true,
false, -1,
-1);
| | public void | testFlagFExistingI()
int iFlags = PackageManager.INSTALL_INTERNAL;
int rFlags = PackageManager.INSTALL_FORWARD_LOCK | PackageManager.INSTALL_REPLACE_EXISTING;
// First install.
installFromRawResource("install.apk", R.raw.install,
iFlags,
false,
false, -1,
-1);
// Replace now
installFromRawResource("install.apk", R.raw.install,
rFlags,
true,
false, -1,
-1);
| | public void | testFlagFManifestA()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
installFromRawResource("install.apk", R.raw.install_loc_auto,
PackageManager.INSTALL_FORWARD_LOCK,
true,
false, -1,
PackageInfo.INSTALL_LOCATION_AUTO);
| | public void | testFlagFManifestE()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
installFromRawResource("install.apk", R.raw.install_loc_sdcard,
PackageManager.INSTALL_FORWARD_LOCK,
true,
false, -1,
PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL);
| | public void | testFlagFManifestI()
installFromRawResource("install.apk", R.raw.install_loc_internal,
PackageManager.INSTALL_FORWARD_LOCK,
true,
false, -1,
PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
| | public void | testFlagI()
sampleInstallFromRawResource(PackageManager.INSTALL_INTERNAL, true);
| | public void | testFlagIE()
installFromRawResource("install.apk", R.raw.install,
PackageManager.INSTALL_EXTERNAL | PackageManager.INSTALL_INTERNAL,
false,
true, PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION,
PackageInfo.INSTALL_LOCATION_AUTO);
| | public void | testFlagIEF()
installFromRawResource("install.apk", R.raw.install,
PackageManager.INSTALL_FORWARD_LOCK | PackageManager.INSTALL_INTERNAL |
PackageManager.INSTALL_EXTERNAL,
false,
true, PackageManager.INSTALL_FAILED_INVALID_INSTALL_LOCATION,
PackageInfo.INSTALL_LOCATION_AUTO);
| | public void | testFlagIExistingE()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int iFlags = PackageManager.INSTALL_EXTERNAL;
int rFlags = PackageManager.INSTALL_INTERNAL | PackageManager.INSTALL_REPLACE_EXISTING;
// First install.
installFromRawResource("install.apk", R.raw.install,
iFlags,
false,
false, -1,
-1);
// Replace now
installFromRawResource("install.apk", R.raw.install,
rFlags,
true,
false, -1,
-1);
| | public void | testFlagIExistingI()
int iFlags = PackageManager.INSTALL_INTERNAL;
int rFlags = PackageManager.INSTALL_INTERNAL | PackageManager.INSTALL_REPLACE_EXISTING;
// First install.
installFromRawResource("install.apk", R.raw.install,
iFlags,
false,
false, -1,
-1);
// Replace now
installFromRawResource("install.apk", R.raw.install,
rFlags,
true,
false, -1,
-1);
| | public void | testFlagIF()
sampleInstallFromRawResource(PackageManager.INSTALL_FORWARD_LOCK
| PackageManager.INSTALL_INTERNAL, true);
| | public void | testFlagIManifestA()
installFromRawResource("install.apk", R.raw.install_loc_auto,
PackageManager.INSTALL_INTERNAL,
true,
false, -1,
PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
| | public void | testFlagIManifestE()
installFromRawResource("install.apk", R.raw.install_loc_sdcard,
PackageManager.INSTALL_INTERNAL,
true,
false, -1,
PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
| | public void | testFlagIManifestI()
installFromRawResource("install.apk", R.raw.install_loc_internal,
PackageManager.INSTALL_INTERNAL,
true,
false, -1,
PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
| | public void | testGetInstalledPackages()
List<PackageInfo> packages = getPm().getInstalledPackages(0);
assertNotNull("installed packages cannot be null", packages);
assertTrue("installed packages cannot be empty", packages.size() > 0);
| | public void | testGetInstalledPackagesAll()Test that getInstalledPackages returns all the data specified in flags.
int flags = PackageManager.GET_ACTIVITIES | PackageManager.GET_GIDS
| PackageManager.GET_CONFIGURATIONS | PackageManager.GET_INSTRUMENTATION
| PackageManager.GET_PERMISSIONS | PackageManager.GET_PROVIDERS
| PackageManager.GET_RECEIVERS | PackageManager.GET_SERVICES
| PackageManager.GET_SIGNATURES | PackageManager.GET_UNINSTALLED_PACKAGES;
List<PackageInfo> packages = getPm().getInstalledPackages(flags);
assertNotNull("installed packages cannot be null", packages);
assertTrue("installed packages cannot be empty", packages.size() > 0);
PackageInfo packageInfo = null;
// Find the package with all components specified in the AndroidManifest
// to ensure no null values
for (PackageInfo pi : packages) {
if ("com.android.frameworks.coretests.install_complete_package_info"
.equals(pi.packageName)) {
packageInfo = pi;
break;
}
}
assertNotNull("activities should not be null", packageInfo.activities);
assertNotNull("configPreferences should not be null", packageInfo.configPreferences);
assertNotNull("instrumentation should not be null", packageInfo.instrumentation);
assertNotNull("permissions should not be null", packageInfo.permissions);
assertNotNull("providers should not be null", packageInfo.providers);
assertNotNull("receivers should not be null", packageInfo.receivers);
assertNotNull("services should not be null", packageInfo.services);
assertNotNull("signatures should not be null", packageInfo.signatures);
| | public void | testGetKeySetByAlias()
PackageManager pm = getPm();
String mPkgName = mContext.getPackageName();
String otherPkgName = "com.android.frameworks.coretests.keysets_api";
KeySet ks;
try {
ks = pm.getKeySetByAlias(null, null);
assertTrue(false); // should have thrown
} catch (NullPointerException e) {
}
try {
ks = pm.getKeySetByAlias(null, "keysetBogus");
assertTrue(false); // should have thrown
} catch (NullPointerException e) {
}
try {
ks = pm.getKeySetByAlias("keysets.test.bogus.package", null);
assertTrue(false); // should have thrown
} catch (NullPointerException e) {
}
try {
ks = pm.getKeySetByAlias("keysets.test.bogus.package", "A");
assertTrue(false); // should have thrown
} catch(IllegalArgumentException e) {
}
try {
ks = pm.getKeySetByAlias(mPkgName, "keysetBogus");
assertTrue(false); // should have thrown
} catch(IllegalArgumentException e) {
}
installFromRawResource("keysetApi.apk", R.raw.keyset_splat_api,
0, false, false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
try {
ks = pm.getKeySetByAlias(otherPkgName, "A");
assertTrue(false); // should have thrown
} catch (SecurityException e) {
}
cleanUpInstall(otherPkgName);
ks = pm.getKeySetByAlias(mPkgName, "A");
assertNotNull(ks);
| | public void | testGetSigningKeySet()The following tests are related to testing KeySets-based API
PackageManager pm = getPm();
String mPkgName = mContext.getPackageName();
String otherPkgName = "com.android.frameworks.coretests.keysets_api";
KeySet ks;
try {
ks = pm.getSigningKeySet(null);
assertTrue(false); // should have thrown
} catch (NullPointerException e) {
}
try {
ks = pm.getSigningKeySet("keysets.test.bogus.package");
assertTrue(false); // should have thrown
} catch (IllegalArgumentException e) {
}
installFromRawResource("keysetApi.apk", R.raw.keyset_splat_api,
0, false, false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
try {
ks = pm.getSigningKeySet(otherPkgName);
assertTrue(false); // should have thrown
} catch (SecurityException e) {
}
cleanUpInstall(otherPkgName);
ks = pm.getSigningKeySet(mContext.getPackageName());
assertNotNull(ks);
| | public void | testGetUnInstalledPackages()
List<PackageInfo> packages = getPm().getInstalledPackages(
PackageManager.GET_UNINSTALLED_PACKAGES);
assertNotNull("installed packages cannot be null", packages);
assertTrue("installed packages cannot be empty", packages.size() > 0);
| | public void | testGetUnInstalledPackagesAll()Test that getInstalledPackages returns all the data specified in
flags when the GET_UNINSTALLED_PACKAGES flag is set.
int flags = PackageManager.GET_UNINSTALLED_PACKAGES
| PackageManager.GET_ACTIVITIES | PackageManager.GET_GIDS
| PackageManager.GET_CONFIGURATIONS | PackageManager.GET_INSTRUMENTATION
| PackageManager.GET_PERMISSIONS | PackageManager.GET_PROVIDERS
| PackageManager.GET_RECEIVERS | PackageManager.GET_SERVICES
| PackageManager.GET_SIGNATURES | PackageManager.GET_UNINSTALLED_PACKAGES;
List<PackageInfo> packages = getPm().getInstalledPackages(flags);
assertNotNull("installed packages cannot be null", packages);
assertTrue("installed packages cannot be empty", packages.size() > 0);
PackageInfo packageInfo = null;
// Find the package with all components specified in the AndroidManifest
// to ensure no null values
for (PackageInfo pi : packages) {
if ("com.android.frameworks.coretests.install_complete_package_info"
.equals(pi.packageName)) {
packageInfo = pi;
break;
}
}
assertNotNull("activities should not be null", packageInfo.activities);
assertNotNull("configPreferences should not be null", packageInfo.configPreferences);
assertNotNull("instrumentation should not be null", packageInfo.instrumentation);
assertNotNull("permissions should not be null", packageInfo.permissions);
assertNotNull("providers should not be null", packageInfo.providers);
assertNotNull("receivers should not be null", packageInfo.receivers);
assertNotNull("services should not be null", packageInfo.services);
assertNotNull("signatures should not be null", packageInfo.signatures);
| | public void | testGetVerifierDeviceIdentity()
PackageManager pm = getPm();
VerifierDeviceIdentity id = pm.getVerifierDeviceIdentity();
assertNotNull("Verifier device identity should not be null", id);
| | public void | testInstallDeclaresPermissions()
/*
* Ensure that permissions are properly declared.
*/
InstallParams ip = null;
InstallParams ip2 = null;
try {
// **: Upon installing a package, are its declared permissions published?
int iFlags = PackageManager.INSTALL_INTERNAL;
int iApk = R.raw.install_decl_perm;
ip = installFromRawResource("install.apk", iApk,
iFlags, false,
false, -1, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
assertInstall(ip.pkg, iFlags, ip.pkg.installLocation);
assertPermissions(BASE_PERMISSIONS_DEFINED);
// **: Upon installing package, are its permissions granted?
int i2Flags = PackageManager.INSTALL_INTERNAL;
int i2Apk = R.raw.install_use_perm_good;
ip2 = installFromRawResource("install2.apk", i2Apk,
i2Flags, false,
false, -1, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
assertInstall(ip2.pkg, i2Flags, ip2.pkg.installLocation);
assertPermissions(BASE_PERMISSIONS_USED);
// **: Upon removing but not deleting, are permissions retained?
GenericReceiver receiver = new DeleteReceiver(ip.pkg.packageName);
try {
invokeDeletePackage(ip.pkg.packageName, PackageManager.DELETE_KEEP_DATA, receiver);
} catch (Exception e) {
failStr(e);
}
assertPermissions(BASE_PERMISSIONS_DEFINED);
assertPermissions(BASE_PERMISSIONS_USED);
// **: Upon re-installing, are permissions retained?
ip = installFromRawResource("install.apk", iApk,
iFlags | PackageManager.INSTALL_REPLACE_EXISTING, false,
false, -1, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
assertInstall(ip.pkg, iFlags, ip.pkg.installLocation);
assertPermissions(BASE_PERMISSIONS_DEFINED);
assertPermissions(BASE_PERMISSIONS_USED);
// **: Upon deleting package, are all permissions removed?
try {
invokeDeletePackage(ip.pkg.packageName, 0, receiver);
ip = null;
} catch (Exception e) {
failStr(e);
}
assertPermissions(BASE_PERMISSIONS_UNDEFINED);
assertPermissions(BASE_PERMISSIONS_NOTUSED);
// **: Delete package using permissions; nothing to check here.
GenericReceiver receiver2 = new DeleteReceiver(ip2.pkg.packageName);
try {
invokeDeletePackage(ip2.pkg.packageName, 0, receiver);
ip2 = null;
} catch (Exception e) {
failStr(e);
}
// **: Re-install package using permissions; no permissions can be granted.
ip2 = installFromRawResource("install2.apk", i2Apk,
i2Flags, false,
false, -1, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
assertInstall(ip2.pkg, i2Flags, ip2.pkg.installLocation);
assertPermissions(BASE_PERMISSIONS_NOTUSED);
// **: Upon installing declaring package, are sig permissions granted
// to other apps (but not other perms)?
ip = installFromRawResource("install.apk", iApk,
iFlags, false,
false, -1, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
assertInstall(ip.pkg, iFlags, ip.pkg.installLocation);
assertPermissions(BASE_PERMISSIONS_DEFINED);
assertPermissions(BASE_PERMISSIONS_SIGUSED);
// **: Re-install package using permissions; are all permissions granted?
ip2 = installFromRawResource("install2.apk", i2Apk,
i2Flags | PackageManager.INSTALL_REPLACE_EXISTING, false,
false, -1, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
assertInstall(ip2.pkg, i2Flags, ip2.pkg.installLocation);
assertPermissions(BASE_PERMISSIONS_NOTUSED);
// **: Upon deleting package, are all permissions removed?
try {
invokeDeletePackage(ip.pkg.packageName, 0, receiver);
ip = null;
} catch (Exception e) {
failStr(e);
}
assertPermissions(BASE_PERMISSIONS_UNDEFINED);
assertPermissions(BASE_PERMISSIONS_NOTUSED);
// **: Delete package using permissions; nothing to check here.
try {
invokeDeletePackage(ip2.pkg.packageName, 0, receiver);
ip2 = null;
} catch (Exception e) {
failStr(e);
}
} finally {
if (ip2 != null) {
cleanUpInstall(ip2);
}
if (ip != null) {
cleanUpInstall(ip);
}
}
| | public void | testInstallFwdLockedInternal()
sampleInstallFromRawResource(PackageManager.INSTALL_FORWARD_LOCK, true);
| | public void | testInstallManifestSdcardUnmount()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
boolean origState = checkMediaState(Environment.MEDIA_MOUNTED);
try {
// Unmount sdcard
assertTrue(unmountMedia());
InstallParams ip = new InstallParams("install.apk", R.raw.install_loc_sdcard);
installFromRawResource(ip, 0, true, false, -1,
PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
} finally {
// Restore original media state
if (origState) {
mountMedia();
} else {
unmountMedia();
}
}
| | public void | testInstallNoCertificates()
int apk1 = APP1_UNSIGNED;
String apk1Name = "install1.apk";
InstallParams ip1 = null;
try {
installFromRawResource(apk1Name, apk1, 0, false,
true, PackageManager.INSTALL_PARSE_FAILED_NO_CERTIFICATES,
PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
} finally {
}
| | public void | testInstallNonexistentFile()
int retCode = PackageManager.INSTALL_FAILED_INVALID_URI;
File invalidFile = new File("/nonexistent-file.apk");
invokeInstallPackageFail(Uri.fromFile(invalidFile), 0, retCode);
| | public void | testInstallNormalInternal()
sampleInstallFromRawResource(0, true);
| | public void | testInstallOnSdPermissionsUnmount()
InstallParams ip = null;
boolean origMediaState = checkMediaState(Environment.MEDIA_MOUNTED);
try {
// **: Upon installing a package, are its declared permissions published?
int iFlags = PackageManager.INSTALL_INTERNAL;
int iApk = R.raw.install_decl_perm;
ip = installFromRawResource("install.apk", iApk,
iFlags, false,
false, -1, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
assertInstall(ip.pkg, iFlags, ip.pkg.installLocation);
assertPermissions(BASE_PERMISSIONS_DEFINED);
// Unmount media here
assertTrue(unmountMedia());
// Mount media again
mountMedia();
//Check permissions now
assertPermissions(BASE_PERMISSIONS_DEFINED);
} finally {
if (ip != null) {
cleanUpInstall(ip);
}
}
| | public void | testInstallSdcard()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
mountMedia();
sampleInstallFromRawResource(PackageManager.INSTALL_EXTERNAL, true);
| | public void | testInstallSdcardStaleContainer()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
boolean origMediaState = checkMediaState(Environment.MEDIA_MOUNTED);
try {
// Mount media first
mountMedia();
String outFileName = "install.apk";
int rawResId = R.raw.install;
PackageManager pm = mContext.getPackageManager();
File filesDir = mContext.getFilesDir();
File outFile = new File(filesDir, outFileName);
Uri packageURI = getInstallablePackage(rawResId, outFile);
PackageParser.Package pkg = parsePackage(packageURI);
assertNotNull(pkg);
// Install an app on sdcard.
installFromRawResource(outFileName, rawResId,
PackageManager.INSTALL_EXTERNAL, false,
false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
// Unmount sdcard
unmountMedia();
// Delete the app on sdcard to leave a stale container on sdcard.
GenericReceiver receiver = new DeleteReceiver(pkg.packageName);
assertTrue(invokeDeletePackage(pkg.packageName, 0, receiver));
mountMedia();
// Reinstall the app and make sure it gets installed.
installFromRawResource(outFileName, rawResId,
PackageManager.INSTALL_EXTERNAL, true,
false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
} catch (Exception e) {
failStr(e.getMessage());
} finally {
if (origMediaState) {
mountMedia();
} else {
unmountMedia();
}
}
| | public void | testInstallSdcardStaleContainerReinstall()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
boolean origMediaState = checkMediaState(Environment.MEDIA_MOUNTED);
try {
// Mount media first
mountMedia();
String outFileName = "install.apk";
int rawResId = R.raw.install;
PackageManager pm = mContext.getPackageManager();
File filesDir = mContext.getFilesDir();
File outFile = new File(filesDir, outFileName);
Uri packageURI = getInstallablePackage(rawResId, outFile);
PackageParser.Package pkg = parsePackage(packageURI);
assertNotNull(pkg);
// Install an app on sdcard.
installFromRawResource(outFileName, rawResId,
PackageManager.INSTALL_EXTERNAL, false,
false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
// Unmount sdcard
unmountMedia();
// Reinstall the app and make sure it gets installed on internal storage.
installFromRawResource(outFileName, rawResId,
PackageManager.INSTALL_REPLACE_EXISTING, false,
false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
mountMedia();
// Verify that the app installed is on internal storage.
assertInstall(pkg, 0, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
} catch (Exception e) {
failStr(e.getMessage());
} finally {
if (origMediaState) {
mountMedia();
} else {
unmountMedia();
}
}
| | public void | testInstallSdcardUnmount()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
boolean origState = checkMediaState(Environment.MEDIA_MOUNTED);
try {
// Unmount sdcard
assertTrue(unmountMedia());
// Try to install and make sure an error code is returned.
installFromRawResource("install.apk", R.raw.install,
PackageManager.INSTALL_EXTERNAL, false,
true, PackageManager.INSTALL_FAILED_MEDIA_UNAVAILABLE,
PackageInfo.INSTALL_LOCATION_AUTO);
} finally {
// Restore original media state
if (origState) {
mountMedia();
} else {
unmountMedia();
}
}
| | public void | testInstall_BadDex_CleanUp()
int retCode = PackageManager.INSTALL_FAILED_DEXOPT;
installFromRawResource("install.apk", R.raw.install_bad_dex, 0, true, true, retCode,
PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
| | public void | testIsSignedBy()
PackageManager pm = getPm();
String mPkgName = mContext.getPackageName();
String otherPkgName = "com.android.frameworks.coretests.keysets_api";
KeySet mSigningKS = pm.getSigningKeySet(mPkgName);
KeySet mDefinedKS = pm.getKeySetByAlias(mPkgName, "A");
try {
assertFalse(pm.isSignedBy(null, null));
assertTrue(false); // should have thrown
} catch (NullPointerException e) {
}
try {
assertFalse(pm.isSignedBy(null, mSigningKS));
assertTrue(false); // should have thrown
} catch (NullPointerException e) {
}
try {
assertFalse(pm.isSignedBy(mPkgName, null));
assertTrue(false); // should have thrown
} catch (NullPointerException e) {
}
try {
assertFalse(pm.isSignedBy("keysets.test.bogus.package", mDefinedKS));
} catch(IllegalArgumentException e) {
}
assertFalse(pm.isSignedBy(mPkgName, mDefinedKS));
assertFalse(pm.isSignedBy(mPkgName, new KeySet(new Binder())));
assertTrue(pm.isSignedBy(mPkgName, mSigningKS));
installFromRawResource("keysetApi.apk", R.raw.keyset_splat_api,
0, false, false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
assertFalse(pm.isSignedBy(otherPkgName, mDefinedKS));
assertTrue(pm.isSignedBy(otherPkgName, mSigningKS));
cleanUpInstall(otherPkgName);
installFromRawResource("keysetApi.apk", R.raw.keyset_splata_api,
0, false, false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
assertTrue(pm.isSignedBy(otherPkgName, mDefinedKS));
assertTrue(pm.isSignedBy(otherPkgName, mSigningKS));
cleanUpInstall(otherPkgName);
| | public void | testIsSignedByExactly()
PackageManager pm = getPm();
String mPkgName = mContext.getPackageName();
String otherPkgName = "com.android.frameworks.coretests.keysets_api";
KeySet mSigningKS = pm.getSigningKeySet(mPkgName);
KeySet mDefinedKS = pm.getKeySetByAlias(mPkgName, "A");
try {
assertFalse(pm.isSignedBy(null, null));
assertTrue(false); // should have thrown
} catch (NullPointerException e) {
}
try {
assertFalse(pm.isSignedBy(null, mSigningKS));
assertTrue(false); // should have thrown
} catch (NullPointerException e) {
}
try {
assertFalse(pm.isSignedBy(mPkgName, null));
assertTrue(false); // should have thrown
} catch (NullPointerException e) {
}
try {
assertFalse(pm.isSignedByExactly("keysets.test.bogus.package", mDefinedKS));
} catch(IllegalArgumentException e) {
}
assertFalse(pm.isSignedByExactly(mPkgName, mDefinedKS));
assertFalse(pm.isSignedByExactly(mPkgName, new KeySet(new Binder())));
assertTrue(pm.isSignedByExactly(mPkgName, mSigningKS));
installFromRawResource("keysetApi.apk", R.raw.keyset_splat_api,
0, false, false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
assertFalse(pm.isSignedByExactly(otherPkgName, mDefinedKS));
assertTrue(pm.isSignedByExactly(otherPkgName, mSigningKS));
cleanUpInstall(otherPkgName);
installFromRawResource("keysetApi.apk", R.raw.keyset_splata_api,
0, false, false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
assertFalse(pm.isSignedByExactly(otherPkgName, mDefinedKS));
assertFalse(pm.isSignedByExactly(otherPkgName, mSigningKS));
cleanUpInstall(otherPkgName);
| | public void | testManifestA()
installFromRawResource("install.apk", R.raw.install_loc_auto,
0,
true,
false, -1,
PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
| | public void | testManifestAExistingE()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int iFlags = PackageManager.INSTALL_EXTERNAL;
int rFlags = PackageManager.INSTALL_REPLACE_EXISTING;
// First install.
installFromRawResource("install.apk", R.raw.install,
iFlags,
false,
false, -1,
-1);
// Replace now
installFromRawResource("install.apk", R.raw.install_loc_auto,
rFlags,
true,
false, -1,
PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL);
| | public void | testManifestAExistingI()
int iFlags = PackageManager.INSTALL_INTERNAL;
int rFlags = PackageManager.INSTALL_REPLACE_EXISTING;
// First install.
installFromRawResource("install.apk", R.raw.install,
iFlags,
false,
false, -1,
-1);
// Replace now
installFromRawResource("install.apk", R.raw.install_loc_auto,
rFlags,
true,
false, -1,
PackageInfo.INSTALL_LOCATION_AUTO);
| | public void | testManifestE()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
installFromRawResource("install.apk", R.raw.install_loc_sdcard,
0,
true,
false, -1,
PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL);
| | public void | testManifestEExistingE()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int iFlags = PackageManager.INSTALL_EXTERNAL;
int rFlags = PackageManager.INSTALL_REPLACE_EXISTING;
// First install.
installFromRawResource("install.apk", R.raw.install,
iFlags,
false,
false, -1,
-1);
// Replace now
installFromRawResource("install.apk", R.raw.install_loc_sdcard,
rFlags,
true,
false, -1,
PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL);
| | public void | testManifestEExistingI()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int iFlags = PackageManager.INSTALL_INTERNAL;
int rFlags = PackageManager.INSTALL_REPLACE_EXISTING;
// First install.
installFromRawResource("install.apk", R.raw.install,
iFlags,
false,
false, -1,
-1);
// Replace now
installFromRawResource("install.apk", R.raw.install_loc_sdcard,
rFlags,
true,
false, -1,
PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL);
| | public void | testManifestI()
installFromRawResource("install.apk", R.raw.install_loc_internal,
0,
true,
false, -1,
PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
| | public void | testManifestIExistingE()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int iFlags = PackageManager.INSTALL_EXTERNAL;
int rFlags = PackageManager.INSTALL_REPLACE_EXISTING;
// First install.
installFromRawResource("install.apk", R.raw.install,
iFlags,
false,
false, -1,
-1);
// Replace now
installFromRawResource("install.apk", R.raw.install_loc_internal,
rFlags,
true,
false, -1,
PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
| | public void | testManifestIExistingI()
int iFlags = PackageManager.INSTALL_INTERNAL;
int rFlags = PackageManager.INSTALL_REPLACE_EXISTING;
// First install.
installFromRawResource("install.apk", R.raw.install,
iFlags,
false,
false, -1,
-1);
// Replace now
installFromRawResource("install.apk", R.raw.install_loc_internal,
rFlags,
true,
false, -1,
PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
| | public void | testManifestInstallLocationAuto()
installFromRawResource("install.apk", R.raw.install_loc_auto,
0, true, false, -1, PackageInfo.INSTALL_LOCATION_AUTO);
| | public void | testManifestInstallLocationFwdLockedFlagSdcard()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
installFromRawResource("install.apk", R.raw.install_loc_unspecified,
PackageManager.INSTALL_FORWARD_LOCK |
PackageManager.INSTALL_EXTERNAL, true, false, -1,
PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL);
| | public void | testManifestInstallLocationFwdLockedSdcard()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
installFromRawResource("install.apk", R.raw.install_loc_sdcard,
PackageManager.INSTALL_FORWARD_LOCK, true, false, -1,
PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL);
| | public void | testManifestInstallLocationInternal()
installFromRawResource("install.apk", R.raw.install_loc_internal,
0, true, false, -1, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
| | public void | testManifestInstallLocationReplaceInternalSdcard()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int iFlags = 0;
int iApk = R.raw.install_loc_internal;
int rFlags = 0;
int rApk = R.raw.install_loc_sdcard;
InstallParams ip = installFromRawResource("install.apk", iApk,
iFlags, false,
false, -1, PackageInfo.INSTALL_LOCATION_INTERNAL_ONLY);
GenericReceiver receiver = new ReplaceReceiver(ip.pkg.packageName);
int replaceFlags = rFlags | PackageManager.INSTALL_REPLACE_EXISTING;
try {
InstallParams rp = installFromRawResource("install.apk", rApk,
replaceFlags, false,
false, -1, PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL);
assertInstall(rp.pkg, replaceFlags, rp.pkg.installLocation);
} catch (Exception e) {
failStr("Failed with exception : " + e);
} finally {
cleanUpInstall(ip);
}
| | public void | testManifestInstallLocationReplaceSdcardInternal()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int iFlags = 0;
int iApk = R.raw.install_loc_sdcard;
int rFlags = 0;
int rApk = R.raw.install_loc_unspecified;
InstallParams ip = installFromRawResource("install.apk", iApk,
iFlags, false,
false, -1, PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL);
int replaceFlags = rFlags | PackageManager.INSTALL_REPLACE_EXISTING;
try {
InstallParams rp = installFromRawResource("install.apk", rApk,
replaceFlags, false,
false, -1, PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL);
assertInstall(rp.pkg, replaceFlags, ip.pkg.installLocation);
} catch (Exception e) {
failStr("Failed with exception : " + e);
} finally {
cleanUpInstall(ip);
}
| | public void | testManifestInstallLocationSdcard()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
installFromRawResource("install.apk", R.raw.install_loc_sdcard,
0, true, false, -1, PackageInfo.INSTALL_LOCATION_PREFER_EXTERNAL);
| | public void | testManifestInstallLocationUnspecified()
installFromRawResource("install.apk", R.raw.install_loc_unspecified,
0, true, false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
| | public void | testMountSdNormalInternal()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
assertTrue(mountFromRawResource());
| | public void | testMoveAppExternalToExternal()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int installFlags = PackageManager.INSTALL_EXTERNAL;
int moveFlags = PackageManager.MOVE_EXTERNAL_MEDIA;
boolean fail = true;
int result = PackageManager.MOVE_FAILED_INVALID_LOCATION;
sampleMoveFromRawResource(installFlags, moveFlags, fail, result);
| | public void | testMoveAppExternalToInternal()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int installFlags = PackageManager.INSTALL_EXTERNAL;
int moveFlags = PackageManager.MOVE_INTERNAL;
boolean fail = false;
int result = PackageManager.MOVE_SUCCEEDED;
sampleMoveFromRawResource(installFlags, moveFlags, fail, result);
| | public void | testMoveAppFailInternalToExternalDelete()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int installFlags = 0;
int moveFlags = PackageManager.MOVE_EXTERNAL_MEDIA;
boolean fail = true;
final int result = PackageManager.MOVE_FAILED_DOESNT_EXIST;
int rawResId = R.raw.install;
int origDefaultLoc = getDefaultInstallLoc();
InstallParams ip = null;
try {
PackageManager pm = getPm();
setInstallLoc(PackageHelper.APP_INSTALL_AUTO);
// Install first
ip = installFromRawResource("install.apk", R.raw.install, installFlags, false,
false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
// Delete the package now retaining data.
GenericReceiver receiver = new DeleteReceiver(ip.pkg.packageName);
invokeDeletePackage(ip.pkg.packageName, PackageManager.DELETE_KEEP_DATA, receiver);
assertTrue(invokeMovePackageFail(ip.pkg.packageName, moveFlags, result));
} catch (Exception e) {
failStr(e);
} finally {
if (ip != null) {
cleanUpInstall(ip);
}
// Restore default install location
setInstallLoc(origDefaultLoc);
}
| | public void | testMoveAppForwardLocked()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int installFlags = PackageManager.INSTALL_FORWARD_LOCK;
int moveFlags = PackageManager.MOVE_EXTERNAL_MEDIA;
boolean fail = false;
int result = PackageManager.MOVE_SUCCEEDED;
sampleMoveFromRawResource(installFlags, moveFlags, fail, result);
| | public void | testMoveAppInternalToExternal()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int installFlags = PackageManager.INSTALL_INTERNAL;
int moveFlags = PackageManager.MOVE_EXTERNAL_MEDIA;
boolean fail = false;
int result = PackageManager.MOVE_SUCCEEDED;
sampleMoveFromRawResource(installFlags, moveFlags, fail, result);
| | public void | testMoveAppInternalToInternal()
int installFlags = PackageManager.INSTALL_INTERNAL;
int moveFlags = PackageManager.MOVE_INTERNAL;
boolean fail = true;
int result = PackageManager.MOVE_FAILED_INVALID_LOCATION;
sampleMoveFromRawResource(installFlags, moveFlags, fail, result);
| | public void | testMultipleUpgradeKSWithSigningKey()
replaceCerts(R.raw.keyset_sau_ub, R.raw.keyset_sa_ua, true, true,
PackageManager.INSTALL_FAILED_UPDATE_INCOMPATIBLE);
| | public void | testMultipleUpgradeKSWithUpgradeKey()
replaceCerts(R.raw.keyset_sa_ua, R.raw.keyset_sab_ua, true, false, -1);
| | public void | testNoKSToUpgradeKS()The following tests are related to testing KeySets-based key rotation
replaceCerts(R.raw.keyset_sa_unone, R.raw.keyset_sa_ua, true, false, -1);
| | public void | testReplaceFailFwdLockedInternal()
sampleReplaceFromRawResource(PackageManager.INSTALL_FORWARD_LOCK);
| | public void | testReplaceFailNormalInternal()
sampleReplaceFromRawResource(0);
| | public void | testReplaceFailSdcard()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
sampleReplaceFromRawResource(PackageManager.INSTALL_EXTERNAL);
| | public void | testReplaceFirstSharedMatchAllCerts()
int apk1 = SHARED1_CERT1;
int apk2 = SHARED2_CERT1;
int rapk1 = SHARED1_CERT1;
checkSignatures(apk1, apk2, PackageManager.SIGNATURE_MATCH);
replaceCerts(apk1, rapk1, true, false, -1);
| | public void | testReplaceFirstSharedMatchMoreCerts()
int apk1 = SHARED1_CERT1;
int apk2 = SHARED2_CERT1;
int rapk1 = SHARED1_CERT1_CERT2;
boolean fail = true;
int retCode = PackageManager.INSTALL_FAILED_UPDATE_INCOMPATIBLE;
checkSharedSignatures(apk1, apk2, false, false, -1, PackageManager.SIGNATURE_MATCH);
installFromRawResource("install.apk", rapk1, PackageManager.INSTALL_REPLACE_EXISTING, true,
fail, retCode, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
| | public void | testReplaceFirstSharedMatchNoCerts()
int apk1 = SHARED1_CERT1;
int apk2 = SHARED2_CERT1;
int rapk1 = SHARED1_CERT2;
boolean fail = true;
int retCode = PackageManager.INSTALL_FAILED_UPDATE_INCOMPATIBLE;
checkSharedSignatures(apk1, apk2, false, false, -1, PackageManager.SIGNATURE_MATCH);
installFromRawResource("install.apk", rapk1, PackageManager.INSTALL_REPLACE_EXISTING, true,
fail, retCode, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
| | public void | testReplaceFirstSharedMatchSomeCerts()
int apk1 = SHARED1_CERT1_CERT2;
int apk2 = SHARED2_CERT1_CERT2;
int rapk1 = SHARED1_CERT1;
boolean fail = true;
int retCode = PackageManager.INSTALL_FAILED_UPDATE_INCOMPATIBLE;
checkSharedSignatures(apk1, apk2, false, false, -1, PackageManager.SIGNATURE_MATCH);
installFromRawResource("install.apk", rapk1, PackageManager.INSTALL_REPLACE_EXISTING, true,
fail, retCode, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
| | public void | testReplaceFlagInternalSdcard()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int iFlags = 0;
int rFlags = PackageManager.INSTALL_EXTERNAL;
InstallParams ip = sampleInstallFromRawResource(iFlags, false);
GenericReceiver receiver = new ReplaceReceiver(ip.pkg.packageName);
int replaceFlags = rFlags | PackageManager.INSTALL_REPLACE_EXISTING;
try {
invokeInstallPackage(ip.packageURI, replaceFlags, receiver, true);
assertInstall(ip.pkg, rFlags, ip.pkg.installLocation);
} catch (Exception e) {
failStr("Failed with exception : " + e);
} finally {
cleanUpInstall(ip);
}
| | public void | testReplaceFlagSdcardInternal()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int iFlags = PackageManager.INSTALL_EXTERNAL;
int rFlags = 0;
InstallParams ip = sampleInstallFromRawResource(iFlags, false);
GenericReceiver receiver = new ReplaceReceiver(ip.pkg.packageName);
int replaceFlags = rFlags | PackageManager.INSTALL_REPLACE_EXISTING;
try {
invokeInstallPackage(ip.packageURI, replaceFlags, receiver, true);
assertInstall(ip.pkg, iFlags, ip.pkg.installLocation);
} catch (Exception e) {
failStr("Failed with exception : " + e);
} finally {
cleanUpInstall(ip);
}
| | public void | testReplaceFwdLockedInternal()
sampleReplaceFromRawResource(PackageManager.INSTALL_REPLACE_EXISTING
| PackageManager.INSTALL_FORWARD_LOCK);
| | public void | testReplaceMatchAllCerts()
replaceCerts(APP1_CERT1_CERT2, APP1_CERT1_CERT2, true, false, -1);
| | public void | testReplaceMatchMoreCerts()
replaceCerts(APP1_CERT1, APP1_CERT1_CERT2, true, true,
PackageManager.INSTALL_FAILED_UPDATE_INCOMPATIBLE);
| | public void | testReplaceMatchMoreCertsReplaceSomeCerts()
InstallParams ip = replaceCerts(APP1_CERT1, APP1_CERT1_CERT2, false, true,
PackageManager.INSTALL_FAILED_UPDATE_INCOMPATIBLE);
try {
int rFlags = PackageManager.INSTALL_REPLACE_EXISTING;
installFromRawResource("install.apk", APP1_CERT1, rFlags, false,
false, -1,
PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
} catch (Exception e) {
failStr(e.getMessage());
} finally {
if (ip != null) {
cleanUpInstall(ip);
}
}
| | public void | testReplaceMatchNoCerts1()
replaceCerts(APP1_CERT1_CERT2, APP1_CERT3, true, true,
PackageManager.INSTALL_FAILED_UPDATE_INCOMPATIBLE);
| | public void | testReplaceMatchNoCerts2()
replaceCerts(APP1_CERT1_CERT2, APP1_CERT3_CERT4, true, true,
PackageManager.INSTALL_FAILED_UPDATE_INCOMPATIBLE);
| | public void | testReplaceMatchSomeCerts1()
replaceCerts(APP1_CERT1_CERT2, APP1_CERT1, true, true,
PackageManager.INSTALL_FAILED_UPDATE_INCOMPATIBLE);
| | public void | testReplaceMatchSomeCerts2()
replaceCerts(APP1_CERT1_CERT2, APP1_CERT2, true, true,
PackageManager.INSTALL_FAILED_UPDATE_INCOMPATIBLE);
| | public void | testReplaceNormalInternal()
sampleReplaceFromRawResource(PackageManager.INSTALL_REPLACE_EXISTING);
| | public void | testReplaceSdcard()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
sampleReplaceFromRawResource(PackageManager.INSTALL_REPLACE_EXISTING
| PackageManager.INSTALL_EXTERNAL);
| | public void | testReplaceSecondSharedMatchAllCerts()
int apk1 = SHARED1_CERT1;
int apk2 = SHARED2_CERT1;
int rapk2 = SHARED2_CERT1;
checkSignatures(apk1, apk2, PackageManager.SIGNATURE_MATCH);
replaceCerts(apk2, rapk2, true, false, -1);
| | public void | testReplaceSecondSharedMatchMoreCerts()
int apk1 = SHARED1_CERT1;
int apk2 = SHARED2_CERT1;
int rapk2 = SHARED2_CERT1_CERT2;
boolean fail = true;
int retCode = PackageManager.INSTALL_FAILED_UPDATE_INCOMPATIBLE;
checkSharedSignatures(apk1, apk2, false, false, -1, PackageManager.SIGNATURE_MATCH);
installFromRawResource("install.apk", rapk2, PackageManager.INSTALL_REPLACE_EXISTING, true,
fail, retCode, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
| | public void | testReplaceSecondSharedMatchNoCerts()
int apk1 = SHARED1_CERT1;
int apk2 = SHARED2_CERT1;
int rapk2 = SHARED2_CERT2;
boolean fail = true;
int retCode = PackageManager.INSTALL_FAILED_UPDATE_INCOMPATIBLE;
checkSharedSignatures(apk1, apk2, false, false, -1, PackageManager.SIGNATURE_MATCH);
installFromRawResource("install.apk", rapk2, PackageManager.INSTALL_REPLACE_EXISTING, true,
fail, retCode, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
| | public void | testReplaceSecondSharedMatchSomeCerts()
int apk1 = SHARED1_CERT1_CERT2;
int apk2 = SHARED2_CERT1_CERT2;
int rapk2 = SHARED2_CERT1;
boolean fail = true;
int retCode = PackageManager.INSTALL_FAILED_UPDATE_INCOMPATIBLE;
checkSharedSignatures(apk1, apk2, false, false, -1, PackageManager.SIGNATURE_MATCH);
installFromRawResource("install.apk", rapk2, PackageManager.INSTALL_REPLACE_EXISTING, true,
fail, retCode, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
| | public void | testSigAddedAfterUpgrade()
// install original apk and grab sigs
installFromRawResource("tmp.apk", R.raw.keyset_sa_ua,
0, false, false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
PackageManager pm = getPm();
String pkgName = "com.android.frameworks.coretests.keysets";
PackageInfo pi = pm.getPackageInfo(pkgName, PackageManager.GET_SIGNATURES);
assertTrue("Package should only have one signature, sig A",
pi.signatures.length == 1);
String sigBefore = pi.signatures[0].toCharsString();
// install apk signed subset upgrade KeySet
installFromRawResource("tmp2.apk", R.raw.keyset_sab_ua,
PackageManager.INSTALL_REPLACE_EXISTING, false, false, -1,
PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
pi = pm.getPackageInfo(pkgName, PackageManager.GET_SIGNATURES);
assertTrue("Package should have two signatures, sig A and sig B",
pi.signatures.length == 2);
Set<String> sigsAfter = new HashSet<String>();
for (int i = 0; i < pi.signatures.length; i++) {
sigsAfter.add(pi.signatures[i].toCharsString());
}
assertTrue("Package signatures did not change after upgrade!",
sigsAfter.contains(sigBefore));
cleanUpInstall(pkgName);
| | public void | testSigChangeAfterUpgrade()
// install original apk and grab sigs
installFromRawResource("tmp.apk", R.raw.keyset_sa_ub,
0, false, false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
PackageManager pm = getPm();
String pkgName = "com.android.frameworks.coretests.keysets";
PackageInfo pi = pm.getPackageInfo(pkgName, PackageManager.GET_SIGNATURES);
assertTrue("Package should only have one signature, sig A",
pi.signatures.length == 1);
String sigBefore = pi.signatures[0].toCharsString();
// install apk signed by different upgrade KeySet
installFromRawResource("tmp2.apk", R.raw.keyset_sb_ub,
PackageManager.INSTALL_REPLACE_EXISTING, false, false, -1,
PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
pi = pm.getPackageInfo(pkgName, PackageManager.GET_SIGNATURES);
assertTrue("Package should only have one signature, sig B",
pi.signatures.length == 1);
String sigAfter = pi.signatures[0].toCharsString();
assertFalse("Package signatures did not change after upgrade!",
sigBefore.equals(sigAfter));
cleanUpInstall(pkgName);
| | public void | testSigRemovedAfterUpgrade()
// install original apk and grab sigs
installFromRawResource("tmp.apk", R.raw.keyset_sab_ua,
0, false, false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
PackageManager pm = getPm();
String pkgName = "com.android.frameworks.coretests.keysets";
PackageInfo pi = pm.getPackageInfo(pkgName, PackageManager.GET_SIGNATURES);
assertTrue("Package should have two signatures, sig A and sig B",
pi.signatures.length == 2);
Set<String> sigsBefore = new HashSet<String>();
for (int i = 0; i < pi.signatures.length; i++) {
sigsBefore.add(pi.signatures[i].toCharsString());
}
// install apk signed subset upgrade KeySet
installFromRawResource("tmp2.apk", R.raw.keyset_sa_ua,
PackageManager.INSTALL_REPLACE_EXISTING, false, false, -1,
PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
pi = pm.getPackageInfo(pkgName, PackageManager.GET_SIGNATURES);
assertTrue("Package should only have one signature, sig A",
pi.signatures.length == 1);
String sigAfter = pi.signatures[0].toCharsString();
assertTrue("Original package signatures did not contain new sig",
sigsBefore.contains(sigAfter));
cleanUpInstall(pkgName);
| | public void | testSigSameAfterUpgrade()
// install original apk and grab sigs
installFromRawResource("tmp.apk", R.raw.keyset_sa_ua,
0, false, false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
PackageManager pm = getPm();
String pkgName = "com.android.frameworks.coretests.keysets";
PackageInfo pi = pm.getPackageInfo(pkgName, PackageManager.GET_SIGNATURES);
assertTrue("Package should only have one signature, sig A",
pi.signatures.length == 1);
String sigBefore = pi.signatures[0].toCharsString();
// install apk signed by same upgrade KeySet
installFromRawResource("tmp2.apk", R.raw.keyset_sa_ua,
PackageManager.INSTALL_REPLACE_EXISTING, false, false, -1,
PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
pi = pm.getPackageInfo(pkgName, PackageManager.GET_SIGNATURES);
assertTrue("Package should only have one signature, sig A",
pi.signatures.length == 1);
String sigAfter = pi.signatures[0].toCharsString();
assertTrue("Package signatures changed after upgrade!",
sigBefore.equals(sigAfter));
cleanUpInstall(pkgName);
| | public void | testUpgradeKSToNoKS()
replaceCerts(R.raw.keyset_sa_ua, R.raw.keyset_sa_unone, true, false, -1);
| | public void | testUpgradeKSWithMultipleUpgradeKeySets()
replaceCerts(R.raw.keyset_sa_ua_ub, R.raw.keyset_sa_ua, true, false, -1);
replaceCerts(R.raw.keyset_sa_ua_ub, R.raw.keyset_sb_ub, true, false, -1);
| | public void | testUpgradeKSWithSigningUpgradeKey()
replaceCerts(R.raw.keyset_sa_ua, R.raw.keyset_sa_ua, true, false, -1);
| | public void | testUpgradeKSWithUpgradeKey()
replaceCerts(R.raw.keyset_sa_ub, R.raw.keyset_sb_ub, true, false, -1);
| | public void | testUpgradeKSWithWrongKey()
replaceCerts(R.raw.keyset_sa_ua, R.raw.keyset_sb_ua, true, true,
PackageManager.INSTALL_FAILED_UPDATE_INCOMPATIBLE);
| | public void | testUpgradeKSWithWrongSigningKey()
replaceCerts(R.raw.keyset_sa_ub, R.raw.keyset_sa_ub, true, true,
PackageManager.INSTALL_FAILED_UPDATE_INCOMPATIBLE);
| | public void | testUpgradeSigPermGained()
// install apk which defines permission
installFromRawResource("permDef.apk", R.raw.keyset_permdef_sa_unone,
0, false, false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
// install apk which uses permission but does not have sig
installFromRawResource("permUse.apk", R.raw.keyset_permuse_sb_ua_ub,
0, false, false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
// verify that package does not have perm before
PackageManager pm = getPm();
String permPkgName = "com.android.frameworks.coretests.keysets_permdef";
String pkgName = "com.android.frameworks.coretests.keysets";
String permName = "com.android.frameworks.coretests.keysets_permdef.keyset_perm";
assertFalse("keyset permission granted to app without same signature!",
pm.checkPermission(permName, pkgName)
== PackageManager.PERMISSION_GRANTED);
// upgrade to apk with perm signature
installFromRawResource("permUse2.apk", R.raw.keyset_permuse_sa_ua_ub,
PackageManager.INSTALL_REPLACE_EXISTING, false, false, -1,
PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
assertTrue("keyset permission not granted to app after upgrade to same sig",
pm.checkPermission(permName, pkgName)
== PackageManager.PERMISSION_GRANTED);
cleanUpInstall(permPkgName);
cleanUpInstall(pkgName);
| | public void | testUpgradeSigPermLost()
// install apk which defines permission
installFromRawResource("permDef.apk", R.raw.keyset_permdef_sa_unone,
0, false, false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
// install apk which uses permission, signed by same sig
installFromRawResource("permUse.apk", R.raw.keyset_permuse_sa_ua_ub,
0, false, false, -1, PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
// verify that package does not have perm before
PackageManager pm = getPm();
String permPkgName = "com.android.frameworks.coretests.keysets_permdef";
String pkgName = "com.android.frameworks.coretests.keysets";
String permName = "com.android.frameworks.coretests.keysets_permdef.keyset_perm";
assertTrue("keyset permission not granted to app with same sig",
pm.checkPermission(permName, pkgName)
== PackageManager.PERMISSION_GRANTED);
// upgrade to apk without perm signature
installFromRawResource("permUse2.apk", R.raw.keyset_permuse_sb_ua_ub,
PackageManager.INSTALL_REPLACE_EXISTING, false, false, -1,
PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
assertFalse("keyset permission not revoked from app which upgraded to a "
+ "different signature",
pm.checkPermission(permName, pkgName)
== PackageManager.PERMISSION_GRANTED);
cleanUpInstall(permPkgName);
cleanUpInstall(pkgName);
| | public void | testUserA()
int userSetting = PackageHelper.APP_INSTALL_AUTO;
int iloc = getExpectedInstallLocation(userSetting);
setUserX(true, userSetting, iloc);
| | public void | testUserE()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int userSetting = PackageHelper.APP_INSTALL_EXTERNAL;
int iloc = getExpectedInstallLocation(userSetting);
setUserX(true, userSetting, iloc);
| | public void | testUserI()
int userSetting = PackageHelper.APP_INSTALL_INTERNAL;
int iloc = getExpectedInstallLocation(userSetting);
setUserX(true, userSetting, iloc);
| | public void | testUserPrefOffA()
int userSetting = PackageHelper.APP_INSTALL_AUTO;
int iloc = PackageInfo.INSTALL_LOCATION_UNSPECIFIED;
setUserX(false, userSetting, iloc);
| | public void | testUserPrefOffUserE()
// Do not run on devices with emulated external storage.
if (Environment.isExternalStorageEmulated()) {
return;
}
int userSetting = PackageHelper.APP_INSTALL_EXTERNAL;
int iloc = PackageInfo.INSTALL_LOCATION_UNSPECIFIED;
setUserX(false, userSetting, iloc);
| | public void | testUserPrefOffUserI()
int userSetting = PackageHelper.APP_INSTALL_INTERNAL;
int iloc = PackageInfo.INSTALL_LOCATION_UNSPECIFIED;
setUserX(false, userSetting, iloc);
| | public void | testUsesFeatureUnknownFeature()Unknown features should be allowed to install. This prevents older phones
from rejecting new packages that specify features that didn't exist when
an older phone existed. All older phones are assumed to have those
features.
Right now we allow all packages to be installed regardless of their
features.
int retCode = PackageManager.INSTALL_SUCCEEDED;
installFromRawResource("install.apk", R.raw.install_uses_feature, 0, true, false, retCode,
PackageInfo.INSTALL_LOCATION_UNSPECIFIED);
| | private boolean | unmountMedia()
// We can't unmount emulated storage.
if (Environment.isExternalStorageEmulated()) {
return true;
}
if (checkMediaState(Environment.MEDIA_UNMOUNTED)) {
return true;
}
final String path = Environment.getExternalStorageDirectory().getPath();
StorageListener observer = new StorageListener(Environment.MEDIA_UNMOUNTED);
StorageManager sm = (StorageManager) mContext.getSystemService(Context.STORAGE_SERVICE);
sm.registerListener(observer);
try {
// Wait on observer
synchronized (observer) {
getMs().unmountVolume(path, true, false);
long waitTime = 0;
while ((!observer.isDone()) && (waitTime < MAX_WAIT_TIME)) {
observer.wait(WAIT_TIME_INCR);
waitTime += WAIT_TIME_INCR;
}
if (!observer.isDone()) {
throw new Exception("Timed out waiting for unmount media notification");
}
return true;
}
} catch (Exception e) {
Log.e(TAG, "Exception : " + e);
return false;
} finally {
sm.unregisterListener(observer);
}
|
|
