@MapFeature.Require(SUPPORTS_PUT)
  public void testComputeIfAbsent_supportedAbsent() {
    assertEquals(
        "computeIfAbsent(notPresent, function) should return new value",
        v3(),
        getMap()
            .computeIfAbsent(
                k3(),
                k -> {
                  assertEquals(k3(), k);
                  return v3();
                }));

  @MapFeature.Require(SUPPORTS_PUT)
  public void testComputeIfAbsent_supportedAbsent() {
    assertEquals(
        "computeIfAbsent(notPresent, function) should return new value",
        v3(),
        getMap()
            .computeIfAbsent(
                k3(),
                k -> {
                  assertEquals(k3(), k);
                  return v3();
                }));

        n -> {
          cache.asMap().computeIfAbsent(key, k -> "value" + n);
        });
    assertEquals(1, cache.size());
  }

  public void testComputeIfAbsentEviction() {
    // b/80241237

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

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

            return false;
        }

        // Check per-account limit
        if (username != null) {
            AccountAttempts account = accountAttempts.computeIfAbsent(username, k -> new AccountAttempts());
            if (account.isLockedOut()) {
                if (account.getLockoutExpiry().isAfter(Instant.now())) {
                    totalAttemptsBlocked.incrementAndGet();

        vFrom.setCompareScope(scopedVertices);

        List<MetadataGraphEdge> exList = excidentEdges.computeIfAbsent(vFrom, k -> new ArrayList<>());

        if (!exList.contains(e)) {
            exList.add(e);
        }

        List<MetadataGraphEdge> inList = incidentEdges.computeIfAbsent(vTo, k -> new ArrayList<>());

        if (!inList.contains(e)) {
            inList.add(e);
        }

        // use original key
        return parent.replace(key, value);
    }

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

    @Override

        }

        private LongAdder getCounter(BuilderProblem.Severity severity) {
            return counters.computeIfAbsent(severity, k -> new LongAdder());
        }

        private List<P> getProblems(BuilderProblem.Severity severity) {
            return problems.computeIfAbsent(severity, k -> new CopyOnWriteArrayList<>());
        }

     *
     * @see Function
     * @see Optional
     * @see HashMap#computeIfAbsent(Object, Function)
     */
    static UnaryOperator<String> memoize(UnaryOperator<String> callback) {
        Map<String, Optional<String>> cache = new HashMap<>();
        return s -> cache.computeIfAbsent(s, v -> Optional.ofNullable(callback.apply(v)))
                .orElse(null);
    }

            throw uoe();
        }

        @Override
        public V replace(K key, V value) {
            throw uoe();
        }

        @Override
        public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
            throw uoe();
        }

        @Override

        // or DiSNI-specific methods

        if (buffer.isDirect()) {
            // Assign a unique address to each buffer instance
            return bufferAddresses.computeIfAbsent(buffer, b -> addressCounter.getAndIncrement());
        } else {
            throw new IllegalArgumentException("Only direct ByteBuffers are supported for RDMA");
        }
    }

    /**