Home | History | Annotate | Download | only in shortcuthost 
      1 /*
      2  * Copyright (C) 2016 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 package android.content.pm.cts.shortcuthost;
     17 
     18 
     19 import com.android.tradefed.device.DeviceNotAvailableException;
     20 import com.android.tradefed.log.LogUtil.CLog;
     21 
     22 import java.util.concurrent.TimeUnit;
     23 import java.util.regex.Pattern;
     24 
     25 public class ShortcutManagerBackupTest extends BaseShortcutManagerHostTest {
     26     private static final String LAUNCHER1_APK = "CtsShortcutBackupLauncher1.apk";
     27     private static final String LAUNCHER2_APK = "CtsShortcutBackupLauncher2.apk";
     28     private static final String LAUNCHER3_APK = "CtsShortcutBackupLauncher3.apk";
     29     private static final String LAUNCHER4_OLD_APK = "CtsShortcutBackupLauncher4old.apk";
     30     private static final String LAUNCHER4_NEW_APK = "CtsShortcutBackupLauncher4new.apk";
     31 
     32     private static final String PUBLISHER1_APK = "CtsShortcutBackupPublisher1.apk";
     33     private static final String PUBLISHER2_APK = "CtsShortcutBackupPublisher2.apk";
     34     private static final String PUBLISHER3_APK = "CtsShortcutBackupPublisher3.apk";
     35     private static final String PUBLISHER4_OLD_APK = "CtsShortcutBackupPublisher4old.apk";
     36     private static final String PUBLISHER4_NEW_APK = "CtsShortcutBackupPublisher4new.apk";
     37     private static final String PUBLISHER4_NEW_NOBACKUP_APK
     38             = "CtsShortcutBackupPublisher4new_nobackup.apk";
     39     private static final String PUBLISHER4_NEW_WRONGKEY_APK
     40             = "CtsShortcutBackupPublisher4new_wrongkey.apk";
     41     private static final String PUBLISHER4_OLD_NO_MANIFST_APK
     42             = "CtsShortcutBackupPublisher4old_nomanifest.apk";
     43     private static final String PUBLISHER4_NEW_NO_MANIFST_APK
     44             = "CtsShortcutBackupPublisher4new_nomanifest.apk";
     45 
     46     private static final String LAUNCHER1_PKG =
     47             "android.content.pm.cts.shortcut.backup.launcher1";
     48     private static final String LAUNCHER2_PKG =
     49             "android.content.pm.cts.shortcut.backup.launcher2";
     50     private static final String LAUNCHER3_PKG =
     51             "android.content.pm.cts.shortcut.backup.launcher3";
     52     private static final String LAUNCHER4_PKG =
     53             "android.content.pm.cts.shortcut.backup.launcher4";
     54 
     55     private static final String PUBLISHER1_PKG =
     56             "android.content.pm.cts.shortcut.backup.publisher1";
     57     private static final String PUBLISHER2_PKG =
     58             "android.content.pm.cts.shortcut.backup.publisher2";
     59     private static final String PUBLISHER3_PKG =
     60             "android.content.pm.cts.shortcut.backup.publisher3";
     61     private static final String PUBLISHER4_PKG =
     62             "android.content.pm.cts.shortcut.backup.publisher4";
     63 
     64     private static final int BROADCAST_TIMEOUT_SECONDS = 120;
     65 
     66     private static final String FEATURE_BACKUP = "android.software.backup";
     67 
     68     private boolean mSupportsBackup;
     69 
     70     @Override
     71     protected void setUp() throws Exception {
     72         super.setUp();
     73 
     74         mSupportsBackup = getDevice().hasFeature(FEATURE_BACKUP);
     75 
     76         if (mSupportsBackup) {
     77             clearShortcuts(LAUNCHER1_PKG, getPrimaryUserId());
     78             clearShortcuts(LAUNCHER2_PKG, getPrimaryUserId());
     79             clearShortcuts(LAUNCHER3_PKG, getPrimaryUserId());
     80             clearShortcuts(LAUNCHER4_PKG, getPrimaryUserId());
     81 
     82             clearShortcuts(PUBLISHER1_PKG, getPrimaryUserId());
     83             clearShortcuts(PUBLISHER2_PKG, getPrimaryUserId());
     84             clearShortcuts(PUBLISHER3_PKG, getPrimaryUserId());
     85             clearShortcuts(PUBLISHER4_PKG, getPrimaryUserId());
     86 
     87             uninstallPackageAndWaitUntilBroadcastsDrain(LAUNCHER1_PKG);
     88             uninstallPackageAndWaitUntilBroadcastsDrain(LAUNCHER2_PKG);
     89             uninstallPackageAndWaitUntilBroadcastsDrain(LAUNCHER3_PKG);
     90             uninstallPackageAndWaitUntilBroadcastsDrain(LAUNCHER4_PKG);
     91 
     92             uninstallPackageAndWaitUntilBroadcastsDrain(PUBLISHER1_PKG);
     93             uninstallPackageAndWaitUntilBroadcastsDrain(PUBLISHER2_PKG);
     94             uninstallPackageAndWaitUntilBroadcastsDrain(PUBLISHER3_PKG);
     95             uninstallPackageAndWaitUntilBroadcastsDrain(PUBLISHER4_PKG);
     96 
     97             waitUntilPackagesGone();
     98         }
     99     }
    100 
    101     @Override
    102     protected void tearDown() throws Exception {
    103         if (DUMPSYS_IN_TEARDOWN) {
    104             dumpsys("tearDown");
    105         }
    106 
    107         if (mSupportsBackup && !NO_UNINSTALL_IN_TEARDOWN) {
    108             getDevice().uninstallPackage(LAUNCHER1_PKG);
    109             getDevice().uninstallPackage(LAUNCHER2_PKG);
    110             getDevice().uninstallPackage(LAUNCHER3_PKG);
    111             getDevice().uninstallPackage(LAUNCHER4_PKG);
    112 
    113             getDevice().uninstallPackage(PUBLISHER1_PKG);
    114             getDevice().uninstallPackage(PUBLISHER2_PKG);
    115             getDevice().uninstallPackage(PUBLISHER3_PKG);
    116             getDevice().uninstallPackage(PUBLISHER4_PKG);
    117         }
    118 
    119         super.tearDown();
    120     }
    121 
    122     private void doBackup() throws Exception {
    123         CLog.i("Backing up package android...");
    124 
    125         waitUntilBroadcastsDrain(); // b/64203677
    126 
    127         CLog.i("Making sure the local transport is selected...");
    128         assertContainsRegex(
    129                 "^Selected transport android/com.android.internal.backup.LocalTransport",
    130                 executeShellCommandWithLog(
    131                         "bmgr transport android/com.android.internal.backup.LocalTransport"));
    132 
    133         executeShellCommandWithLog("dumpsys backup");
    134 
    135         assertContainsRegex(
    136                 "Wiped",
    137                 executeShellCommandWithLog(
    138                         "bmgr wipe android/com.android.internal.backup.LocalTransport android"));
    139 
    140         assertContainsRegex(
    141                 "Backup finished with result: Success",
    142                 executeShellCommandWithLog("bmgr backupnow android"));
    143 
    144     }
    145 
    146     private void doRestore() throws DeviceNotAvailableException {
    147         CLog.i("Restoring package android...");
    148 
    149         assertContainsRegex(
    150                 "\\bdone\\b",
    151                 executeShellCommandWithLog("bmgr restore 1 android"));
    152 
    153     }
    154 
    155     private void uninstallPackageAndWaitUntilBroadcastsDrain(String pkg) throws Exception {
    156         getDevice().uninstallPackage(pkg);
    157         waitUntilBroadcastsDrain();
    158     }
    159 
    160     /**
    161      * Wait until the broadcasts queues all drain.
    162      */
    163     private void waitUntilBroadcastsDrain() throws Exception {
    164         final long TIMEOUT = System.nanoTime() +
    165                 TimeUnit.SECONDS.toNanos(BROADCAST_TIMEOUT_SECONDS);
    166 
    167         final Pattern re = Pattern.compile("^\\s+Active (ordered)? broadcasts \\[",
    168                 Pattern.MULTILINE);
    169 
    170         String dumpsys = "";
    171         while (System.nanoTime() < TIMEOUT) {
    172             Thread.sleep(1000);
    173 
    174             dumpsys = getDevice().executeShellCommand("dumpsys activity broadcasts");
    175 
    176             if (re.matcher(dumpsys).find()) {
    177                 continue;
    178             }
    179 
    180             CLog.d("Broadcast queues drained:\n" + dumpsys);
    181 
    182             dumpsys("Broadcast queues drained");
    183 
    184             // All packages gone.
    185             return;
    186         }
    187         fail("Broadcast queues didn't drain before time out."
    188                 + " Last dumpsys=\n" + dumpsys);
    189     }
    190 
    191     /**
    192      * Wait until all the test packages are forgotten by the shortcut manager.
    193      */
    194     private void waitUntilPackagesGone() throws Exception {
    195         CLog.i("Waiting until all packages are removed from shortcut manager...");
    196 
    197         final String packages[] = {
    198                 LAUNCHER1_PKG,  LAUNCHER2_PKG, LAUNCHER3_PKG, LAUNCHER4_PKG,
    199                 PUBLISHER1_PKG, PUBLISHER2_PKG, PUBLISHER3_PKG, PUBLISHER4_PKG,
    200         };
    201 
    202         String dumpsys = "";
    203         final long TIMEOUT = System.nanoTime() +
    204                 TimeUnit.SECONDS.toNanos(BROADCAST_TIMEOUT_SECONDS);
    205 
    206         while (System.nanoTime() < TIMEOUT) {
    207             Thread.sleep(2000);
    208             dumpsys = getDevice().executeShellCommand("dumpsys shortcut");
    209 
    210             if (dumpsys.contains("Launcher: " + LAUNCHER1_PKG)) continue;
    211             if (dumpsys.contains("Launcher: " + LAUNCHER2_PKG)) continue;
    212             if (dumpsys.contains("Launcher: " + LAUNCHER3_PKG)) continue;
    213             if (dumpsys.contains("Launcher: " + LAUNCHER4_PKG)) continue;
    214             if (dumpsys.contains("Package: " + PUBLISHER1_PKG)) continue;
    215             if (dumpsys.contains("Package: " + PUBLISHER2_PKG)) continue;
    216             if (dumpsys.contains("Package: " + PUBLISHER3_PKG)) continue;
    217             if (dumpsys.contains("Package: " + PUBLISHER4_PKG)) continue;
    218 
    219             dumpsys("Shortcut manager handled broadcasts");
    220 
    221             // All packages gone.
    222             return;
    223         }
    224         fail("ShortcutManager didn't handle all expected broadcasts before time out."
    225                 + " Last dumpsys=\n" + dumpsys);
    226     }
    227 
    228     public void testBackupAndRestore() throws Exception {
    229         if (!mSupportsBackup) {
    230             return;
    231         }
    232         dumpsys("Test start");
    233 
    234         installAppAsUser(LAUNCHER1_APK, getPrimaryUserId());
    235         installAppAsUser(LAUNCHER2_APK, getPrimaryUserId());
    236         installAppAsUser(LAUNCHER3_APK, getPrimaryUserId());
    237 
    238         installAppAsUser(PUBLISHER1_APK, getPrimaryUserId());
    239         installAppAsUser(PUBLISHER2_APK, getPrimaryUserId());
    240         installAppAsUser(PUBLISHER3_APK, getPrimaryUserId());
    241 
    242         // Prepare shortcuts
    243         runDeviceTestsAsUser(PUBLISHER1_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    244         runDeviceTestsAsUser(PUBLISHER2_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    245         runDeviceTestsAsUser(PUBLISHER3_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    246 
    247         runDeviceTestsAsUser(LAUNCHER1_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    248         runDeviceTestsAsUser(LAUNCHER2_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    249         runDeviceTestsAsUser(LAUNCHER3_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    250 
    251         // Tweak shortcuts a little bit to make disabled shortcuts.
    252         runDeviceTestsAsUser(PUBLISHER2_PKG, ".ShortcutManagerPreBackup2Test", getPrimaryUserId());
    253 
    254         dumpsys("Before backup");
    255 
    256         // Backup
    257         doBackup();
    258 
    259         // Uninstall all apps
    260         uninstallPackageAndWaitUntilBroadcastsDrain(LAUNCHER1_PKG);
    261         uninstallPackageAndWaitUntilBroadcastsDrain(LAUNCHER2_PKG);
    262         uninstallPackageAndWaitUntilBroadcastsDrain(LAUNCHER3_PKG);
    263         uninstallPackageAndWaitUntilBroadcastsDrain(PUBLISHER1_PKG);
    264         uninstallPackageAndWaitUntilBroadcastsDrain(PUBLISHER2_PKG);
    265         uninstallPackageAndWaitUntilBroadcastsDrain(PUBLISHER3_PKG);
    266 
    267 
    268         // Make sure the shortcut service handled all the uninstall broadcasts.
    269         waitUntilPackagesGone();
    270 
    271         // Do it one more time just in case...
    272         waitUntilBroadcastsDrain();
    273 
    274         // Then restore
    275         doRestore();
    276 
    277         dumpsys("After restore");
    278 
    279         // First, restore launcher 1, which shouldn't see any shortcuts from the packages yet.
    280         installAppAsUser(LAUNCHER1_APK, getPrimaryUserId());
    281         runDeviceTestsAsUser(LAUNCHER1_PKG, ".ShortcutManagerPostBackupTest",
    282                 "testWithUninstall_beforeAppRestore",
    283                 getPrimaryUserId());
    284 
    285         // Restore the apps.  Even though launcher 2 hasn't been re-installed yet, they should
    286         // still have pinned shortcuts by launcher 2.
    287         installAppAsUser(PUBLISHER1_APK, getPrimaryUserId());
    288         installAppAsUser(PUBLISHER2_APK, getPrimaryUserId());
    289         installAppAsUser(PUBLISHER3_APK, getPrimaryUserId());
    290 
    291         runDeviceTestsAsUser(PUBLISHER1_PKG, ".ShortcutManagerPostBackupTest",
    292                 "testWithUninstall",
    293                 getPrimaryUserId());
    294 
    295         runDeviceTestsAsUser(PUBLISHER2_PKG, ".ShortcutManagerPostBackupTest",
    296                 "testWithUninstall",
    297                 getPrimaryUserId());
    298 
    299         runDeviceTestsAsUser(PUBLISHER3_PKG, ".ShortcutManagerPostBackupTest",
    300                 "testWithUninstall",
    301                 getPrimaryUserId());
    302 
    303         // Now launcher 1 should see shortcuts from these packages.
    304         runDeviceTestsAsUser(LAUNCHER1_PKG, ".ShortcutManagerPostBackupTest",
    305                 "testWithUninstall_afterAppRestore",
    306                 getPrimaryUserId());
    307 
    308         // Then restore launcher 2 and check.
    309         installAppAsUser(LAUNCHER2_APK, getPrimaryUserId());
    310         runDeviceTestsAsUser(LAUNCHER2_PKG, ".ShortcutManagerPostBackupTest",
    311                 "testWithUninstall_afterAppRestore",
    312                 getPrimaryUserId());
    313 
    314 
    315         // Run the same package side check.  The result should be the same.
    316         runDeviceTestsAsUser(PUBLISHER1_PKG, ".ShortcutManagerPostBackupTest",
    317                 "testWithUninstall",
    318                 getPrimaryUserId());
    319 
    320         runDeviceTestsAsUser(PUBLISHER2_PKG, ".ShortcutManagerPostBackupTest",
    321                 "testWithUninstall",
    322                 getPrimaryUserId());
    323 
    324         runDeviceTestsAsUser(PUBLISHER3_PKG, ".ShortcutManagerPostBackupTest",
    325                 "testWithUninstall",
    326                 getPrimaryUserId());
    327     }
    328 
    329     public void testBackupAndRestore_downgrade() throws Exception {
    330         if (!mSupportsBackup) {
    331             return;
    332         }
    333         dumpsys("Test start");
    334 
    335         // First, publish shortcuts from the new version and pin them.
    336 
    337         installAppAsUser(PUBLISHER4_NEW_APK, getPrimaryUserId());
    338         installAppAsUser(LAUNCHER4_NEW_APK, getPrimaryUserId());
    339 
    340         runDeviceTestsAsUser(PUBLISHER4_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    341         runDeviceTestsAsUser(LAUNCHER4_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    342 
    343         dumpsys("Before backup");
    344 
    345         // Backup
    346         doBackup();
    347 
    348         // Uninstall all apps
    349         uninstallPackageAndWaitUntilBroadcastsDrain(LAUNCHER4_PKG);
    350         uninstallPackageAndWaitUntilBroadcastsDrain(PUBLISHER4_PKG);
    351 
    352         // Make sure the shortcut service handled all the uninstall broadcasts.
    353         waitUntilPackagesGone();
    354 
    355         // Do it one more time just in case...
    356         waitUntilBroadcastsDrain();
    357 
    358         // Then restore
    359         doRestore();
    360 
    361         dumpsys("After restore");
    362 
    363         // Restore the old version of the app, and the launcher.
    364         // (But we don't check the launcher's version, so using old is fine.)
    365         installAppAsUser(LAUNCHER4_OLD_APK, getPrimaryUserId());
    366         installAppAsUser(PUBLISHER4_OLD_APK, getPrimaryUserId());
    367         waitUntilBroadcastsDrain();
    368 
    369         runDeviceTestsAsUser(PUBLISHER4_PKG, ".ShortcutManagerPostBackupTest",
    370                 "testRestoredOnOldVersion",
    371                 getPrimaryUserId());
    372 
    373         runDeviceTestsAsUser(LAUNCHER4_PKG, ".ShortcutManagerPostBackupTest",
    374                 "testRestoredOnOldVersion",
    375                 getPrimaryUserId());
    376 
    377         // New install the original version. All blocked shortcuts should re-appear.
    378         installAppAsUser(PUBLISHER4_NEW_APK, getPrimaryUserId());
    379         waitUntilBroadcastsDrain();
    380 
    381         runDeviceTestsAsUser(PUBLISHER4_PKG, ".ShortcutManagerPostBackupTest",
    382                 "testRestoredOnNewVersion",
    383                 getPrimaryUserId());
    384 
    385         runDeviceTestsAsUser(LAUNCHER4_PKG, ".ShortcutManagerPostBackupTest",
    386                 "testRestoredOnNewVersion",
    387                 getPrimaryUserId());
    388 
    389     }
    390 
    391     public void testBackupAndRestore_backupWasDisabled() throws Exception {
    392         if (!mSupportsBackup) {
    393             return;
    394         }
    395         dumpsys("Test start");
    396 
    397         // First, publish shortcuts from "nobackup" version.
    398 
    399         installAppAsUser(PUBLISHER4_NEW_NOBACKUP_APK, getPrimaryUserId());
    400         installAppAsUser(LAUNCHER4_NEW_APK, getPrimaryUserId());
    401 
    402         runDeviceTestsAsUser(PUBLISHER4_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    403         runDeviceTestsAsUser(LAUNCHER4_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    404 
    405         dumpsys("Before backup");
    406 
    407         // Backup
    408         doBackup();
    409 
    410         // Uninstall all apps
    411         uninstallPackageAndWaitUntilBroadcastsDrain(LAUNCHER4_PKG);
    412         uninstallPackageAndWaitUntilBroadcastsDrain(PUBLISHER4_PKG);
    413 
    414         // Make sure the shortcut service handled all the uninstall broadcasts.
    415         waitUntilPackagesGone();
    416 
    417         // Do it one more time just in case...
    418         waitUntilBroadcastsDrain();
    419 
    420         // Then restore
    421         doRestore();
    422 
    423         dumpsys("After restore");
    424 
    425         // Install the "backup-ok" version. But restoration is limited.
    426         installAppAsUser(LAUNCHER4_NEW_APK, getPrimaryUserId());
    427         installAppAsUser(PUBLISHER4_NEW_APK, getPrimaryUserId());
    428         waitUntilBroadcastsDrain();
    429 
    430         runDeviceTestsAsUser(PUBLISHER4_PKG, ".ShortcutManagerPostBackupTest",
    431                 "testBackupDisabled",
    432                 getPrimaryUserId());
    433     }
    434 
    435     public void testBackupAndRestore_backupIsDisabled() throws Exception {
    436         if (!mSupportsBackup) {
    437             return;
    438         }
    439         dumpsys("Test start");
    440 
    441         // First, publish shortcuts from backup-ok version.
    442 
    443         installAppAsUser(PUBLISHER4_NEW_APK, getPrimaryUserId());
    444         installAppAsUser(LAUNCHER4_NEW_APK, getPrimaryUserId());
    445 
    446         runDeviceTestsAsUser(PUBLISHER4_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    447         runDeviceTestsAsUser(LAUNCHER4_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    448 
    449         dumpsys("Before backup");
    450 
    451         // Backup
    452         doBackup();
    453 
    454         // Uninstall all apps
    455         uninstallPackageAndWaitUntilBroadcastsDrain(LAUNCHER4_PKG);
    456         uninstallPackageAndWaitUntilBroadcastsDrain(PUBLISHER4_PKG);
    457 
    458         // Make sure the shortcut service handled all the uninstall broadcasts.
    459         waitUntilPackagesGone();
    460 
    461         // Do it one more time just in case...
    462         waitUntilBroadcastsDrain();
    463 
    464         // Then restore
    465         doRestore();
    466 
    467         dumpsys("After restore");
    468 
    469         // Install the nobackup version. Restoration is limited.
    470         installAppAsUser(LAUNCHER4_NEW_APK, getPrimaryUserId());
    471         installAppAsUser(PUBLISHER4_NEW_NOBACKUP_APK, getPrimaryUserId());
    472         waitUntilBroadcastsDrain();
    473 
    474         runDeviceTestsAsUser(PUBLISHER4_PKG, ".ShortcutManagerPostBackupTest",
    475                 "testBackupDisabled",
    476                 getPrimaryUserId());
    477     }
    478 
    479     public void testBackupAndRestore_wrongKey() throws Exception {
    480         if (!mSupportsBackup) {
    481             return;
    482         }
    483         dumpsys("Test start");
    484 
    485         // First, publish shortcuts from backup-ok version.
    486 
    487         installAppAsUser(PUBLISHER4_NEW_APK, getPrimaryUserId());
    488         installAppAsUser(LAUNCHER4_NEW_APK, getPrimaryUserId());
    489 
    490         runDeviceTestsAsUser(PUBLISHER4_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    491         runDeviceTestsAsUser(LAUNCHER4_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    492 
    493         dumpsys("Before backup");
    494 
    495         // Backup
    496         doBackup();
    497 
    498         // Uninstall all apps
    499         uninstallPackageAndWaitUntilBroadcastsDrain(LAUNCHER4_PKG);
    500         uninstallPackageAndWaitUntilBroadcastsDrain(PUBLISHER4_PKG);
    501 
    502         // Make sure the shortcut service handled all the uninstall broadcasts.
    503         waitUntilPackagesGone();
    504 
    505         // Do it one more time just in case...
    506         waitUntilBroadcastsDrain();
    507 
    508         // Then restore
    509         doRestore();
    510 
    511         dumpsys("After restore");
    512 
    513         // Install the nobackup version. Restoration is limited.
    514         installAppAsUser(LAUNCHER4_NEW_APK, getPrimaryUserId());
    515         installAppAsUser(PUBLISHER4_NEW_WRONGKEY_APK, getPrimaryUserId());
    516         waitUntilBroadcastsDrain();
    517 
    518         runDeviceTestsAsUser(PUBLISHER4_PKG, ".ShortcutManagerPostBackupTest",
    519                 "testRestoreWrongKey",
    520                 getPrimaryUserId());
    521 
    522         runDeviceTestsAsUser(LAUNCHER4_PKG, ".ShortcutManagerPostBackupTest",
    523                 "testRestoreWrongKey",
    524                 getPrimaryUserId());
    525     }
    526 
    527     public void testBackupAndRestore_noManifestOnOldVersion() throws Exception {
    528         if (!mSupportsBackup) {
    529             return;
    530         }
    531         dumpsys("Test start");
    532 
    533         // First, publish shortcuts from backup-ok version.
    534 
    535         installAppAsUser(PUBLISHER4_NEW_APK, getPrimaryUserId());
    536         installAppAsUser(LAUNCHER4_NEW_APK, getPrimaryUserId());
    537 
    538         runDeviceTestsAsUser(PUBLISHER4_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    539         runDeviceTestsAsUser(LAUNCHER4_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    540 
    541         dumpsys("Before backup");
    542 
    543         // Backup
    544         doBackup();
    545 
    546         // Uninstall all apps
    547         uninstallPackageAndWaitUntilBroadcastsDrain(LAUNCHER4_PKG);
    548         uninstallPackageAndWaitUntilBroadcastsDrain(PUBLISHER4_PKG);
    549 
    550         // Make sure the shortcut service handled all the uninstall broadcasts.
    551         waitUntilPackagesGone();
    552 
    553         // Do it one more time just in case...
    554         waitUntilBroadcastsDrain();
    555 
    556         // Then restore
    557         doRestore();
    558 
    559         dumpsys("After restore");
    560 
    561         // Install the nobackup version. Restoration is limited.
    562         installAppAsUser(LAUNCHER4_NEW_APK, getPrimaryUserId());
    563         installAppAsUser(PUBLISHER4_OLD_NO_MANIFST_APK, getPrimaryUserId());
    564         waitUntilBroadcastsDrain();
    565 
    566         runDeviceTestsAsUser(PUBLISHER4_PKG, ".ShortcutManagerPostBackupTest",
    567                 "testRestoreNoManifestOnOldVersion",
    568                 getPrimaryUserId());
    569 
    570         runDeviceTestsAsUser(LAUNCHER4_PKG, ".ShortcutManagerPostBackupTest",
    571                 "testRestoreNoManifestOnOldVersion",
    572                 getPrimaryUserId());
    573     }
    574 
    575     public void testBackupAndRestore_noManifestOnNewVersion() throws Exception {
    576         if (!mSupportsBackup) {
    577             return;
    578         }
    579         dumpsys("Test start");
    580 
    581         // First, publish shortcuts from backup-ok version.
    582 
    583         installAppAsUser(PUBLISHER4_NEW_APK, getPrimaryUserId());
    584         installAppAsUser(LAUNCHER4_NEW_APK, getPrimaryUserId());
    585 
    586         runDeviceTestsAsUser(PUBLISHER4_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    587         runDeviceTestsAsUser(LAUNCHER4_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    588 
    589         dumpsys("Before backup");
    590 
    591         // Backup
    592         doBackup();
    593 
    594         // Uninstall all apps
    595         uninstallPackageAndWaitUntilBroadcastsDrain(LAUNCHER4_PKG);
    596         uninstallPackageAndWaitUntilBroadcastsDrain(PUBLISHER4_PKG);
    597 
    598         // Make sure the shortcut service handled all the uninstall broadcasts.
    599         waitUntilPackagesGone();
    600 
    601         // Do it one more time just in case...
    602         waitUntilBroadcastsDrain();
    603 
    604         // Then restore
    605         doRestore();
    606 
    607         dumpsys("After restore");
    608 
    609         // Install the nobackup version. Restoration is limited.
    610         installAppAsUser(LAUNCHER4_NEW_APK, getPrimaryUserId());
    611         installAppAsUser(PUBLISHER4_NEW_NO_MANIFST_APK, getPrimaryUserId());
    612         waitUntilBroadcastsDrain();
    613 
    614         runDeviceTestsAsUser(PUBLISHER4_PKG, ".ShortcutManagerPostBackupTest",
    615                 "testRestoreNoManifestOnNewVersion",
    616                 getPrimaryUserId());
    617 
    618         runDeviceTestsAsUser(LAUNCHER4_PKG, ".ShortcutManagerPostBackupTest",
    619                 "testRestoreNoManifestOnNewVersion",
    620                 getPrimaryUserId());
    621     }
    622 
    623     /**
    624      * Make sure invisible shortcuts are ignored by all API calls.
    625      *
    626      * (Restore from new to old-nomanifest)
    627      */
    628     public void testBackupAndRestore_invisibleIgnored() throws Exception {
    629         if (!mSupportsBackup) {
    630             return;
    631         }
    632         dumpsys("Test start");
    633 
    634         // First, publish shortcuts from backup-ok version.
    635 
    636         installAppAsUser(PUBLISHER4_NEW_APK, getPrimaryUserId());
    637         installAppAsUser(LAUNCHER4_NEW_APK, getPrimaryUserId());
    638 
    639         runDeviceTestsAsUser(PUBLISHER4_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    640         runDeviceTestsAsUser(LAUNCHER4_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    641 
    642         dumpsys("Before backup");
    643 
    644         // Backup
    645         doBackup();
    646 
    647         // Uninstall all apps
    648         uninstallPackageAndWaitUntilBroadcastsDrain(LAUNCHER4_PKG);
    649         uninstallPackageAndWaitUntilBroadcastsDrain(PUBLISHER4_PKG);
    650 
    651         // Make sure the shortcut service handled all the uninstall broadcasts.
    652         waitUntilPackagesGone();
    653 
    654         // Do it one more time just in case...
    655         waitUntilBroadcastsDrain();
    656 
    657         // Then restore
    658         doRestore();
    659 
    660         dumpsys("After restore");
    661 
    662         // Install the nobackup version. Restoration is limited.
    663         installAppAsUser(LAUNCHER4_NEW_APK, getPrimaryUserId());
    664         installAppAsUser(PUBLISHER4_OLD_NO_MANIFST_APK, getPrimaryUserId());
    665         waitUntilBroadcastsDrain();
    666 
    667         runDeviceTestsAsUser(PUBLISHER4_PKG, ".ShortcutManagerPostBackupTest",
    668                 "testInvisibleIgnored",
    669                 getPrimaryUserId());
    670 
    671         runDeviceTestsAsUser(LAUNCHER4_PKG, ".ShortcutManagerPostBackupTest",
    672                 "testInvisibleIgnored",
    673                 getPrimaryUserId());
    674     }
    675 
    676     public void testBackupAndRestore_withNoUninstall() throws Exception {
    677         if (!mSupportsBackup) {
    678             return;
    679         }
    680 
    681         installAppAsUser(PUBLISHER1_APK, getPrimaryUserId());
    682         installAppAsUser(PUBLISHER3_APK, getPrimaryUserId());
    683 
    684         // Prepare shortcuts
    685         runDeviceTestsAsUser(PUBLISHER1_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    686         runDeviceTestsAsUser(PUBLISHER3_PKG, ".ShortcutManagerPreBackupTest", getPrimaryUserId());
    687 
    688         // Backup & restore.
    689         doBackup();
    690         doRestore();
    691 
    692         // Make sure the manifest shortcuts are re-published.
    693         runDeviceTestsAsUser(PUBLISHER1_PKG, ".ShortcutManagerPostBackupTest",
    694                 "testWithNoUninstall",
    695                 getPrimaryUserId());
    696 
    697         runDeviceTestsAsUser(PUBLISHER3_PKG, ".ShortcutManagerPostBackupTest",
    698                 "testWithNoUninstall",
    699                 getPrimaryUserId());
    700     }
    701 }