@CollectionSize.Require(SEVERAL)
  public void testMultimapRemoveDeletesFirstOccurrence() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k0(), v1()), mapEntry(k0(), v0()));

    List<V> list = multimap().get(k0());
    multimap().remove(k0(), v0());
    assertContentsInOrder(list, v1(), v0());
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(SEVERAL)
  public void testRemoveAtIndexFromGetPropagates() {

    Multimap<Integer, UnhashableObject> multimap = ImmutableMultimap.of(0, unhashables.e0());
    assertEquals(1, multimap.get(0).size());
    assertTrue(multimap.get(0).contains(unhashables.e0()));
  }

  public void testUnhashableMixedValues() {
    SampleElements<UnhashableObject> unhashables = new Unhashables();
    Multimap<Integer, Object> multimap =
        ImmutableMultimap.<Integer, Object>of(

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class MultimapForEachTester<K, V> extends AbstractMultimapTester<K, V, Multimap<K, V>> {
  public void testForEach() {
    List<Entry<K, V>> entries = new ArrayList<>();
    multimap().forEach((k, v) -> entries.add(mapEntry(k, v)));
    assertEqualIgnoringOrder(getSampleElements(), multimap().entries());
  }

  @CollectionFeature.Require(KNOWN_ORDER)
  public void testForEachOrder() {

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.Multimap;
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 org.junit.Ignore;

/**
 * Tester for {@code Multimap.toString()}.
 *
 * @author Louis Wasserman
 */
@GwtCompatible

      expected.add(entry.getValue());
    }
    assertEqualInOrder(expected, multimap().values());
  }

  @CollectionFeature.Require(SUPPORTS_ITERATOR_REMOVE)
  @CollectionSize.Require(ONE)
  public void testValuesIteratorRemove() {
    Iterator<V> valuesItr = multimap().values().iterator();
    valuesItr.next();
    valuesItr.remove();
    assertTrue(multimap().isEmpty());
  }

    }
  }

  // Following Javadoc copied from Multimap and SortedSetMultimap.

  /**
   * Returns a collection view of all values associated with a key. If no mappings in the multimap
   * have the provided key, an empty collection is returned.
   *
   * <p>Changes to the returned collection will update the underlying multimap, and vice versa.
   *

@GwtCompatible
public enum MultimapFeature implements Feature<Multimap> {
  VALUE_COLLECTIONS_SUPPORT_ITERATOR_REMOVE;

  private final Set<Feature<? super Multimap>> implied;

  MultimapFeature(Feature<? super Multimap>... implied) {
    this.implied = copyToSet(implied);
  }

  @Override
  public Set<Feature<? super Multimap>> getImpliedFeatures() {
    return implied;
  }

package com.google.common.collect;

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.testing.MapInterfaceTest;
import java.util.Collection;
import java.util.Map;

/**
 * Test {@link Multimap#asMap()} for an {@link ImmutableMultimap} with {@link MapInterfaceTest}.
 *
 * @author Jared Levy
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public class ImmutableMultimapAsMapImplementsMapTest

import com.google.common.collect.Multimap;

/**
 * Helper methods/assertions for use with {@code com.google.common.collect} types.
 *
 * @author Colin Decker
 */
@GwtCompatible
final class GoogleHelpers {

  private GoogleHelpers() {}

  static void assertEmpty(Multimap<?, ?> multimap) {
    if (!multimap.isEmpty()) {
      fail("Not true that " + multimap + " is empty");
    }
  }

  public enum ListMultimapImpl {
    ArrayListMultimapImpl {
      @Override
      <K, V> ListMultimap<K, V> create(Multimap<K, V> contents) {
        return ArrayListMultimap.create(contents);
      }
    },
    LinkedListMultimapImpl {
      @Override
      <K, V> ListMultimap<K, V> create(Multimap<K, V> contents) {
        return LinkedListMultimap.create(contents);
      }
    },
    ImmutableListMultimapImpl {