Home | History | Annotate | Download | only in shortcutmanagertest 
      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 com.android.server.pm.shortcutmanagertest;
     17 
     18 import static junit.framework.Assert.assertEquals;
     19 import static junit.framework.Assert.assertFalse;
     20 import static junit.framework.Assert.assertNotNull;
     21 import static junit.framework.Assert.assertNull;
     22 import static junit.framework.Assert.assertTrue;
     23 import static junit.framework.Assert.fail;
     24 
     25 import static org.mockito.Matchers.any;
     26 import static org.mockito.Matchers.anyList;
     27 import static org.mockito.Matchers.anyString;
     28 import static org.mockito.Matchers.eq;
     29 import static org.mockito.Mockito.mock;
     30 import static org.mockito.Mockito.reset;
     31 import static org.mockito.Mockito.times;
     32 import static org.mockito.Mockito.verify;
     33 
     34 import android.app.Instrumentation;
     35 import android.content.ComponentName;
     36 import android.content.Context;
     37 import android.content.pm.LauncherApps;
     38 import android.content.pm.LauncherApps.Callback;
     39 import android.content.pm.ShortcutInfo;
     40 import android.graphics.Bitmap;
     41 import android.graphics.BitmapFactory;
     42 import android.os.BaseBundle;
     43 import android.os.Bundle;
     44 import android.os.Handler;
     45 import android.os.Looper;
     46 import android.os.Parcel;
     47 import android.os.ParcelFileDescriptor;
     48 import android.os.PersistableBundle;
     49 import android.os.UserHandle;
     50 import android.test.MoreAsserts;
     51 import android.util.Log;
     52 
     53 import junit.framework.Assert;
     54 
     55 import org.hamcrest.BaseMatcher;
     56 import org.hamcrest.Description;
     57 import org.hamcrest.Matcher;
     58 import org.json.JSONException;
     59 import org.json.JSONObject;
     60 import org.mockito.ArgumentCaptor;
     61 import org.mockito.Mockito;
     62 
     63 import java.io.BufferedReader;
     64 import java.io.File;
     65 import java.io.FileNotFoundException;
     66 import java.io.FileReader;
     67 import java.io.IOException;
     68 import java.util.ArrayList;
     69 import java.util.Arrays;
     70 import java.util.Collection;
     71 import java.util.Collections;
     72 import java.util.Comparator;
     73 import java.util.LinkedHashSet;
     74 import java.util.List;
     75 import java.util.Set;
     76 import java.util.SortedSet;
     77 import java.util.TreeSet;
     78 import java.util.concurrent.CountDownLatch;
     79 import java.util.function.BooleanSupplier;
     80 import java.util.function.Consumer;
     81 import java.util.function.Function;
     82 import java.util.function.Predicate;
     83 
     84 /**
     85  * Common utility methods for ShortcutManager tests.  This is used by both CTS and the unit tests.
     86  * Because it's used by CTS too, it can only access the public APIs.
     87  */
     88 public class ShortcutManagerTestUtils {
     89     private static final String TAG = "ShortcutManagerUtils";
     90 
     91     private static final boolean ENABLE_DUMPSYS = true; // DO NOT SUBMIT WITH true
     92 
     93     private static final int STANDARD_TIMEOUT_SEC = 5;
     94 
     95     private static final String[] EMPTY_STRINGS = new String[0];
     96 
     97     private ShortcutManagerTestUtils() {
     98     }
     99 
    100     public static List<String> readAll(File file) throws FileNotFoundException {
    101         return readAll(ParcelFileDescriptor.open(
    102                 file.getAbsoluteFile(), ParcelFileDescriptor.MODE_READ_ONLY));
    103     }
    104 
    105     public static List<String> readAll(ParcelFileDescriptor pfd) {
    106         try {
    107             try {
    108                 final ArrayList<String> ret = new ArrayList<>();
    109                 try (BufferedReader r = new BufferedReader(
    110                         new FileReader(pfd.getFileDescriptor()))) {
    111                     String line;
    112                     while ((line = r.readLine()) != null) {
    113                         ret.add(line);
    114                     }
    115                     r.readLine();
    116                 }
    117                 return ret;
    118             } finally {
    119                 pfd.close();
    120             }
    121         } catch (IOException e) {
    122             throw new RuntimeException(e);
    123         }
    124     }
    125 
    126     public static String concatResult(List<String> result) {
    127         final StringBuilder sb = new StringBuilder();
    128         for (String s : result) {
    129             sb.append(s);
    130             sb.append("\n");
    131         }
    132         return sb.toString();
    133     }
    134 
    135     public static boolean resultContains(List<String> result, String expected) {
    136         for (String line : result) {
    137             if (line.contains(expected)) {
    138                 return true;
    139             }
    140         }
    141         return false;
    142     }
    143 
    144     public static List<String> assertSuccess(List<String> result) {
    145         if (!resultContains(result, "Success")) {
    146             fail("Command failed.  Result was:\n" + concatResult(result));
    147         }
    148         return result;
    149     }
    150 
    151     public static List<String> assertContains(List<String> result, String expected) {
    152         if (!resultContains(result, expected)) {
    153             fail("Didn't contain expected string=" + expected
    154                     + "\nActual:\n" + concatResult(result));
    155         }
    156         return result;
    157     }
    158 
    159     public static List<String> runCommand(Instrumentation instrumentation, String command) {
    160         return runCommand(instrumentation, command, null);
    161     }
    162     public static List<String> runCommand(Instrumentation instrumentation, String command,
    163             Predicate<List<String>> resultAsserter) {
    164         Log.d(TAG, "Running command: " + command);
    165         final List<String> result;
    166         try {
    167             result = readAll(
    168                     instrumentation.getUiAutomation().executeShellCommand(command));
    169         } catch (Exception e) {
    170             throw new RuntimeException(e);
    171         }
    172         if (resultAsserter != null && !resultAsserter.test(result)) {
    173             fail("Command '" + command + "' failed, output was:\n" + concatResult(result));
    174         }
    175         return result;
    176     }
    177 
    178     public static void runCommandForNoOutput(Instrumentation instrumentation, String command) {
    179         runCommand(instrumentation, command, result -> result.size() == 0);
    180     }
    181 
    182     public static List<String> runShortcutCommand(Instrumentation instrumentation, String command,
    183             Predicate<List<String>> resultAsserter) {
    184         return runCommand(instrumentation, "cmd shortcut " + command, resultAsserter);
    185     }
    186 
    187     public static List<String> runShortcutCommandForSuccess(Instrumentation instrumentation,
    188             String command) {
    189         return runShortcutCommand(instrumentation, command, result -> result.contains("Success"));
    190     }
    191 
    192     public static String getDefaultLauncher(Instrumentation instrumentation) {
    193         final String PREFIX = "Launcher: ComponentInfo{";
    194         final String POSTFIX = "}";
    195         final List<String> result = runShortcutCommandForSuccess(
    196                 instrumentation, "get-default-launcher");
    197         for (String s : result) {
    198             if (s.startsWith(PREFIX) && s.endsWith(POSTFIX)) {
    199                 return s.substring(PREFIX.length(), s.length() - POSTFIX.length());
    200             }
    201         }
    202         fail("Default launcher not found");
    203         return null;
    204     }
    205 
    206     public static void setDefaultLauncher(Instrumentation instrumentation, String component) {
    207         runCommand(instrumentation, "cmd package set-home-activity --user "
    208                 + instrumentation.getContext().getUserId() + " " + component,
    209                 result -> result.contains("Success"));
    210     }
    211 
    212     public static void setDefaultLauncher(Instrumentation instrumentation, Context packageContext) {
    213         setDefaultLauncher(instrumentation, packageContext.getPackageName()
    214                 + "/android.content.pm.cts.shortcutmanager.packages.Launcher");
    215     }
    216 
    217     public static void overrideConfig(Instrumentation instrumentation, String config) {
    218         runShortcutCommandForSuccess(instrumentation, "override-config " + config);
    219     }
    220 
    221     public static void resetConfig(Instrumentation instrumentation) {
    222         runShortcutCommandForSuccess(instrumentation, "reset-config");
    223     }
    224 
    225     public static void resetThrottling(Instrumentation instrumentation) {
    226         runShortcutCommandForSuccess(instrumentation, "reset-throttling");
    227     }
    228 
    229     public static void resetAllThrottling(Instrumentation instrumentation) {
    230         runShortcutCommandForSuccess(instrumentation, "reset-all-throttling");
    231     }
    232 
    233     public static void clearShortcuts(Instrumentation instrumentation, int userId,
    234             String packageName) {
    235         runShortcutCommandForSuccess(instrumentation, "clear-shortcuts "
    236                 + " --user " + userId + " " + packageName);
    237     }
    238 
    239     public static void anyContains(List<String> result, String expected) {
    240         for (String l : result) {
    241             if (l.contains(expected)) {
    242                 return;
    243             }
    244         }
    245         fail("Result didn't contain '" + expected + "': was\n" + result);
    246     }
    247 
    248     public static void enableComponent(Instrumentation instrumentation, ComponentName cn,
    249             boolean enable) {
    250 
    251         final String word = (enable ? "enable" : "disable");
    252         runCommand(instrumentation,
    253                 "pm " + word + " " + cn.flattenToString()
    254                 , result ->concatResult(result).contains(word));
    255     }
    256 
    257     public static void appOps(Instrumentation instrumentation, String packageName,
    258             String op, String mode) {
    259         runCommand(instrumentation, "appops set " + packageName + " " + op + " " + mode);
    260     }
    261 
    262     public static void dumpsysShortcut(Instrumentation instrumentation) {
    263         if (!ENABLE_DUMPSYS) {
    264             return;
    265         }
    266         Log.e(TAG, "Dumpsys shortcut");
    267         for (String s : runCommand(instrumentation, "dumpsys shortcut")) {
    268             Log.e(TAG, s);
    269         }
    270     }
    271 
    272     public static JSONObject getCheckinDump(Instrumentation instrumentation) throws JSONException {
    273         return new JSONObject(concatResult(runCommand(instrumentation, "dumpsys shortcut -c")));
    274     }
    275 
    276     public static boolean isLowRamDevice(Instrumentation instrumentation) throws JSONException {
    277         return getCheckinDump(instrumentation).getBoolean("lowRam");
    278     }
    279 
    280     public static int getIconSize(Instrumentation instrumentation) throws JSONException {
    281         return getCheckinDump(instrumentation).getInt("iconSize");
    282     }
    283 
    284     public static Bundle makeBundle(Object... keysAndValues) {
    285         assertTrue((keysAndValues.length % 2) == 0);
    286 
    287         if (keysAndValues.length == 0) {
    288             return null;
    289         }
    290         final Bundle ret = new Bundle();
    291 
    292         for (int i = keysAndValues.length - 2; i >= 0; i -= 2) {
    293             final String key = keysAndValues[i].toString();
    294             final Object value = keysAndValues[i + 1];
    295 
    296             if (value == null) {
    297                 ret.putString(key, null);
    298             } else if (value instanceof Integer) {
    299                 ret.putInt(key, (Integer) value);
    300             } else if (value instanceof String) {
    301                 ret.putString(key, (String) value);
    302             } else if (value instanceof Bundle) {
    303                 ret.putBundle(key, (Bundle) value);
    304             } else {
    305                 fail("Type not supported yet: " + value.getClass().getName());
    306             }
    307         }
    308         return ret;
    309     }
    310 
    311     public static PersistableBundle makePersistableBundle(Object... keysAndValues) {
    312         assertTrue((keysAndValues.length % 2) == 0);
    313 
    314         if (keysAndValues.length == 0) {
    315             return null;
    316         }
    317         final PersistableBundle ret = new PersistableBundle();
    318 
    319         for (int i = keysAndValues.length - 2; i >= 0; i -= 2) {
    320             final String key = keysAndValues[i].toString();
    321             final Object value = keysAndValues[i + 1];
    322 
    323             if (value == null) {
    324                 ret.putString(key, null);
    325             } else if (value instanceof Integer) {
    326                 ret.putInt(key, (Integer) value);
    327             } else if (value instanceof String) {
    328                 ret.putString(key, (String) value);
    329             } else if (value instanceof PersistableBundle) {
    330                 ret.putPersistableBundle(key, (PersistableBundle) value);
    331             } else {
    332                 fail("Type not supported yet: " + value.getClass().getName());
    333             }
    334         }
    335         return ret;
    336     }
    337 
    338     public static <T> List<T> list(T... array) {
    339         return Arrays.asList(array);
    340     }
    341 
    342     public static <T> Set<T> hashSet(Set<T> in) {
    343         return new LinkedHashSet<>(in);
    344     }
    345 
    346     public static <T> Set<T> set(T... values) {
    347         return set(v -> v, values);
    348     }
    349 
    350     public static <T, V> Set<T> set(Function<V, T> converter, V... values) {
    351         return set(converter, Arrays.asList(values));
    352     }
    353 
    354     public static <T, V> Set<T> set(Function<V, T> converter, List<V> values) {
    355         final LinkedHashSet<T> ret = new LinkedHashSet<>();
    356         for (V v : values) {
    357             ret.add(converter.apply(v));
    358         }
    359         return ret;
    360     }
    361 
    362     public static void resetAll(Collection<?> mocks) {
    363         for (Object o : mocks) {
    364             reset(o);
    365         }
    366     }
    367 
    368     public static <T extends Collection<?>> T assertEmpty(T collection) {
    369         if (collection == null) {
    370             return collection; // okay.
    371         }
    372         assertEquals(0, collection.size());
    373         return collection;
    374     }
    375 
    376     public static List<ShortcutInfo> filter(List<ShortcutInfo> list, Predicate<ShortcutInfo> p) {
    377         final ArrayList<ShortcutInfo> ret = new ArrayList<>(list);
    378         ret.removeIf(si -> !p.test(si));
    379         return ret;
    380     }
    381 
    382     public static List<ShortcutInfo> filterByActivity(List<ShortcutInfo> list,
    383             ComponentName activity) {
    384         return filter(list, si ->
    385                 (si.getActivity().equals(activity)
    386                         && (si.isDeclaredInManifest() || si.isDynamic())));
    387     }
    388 
    389     public static List<ShortcutInfo> changedSince(List<ShortcutInfo> list, long time) {
    390         return filter(list, si -> si.getLastChangedTimestamp() >= time);
    391     }
    392 
    393     @FunctionalInterface
    394     public interface ExceptionRunnable {
    395         void run() throws Exception;
    396     }
    397 
    398     public static void assertExpectException(Class<? extends Throwable> expectedExceptionType,
    399             String expectedExceptionMessageRegex, ExceptionRunnable r) {
    400         assertExpectException("", expectedExceptionType, expectedExceptionMessageRegex, r);
    401     }
    402 
    403     public static void assertCannotUpdateImmutable(Runnable r) {
    404         assertExpectException(
    405                 IllegalArgumentException.class, "may not be manipulated via APIs", r::run);
    406     }
    407 
    408     public static void assertDynamicShortcutCountExceeded(Runnable r) {
    409         assertExpectException(IllegalArgumentException.class,
    410                 "Max number of dynamic shortcuts exceeded", r::run);
    411     }
    412 
    413     public static void assertExpectException(String message,
    414             Class<? extends Throwable> expectedExceptionType,
    415             String expectedExceptionMessageRegex, ExceptionRunnable r) {
    416         try {
    417             r.run();
    418         } catch (Throwable e) {
    419             Assert.assertTrue(
    420                     "Expected exception type was " + expectedExceptionType.getName()
    421                             + " but caught " + e + " (message=" + message + ")",
    422                     expectedExceptionType.isAssignableFrom(e.getClass()));
    423             if (expectedExceptionMessageRegex != null) {
    424                 MoreAsserts.assertContainsRegex(expectedExceptionMessageRegex, e.getMessage());
    425             }
    426             return; // Pass
    427         }
    428         Assert.fail("Expected exception type " + expectedExceptionType.getName()
    429                 + " was not thrown");
    430     }
    431 
    432     public static List<ShortcutInfo> assertShortcutIds(List<ShortcutInfo> actualShortcuts,
    433             String... expectedIds) {
    434         final SortedSet<String> expected = new TreeSet<>(list(expectedIds));
    435         final SortedSet<String> actual = new TreeSet<>();
    436         for (ShortcutInfo s : actualShortcuts) {
    437             actual.add(s.getId());
    438         }
    439 
    440         // Compare the sets.
    441         assertEquals(expected, actual);
    442         return actualShortcuts;
    443     }
    444 
    445     public static List<ShortcutInfo> assertShortcutIdsOrdered(List<ShortcutInfo> actualShortcuts,
    446             String... expectedIds) {
    447         final ArrayList<String> expected = new ArrayList<>(list(expectedIds));
    448         final ArrayList<String> actual = new ArrayList<>();
    449         for (ShortcutInfo s : actualShortcuts) {
    450             actual.add(s.getId());
    451         }
    452         assertEquals(expected, actual);
    453         return actualShortcuts;
    454     }
    455 
    456     public static List<ShortcutInfo> assertAllHaveIntents(
    457             List<ShortcutInfo> actualShortcuts) {
    458         for (ShortcutInfo s : actualShortcuts) {
    459             assertNotNull("ID " + s.getId(), s.getIntent());
    460         }
    461         return actualShortcuts;
    462     }
    463 
    464     public static List<ShortcutInfo> assertAllNotHaveIntents(
    465             List<ShortcutInfo> actualShortcuts) {
    466         for (ShortcutInfo s : actualShortcuts) {
    467             assertNull("ID " + s.getId(), s.getIntent());
    468         }
    469         return actualShortcuts;
    470     }
    471 
    472     public static List<ShortcutInfo> assertAllHaveTitle(
    473             List<ShortcutInfo> actualShortcuts) {
    474         for (ShortcutInfo s : actualShortcuts) {
    475             assertNotNull("ID " + s.getId(), s.getShortLabel());
    476         }
    477         return actualShortcuts;
    478     }
    479 
    480     public static List<ShortcutInfo> assertAllNotHaveTitle(
    481             List<ShortcutInfo> actualShortcuts) {
    482         for (ShortcutInfo s : actualShortcuts) {
    483             assertNull("ID " + s.getId(), s.getShortLabel());
    484         }
    485         return actualShortcuts;
    486     }
    487 
    488     public static List<ShortcutInfo> assertAllKeyFieldsOnly(
    489             List<ShortcutInfo> actualShortcuts) {
    490         for (ShortcutInfo s : actualShortcuts) {
    491             assertTrue("ID " + s.getId(), s.hasKeyFieldsOnly());
    492         }
    493         return actualShortcuts;
    494     }
    495 
    496     public static List<ShortcutInfo> assertAllNotKeyFieldsOnly(
    497             List<ShortcutInfo> actualShortcuts) {
    498         for (ShortcutInfo s : actualShortcuts) {
    499             assertFalse("ID " + s.getId(), s.hasKeyFieldsOnly());
    500         }
    501         return actualShortcuts;
    502     }
    503 
    504     public static List<ShortcutInfo> assertAllDynamic(List<ShortcutInfo> actualShortcuts) {
    505         for (ShortcutInfo s : actualShortcuts) {
    506             assertTrue("ID " + s.getId(), s.isDynamic());
    507         }
    508         return actualShortcuts;
    509     }
    510 
    511     public static List<ShortcutInfo> assertAllPinned(List<ShortcutInfo> actualShortcuts) {
    512         for (ShortcutInfo s : actualShortcuts) {
    513             assertTrue("ID " + s.getId(), s.isPinned());
    514         }
    515         return actualShortcuts;
    516     }
    517 
    518     public static List<ShortcutInfo> assertAllDynamicOrPinned(
    519             List<ShortcutInfo> actualShortcuts) {
    520         for (ShortcutInfo s : actualShortcuts) {
    521             assertTrue("ID " + s.getId(), s.isDynamic() || s.isPinned());
    522         }
    523         return actualShortcuts;
    524     }
    525 
    526     public static List<ShortcutInfo> assertAllManifest(
    527             List<ShortcutInfo> actualShortcuts) {
    528         for (ShortcutInfo s : actualShortcuts) {
    529             assertTrue("ID " + s.getId(), s.isDeclaredInManifest());
    530         }
    531         return actualShortcuts;
    532     }
    533 
    534     public static List<ShortcutInfo> assertAllNotManifest(
    535             List<ShortcutInfo> actualShortcuts) {
    536         for (ShortcutInfo s : actualShortcuts) {
    537             assertFalse("ID " + s.getId(), s.isDeclaredInManifest());
    538         }
    539         return actualShortcuts;
    540     }
    541 
    542     public static List<ShortcutInfo> assertAllDisabled(
    543             List<ShortcutInfo> actualShortcuts) {
    544         for (ShortcutInfo s : actualShortcuts) {
    545             assertTrue("ID " + s.getId(), !s.isEnabled());
    546         }
    547         return actualShortcuts;
    548     }
    549 
    550     public static List<ShortcutInfo> assertAllEnabled(
    551             List<ShortcutInfo> actualShortcuts) {
    552         for (ShortcutInfo s : actualShortcuts) {
    553             assertTrue("ID " + s.getId(), s.isEnabled());
    554         }
    555         return actualShortcuts;
    556     }
    557 
    558     public static List<ShortcutInfo> assertAllImmutable(
    559             List<ShortcutInfo> actualShortcuts) {
    560         for (ShortcutInfo s : actualShortcuts) {
    561             assertTrue("ID " + s.getId(), s.isImmutable());
    562         }
    563         return actualShortcuts;
    564     }
    565 
    566     public static void assertDynamicOnly(ShortcutInfo si) {
    567         assertTrue(si.isDynamic());
    568         assertFalse(si.isPinned());
    569     }
    570 
    571     public static void assertPinnedOnly(ShortcutInfo si) {
    572         assertFalse(si.isDynamic());
    573         assertFalse(si.isDeclaredInManifest());
    574         assertTrue(si.isPinned());
    575     }
    576 
    577     public static void assertDynamicAndPinned(ShortcutInfo si) {
    578         assertTrue(si.isDynamic());
    579         assertTrue(si.isPinned());
    580     }
    581 
    582     public static void assertBitmapSize(int expectedWidth, int expectedHeight, Bitmap bitmap) {
    583         assertEquals("width", expectedWidth, bitmap.getWidth());
    584         assertEquals("height", expectedHeight, bitmap.getHeight());
    585     }
    586 
    587     public static <T> void assertAllUnique(Collection<T> list) {
    588         final Set<Object> set = new LinkedHashSet<>();
    589         for (T item : list) {
    590             if (set.contains(item)) {
    591                 fail("Duplicate item found: " + item + " (in the list: " + list + ")");
    592             }
    593             set.add(item);
    594         }
    595     }
    596 
    597     public static ShortcutInfo findShortcut(List<ShortcutInfo> list, String id) {
    598         for (ShortcutInfo si : list) {
    599             if (si.getId().equals(id)) {
    600                 return si;
    601             }
    602         }
    603         fail("Shortcut " + id + " not found in the list");
    604         return null;
    605     }
    606 
    607     public static Bitmap pfdToBitmap(ParcelFileDescriptor pfd) {
    608         assertNotNull(pfd);
    609         try {
    610             try {
    611                 return BitmapFactory.decodeFileDescriptor(pfd.getFileDescriptor());
    612             } finally {
    613                 pfd.close();
    614             }
    615         } catch (IOException e) {
    616             throw new RuntimeException(e);
    617         }
    618     }
    619 
    620     public static void assertBundleEmpty(BaseBundle b) {
    621         assertTrue(b == null || b.size() == 0);
    622     }
    623 
    624     public static void assertCallbackNotReceived(LauncherApps.Callback mock) {
    625         verify(mock, times(0)).onShortcutsChanged(anyString(), anyList(),
    626                 any(UserHandle.class));
    627     }
    628 
    629     public static void assertCallbackReceived(LauncherApps.Callback mock,
    630             UserHandle user, String packageName, String... ids) {
    631         verify(mock).onShortcutsChanged(eq(packageName), checkShortcutIds(ids),
    632                 eq(user));
    633     }
    634 
    635     public static boolean checkAssertSuccess(Runnable r) {
    636         try {
    637             r.run();
    638             return true;
    639         } catch (AssertionError e) {
    640             return false;
    641         }
    642     }
    643 
    644     public static <T> T checkArgument(Predicate<T> checker, String description,
    645             List<T> matchedCaptor) {
    646         final Matcher<T> m = new BaseMatcher<T>() {
    647             @Override
    648             public boolean matches(Object item) {
    649                 if (item == null) {
    650                     return false;
    651                 }
    652                 final T value = (T) item;
    653                 if (!checker.test(value)) {
    654                     return false;
    655                 }
    656 
    657                 if (matchedCaptor != null) {
    658                     matchedCaptor.add(value);
    659                 }
    660                 return true;
    661             }
    662 
    663             @Override
    664             public void describeTo(Description d) {
    665                 d.appendText(description);
    666             }
    667         };
    668         return Mockito.argThat(m);
    669     }
    670 
    671     public static List<ShortcutInfo> checkShortcutIds(String... ids) {
    672         return checkArgument((List<ShortcutInfo> list) -> {
    673             final Set<String> actualSet = set(si -> si.getId(), list);
    674             return actualSet.equals(set(ids));
    675 
    676         }, "Shortcut IDs=[" + Arrays.toString(ids) + "]", null);
    677     }
    678 
    679     public static ShortcutInfo parceled(ShortcutInfo si) {
    680         Parcel p = Parcel.obtain();
    681         p.writeParcelable(si, 0);
    682         p.setDataPosition(0);
    683         ShortcutInfo si2 = p.readParcelable(ShortcutManagerTestUtils.class.getClassLoader());
    684         p.recycle();
    685         return si2;
    686     }
    687 
    688     public static List<ShortcutInfo> cloneShortcutList(List<ShortcutInfo> list) {
    689         if (list == null) {
    690             return null;
    691         }
    692         final List<ShortcutInfo> ret = new ArrayList<>(list.size());
    693         for (ShortcutInfo si : list) {
    694             ret.add(parceled(si));
    695         }
    696 
    697         return ret;
    698     }
    699 
    700     private static final Comparator<ShortcutInfo> sRankComparator =
    701             (ShortcutInfo a, ShortcutInfo b) -> Integer.compare(a.getRank(), b.getRank());
    702 
    703     public static List<ShortcutInfo> sortedByRank(List<ShortcutInfo> shortcuts) {
    704         final ArrayList<ShortcutInfo> ret = new ArrayList<>(shortcuts);
    705         Collections.sort(ret, sRankComparator);
    706         return ret;
    707     }
    708 
    709     public static void waitUntil(String message, BooleanSupplier condition) {
    710         waitUntil(message, condition, STANDARD_TIMEOUT_SEC);
    711     }
    712 
    713     public static void waitUntil(String message, BooleanSupplier condition, int timeoutSeconds) {
    714         final long timeout = System.currentTimeMillis() + (timeoutSeconds * 1000L);
    715         while (System.currentTimeMillis() < timeout) {
    716             if (condition.getAsBoolean()) {
    717                 return;
    718             }
    719             try {
    720                 Thread.sleep(100);
    721             } catch (InterruptedException e) {
    722                 throw new RuntimeException(e);
    723             }
    724         }
    725         fail("Timed out for: " + message);
    726     }
    727 
    728     public static ShortcutListAsserter assertWith(List<ShortcutInfo> list) {
    729         return new ShortcutListAsserter(list);
    730     }
    731 
    732     /**
    733      * New style assertion that allows chained calls.
    734      */
    735     public static class ShortcutListAsserter {
    736         private final ShortcutListAsserter mOriginal;
    737         private final List<ShortcutInfo> mList;
    738 
    739         ShortcutListAsserter(List<ShortcutInfo> list) {
    740             this(null, list);
    741         }
    742 
    743         private ShortcutListAsserter(ShortcutListAsserter original, List<ShortcutInfo> list) {
    744             mOriginal = (original == null) ? this : original;
    745             mList = (list == null) ? new ArrayList<>(0) : new ArrayList<>(list);
    746         }
    747 
    748         public ShortcutListAsserter revertToOriginalList() {
    749             return mOriginal;
    750         }
    751 
    752         public ShortcutListAsserter selectDynamic() {
    753             return new ShortcutListAsserter(this,
    754                     filter(mList, ShortcutInfo::isDynamic));
    755         }
    756 
    757         public ShortcutListAsserter selectManifest() {
    758             return new ShortcutListAsserter(this,
    759                     filter(mList, ShortcutInfo::isDeclaredInManifest));
    760         }
    761 
    762         public ShortcutListAsserter selectPinned() {
    763             return new ShortcutListAsserter(this,
    764                     filter(mList, ShortcutInfo::isPinned));
    765         }
    766 
    767         public ShortcutListAsserter selectByActivity(ComponentName activity) {
    768             return new ShortcutListAsserter(this,
    769                     ShortcutManagerTestUtils.filterByActivity(mList, activity));
    770         }
    771 
    772         public ShortcutListAsserter selectByChangedSince(long time) {
    773             return new ShortcutListAsserter(this,
    774                     ShortcutManagerTestUtils.changedSince(mList, time));
    775         }
    776 
    777         public ShortcutListAsserter selectByIds(String... ids) {
    778             final Set<String> idSet = set(ids);
    779             final ArrayList<ShortcutInfo> selected = new ArrayList<>();
    780             for (ShortcutInfo si : mList) {
    781                 if (idSet.contains(si.getId())) {
    782                     selected.add(si);
    783                     idSet.remove(si.getId());
    784                 }
    785             }
    786             if (idSet.size() > 0) {
    787                 fail("Shortcuts not found for IDs=" + idSet);
    788             }
    789 
    790             return new ShortcutListAsserter(this, selected);
    791         }
    792 
    793         public ShortcutListAsserter toSortByRank() {
    794             return new ShortcutListAsserter(this,
    795                     ShortcutManagerTestUtils.sortedByRank(mList));
    796         }
    797 
    798         public ShortcutListAsserter call(Consumer<List<ShortcutInfo>> c) {
    799             c.accept(mList);
    800             return this;
    801         }
    802 
    803         public ShortcutListAsserter haveIds(String... expectedIds) {
    804             assertShortcutIds(mList, expectedIds);
    805             return this;
    806         }
    807 
    808         public ShortcutListAsserter haveIdsOrdered(String... expectedIds) {
    809             assertShortcutIdsOrdered(mList, expectedIds);
    810             return this;
    811         }
    812 
    813         private ShortcutListAsserter haveSequentialRanks() {
    814             for (int i = 0; i < mList.size(); i++) {
    815                 final ShortcutInfo si = mList.get(i);
    816                 assertEquals("Rank not sequential: id=" + si.getId(), i, si.getRank());
    817             }
    818             return this;
    819         }
    820 
    821         public ShortcutListAsserter haveRanksInOrder(String... expectedIds) {
    822             toSortByRank()
    823                     .haveSequentialRanks()
    824                     .haveIdsOrdered(expectedIds);
    825             return this;
    826         }
    827 
    828         public ShortcutListAsserter isEmpty() {
    829             assertEquals(0, mList.size());
    830             return this;
    831         }
    832 
    833         public ShortcutListAsserter areAllDynamic() {
    834             forAllShortcuts(s -> assertTrue("id=" + s.getId(), s.isDynamic()));
    835             return this;
    836         }
    837 
    838         public ShortcutListAsserter areAllNotDynamic() {
    839             forAllShortcuts(s -> assertFalse("id=" + s.getId(), s.isDynamic()));
    840             return this;
    841         }
    842 
    843         public ShortcutListAsserter areAllPinned() {
    844             forAllShortcuts(s -> assertTrue("id=" + s.getId(), s.isPinned()));
    845             return this;
    846         }
    847 
    848         public ShortcutListAsserter areAllNotPinned() {
    849             forAllShortcuts(s -> assertFalse("id=" + s.getId(), s.isPinned()));
    850             return this;
    851         }
    852 
    853         public ShortcutListAsserter areAllManifest() {
    854             forAllShortcuts(s -> assertTrue("id=" + s.getId(), s.isDeclaredInManifest()));
    855             return this;
    856         }
    857 
    858         public ShortcutListAsserter areAllNotManifest() {
    859             forAllShortcuts(s -> assertFalse("id=" + s.getId(), s.isDeclaredInManifest()));
    860             return this;
    861         }
    862 
    863         public ShortcutListAsserter areAllImmutable() {
    864             forAllShortcuts(s -> assertTrue("id=" + s.getId(), s.isImmutable()));
    865             return this;
    866         }
    867 
    868         public ShortcutListAsserter areAllMutable() {
    869             forAllShortcuts(s -> assertFalse("id=" + s.getId(), s.isImmutable()));
    870             return this;
    871         }
    872 
    873         public ShortcutListAsserter areAllEnabled() {
    874             forAllShortcuts(s -> assertTrue("id=" + s.getId(), s.isEnabled()));
    875             return this;
    876         }
    877 
    878         public ShortcutListAsserter areAllDisabled() {
    879             forAllShortcuts(s -> assertFalse("id=" + s.getId(), s.isEnabled()));
    880             return this;
    881         }
    882 
    883         public ShortcutListAsserter areAllWithKeyFieldsOnly() {
    884             forAllShortcuts(s -> assertTrue("id=" + s.getId(), s.hasKeyFieldsOnly()));
    885             return this;
    886         }
    887 
    888         public ShortcutListAsserter areAllNotWithKeyFieldsOnly() {
    889             forAllShortcuts(s -> assertFalse("id=" + s.getId(), s.hasKeyFieldsOnly()));
    890             return this;
    891         }
    892 
    893         public ShortcutListAsserter areAllWithActivity(ComponentName activity) {
    894             forAllShortcuts(s -> assertTrue("id=" + s.getId(), s.getActivity().equals(activity)));
    895             return this;
    896         }
    897 
    898         public ShortcutListAsserter forAllShortcuts(Consumer<ShortcutInfo> sa) {
    899             boolean found = false;
    900             for (int i = 0; i < mList.size(); i++) {
    901                 final ShortcutInfo si = mList.get(i);
    902                 found = true;
    903                 sa.accept(si);
    904             }
    905             assertTrue("No shortcuts found.", found);
    906             return this;
    907         }
    908 
    909         public ShortcutListAsserter forShortcut(Predicate<ShortcutInfo> p,
    910                 Consumer<ShortcutInfo> sa) {
    911             boolean found = false;
    912             for (int i = 0; i < mList.size(); i++) {
    913                 final ShortcutInfo si = mList.get(i);
    914                 if (p.test(si)) {
    915                     found = true;
    916                     try {
    917                         sa.accept(si);
    918                     } catch (Throwable e) {
    919                         throw new AssertionError("Assertion failed for shortcut " + si.getId(), e);
    920                     }
    921                 }
    922             }
    923             assertTrue("Shortcut with the given condition not found.", found);
    924             return this;
    925         }
    926 
    927         public ShortcutListAsserter forShortcutWithId(String id, Consumer<ShortcutInfo> sa) {
    928             forShortcut(si -> si.getId().equals(id), sa);
    929 
    930             return this;
    931         }
    932     }
    933 
    934     public static void assertBundlesEqual(BaseBundle b1, BaseBundle b2) {
    935         if (b1 == null && b2 == null) {
    936             return; // pass
    937         }
    938         assertNotNull("b1 is null but b2 is not", b1);
    939         assertNotNull("b2 is null but b1 is not", b2);
    940 
    941         // HashSet makes the error message readable.
    942         assertEquals(set(b1.keySet()), set(b2.keySet()));
    943 
    944         for (String key : b1.keySet()) {
    945             final Object v1 = b1.get(key);
    946             final Object v2 = b2.get(key);
    947             if (v1 == null) {
    948                 if (v2 == null) {
    949                     return;
    950                 }
    951             }
    952             if (v1.equals(v2)) {
    953                 return;
    954             }
    955 
    956             assertTrue("Only either value is null: key=" + key
    957                     + " b1=" + b1 + " b2=" + b2, v1 != null && v2 != null);
    958             assertEquals("Class mismatch: key=" + key, v1.getClass(), v2.getClass());
    959 
    960             if (v1 instanceof BaseBundle) {
    961                 assertBundlesEqual((BaseBundle) v1, (BaseBundle) v2);
    962 
    963             } else if (v1 instanceof boolean[]) {
    964                 assertTrue(Arrays.equals((boolean[]) v1, (boolean[]) v2));
    965 
    966             } else if (v1 instanceof int[]) {
    967                 MoreAsserts.assertEquals((int[]) v1, (int[]) v2);
    968 
    969             } else if (v1 instanceof double[]) {
    970                 MoreAsserts.assertEquals((double[]) v1, (double[]) v2);
    971 
    972             } else if (v1 instanceof String[]) {
    973                 MoreAsserts.assertEquals((String[]) v1, (String[]) v2);
    974 
    975             } else if (v1 instanceof Double) {
    976                 if (((Double) v1).isNaN()) {
    977                     assertTrue(((Double) v2).isNaN());
    978                 } else {
    979                     assertEquals(v1, v2);
    980                 }
    981 
    982             } else {
    983                 assertEquals(v1, v2);
    984             }
    985         }
    986     }
    987 
    988     public static void waitOnMainThread() throws InterruptedException {
    989         final CountDownLatch latch = new CountDownLatch(1);
    990 
    991         new Handler(Looper.getMainLooper()).post(() -> latch.countDown());
    992 
    993         latch.await();
    994     }
    995 
    996     public static class LauncherCallbackAsserter {
    997         private final LauncherApps.Callback mCallback = mock(LauncherApps.Callback.class);
    998 
    999         private Callback getMockCallback() {
   1000             return mCallback;
   1001         }
   1002 
   1003         public LauncherCallbackAsserter assertNoCallbackCalled() {
   1004             verify(mCallback, times(0)).onShortcutsChanged(
   1005                     anyString(),
   1006                     any(List.class),
   1007                     any(UserHandle.class));
   1008             return this;
   1009         }
   1010 
   1011         public LauncherCallbackAsserter assertNoCallbackCalledForPackage(
   1012                 String publisherPackageName) {
   1013             verify(mCallback, times(0)).onShortcutsChanged(
   1014                     eq(publisherPackageName),
   1015                     any(List.class),
   1016                     any(UserHandle.class));
   1017             return this;
   1018         }
   1019 
   1020         public LauncherCallbackAsserter assertNoCallbackCalledForPackageAndUser(
   1021                 String publisherPackageName, UserHandle publisherUserHandle) {
   1022             verify(mCallback, times(0)).onShortcutsChanged(
   1023                     eq(publisherPackageName),
   1024                     any(List.class),
   1025                     eq(publisherUserHandle));
   1026             return this;
   1027         }
   1028 
   1029         public ShortcutListAsserter assertCallbackCalledForPackageAndUser(
   1030                 String publisherPackageName, UserHandle publisherUserHandle) {
   1031             final ArgumentCaptor<List> shortcuts = ArgumentCaptor.forClass(List.class);
   1032             verify(mCallback, times(1)).onShortcutsChanged(
   1033                     eq(publisherPackageName),
   1034                     shortcuts.capture(),
   1035                     eq(publisherUserHandle));
   1036             return new ShortcutListAsserter(shortcuts.getValue());
   1037         }
   1038     }
   1039 
   1040     public static LauncherCallbackAsserter assertForLauncherCallback(
   1041             LauncherApps launcherApps, Runnable body) throws InterruptedException {
   1042         final LauncherCallbackAsserter asserter = new LauncherCallbackAsserter();
   1043         launcherApps.registerCallback(asserter.getMockCallback(),
   1044                 new Handler(Looper.getMainLooper()));
   1045 
   1046         body.run();
   1047 
   1048         waitOnMainThread();
   1049 
   1050         // TODO unregister doesn't work well during unit tests.  Figure out and fix it.
   1051         // launcherApps.unregisterCallback(asserter.getMockCallback());
   1052 
   1053         return asserter;
   1054     }
   1055 
   1056     public static void retryUntil(BooleanSupplier checker, String message) {
   1057         retryUntil(checker, message, 30);
   1058     }
   1059 
   1060     public static void retryUntil(BooleanSupplier checker, String message, long timeoutSeconds) {
   1061         final long timeOut = System.currentTimeMillis() + timeoutSeconds * 1000;
   1062         while (!checker.getAsBoolean()) {
   1063             if (System.currentTimeMillis() > timeOut) {
   1064                 break;
   1065             }
   1066             try {
   1067                 Thread.sleep(200);
   1068             } catch (InterruptedException ignore) {
   1069             }
   1070         }
   1071         assertTrue(message, checker.getAsBoolean());
   1072     }
   1073 }
   1074