v3(),
        getMap()
            .compute(
                k3(),
                (k, v) -> {
                  assertEquals(k3(), k);
                  assertNull(v);
                  return v3();
                }));
    expectAdded(e3());
    assertEquals(getNumElements() + 1, getMap().size());
  }

  @MapFeature.Require({SUPPORTS_PUT, SUPPORTS_REMOVE})

    public int compare(Entry<K, V> a, Entry<K, V> b) {
      return (keyComparator == null)
          ? ((Comparable) a.getKey()).compareTo(b.getKey())
          : keyComparator.compare(a.getKey(), b.getKey());
    }
  }

  public static <K extends @Nullable Object, V extends @Nullable Object>

        return ImmutableMap.<K, V>of(entry.getKey(), entry.getValue());
      default:
        Map<K, V> orderPreservingCopy = Maps.newLinkedHashMap();
        for (Entry<? extends K, ? extends V> e : map.entrySet()) {
          orderPreservingCopy.put(checkNotNull(e.getKey()), checkNotNull(e.getValue()));
        }
        return new RegularImmutableMap<K, V>(orderPreservingCopy);

public class ConcurrentMapReplaceTester<K, V> extends AbstractMapTester<K, V> {
  @Override
  protected ConcurrentMap<K, V> getMap() {
    return (ConcurrentMap<K, V>) super.getMap();
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testReplace_supportedPresent() {
    assertEquals(v0(), getMap().replace(k0(), v3()));
    expectReplacement(entry(k0(), v3()));
  }

  @MapFeature.Require(SUPPORTS_PUT)

        final String servletPath = req.getServletPath();
        for (final Map.Entry<String, String> entry : encodingMap.entrySet()) {
            final String path = entry.getKey();
            if (servletPath.startsWith(path)) {
                req.setCharacterEncoding(entry.getValue());
                final StringBuilder locationBuf = new StringBuilder(1000);

  public void testClearClearsInverse() {
    BiMap<V, K> inv = getMap().inverse();
    getMap().clear();
    assertTrue(getMap().isEmpty());
    assertTrue(inv.isEmpty());
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testKeySetClearClearsInverse() {
    BiMap<V, K> inv = getMap().inverse();
    getMap().keySet().clear();
    assertTrue(getMap().isEmpty());
    assertTrue(inv.isEmpty());
  }

  public void testClearClearsInverse() {
    BiMap<V, K> inv = getMap().inverse();
    getMap().clear();
    assertTrue(getMap().isEmpty());
    assertTrue(inv.isEmpty());
  }

  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testKeySetClearClearsInverse() {
    BiMap<V, K> inv = getMap().inverse();
    getMap().keySet().clear();
    assertTrue(getMap().isEmpty());
    assertTrue(inv.isEmpty());
  }

  @CollectionSize.Require(absent = ZERO)
  public void testRemove_present() {
    int initialSize = getMap().size();
    assertEquals("remove(present) should return the associated value", v0(), getMap().remove(k0()));
    assertEquals(
        "remove(present) should decrease a map's size by one.", initialSize - 1, getMap().size());
    expectMissing(e0());
  }

public class MapClearTester<K, V> extends AbstractMapTester<K, V> {
  @MapFeature.Require(SUPPORTS_REMOVE)
  public void testClear() {
    getMap().clear();
    assertTrue("After clear(), a map should be empty.", getMap().isEmpty());
    assertEquals(0, getMap().size());
    assertFalse(getMap().entrySet().iterator().hasNext());
  }

  @MapFeature.Require({FAILS_FAST_ON_CONCURRENT_MODIFICATION, SUPPORTS_REMOVE})

  @Override
  protected ConcurrentMap<K, V> getMap() {
    return (ConcurrentMap<K, V>) super.getMap();
  }

  @MapFeature.Require(SUPPORTS_PUT)
  @CollectionSize.Require(absent = ZERO)
  public void testReplaceEntry_supportedPresent() {
    assertTrue(getMap().replace(k0(), v0(), v3()));
    expectReplacement(entry(k0(), v3()));
  }