|
Java example source code file (MultimapTestSuiteBuilder.java)
This example Java source code file (MultimapTestSuiteBuilder.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 MultimapTestSuiteBuilder.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.testing.google;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.collect.testing.Helpers.mapEntry;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMultimap;
import com.google.common.collect.Multimap;
import com.google.common.collect.Multiset;
import com.google.common.collect.testing.AbstractTester;
import com.google.common.collect.testing.CollectionTestSuiteBuilder;
import com.google.common.collect.testing.DerivedGenerator;
import com.google.common.collect.testing.FeatureSpecificTestSuiteBuilder;
import com.google.common.collect.testing.Helpers;
import com.google.common.collect.testing.MapTestSuiteBuilder;
import com.google.common.collect.testing.OneSizeTestContainerGenerator;
import com.google.common.collect.testing.PerCollectionSizeTestSuiteBuilder;
import com.google.common.collect.testing.SampleElements;
import com.google.common.collect.testing.TestCollectionGenerator;
import com.google.common.collect.testing.TestMapGenerator;
import com.google.common.collect.testing.TestSubjectGenerator;
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.features.MapFeature;
import com.google.common.testing.SerializableTester;
import junit.framework.TestSuite;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
* Creates, based on your criteria, a JUnit test suite that exhaustively tests
* a {@code Multimap} implementation.
*
* @author Louis Wasserman
*/
@GwtIncompatible
public class MultimapTestSuiteBuilder<K, V, M extends Multimap
extends PerCollectionSizeTestSuiteBuilder<
MultimapTestSuiteBuilder<K, V, M>, TestMultimapGenerator, M, Map.Entry> {
public static <K, V, M extends Multimap MultimapTestSuiteBuilder using(
TestMultimapGenerator<K, V, M> generator) {
return new MultimapTestSuiteBuilder<K, V, M>().usingGenerator(generator);
}
// Class parameters must be raw.
@Override
protected List<Class getTesters() {
return ImmutableList.<Classof(
MultimapAsMapGetTester.class,
MultimapAsMapTester.class,
MultimapSizeTester.class,
MultimapClearTester.class,
MultimapContainsKeyTester.class,
MultimapContainsValueTester.class,
MultimapContainsEntryTester.class,
MultimapEntriesTester.class,
MultimapEqualsTester.class,
MultimapGetTester.class,
MultimapKeySetTester.class,
MultimapKeysTester.class,
MultimapPutTester.class,
MultimapPutAllMultimapTester.class,
MultimapPutIterableTester.class,
MultimapReplaceValuesTester.class,
MultimapRemoveEntryTester.class,
MultimapRemoveAllTester.class,
MultimapToStringTester.class,
MultimapValuesTester.class);
}
@Override
protected List<TestSuite> createDerivedSuites(
FeatureSpecificTestSuiteBuilder<
?, ? extends OneSizeTestContainerGenerator<M, Map.Entry>
parentBuilder) {
// TODO: Once invariant support is added, supply invariants to each of the
// derived suites, to check that mutations to the derived collections are
// reflected in the underlying map.
List<TestSuite> derivedSuites = super.createDerivedSuites(parentBuilder);
if (parentBuilder.getFeatures().contains(CollectionFeature.SERIALIZABLE)) {
derivedSuites.add(
MultimapTestSuiteBuilder.using(
new ReserializedMultimapGenerator<K, V, M>(parentBuilder.getSubjectGenerator()))
.withFeatures(computeReserializedMultimapFeatures(parentBuilder.getFeatures()))
.named(parentBuilder.getName() + " reserialized")
.suppressing(parentBuilder.getSuppressedTests())
.createTestSuite());
}
derivedSuites.add(
MapTestSuiteBuilder.using(new AsMapGenerator<K, V, M>(parentBuilder.getSubjectGenerator()))
.withFeatures(computeAsMapFeatures(parentBuilder.getFeatures()))
.named(parentBuilder.getName() + ".asMap")
.suppressing(parentBuilder.getSuppressedTests())
.createTestSuite());
derivedSuites.add(computeEntriesTestSuite(parentBuilder));
derivedSuites.add(computeMultimapGetTestSuite(parentBuilder));
derivedSuites.add(computeMultimapAsMapGetTestSuite(parentBuilder));
derivedSuites.add(computeKeysTestSuite(parentBuilder));
derivedSuites.add(computeValuesTestSuite(parentBuilder));
return derivedSuites;
}
TestSuite computeValuesTestSuite(
FeatureSpecificTestSuiteBuilder<
?, ? extends OneSizeTestContainerGenerator<M, Map.Entry>
parentBuilder) {
return CollectionTestSuiteBuilder.using(
new ValuesGenerator<K, V, M>(parentBuilder.getSubjectGenerator()))
.withFeatures(computeValuesFeatures(parentBuilder.getFeatures()))
.named(parentBuilder.getName() + ".values")
.suppressing(parentBuilder.getSuppressedTests())
.createTestSuite();
}
TestSuite computeEntriesTestSuite(
FeatureSpecificTestSuiteBuilder<
?, ? extends OneSizeTestContainerGenerator<M, Map.Entry>
parentBuilder) {
return CollectionTestSuiteBuilder.using(
new EntriesGenerator<K, V, M>(parentBuilder.getSubjectGenerator()))
.withFeatures(computeEntriesFeatures(parentBuilder.getFeatures()))
.named(parentBuilder.getName() + ".entries")
.suppressing(parentBuilder.getSuppressedTests())
.createTestSuite();
}
TestSuite computeMultimapGetTestSuite(
FeatureSpecificTestSuiteBuilder<
?, ? extends OneSizeTestContainerGenerator<M, Map.Entry>
parentBuilder) {
return CollectionTestSuiteBuilder.using(
new MultimapGetGenerator<K, V, M>(parentBuilder.getSubjectGenerator()))
.withFeatures(computeMultimapGetFeatures(parentBuilder.getFeatures()))
.named(parentBuilder.getName() + ".get[key]")
.suppressing(parentBuilder.getSuppressedTests())
.createTestSuite();
}
TestSuite computeMultimapAsMapGetTestSuite(
FeatureSpecificTestSuiteBuilder<
?, ? extends OneSizeTestContainerGenerator<M, Map.Entry>
parentBuilder) {
Set<Feature features = computeMultimapAsMapGetFeatures(parentBuilder.getFeatures());
if (Collections.disjoint(features, EnumSet.allOf(CollectionSize.class))) {
return new TestSuite();
} else {
return CollectionTestSuiteBuilder.using(
new MultimapAsMapGetGenerator<K, V, M>(parentBuilder.getSubjectGenerator()))
.withFeatures(features)
.named(parentBuilder.getName() + ".asMap[].get[key]")
.suppressing(parentBuilder.getSuppressedTests())
.createTestSuite();
}
}
TestSuite computeKeysTestSuite(
FeatureSpecificTestSuiteBuilder<
?, ? extends OneSizeTestContainerGenerator<M, Map.Entry>
parentBuilder) {
return MultisetTestSuiteBuilder.using(
new KeysGenerator<K, V, M>(parentBuilder.getSubjectGenerator()))
.withFeatures(computeKeysFeatures(parentBuilder.getFeatures()))
.named(parentBuilder.getName() + ".keys")
.suppressing(parentBuilder.getSuppressedTests())
.createTestSuite();
}
static Set<Feature computeDerivedCollectionFeatures(Set> multimapFeatures) {
Set<Feature derivedFeatures = Helpers.copyToSet(multimapFeatures);
if (!derivedFeatures.remove(CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS)) {
derivedFeatures.remove(CollectionFeature.SERIALIZABLE);
}
if (derivedFeatures.remove(MapFeature.SUPPORTS_REMOVE)) {
derivedFeatures.add(CollectionFeature.SUPPORTS_REMOVE);
}
return derivedFeatures;
}
static Set<Feature computeEntriesFeatures(Set> multimapFeatures) {
Set<Feature result = computeDerivedCollectionFeatures(multimapFeatures);
if (multimapFeatures.contains(MapFeature.ALLOWS_NULL_ENTRY_QUERIES)) {
result.add(CollectionFeature.ALLOWS_NULL_QUERIES);
}
return result;
}
static Set<Feature computeValuesFeatures(Set> multimapFeatures) {
Set<Feature result = computeDerivedCollectionFeatures(multimapFeatures);
if (multimapFeatures.contains(MapFeature.ALLOWS_NULL_VALUES)) {
result.add(CollectionFeature.ALLOWS_NULL_VALUES);
}
if (multimapFeatures.contains(MapFeature.ALLOWS_NULL_VALUE_QUERIES)) {
result.add(CollectionFeature.ALLOWS_NULL_QUERIES);
}
return result;
}
static Set<Feature computeKeysFeatures(Set> multimapFeatures) {
Set<Feature result = computeDerivedCollectionFeatures(multimapFeatures);
if (multimapFeatures.contains(MapFeature.ALLOWS_NULL_KEYS)) {
result.add(CollectionFeature.ALLOWS_NULL_VALUES);
}
if (multimapFeatures.contains(MapFeature.ALLOWS_NULL_KEY_QUERIES)) {
result.add(CollectionFeature.ALLOWS_NULL_QUERIES);
}
return result;
}
private static Set<Feature computeReserializedMultimapFeatures(
Set<Feature multimapFeatures) {
Set<Feature derivedFeatures = Helpers.copyToSet(multimapFeatures);
derivedFeatures.remove(CollectionFeature.SERIALIZABLE);
derivedFeatures.remove(CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS);
return derivedFeatures;
}
private static Set<Feature computeAsMapFeatures(Set> multimapFeatures) {
Set<Feature derivedFeatures = Helpers.copyToSet(multimapFeatures);
derivedFeatures.remove(MapFeature.GENERAL_PURPOSE);
derivedFeatures.remove(MapFeature.SUPPORTS_PUT);
derivedFeatures.remove(MapFeature.ALLOWS_NULL_VALUES);
derivedFeatures.add(MapFeature.ALLOWS_NULL_VALUE_QUERIES);
derivedFeatures.add(MapFeature.REJECTS_DUPLICATES_AT_CREATION);
if (!derivedFeatures.contains(CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS)) {
derivedFeatures.remove(CollectionFeature.SERIALIZABLE);
}
return derivedFeatures;
}
private static final Multimap<Feature> GET_FEATURE_MAP =
ImmutableMultimap.<Feature>builder()
.put(
MapFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION,
CollectionFeature.FAILS_FAST_ON_CONCURRENT_MODIFICATION)
.put(MapFeature.GENERAL_PURPOSE, ListFeature.SUPPORTS_ADD_WITH_INDEX)
.put(MapFeature.GENERAL_PURPOSE, ListFeature.SUPPORTS_REMOVE_WITH_INDEX)
.put(MapFeature.GENERAL_PURPOSE, ListFeature.SUPPORTS_SET)
.put(MapFeature.ALLOWS_NULL_VALUE_QUERIES, CollectionFeature.ALLOWS_NULL_QUERIES)
.put(MapFeature.ALLOWS_NULL_VALUES, CollectionFeature.ALLOWS_NULL_VALUES)
.put(MapFeature.SUPPORTS_REMOVE, CollectionFeature.SUPPORTS_REMOVE)
.put(MapFeature.SUPPORTS_PUT, CollectionFeature.SUPPORTS_ADD)
.build();
Set<Feature computeMultimapGetFeatures(Set> multimapFeatures) {
Set<Feature derivedFeatures = Helpers.copyToSet(multimapFeatures);
for (Map.Entry<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;
}
Set<Feature computeMultimapAsMapGetFeatures(Set> multimapFeatures) {
Set<Feature derivedFeatures =
Helpers.copyToSet(computeMultimapGetFeatures(multimapFeatures));
if (derivedFeatures.remove(CollectionSize.ANY)) {
derivedFeatures.addAll(CollectionSize.ANY.getImpliedFeatures());
}
derivedFeatures.remove(CollectionSize.ZERO);
return derivedFeatures;
}
private static class AsMapGenerator<K, V, M extends Multimap
implements TestMapGenerator<K, Collection, DerivedGenerator {
private final OneSizeTestContainerGenerator<M, Map.Entry multimapGenerator;
public AsMapGenerator(OneSizeTestContainerGenerator<M, Entry multimapGenerator) {
this.multimapGenerator = multimapGenerator;
}
@Override
public TestSubjectGenerator<?> getInnerGenerator() {
return multimapGenerator;
}
private Collection<V> createCollection(V v) {
return ((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator())
.createCollection(Collections.singleton(v));
}
@Override
public SampleElements<Entry> samples() {
SampleElements<K> sampleKeys =
((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator()).sampleKeys();
SampleElements<V> sampleValues =
((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator()).sampleValues();
return new SampleElements<Entry>(
mapEntry(sampleKeys.e0(), createCollection(sampleValues.e0())),
mapEntry(sampleKeys.e1(), createCollection(sampleValues.e1())),
mapEntry(sampleKeys.e2(), createCollection(sampleValues.e2())),
mapEntry(sampleKeys.e3(), createCollection(sampleValues.e3())),
mapEntry(sampleKeys.e4(), createCollection(sampleValues.e4())));
}
@Override
public Map<K, Collection create(Object... elements) {
Set<K> keySet = new HashSet();
List<Map.Entry builder = new ArrayList>();
for (Object o : elements) {
Map.Entry<K, Collection entry = (Entry>) o;
keySet.add(entry.getKey());
for (V v : entry.getValue()) {
builder.add(mapEntry(entry.getKey(), v));
}
}
checkArgument(keySet.size() == elements.length, "Duplicate keys");
return multimapGenerator.create(builder.toArray()).asMap();
}
@SuppressWarnings("unchecked")
@Override
public Entry<K, Collection[] createArray(int length) {
return new Entry[length];
}
@Override
public Iterable<Entry> order(List>> insertionOrder) {
Map<K, Collection map = new HashMap>();
List<Map.Entry builder = new ArrayList>();
for (Entry<K, Collection entry : insertionOrder) {
for (V v : entry.getValue()) {
builder.add(mapEntry(entry.getKey(), v));
}
map.put(entry.getKey(), entry.getValue());
}
Iterable<Map.Entry ordered = multimapGenerator.order(builder);
LinkedHashMap<K, Collection orderedMap = new LinkedHashMap>();
for (Map.Entry<K, V> entry : ordered) {
orderedMap.put(entry.getKey(), map.get(entry.getKey()));
}
return orderedMap.entrySet();
}
@Override
public K[] createKeyArray(int length) {
return ((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator())
.createKeyArray(length);
}
@SuppressWarnings("unchecked")
@Override
public Collection<V>[] createValueArray(int length) {
return new Collection[length];
}
}
static class EntriesGenerator<K, V, M extends Multimap
implements TestCollectionGenerator<Entry, DerivedGenerator {
private final OneSizeTestContainerGenerator<M, Map.Entry multimapGenerator;
public EntriesGenerator(OneSizeTestContainerGenerator<M, Entry multimapGenerator) {
this.multimapGenerator = multimapGenerator;
}
@Override
public TestSubjectGenerator<?> getInnerGenerator() {
return multimapGenerator;
}
@Override
public SampleElements<Entry samples() {
return multimapGenerator.samples();
}
@Override
public Collection<Entry create(Object... elements) {
return multimapGenerator.create(elements).entries();
}
@SuppressWarnings("unchecked")
@Override
public Entry<K, V>[] createArray(int length) {
return new Entry[length];
}
@Override
public Iterable<Entry order(List> insertionOrder) {
return multimapGenerator.order(insertionOrder);
}
}
static class ValuesGenerator<K, V, M extends Multimap
implements TestCollectionGenerator<V> {
private final OneSizeTestContainerGenerator<M, Map.Entry multimapGenerator;
public ValuesGenerator(OneSizeTestContainerGenerator<M, Entry multimapGenerator) {
this.multimapGenerator = multimapGenerator;
}
@Override
public SampleElements<V> samples() {
return ((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator())
.sampleValues();
}
@Override
public Collection<V> create(Object... elements) {
K k =
((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator())
.sampleKeys()
.e0();
Entry<K, V>[] entries = new Entry[elements.length];
for (int i = 0; i < elements.length; i++) {
entries[i] = mapEntry(k, (V) elements[i]);
}
return multimapGenerator.create((Object[]) entries).values();
}
@SuppressWarnings("unchecked")
@Override
public V[] createArray(int length) {
return ((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator())
.createValueArray(length);
}
@Override
public Iterable<V> order(List insertionOrder) {
K k =
((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator())
.sampleKeys()
.e0();
List<Entry entries = new ArrayList>();
for (V v : insertionOrder) {
entries.add(mapEntry(k, v));
}
Iterable<Entry ordered = multimapGenerator.order(entries);
List<V> orderedValues = new ArrayList();
for (Entry<K, V> entry : ordered) {
orderedValues.add(entry.getValue());
}
return orderedValues;
}
}
static class KeysGenerator<K, V, M extends Multimap
implements TestMultisetGenerator<K>, DerivedGenerator {
private final OneSizeTestContainerGenerator<M, Map.Entry multimapGenerator;
public KeysGenerator(OneSizeTestContainerGenerator<M, Entry multimapGenerator) {
this.multimapGenerator = multimapGenerator;
}
@Override
public TestSubjectGenerator<?> getInnerGenerator() {
return multimapGenerator;
}
@Override
public SampleElements<K> samples() {
return ((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator()).sampleKeys();
}
@Override
public Multiset<K> create(Object... elements) {
/*
* This is nasty and complicated, but it's the only way to make sure keys get mapped to enough
* distinct values.
*/
Map.Entry[] entries = new Map.Entry[elements.length];
Map<K, Iterator valueIterators = new HashMap>();
for (int i = 0; i < elements.length; i++) {
@SuppressWarnings("unchecked")
K key = (K) elements[i];
Iterator<V> valueItr = valueIterators.get(key);
if (valueItr == null) {
valueIterators.put(key, valueItr = sampleValuesIterator());
}
entries[i] = mapEntry((K) elements[i], valueItr.next());
}
return multimapGenerator.create((Object[]) entries).keys();
}
private Iterator<V> sampleValuesIterator() {
return ((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator())
.sampleValues()
.iterator();
}
@SuppressWarnings("unchecked")
@Override
public K[] createArray(int length) {
return ((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator())
.createKeyArray(length);
}
@Override
public Iterable<K> order(List insertionOrder) {
Iterator<V> valueIter = sampleValuesIterator();
List<Entry entries = new ArrayList>();
for (K k : insertionOrder) {
entries.add(mapEntry(k, valueIter.next()));
}
Iterable<Entry ordered = multimapGenerator.order(entries);
List<K> orderedValues = new ArrayList();
for (Entry<K, V> entry : ordered) {
orderedValues.add(entry.getKey());
}
return orderedValues;
}
}
static class MultimapGetGenerator<K, V, M extends Multimap
implements TestCollectionGenerator<V> {
final OneSizeTestContainerGenerator<M, Map.Entry multimapGenerator;
public MultimapGetGenerator(
OneSizeTestContainerGenerator<M, Map.Entry multimapGenerator) {
this.multimapGenerator = multimapGenerator;
}
@Override
public SampleElements<V> samples() {
return ((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator())
.sampleValues();
}
@Override
public V[] createArray(int length) {
return ((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator())
.createValueArray(length);
}
@Override
public Iterable<V> order(List insertionOrder) {
K k =
((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator())
.sampleKeys()
.e0();
List<Entry entries = new ArrayList>();
for (V v : insertionOrder) {
entries.add(mapEntry(k, v));
}
Iterable<Entry orderedEntries = multimapGenerator.order(entries);
List<V> values = new ArrayList();
for (Entry<K, V> entry : orderedEntries) {
values.add(entry.getValue());
}
return values;
}
@Override
public Collection<V> create(Object... elements) {
Entry<K, V>[] array = multimapGenerator.createArray(elements.length);
K k =
((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator())
.sampleKeys()
.e0();
for (int i = 0; i < elements.length; i++) {
array[i] = mapEntry(k, (V) elements[i]);
}
return multimapGenerator.create((Object[]) array).get(k);
}
}
static class MultimapAsMapGetGenerator<K, V, M extends Multimap
extends MultimapGetGenerator<K, V, M> {
public MultimapAsMapGetGenerator(
OneSizeTestContainerGenerator<M, Map.Entry multimapGenerator) {
super(multimapGenerator);
}
@Override
public Collection<V> create(Object... elements) {
Entry<K, V>[] array = multimapGenerator.createArray(elements.length);
K k =
((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator())
.sampleKeys()
.e0();
for (int i = 0; i < elements.length; i++) {
array[i] = mapEntry(k, (V) elements[i]);
}
return multimapGenerator.create((Object[]) array).asMap().get(k);
}
}
private static class ReserializedMultimapGenerator<K, V, M extends Multimap
implements TestMultimapGenerator<K, V, M> {
private final OneSizeTestContainerGenerator<M, Map.Entry multimapGenerator;
public ReserializedMultimapGenerator(
OneSizeTestContainerGenerator<M, Map.Entry multimapGenerator) {
this.multimapGenerator = multimapGenerator;
}
@Override
public SampleElements<Map.Entry samples() {
return multimapGenerator.samples();
}
@Override
public Map.Entry<K, V>[] createArray(int length) {
return multimapGenerator.createArray(length);
}
@Override
public Iterable<Map.Entry order(List> insertionOrder) {
return multimapGenerator.order(insertionOrder);
}
@Override
public M create(Object... elements) {
return SerializableTester.reserialize(
((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator())
.create(elements));
}
@Override
public K[] createKeyArray(int length) {
return ((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator())
.createKeyArray(length);
}
@Override
public V[] createValueArray(int length) {
return ((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator())
.createValueArray(length);
}
@Override
public SampleElements<K> sampleKeys() {
return ((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator()).sampleKeys();
}
@Override
public SampleElements<V> sampleValues() {
return ((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator())
.sampleValues();
}
@Override
public Collection<V> createCollection(Iterable values) {
return ((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator())
.createCollection(values);
}
}
}
Other Java examples (source code examples)
Here is a short list of links related to this Java MultimapTestSuiteBuilder.java source code file:
|