return suite;
  }

  protected Collection<Method> suppressForEmptyList() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForSingletonList() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForArraysAsList() {
    return Collections.emptySet();
  }

  protected Collection<Method> suppressForArrayList() {
    return Collections.emptySet();

      @Override
      <K extends @Nullable Object, V extends @Nullable Object> Map<K, Collection<V>> createMap() {
        return Platform.newHashMapWithExpectedSize(expectedKeys);
      }
    };
  }

  /**
   * Uses a hash table to map keys to value collections.
   *
   * <p>The collections returned by {@link Multimap#keySet()}, {@link Multimap#keys()}, and {@link

    SORTED {
      @Override
      void arrange(List<Integer> list) {
        Collections.sort(list);
      }
    },
    ALMOST_SORTED {
      @Override
      void arrange(List<Integer> list) {
        Collections.sort(list);
        if (list.size() > 1) {
          int i = (list.size() - 1) / 2;
          Collections.swap(list, i, i + 1);
        }
      }
    },
    RANDOM {
      @Override

import static com.google.common.collect.testing.IteratorFeature.UNMODIFIABLE;
import static java.util.Collections.emptyList;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.collect.testing.IteratorTester;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;

   */
  protected AbstractSetMultimap(Map<K, Collection<V>> map) {
    super(map);
  }

  @Override
  abstract Set<V> createCollection();

  @Override
  Set<V> createUnmodifiableEmptyCollection() {
    return Collections.emptySet();
  }

  @Override
  <E extends @Nullable Object> Collection<E> unmodifiableCollectionSubclass(
      Collection<E> collection) {
    return Collections.unmodifiableSet((Set<E>) collection);
  }

import com.google.common.collect.testing.features.CollectionSize;
import com.google.common.collect.testing.features.MapFeature;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import org.junit.Ignore;

/**
 * Tests for {@link Multimap#replaceValues(Object, Iterable)}.
 *
 * @author Louis Wasserman
 */
@GwtCompatible

    synchronized (collection) { // for Collections.synchronized
      assertFalse(collection.spliterator().hasCharacteristics(Spliterator.NONNULL));
    }
  }

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testSpliteratorNotImmutable_CollectionAllowsAdd() {
    // If add is supported, verify that IMMUTABLE is not reported.
    synchronized (collection) { // for Collections.synchronized

    assertFalse(entries.remove(Maps.immutableEntry("foo", Collections.singleton(2))));
    assertTrue(map.containsKey("foo"));
    assertTrue(entries.contains(Maps.immutableEntry("foo", Collections.singleton(1))));
    assertTrue(entries.remove(Maps.immutableEntry("foo", Collections.singleton(1))));
    assertFalse(map.containsKey("foo"));
  }

  public void testForMapGetIteration() {

    resetContainer(
        Helpers.mapEntry(k0(), v0()), Helpers.mapEntry(k1(), v0()), Helpers.mapEntry(k0(), v3()));
    Set<Entry<K, Collection<V>>> expected = Sets.newHashSet();
    expected.add(Helpers.mapEntry(k0(), (Collection<V>) Sets.newHashSet(v0(), v3())));
    expected.add(Helpers.mapEntry(k1(), (Collection<V>) Sets.newHashSet(v0())));
    new EqualsTester().addEqualityGroup(expected, multimap().asMap().entrySet()).testEquals();
  }

    resetContainer(
        Helpers.mapEntry(k0(), v0()), Helpers.mapEntry(k1(), v0()), Helpers.mapEntry(k0(), v3()));
    Set<Entry<K, Collection<V>>> expected = Sets.newHashSet();
    expected.add(Helpers.mapEntry(k0(), (Collection<V>) Lists.newArrayList(v0(), v3())));
    expected.add(Helpers.mapEntry(k1(), (Collection<V>) Lists.newArrayList(v0())));
    new EqualsTester().addEqualityGroup(expected, multimap().asMap().entrySet()).testEquals();
  }