/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.server.pm.shortcutmanagertest;
import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertFalse;
import static junit.framework.Assert.assertNotNull;
import static junit.framework.Assert.assertNull;
import static junit.framework.Assert.assertTrue;
import static junit.framework.Assert.fail;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyList;
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import android.app.Instrumentation;
import android.content.ComponentName;
import android.content.Context;
import android.content.pm.LauncherApps;
import android.content.pm.LauncherApps.Callback;
import android.content.pm.ShortcutInfo;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.BaseBundle;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Parcel;
import android.os.ParcelFileDescriptor;
import android.os.PersistableBundle;
import android.os.UserHandle;
import android.test.MoreAsserts;
import android.util.Log;
import junit.framework.Assert;
import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
import org.hamcrest.Matcher;
import org.json.JSONException;
import org.json.JSONObject;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.concurrent.CountDownLatch;
import java.util.function.BooleanSupplier;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
/**
* Common utility methods for ShortcutManager tests. This is used by both CTS and the unit tests.
* Because it's used by CTS too, it can only access the public APIs.
*/
public class ShortcutManagerTestUtils {
private static final String TAG = "ShortcutManagerUtils";
private static final boolean ENABLE_DUMPSYS = true; // DO NOT SUBMIT WITH true
private static final int STANDARD_TIMEOUT_SEC = 5;
private static final String[] EMPTY_STRINGS = new String[0];
private ShortcutManagerTestUtils() {
}
public static List<String> readAll(File file) throws FileNotFoundException {
return readAll(ParcelFileDescriptor.open(
file.getAbsoluteFile(), ParcelFileDescriptor.MODE_READ_ONLY));
}
public static List<String> readAll(ParcelFileDescriptor pfd) {
try {
try {
final ArrayList<String> ret = new ArrayList<>();
try (BufferedReader r = new BufferedReader(
new FileReader(pfd.getFileDescriptor()))) {
String line;
while ((line = r.readLine()) != null) {
ret.add(line);
}
r.readLine();
}
return ret;
} finally {
pfd.close();
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static String concatResult(List<String> result) {
final StringBuilder sb = new StringBuilder();
for (String s : result) {
sb.append(s);
sb.append("\n");
}
return sb.toString();
}
public static boolean resultContains(List<String> result, String expected) {
for (String line : result) {
if (line.contains(expected)) {
return true;
}
}
return false;
}
public static List<String> assertSuccess(List<String> result) {
if (!resultContains(result, "Success")) {
fail("Command failed. Result was:\n" + concatResult(result));
}
return result;
}
public static List<String> assertContains(List<String> result, String expected) {
if (!resultContains(result, expected)) {
fail("Didn't contain expected string=" + expected
+ "\nActual:\n" + concatResult(result));
}
return result;
}
public static List<String> runCommand(Instrumentation instrumentation, String command) {
return runCommand(instrumentation, command, null);
}
public static List<String> runCommand(Instrumentation instrumentation, String command,
Predicate<List<String>> resultAsserter) {
Log.d(TAG, "Running command: " + command);
final List<String> result;
try {
result = readAll(
instrumentation.getUiAutomation().executeShellCommand(command));
} catch (Exception e) {
throw new RuntimeException(e);
}
if (resultAsserter != null && !resultAsserter.test(result)) {
fail("Command '" + command + "' failed, output was:\n" + concatResult(result));
}
return result;
}
public static void runCommandForNoOutput(Instrumentation instrumentation, String command) {
runCommand(instrumentation, command, result -> result.size() == 0);
}
public static List<String> runShortcutCommand(Instrumentation instrumentation, String command,
Predicate<List<String>> resultAsserter) {
return runCommand(instrumentation, "cmd shortcut " + command, resultAsserter);
}
public static List<String> runShortcutCommandForSuccess(Instrumentation instrumentation,
String command) {
return runShortcutCommand(instrumentation, command, result -> result.contains("Success"));
}
public static String getDefaultLauncher(Instrumentation instrumentation) {
final String PREFIX = "Launcher: ComponentInfo{";
final String POSTFIX = "}";
final List<String> result = runShortcutCommandForSuccess(
instrumentation, "get-default-launcher");
for (String s : result) {
if (s.startsWith(PREFIX) && s.endsWith(POSTFIX)) {
return s.substring(PREFIX.length(), s.length() - POSTFIX.length());
}
}
fail("Default launcher not found");
return null;
}
public static void setDefaultLauncher(Instrumentation instrumentation, String component) {
runCommand(instrumentation, "cmd package set-home-activity --user "
+ instrumentation.getContext().getUserId() + " " + component,
result -> result.contains("Success"));
}
public static void setDefaultLauncher(Instrumentation instrumentation, Context packageContext) {
setDefaultLauncher(instrumentation, packageContext.getPackageName()
+ "/android.content.pm.cts.shortcutmanager.packages.Launcher");
}
public static void overrideConfig(Instrumentation instrumentation, String config) {
runShortcutCommandForSuccess(instrumentation, "override-config " + config);
}
public static void resetConfig(Instrumentation instrumentation) {
runShortcutCommandForSuccess(instrumentation, "reset-config");
}
public static void resetThrottling(Instrumentation instrumentation) {
runShortcutCommandForSuccess(instrumentation, "reset-throttling");
}
public static void resetAllThrottling(Instrumentation instrumentation) {
runShortcutCommandForSuccess(instrumentation, "reset-all-throttling");
}
public static void clearShortcuts(Instrumentation instrumentation, int userId,
String packageName) {
runShortcutCommandForSuccess(instrumentation, "clear-shortcuts "
+ " --user " + userId + " " + packageName);
}
public static void anyContains(List<String> result, String expected) {
for (String l : result) {
if (l.contains(expected)) {
return;
}
}
fail("Result didn't contain '" + expected + "': was\n" + result);
}
public static void enableComponent(Instrumentation instrumentation, ComponentName cn,
boolean enable) {
final String word = (enable ? "enable" : "disable");
runCommand(instrumentation,
"pm " + word + " " + cn.flattenToString()
, result ->concatResult(result).contains(word));
}
public static void appOps(Instrumentation instrumentation, String packageName,
String op, String mode) {
runCommand(instrumentation, "appops set " + packageName + " " + op + " " + mode);
}
public static void dumpsysShortcut(Instrumentation instrumentation) {
if (!ENABLE_DUMPSYS) {
return;
}
Log.e(TAG, "Dumpsys shortcut");
for (String s : runCommand(instrumentation, "dumpsys shortcut")) {
Log.e(TAG, s);
}
}
public static JSONObject getCheckinDump(Instrumentation instrumentation) throws JSONException {
return new JSONObject(concatResult(runCommand(instrumentation, "dumpsys shortcut -c")));
}
public static boolean isLowRamDevice(Instrumentation instrumentation) throws JSONException {
return getCheckinDump(instrumentation).getBoolean("lowRam");
}
public static int getIconSize(Instrumentation instrumentation) throws JSONException {
return getCheckinDump(instrumentation).getInt("iconSize");
}
public static Bundle makeBundle(Object... keysAndValues) {
assertTrue((keysAndValues.length % 2) == 0);
if (keysAndValues.length == 0) {
return null;
}
final Bundle ret = new Bundle();
for (int i = keysAndValues.length - 2; i >= 0; i -= 2) {
final String key = keysAndValues[i].toString();
final Object value = keysAndValues[i + 1];
if (value == null) {
ret.putString(key, null);
} else if (value instanceof Integer) {
ret.putInt(key, (Integer) value);
} else if (value instanceof String) {
ret.putString(key, (String) value);
} else if (value instanceof Bundle) {
ret.putBundle(key, (Bundle) value);
} else {
fail("Type not supported yet: " + value.getClass().getName());
}
}
return ret;
}
public static PersistableBundle makePersistableBundle(Object... keysAndValues) {
assertTrue((keysAndValues.length % 2) == 0);
if (keysAndValues.length == 0) {
return null;
}
final PersistableBundle ret = new PersistableBundle();
for (int i = keysAndValues.length - 2; i >= 0; i -= 2) {
final String key = keysAndValues[i].toString();
final Object value = keysAndValues[i + 1];
if (value == null) {
ret.putString(key, null);
} else if (value instanceof Integer) {
ret.putInt(key, (Integer) value);
} else if (value instanceof String) {
ret.putString(key, (String) value);
} else if (value instanceof PersistableBundle) {
ret.putPersistableBundle(key, (PersistableBundle) value);
} else {
fail("Type not supported yet: " + value.getClass().getName());
}
}
return ret;
}
public static <T> List<T> list(T... array) {
return Arrays.asList(array);
}
public static <T> Set<T> hashSet(Set<T> in) {
return new LinkedHashSet<>(in);
}
public static <T> Set<T> set(T... values) {
return set(v -> v, values);
}
public static <T, V> Set<T> set(Function<V, T> converter, V... values) {
return set(converter, Arrays.asList(values));
}
public static <T, V> Set<T> set(Function<V, T> converter, List<V> values) {
final LinkedHashSet<T> ret = new LinkedHashSet<>();
for (V v : values) {
ret.add(converter.apply(v));
}
return ret;
}
public static void resetAll(Collection<?> mocks) {
for (Object o : mocks) {
reset(o);
}
}
public static <T extends Collection<?>> T assertEmpty(T collection) {
if (collection == null) {
return collection; // okay.
}
assertEquals(0, collection.size());
return collection;
}
public static List<ShortcutInfo> filter(List<ShortcutInfo> list, Predicate<ShortcutInfo> p) {
final ArrayList<ShortcutInfo> ret = new ArrayList<>(list);
ret.removeIf(si -> !p.test(si));
return ret;
}
public static List<ShortcutInfo> filterByActivity(List<ShortcutInfo> list,
ComponentName activity) {
return filter(list, si ->
(si.getActivity().equals(activity)
&& (si.isDeclaredInManifest() || si.isDynamic())));
}
public static List<ShortcutInfo> changedSince(List<ShortcutInfo> list, long time) {
return filter(list, si -> si.getLastChangedTimestamp() >= time);
}
@FunctionalInterface
public interface ExceptionRunnable {
void run() throws Exception;
}
public static void assertExpectException(Class<? extends Throwable> expectedExceptionType,
String expectedExceptionMessageRegex, ExceptionRunnable r) {
assertExpectException("", expectedExceptionType, expectedExceptionMessageRegex, r);
}
public static void assertCannotUpdateImmutable(Runnable r) {
assertExpectException(
IllegalArgumentException.class, "may not be manipulated via APIs", r::run);
}
public static void assertDynamicShortcutCountExceeded(Runnable r) {
assertExpectException(IllegalArgumentException.class,
"Max number of dynamic shortcuts exceeded", r::run);
}
public static void assertExpectException(String message,
Class<? extends Throwable> expectedExceptionType,
String expectedExceptionMessageRegex, ExceptionRunnable r) {
try {
r.run();
} catch (Throwable e) {
Assert.assertTrue(
"Expected exception type was " + expectedExceptionType.getName()
+ " but caught " + e + " (message=" + message + ")",
expectedExceptionType.isAssignableFrom(e.getClass()));
if (expectedExceptionMessageRegex != null) {
MoreAsserts.assertContainsRegex(expectedExceptionMessageRegex, e.getMessage());
}
return; // Pass
}
Assert.fail("Expected exception type " + expectedExceptionType.getName()
+ " was not thrown");
}
public static List<ShortcutInfo> assertShortcutIds(List<ShortcutInfo> actualShortcuts,
String... expectedIds) {
final SortedSet<String> expected = new TreeSet<>(list(expectedIds));
final SortedSet<String> actual = new TreeSet<>();
for (ShortcutInfo s : actualShortcuts) {
actual.add(s.getId());
}
// Compare the sets.
assertEquals(expected, actual);
return actualShortcuts;
}
public static List<ShortcutInfo> assertShortcutIdsOrdered(List<ShortcutInfo> actualShortcuts,
String... expectedIds) {
final ArrayList<String> expected = new ArrayList<>(list(expectedIds));
final ArrayList<String> actual = new ArrayList<>();
for (ShortcutInfo s : actualShortcuts) {
actual.add(s.getId());
}
assertEquals(expected, actual);
return actualShortcuts;
}
public static List<ShortcutInfo> assertAllHaveIntents(
List<ShortcutInfo> actualShortcuts) {
for (ShortcutInfo s : actualShortcuts) {
assertNotNull("ID " + s.getId(), s.getIntent());
}
return actualShortcuts;
}
public static List<ShortcutInfo> assertAllNotHaveIntents(
List<ShortcutInfo> actualShortcuts) {
for (ShortcutInfo s : actualShortcuts) {
assertNull("ID " + s.getId(), s.getIntent());
}
return actualShortcuts;
}
public static List<ShortcutInfo> assertAllHaveTitle(
List<ShortcutInfo> actualShortcuts) {
for (ShortcutInfo s : actualShortcuts) {
assertNotNull("ID " + s.getId(), s.getShortLabel());
}
return actualShortcuts;
}
public static List<ShortcutInfo> assertAllNotHaveTitle(
List<ShortcutInfo> actualShortcuts) {
for (ShortcutInfo s : actualShortcuts) {
assertNull("ID " + s.getId(), s.getShortLabel());
}
return actualShortcuts;
}
public static List<ShortcutInfo> assertAllKeyFieldsOnly(
List<ShortcutInfo> actualShortcuts) {
for (ShortcutInfo s : actualShortcuts) {
assertTrue("ID " + s.getId(), s.hasKeyFieldsOnly());
}
return actualShortcuts;
}
public static List<ShortcutInfo> assertAllNotKeyFieldsOnly(
List<ShortcutInfo> actualShortcuts) {
for (ShortcutInfo s : actualShortcuts) {
assertFalse("ID " + s.getId(), s.hasKeyFieldsOnly());
}
return actualShortcuts;
}
public static List<ShortcutInfo> assertAllDynamic(List<ShortcutInfo> actualShortcuts) {
for (ShortcutInfo s : actualShortcuts) {
assertTrue("ID " + s.getId(), s.isDynamic());
}
return actualShortcuts;
}
public static List<ShortcutInfo> assertAllPinned(List<ShortcutInfo> actualShortcuts) {
for (ShortcutInfo s : actualShortcuts) {
assertTrue("ID " + s.getId(), s.isPinned());
}
return actualShortcuts;
}
public static List<ShortcutInfo> assertAllDynamicOrPinned(
List<ShortcutInfo> actualShortcuts) {
for (ShortcutInfo s : actualShortcuts) {
assertTrue("ID " + s.getId(), s.isDynamic() || s.isPinned());
}
return actualShortcuts;
}
public static List<ShortcutInfo> assertAllManifest(
List<ShortcutInfo> actualShortcuts) {
for (ShortcutInfo s : actualShortcuts) {
assertTrue("ID " + s.getId(), s.isDeclaredInManifest());
}
return actualShortcuts;
}
public static List<ShortcutInfo> assertAllNotManifest(
List<ShortcutInfo> actualShortcuts) {
for (ShortcutInfo s : actualShortcuts) {
assertFalse("ID " + s.getId(), s.isDeclaredInManifest());
}
return actualShortcuts;
}
public static List<ShortcutInfo> assertAllDisabled(
List<ShortcutInfo> actualShortcuts) {
for (ShortcutInfo s : actualShortcuts) {
assertTrue("ID " + s.getId(), !s.isEnabled());
}
return actualShortcuts;
}
public static List<ShortcutInfo> assertAllEnabled(
List<ShortcutInfo> actualShortcuts) {
for (ShortcutInfo s : actualShortcuts) {
assertTrue("ID " + s.getId(), s.isEnabled());
}
return actualShortcuts;
}
public static List<ShortcutInfo> assertAllImmutable(
List<ShortcutInfo> actualShortcuts) {
for (ShortcutInfo s : actualShortcuts) {
assertTrue("ID " + s.getId(), s.isImmutable());
}
return actualShortcuts;
}
public static void assertDynamicOnly(ShortcutInfo si) {
assertTrue(si.isDynamic());
assertFalse(si.isPinned());
}
public static void assertPinnedOnly(ShortcutInfo si) {
assertFalse(si.isDynamic());
assertFalse(si.isDeclaredInManifest());
assertTrue(si.isPinned());
}
public static void assertDynamicAndPinned(ShortcutInfo si) {
assertTrue(si.isDynamic());
assertTrue(si.isPinned());
}
public static void assertBitmapSize(int expectedWidth, int expectedHeight, Bitmap bitmap) {
assertEquals("width", expectedWidth, bitmap.getWidth());
assertEquals("height", expectedHeight, bitmap.getHeight());
}
public static <T> void assertAllUnique(Collection<T> list) {
final Set<Object> set = new LinkedHashSet<>();
for (T item : list) {
if (set.contains(item)) {
fail("Duplicate item found: " + item + " (in the list: " + list + ")");
}
set.add(item);
}
}
public static ShortcutInfo findShortcut(List<ShortcutInfo> list, String id) {
for (ShortcutInfo si : list) {
if (si.getId().equals(id)) {
return si;
}
}
fail("Shortcut " + id + " not found in the list");
return null;
}
public static Bitmap pfdToBitmap(ParcelFileDescriptor pfd) {
assertNotNull(pfd);
try {
try {
return BitmapFactory.decodeFileDescriptor(pfd.getFileDescriptor());
} finally {
pfd.close();
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public static void assertBundleEmpty(BaseBundle b) {
assertTrue(b == null || b.size() == 0);
}
public static void assertCallbackNotReceived(LauncherApps.Callback mock) {
verify(mock, times(0)).onShortcutsChanged(anyString(), anyList(),
any(UserHandle.class));
}
public static void assertCallbackReceived(LauncherApps.Callback mock,
UserHandle user, String packageName, String... ids) {
verify(mock).onShortcutsChanged(eq(packageName), checkShortcutIds(ids),
eq(user));
}
public static boolean checkAssertSuccess(Runnable r) {
try {
r.run();
return true;
} catch (AssertionError e) {
return false;
}
}
public static <T> T checkArgument(Predicate<T> checker, String description,
List<T> matchedCaptor) {
final Matcher<T> m = new BaseMatcher<T>() {
@Override
public boolean matches(Object item) {
if (item == null) {
return false;
}
final T value = (T) item;
if (!checker.test(value)) {
return false;
}
if (matchedCaptor != null) {
matchedCaptor.add(value);
}
return true;
}
@Override
public void describeTo(Description d) {
d.appendText(description);
}
};
return Mockito.argThat(m);
}
public static List<ShortcutInfo> checkShortcutIds(String... ids) {
return checkArgument((List<ShortcutInfo> list) -> {
final Set<String> actualSet = set(si -> si.getId(), list);
return actualSet.equals(set(ids));
}, "Shortcut IDs=[" + Arrays.toString(ids) + "]", null);
}
public static ShortcutInfo parceled(ShortcutInfo si) {
Parcel p = Parcel.obtain();
p.writeParcelable(si, 0);
p.setDataPosition(0);
ShortcutInfo si2 = p.readParcelable(ShortcutManagerTestUtils.class.getClassLoader());
p.recycle();
return si2;
}
public static List<ShortcutInfo> cloneShortcutList(List<ShortcutInfo> list) {
if (list == null) {
return null;
}
final List<ShortcutInfo> ret = new ArrayList<>(list.size());
for (ShortcutInfo si : list) {
ret.add(parceled(si));
}
return ret;
}
private static final Comparator<ShortcutInfo> sRankComparator =
(ShortcutInfo a, ShortcutInfo b) -> Integer.compare(a.getRank(), b.getRank());
public static List<ShortcutInfo> sortedByRank(List<ShortcutInfo> shortcuts) {
final ArrayList<ShortcutInfo> ret = new ArrayList<>(shortcuts);
Collections.sort(ret, sRankComparator);
return ret;
}
public static void waitUntil(String message, BooleanSupplier condition) {
waitUntil(message, condition, STANDARD_TIMEOUT_SEC);
}
public static void waitUntil(String message, BooleanSupplier condition, int timeoutSeconds) {
final long timeout = System.currentTimeMillis() + (timeoutSeconds * 1000L);
while (System.currentTimeMillis() < timeout) {
if (condition.getAsBoolean()) {
return;
}
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
fail("Timed out for: " + message);
}
public static ShortcutListAsserter assertWith(List<ShortcutInfo> list) {
return new ShortcutListAsserter(list);
}
/**
* New style assertion that allows chained calls.
*/
public static class ShortcutListAsserter {
private final ShortcutListAsserter mOriginal;
private final List<ShortcutInfo> mList;
ShortcutListAsserter(List<ShortcutInfo> list) {
this(null, list);
}
private ShortcutListAsserter(ShortcutListAsserter original, List<ShortcutInfo> list) {
mOriginal = (original == null) ? this : original;
mList = (list == null) ? new ArrayList<>(0) : new ArrayList<>(list);
}
public ShortcutListAsserter revertToOriginalList() {
return mOriginal;
}
public ShortcutListAsserter selectDynamic() {
return new ShortcutListAsserter(this,
filter(mList, ShortcutInfo::isDynamic));
}
public ShortcutListAsserter selectManifest() {
return new ShortcutListAsserter(this,
filter(mList, ShortcutInfo::isDeclaredInManifest));
}
public ShortcutListAsserter selectPinned() {
return new ShortcutListAsserter(this,
filter(mList, ShortcutInfo::isPinned));
}
public ShortcutListAsserter selectByActivity(ComponentName activity) {
return new ShortcutListAsserter(this,
ShortcutManagerTestUtils.filterByActivity(mList, activity));
}
public ShortcutListAsserter selectByChangedSince(long time) {
return new ShortcutListAsserter(this,
ShortcutManagerTestUtils.changedSince(mList, time));
}
public ShortcutListAsserter selectByIds(String... ids) {
final Set<String> idSet = set(ids);
final ArrayList<ShortcutInfo> selected = new ArrayList<>();
for (ShortcutInfo si : mList) {
if (idSet.contains(si.getId())) {
selected.add(si);
idSet.remove(si.getId());
}
}
if (idSet.size() > 0) {
fail("Shortcuts not found for IDs=" + idSet);
}
return new ShortcutListAsserter(this, selected);
}
public ShortcutListAsserter toSortByRank() {
return new ShortcutListAsserter(this,
ShortcutManagerTestUtils.sortedByRank(mList));
}
public ShortcutListAsserter call(Consumer<List<ShortcutInfo>> c) {
c.accept(mList);
return this;
}
public ShortcutListAsserter haveIds(String... expectedIds) {
assertShortcutIds(mList, expectedIds);
return this;
}
public ShortcutListAsserter haveIdsOrdered(String... expectedIds) {
assertShortcutIdsOrdered(mList, expectedIds);
return this;
}
private ShortcutListAsserter haveSequentialRanks() {
for (int i = 0; i < mList.size(); i++) {
final ShortcutInfo si = mList.get(i);
assertEquals("Rank not sequential: id=" + si.getId(), i, si.getRank());
}
return this;
}
public ShortcutListAsserter haveRanksInOrder(String... expectedIds) {
toSortByRank()
.haveSequentialRanks()
.haveIdsOrdered(expectedIds);
return this;
}
public ShortcutListAsserter isEmpty() {
assertEquals(0, mList.size());
return this;
}
public ShortcutListAsserter areAllDynamic() {
forAllShortcuts(s -> assertTrue("id=" + s.getId(), s.isDynamic()));
return this;
}
public ShortcutListAsserter areAllNotDynamic() {
forAllShortcuts(s -> assertFalse("id=" + s.getId(), s.isDynamic()));
return this;
}
public ShortcutListAsserter areAllPinned() {
forAllShortcuts(s -> assertTrue("id=" + s.getId(), s.isPinned()));
return this;
}
public ShortcutListAsserter areAllNotPinned() {
forAllShortcuts(s -> assertFalse("id=" + s.getId(), s.isPinned()));
return this;
}
public ShortcutListAsserter areAllManifest() {
forAllShortcuts(s -> assertTrue("id=" + s.getId(), s.isDeclaredInManifest()));
return this;
}
public ShortcutListAsserter areAllNotManifest() {
forAllShortcuts(s -> assertFalse("id=" + s.getId(), s.isDeclaredInManifest()));
return this;
}
public ShortcutListAsserter areAllImmutable() {
forAllShortcuts(s -> assertTrue("id=" + s.getId(), s.isImmutable()));
return this;
}
public ShortcutListAsserter areAllMutable() {
forAllShortcuts(s -> assertFalse("id=" + s.getId(), s.isImmutable()));
return this;
}
public ShortcutListAsserter areAllEnabled() {
forAllShortcuts(s -> assertTrue("id=" + s.getId(), s.isEnabled()));
return this;
}
public ShortcutListAsserter areAllDisabled() {
forAllShortcuts(s -> assertFalse("id=" + s.getId(), s.isEnabled()));
return this;
}
public ShortcutListAsserter areAllWithKeyFieldsOnly() {
forAllShortcuts(s -> assertTrue("id=" + s.getId(), s.hasKeyFieldsOnly()));
return this;
}
public ShortcutListAsserter areAllNotWithKeyFieldsOnly() {
forAllShortcuts(s -> assertFalse("id=" + s.getId(), s.hasKeyFieldsOnly()));
return this;
}
public ShortcutListAsserter areAllWithActivity(ComponentName activity) {
forAllShortcuts(s -> assertTrue("id=" + s.getId(), s.getActivity().equals(activity)));
return this;
}
public ShortcutListAsserter forAllShortcuts(Consumer<ShortcutInfo> sa) {
boolean found = false;
for (int i = 0; i < mList.size(); i++) {
final ShortcutInfo si = mList.get(i);
found = true;
sa.accept(si);
}
assertTrue("No shortcuts found.", found);
return this;
}
public ShortcutListAsserter forShortcut(Predicate<ShortcutInfo> p,
Consumer<ShortcutInfo> sa) {
boolean found = false;
for (int i = 0; i < mList.size(); i++) {
final ShortcutInfo si = mList.get(i);
if (p.test(si)) {
found = true;
try {
sa.accept(si);
} catch (Throwable e) {
throw new AssertionError("Assertion failed for shortcut " + si.getId(), e);
}
}
}
assertTrue("Shortcut with the given condition not found.", found);
return this;
}
public ShortcutListAsserter forShortcutWithId(String id, Consumer<ShortcutInfo> sa) {
forShortcut(si -> si.getId().equals(id), sa);
return this;
}
}
public static void assertBundlesEqual(BaseBundle b1, BaseBundle b2) {
if (b1 == null && b2 == null) {
return; // pass
}
assertNotNull("b1 is null but b2 is not", b1);
assertNotNull("b2 is null but b1 is not", b2);
// HashSet makes the error message readable.
assertEquals(set(b1.keySet()), set(b2.keySet()));
for (String key : b1.keySet()) {
final Object v1 = b1.get(key);
final Object v2 = b2.get(key);
if (v1 == null) {
if (v2 == null) {
return;
}
}
if (v1.equals(v2)) {
return;
}
assertTrue("Only either value is null: key=" + key
+ " b1=" + b1 + " b2=" + b2, v1 != null && v2 != null);
assertEquals("Class mismatch: key=" + key, v1.getClass(), v2.getClass());
if (v1 instanceof BaseBundle) {
assertBundlesEqual((BaseBundle) v1, (BaseBundle) v2);
} else if (v1 instanceof boolean[]) {
assertTrue(Arrays.equals((boolean[]) v1, (boolean[]) v2));
} else if (v1 instanceof int[]) {
MoreAsserts.assertEquals((int[]) v1, (int[]) v2);
} else if (v1 instanceof double[]) {
MoreAsserts.assertEquals((double[]) v1, (double[]) v2);
} else if (v1 instanceof String[]) {
MoreAsserts.assertEquals((String[]) v1, (String[]) v2);
} else if (v1 instanceof Double) {
if (((Double) v1).isNaN()) {
assertTrue(((Double) v2).isNaN());
} else {
assertEquals(v1, v2);
}
} else {
assertEquals(v1, v2);
}
}
}
public static void waitOnMainThread() throws InterruptedException {
final CountDownLatch latch = new CountDownLatch(1);
new Handler(Looper.getMainLooper()).post(() -> latch.countDown());
latch.await();
}
public static class LauncherCallbackAsserter {
private final LauncherApps.Callback mCallback = mock(LauncherApps.Callback.class);
private Callback getMockCallback() {
return mCallback;
}
public LauncherCallbackAsserter assertNoCallbackCalled() {
verify(mCallback, times(0)).onShortcutsChanged(
anyString(),
any(List.class),
any(UserHandle.class));
return this;
}
public LauncherCallbackAsserter assertNoCallbackCalledForPackage(
String publisherPackageName) {
verify(mCallback, times(0)).onShortcutsChanged(
eq(publisherPackageName),
any(List.class),
any(UserHandle.class));
return this;
}
public LauncherCallbackAsserter assertNoCallbackCalledForPackageAndUser(
String publisherPackageName, UserHandle publisherUserHandle) {
verify(mCallback, times(0)).onShortcutsChanged(
eq(publisherPackageName),
any(List.class),
eq(publisherUserHandle));
return this;
}
public ShortcutListAsserter assertCallbackCalledForPackageAndUser(
String publisherPackageName, UserHandle publisherUserHandle) {
final ArgumentCaptor<List> shortcuts = ArgumentCaptor.forClass(List.class);
verify(mCallback, times(1)).onShortcutsChanged(
eq(publisherPackageName),
shortcuts.capture(),
eq(publisherUserHandle));
return new ShortcutListAsserter(shortcuts.getValue());
}
}
public static LauncherCallbackAsserter assertForLauncherCallback(
LauncherApps launcherApps, Runnable body) throws InterruptedException {
final LauncherCallbackAsserter asserter = new LauncherCallbackAsserter();
launcherApps.registerCallback(asserter.getMockCallback(),
new Handler(Looper.getMainLooper()));
body.run();
waitOnMainThread();
// TODO unregister doesn't work well during unit tests. Figure out and fix it.
// launcherApps.unregisterCallback(asserter.getMockCallback());
return asserter;
}
public static void retryUntil(BooleanSupplier checker, String message) {
retryUntil(checker, message, 30);
}
public static void retryUntil(BooleanSupplier checker, String message, long timeoutSeconds) {
final long timeOut = System.currentTimeMillis() + timeoutSeconds * 1000;
while (!checker.getAsBoolean()) {
if (System.currentTimeMillis() > timeOut) {
break;
}
try {
Thread.sleep(200);
} catch (InterruptedException ignore) {
}
}
assertTrue(message, checker.getAsBoolean());
}
}