doParallelCacheOp(count, n -> cache.asMap().computeIfAbsent(key, k -> "value" + n));
    assertThat(cache.size()).isEqualTo(1);
  }

  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("");

  @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();
                }));

   * [computeIfAbsent] implementation. No locks are held while calling this function.
   */
  fun <T : Any> tag(
    type: KClass<T>,
    computeIfAbsent: () -> T,
  ): T

  /**
   * Returns the tag attached with [type] as a key. If it is absent, then [computeIfAbsent] is
   * called and that value is both inserted and returned.
   *

    fun <T : Any?> executeQuery(apiSourceFile: ApiSourceFile.Java, query: JavaSourceQuery<T>): T =
        openJavaCompilationUnitsByFile
            .computeIfAbsent(apiSourceFile.currentFile) { JavaParser().parse(it).getResult().get() }
            .accept(query.visitor, null)
            ?: query.defaultValue

  override fun <T> tag(type: Class<out T>): T? = error("unexpected")

  override fun <T : Any> tag(
    type: KClass<T>,
    computeIfAbsent: () -> T,
  ): T = error("unexpected")

  override fun <T : Any> tag(
    type: Class<T>,
    computeIfAbsent: () -> T,
  ): T = error("unexpected")

  override fun clone(): Call = error("unexpected")

    public List<MavenProject> getDownstreamProjects(MavenProject project, boolean transitive) {
        Key key = new Key(project, transitive, false);
        // Do not use computeIfAbsent here, as the computation is recursive
        // and this is not supported by computeIfAbsent.
        List<MavenProject> list = cache.get(key);
        if (list == null) {

  override fun <T : Any> tag(
    type: KClass<T>,
    computeIfAbsent: () -> T,
  ): T = tags.computeIfAbsent(type, computeIfAbsent)

  override fun <T : Any> tag(
    type: Class<T>,
    computeIfAbsent: () -> T,
  ): T = tags.computeIfAbsent(type.kotlin, computeIfAbsent)

  @SuppressWarnings("CloneDoesntCallSuperClone") // We are a final type & this saves clearing state.

    val tags = EmptyTags
    val atomicTags = AtomicReference<Tags>(tags)
    val result =
      atomicTags.computeIfAbsent(String::class) {
        // 'Race' by making another computeIfAbsent call. In practice this would be another thread.
        assertThat(atomicTags.computeIfAbsent(Integer::class) { 5 as Integer }).isEqualTo(5)
        "a"
      }
    assertThat(result).isEqualTo("a")

        }
        return plural;
    }

    private void recordString(String path, String value) {
        pathStats
                .computeIfAbsent(path, k -> new HashMap<>())
                .computeIfAbsent(value, k -> new StringStats())
                .recordOccurrence(value);
    }

    List<PathAnalysis> getPathAnalysisSorted() {

        Long existingWeight = projectWeights.get(project);
        if (existingWeight != null) {
            return existingWeight;
        }

        // Calculate weight without using computeIfAbsent to avoid recursive update issues
        long weight = calculateWeight(project);

        // Use putIfAbsent to handle concurrent access safely
        Long previousWeight = projectWeights.putIfAbsent(project, weight);