| /* |
| * Copyright (C) 2012 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.base.Preconditions.checkArgument; |
| import static com.google.common.base.Preconditions.checkNotNull; |
| import static com.google.common.collect.testing.Helpers.mapEntry; |
| |
| import com.google.common.base.Charsets; |
| import com.google.common.base.Function; |
| import com.google.common.base.Predicate; |
| import com.google.common.collect.Maps.EntryTransformer; |
| import com.google.common.collect.testing.Helpers; |
| import com.google.common.collect.testing.MapTestSuiteBuilder; |
| import com.google.common.collect.testing.NavigableMapTestSuiteBuilder; |
| import com.google.common.collect.testing.SafeTreeMap; |
| import com.google.common.collect.testing.SampleElements; |
| import com.google.common.collect.testing.SortedMapTestSuiteBuilder; |
| import com.google.common.collect.testing.TestMapGenerator; |
| import com.google.common.collect.testing.TestStringMapGenerator; |
| import com.google.common.collect.testing.TestStringSortedMapGenerator; |
| import com.google.common.collect.testing.features.CollectionFeature; |
| import com.google.common.collect.testing.features.CollectionSize; |
| import com.google.common.collect.testing.features.MapFeature; |
| import com.google.common.collect.testing.google.BiMapTestSuiteBuilder; |
| import com.google.common.collect.testing.google.TestStringBiMapGenerator; |
| import com.google.common.io.BaseEncoding; |
| |
| import junit.framework.Test; |
| import junit.framework.TestCase; |
| import junit.framework.TestSuite; |
| |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Map.Entry; |
| import java.util.NavigableMap; |
| import java.util.NavigableSet; |
| import java.util.Set; |
| import java.util.SortedMap; |
| import java.util.SortedSet; |
| |
| import javax.annotation.Nullable; |
| |
| /** |
| * Test suites for wrappers in {@code Maps}. |
| * |
| * @author Louis Wasserman |
| */ |
| public class MapsCollectionTest extends TestCase { |
| public static Test suite() { |
| TestSuite suite = new TestSuite(); |
| |
| suite.addTest(NavigableMapTestSuiteBuilder |
| .using(new TestStringSortedMapGenerator() { |
| @Override |
| protected SortedMap<String, String> create(Entry<String, String>[] entries) { |
| SafeTreeMap<String, String> map = new SafeTreeMap<String, String>(); |
| putEntries(map, entries); |
| return Maps.unmodifiableNavigableMap(map); |
| } |
| }) |
| .named("unmodifiableNavigableMap[SafeTreeMap]") |
| .withFeatures(CollectionSize.ANY, |
| MapFeature.ALLOWS_NULL_VALUES, |
| CollectionFeature.SERIALIZABLE) |
| .createTestSuite()); |
| suite.addTest(BiMapTestSuiteBuilder |
| .using(new TestStringBiMapGenerator() { |
| @Override |
| protected BiMap<String, String> create(Entry<String, String>[] entries) { |
| BiMap<String, String> bimap = HashBiMap.create(entries.length); |
| for (Entry<String, String> entry : entries) { |
| checkArgument(!bimap.containsKey(entry.getKey())); |
| bimap.put(entry.getKey(), entry.getValue()); |
| } |
| return Maps.unmodifiableBiMap(bimap); |
| } |
| }) |
| .named("unmodifiableBiMap[HashBiMap]") |
| .withFeatures( |
| CollectionSize.ANY, |
| MapFeature.ALLOWS_NULL_VALUES, |
| MapFeature.ALLOWS_NULL_KEYS, |
| MapFeature.ALLOWS_ANY_NULL_QUERIES, |
| MapFeature.REJECTS_DUPLICATES_AT_CREATION, |
| CollectionFeature.SERIALIZABLE) |
| .createTestSuite()); |
| suite.addTest(MapTestSuiteBuilder |
| .using(new TestMapGenerator<String, Integer>() { |
| @Override |
| public SampleElements<Entry<String, Integer>> samples() { |
| return new SampleElements<Entry<String, Integer>>( |
| mapEntry("x", 1), |
| mapEntry("xxx", 3), |
| mapEntry("xx", 2), |
| mapEntry("xxxx", 4), |
| mapEntry("aaaaa", 5)); |
| } |
| |
| @Override |
| public Map<String, Integer> create(Object... elements) { |
| Set<String> set = Sets.newLinkedHashSet(); |
| for (Object e : elements) { |
| Entry<?, ?> entry = (Entry<?, ?>) e; |
| checkNotNull(entry.getValue()); |
| set.add((String) checkNotNull(entry.getKey())); |
| } |
| return Maps.asMap(set, new Function<String, Integer>() { |
| @Override |
| public Integer apply(String input) { |
| return input.length(); |
| } |
| }); |
| } |
| |
| @SuppressWarnings("unchecked") |
| @Override |
| public Entry<String, Integer>[] createArray(int length) { |
| return new Entry[length]; |
| } |
| |
| @Override |
| public Iterable<Entry<String, Integer>> order( |
| List<Entry<String, Integer>> insertionOrder) { |
| return insertionOrder; |
| } |
| |
| @Override |
| public String[] createKeyArray(int length) { |
| return new String[length]; |
| } |
| |
| @Override |
| public Integer[] createValueArray(int length) { |
| return new Integer[length]; |
| } |
| }) |
| .named("Maps.asMap[Set, Function]") |
| .withFeatures(CollectionSize.ANY, |
| MapFeature.SUPPORTS_REMOVE, |
| CollectionFeature.SUPPORTS_ITERATOR_REMOVE) |
| .createTestSuite()); |
| suite.addTest(SortedMapTestSuiteBuilder |
| .using(new TestMapGenerator<String, Integer>() { |
| @Override |
| public String[] createKeyArray(int length) { |
| return new String[length]; |
| } |
| |
| @Override |
| public Integer[] createValueArray(int length) { |
| return new Integer[length]; |
| } |
| |
| @Override |
| public SampleElements<Entry<String, Integer>> samples() { |
| return new SampleElements<Entry<String, Integer>>( |
| mapEntry("a", 1), |
| mapEntry("aa", 2), |
| mapEntry("aba", 3), |
| mapEntry("bbbb", 4), |
| mapEntry("ccccc", 5)); |
| } |
| |
| @Override |
| public SortedMap<String, Integer> create(Object... elements) { |
| SortedSet<String> set = new NonNavigableSortedSet(); |
| for (Object e : elements) { |
| Entry<?, ?> entry = (Entry<?, ?>) e; |
| checkNotNull(entry.getValue()); |
| set.add((String) checkNotNull(entry.getKey())); |
| } |
| return Maps.asMap(set, new Function<String, Integer>() { |
| @Override |
| public Integer apply(String input) { |
| return input.length(); |
| } |
| }); |
| } |
| |
| @SuppressWarnings("unchecked") |
| @Override |
| public Entry<String, Integer>[] createArray(int length) { |
| return new Entry[length]; |
| } |
| |
| @Override |
| public Iterable<Entry<String, Integer>> order( |
| List<Entry<String, Integer>> insertionOrder) { |
| Collections.sort(insertionOrder, new Comparator<Entry<String, Integer>>() { |
| @Override |
| public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) { |
| return o1.getKey().compareTo(o2.getKey()); |
| } |
| }); |
| return insertionOrder; |
| } |
| }) |
| .named("Maps.asMap[SortedSet, Function]") |
| .withFeatures(CollectionSize.ANY, |
| CollectionFeature.SUPPORTS_ITERATOR_REMOVE, |
| MapFeature.SUPPORTS_REMOVE) |
| .createTestSuite()); |
| suite.addTest(NavigableMapTestSuiteBuilder |
| .using(new TestMapGenerator<String, Integer>() { |
| @Override |
| public String[] createKeyArray(int length) { |
| return new String[length]; |
| } |
| |
| @Override |
| public Integer[] createValueArray(int length) { |
| return new Integer[length]; |
| } |
| |
| @Override |
| public SampleElements<Entry<String, Integer>> samples() { |
| return new SampleElements<Entry<String, Integer>>( |
| mapEntry("a", 1), |
| mapEntry("aa", 2), |
| mapEntry("aba", 3), |
| mapEntry("bbbb", 4), |
| mapEntry("ccccc", 5)); |
| } |
| |
| @Override |
| public NavigableMap<String, Integer> create(Object... elements) { |
| NavigableSet<String> set = Sets.newTreeSet(Ordering.natural()); |
| for (Object e : elements) { |
| Map.Entry<?, ?> entry = (Entry<?, ?>) e; |
| checkNotNull(entry.getValue()); |
| set.add((String) checkNotNull(entry.getKey())); |
| } |
| return Maps.asMap(set, new Function<String, Integer>() { |
| @Override |
| public Integer apply(String input) { |
| return input.length(); |
| } |
| }); |
| } |
| |
| @SuppressWarnings("unchecked") |
| @Override |
| public Entry<String, Integer>[] createArray(int length) { |
| return new Entry[length]; |
| } |
| |
| @Override |
| public Iterable<Entry<String, Integer>> order( |
| List<Entry<String, Integer>> insertionOrder) { |
| Collections.sort(insertionOrder, new Comparator<Entry<String, Integer>>() { |
| @Override |
| public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) { |
| return o1.getKey().compareTo(o2.getKey()); |
| } |
| }); |
| return insertionOrder; |
| } |
| }) |
| .named("Maps.asMap[NavigableSet, Function]") |
| .withFeatures(CollectionSize.ANY, |
| MapFeature.SUPPORTS_REMOVE, |
| CollectionFeature.SUPPORTS_ITERATOR_REMOVE) |
| .createTestSuite()); |
| suite.addTest(filterSuite()); |
| suite.addTest(transformSuite()); |
| return suite; |
| } |
| |
| static TestSuite filterSuite() { |
| TestSuite suite = new TestSuite("Filter"); |
| suite.addTest(filterMapSuite()); |
| suite.addTest(filterBiMapSuite()); |
| suite.addTest(filterSortedMapSuite()); |
| suite.addTest(filterNavigableMapSuite()); |
| return suite; |
| } |
| |
| static TestSuite filterMapSuite() { |
| TestSuite suite = new TestSuite("FilterMap"); |
| suite.addTest(MapTestSuiteBuilder.using(new TestStringMapGenerator() { |
| @Override |
| protected Map<String, String> create(Entry<String, String>[] entries) { |
| Map<String, String> map = Maps.newHashMap(); |
| putEntries(map, entries); |
| map.putAll(ENTRIES_TO_FILTER); |
| return Maps.filterKeys(map, FILTER_KEYS); |
| } |
| }) |
| .named("Maps.filterKeys[Map, Predicate]") |
| .withFeatures( |
| MapFeature.ALLOWS_NULL_KEYS, |
| MapFeature.ALLOWS_NULL_VALUES, |
| MapFeature.ALLOWS_ANY_NULL_QUERIES, |
| MapFeature.GENERAL_PURPOSE, |
| CollectionSize.ANY) |
| .createTestSuite()); |
| suite.addTest(MapTestSuiteBuilder.using(new TestStringMapGenerator() { |
| @Override |
| protected Map<String, String> create(Entry<String, String>[] entries) { |
| Map<String, String> map = Maps.newHashMap(); |
| putEntries(map, entries); |
| map.putAll(ENTRIES_TO_FILTER); |
| return Maps.filterValues(map, FILTER_VALUES); |
| } |
| }) |
| .named("Maps.filterValues[Map, Predicate]") |
| .withFeatures( |
| MapFeature.ALLOWS_NULL_KEYS, |
| MapFeature.ALLOWS_NULL_VALUES, |
| MapFeature.ALLOWS_ANY_NULL_QUERIES, |
| MapFeature.GENERAL_PURPOSE, |
| CollectionSize.ANY) |
| .createTestSuite()); |
| suite.addTest(MapTestSuiteBuilder.using(new TestStringMapGenerator() { |
| @Override |
| protected Map<String, String> create(Entry<String, String>[] entries) { |
| Map<String, String> map = Maps.newHashMap(); |
| putEntries(map, entries); |
| map.putAll(ENTRIES_TO_FILTER); |
| return Maps.filterEntries(map, FILTER_ENTRIES); |
| } |
| }) |
| .named("Maps.filterEntries[Map, Predicate]") |
| .withFeatures( |
| MapFeature.ALLOWS_NULL_KEYS, |
| MapFeature.ALLOWS_NULL_VALUES, |
| MapFeature.ALLOWS_ANY_NULL_QUERIES, |
| MapFeature.GENERAL_PURPOSE, |
| CollectionSize.ANY) |
| .createTestSuite()); |
| suite.addTest(MapTestSuiteBuilder.using(new TestStringMapGenerator() { |
| @Override |
| protected Map<String, String> create(Entry<String, String>[] entries) { |
| Map<String, String> map = Maps.newHashMap(); |
| putEntries(map, entries); |
| map.putAll(ENTRIES_TO_FILTER); |
| map = Maps.filterEntries(map, FILTER_ENTRIES_1); |
| return Maps.filterEntries(map, FILTER_ENTRIES_2); |
| } |
| }) |
| .named("Maps.filterEntries[Maps.filterEntries[Map, Predicate], Predicate]") |
| .withFeatures( |
| MapFeature.ALLOWS_NULL_KEYS, |
| MapFeature.ALLOWS_NULL_VALUES, |
| MapFeature.ALLOWS_ANY_NULL_QUERIES, |
| MapFeature.GENERAL_PURPOSE, |
| CollectionSize.ANY) |
| .createTestSuite()); |
| return suite; |
| } |
| |
| static TestSuite filterBiMapSuite() { |
| TestSuite suite = new TestSuite("FilterBiMap"); |
| suite.addTest(BiMapTestSuiteBuilder.using(new TestStringBiMapGenerator() { |
| @Override |
| protected BiMap<String, String> create(Entry<String, String>[] entries) { |
| BiMap<String, String> map = HashBiMap.create(); |
| putEntries(map, entries); |
| map.putAll(ENTRIES_TO_FILTER); |
| return Maps.filterKeys(map, FILTER_KEYS); |
| } |
| }) |
| .named("Maps.filterKeys[BiMap, Predicate]") |
| .withFeatures( |
| MapFeature.ALLOWS_NULL_KEYS, |
| MapFeature.ALLOWS_NULL_VALUES, |
| MapFeature.GENERAL_PURPOSE, |
| CollectionSize.ANY) |
| .createTestSuite()); |
| suite.addTest(BiMapTestSuiteBuilder.using(new TestStringBiMapGenerator() { |
| @Override |
| protected BiMap<String, String> create(Entry<String, String>[] entries) { |
| BiMap<String, String> map = HashBiMap.create(); |
| putEntries(map, entries); |
| map.putAll(ENTRIES_TO_FILTER); |
| return Maps.filterValues(map, FILTER_VALUES); |
| } |
| }) |
| .named("Maps.filterValues[BiMap, Predicate]") |
| .withFeatures( |
| MapFeature.ALLOWS_NULL_KEYS, |
| MapFeature.ALLOWS_NULL_VALUES, |
| MapFeature.ALLOWS_ANY_NULL_QUERIES, |
| MapFeature.GENERAL_PURPOSE, |
| CollectionSize.ANY) |
| .createTestSuite()); |
| suite.addTest(BiMapTestSuiteBuilder.using(new TestStringBiMapGenerator() { |
| @Override |
| protected BiMap<String, String> create(Entry<String, String>[] entries) { |
| BiMap<String, String> map = HashBiMap.create(); |
| putEntries(map, entries); |
| map.putAll(ENTRIES_TO_FILTER); |
| return Maps.filterEntries(map, FILTER_ENTRIES); |
| } |
| }) |
| .named("Maps.filterEntries[BiMap, Predicate]") |
| .withFeatures( |
| MapFeature.ALLOWS_NULL_KEYS, |
| MapFeature.ALLOWS_NULL_VALUES, |
| MapFeature.ALLOWS_ANY_NULL_QUERIES, |
| MapFeature.GENERAL_PURPOSE, |
| CollectionSize.ANY) |
| .createTestSuite()); |
| return suite; |
| } |
| |
| static TestSuite filterSortedMapSuite() { |
| TestSuite suite = new TestSuite("FilterSortedMap"); |
| suite.addTest(SortedMapTestSuiteBuilder.using(new TestStringSortedMapGenerator() { |
| @Override |
| protected SortedMap<String, String> create(Entry<String, String>[] entries) { |
| SortedMap<String, String> map = new NonNavigableSortedMap(); |
| putEntries(map, entries); |
| map.putAll(ENTRIES_TO_FILTER); |
| return Maps.filterKeys(map, FILTER_KEYS); |
| } |
| }) |
| .named("Maps.filterKeys[SortedMap, Predicate]") |
| .withFeatures( |
| MapFeature.ALLOWS_NULL_VALUES, |
| MapFeature.GENERAL_PURPOSE, |
| CollectionSize.ANY) |
| .createTestSuite()); |
| suite.addTest(SortedMapTestSuiteBuilder.using(new TestStringSortedMapGenerator() { |
| @Override |
| protected SortedMap<String, String> create(Entry<String, String>[] entries) { |
| SortedMap<String, String> map = new NonNavigableSortedMap(); |
| putEntries(map, entries); |
| map.putAll(ENTRIES_TO_FILTER); |
| return Maps.filterValues(map, FILTER_VALUES); |
| } |
| }) |
| .named("Maps.filterValues[SortedMap, Predicate]") |
| .withFeatures( |
| MapFeature.ALLOWS_NULL_VALUES, |
| MapFeature.GENERAL_PURPOSE, |
| CollectionSize.ANY) |
| .createTestSuite()); |
| suite.addTest(SortedMapTestSuiteBuilder.using(new TestStringSortedMapGenerator() { |
| @Override |
| protected SortedMap<String, String> create(Entry<String, String>[] entries) { |
| SortedMap<String, String> map = new NonNavigableSortedMap(); |
| putEntries(map, entries); |
| map.putAll(ENTRIES_TO_FILTER); |
| return Maps.filterEntries(map, FILTER_ENTRIES); |
| } |
| }) |
| .named("Maps.filterEntries[SortedMap, Predicate]") |
| .withFeatures( |
| MapFeature.ALLOWS_NULL_VALUES, |
| MapFeature.GENERAL_PURPOSE, |
| CollectionSize.ANY) |
| .createTestSuite()); |
| return suite; |
| } |
| |
| static TestSuite filterNavigableMapSuite() { |
| TestSuite suite = new TestSuite("FilterNavigableMap"); |
| suite.addTest(NavigableMapTestSuiteBuilder.using(new TestStringSortedMapGenerator() { |
| @Override |
| protected NavigableMap<String, String> create(Entry<String, String>[] entries) { |
| NavigableMap<String, String> map = new SafeTreeMap<String, String>(); |
| putEntries(map, entries); |
| map.put("banana", "toast"); |
| map.put("eggplant", "spam"); |
| return Maps.filterKeys(map, FILTER_KEYS); |
| } |
| }) |
| .named("Maps.filterKeys[NavigableMap, Predicate]") |
| .withFeatures( |
| MapFeature.ALLOWS_NULL_VALUES, |
| MapFeature.GENERAL_PURPOSE, |
| CollectionSize.ANY) |
| .createTestSuite()); |
| suite.addTest(NavigableMapTestSuiteBuilder.using(new TestStringSortedMapGenerator() { |
| @Override |
| protected NavigableMap<String, String> create(Entry<String, String>[] entries) { |
| NavigableMap<String, String> map = new SafeTreeMap<String, String>(); |
| putEntries(map, entries); |
| map.put("banana", "toast"); |
| map.put("eggplant", "spam"); |
| return Maps.filterValues(map, FILTER_VALUES); |
| } |
| }) |
| .named("Maps.filterValues[NavigableMap, Predicate]") |
| .withFeatures( |
| MapFeature.ALLOWS_NULL_VALUES, |
| MapFeature.GENERAL_PURPOSE, |
| CollectionSize.ANY) |
| .createTestSuite()); |
| suite.addTest(NavigableMapTestSuiteBuilder.using(new TestStringSortedMapGenerator() { |
| @Override |
| protected NavigableMap<String, String> create(Entry<String, String>[] entries) { |
| NavigableMap<String, String> map = new SafeTreeMap<String, String>(); |
| putEntries(map, entries); |
| map.put("banana", "toast"); |
| map.put("eggplant", "spam"); |
| return Maps.filterEntries(map, FILTER_ENTRIES); |
| } |
| }) |
| .named("Maps.filterEntries[NavigableMap, Predicate]") |
| .withFeatures( |
| MapFeature.ALLOWS_NULL_VALUES, |
| MapFeature.GENERAL_PURPOSE, |
| CollectionSize.ANY) |
| .createTestSuite()); |
| return suite; |
| } |
| |
| static void putEntries(Map<String, String> map, Entry<String, String>[] entries) { |
| for (Entry<String, String> entry : entries) { |
| map.put(entry.getKey(), entry.getValue()); |
| } |
| } |
| |
| static final Predicate<String> FILTER_KEYS = new Predicate<String>() { |
| @Override |
| public boolean apply(@Nullable String string) { |
| return !"banana".equals(string) && !"eggplant".equals(string); |
| } |
| }; |
| |
| static final Predicate<String> FILTER_VALUES = new Predicate<String>() { |
| @Override |
| public boolean apply(@Nullable String string) { |
| return !"toast".equals(string) && !"spam".equals(string); |
| } |
| }; |
| |
| static final Predicate<Entry<String, String>> FILTER_ENTRIES = |
| new Predicate<Entry<String, String>>() { |
| @Override |
| public boolean apply(Entry<String, String> entry) { |
| return !Helpers.mapEntry("banana", "toast").equals(entry) |
| && !Helpers.mapEntry("eggplant", "spam").equals(entry); |
| } |
| }; |
| |
| static final Predicate<Entry<String, String>> FILTER_ENTRIES_1 = |
| new Predicate<Entry<String, String>>() { |
| @Override |
| public boolean apply(Entry<String, String> entry) { |
| return !Helpers.mapEntry("banana", "toast").equals(entry); |
| } |
| }; |
| |
| static final Predicate<Entry<String, String>> FILTER_ENTRIES_2 = |
| new Predicate<Entry<String, String>>() { |
| @Override |
| public boolean apply(Entry<String, String> entry) { |
| return !Helpers.mapEntry("eggplant", "spam").equals(entry); |
| } |
| }; |
| |
| static final Map<String, String> ENTRIES_TO_FILTER = |
| ImmutableMap.of("banana", "toast", "eggplant", "spam"); |
| |
| static final Predicate<Entry<String, String>> NOT_NULL_ENTRY = |
| new Predicate<Entry<String, String>>() { |
| @Override |
| public boolean apply(Entry<String, String> entry) { |
| return entry.getKey() != null && entry.getValue() != null; |
| } |
| }; |
| |
| private static class NonNavigableSortedSet |
| extends ForwardingSortedSet<String> { |
| |
| private final SortedSet<String> delegate = Sets.newTreeSet(Ordering.natural()); |
| |
| @Override |
| protected SortedSet<String> delegate() { |
| return delegate; |
| } |
| } |
| |
| private static class NonNavigableSortedMap |
| extends ForwardingSortedMap<String, String> { |
| |
| private final SortedMap<String, String> delegate = |
| new SafeTreeMap<String, String>(Ordering.natural()); |
| |
| @Override |
| protected SortedMap<String, String> delegate() { |
| return delegate; |
| } |
| } |
| |
| private static String encode(String str) { |
| return BaseEncoding.base64().encode(str.getBytes(Charsets.UTF_8)); |
| } |
| |
| private static final Function<String, String> DECODE_FUNCTION = new Function<String, String>() { |
| @Override |
| public String apply(String input) { |
| return new String(BaseEncoding.base64().decode(input), Charsets.UTF_8); |
| } |
| }; |
| |
| private static final EntryTransformer<String, String, String> DECODE_ENTRY_TRANSFORMER = |
| new EntryTransformer<String, String, String>() { |
| @Override |
| public String transformEntry(String key, String value) { |
| return DECODE_FUNCTION.apply(value); |
| } |
| }; |
| |
| static TestSuite transformSuite() { |
| TestSuite suite = new TestSuite("Maps.transform"); |
| suite.addTest(transformMapSuite()); |
| suite.addTest(transformSortedMapSuite()); |
| suite.addTest(transformNavigableMapSuite()); |
| return suite; |
| } |
| |
| static TestSuite transformMapSuite() { |
| TestSuite suite = new TestSuite("TransformMap"); |
| suite.addTest(MapTestSuiteBuilder.using(new TestStringMapGenerator() { |
| @Override |
| protected Map<String, String> create(Entry<String, String>[] entries) { |
| Map<String, String> map = Maps.newLinkedHashMap(); |
| for (Entry<String, String> entry : entries) { |
| map.put(entry.getKey(), encode(entry.getValue())); |
| } |
| return Maps.transformValues(map, DECODE_FUNCTION); |
| } |
| }) |
| .named("Maps.transformValues[Map, Function]") |
| .withFeatures( |
| CollectionSize.ANY, |
| CollectionFeature.KNOWN_ORDER, |
| MapFeature.ALLOWS_NULL_KEYS, |
| MapFeature.ALLOWS_ANY_NULL_QUERIES, |
| MapFeature.SUPPORTS_REMOVE, |
| CollectionFeature.SUPPORTS_ITERATOR_REMOVE) |
| .createTestSuite()); |
| suite.addTest(MapTestSuiteBuilder.using(new TestStringMapGenerator() { |
| @Override |
| protected Map<String, String> create(Entry<String, String>[] entries) { |
| Map<String, String> map = Maps.newLinkedHashMap(); |
| for (Entry<String, String> entry : entries) { |
| map.put(entry.getKey(), encode(entry.getValue())); |
| } |
| return Maps.transformEntries(map, DECODE_ENTRY_TRANSFORMER); |
| } |
| }) |
| .named("Maps.transformEntries[Map, EntryTransformer]") |
| .withFeatures( |
| CollectionSize.ANY, |
| CollectionFeature.KNOWN_ORDER, |
| MapFeature.ALLOWS_NULL_KEYS, |
| MapFeature.ALLOWS_ANY_NULL_QUERIES, |
| MapFeature.SUPPORTS_REMOVE, |
| CollectionFeature.SUPPORTS_ITERATOR_REMOVE) |
| .createTestSuite()); |
| return suite; |
| } |
| |
| static TestSuite transformSortedMapSuite() { |
| TestSuite suite = new TestSuite("TransformSortedMap"); |
| suite.addTest(SortedMapTestSuiteBuilder.using(new TestStringSortedMapGenerator() { |
| @Override |
| protected SortedMap<String, String> create(Entry<String, String>[] entries) { |
| SortedMap<String, String> map = new NonNavigableSortedMap(); |
| for (Entry<String, String> entry : entries) { |
| map.put(entry.getKey(), encode(entry.getValue())); |
| } |
| return Maps.transformValues(map, DECODE_FUNCTION); |
| } |
| }) |
| .named("Maps.transformValues[SortedMap, Function]") |
| .withFeatures( |
| CollectionSize.ANY, |
| CollectionFeature.KNOWN_ORDER, |
| MapFeature.SUPPORTS_REMOVE, |
| CollectionFeature.SUPPORTS_ITERATOR_REMOVE) |
| .createTestSuite()); |
| suite.addTest(SortedMapTestSuiteBuilder.using(new TestStringSortedMapGenerator() { |
| @Override |
| protected SortedMap<String, String> create(Entry<String, String>[] entries) { |
| SortedMap<String, String> map = new NonNavigableSortedMap(); |
| for (Entry<String, String> entry : entries) { |
| map.put(entry.getKey(), encode(entry.getValue())); |
| } |
| return Maps.transformEntries(map, DECODE_ENTRY_TRANSFORMER); |
| } |
| }) |
| .named("Maps.transformEntries[SortedMap, EntryTransformer]") |
| .withFeatures( |
| CollectionSize.ANY, |
| CollectionFeature.KNOWN_ORDER, |
| MapFeature.SUPPORTS_REMOVE, |
| CollectionFeature.SUPPORTS_ITERATOR_REMOVE) |
| .createTestSuite()); |
| return suite; |
| } |
| |
| static TestSuite transformNavigableMapSuite() { |
| TestSuite suite = new TestSuite("TransformNavigableMap"); |
| suite.addTest(NavigableMapTestSuiteBuilder.using(new TestStringSortedMapGenerator() { |
| @Override |
| protected NavigableMap<String, String> create(Entry<String, String>[] entries) { |
| NavigableMap<String, String> map = new SafeTreeMap<String, String>(); |
| for (Entry<String, String> entry : entries) { |
| map.put(entry.getKey(), encode(entry.getValue())); |
| } |
| return Maps.transformValues(map, DECODE_FUNCTION); |
| } |
| }) |
| .named("Maps.transformValues[NavigableMap, Function]") |
| .withFeatures( |
| CollectionSize.ANY, |
| CollectionFeature.KNOWN_ORDER, |
| MapFeature.SUPPORTS_REMOVE, |
| CollectionFeature.SUPPORTS_ITERATOR_REMOVE) |
| .createTestSuite()); |
| suite.addTest(NavigableMapTestSuiteBuilder.using(new TestStringSortedMapGenerator() { |
| @Override |
| protected NavigableMap<String, String> create(Entry<String, String>[] entries) { |
| NavigableMap<String, String> map = new SafeTreeMap<String, String>(); |
| for (Entry<String, String> entry : entries) { |
| map.put(entry.getKey(), encode(entry.getValue())); |
| } |
| return Maps.transformEntries(map, DECODE_ENTRY_TRANSFORMER); |
| } |
| }) |
| .named("Maps.transformEntries[NavigableMap, EntryTransformer]") |
| .withFeatures( |
| CollectionSize.ANY, |
| CollectionFeature.KNOWN_ORDER, |
| MapFeature.SUPPORTS_REMOVE, |
| CollectionFeature.SUPPORTS_ITERATOR_REMOVE) |
| .createTestSuite()); |
| return suite; |
| } |
| } |