diff options
Diffstat (limited to 'guava-tests/test/com/google/common/collect/MultimapCollectionTest.java')
| -rw-r--r-- | guava-tests/test/com/google/common/collect/MultimapCollectionTest.java | 978 |
1 files changed, 978 insertions, 0 deletions
diff --git a/guava-tests/test/com/google/common/collect/MultimapCollectionTest.java b/guava-tests/test/com/google/common/collect/MultimapCollectionTest.java new file mode 100644 index 0000000..886dfd1 --- /dev/null +++ b/guava-tests/test/com/google/common/collect/MultimapCollectionTest.java @@ -0,0 +1,978 @@ +/* + * Copyright (C) 2008 The Guava Authors + * + * 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.google.common.collect; + +import static com.google.common.collect.Maps.newHashMap; +import static com.google.common.collect.testing.features.CollectionFeature.ALLOWS_NULL_VALUES; +import static com.google.common.collect.testing.features.CollectionFeature.REMOVE_OPERATIONS; +import static com.google.common.collect.testing.google.AbstractMultisetSetCountTester.getSetCountDuplicateInitializingMethods; +import static com.google.common.collect.testing.google.MultisetIteratorTester.getIteratorDuplicateInitializingMethods; +import static com.google.common.collect.testing.google.MultisetReadsTester.getReadsDuplicateInitializingMethods; +import static java.lang.reflect.Proxy.newProxyInstance; + +import com.google.common.annotations.GwtIncompatible; +import com.google.common.base.Functions; +import com.google.common.base.Predicate; +import com.google.common.base.Supplier; +import com.google.common.collect.testing.CollectionTestSuiteBuilder; +import com.google.common.collect.testing.ListTestSuiteBuilder; +import com.google.common.collect.testing.SampleElements; +import com.google.common.collect.testing.SetTestSuiteBuilder; +import com.google.common.collect.testing.TestCollectionGenerator; +import com.google.common.collect.testing.TestListGenerator; +import com.google.common.collect.testing.TestStringCollectionGenerator; +import com.google.common.collect.testing.TestStringListGenerator; +import com.google.common.collect.testing.TestStringSetGenerator; +import com.google.common.collect.testing.TestStringSortedSetGenerator; +import com.google.common.collect.testing.features.CollectionFeature; +import com.google.common.collect.testing.features.CollectionSize; +import com.google.common.collect.testing.features.Feature; +import com.google.common.collect.testing.features.ListFeature; +import com.google.common.collect.testing.google.MultisetTestSuiteBuilder; +import com.google.common.collect.testing.google.MultisetWritesTester; +import com.google.common.collect.testing.google.TestStringMultisetGenerator; +import com.google.common.collect.testing.testers.CollectionIteratorTester; + +import junit.framework.Test; +import junit.framework.TestCase; +import junit.framework.TestSuite; + +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import java.util.SortedSet; +import java.util.TreeSet; + +/** + * Run collection tests on {@link Multimap} implementations. + * + * @author Jared Levy + */ +@GwtIncompatible("suite") // TODO(cpovirk): set up collect/gwt/suites version +public class MultimapCollectionTest extends TestCase { + + private static final Feature<?>[] COLLECTION_FEATURES = { + CollectionSize.ANY, + CollectionFeature.ALLOWS_NULL_VALUES, + CollectionFeature.GENERAL_PURPOSE + }; + + static final Feature<?>[] COLLECTION_FEATURES_ORDER = { + CollectionSize.ANY, + CollectionFeature.ALLOWS_NULL_VALUES, + CollectionFeature.KNOWN_ORDER, + CollectionFeature.GENERAL_PURPOSE + }; + static final Feature<?>[] COLLECTION_FEATURES_REMOVE = { + CollectionSize.ANY, + CollectionFeature.ALLOWS_NULL_VALUES, + CollectionFeature.REMOVE_OPERATIONS + }; + + static final Feature<?>[] COLLECTION_FEATURES_REMOVE_ORDER = { + CollectionSize.ANY, + CollectionFeature.ALLOWS_NULL_VALUES, + CollectionFeature.KNOWN_ORDER, + CollectionFeature.REMOVE_OPERATIONS + }; + + private static final Feature<?>[] LIST_FEATURES = { + CollectionSize.ANY, + CollectionFeature.ALLOWS_NULL_VALUES, + ListFeature.GENERAL_PURPOSE + }; + + private static final Feature<?>[] LIST_FEATURES_REMOVE_SET = { + CollectionSize.ANY, + CollectionFeature.ALLOWS_NULL_VALUES, + ListFeature.REMOVE_OPERATIONS, + ListFeature.SUPPORTS_SET + }; + + private static final Feature<?>[] FOR_MAP_FEATURES_ONE = { + CollectionSize.ONE, + ALLOWS_NULL_VALUES, + REMOVE_OPERATIONS, + }; + + private static final Feature<?>[] FOR_MAP_FEATURES_ANY = { + CollectionSize.ANY, + ALLOWS_NULL_VALUES, + REMOVE_OPERATIONS, + }; + + static final Supplier<TreeSet<String>> STRING_TREESET_FACTORY + = new Supplier<TreeSet<String>>() { + @Override + public TreeSet<String> get() { + return new TreeSet<String>(Ordering.natural().nullsLast()); + } + }; + + static void populateMultimapForGet( + Multimap<Integer, String> multimap, String[] elements) { + multimap.put(2, "foo"); + for (String element : elements) { + multimap.put(3, element); + } + } + + static void populateMultimapForKeySet( + Multimap<String, Integer> multimap, String[] elements) { + for (String element : elements) { + multimap.put(element, 2); + multimap.put(element, 3); + } + } + + static void populateMultimapForValues( + Multimap<Integer, String> multimap, String[] elements) { + for (int i = 0; i < elements.length; i++) { + multimap.put(i % 2, elements[i]); + } + } + + static void populateMultimapForKeys( + Multimap<String, Integer> multimap, String[] elements) { + for (int i = 0; i < elements.length; i++) { + multimap.put(elements[i], i); + } + } + + /** + * Implements {@code Multimap.put()} -- and no other methods -- for a {@code + * Map} by ignoring all but the latest value for each key. This class exists + * only so that we can use + * {@link MultimapCollectionTest#populateMultimapForGet(Multimap, String[])} + * and similar methods to populate a map to be passed to + * {@link Multimaps#forMap(Map)}. All tests should run against the result of + * {@link #build()}. + */ + private static final class PopulatableMapAsMultimap<K, V> + extends ForwardingMultimap<K, V> { + final Map<K, V> map; + final SetMultimap<K, V> unusableDelegate; + + static <K, V> PopulatableMapAsMultimap<K, V> create() { + return new PopulatableMapAsMultimap<K, V>(); + } + + @SuppressWarnings("unchecked") // all methods throw immediately + PopulatableMapAsMultimap() { + this.map = newHashMap(); + this.unusableDelegate = (SetMultimap<K, V>) newProxyInstance( + SetMultimap.class.getClassLoader(), + new Class<?>[] {SetMultimap.class}, + new InvocationHandler() { + @Override + public Object invoke(Object proxy, Method method, Object[] args) + throws Throwable { + throw new UnsupportedOperationException(); + } + }); + } + + @Override protected Multimap<K, V> delegate() { + return unusableDelegate; + } + + @Override public boolean put(K key, V value) { + map.put(key, value); + return true; + } + + SetMultimap<K, V> build() { + return Multimaps.forMap(map); + } + } + + static abstract class TestEntriesGenerator + implements TestCollectionGenerator<Entry<String, Integer>> { + @Override + public SampleElements<Entry<String, Integer>> samples() { + return new SampleElements<Entry<String, Integer>>( + Maps.immutableEntry("bar", 1), + Maps.immutableEntry("bar", 2), + Maps.immutableEntry("foo", 3), + Maps.immutableEntry("bar", 3), + Maps.immutableEntry("cat", 2)); + } + + @Override + public Collection<Entry<String, Integer>> create(Object... elements) { + Multimap<String, Integer> multimap = createMultimap(); + for (Object element : elements) { + @SuppressWarnings("unchecked") + Entry<String, Integer> entry = (Entry<String, Integer>) element; + multimap.put(entry.getKey(), entry.getValue()); + } + return multimap.entries(); + } + + abstract Multimap<String, Integer> createMultimap(); + + @Override + @SuppressWarnings("unchecked") + public Entry<String, Integer>[] createArray(int length) { + return (Entry<String, Integer>[]) new Entry<?, ?>[length]; + } + + @Override + public List<Entry<String, Integer>> order( + List<Entry<String, Integer>> insertionOrder) { + return insertionOrder; + } + } + + public static abstract class TestEntriesListGenerator + extends TestEntriesGenerator + implements TestListGenerator<Entry<String, Integer>> { + @Override public List<Entry<String, Integer>> create(Object... elements) { + return (List<Entry<String, Integer>>) super.create(elements); + } + } + + private static abstract class TestEntrySetGenerator + extends TestEntriesGenerator { + @Override abstract SetMultimap<String, Integer> createMultimap(); + + @Override public Set<Entry<String, Integer>> create(Object... elements) { + return (Set<Entry<String, Integer>>) super.create(elements); + } + } + + private static final Predicate<Map.Entry<Integer, String>> FILTER_GET_PREDICATE + = new Predicate<Map.Entry<Integer, String>>() { + @Override public boolean apply(Entry<Integer, String> entry) { + return !"badvalue".equals(entry.getValue()) && 55556 != entry.getKey(); + } + }; + + private static final Predicate<Map.Entry<String, Integer>> FILTER_KEYSET_PREDICATE + = new Predicate<Map.Entry<String, Integer>>() { + @Override public boolean apply(Entry<String, Integer> entry) { + return !"badkey".equals(entry.getKey()) && 55556 != entry.getValue(); + } + }; + + public static Test suite() { + TestSuite suite = new TestSuite(); + + suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { + @Override protected Set<String> create(String[] elements) { + SetMultimap<Integer, String> multimap = HashMultimap.create(); + populateMultimapForGet(multimap, elements); + return multimap.get(3); + } + }) + .named("HashMultimap.get") + .withFeatures(COLLECTION_FEATURES) + .createTestSuite()); + + suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { + @Override protected Set<String> create(String[] elements) { + SetMultimap<Integer, String> multimap + = LinkedHashMultimap.create(); + populateMultimapForGet(multimap, elements); + return multimap.get(3); + } + }) + .named("LinkedHashMultimap.get") + .withFeatures(COLLECTION_FEATURES_ORDER) + .createTestSuite()); + + suite.addTest(SetTestSuiteBuilder.using( + new TestStringSortedSetGenerator() { + @Override protected SortedSet<String> create(String[] elements) { + SortedSetMultimap<Integer, String> multimap = + TreeMultimap.create(Ordering.natural().nullsFirst(), + Ordering.natural().nullsLast()); + populateMultimapForGet(multimap, elements); + return multimap.get(3); + } + }) + .named("TreeMultimap.get") + .withFeatures(COLLECTION_FEATURES_ORDER) + .createTestSuite()); + + suite.addTest(ListTestSuiteBuilder.using(new TestStringListGenerator() { + @Override protected List<String> create(String[] elements) { + ListMultimap<Integer, String> multimap + = ArrayListMultimap.create(); + populateMultimapForGet(multimap, elements); + return multimap.get(3); + } + }) + .named("ArrayListMultimap.get") + .withFeatures(LIST_FEATURES) + .createTestSuite()); + + suite.addTest(ListTestSuiteBuilder.using(new TestStringListGenerator() { + @Override protected List<String> create(String[] elements) { + ListMultimap<Integer, String> multimap + = Multimaps.synchronizedListMultimap( + ArrayListMultimap.<Integer, String>create()); + populateMultimapForGet(multimap, elements); + return multimap.get(3); + } + }) + .named("synchronized ArrayListMultimap.get") + .withFeatures(LIST_FEATURES) + .createTestSuite()); + + suite.addTest(ListTestSuiteBuilder.using(new TestStringListGenerator() { + @Override protected List<String> create(String[] elements) { + ListMultimap<Integer, String> multimap + = LinkedListMultimap.create(); + populateMultimapForGet(multimap, elements); + return multimap.get(3); + } + }) + .named("LinkedListMultimap.get") + .withFeatures(LIST_FEATURES) + .createTestSuite()); + + suite.addTest(ListTestSuiteBuilder.using(new TestStringListGenerator() { + @Override protected List<String> create(String[] elements) { + ImmutableListMultimap.Builder<Integer, String> builder + = ImmutableListMultimap.builder(); + ListMultimap<Integer, String> multimap + = builder.put(2, "foo") + .putAll(3, elements) + .build(); + return multimap.get(3); + } + }) + .named("ImmutableListMultimap.get") + .withFeatures(CollectionSize.ANY) + .createTestSuite()); + + suite.addTest(SetTestSuiteBuilder.using( + new TestStringSetGenerator() { + @Override protected Set<String> create(String[] elements) { + PopulatableMapAsMultimap<Integer, String> multimap + = PopulatableMapAsMultimap.create(); + populateMultimapForGet(multimap, elements); + return multimap.build().get(3); + } + }) + .named("Multimaps.forMap.get") + .withFeatures(FOR_MAP_FEATURES_ONE) + .createTestSuite()); + + suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { + @Override protected Set<String> create(String[] elements) { + SetMultimap<Integer, String> multimap + = LinkedHashMultimap.create(); + populateMultimapForGet(multimap, elements); + multimap.put(3, "badvalue"); + multimap.put(55556, "foo"); + return (Set<String>) Multimaps.filterEntries(multimap, FILTER_GET_PREDICATE).get(3); + } + }) + .named("Multimaps.filterEntries.get") + .withFeatures(COLLECTION_FEATURES_ORDER) + .suppressing(CollectionIteratorTester.getIteratorKnownOrderRemoveSupportedMethod()) + .createTestSuite()); + + suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { + @Override protected Set<String> create(String[] elements) { + Multimap<String, Integer> multimap = HashMultimap.create(); + populateMultimapForKeySet(multimap, elements); + return multimap.keySet(); + } + }) + .named("HashMultimap.keySet") + .withFeatures(COLLECTION_FEATURES_REMOVE) + .createTestSuite()); + + suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { + @Override protected Set<String> create(String[] elements) { + Multimap<String, Integer> multimap + = LinkedHashMultimap.create(); + populateMultimapForKeySet(multimap, elements); + return multimap.keySet(); + } + }) + .named("LinkedHashMultimap.keySet") + .withFeatures(COLLECTION_FEATURES_REMOVE_ORDER) + .createTestSuite()); + + suite.addTest(SetTestSuiteBuilder.using( + new TestStringSortedSetGenerator() { + @Override protected SortedSet<String> create(String[] elements) { + TreeMultimap<String, Integer> multimap = + TreeMultimap.create(Ordering.natural().nullsFirst(), + Ordering.natural().nullsLast()); + populateMultimapForKeySet(multimap, elements); + return multimap.keySet(); + } + }) + .named("TreeMultimap.keySet") + .withFeatures(COLLECTION_FEATURES_REMOVE_ORDER) + .createTestSuite()); + + suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { + @Override protected Set<String> create(String[] elements) { + Multimap<String, Integer> multimap + = ArrayListMultimap.create(); + populateMultimapForKeySet(multimap, elements); + return multimap.keySet(); + } + }) + .named("ArrayListMultimap.keySet") + .withFeatures(COLLECTION_FEATURES_REMOVE) + .createTestSuite()); + + suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { + @Override protected Set<String> create(String[] elements) { + Multimap<String, Integer> multimap + = LinkedListMultimap.create(); + populateMultimapForKeySet(multimap, elements); + return multimap.keySet(); + } + }) + .named("LinkedListMultimap.keySet") + .withFeatures(COLLECTION_FEATURES_REMOVE_ORDER) + .createTestSuite()); + + suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { + @Override protected Set<String> create(String[] elements) { + ImmutableListMultimap.Builder<String, Integer> builder + = ImmutableListMultimap.builder(); + for (String element : elements) { + builder.put(element, 2); + builder.put(element, 3); + } + Multimap<String, Integer> multimap = builder.build(); + return multimap.keySet(); + } + }) + .named("ImmutableListMultimap.keySet") + .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER) + .createTestSuite()); + + suite.addTest(SetTestSuiteBuilder.using( + new TestStringSetGenerator() { + @Override protected Set<String> create(String[] elements) { + PopulatableMapAsMultimap<String, Integer> multimap + = PopulatableMapAsMultimap.create(); + populateMultimapForKeySet(multimap, elements); + return multimap.build().keySet(); + } + }) + .named("Multimaps.forMap.keySet") + .withFeatures(FOR_MAP_FEATURES_ANY) + .createTestSuite()); + + suite.addTest(SetTestSuiteBuilder.using( + new TestStringSetGenerator() { + @Override protected Set<String> create(String[] elements) { + SetMultimap<String, Integer> multimap = LinkedHashMultimap.create(); + populateMultimapForKeySet(multimap, elements); + multimap.put("badkey", 3); + multimap.put("a", 55556); + return Multimaps.filterEntries(multimap, FILTER_KEYSET_PREDICATE).keySet(); + } + }) + .named("Multimaps.filterEntries.keySet") + .withFeatures(COLLECTION_FEATURES_REMOVE_ORDER) + .suppressing(CollectionIteratorTester.getIteratorKnownOrderRemoveSupportedMethod()) + .createTestSuite()); + + suite.addTest(CollectionTestSuiteBuilder.using( + new TestStringCollectionGenerator() { + @Override public Collection<String> create(String[] elements) { + Multimap<Integer, String> multimap = HashMultimap.create(); + populateMultimapForValues(multimap, elements); + return multimap.values(); + } + }) + .named("HashMultimap.values") + .withFeatures(COLLECTION_FEATURES_REMOVE) + .createTestSuite()); + + suite.addTest(CollectionTestSuiteBuilder.using( + new TestStringCollectionGenerator() { + @Override public Collection<String> create(String[] elements) { + Multimap<Integer, String> multimap + = LinkedHashMultimap.create(); + populateMultimapForValues(multimap, elements); + return multimap.values(); + } + }) + .named("LinkedHashMultimap.values") + .withFeatures(COLLECTION_FEATURES_REMOVE_ORDER) + .createTestSuite()); + + suite.addTest(CollectionTestSuiteBuilder.using( + new TestStringCollectionGenerator() { + @Override public Collection<String> create(String[] elements) { + Multimap<Integer, String> multimap + = TreeMultimap.create(Ordering.natural().nullsFirst(), + Ordering.natural().nullsLast()); + populateMultimapForValues(multimap, elements); + return multimap.values(); + } + }) + .named("TreeMultimap.values") + .withFeatures(COLLECTION_FEATURES_REMOVE) + .createTestSuite()); + + suite.addTest(CollectionTestSuiteBuilder.using( + new TestStringCollectionGenerator() { + @Override public Collection<String> create(String[] elements) { + Multimap<Integer, String> multimap + = ArrayListMultimap.create(); + populateMultimapForValues(multimap, elements); + return multimap.values(); + } + }) + .named("ArrayListMultimap.values") + .withFeatures(COLLECTION_FEATURES_REMOVE) + .createTestSuite()); + + suite.addTest(ListTestSuiteBuilder.using( + new TestStringListGenerator() { + @Override public List<String> create(String[] elements) { + LinkedListMultimap<Integer, String> multimap + = LinkedListMultimap.create(); + populateMultimapForValues(multimap, elements); + return multimap.values(); + } + }) + .named("LinkedListMultimap.values") + .withFeatures(LIST_FEATURES_REMOVE_SET) + .createTestSuite()); + + suite.addTest(CollectionTestSuiteBuilder.using( + new TestStringCollectionGenerator() { + @Override public Collection<String> create(String[] elements) { + ImmutableListMultimap.Builder<Integer, String> builder + = ImmutableListMultimap.builder(); + for (int i = 0; i < elements.length; i++) { + builder.put(i % 2, elements[i]); + } + return builder.build().values(); + } + }) + .named("ImmutableListMultimap.values") + .withFeatures(CollectionSize.ANY) + .createTestSuite()); + + suite.addTest(CollectionTestSuiteBuilder.using( + new TestStringCollectionGenerator() { + @Override public Collection<String> create(String[] elements) { + Multimap<Integer, String> multimap + = LinkedHashMultimap.create(); + populateMultimapForValues(multimap, elements); + multimap.put(3, "badvalue"); + multimap.put(55556, "foo"); + return Multimaps.filterEntries(multimap, FILTER_GET_PREDICATE).values(); + } + }) + .named("Multimaps.filterEntries.values") + .withFeatures(COLLECTION_FEATURES_REMOVE_ORDER) + .suppressing(CollectionIteratorTester.getIteratorKnownOrderRemoveSupportedMethod()) + .createTestSuite()); + + // TODO: use collection testers on Multimaps.forMap.values + + suite.addTest(MultisetTestSuiteBuilder.using( + new TestStringMultisetGenerator() { + @Override protected Multiset<String> create(String[] elements) { + Multimap<String, Integer> multimap = HashMultimap.create(); + populateMultimapForKeys(multimap, elements); + return multimap.keys(); + } + }) + .named("HashMultimap.keys") + .withFeatures(COLLECTION_FEATURES_REMOVE) + .createTestSuite()); + + suite.addTest(MultisetTestSuiteBuilder.using( + new TestStringMultisetGenerator() { + @Override protected Multiset<String> create(String[] elements) { + Multimap<String, Integer> multimap + = LinkedHashMultimap.create(); + populateMultimapForKeys(multimap, elements); + return multimap.keys(); + } + }) + .named("LinkedHashMultimap.keys") + .withFeatures(COLLECTION_FEATURES_REMOVE_ORDER) + .createTestSuite()); + + suite.addTest(MultisetTestSuiteBuilder.using( + new TestStringMultisetGenerator() { + @Override protected Multiset<String> create(String[] elements) { + Multimap<String, Integer> multimap + = TreeMultimap.create(Ordering.natural().nullsFirst(), + Ordering.natural().nullsLast()); + populateMultimapForKeys(multimap, elements); + return multimap.keys(); + } + + @Override public List<String> order(List<String> insertionOrder) { + Collections.sort(insertionOrder, Ordering.natural().nullsFirst()); + return insertionOrder; + } + }) + .named("TreeMultimap.keys") + .withFeatures(COLLECTION_FEATURES_REMOVE_ORDER) + .createTestSuite()); + + suite.addTest(MultisetTestSuiteBuilder.using( + new TestStringMultisetGenerator() { + @Override protected Multiset<String> create(String[] elements) { + Multimap<String, Integer> multimap + = ArrayListMultimap.create(); + populateMultimapForKeys(multimap, elements); + return multimap.keys(); + } + }) + .named("ArrayListMultimap.keys") + .withFeatures(COLLECTION_FEATURES_REMOVE) + .createTestSuite()); + + suite.addTest(MultisetTestSuiteBuilder.using( + new TestStringMultisetGenerator() { + @Override protected Multiset<String> create(String[] elements) { + Multimap<String, Integer> multimap + = Multimaps.synchronizedListMultimap( + ArrayListMultimap.<String, Integer>create()); + populateMultimapForKeys(multimap, elements); + return multimap.keys(); + } + }) + .named("synchronized ArrayListMultimap.keys") + .withFeatures(COLLECTION_FEATURES_REMOVE) + .createTestSuite()); + + suite.addTest(MultisetTestSuiteBuilder.using( + new TestStringMultisetGenerator() { + @Override protected Multiset<String> create(String[] elements) { + Multimap<String, Integer> multimap + = LinkedListMultimap.create(); + populateMultimapForKeys(multimap, elements); + return multimap.keys(); + } + }) + .named("LinkedListMultimap.keys") + .withFeatures(COLLECTION_FEATURES_REMOVE_ORDER) + .createTestSuite()); + + suite.addTest(MultisetTestSuiteBuilder.using( + new TestStringMultisetGenerator() { + @Override protected Multiset<String> create(String[] elements) { + ImmutableListMultimap.Builder<String, Integer> builder + = ImmutableListMultimap.builder(); + for (int i = 0; i < elements.length; i++) { + builder.put(elements[i], i); + } + Multimap<String, Integer> multimap = builder.build(); + return multimap.keys(); + } + }) + .named("ImmutableListMultimap.keys") + .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER) + .createTestSuite()); + + suite.addTest(MultisetTestSuiteBuilder.using( + new TestStringMultisetGenerator() { + @Override protected Multiset<String> create(String[] elements) { + PopulatableMapAsMultimap<String, Integer> multimap + = PopulatableMapAsMultimap.create(); + populateMultimapForKeys(multimap, elements); + return multimap.build().keys(); + } + }) + .named("Multimaps.forMap.keys") + .withFeatures(FOR_MAP_FEATURES_ANY) + .suppressing(getReadsDuplicateInitializingMethods()) + .suppressing(getSetCountDuplicateInitializingMethods()) + .suppressing(getIteratorDuplicateInitializingMethods()) + .createTestSuite()); + + suite.addTest(MultisetTestSuiteBuilder.using( + new TestStringMultisetGenerator() { + @Override protected Multiset<String> create(String[] elements) { + SetMultimap<String, Integer> multimap = LinkedHashMultimap.create(); + populateMultimapForKeys(multimap, elements); + multimap.put("badkey", 3); + multimap.put("a", 55556); + return Multimaps.filterEntries(multimap, FILTER_KEYSET_PREDICATE).keys(); + } + }) + .named("Multimaps.filterEntries.keys") + .withFeatures(COLLECTION_FEATURES_REMOVE_ORDER) + .suppressing(CollectionIteratorTester.getIteratorKnownOrderRemoveSupportedMethod()) + .suppressing(MultisetWritesTester.getEntrySetIteratorMethod()) + .suppressing(getIteratorDuplicateInitializingMethods()) + .createTestSuite()); + + suite.addTest(CollectionTestSuiteBuilder.using( + new TestEntrySetGenerator() { + @Override SetMultimap<String, Integer> createMultimap() { + return HashMultimap.create(); + } + }) + .named("HashMultimap.entries") + .withFeatures(CollectionSize.ANY, CollectionFeature.REMOVE_OPERATIONS) + .createTestSuite()); + + suite.addTest(CollectionTestSuiteBuilder.using( + new TestEntrySetGenerator() { + @Override SetMultimap<String, Integer> createMultimap() { + return LinkedHashMultimap.create(); + } + }) + .named("LinkedHashMultimap.entries") + .withFeatures(CollectionSize.ANY, CollectionFeature.REMOVE_OPERATIONS, + CollectionFeature.KNOWN_ORDER) + .createTestSuite()); + + suite.addTest(CollectionTestSuiteBuilder.using( + new TestEntrySetGenerator() { + @Override SetMultimap<String, Integer> createMultimap() { + return TreeMultimap.create(Ordering.natural().nullsFirst(), + Ordering.natural().nullsLast()); + } + }) + .named("TreeMultimap.entries") + .withFeatures(CollectionSize.ANY, CollectionFeature.REMOVE_OPERATIONS, + CollectionFeature.KNOWN_ORDER) + .createTestSuite()); + + suite.addTest(CollectionTestSuiteBuilder.using( + new TestEntriesGenerator() { + @Override Multimap<String, Integer> createMultimap() { + return ArrayListMultimap.create(); + } + }) + .named("ArrayListMultimap.entries") + .withFeatures(CollectionSize.ANY, CollectionFeature.REMOVE_OPERATIONS) + .createTestSuite()); + + suite.addTest(CollectionTestSuiteBuilder.using( + new TestEntriesGenerator() { + @Override Multimap<String, Integer> createMultimap() { + return Multimaps.synchronizedListMultimap( + ArrayListMultimap.<String, Integer>create()); + } + }) + .named("synchronized ArrayListMultimap.entries") + .withFeatures(CollectionSize.ANY, CollectionFeature.REMOVE_OPERATIONS) + .createTestSuite()); + + suite.addTest(ListTestSuiteBuilder.using( + new TestEntriesListGenerator() { + @Override Multimap<String, Integer> createMultimap() { + return LinkedListMultimap.create(); + } + }) + .named("LinkedListMultimap.entries") + .withFeatures(CollectionSize.ANY, ListFeature.REMOVE_OPERATIONS, + CollectionFeature.KNOWN_ORDER) + .createTestSuite()); + + suite.addTest(CollectionTestSuiteBuilder.using( + new TestEntriesGenerator() { + @Override Multimap<String, Integer> createMultimap() { + return ImmutableListMultimap.of(); + } + + @Override public Collection<Entry<String, Integer>> create( + Object... elements) { + ImmutableListMultimap.Builder<String, Integer> builder + = ImmutableListMultimap.builder(); + for (Object element : elements) { + @SuppressWarnings("unchecked") + Entry<String, Integer> entry = (Entry<String, Integer>) element; + builder.put(entry.getKey(), entry.getValue()); + } + return builder.build().entries(); + } + }) + .named("ImmutableListMultimap.entries") + .withFeatures(CollectionSize.ANY, CollectionFeature.KNOWN_ORDER) + .createTestSuite()); + + suite.addTest(CollectionTestSuiteBuilder.using( + new TestEntriesGenerator() { + @Override Multimap<String, Integer> createMultimap() { + Multimap<String, Integer> multimap = LinkedHashMultimap.create(); + multimap.put("badkey", 3); + multimap.put("a", 55556); + return Multimaps.filterEntries(multimap, FILTER_KEYSET_PREDICATE); + } + }) + .named("Multimap.filterEntries.entries") + .withFeatures(CollectionSize.ANY, CollectionFeature.REMOVE_OPERATIONS, + CollectionFeature.KNOWN_ORDER) + .suppressing(CollectionIteratorTester.getIteratorKnownOrderRemoveSupportedMethod()) + .createTestSuite()); + + suite.addTest(ListTestSuiteBuilder.using(new TestStringListGenerator() { + @Override protected List<String> create(String[] elements) { + ListMultimap<Integer, String> multimap = ArrayListMultimap.create(); + populateMultimapForGet(multimap, elements); + return Multimaps.transformValues( + multimap, Functions.<String> identity()).get(3); + } + }).named("Multimaps.transformValues[ListMultimap].get").withFeatures( + CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_VALUES, + CollectionFeature.REMOVE_OPERATIONS, + ListFeature.SUPPORTS_REMOVE_WITH_INDEX).createTestSuite()); + + suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { + @Override protected Set<String> create(String[] elements) { + ListMultimap<String, Integer> multimap = ArrayListMultimap.create(); + populateMultimapForKeySet(multimap, elements); + return Multimaps.transformValues( + multimap, Functions.<Integer> identity()).keySet(); + } + }).named("Multimaps.transformValues[ListMultimap].keySet").withFeatures( + CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_VALUES, + CollectionFeature.REMOVE_OPERATIONS).createTestSuite()); + + suite.addTest(MultisetTestSuiteBuilder.using( + new TestStringMultisetGenerator() { + @Override protected Multiset<String> create(String[] elements) { + ListMultimap<String, Integer> multimap + = ArrayListMultimap.create(); + populateMultimapForKeys(multimap, elements); + return Multimaps.transformValues( + multimap, Functions.<Integer> identity()).keys(); + } + }) + .named("Multimaps.transform[ListMultimap].keys") + .withFeatures(COLLECTION_FEATURES_REMOVE) + .createTestSuite()); + + suite.addTest( + CollectionTestSuiteBuilder.using(new TestStringCollectionGenerator() { + @Override public Collection<String> create(String[] elements) { + ListMultimap<Integer, String> multimap = ArrayListMultimap.create(); + populateMultimapForValues(multimap, elements); + return Multimaps.transformValues( + multimap, Functions.<String> identity()).values(); + } + }).named("Multimaps.transformValues[ListMultimap].values").withFeatures( + COLLECTION_FEATURES_REMOVE).createTestSuite()); + + suite.addTest(CollectionTestSuiteBuilder.using(new TestEntriesGenerator() { + @Override public Collection<Entry<String, Integer>> create( + Object... elements) { + ListMultimap<String, Integer> multimap = ArrayListMultimap.create(); + for (Object element : elements) { + @SuppressWarnings("unchecked") + Entry<String, Integer> entry = (Entry<String, Integer>) element; + multimap.put(entry.getKey(), entry.getValue()); + } + return Multimaps.transformValues( + multimap, Functions.<Integer> identity()).entries(); + } + + @Override Multimap<String, Integer> createMultimap() { + return Multimaps.transformValues( + ArrayListMultimap.<String, Integer> create(), + Functions.<Integer> identity()); + } + }).named("Multimaps.transformValues[ListMultimap].entries") + .withFeatures(CollectionSize.ANY, CollectionFeature.REMOVE_OPERATIONS) + .createTestSuite()); + + suite.addTest( + CollectionTestSuiteBuilder.using(new TestStringCollectionGenerator() { + @Override protected Collection<String> create(String[] elements) { + Multimap<Integer, String> multimap = ArrayListMultimap.create(); + populateMultimapForGet(multimap, elements); + return Multimaps.transformValues( + multimap, Functions.<String> identity()).get(3); + } + }).named("Multimaps.transformValues[Multimap].get").withFeatures( + CollectionSize.ANY, CollectionFeature.ALLOWS_NULL_VALUES, + CollectionFeature.REMOVE_OPERATIONS).createTestSuite()); + + suite.addTest(SetTestSuiteBuilder.using(new TestStringSetGenerator() { + @Override protected Set<String> create(String[] elements) { + Multimap<String, Integer> multimap = ArrayListMultimap.create(); + populateMultimapForKeySet(multimap, elements); + return Multimaps.transformValues( + multimap, Functions.<Integer> identity()).keySet(); + } + }).named("Multimaps.transformValues[Multimap].keySet").withFeatures( + COLLECTION_FEATURES_REMOVE).createTestSuite()); + + suite.addTest(MultisetTestSuiteBuilder.using( + new TestStringMultisetGenerator() { + @Override protected Multiset<String> create(String[] elements) { + Multimap<String, Integer> multimap + = ArrayListMultimap.create(); + populateMultimapForKeys(multimap, elements); + return Multimaps.transformValues( + multimap, Functions.<Integer> identity()).keys(); + } + }) + .named("Multimaps.transformValues[Multimap].keys") + .withFeatures(COLLECTION_FEATURES_REMOVE) + .createTestSuite()); + + suite.addTest( + CollectionTestSuiteBuilder.using(new TestStringCollectionGenerator() { + @Override public Collection<String> create(String[] elements) { + Multimap<Integer, String> multimap = ArrayListMultimap.create(); + populateMultimapForValues(multimap, elements); + return Multimaps.transformValues( + multimap, Functions.<String> identity()).values(); + } + }).named("Multimaps.transformValues[Multimap].values").withFeatures( + COLLECTION_FEATURES_REMOVE).createTestSuite()); + + suite.addTest(CollectionTestSuiteBuilder.using(new TestEntriesGenerator() { + @Override public Collection<Entry<String, Integer>> create( + Object... elements) { + Multimap<String, Integer> multimap = ArrayListMultimap.create(); + for (Object element : elements) { + @SuppressWarnings("unchecked") + Entry<String, Integer> entry = (Entry<String, Integer>) element; + multimap.put(entry.getKey(), entry.getValue()); + } + return Multimaps.transformValues( + multimap, Functions.<Integer> identity()).entries(); + } + @Override Multimap<String, Integer> createMultimap() { + return Multimaps.transformValues( + (Multimap<String, Integer>) + ArrayListMultimap.<String, Integer> create(), + Functions.<Integer> identity()); + } + }).named("Multimaps.transformValues[Multimap].entries") + .withFeatures(CollectionSize.ANY, CollectionFeature.REMOVE_OPERATIONS) + .createTestSuite()); + + // TODO: use collection testers on Multimaps.forMap.entries + + return suite; + } +} |