return new SampleElements<>(
        Helpers.mapEntry(keys.e0(), values.e0()),
        Helpers.mapEntry(keys.e1(), values.e1()),
        Helpers.mapEntry(keys.e2(), values.e2()),
        Helpers.mapEntry(keys.e3(), values.e3()),
        Helpers.mapEntry(keys.e4(), values.e4()));
  }

  public E e0() {
    return e0;
  }

  public E e1() {

    return new SampleElements<>(
        Helpers.mapEntry(keys.e0(), values.e0()),
        Helpers.mapEntry(keys.e1(), values.e1()),
        Helpers.mapEntry(keys.e2(), values.e2()),
        Helpers.mapEntry(keys.e3(), values.e3()),
        Helpers.mapEntry(keys.e4(), values.e4()));
  }

  public E e0() {
    return e0;
  }

  public E e1() {

    expectContents(Helpers.mapEntry(k1(), v0()));
    assertEquals(k1(), getMap().inverse().get(v0()));
    assertEquals(1, getMap().size());
    assertFalse(getMap().containsKey(k0()));
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(SEVERAL)
  public void testForcePutKeyAndValuePresent() {
    getMap().forcePut(k0(), v1());

  @Override
  public SampleElements<Entry<String, String>> samples() {
    return new SampleElements<>(
        Helpers.mapEntry("one", "January"),
        Helpers.mapEntry("two", "February"),
        Helpers.mapEntry("three", "March"),
        Helpers.mapEntry("four", "April"),
        Helpers.mapEntry("five", "May"));
  }

  @Override
  public SampleElements<String> sampleKeys() {

    super.setUp();
    navigableMap = (SortedMap<K, V>) getMap();
    List<Entry<K, V>> entries =
        Helpers.copyToList(
            getSubjectGenerator()
                .getSampleElements(getSubjectGenerator().getCollectionSize().getNumElements()));
    Collections.sort(entries, Helpers.<K, V>entryComparator(navigableMap.comparator()));

    // some tests assume SEVERAL == 3
    if (entries.size() >= 1) {

                    return new SampleElements<>(
                        Helpers.mapEntry("a", (Collection<String>) ImmutableSortedSet.of("alex")),
                        Helpers.mapEntry(
                            "b", (Collection<String>) ImmutableSortedSet.of("bob", "bagel")),
                        Helpers.mapEntry(
                            "c", (Collection<String>) ImmutableSortedSet.of("carl", "carol")),

  public void setUp() throws Exception {
    super.setUp();
    navigableMap = (NavigableMap<K, V>) getMap();
    entries =
        Helpers.copyToList(
            getSubjectGenerator()
                .getSampleElements(getSubjectGenerator().getCollectionSize().getNumElements()));
    Collections.sort(entries, Helpers.<K, V>entryComparator(navigableMap.comparator()));

    // some tests assume SEVERAL == 3
    if (entries.size() >= 1) {

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

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

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

    List<Entry<K, V>> entries = Helpers.copyToList(multimap().entries());
    for (Entry<K, V> entry : entries) {
      resetContainer();

      K key = entry.getKey();
      V value = entry.getValue();
      Collection<V> collection = multimap().get(key);
      assertNotNull(collection);
      Collection<V> expectedCollection = Helpers.copyToList(collection);

      multimap().remove(key, value);

        throw PermittedMetaException.ISE;
      }
    }

    private List<E> getElements() {
      List<E> elements = new ArrayList<>();
      Helpers.addAll(elements, previousElements);
      Helpers.addAll(elements, Helpers.reverse(nextElements));
      return elements;
    }
  }

  public enum KnownOrder {
    KNOWN_ORDER,
    UNKNOWN_ORDER
  }