resetContainer(mapEntry(k0(), v0()), mapEntry(k0(), v3()));

    Set<Entry<K, Collection<V>>> asMapEntrySet = multimap().asMap().entrySet();
    Collection<V> valueCollection = getOnlyElement(asMapEntrySet).getValue();
    assertContentsAnyOrder(valueCollection, v0(), v3());
    assertTrue(multimap().put(k0(), v4()));
    assertContentsAnyOrder(valueCollection, v0(), v3(), v4());
  }

  @CollectionSize.Require(SEVERAL)

    }
  }

  @CollectionSize.Require(SEVERAL)
  public void testEquals() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k1(), v0()), mapEntry(k0(), v3()));
    Map<K, Collection<V>> expected = new HashMap<>();
    expected.put(k0(), Lists.newArrayList(v0(), v3()));
    expected.put(k1(), Lists.newArrayList(v0()));
    new EqualsTester().addEqualityGroup(expected, multimap().asMap()).testEquals();
  }

    }
  }

  @CollectionSize.Require(SEVERAL)
  public void testEquals() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k1(), v0()), mapEntry(k0(), v3()));
    Map<K, Collection<V>> expected = new HashMap<>();
    expected.put(k0(), Lists.newArrayList(v0(), v3()));
    expected.put(k1(), Lists.newArrayList(v0()));
    new EqualsTester().addEqualityGroup(expected, multimap().asMap()).testEquals();
  }

    }
  }

  @CollectionSize.Require(SEVERAL)
  public void testEquals() {
    resetContainer(mapEntry(k0(), v0()), mapEntry(k1(), v0()), mapEntry(k0(), v3()));
    Map<K, Collection<V>> expected = new HashMap<>();
    expected.put(k0(), newHashSet(v0(), v3()));
    expected.put(k1(), newHashSet(v0()));
    new EqualsTester().addEqualityGroup(expected, multimap().asMap()).testEquals();
  }

  @CollectionSize.Require(SEVERAL)

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testReplace_supportedPresent() {
    try {
      assertEquals(v0(), getMap().replace(k0(), v3()));
      expectReplacement(entry(k0(), v3()));
    } catch (ClassCastException tolerated) { // for ClassToInstanceMap
      expectUnchanged();
    }
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)

    assertFalse(entries.contains(mapEntry(k3(), v3())));
    multimap().put(k3(), v3());
    assertContains(entries, mapEntry(k3(), v3()));
  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutPresentKeyPropagatesToEntries() {
    Collection<Entry<K, V>> entries = multimap().entries();
    assertFalse(entries.contains(mapEntry(k0(), v3())));
    multimap().put(k0(), v3());

    assertFalse(entries.contains(mapEntry(k3(), v3())));
    multimap().put(k3(), v3());
    assertContains(entries, mapEntry(k3(), v3()));
  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutPresentKeyPropagatesToEntries() {
    Collection<Entry<K, V>> entries = multimap().entries();
    assertFalse(entries.contains(mapEntry(k0(), v3())));
    multimap().put(k0(), v3());

    expectAdded(e3());
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testPutIfAbsent_supportedPresent() {
    assertEquals(
        "putIfAbsent(present, value) should return existing value",
        v0(),
        getMap().putIfAbsent(k0(), v3()));
    expectUnchanged();
  }

        v3(),
        getMap()
            .merge(
                getKeyForNullValue(),
                v3(),
                (oldV, newV) -> {
                  throw new AssertionFailedError(
                      "Should not call merge function if key was mapped to null");
                }));
    expectReplacement(entry(getKeyForNullValue(), v3()));
  }

   */
  public static <K, V> ImmutableMap<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3) {
    checkEntryNotNull(k1, v1);
    checkEntryNotNull(k2, v2);
    checkEntryNotNull(k3, v3);
    return RegularImmutableMap.create(3, new Object[] {k1, v1, k2, v2, k3, v3});
  }

  /**
   * Returns an immutable map containing the given entries, in order.
   *