|
|
Java example source code file (MapsCollectionTest.java)
This example Java source code file (MapsCollectionTest.java) is included in the alvinalexander.com
"Java Source Code
Warehouse" project. The intent of this project is to help you "Learn
Java by Example" TM.
Learn more about this Java project at its project page.
The MapsCollectionTest.java Java example source code
/*
* 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[] entries) {
SafeTreeMap<String, String> map = new SafeTreeMap();
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[] 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 samples() {
return new SampleElements<Entry(
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 order(
List<Entry 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 samples() {
return new SampleElements<Entry(
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 order(
List<Entry insertionOrder) {
Collections.sort(insertionOrder, new Comparator<Entry() {
@Override
public int compare(Entry<String, Integer> o1, Entry 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 samples() {
return new SampleElements<Entry(
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 order(
List<Entry insertionOrder) {
Collections.sort(insertionOrder, new Comparator<Entry() {
@Override
public int compare(Entry<String, Integer> o1, Entry 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[] 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[] 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[] 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[] 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[] 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[] 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[] 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[] 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[] 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[] 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[] entries) {
NavigableMap<String, String> map = new SafeTreeMap();
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[] entries) {
NavigableMap<String, String> map = new SafeTreeMap();
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[] entries) {
NavigableMap<String, String> map = new SafeTreeMap();
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[] entries) {
for (Entry<String, String> entry : entries) {
map.put(entry.getKey(), entry.getValue());
}
}
static final Predicate<String> FILTER_KEYS = new Predicate() {
@Override
public boolean apply(@Nullable String string) {
return !"banana".equals(string) && !"eggplant".equals(string);
}
};
static final Predicate<String> FILTER_VALUES = new Predicate() {
@Override
public boolean apply(@Nullable String string) {
return !"toast".equals(string) && !"spam".equals(string);
}
};
static final Predicate<Entry FILTER_ENTRIES =
new Predicate<Entry() {
@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 FILTER_ENTRIES_1 =
new Predicate<Entry() {
@Override
public boolean apply(Entry<String, String> entry) {
return !Helpers.mapEntry("banana", "toast").equals(entry);
}
};
static final Predicate<Entry FILTER_ENTRIES_2 =
new Predicate<Entry() {
@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 NOT_NULL_ENTRY =
new Predicate<Entry() {
@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() {
@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[] 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[] 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[] 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[] 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[] entries) {
NavigableMap<String, String> map = new SafeTreeMap();
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[] entries) {
NavigableMap<String, String> map = new SafeTreeMap();
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;
}
}
Other Java examples (source code examples)
Here is a short list of links related to this Java MapsCollectionTest.java source code file:
|
The search page
Other Java source code examples at this package level
Click here to learn more about this project
