Set<Feature<?>> computeMultimapGetFeatures(Set<Feature<?>> multimapFeatures) {
Set<Feature<?>> derivedFeatures = Helpers.copyToSet(multimapFeatures);
for (Map.Entry<Feature<?>,Feature<?>> entry : GET_FEATURE_MAP.entries()) {
if (derivedFeatures.contains(entry.getKey())) {
derivedFeatures.add(entry.getValue());
}
}
if (derivedFeatures.remove(MultimapFeature.VALUE_COLLECTIONS_SUPPORT_IteraTOR_REMOVE)) {
derivedFeatures.add(CollectionFeature.SUPPORTS_IteraTOR_REMOVE);
}
if (!derivedFeatures.contains(CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS)) {
derivedFeatures.remove(CollectionFeature.SERIALIZABLE);
}
derivedFeatures.removeAll(GET_FEATURE_MAP.keySet());
return derivedFeatures;
}
项目:guava-mock
文件:MultimapRemoveEntryTester.java
@MapFeature.Require(SUPPORTS_REMOVE)
@CollectionSize.Require(absent = ZERO)
public void testRemovePropagatesToAsMap() {
List<Entry<K,V>> entries = Helpers.copyToList(multimap().entries());
for (Entry<K,V> entry : entries) {
resetContainer();
K key = entry.getKey();
V value = entry.getValue();
Collection<V> collection = multimap().asMap().get(key);
assertNotNull(collection);
Collection<V> expectedCollection = Helpers.copyToList(collection);
multimap().remove(key,value);
expectedCollection.remove(value);
assertEqualIgnoringOrder(expectedCollection,collection);
assertEquals(!expectedCollection.isEmpty(),multimap().containsKey(key));
}
}
public void testArbitrary_withCollisions() {
List<Integer> list = Lists.newArrayList();
for (int i = 0; i < 50; i++) {
list.add(i);
}
Ordering<Object> arbitrary = new ArbitraryOrdering() {
@Override int identityHashCode(Object object) {
return ((Integer) object) % 5; // fake tons of collisions!
}
};
// Don't let the elements be in such a predictable order
list = shuffledcopy(list,new Random(1));
Collections.sort(list,arbitrary);
// Now we don't care what order it's put the list in,only that
// comparing any pair of elements gives the answer we expect.
Helpers.testComparator(arbitrary,list);
}
@MapFeature.Require(SUPPORTS_PUT)
@CollectionSize.Require(absent = ZERO)
public void testPutPresentKeyPropagatesToAsMapGet() {
List<K> keys = Helpers.copyToList(multimap().keySet());
for (K key : keys) {
resetContainer();
int size = getNumElements();
Collection<V> collection = multimap().asMap().get(key);
assertNotNull(collection);
Collection<V> expectedCollection = Helpers.copyToList(collection);
multimap().put(key,v3());
expectedCollection.add(v3());
assertEqualIgnoringOrder(expectedCollection,collection);
assertEquals(size + 1,multimap().size());
}
}
@CollectionSize.Require(SEVERAL)
public void testOrderingDoesntAffectEqualsComparisons() {
SetMultimap<K,V> multimap1 =
getSubjectGenerator()
.create(
Helpers.mapEntry(k0(),v0()),Helpers.mapEntry(k0(),v1()),v4()));
SetMultimap<K,V> multimap2 =
getSubjectGenerator()
.create(
Helpers.mapEntry(k0(),v4()));
new EqualsTester().addEqualityGroup(multimap1,multimap2).testEquals();
}
项目:guava-mock
文件:OrderingTest.java
public void testArbitrary_withCollisions() {
List<Integer> list = Lists.newArrayList();
for (int i = 0; i < 50; i++) {
list.add(i);
}
Ordering<Object> arbitrary = new ArbitraryOrdering() {
@Override int identityHashCode(Object object) {
return ((Integer) object) % 5; // fake tons of collisions!
}
};
// Don't let the elements be in such a predictable order
list = shuffledcopy(list,list);
}
@SuppressWarnings("unchecked") // dang varargs
public void testLexicographical() {
Comparator<String> comparator = Ordering.natural();
Comparator<Iterable<String>> lexy = Comparators.lexicographical(comparator);
ImmutableList<String> empty = ImmutableList.of();
ImmutableList<String> a = ImmutableList.of("a");
ImmutableList<String> aa = ImmutableList.of("a","a");
ImmutableList<String> ab = ImmutableList.of("a","b");
ImmutableList<String> b = ImmutableList.of("b");
Helpers.testComparator(lexy,empty,a,aa,ab,b);
new EqualsTester()
.addEqualityGroup(lexy,Comparators.lexicographical(comparator))
.addEqualityGroup(Comparators.lexicographical(String.CASE_INSENSITIVE_ORDER))
.addEqualityGroup(Ordering.natural())
.testEquals();
}
项目:guava-mock
文件:AbstractImmutableSetTest.java
/**
* Verify thread safety by using a collection whose size() may be inconsistent
* with the actual number of elements. Tests using this method might fail in
* GWT because the GWT emulations might count on size() during copy. It is
* safe to do so in GWT because javascript is single-threaded.
*/
// Todo(benyu): turn this into a test once all copyOf(Collection) are
// thread-safe
@GwtIncompatible // GWT is single threaded
void verifyThreadSafe() {
List<String> sample = Lists.newArrayList("a","b","c");
for (int delta : new int[] {-1,1}) {
for (int i = 0; i < sample.size(); i++) {
Collection<String> misleading = Helpers.misleadingSizeCollection(delta);
List<String> expected = sample.subList(0,i);
misleading.addAll(expected);
assertEquals("delta: " + delta + " sample size: " + i,Sets.newHashSet(expected),copyOf(misleading));
}
}
}
@Override
public void setUp() throws Exception {
super.setUp();
navigableSet = (NavigableSet<E>) getSet();
values =
Helpers.copyToList(
getSubjectGenerator()
.getSampleElements(getSubjectGenerator().getCollectionSize().getNumElements()));
Collections.sort(values,navigableSet.comparator());
// some tests assume SEVERAL == 3
if (values.size() >= 1) {
a = values.get(0);
if (values.size() >= 3) {
b = values.get(1);
c = values.get(2);
}
}
}
@CollectionSize.Require(ONE)
@CollectionFeature.Require(SUPPORTS_IteraTOR_REMOVE)
public void testIteratorRemovePropagatesToMultimap() {
Iterator<Entry<K,V>> iterator = multimap().entries().iterator();
assertEquals(Helpers.mapEntry(k0(),iterator.next());
iterator.remove();
assertTrue(multimap().isEmpty());
}
public void testLexicographicalComparator() {
List<double[]> ordered = Arrays.asList(
new double[] {},new double[] {LEAST},new double[] {LEAST,LEAST},(double) 1},new double[] {(double) 1},new double[] {(double) 1,new double[] {GREATEST,Double.MAX_VALUE},GREATEST},GREATEST,GREATEST});
Comparator<double[]> comparator = Doubles.lexicographicalComparator();
Helpers.testComparator(comparator,ordered);
}
项目:guava-mock
文件:MultisetForEachEntryTester.java
public void testForEachEntry() {
List<Entry<E>> expected = new ArrayList<>(getMultiset().entrySet());
List<Entry<E>> actual = new ArrayList<>();
getMultiset()
.forEachEntry((element,count) -> actual.add(Multisets.immutableEntry(element,count)));
Helpers.assertEqualIgnoringOrder(expected,actual);
}
项目:guava-mock
文件:OrderingTest.java
public void testArbitrary_withoutCollisions() {
List<Object> list = Lists.newArrayList();
for (int i = 0; i < 50; i++) {
list.add(new Object());
}
Ordering<Object> arbitrary = Ordering.arbitrary();
Collections.sort(list,list);
assertEquals("Ordering.arbitrary()",arbitrary.toString());
}
@MapFeature.Require(SUPPORTS_PUT)
@CollectionSize.Require(absent = ZERO)
public void testPutPresentKeyPropagatesToAsMapEntrySet() {
List<K> keys = Helpers.copyToList(multimap().keySet());
for (K key : keys) {
resetContainer();
int size = getNumElements();
Iterator<Entry<K,Collection<V>>> asMapItr = multimap().asMap().entrySet().iterator();
Collection<V> collection = null;
while (asMapItr.hasNext()) {
Entry<K,Collection<V>> asMapEntry = asMapItr.next();
if (key.equals(asMapEntry.getKey())) {
collection = asMapEntry.getValue();
break;
}
}
assertNotNull(collection);
Collection<V> expectedCollection = Helpers.copyToList(collection);
multimap().put(key,multimap().size());
}
}
public void testLexicographicalComparator() {
List<long[]> ordered = Arrays.asList(
new long[] {},new long[] {MIN_VALUE},new long[] {MIN_VALUE,MIN_VALUE},(long) 1},new long[] {(long) 1},new long[] {(long) 1,new long[] {MAX_VALUE,MAX_VALUE - (long) 1},MAX_VALUE},MAX_VALUE,MAX_VALUE});
Comparator<long[]> comparator = Longs.lexicographicalComparator();
Helpers.testComparator(comparator,ordered);
}
public void testToArray_threadSafe() {
for (int delta : new int[] { +1,-1 }) {
for (int i = 0; i < VALUES.length; i++) {
List<Long> list = Longs.asList(VALUES).subList(0,i);
Collection<Long> misleadingSize =
Helpers.misleadingSizeCollection(delta);
misleadingSize.addAll(list);
long[] arr = Longs.toArray(misleadingSize);
assertEquals(i,arr.length);
for (int j = 0; j < i; j++) {
assertEquals(VALUES[j],arr[j]);
}
}
}
}
项目:guava-mock
文件:ListMultimapTestSuiteBuilder.java
@Override
protected List<Class<? extends AbstractTester>> getTesters() {
List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
testers.add(ListMultimapAsMapTester.class);
testers.add(ListMultimapEqualsTester.class);
testers.add(ListMultimapPutTester.class);
testers.add(ListMultimapPutAllTester.class);
testers.add(ListMultimapRemoveTester.class);
testers.add(ListMultimapReplaceValuesTester.class);
return testers;
}
项目:guava-mock
文件:TestStringListMultimapGenerator.java
@Override
public SampleElements<Map.Entry<String,String>> samples() {
return new SampleElements<Map.Entry<String,String>>(
Helpers.mapEntry("one","January"),Helpers.mapEntry("two","February"),Helpers.mapEntry("three","march"),Helpers.mapEntry("four","April"),Helpers.mapEntry("five","May"));
}
@CollectionSize.Require(absent = ZERO)
@MapFeature.Require(SUPPORTS_PUT)
public void testPutPresentKeyPropagatesToEntries() {
Collection<Entry<K,V>> entries = multimap().entries();
assertFalse(entries.contains(Helpers.mapEntry(k0(),v3())));
multimap().put(k0(),v3());
assertContains(entries,v3()));
}
项目:guava-mock
文件:OrderingTest.java
public void testNullsLast() {
Ordering<Integer> ordering = Ordering.natural().nullsLast();
Helpers.testComparator(ordering,1,Integer.MAX_VALUE,null);
new EqualsTester()
.addEqualityGroup(ordering,Ordering.natural().nullsLast())
.addEqualityGroup(numberOrdering.nullsLast())
.addEqualityGroup(Ordering.natural())
.testEquals();
}
/**
* Returns {@link Method} instances for the tests that assume multisets support duplicates so that
* the test of {@code Multisets.forSet()} can suppress them.
*/
@GwtIncompatible // reflection
public static List<Method> getIteratorDuplicateInitializingMethods() {
return Arrays.asList(
Helpers.getmethod(MultisetIteratorTester.class,"testIteratorKNownorder"),Helpers.getmethod(MultisetIteratorTester.class,"testIteratorUnkNownorder"),"testRemovingIteratorKNownorder"),"testRemovingIteratorUnkNownorder"));
}
项目:guava-mock
文件:MultisetRemoveTester.java
public void testImmutableEnumMapOrdering() {
ImmutableMap<AnEnum,String> map = Maps.immutableEnumMap(
ImmutableMap.of(AnEnum.C,"c",AnEnum.A,"a",AnEnum.E,"e"));
assertthat(map.entrySet()).containsExactly(
Helpers.mapEntry(AnEnum.A,"a"),Helpers.mapEntry(AnEnum.C,"c"),Helpers.mapEntry(AnEnum.E,"e")).inorder();
}
项目:guava-mock
文件:MultimapRemoveEntryTester.java
@CollectionSize.Require(absent = ZERO)
@MapFeature.Require({SUPPORTS_REMOVE,ALLOWS_NULL_KEYS})
public void testRemoveNullKeyPresent() {
initMultimapWithNullKey();
assertTrue(multimap().remove(null,getValueForNullKey()));
expectMissing(Helpers.mapEntry((K) null,getValueForNullKey()));
assertGet(getKeyForNullValue(),ImmutableList.<V>of());
}
项目:guava-mock
文件:MultimapRemoveEntryTester.java
@CollectionSize.Require(absent = ZERO)
@MapFeature.Require({SUPPORTS_REMOVE,ALLOWS_NULL_VALUES})
public void testRemoveNullValuePresent() {
initMultimapWithNullValue();
assertTrue(multimap().remove(getKeyForNullValue(),null));
expectMissing(Helpers.mapEntry(getKeyForNullValue(),(V) null));
assertGet(getKeyForNullValue(),ImmutableList.<V>of());
}
项目:guava-mock
文件:MultimapKeysTester.java
@CollectionSize.Require(SEVERAL)
public void testKeys() {
resetContainer(
Helpers.mapEntry(k0(),Helpers.mapEntry(k1(),v0()));
Multiset<K> keys = multimap().keys();
assertEquals(2,keys.count(k0()));
assertEquals(1,keys.count(k1()));
assertEquals(3,keys.size());
assertContainsAllOf(keys,k0(),k1());
assertContainsAllOf(
keys.entrySet(),Multisets.immutableEntry(k0(),2),Multisets.immutableEntry(k1(),1));
}
项目:guava-mock
文件:EnumBiMapTest.java
@Override
public SampleElements<Entry<Country,Currency>> samples() {
return new SampleElements<Entry<Country,Currency>>(
Helpers.mapEntry(Country.CANADA,Currency.DOLLAR),Helpers.mapEntry(Country.CHILE,Currency.PESO),Helpers.mapEntry(Country.UK,Currency.POUND),Helpers.mapEntry(Country.JAPAN,Currency.YEN),Helpers.mapEntry(Country.SWITZERLAND,Currency.FRANC));
}
@Override
protected List<Class<? extends AbstractTester>> getTesters() {
List<Class<? extends AbstractTester>> testers = Helpers.copyToList(super.getTesters());
testers.add(ListMultimapAsMapTester.class);
testers.add(ListMultimapEqualsTester.class);
testers.add(ListMultimapPutTester.class);
testers.add(ListMultimapPutAllTester.class);
testers.add(ListMultimapRemoveTester.class);
testers.add(ListMultimapReplaceValuesTester.class);
return testers;
}
项目:guava-mock
文件:ListMultimapAsMapTester.java
@CollectionSize.Require(SEVERAL)
@MapFeature.Require(SUPPORTS_REMOVE)
public void testValuesRemove() {
resetContainer(
Helpers.mapEntry(k0(),v3()));
assertTrue(multimap().asMap().values().remove(Collections.singletonList(v0())));
assertEquals(2,multimap().size());
assertEquals(
Collections.singletonMap(k0(),Lists.newArrayList(v0(),v3())),multimap().asMap());
}
@MapFeature.Require(ALLOWS_NULL_VALUES)
@CollectionSize.Require(absent = ZERO)
public void testForEach_nullValues() {
initMapWithNullValue();
List<Entry<K,V>> expectedEntries = Arrays.asList(createArrayWithNullValue());
List<Entry<K,V>> entries = new ArrayList<>();
getMap().forEach((k,v) -> entries.add(entry(k,v)));
Helpers.assertEqualIgnoringOrder(expectedEntries,entries);
}
public void testHeadMap() {
List<Entry<K,V>> entries =
Helpers.copyToList(
getSubjectGenerator()
.getSampleElements(getSubjectGenerator().getCollectionSize().getNumElements()));
Collections.sort(entries,Helpers.<K,V>entryComparator(navigableMap.comparator()));
for (int i = 0; i < entries.size(); i++) {
assertEqualInorder(
entries.subList(0,i),navigableMap.headMap(entries.get(i).getKey()).entrySet());
}
}
@ListFeature.Require(SUPPORTS_SET)
@CollectionSize.Require(absent = {ZERO,ONE})
public void testSubList_subListSetAffectsOriginalLargeList() {
List<E> subList = getList().subList(1,2);
subList.set(0,e3());
List<E> expected = Helpers.copyToList(createSamplesArray());
expected.set(1,e3());
expectContents(expected);
}
项目:guava-mock
文件:IntsTest.java
public void testLexicographicalComparator() {
List<int[]> ordered = Arrays.asList(
new int[] {},new int[] {LEAST},new int[] {LEAST,(int) 1},new int[] {(int) 1},new int[] {(int) 1,new int[] {GREATEST,GREATEST - (int) 1},GREATEST});
Comparator<int[]> comparator = Ints.lexicographicalComparator();
Helpers.testComparator(comparator,ordered);
}
项目:guava-mock
文件:BiMapPutTester.java
@SuppressWarnings("unchecked")
@MapFeature.Require(SUPPORTS_PUT)
@CollectionSize.Require(ZERO)
public void testForcePutOverwritesOldValueEntry() {
getMap().put(k0(),v0());
getMap().forcePut(k1(),v0());
// verify that the bimap is unchanged
expectAdded(Helpers.mapEntry(k1(),v0()));
}
项目:guava-mock
文件:ImmutableListTest.java
public void testcopyOf_concurrentlyMutating() {
List<String> sample = Lists.newArrayList("a",1}) {
for (int i = 0; i < sample.size(); i++) {
Collection<String> misleading =
Helpers.misleadingSizeCollection(delta);
List<String> expected = sample.subList(0,i);
misleading.addAll(expected);
assertEquals(expected,ImmutableList.copyOf(misleading));
assertEquals(expected,ImmutableList.copyOf((Iterable<String>) misleading));
}
}
}
项目:guava-mock
文件:MapEntrySetTester.java
@CollectionSize.Require(absent = ZERO)
@MapFeature.Require(SUPPORTS_REMOVE)
public void testRemovePropagatesToMultimap() {
assertTrue(multimap().entries().remove(Helpers.mapEntry(k0(),v0())));
expectMissing(Helpers.mapEntry(k0(),v0()));
assertEquals(getNumElements() - 1,multimap().size());
assertFalse(multimap().containsEntry(k0(),v0()));
}
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 [email protected] 举报,一经查实,本站将立刻删除。