}

    @Override
    public SampleElements<Entry<String, String>> samples() {
      return new SampleElements<>(
          mapEntry("one", "january"),
          mapEntry("two", "february"),
          mapEntry("three", "march"),
          mapEntry("four", "april"),
          mapEntry("five", "may"));
    }

    @Override
    public M create(Object... elements) {

  @CollectionSize.Require(SEVERAL)
  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testPropagatesRemoveToMultimap() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k0(), v3()), mapEntry(k0(), v2()));
    Collection<V> result = multimap().asMap().get(k0());
    assertTrue(result.remove(v0()));
    assertFalse(multimap().containsEntry(k0(), v0()));
    assertEquals(2, multimap().size());

    CollectorTester.of(collector, equivalence)
        .expectCollects(
            ImmutableMap.of("one", 1, "two", 4, "three", 3),
            mapEntry("one", 1),
            mapEntry("two", 2),
            mapEntry("three", 3),
            mapEntry("two", 2));
  }

  // Non-creation tests

  public void testNullGet() {
    ImmutableMap<String, Integer> map = ImmutableMap.of("one", 1);

 */

package com.google.common.collect.testing.google;

import static com.google.common.collect.testing.Helpers.assertEqualIgnoringOrder;
import static com.google.common.collect.testing.Helpers.mapEntry;
import static java.util.Arrays.asList;

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.Multimap;
import com.google.common.collect.testing.AbstractContainerTester;

    CollectorTester.of(collector, equivalence)
        .expectCollects(
            ImmutableBiMap.of("one", 1, "two", 2, "three", 3),
            mapEntry("one", 1),
            mapEntry("two", 2),
            mapEntry("three", 3));
  }

  public void testToImmutableBiMap_exceptionOnDuplicateKey() {
    Collector<Entry<String, Integer>, ?, ImmutableBiMap<String, Integer>> collector =

    multimap().forEach((k, v) -> entries.add(mapEntry(k, v)));
    assertEqualIgnoringOrder(getSampleElements(), multimap().entries());
  }

  @CollectionFeature.Require(KNOWN_ORDER)
  public void testForEachOrder() {
    List<Entry<K, V>> entries = new ArrayList<>();
    multimap().forEach((k, v) -> entries.add(mapEntry(k, v)));
    assertEqualIgnoringOrder(getSampleElements(), multimap().entries());
  }

 */

package com.google.common.collect.testing.google;

import static com.google.common.collect.testing.Helpers.assertEqualIgnoringOrder;
import static com.google.common.collect.testing.Helpers.mapEntry;

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.BiMap;
import com.google.common.collect.testing.AbstractMapTester;
import java.util.ArrayList;
import java.util.Collection;

        }

        @Override
        public Multiset.Entry<E> next() {
          final Map.Entry<E, Integer> mapEntry = backingEntries.next();
          return new Multisets.AbstractEntry<E>() {
            @Override
            public E getElement() {
              return mapEntry.getKey();
            }

            @Override
            public int getCount() {

 * limitations under the License.
 */

package com.google.common.collect.testing;

import static com.google.common.collect.testing.Helpers.copyToList;
import static com.google.common.collect.testing.Helpers.mapEntry;

import com.google.common.annotations.GwtCompatible;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;

    } catch (UnsupportedOperationException e) {
      return;
    }

    map.put(null, unmappedValue);
    Entry<@Nullable K, V> entry = mapEntry(null, unmappedValue);
    assertTrue(entrySet.contains(entry));
    Entry<@Nullable K, @Nullable V> nonEntry = mapEntry(null, null);
    assertFalse(entrySet.contains(nonEntry));
  }

  public void testEntrySetContainsEntryNullKeyMissing() {
    Map<K, V> map;