xref: /external/guava/guava-testlib/src/com/google/common/collect/testing/google/MultimapTestSuiteBuilder.java

/*
 * 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.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
 */
public class MultimapTestSuiteBuilder<K, V, M extends Multimap<K, V>> extends
    PerCollectionSizeTestSuiteBuilder<
    MultimapTestSuiteBuilder<K, V, M>,
    TestMultimapGenerator<K, V, M>, M, Map.Entry<K, V>> {

  public static <K, V, M extends Multimap<K, V>> MultimapTestSuiteBuilder<K, V, M> using(
      TestMultimapGenerator<K, V, M> generator) {
    return new MultimapTestSuiteBuilder<K, V, M>().usingGenerator(generator);
  }

  // Class parameters must be raw.
  @Override
  protected List<Class<? extends AbstractTester>> getTesters() {
    return ImmutableList.<Class<? extends AbstractTester>> of(
        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<K, V>>>
      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<K, V>>> 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<K, V>>> 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<K, V>>> 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<K, V>>> 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<K, V>>> 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<Feature<?>> 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<Feature<?>> 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<Feature<?>> 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<Feature<?>> 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<Feature<?>> 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<?>, Feature<?>> GET_FEATURE_MAP = ImmutableMultimap
      .<Feature<?>, 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<Feature<?>> multimapFeatures) {
    Set<Feature<?>> derivedFeatures = Helpers.copyToSet(multimapFeatures);
    for (Map.Entry<Feature<?>, Feature<?>> entry : GET_FEATURE_MAP.entries()) {
      if (derivedFeatures.contains(entry.getKey())) {
        derivedFeatures.add(entry.getValue());
      }
    }
    if (derivedFeatures.remove(MultimapFeature.VALUE_COLLECTIONS_SUPPORT_ITERATOR_REMOVE)) {
      derivedFeatures.add(CollectionFeature.SUPPORTS_ITERATOR_REMOVE);
    }
    if (!derivedFeatures.contains(CollectionFeature.SERIALIZABLE_INCLUDING_VIEWS)) {
      derivedFeatures.remove(CollectionFeature.SERIALIZABLE);
    }
    derivedFeatures.removeAll(GET_FEATURE_MAP.keySet());
    return derivedFeatures;
  }

  Set<Feature<?>> computeMultimapAsMapGetFeatures(
      Set<Feature<?>> 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<K, V>> implements
      TestMapGenerator<K, Collection<V>>, DerivedGenerator {
    private final OneSizeTestContainerGenerator<M, Map.Entry<K, V>> multimapGenerator;

    public AsMapGenerator(
        OneSizeTestContainerGenerator<M, Entry<K, V>> 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<K, Collection<V>>> 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<K, Collection<V>>>(
          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<V>> create(Object... elements) {
      Set<K> keySet = new HashSet<K>();
      List<Map.Entry<K, V>> builder = new ArrayList<Entry<K, V>>();
      for (Object o : elements) {
        Map.Entry<K, Collection<V>> entry = (Entry<K, Collection<V>>) 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<V>>[] createArray(int length) {
      return new Entry[length];
    }

    @Override
    public Iterable<Entry<K, Collection<V>>> order(List<Entry<K, Collection<V>>> insertionOrder) {
      Map<K, Collection<V>> map = new HashMap<K, Collection<V>>();
      List<Map.Entry<K, V>> builder = new ArrayList<Entry<K, V>>();
      for (Entry<K, Collection<V>> entry : insertionOrder) {
        for (V v : entry.getValue()) {
          builder.add(mapEntry(entry.getKey(), v));
        }
        map.put(entry.getKey(), entry.getValue());
      }
      Iterable<Map.Entry<K, V>> ordered = multimapGenerator.order(builder);
      LinkedHashMap<K, Collection<V>> orderedMap = new LinkedHashMap<K, Collection<V>>();
      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<K, V>>
      implements TestCollectionGenerator<Entry<K, V>>, DerivedGenerator {
    private final OneSizeTestContainerGenerator<M, Map.Entry<K, V>> multimapGenerator;

    public EntriesGenerator(
        OneSizeTestContainerGenerator<M, Entry<K, V>> multimapGenerator) {
      this.multimapGenerator = multimapGenerator;
    }

    @Override
    public TestSubjectGenerator<?> getInnerGenerator() {
      return multimapGenerator;
    }

    @Override
    public SampleElements<Entry<K, V>> samples() {
      return multimapGenerator.samples();
    }

    @Override
    public Collection<Entry<K, V>> 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<K, V>> order(List<Entry<K, V>> insertionOrder) {
      return multimapGenerator.order(insertionOrder);
    }
  }

  static class ValuesGenerator<K, V, M extends Multimap<K, V>>
      implements TestCollectionGenerator<V> {
    private final OneSizeTestContainerGenerator<M, Map.Entry<K, V>> multimapGenerator;

    public ValuesGenerator(
        OneSizeTestContainerGenerator<M, Entry<K, V>> 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(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<V> insertionOrder) {
      K k =
          ((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator()).sampleKeys().e0;
      List<Entry<K, V>> entries = new ArrayList<Entry<K, V>>();
      for (V v : insertionOrder) {
        entries.add(mapEntry(k, v));
      }
      Iterable<Entry<K, V>> ordered = multimapGenerator.order(entries);
      List<V> orderedValues = new ArrayList<V>();
      for (Entry<K, V> entry : ordered) {
        orderedValues.add(entry.getValue());
      }
      return orderedValues;
    }
  }

  static class KeysGenerator<K, V, M extends Multimap<K, V>> implements
      TestMultisetGenerator<K>, DerivedGenerator {
    private final OneSizeTestContainerGenerator<M, Map.Entry<K, V>> multimapGenerator;

    public KeysGenerator(
        OneSizeTestContainerGenerator<M, Entry<K, V>> 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<V>> valueIterators = new HashMap<K, Iterator<V>>();
      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(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<K> insertionOrder) {
      Iterator<V> valueIter = sampleValuesIterator();
      List<Entry<K, V>> entries = new ArrayList<Entry<K, V>>();
      for (K k : insertionOrder) {
        entries.add(mapEntry(k, valueIter.next()));
      }
      Iterable<Entry<K, V>> ordered = multimapGenerator.order(entries);
      List<K> orderedValues = new ArrayList<K>();
      for (Entry<K, V> entry : ordered) {
        orderedValues.add(entry.getKey());
      }
      return orderedValues;
    }
  }

  static class MultimapGetGenerator<K, V, M extends Multimap<K, V>>
      implements TestCollectionGenerator<V> {
    final OneSizeTestContainerGenerator<M, Map.Entry<K, V>> multimapGenerator;

    public MultimapGetGenerator(
        OneSizeTestContainerGenerator<
        M, Map.Entry<K, V>> 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<V> insertionOrder) {
      K k = ((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator())
          .sampleKeys().e0;
      List<Entry<K, V>> entries = new ArrayList<Entry<K, V>>();
      for (V v : insertionOrder) {
        entries.add(mapEntry(k, v));
      }
      Iterable<Entry<K, V>> orderedEntries = multimapGenerator.order(entries);
      List<V> values = new ArrayList<V>();
      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(array).get(k);
    }
  }

  static class MultimapAsMapGetGenerator<K, V, M extends Multimap<K, V>>
      extends MultimapGetGenerator<K, V, M> {

    public MultimapAsMapGetGenerator(
        OneSizeTestContainerGenerator<
        M, Map.Entry<K, V>> 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(array).asMap().get(k);
    }
  }

  private static class ReserializedMultimapGenerator<K, V, M extends Multimap<K, V>>
      implements TestMultimapGenerator<K, V, M> {
    private final OneSizeTestContainerGenerator<M, Map.Entry<K, V>> multimapGenerator;

    public ReserializedMultimapGenerator(
        OneSizeTestContainerGenerator<
        M, Map.Entry<K, V>> multimapGenerator) {
      this.multimapGenerator = multimapGenerator;
    }

    @Override
    public SampleElements<Map.Entry<K, V>> samples() {
      return multimapGenerator.samples();
    }

    @Override
    public Map.Entry<K, V>[] createArray(int length) {
      return multimapGenerator.createArray(length);
    }

    @Override
    public Iterable<Map.Entry<K, V>> order(
        List<Map.Entry<K, V>> 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<? extends V> values) {
      return ((TestMultimapGenerator<K, V, M>) multimapGenerator.getInnerGenerator())
          .createCollection(values);
    }
  }
}