1 /* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.framework.tests; 18 19 import com.android.tradefed.config.Option; 20 import com.android.tradefed.config.Option.Importance; 21 import com.android.tradefed.device.DeviceNotAvailableException; 22 import com.android.tradefed.log.LogUtil.CLog; 23 import com.android.tradefed.testtype.DeviceTestCase; 24 import com.android.tradefed.util.FileUtil; 25 26 import java.io.File; 27 28 public class PackageManagerOTATests extends DeviceTestCase { 29 30 @Option(name = "test-app-path", description = 31 "path to the app repository containing test apks", importance = Importance.IF_UNSET) 32 private File mTestAppRepositoryPath = null; 33 @Option(name = "use-priv-path", description = 34 "set to true if the special priviledged app directory should be used; default is false", 35 importance = Importance.IF_UNSET) 36 private boolean mUsePrivAppDirectory = false; 37 38 private PackageManagerOTATestUtils mUtils = null; 39 private String mSystemAppPath = "/system/app/version_test.apk"; 40 private String mDiffSystemAppPath = "/system/app/version_test_diff.apk"; 41 42 // String constants use for the tests. 43 private static final String PACKAGE_XPATH = "/packages/package[@name=\"" + 44 "com.android.frameworks.coretests.version_test\"]"; 45 private static final String UPDATE_PACKAGE_XPATH = "/packages/updated-package[@name=\"" + 46 "com.android.frameworks.coretests.version_test\"]"; 47 private static final String VERSION_XPATH = "/packages/package[@name=\"" + 48 "com.android.frameworks.coretests.version_test\"]/@version"; 49 private static final String CODE_PATH_XPATH = "/packages/package[@name=\"" + 50 "com.android.frameworks.coretests.version_test\"]/@codePath"; 51 private static final String VERSION_1_APK = "FrameworkCoreTests_version_1.apk"; 52 private static final String VERSION_2_APK = "FrameworkCoreTests_version_2.apk"; 53 private static final String VERSION_3_APK = "FrameworkCoreTests_version_3.apk"; 54 private static final String VERSION_1_NO_SYS_PERMISSION_APK = 55 "FrameworkCoreTests_version_1_nosys.apk"; 56 private static final String DATA_APP_DIRECTORY = "/data/app/"; 57 private static final String PACKAGE_NAME = "com.android.frameworks.coretests.version_test"; 58 private static final String VIBRATE_PERMISSION = "android.permission.VIBRATE"; 59 private static final String CACHE_PERMISSION = "android.permission.ACCESS_CACHE_FILESYSTEM"; 60 61 62 // Temporary file used when examine the packages xml file from the device. 63 private File mPackageXml = null; 64 65 @Override 66 protected void setUp() throws Exception { 67 super.setUp(); 68 mUtils = new PackageManagerOTATestUtils(getDevice()); 69 70 if (mUsePrivAppDirectory) { 71 mSystemAppPath = "/system/priv-app/version_test.apk"; 72 mDiffSystemAppPath = "/system/priv-app/version_test_diff.apk"; 73 } 74 75 // Clean up any potential old files from previous tests. 76 // delete from /system if exists 77 getDevice().enableAdbRoot(); 78 mUtils.removeSystemApp(mSystemAppPath, false); 79 mUtils.removeSystemApp(mDiffSystemAppPath, false); 80 mUtils.restartSystem(); 81 // delete from /data if there is one 82 getDevice().uninstallPackage(PACKAGE_NAME); 83 84 String res = getDevice().executeShellCommand("pm path " + PACKAGE_NAME).trim(); 85 assertTrue("Package should not be installed before test", res.isEmpty()); 86 } 87 88 @Override 89 protected void tearDown() throws Exception { 90 // Clean up. 91 if (mPackageXml != null) { 92 FileUtil.deleteFile(mPackageXml); 93 } 94 } 95 96 /** 97 * Get the absolute file system location of test app with given filename 98 * 99 * @param fileName the file name of the test app apk 100 * @return {@link String} of absolute file path 101 */ 102 public File getTestAppFilePath(String fileName) { 103 // need to check both data/app/apkFileName and 104 // data/app/apkFileName/apkFileName 105 File file = FileUtil.getFileForPath(mTestAppRepositoryPath, fileName); 106 if (file.exists()) { 107 return file; 108 } 109 110 int index = fileName.lastIndexOf('.'); 111 String dir = fileName.substring(0, index); 112 file = FileUtil.getFileForPath(mTestAppRepositoryPath, dir, fileName); 113 CLog.d("Test path : %s", file.getAbsolutePath()); 114 return file; 115 } 116 117 /** 118 * Test case when system app added is newer than update. 119 * <p/> 120 * Assumes adb is running as root in device under test. 121 * 122 * @throws DeviceNotAvailableException 123 */ 124 public void testSystemAppAddedNewerThanUpdate() throws DeviceNotAvailableException { 125 mUtils.installFile(getTestAppFilePath(VERSION_1_APK), true); 126 mPackageXml = mUtils.pullPackagesXML(); 127 assertNotNull("Failed to pull packages xml file from device", mPackageXml); 128 assertTrue("Initial package should be installed", 129 mUtils.expectExists(mPackageXml, PACKAGE_XPATH)); 130 assertTrue("Package version should be 1", 131 mUtils.expectEquals(mPackageXml, VERSION_XPATH, "1")); 132 assertFalse("Updated-package should not be present", 133 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 134 assertFalse("Package should not have FLAG_SYSTEM", 135 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 136 assertTrue("VIBRATE permission should be granted", 137 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 138 assertFalse("ACCESS_CACHE_FILESYSTEM permission should NOT be granted", 139 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 140 141 mUtils.pushSystemApp(getTestAppFilePath(VERSION_2_APK), mSystemAppPath); 142 mPackageXml = mUtils.pullPackagesXML(); 143 assertTrue("After system app push, package should still be installed", 144 mUtils.expectExists(mPackageXml, PACKAGE_XPATH)); 145 assertTrue("After system app push, system app should be visible", 146 mUtils.expectEquals(mPackageXml, VERSION_XPATH, "2")); 147 assertFalse("Updated-package should not be present", 148 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 149 assertTrue("Package should have FLAG_SYSTEM", 150 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 151 assertTrue("VIBRATE permission should be granted", 152 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 153 assertTrue("ACCESS_CACHE_FILESYSTEM permission should be granted", 154 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 155 } 156 157 /** 158 * Test case when system app added is older than update. 159 * <p/> 160 * Assumes adb is running as root in device under test. 161 * 162 * @throws DeviceNotAvailableException 163 */ 164 public void testSystemAppAddedOlderThanUpdate() throws DeviceNotAvailableException { 165 mUtils.installFile(getTestAppFilePath(VERSION_2_APK), true); 166 mPackageXml = mUtils.pullPackagesXML(); 167 assertNotNull("Failed to pull packages xml file from device", mPackageXml); 168 assertTrue("Initial package should be installed", 169 mUtils.expectExists(mPackageXml, PACKAGE_XPATH)); 170 assertTrue("Package version should be 2", 171 mUtils.expectEquals(mPackageXml, VERSION_XPATH, "2")); 172 assertFalse("Updated-package should not be present", 173 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 174 assertFalse("Package should not have FLAG_SYSTEM", 175 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 176 assertTrue("VIBRATE permission should be granted", 177 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 178 assertFalse("ACCESS_CACHE_FILESYSTEM permission should NOT be granted", 179 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 180 181 mUtils.pushSystemApp(getTestAppFilePath(VERSION_1_APK), mSystemAppPath); 182 mPackageXml = mUtils.pullPackagesXML(); 183 assertTrue("After system app push, package should still be installed", 184 mUtils.expectExists(mPackageXml, PACKAGE_XPATH)); 185 assertTrue("After system app push, system app should be visible", 186 mUtils.expectEquals(mPackageXml, VERSION_XPATH, "2")); 187 assertTrue("Updated-package should be present", 188 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 189 assertTrue("Package should have FLAG_SYSTEM", 190 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 191 assertTrue("VIBRATE permission should be granted", 192 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 193 assertTrue("ACCESS_CACHE_FILESYSTEM permission should be granted", 194 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 195 } 196 197 /** 198 * Test when system app gets removed. 199 * <p/> 200 * Assumes adb is running as root in device under test. 201 * 202 * @throws DeviceNotAvailableException 203 */ 204 public void testSystemAppRemoved() throws DeviceNotAvailableException { 205 mUtils.pushSystemApp(getTestAppFilePath(VERSION_1_APK), mSystemAppPath); 206 mPackageXml = mUtils.pullPackagesXML(); 207 assertTrue("Initial package should be installed", 208 mUtils.expectExists(mPackageXml, PACKAGE_XPATH)); 209 assertTrue("Package should have FLAG_SYSTEM", 210 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 211 assertFalse("Updated-package should not be present", 212 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 213 mUtils.removeSystemApp(mSystemAppPath, true); 214 mPackageXml = mUtils.pullPackagesXML(); 215 assertFalse("Package should not be installed", 216 mUtils.expectExists(mPackageXml, PACKAGE_XPATH)); 217 assertFalse("Updated-package should not be present", 218 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 219 } 220 221 /** 222 * Test when update has a newer version. 223 * <p/> 224 * Assumes adb is running as root in device under test. 225 * 226 * @throws DeviceNotAvailableException 227 */ 228 public void testSystemAppUpdatedNewerVersion() throws DeviceNotAvailableException { 229 mUtils.pushSystemApp(getTestAppFilePath(VERSION_2_APK), mSystemAppPath); 230 mPackageXml = mUtils.pullPackagesXML(); 231 assertTrue("The package should be installed", 232 mUtils.expectExists(mPackageXml, PACKAGE_XPATH)); 233 assertTrue("Package version should be 2", 234 mUtils.expectEquals(mPackageXml, VERSION_XPATH, "2")); 235 assertFalse("Updated-package should not be present", 236 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 237 assertTrue("Package should have FLAG_SYSTEM", 238 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 239 assertTrue("VIBRATE permission should be granted", 240 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 241 assertTrue("ACCESS_CACHE_FILESYSTEM permission should be granted", 242 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 243 244 mUtils.installFile(getTestAppFilePath(VERSION_3_APK), true); 245 mPackageXml = mUtils.pullPackagesXML(); 246 assertFalse("After system app upgrade, the path should be the upgraded app on /data", 247 mUtils.expectEquals(mPackageXml, CODE_PATH_XPATH, mSystemAppPath)); 248 assertTrue("Package version should be 3", 249 mUtils.expectEquals(mPackageXml, VERSION_XPATH, "3")); 250 assertTrue("Updated-package should be present", 251 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 252 assertTrue("Package should have FLAG_SYSTEM", 253 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 254 assertTrue("VIBRATE permission should be granted", 255 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 256 assertTrue("ACCESS_CACHE_FILESYSTEM permission should be granted", 257 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 258 259 mUtils.restartSystem(); 260 mPackageXml = mUtils.pullPackagesXML(); 261 assertFalse("After system app upgrade, the path should be the upgraded app on /data", 262 mUtils.expectEquals(mPackageXml, CODE_PATH_XPATH, mSystemAppPath)); 263 assertTrue("Package version should be 3", 264 mUtils.expectEquals(mPackageXml, VERSION_XPATH, "3")); 265 assertTrue("Updated-package should be present", 266 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 267 assertTrue("Package should have FLAG_SYSTEM", 268 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 269 assertTrue("VIBRATE permission should be granted", 270 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 271 assertTrue("ACCESS_CACHE_FILESYSTEM permission should be granted", 272 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 273 274 mUtils.restartSystem(); 275 mPackageXml = mUtils.pullPackagesXML(); 276 assertFalse("After system app upgrade, the path should be the upgraded app on /data", 277 mUtils.expectEquals(mPackageXml, CODE_PATH_XPATH, mSystemAppPath)); 278 assertTrue("Package version should be 3", 279 mUtils.expectEquals(mPackageXml, VERSION_XPATH, "3")); 280 assertTrue("Updated-package should be present", 281 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 282 assertTrue("Package should have FLAG_SYSTEM", 283 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 284 assertTrue("VIBRATE permission should be granted", 285 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 286 assertTrue("ACCESS_CACHE_FILESYSTEM permission should be granted", 287 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 288 } 289 290 /** 291 * Test when update has an older version. 292 * <p/> 293 * Assumes adb is running as root in device under test. 294 * 295 * @throws DeviceNotAvailableException 296 */ 297 public void testSystemAppUpdatedOlderVersion() throws DeviceNotAvailableException { 298 mUtils.pushSystemApp(getTestAppFilePath(VERSION_2_APK), mSystemAppPath); 299 mPackageXml = mUtils.pullPackagesXML(); 300 assertTrue("After system app push, the package should be installed", 301 mUtils.expectExists(mPackageXml, PACKAGE_XPATH)); 302 assertTrue("Package version should be 2", 303 mUtils.expectEquals(mPackageXml, VERSION_XPATH, "2")); 304 assertFalse("Updated-package should not be present", 305 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 306 assertTrue("Package should have FLAG_SYSTEM", 307 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 308 assertTrue("VIBRATE permission should be granted", 309 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 310 assertTrue("ACCESS_CACHE_FILESYSTEM permission should be granted", 311 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 312 313 // The "-d" command forces a downgrade. 314 mUtils.installFile(getTestAppFilePath(VERSION_1_APK), true, "-d"); 315 mPackageXml = mUtils.pullPackagesXML(); 316 assertTrue("After system app upgrade, the path should be the upgraded app on /data", 317 mUtils.expectStartsWith(mPackageXml, CODE_PATH_XPATH, 318 DATA_APP_DIRECTORY + PACKAGE_NAME)); 319 assertTrue("Package version should be 1", 320 mUtils.expectEquals(mPackageXml, VERSION_XPATH, "1")); 321 assertTrue("Updated-package should be present", 322 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 323 assertTrue("Package should have FLAG_SYSTEM", 324 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 325 assertTrue("VIBRATE permission should be granted", 326 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 327 assertTrue("ACCESS_CACHE_FILESYSTEM permission should be granted", 328 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 329 330 mUtils.restartSystem(); 331 mPackageXml = mUtils.pullPackagesXML(); 332 assertTrue("After reboot, the path should be the be installed", 333 mUtils.expectEquals(mPackageXml, CODE_PATH_XPATH, mSystemAppPath)); 334 assertTrue("Package version should be 2", 335 mUtils.expectEquals(mPackageXml, VERSION_XPATH, "2")); 336 assertFalse("Updated-package should NOT be present", 337 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 338 assertTrue("Package should have FLAG_SYSTEM", 339 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 340 assertTrue("VIBRATE permission should be granted", 341 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 342 assertTrue("ACCESS_CACHE_FILESYSTEM permission should be granted", 343 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 344 345 mUtils.restartSystem(); 346 mPackageXml = mUtils.pullPackagesXML(); 347 assertTrue("After reboot, the path should be the be installed", 348 mUtils.expectEquals(mPackageXml, CODE_PATH_XPATH, mSystemAppPath)); 349 assertTrue("Package version should be 2", 350 mUtils.expectEquals(mPackageXml, VERSION_XPATH, "2")); 351 assertFalse("Updated-package should NOT be present", 352 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 353 assertTrue("Package should have FLAG_SYSTEM", 354 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 355 assertTrue("VIBRATE permission should be granted", 356 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 357 assertTrue("ACCESS_CACHE_FILESYSTEM permission should be granted", 358 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 359 } 360 361 /** 362 * Test when updated system app has the same version. Package manager is expected to use 363 * the newly installed upgrade. 364 * <p/> 365 * Assumes adb is running as root in device under test. 366 * 367 * @throws DeviceNotAvailableException 368 */ 369 public void testSystemAppUpdatedSameVersion_PreferUpdatedApk() 370 throws DeviceNotAvailableException { 371 mUtils.pushSystemApp(getTestAppFilePath(VERSION_2_APK), mSystemAppPath); 372 mPackageXml = mUtils.pullPackagesXML(); 373 assertTrue("The package should be installed", 374 mUtils.expectExists(mPackageXml, PACKAGE_XPATH)); 375 assertTrue("Package version should be 2", 376 mUtils.expectEquals(mPackageXml, VERSION_XPATH, "2")); 377 assertFalse("Updated-package should not be present", 378 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 379 assertTrue("Package should have FLAG_SYSTEM", 380 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 381 assertTrue("VIBRATE permission should be granted", 382 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 383 assertTrue("ACCESS_CACHE_FILESYSTEM permission should be granted", 384 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 385 386 mUtils.installFile(getTestAppFilePath(VERSION_2_APK), true); 387 mPackageXml = mUtils.pullPackagesXML(); 388 assertFalse("After system app upgrade, the path should be the upgraded app in /data", 389 mUtils.expectEquals(mPackageXml, CODE_PATH_XPATH, mSystemAppPath)); 390 assertTrue("Package version should be 2", 391 mUtils.expectEquals(mPackageXml, VERSION_XPATH, "2")); 392 assertTrue("Updated-package should be present", 393 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 394 assertTrue("Package should have FLAG_SYSTEM", 395 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 396 assertTrue("VIBRATE permission should be granted", 397 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 398 assertTrue("ACCESS_CACHE_FILESYSTEM permission should be granted", 399 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 400 401 mUtils.restartSystem(); 402 mPackageXml = mUtils.pullPackagesXML(); 403 assertFalse("After reboot, the path should be the upgraded app in /data", 404 mUtils.expectEquals(mPackageXml, CODE_PATH_XPATH, mSystemAppPath)); 405 assertTrue("Package version should be 2", 406 mUtils.expectEquals(mPackageXml, VERSION_XPATH, "2")); 407 assertTrue("Updated-package should be present", 408 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 409 assertTrue("Package should have FLAG_SYSTEM", 410 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 411 assertTrue("VIBRATE permission should be granted", 412 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 413 assertTrue("ACCESS_CACHE_FILESYSTEM permission should be granted", 414 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 415 416 } 417 418 /** 419 * Test when update has system app removed. 420 * <p/> 421 * Assumes adb is running as root in device under test. 422 * 423 * @throws DeviceNotAvailableException 424 */ 425 public void testUpdatedSystemAppRemoved() throws DeviceNotAvailableException { 426 mUtils.pushSystemApp(getTestAppFilePath(VERSION_1_APK), mSystemAppPath); 427 mUtils.installFile(getTestAppFilePath(VERSION_2_APK), true); 428 mPackageXml = mUtils.pullPackagesXML(); 429 assertTrue("Package should be installed", 430 mUtils.expectExists(mPackageXml, PACKAGE_XPATH)); 431 assertTrue("Updated-package should be present", 432 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 433 assertTrue("Package should have FLAG_SYSTEM", 434 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 435 assertTrue("VIBRATE permission should be granted", 436 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 437 assertTrue("ACCESS_CACHE_FILESYSTEM permission should be granted", 438 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 439 440 mUtils.removeSystemApp(mSystemAppPath, true); 441 mPackageXml = mUtils.pullPackagesXML(); 442 assertTrue("Package should still be installed", 443 mUtils.expectExists(mPackageXml, PACKAGE_XPATH)); 444 assertFalse("Updated-package entry should not be present", 445 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 446 assertFalse("Package should not have FLAG_SYSTEM", 447 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 448 assertTrue("VIBRATE permission should be granted", 449 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 450 assertFalse("ACCESS_CACHE_FILESYSTEM permission should NOT be granted", 451 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 452 } 453 454 /** 455 * Test when system app is updated with a new permission. Specifically: 456 * <ol> 457 * <li>system app FOO is present, does not declare system permission</li> 458 * <li>FOO is overlain by an installed update that declares new permission</li> 459 * <li>FOO is replaced during an OTA, but installed update still has higher version number</li> 460 * <li>Verify permission is granted</li> 461 * </ol> 462 * 463 * @throws DeviceNotAvailableException 464 */ 465 public void testSystemAppUpdatedNewPermission() throws DeviceNotAvailableException { 466 mUtils.pushSystemApp(getTestAppFilePath(VERSION_1_NO_SYS_PERMISSION_APK), mSystemAppPath); 467 mPackageXml = mUtils.pullPackagesXML(); 468 assertTrue("The package should be installed", 469 mUtils.expectExists(mPackageXml, PACKAGE_XPATH)); 470 assertTrue("Package version should be 1", 471 mUtils.expectEquals(mPackageXml, VERSION_XPATH, "1")); 472 assertFalse("Updated-package should not be present", 473 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 474 assertTrue("Package should have FLAG_SYSTEM", 475 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 476 assertTrue("VIBRATE permission should be granted", 477 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 478 assertFalse("ACCESS_CACHE_FILESYSTEM permission should NOT be granted", 479 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 480 481 mUtils.installFile(getTestAppFilePath(VERSION_3_APK), true); 482 mPackageXml = mUtils.pullPackagesXML(); 483 assertFalse("After system app upgrade, the path should be the upgraded app on /data", 484 mUtils.expectEquals(mPackageXml, CODE_PATH_XPATH, mSystemAppPath)); 485 assertTrue("Package version should be 3", 486 mUtils.expectEquals(mPackageXml, VERSION_XPATH, "3")); 487 assertTrue("Updated-package should be present", 488 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 489 assertTrue("Package should have FLAG_SYSTEM", 490 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 491 assertTrue("VIBRATE permission should be granted", 492 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 493 assertFalse("ACCESS_CACHE_FILESYSTEM permission should NOT be granted", 494 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 495 496 mUtils.pushSystemApp(getTestAppFilePath(VERSION_2_APK), mSystemAppPath); 497 mUtils.restartSystem(); 498 mPackageXml = mUtils.pullPackagesXML(); 499 assertFalse("After reboot, the path should be the data app", 500 mUtils.expectEquals(mPackageXml, CODE_PATH_XPATH, mSystemAppPath)); 501 assertTrue("Package version should be 3", 502 mUtils.expectEquals(mPackageXml, VERSION_XPATH, "3")); 503 assertTrue("Updated-package should be present", 504 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 505 assertTrue("Package should have FLAG_SYSTEM", 506 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 507 assertTrue("VIBRATE permission should be granted", 508 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 509 assertTrue("ACCESS_CACHE_FILESYSTEM permission should be granted", 510 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 511 512 mUtils.restartSystem(); 513 mPackageXml = mUtils.pullPackagesXML(); 514 assertFalse("After reboot, the path should be the data app", 515 mUtils.expectEquals(mPackageXml, CODE_PATH_XPATH, mSystemAppPath)); 516 assertTrue("Package version should be 3", 517 mUtils.expectEquals(mPackageXml, VERSION_XPATH, "3")); 518 assertTrue("Updated-package should be present", 519 mUtils.expectExists(mPackageXml, UPDATE_PACKAGE_XPATH)); 520 assertTrue("Package should have FLAG_SYSTEM", 521 mUtils.packageHasFlag(PACKAGE_NAME, " SYSTEM ")); 522 assertTrue("VIBRATE permission should be granted", 523 mUtils.packageHasPermission(PACKAGE_NAME, VIBRATE_PERMISSION)); 524 assertTrue("ACCESS_CACHE_FILESYSTEM permission should be granted", 525 mUtils.packageHasPermission(PACKAGE_NAME, CACHE_PERMISSION)); 526 } 527 } 528
