assertThrows(UnsupportedOperationException.class, () -> multimap().put(k3(), v3()));
  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testPutEmpty() {
    int size = getNumElements();

    assertGet(k3(), ImmutableList.<V>of());

    assertTrue(multimap().put(k3(), v3()));

    assertGet(k3(), v3());
    assertEquals(size + 1, multimap().size());
  }

  @MapFeature.Require(SUPPORTS_PUT)

  }

  @CollectionSize.Require(absent = CollectionSize.ZERO)
  public void testEquals_otherMapWithDifferentEntries() {
    Map<K, V> other = newHashMap(getSampleEntries(getNumEntries() - 1));
    other.put(k3(), v3());
    assertFalse(
        "A Map should not equal another Map containing different entries.", getMap().equals(other));
  }

  @CollectionSize.Require(absent = CollectionSize.ZERO)

    assertEquals(
        "computeIfAbsent(notPresent, function) should return new value",
        v3(),
        getMap()
            .computeIfAbsent(
                k3(),
                k -> {
                  assertEquals(k3(), k);
                  return v3();
                }));
    expectAdded(e3());
  }

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

  @CollectionSize.Require(absent = ZERO)
  public void testContainsEntryYes() {
    assertTrue(multimap().containsEntry(k0(), v0()));
  }

  public void testContainsEntryNo() {
    assertFalse(multimap().containsEntry(k3(), v3()));
  }

  public void testContainsEntryAgreesWithGet() {
    for (K k : sampleKeys()) {
      for (V v : sampleValues()) {
        assertEquals(multimap().get(k).contains(v), multimap().containsEntry(k, v));

      K k1, V v1, K k2, V v2, K k3, V v3) {
    return new Builder<K, V>(Ordering.natural()).put(k1, v1).put(k2, v2).put(k3, v3).build();
  }

  public static <K extends Comparable<? super K>, V> ImmutableSortedMap<K, V> of(
      K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
    return new Builder<K, V>(Ordering.natural())
        .put(k1, v1)
        .put(k2, v2)
        .put(k3, v3)
        .put(k4, v4)

  @CollectionSize.Require(absent = ZERO)
  public void testContainsEntryYes() {
    assertTrue(multimap().containsEntry(k0(), v0()));
  }

  public void testContainsEntryNo() {
    assertFalse(multimap().containsEntry(k3(), v3()));
  }

  public void testContainsEntryAgreesWithGet() {
    for (K k : sampleKeys()) {
      for (V v : sampleValues()) {
        assertEquals(multimap().get(k).contains(v), multimap().containsEntry(k, v));

  public void testGet_yes() {
    assertEquals("get(present) should return the associated value", v0(), get(k0()));
  }

  public void testGet_no() {
    assertNull("get(notPresent) should return null", get(k3()));
  }

  @MapFeature.Require(ALLOWS_NULL_KEY_QUERIES)
  public void testGet_nullNotContainedButAllowed() {
    assertNull("get(null) should return null", get(null));
  }

    assertTrue("containsKey(present) should return true", getMap().containsKey(k0()));
  }

  public void testContains_no() {
    assertFalse("containsKey(notPresent) should return false", getMap().containsKey(k3()));
  }

  @MapFeature.Require(ALLOWS_NULL_KEY_QUERIES)
  public void testContains_nullNotContainedButAllowed() {
    assertFalse("containsKey(null) should return false", getMap().containsKey(null));
  }

    try {
      assertFalse(getMap().replace(k3(), v3(), null));
    } catch (NullPointerException tolerated) {
      // the operation would be a no-op, so exceptions are allowed but not required
    }
    expectUnchanged();
  }

  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUE_QUERIES})
  public void testReplaceEntry_nullDifferentFromAbsent() {
    assertFalse(getMap().replace(k3(), null, v3()));
    expectUnchanged();
  }

    try {
      assertFalse(getMap().replace(k3(), v3(), null));
    } catch (NullPointerException tolerated) {
      // the operation would be a no-op, so exceptions are allowed but not required
    }
    expectUnchanged();
  }

  @MapFeature.Require({SUPPORTS_PUT, ALLOWS_NULL_VALUE_QUERIES})
  public void testReplaceEntry_nullDifferentFromAbsent() {
    assertFalse(getMap().replace(k3(), null, v3()));
    expectUnchanged();
  }