Utility to merge multiple Bundles.
As part of our work on the "modern" broadcast queue, we're likely going to need to collapse multiple existing broadcasts together, using various strategies based on the contents of the extras. Intents at a high level already have Intent.fillIn() to describe how to be blended together, and this new class describes how to blend a Bundle of extras together. Common examples are included in testMerge_PackageChanged() and testMerge_DropBox(). We have a strong preference to have the merging strategy described in a static way so that it can be applied without the risk of an open-ended callback while a critical lock is being held. This also aids the ability for remote processes to influence how their broadcasts are merged. Bug: 249160234 Test: atest FrameworksCoreTests:BundleMergerTest Change-Id: Ibe8623c02147afbb99826dccb063bd566d447642
This commit is contained in:
Jeff Sharkey
379
core/java/android/os/BundleMerger.java
Normal file
379
core/java/android/os/BundleMerger.java
Normal file
@@ -0,0 +1,379 @@
|
||||
/*
|
||||
* Copyright (C) 2022 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 android.os;
|
||||
|
||||
import android.annotation.IntDef;
|
||||
import android.annotation.NonNull;
|
||||
import android.annotation.Nullable;
|
||||
import android.util.ArrayMap;
|
||||
import android.util.ArraySet;
|
||||
import android.util.Log;
|
||||
|
||||
import com.android.internal.annotations.VisibleForTesting;
|
||||
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.reflect.Array;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Objects;
|
||||
import java.util.function.BinaryOperator;
|
||||
|
||||
/**
|
||||
* Configured rules for merging two {@link Bundle} instances.
|
||||
* <p>
|
||||
* By default, values from both {@link Bundle} instances are blended together on
|
||||
* a key-wise basis, and conflicting value definitions for a key are dropped.
|
||||
* <p>
|
||||
* Nuanced strategies for handling conflicting value definitions can be applied
|
||||
* using {@link #setMergeStrategy(String, int)} and
|
||||
* {@link #setDefaultMergeStrategy(int)}.
|
||||
* <p>
|
||||
* When conflicting values have <em>inconsistent</em> data types (such as trying
|
||||
* to merge a {@link String} and a {@link Integer}), both conflicting values are
|
||||
* rejected and the key becomes undefined, regardless of the requested strategy.
|
||||
*
|
||||
* @hide
|
||||
*/
|
||||
public class BundleMerger implements Parcelable {
|
||||
private static final String TAG = "BundleMerger";
|
||||
|
||||
private @Strategy int mDefaultStrategy = STRATEGY_REJECT;
|
||||
|
||||
private final ArrayMap<String, Integer> mStrategies = new ArrayMap<>();
|
||||
|
||||
/**
|
||||
* Merge strategy that rejects both conflicting values.
|
||||
*/
|
||||
public static final int STRATEGY_REJECT = 0;
|
||||
|
||||
/**
|
||||
* Merge strategy that selects the first of conflicting values.
|
||||
*/
|
||||
public static final int STRATEGY_FIRST = 1;
|
||||
|
||||
/**
|
||||
* Merge strategy that selects the last of conflicting values.
|
||||
*/
|
||||
public static final int STRATEGY_LAST = 2;
|
||||
|
||||
/**
|
||||
* Merge strategy that selects the "minimum" of conflicting values which are
|
||||
* {@link Comparable} with each other.
|
||||
*/
|
||||
public static final int STRATEGY_COMPARABLE_MIN = 3;
|
||||
|
||||
/**
|
||||
* Merge strategy that selects the "maximum" of conflicting values which are
|
||||
* {@link Comparable} with each other.
|
||||
*/
|
||||
public static final int STRATEGY_COMPARABLE_MAX = 4;
|
||||
|
||||
/**
|
||||
* Merge strategy that numerically adds both conflicting values.
|
||||
*/
|
||||
public static final int STRATEGY_NUMBER_ADD = 5;
|
||||
|
||||
/**
|
||||
* Merge strategy that numerically increments the first conflicting value by
|
||||
* {@code 1} and ignores the last conflicting value.
|
||||
*/
|
||||
public static final int STRATEGY_NUMBER_INCREMENT_FIRST = 6;
|
||||
|
||||
/**
|
||||
* Merge strategy that combines conflicting values using a boolean "and"
|
||||
* operation.
|
||||
*/
|
||||
public static final int STRATEGY_BOOLEAN_AND = 7;
|
||||
|
||||
/**
|
||||
* Merge strategy that combines conflicting values using a boolean "or"
|
||||
* operation.
|
||||
*/
|
||||
public static final int STRATEGY_BOOLEAN_OR = 8;
|
||||
|
||||
/**
|
||||
* Merge strategy that combines two conflicting array values by appending
|
||||
* the last array after the first array.
|
||||
*/
|
||||
public static final int STRATEGY_ARRAY_APPEND = 9;
|
||||
|
||||
/**
|
||||
* Merge strategy that combines two conflicting {@link ArrayList} values by
|
||||
* appending the last {@link ArrayList} after the first {@link ArrayList}.
|
||||
*/
|
||||
public static final int STRATEGY_ARRAY_LIST_APPEND = 10;
|
||||
|
||||
@IntDef(flag = false, prefix = { "STRATEGY_" }, value = {
|
||||
STRATEGY_REJECT,
|
||||
STRATEGY_FIRST,
|
||||
STRATEGY_LAST,
|
||||
STRATEGY_COMPARABLE_MIN,
|
||||
STRATEGY_COMPARABLE_MAX,
|
||||
STRATEGY_NUMBER_ADD,
|
||||
STRATEGY_NUMBER_INCREMENT_FIRST,
|
||||
STRATEGY_BOOLEAN_AND,
|
||||
STRATEGY_BOOLEAN_OR,
|
||||
STRATEGY_ARRAY_APPEND,
|
||||
STRATEGY_ARRAY_LIST_APPEND,
|
||||
})
|
||||
@Retention(RetentionPolicy.SOURCE)
|
||||
public @interface Strategy {}
|
||||
|
||||
/**
|
||||
* Create a empty set of rules for merging two {@link Bundle} instances.
|
||||
*/
|
||||
public BundleMerger() {
|
||||
}
|
||||
|
||||
private BundleMerger(@NonNull Parcel in) {
|
||||
mDefaultStrategy = in.readInt();
|
||||
final int N = in.readInt();
|
||||
for (int i = 0; i < N; i++) {
|
||||
mStrategies.put(in.readString(), in.readInt());
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeToParcel(@NonNull Parcel out, int flags) {
|
||||
out.writeInt(mDefaultStrategy);
|
||||
final int N = mStrategies.size();
|
||||
out.writeInt(N);
|
||||
for (int i = 0; i < N; i++) {
|
||||
out.writeString(mStrategies.keyAt(i));
|
||||
out.writeInt(mStrategies.valueAt(i));
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public int describeContents() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Configure the default merge strategy to be used when there isn't a
|
||||
* more-specific strategy defined for a particular key via
|
||||
* {@link #setMergeStrategy(String, int)}.
|
||||
*/
|
||||
public void setDefaultMergeStrategy(@Strategy int strategy) {
|
||||
mDefaultStrategy = strategy;
|
||||
}
|
||||
|
||||
/**
|
||||
* Configure the merge strategy to be used for the given key.
|
||||
* <p>
|
||||
* Subsequent calls for the same key will overwrite any previously
|
||||
* configured strategy.
|
||||
*/
|
||||
public void setMergeStrategy(@NonNull String key, @Strategy int strategy) {
|
||||
mStrategies.put(key, strategy);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the merge strategy to be used for the given key, as defined by
|
||||
* {@link #setMergeStrategy(String, int)}.
|
||||
* <p>
|
||||
* If no specific strategy has been configured for the given key, this
|
||||
* returns {@link #setDefaultMergeStrategy(int)}.
|
||||
*/
|
||||
public @Strategy int getMergeStrategy(@NonNull String key) {
|
||||
return (int) mStrategies.getOrDefault(key, mDefaultStrategy);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return a {@link BinaryOperator} which applies the strategies configured
|
||||
* in this object to merge the two given {@link Bundle} arguments.
|
||||
*/
|
||||
public BinaryOperator<Bundle> asBinaryOperator() {
|
||||
return this::merge;
|
||||
}
|
||||
|
||||
/**
|
||||
* Apply the strategies configured in this object to merge the two given
|
||||
* {@link Bundle} arguments.
|
||||
*
|
||||
* @return the merged {@link Bundle} result. If one argument is {@code null}
|
||||
* it will return the other argument. If both arguments are null it
|
||||
* will return {@code null}.
|
||||
*/
|
||||
@SuppressWarnings("deprecation")
|
||||
public @Nullable Bundle merge(@Nullable Bundle first, @Nullable Bundle last) {
|
||||
if (first == null && last == null) {
|
||||
return null;
|
||||
}
|
||||
if (first == null) {
|
||||
first = Bundle.EMPTY;
|
||||
}
|
||||
if (last == null) {
|
||||
last = Bundle.EMPTY;
|
||||
}
|
||||
|
||||
// Start by bulk-copying all values without attempting to unpack any
|
||||
// custom parcelables; we'll circle back to handle conflicts below
|
||||
final Bundle res = new Bundle();
|
||||
res.putAll(first);
|
||||
res.putAll(last);
|
||||
|
||||
final ArraySet<String> conflictingKeys = new ArraySet<>();
|
||||
conflictingKeys.addAll(first.keySet());
|
||||
conflictingKeys.retainAll(last.keySet());
|
||||
for (int i = 0; i < conflictingKeys.size(); i++) {
|
||||
final String key = conflictingKeys.valueAt(i);
|
||||
final int strategy = getMergeStrategy(key);
|
||||
final Object firstValue = first.get(key);
|
||||
final Object lastValue = last.get(key);
|
||||
try {
|
||||
res.putObject(key, merge(strategy, firstValue, lastValue));
|
||||
} catch (Exception e) {
|
||||
Log.w(TAG, "Failed to merge key " + key + " with " + firstValue + " and "
|
||||
+ lastValue + " using strategy " + strategy, e);
|
||||
}
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
/**
|
||||
* Merge the two given values. If only one of the values is defined, it
|
||||
* always wins, otherwise the given strategy is applied.
|
||||
*
|
||||
* @hide
|
||||
*/
|
||||
@VisibleForTesting
|
||||
public static @Nullable Object merge(@Strategy int strategy,
|
||||
@Nullable Object first, @Nullable Object last) {
|
||||
if (first == null) return last;
|
||||
if (last == null) return first;
|
||||
|
||||
if (first.getClass() != last.getClass()) {
|
||||
throw new IllegalArgumentException("Merging requires consistent classes; first "
|
||||
+ first.getClass() + " last " + last.getClass());
|
||||
}
|
||||
|
||||
switch (strategy) {
|
||||
case STRATEGY_REJECT:
|
||||
// Only actually reject when the values are different
|
||||
if (Objects.deepEquals(first, last)) {
|
||||
return first;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
case STRATEGY_FIRST:
|
||||
return first;
|
||||
case STRATEGY_LAST:
|
||||
return last;
|
||||
case STRATEGY_COMPARABLE_MIN:
|
||||
return comparableMin(first, last);
|
||||
case STRATEGY_COMPARABLE_MAX:
|
||||
return comparableMax(first, last);
|
||||
case STRATEGY_NUMBER_ADD:
|
||||
return numberAdd(first, last);
|
||||
case STRATEGY_NUMBER_INCREMENT_FIRST:
|
||||
return numberIncrementFirst(first, last);
|
||||
case STRATEGY_BOOLEAN_AND:
|
||||
return booleanAnd(first, last);
|
||||
case STRATEGY_BOOLEAN_OR:
|
||||
return booleanOr(first, last);
|
||||
case STRATEGY_ARRAY_APPEND:
|
||||
return arrayAppend(first, last);
|
||||
case STRATEGY_ARRAY_LIST_APPEND:
|
||||
return arrayListAppend(first, last);
|
||||
default:
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private static @NonNull Object comparableMin(@NonNull Object first, @NonNull Object last) {
|
||||
return ((Comparable<Object>) first).compareTo(last) < 0 ? first : last;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private static @NonNull Object comparableMax(@NonNull Object first, @NonNull Object last) {
|
||||
return ((Comparable<Object>) first).compareTo(last) >= 0 ? first : last;
|
||||
}
|
||||
|
||||
private static @NonNull Object numberAdd(@NonNull Object first, @NonNull Object last) {
|
||||
if (first instanceof Integer) {
|
||||
return ((Integer) first) + ((Integer) last);
|
||||
} else if (first instanceof Long) {
|
||||
return ((Long) first) + ((Long) last);
|
||||
} else if (first instanceof Float) {
|
||||
return ((Float) first) + ((Float) last);
|
||||
} else if (first instanceof Double) {
|
||||
return ((Double) first) + ((Double) last);
|
||||
} else {
|
||||
throw new IllegalArgumentException("Unable to add " + first.getClass());
|
||||
}
|
||||
}
|
||||
|
||||
private static @NonNull Number numberIncrementFirst(@NonNull Object first,
|
||||
@NonNull Object last) {
|
||||
if (first instanceof Integer) {
|
||||
return ((Integer) first) + 1;
|
||||
} else if (first instanceof Long) {
|
||||
return ((Long) first) + 1L;
|
||||
} else {
|
||||
throw new IllegalArgumentException("Unable to add " + first.getClass());
|
||||
}
|
||||
}
|
||||
|
||||
private static @NonNull Object booleanAnd(@NonNull Object first, @NonNull Object last) {
|
||||
return ((Boolean) first) && ((Boolean) last);
|
||||
}
|
||||
|
||||
private static @NonNull Object booleanOr(@NonNull Object first, @NonNull Object last) {
|
||||
return ((Boolean) first) || ((Boolean) last);
|
||||
}
|
||||
|
||||
private static @NonNull Object arrayAppend(@NonNull Object first, @NonNull Object last) {
|
||||
if (!first.getClass().isArray()) {
|
||||
throw new IllegalArgumentException("Unable to append " + first.getClass());
|
||||
}
|
||||
final Class<?> clazz = first.getClass().getComponentType();
|
||||
final int firstLength = Array.getLength(first);
|
||||
final int lastLength = Array.getLength(last);
|
||||
final Object res = Array.newInstance(clazz, firstLength + lastLength);
|
||||
System.arraycopy(first, 0, res, 0, firstLength);
|
||||
System.arraycopy(last, 0, res, firstLength, lastLength);
|
||||
return res;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private static @NonNull Object arrayListAppend(@NonNull Object first, @NonNull Object last) {
|
||||
if (!(first instanceof ArrayList)) {
|
||||
throw new IllegalArgumentException("Unable to append " + first.getClass());
|
||||
}
|
||||
final ArrayList<Object> firstList = (ArrayList<Object>) first;
|
||||
final ArrayList<Object> lastList = (ArrayList<Object>) last;
|
||||
final ArrayList<Object> res = new ArrayList<>(firstList.size() + lastList.size());
|
||||
res.addAll(firstList);
|
||||
res.addAll(lastList);
|
||||
return res;
|
||||
}
|
||||
|
||||
public static final @android.annotation.NonNull Parcelable.Creator<BundleMerger> CREATOR =
|
||||
new Parcelable.Creator<BundleMerger>() {
|
||||
@Override
|
||||
public BundleMerger createFromParcel(Parcel in) {
|
||||
return new BundleMerger(in);
|
||||
}
|
||||
|
||||
@Override
|
||||
public BundleMerger[] newArray(int size) {
|
||||
return new BundleMerger[size];
|
||||
}
|
||||
};
|
||||
}
|
||||
408
core/tests/coretests/src/android/os/BundleMergerTest.java
Normal file
408
core/tests/coretests/src/android/os/BundleMergerTest.java
Normal file
@@ -0,0 +1,408 @@
|
||||
/*
|
||||
* Copyright (C) 2022 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 android.os;
|
||||
|
||||
import static android.os.BundleMerger.STRATEGY_ARRAY_APPEND;
|
||||
import static android.os.BundleMerger.STRATEGY_ARRAY_LIST_APPEND;
|
||||
import static android.os.BundleMerger.STRATEGY_BOOLEAN_AND;
|
||||
import static android.os.BundleMerger.STRATEGY_BOOLEAN_OR;
|
||||
import static android.os.BundleMerger.STRATEGY_COMPARABLE_MAX;
|
||||
import static android.os.BundleMerger.STRATEGY_COMPARABLE_MIN;
|
||||
import static android.os.BundleMerger.STRATEGY_FIRST;
|
||||
import static android.os.BundleMerger.STRATEGY_LAST;
|
||||
import static android.os.BundleMerger.STRATEGY_NUMBER_ADD;
|
||||
import static android.os.BundleMerger.STRATEGY_NUMBER_INCREMENT_FIRST;
|
||||
import static android.os.BundleMerger.STRATEGY_REJECT;
|
||||
import static android.os.BundleMerger.merge;
|
||||
|
||||
import static org.junit.Assert.assertArrayEquals;
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertThrows;
|
||||
|
||||
import android.content.Intent;
|
||||
import android.net.Uri;
|
||||
|
||||
import androidx.test.filters.SmallTest;
|
||||
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.junit.runners.JUnit4;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
|
||||
@SmallTest
|
||||
@RunWith(JUnit4.class)
|
||||
public class BundleMergerTest {
|
||||
/**
|
||||
* Strategies are only applied when there is an actual conflict; in the
|
||||
* absence of conflict we pick whichever value is defined.
|
||||
*/
|
||||
@Test
|
||||
public void testNoConflict() throws Exception {
|
||||
for (int strategy = Byte.MIN_VALUE; strategy < Byte.MAX_VALUE; strategy++) {
|
||||
assertEquals(null, merge(strategy, null, null));
|
||||
assertEquals(10, merge(strategy, 10, null));
|
||||
assertEquals(20, merge(strategy, null, 20));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Strategies are only applied to identical data types; if there are mixed
|
||||
* types we always reject the two conflicting values.
|
||||
*/
|
||||
@Test
|
||||
public void testMixedTypes() throws Exception {
|
||||
for (int strategy = Byte.MIN_VALUE; strategy < Byte.MAX_VALUE; strategy++) {
|
||||
final int finalStrategy = strategy;
|
||||
assertThrows(Exception.class, () -> {
|
||||
merge(finalStrategy, 10, "foo");
|
||||
});
|
||||
assertThrows(Exception.class, () -> {
|
||||
merge(finalStrategy, List.of("foo"), "bar");
|
||||
});
|
||||
assertThrows(Exception.class, () -> {
|
||||
merge(finalStrategy, new String[] { "foo" }, "bar");
|
||||
});
|
||||
assertThrows(Exception.class, () -> {
|
||||
merge(finalStrategy, Integer.valueOf(10), Long.valueOf(10));
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testStrategyReject() throws Exception {
|
||||
assertEquals(null, merge(STRATEGY_REJECT, 10, 20));
|
||||
|
||||
// Identical values aren't technically a conflict, so they're passed
|
||||
// through without being rejected
|
||||
assertEquals(10, merge(STRATEGY_REJECT, 10, 10));
|
||||
assertArrayEquals(new int[] {10},
|
||||
(int[]) merge(STRATEGY_REJECT, new int[] {10}, new int[] {10}));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testStrategyFirst() throws Exception {
|
||||
assertEquals(10, merge(STRATEGY_FIRST, 10, 20));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testStrategyLast() throws Exception {
|
||||
assertEquals(20, merge(STRATEGY_LAST, 10, 20));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testStrategyComparableMin() throws Exception {
|
||||
assertEquals(10, merge(STRATEGY_COMPARABLE_MIN, 10, 20));
|
||||
assertEquals(10, merge(STRATEGY_COMPARABLE_MIN, 20, 10));
|
||||
assertEquals("a", merge(STRATEGY_COMPARABLE_MIN, "a", "z"));
|
||||
assertEquals("a", merge(STRATEGY_COMPARABLE_MIN, "z", "a"));
|
||||
|
||||
assertThrows(Exception.class, () -> {
|
||||
merge(STRATEGY_COMPARABLE_MIN, new Binder(), new Binder());
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testStrategyComparableMax() throws Exception {
|
||||
assertEquals(20, merge(STRATEGY_COMPARABLE_MAX, 10, 20));
|
||||
assertEquals(20, merge(STRATEGY_COMPARABLE_MAX, 20, 10));
|
||||
assertEquals("z", merge(STRATEGY_COMPARABLE_MAX, "a", "z"));
|
||||
assertEquals("z", merge(STRATEGY_COMPARABLE_MAX, "z", "a"));
|
||||
|
||||
assertThrows(Exception.class, () -> {
|
||||
merge(STRATEGY_COMPARABLE_MAX, new Binder(), new Binder());
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testStrategyNumberAdd() throws Exception {
|
||||
assertEquals(30, merge(STRATEGY_NUMBER_ADD, 10, 20));
|
||||
assertEquals(30, merge(STRATEGY_NUMBER_ADD, 20, 10));
|
||||
assertEquals(30L, merge(STRATEGY_NUMBER_ADD, 10L, 20L));
|
||||
assertEquals(30L, merge(STRATEGY_NUMBER_ADD, 20L, 10L));
|
||||
|
||||
assertThrows(Exception.class, () -> {
|
||||
merge(STRATEGY_NUMBER_ADD, new Binder(), new Binder());
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testStrategyNumberIncrementFirst() throws Exception {
|
||||
assertEquals(11, merge(STRATEGY_NUMBER_INCREMENT_FIRST, 10, 20));
|
||||
assertEquals(21, merge(STRATEGY_NUMBER_INCREMENT_FIRST, 20, 10));
|
||||
assertEquals(11L, merge(STRATEGY_NUMBER_INCREMENT_FIRST, 10L, 20L));
|
||||
assertEquals(21L, merge(STRATEGY_NUMBER_INCREMENT_FIRST, 20L, 10L));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testStrategyBooleanAnd() throws Exception {
|
||||
assertEquals(false, merge(STRATEGY_BOOLEAN_AND, false, false));
|
||||
assertEquals(false, merge(STRATEGY_BOOLEAN_AND, true, false));
|
||||
assertEquals(false, merge(STRATEGY_BOOLEAN_AND, false, true));
|
||||
assertEquals(true, merge(STRATEGY_BOOLEAN_AND, true, true));
|
||||
|
||||
assertThrows(Exception.class, () -> {
|
||||
merge(STRATEGY_BOOLEAN_AND, "True!", "False?");
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testStrategyBooleanOr() throws Exception {
|
||||
assertEquals(false, merge(STRATEGY_BOOLEAN_OR, false, false));
|
||||
assertEquals(true, merge(STRATEGY_BOOLEAN_OR, true, false));
|
||||
assertEquals(true, merge(STRATEGY_BOOLEAN_OR, false, true));
|
||||
assertEquals(true, merge(STRATEGY_BOOLEAN_OR, true, true));
|
||||
|
||||
assertThrows(Exception.class, () -> {
|
||||
merge(STRATEGY_BOOLEAN_OR, "True!", "False?");
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testStrategyArrayAppend() throws Exception {
|
||||
assertArrayEquals(new int[] {},
|
||||
(int[]) merge(STRATEGY_ARRAY_APPEND, new int[] {}, new int[] {}));
|
||||
assertArrayEquals(new int[] {10},
|
||||
(int[]) merge(STRATEGY_ARRAY_APPEND, new int[] {10}, new int[] {}));
|
||||
assertArrayEquals(new int[] {20},
|
||||
(int[]) merge(STRATEGY_ARRAY_APPEND, new int[] {}, new int[] {20}));
|
||||
assertArrayEquals(new int[] {10, 20},
|
||||
(int[]) merge(STRATEGY_ARRAY_APPEND, new int[] {10}, new int[] {20}));
|
||||
assertArrayEquals(new int[] {10, 30, 20, 40},
|
||||
(int[]) merge(STRATEGY_ARRAY_APPEND, new int[] {10, 30}, new int[] {20, 40}));
|
||||
assertArrayEquals(new String[] {"a", "b"},
|
||||
(String[]) merge(STRATEGY_ARRAY_APPEND, new String[] {"a"}, new String[] {"b"}));
|
||||
|
||||
assertThrows(Exception.class, () -> {
|
||||
merge(STRATEGY_ARRAY_APPEND, 10, 20);
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testStrategyArrayListAppend() throws Exception {
|
||||
assertEquals(arrayListOf(),
|
||||
merge(STRATEGY_ARRAY_LIST_APPEND, arrayListOf(), arrayListOf()));
|
||||
assertEquals(arrayListOf(10),
|
||||
merge(STRATEGY_ARRAY_LIST_APPEND, arrayListOf(10), arrayListOf()));
|
||||
assertEquals(arrayListOf(20),
|
||||
merge(STRATEGY_ARRAY_LIST_APPEND, arrayListOf(), arrayListOf(20)));
|
||||
assertEquals(arrayListOf(10, 20),
|
||||
merge(STRATEGY_ARRAY_LIST_APPEND, arrayListOf(10), arrayListOf(20)));
|
||||
assertEquals(arrayListOf(10, 30, 20, 40),
|
||||
merge(STRATEGY_ARRAY_LIST_APPEND, arrayListOf(10, 30), arrayListOf(20, 40)));
|
||||
assertEquals(arrayListOf("a", "b"),
|
||||
merge(STRATEGY_ARRAY_LIST_APPEND, arrayListOf("a"), arrayListOf("b")));
|
||||
|
||||
assertThrows(Exception.class, () -> {
|
||||
merge(STRATEGY_ARRAY_LIST_APPEND, 10, 20);
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMerge_Simple() throws Exception {
|
||||
final BundleMerger merger = new BundleMerger();
|
||||
final Bundle probe = new Bundle();
|
||||
probe.putInt(Intent.EXTRA_INDEX, 42);
|
||||
|
||||
assertEquals(null, merger.merge(null, null));
|
||||
assertEquals(probe.keySet(), merger.merge(probe, null).keySet());
|
||||
assertEquals(probe.keySet(), merger.merge(null, probe).keySet());
|
||||
assertEquals(probe.keySet(), merger.merge(probe, probe).keySet());
|
||||
}
|
||||
|
||||
/**
|
||||
* Verify that we can merge parcelables present in the base classpath, since
|
||||
* everyone on the device will be able to unpack them.
|
||||
*/
|
||||
@Test
|
||||
public void testMerge_Parcelable_BCP() throws Exception {
|
||||
final BundleMerger merger = new BundleMerger();
|
||||
merger.setMergeStrategy(Intent.EXTRA_STREAM, STRATEGY_COMPARABLE_MIN);
|
||||
|
||||
Bundle a = new Bundle();
|
||||
a.putParcelable(Intent.EXTRA_STREAM, Uri.parse("http://example.com"));
|
||||
a = parcelAndUnparcel(a);
|
||||
|
||||
Bundle b = new Bundle();
|
||||
b.putParcelable(Intent.EXTRA_STREAM, Uri.parse("http://example.net"));
|
||||
b = parcelAndUnparcel(b);
|
||||
|
||||
assertEquals(Uri.parse("http://example.com"),
|
||||
merger.merge(a, b).getParcelable(Intent.EXTRA_STREAM, Uri.class));
|
||||
assertEquals(Uri.parse("http://example.com"),
|
||||
merger.merge(b, a).getParcelable(Intent.EXTRA_STREAM, Uri.class));
|
||||
}
|
||||
|
||||
/**
|
||||
* Verify that we tiptoe around custom parcelables while still merging other
|
||||
* known data types. Custom parcelables aren't in the base classpath, so not
|
||||
* everyone on the device will be able to unpack them.
|
||||
*/
|
||||
@Test
|
||||
public void testMerge_Parcelable_Custom() throws Exception {
|
||||
final BundleMerger merger = new BundleMerger();
|
||||
merger.setMergeStrategy(Intent.EXTRA_INDEX, STRATEGY_NUMBER_ADD);
|
||||
|
||||
Bundle a = new Bundle();
|
||||
a.putInt(Intent.EXTRA_INDEX, 10);
|
||||
a.putString(Intent.EXTRA_CC, "foo@bar.com");
|
||||
a.putParcelable(Intent.EXTRA_SUBJECT, new ExplodingParcelable());
|
||||
a = parcelAndUnparcel(a);
|
||||
|
||||
Bundle b = new Bundle();
|
||||
b.putInt(Intent.EXTRA_INDEX, 20);
|
||||
a.putString(Intent.EXTRA_BCC, "foo@baz.com");
|
||||
b.putParcelable(Intent.EXTRA_STREAM, new ExplodingParcelable());
|
||||
b = parcelAndUnparcel(b);
|
||||
|
||||
Bundle ab = merger.merge(a, b);
|
||||
assertEquals(Set.of(Intent.EXTRA_INDEX, Intent.EXTRA_CC, Intent.EXTRA_BCC,
|
||||
Intent.EXTRA_SUBJECT, Intent.EXTRA_STREAM), ab.keySet());
|
||||
assertEquals(30, ab.getInt(Intent.EXTRA_INDEX));
|
||||
assertEquals("foo@bar.com", ab.getString(Intent.EXTRA_CC));
|
||||
assertEquals("foo@baz.com", ab.getString(Intent.EXTRA_BCC));
|
||||
|
||||
// And finally, make sure that if we try unpacking one of our custom
|
||||
// values that we actually explode
|
||||
assertThrows(BadParcelableException.class, () -> {
|
||||
ab.getParcelable(Intent.EXTRA_SUBJECT, ExplodingParcelable.class);
|
||||
});
|
||||
assertThrows(BadParcelableException.class, () -> {
|
||||
ab.getParcelable(Intent.EXTRA_STREAM, ExplodingParcelable.class);
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMerge_PackageChanged() throws Exception {
|
||||
final BundleMerger merger = new BundleMerger();
|
||||
merger.setMergeStrategy(Intent.EXTRA_CHANGED_COMPONENT_NAME_LIST, STRATEGY_ARRAY_APPEND);
|
||||
|
||||
final Bundle first = new Bundle();
|
||||
first.putInt(Intent.EXTRA_UID, 10001);
|
||||
first.putStringArray(Intent.EXTRA_CHANGED_COMPONENT_NAME_LIST, new String[] {
|
||||
"com.example.Foo",
|
||||
});
|
||||
|
||||
final Bundle second = new Bundle();
|
||||
second.putInt(Intent.EXTRA_UID, 10001);
|
||||
second.putStringArray(Intent.EXTRA_CHANGED_COMPONENT_NAME_LIST, new String[] {
|
||||
"com.example.Bar",
|
||||
"com.example.Baz",
|
||||
});
|
||||
|
||||
final Bundle res = merger.merge(first, second);
|
||||
assertEquals(10001, res.getInt(Intent.EXTRA_UID));
|
||||
assertArrayEquals(new String[] {
|
||||
"com.example.Foo", "com.example.Bar", "com.example.Baz",
|
||||
}, res.getStringArray(Intent.EXTRA_CHANGED_COMPONENT_NAME_LIST));
|
||||
}
|
||||
|
||||
/**
|
||||
* Each event in isolation reports "zero events dropped", but if we need to
|
||||
* merge them together, then we start incrementing.
|
||||
*/
|
||||
@Test
|
||||
public void testMerge_DropBox() throws Exception {
|
||||
final BundleMerger merger = new BundleMerger();
|
||||
merger.setMergeStrategy(DropBoxManager.EXTRA_TIME,
|
||||
STRATEGY_COMPARABLE_MAX);
|
||||
merger.setMergeStrategy(DropBoxManager.EXTRA_DROPPED_COUNT,
|
||||
STRATEGY_NUMBER_INCREMENT_FIRST);
|
||||
|
||||
final long now = System.currentTimeMillis();
|
||||
final Bundle a = new Bundle();
|
||||
a.putString(DropBoxManager.EXTRA_TAG, "system_server_strictmode");
|
||||
a.putLong(DropBoxManager.EXTRA_TIME, now);
|
||||
a.putInt(DropBoxManager.EXTRA_DROPPED_COUNT, 0);
|
||||
|
||||
final Bundle b = new Bundle();
|
||||
b.putString(DropBoxManager.EXTRA_TAG, "system_server_strictmode");
|
||||
b.putLong(DropBoxManager.EXTRA_TIME, now + 1000);
|
||||
b.putInt(DropBoxManager.EXTRA_DROPPED_COUNT, 0);
|
||||
|
||||
final Bundle c = new Bundle();
|
||||
c.putString(DropBoxManager.EXTRA_TAG, "system_server_strictmode");
|
||||
c.putLong(DropBoxManager.EXTRA_TIME, now + 2000);
|
||||
c.putInt(DropBoxManager.EXTRA_DROPPED_COUNT, 0);
|
||||
|
||||
final Bundle ab = merger.merge(a, b);
|
||||
assertEquals("system_server_strictmode", ab.getString(DropBoxManager.EXTRA_TAG));
|
||||
assertEquals(now + 1000, ab.getLong(DropBoxManager.EXTRA_TIME));
|
||||
assertEquals(1, ab.getInt(DropBoxManager.EXTRA_DROPPED_COUNT));
|
||||
|
||||
final Bundle abc = merger.merge(ab, c);
|
||||
assertEquals("system_server_strictmode", abc.getString(DropBoxManager.EXTRA_TAG));
|
||||
assertEquals(now + 2000, abc.getLong(DropBoxManager.EXTRA_TIME));
|
||||
assertEquals(2, abc.getInt(DropBoxManager.EXTRA_DROPPED_COUNT));
|
||||
}
|
||||
|
||||
private static ArrayList<Object> arrayListOf(Object... values) {
|
||||
final ArrayList<Object> res = new ArrayList<>(values.length);
|
||||
for (Object value : values) {
|
||||
res.add(value);
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
private static Bundle parcelAndUnparcel(Bundle input) {
|
||||
final Parcel parcel = Parcel.obtain();
|
||||
try {
|
||||
input.writeToParcel(parcel, 0);
|
||||
parcel.setDataPosition(0);
|
||||
return Bundle.CREATOR.createFromParcel(parcel);
|
||||
} finally {
|
||||
parcel.recycle();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Object that only offers to parcel itself; if something tries unparceling
|
||||
* it, it will "explode" by throwing an exception.
|
||||
* <p>
|
||||
* Useful for verifying interactions that must leave unknown data in a
|
||||
* parceled state.
|
||||
*/
|
||||
public static class ExplodingParcelable implements Parcelable {
|
||||
public ExplodingParcelable() {
|
||||
}
|
||||
|
||||
@Override
|
||||
public int describeContents() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeToParcel(Parcel out, int flags) {
|
||||
out.writeInt(42);
|
||||
}
|
||||
|
||||
public static final Creator<ExplodingParcelable> CREATOR =
|
||||
new Creator<ExplodingParcelable>() {
|
||||
@Override
|
||||
public ExplodingParcelable createFromParcel(Parcel in) {
|
||||
throw new BadParcelableException("exploding!");
|
||||
}
|
||||
|
||||
@Override
|
||||
public ExplodingParcelable[] newArray(int size) {
|
||||
throw new BadParcelableException("exploding!");
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user