new EqualsTester().addEqualityGroup(expected, multimap().asMap().entrySet()).testEquals();
  }

  @CollectionSize.Require(SEVERAL)
  @MapFeature.Require(SUPPORTS_REMOVE)
  /*
   * SetMultimap.asMap essentially returns a Map<K, Set<V>>; we just can't declare it that way.
   * Thus, calls like asMap().values().remove(someSet) are safe because they are comparing a set to
   * a collection of other sets.
   */

    Collection<V> result = multimap().asMap().get(k0());
    assertTrue(result.remove(v0()));
    assertFalse(multimap().containsEntry(k0(), v0()));
    assertEquals(2, multimap().size());
  }

  @CollectionSize.Require(absent = ZERO)
  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testPropagatesRemoveLastElementToMultimap() {
    Collection<V> result = multimap().asMap().get(k0());
    assertTrue(result.remove(v0()));

  public void testAsMapGetNullKeyPresent() {
    initMultimapWithNullKey();
    assertContentsAnyOrder(multimap().asMap().get(null), getValueForNullKey());
  }

  @MapFeature.Require(ALLOWS_NULL_KEY_QUERIES)
  public void testAsMapGetNullKeyAbsent() {
    assertNull(multimap().asMap().get(null));
  }

  @MapFeature.Require(absent = ALLOWS_NULL_KEY_QUERIES)
  public void testAsMapGetNullKeyUnsupported() {

  public void testAsMapGetNullKeyPresent() {
    initMultimapWithNullKey();
    assertContentsAnyOrder(multimap().asMap().get(null), getValueForNullKey());
  }

  @MapFeature.Require(ALLOWS_NULL_KEY_QUERIES)
  public void testAsMapGetNullKeyAbsent() {
    assertNull(multimap().asMap().get(null));
  }

  @MapFeature.Require(absent = ALLOWS_NULL_KEY_QUERIES)
  public void testAsMapGetNullKeyUnsupported() {

      Collection<V> collection = multimap().asMap().get(key);
      if (collection != null) {
        multimap().clear();
        assertEmpty(collection);
      }
    }
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testClearPropagatesToAsMap() {
    Map<K, Collection<V>> asMap = multimap().asMap();
    multimap().clear();
    assertEmpty(asMap);
  }

  @MapFeature.Require(SUPPORTS_REMOVE)

    assertThat(c.asMap().computeIfAbsent("hash-1", k -> "")).isEqualTo("");
    assertThat(c.size()).isEqualTo(1);
    assertThat(c.asMap().computeIfAbsent("hash-2", k -> "")).isEqualTo("");
  }

  public void testComputeEviction() {
    // b/80241237

    Cache<String, String> c = CacheBuilder.newBuilder().maximumSize(1).build();

    assertThat(c.asMap().compute("hash-1", (k, v) -> "a")).isEqualTo("a");

    // 1 won't be cached
    assertThat(cache.getUnchecked(1)).isEqualTo(1);
    assertThat(cache.asMap().keySet()).isEmpty();

    CacheTesting.processPendingNotifications(cache);
    assertThat(removalListener.getCount()).isEqualTo(1);

    // 2 will be cached
    assertThat(cache.getUnchecked(2)).isEqualTo(2);
    assertThat(cache.asMap().keySet()).containsExactly(2);

    CacheTesting.processPendingNotifications(cache);

      Collection<V> collection = multimap().asMap().get(key);
      if (collection != null) {
        multimap().clear();
        assertEmpty(collection);
      }
    }
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testClearPropagatesToAsMap() {
    Map<K, Collection<V>> asMap = multimap().asMap();
    multimap().clear();
    assertEmpty(asMap);
  }

  @MapFeature.Require(SUPPORTS_REMOVE)

      try {
        multimap.asMap().get(presentKey).remove(sampleValue);
        fail("asMap().get().remove() succeeded on unmodifiable multimap");
      } catch (UnsupportedOperationException expected) {
      }
      assertMultimapRemainsUnmodified(multimap, originalEntries);

      try {
        multimap.asMap().values().iterator().next().remove(sampleValue);

    assertEquals(1, Iterators.size(cache.asMap().entrySet().iterator()));
    assertEquals(1, Iterators.size(cache.asMap().keySet().iterator()));
    assertEquals(1, Iterators.size(cache.asMap().values().iterator()));

    CacheTesting.expireEntries((LoadingCache<?, ?>) cache, EXPIRING_TIME, ticker);

    for (int i = 0; i < 11; i++) {
      assertFalse(cache.asMap().containsKey(KEY_PREFIX + i));
    }