@MapFeature.Require(SUPPORTS_PUT)
  public void testComputeIfPresent_supportedAbsent() {
    assertNull(
        "computeIfPresent(notPresent, function) should return null",
        getMap()
            .computeIfPresent(
                k3(),
                (k, v) -> {
                  throw new AssertionFailedError();
                }));
    expectUnchanged();
  }

  @MapFeature.Require(SUPPORTS_PUT)
  public void testComputeIfPresent_supportedAbsent() {
    assertNull(
        "computeIfPresent(notPresent, function) should return null",
        getMap()
            .computeIfPresent(
                k3(),
                (k, v) -> {
                  throw new AssertionFailedError();
                }));
    expectUnchanged();
  }

            .build();
    cache.put(1, 2);

    // explicitly remove the existing value
    cache.asMap().computeIfPresent(1, (key, value) -> null);
    assertThat(notifications).hasSize(1);
    CacheTesting.checkEmpty(cache);

    // ensure no zombie entry remains
    cache.asMap().computeIfPresent(1, (key, value) -> null);
    assertThat(notifications).hasSize(1);
    CacheTesting.checkEmpty(cache);
  }

        // use original key
        return parent.computeIfAbsent(key, mappingFunction);
    }

    @Override
    public V computeIfPresent(final K key, final BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
        // use original key
        return parent.computeIfPresent(key, remappingFunction);
    }

    @Override

    @SuppressWarnings("nullness") // TODO: b/423853632 - Remove after checker is fixed.
    @Override
    public @Nullable V computeIfPresent(
        K key, BiFunction<? super K, ? super @NonNull V, ? extends @Nullable V> remappingFunction) {
      synchronized (mutex) {
        return delegate().computeIfPresent(key, remappingFunction);
      }
    }

    @Override
    public @Nullable V compute(
        K key,

    assertThrows(
        UnsupportedOperationException.class, () -> unmod.computeIfAbsent(3, k -> k + "three"));
    assertThrows(UnsupportedOperationException.class, () -> unmod.computeIfPresent(4, (k, v) -> v));
    assertThrows(UnsupportedOperationException.class, () -> unmod.compute(4, (k, v) -> v));
    assertThrows(UnsupportedOperationException.class, () -> unmod.merge(4, "four", (k, v) -> v));

        K key, java.util.function.Function<? super K, ? extends V> mappingFunction) {
      throw new UnsupportedOperationException();
    }

    @Override
    public @Nullable V computeIfPresent(
        K key, BiFunction<? super K, ? super @NonNull V, ? extends @Nullable V> remappingFunction) {
      throw new UnsupportedOperationException();
    }

    @Override
    public @Nullable V compute(

    checkNotNull(key);
    checkNotNull(function);
    return compute(key, (k, oldValue) -> (oldValue == null) ? function.apply(key) : oldValue);
  }

  @Override
  public @Nullable V computeIfPresent(
      K key, BiFunction<? super K, ? super V, ? extends @Nullable V> function) {
    checkNotNull(key);
    checkNotNull(function);