@Nullable V getIfCached(@Nullable Object key) {
    Entry<K, V> entry = cacheEntry; // store local reference for thread-safety

    // Check cache. We use == on purpose because it's cheaper and a cache miss is ok.
    if (entry != null && entry.getKey() == key) {
      return entry.getValue();
    }
    return null;
  }

  void clearCache() {
    cacheEntry = null;
  }

        } else {
            trackingDir = event.getFile().getParentFile().toPath().resolve(".tracking");
        }

        String baseName;
        String ext = missing ? ".miss" : ".dep";
        Path trackingFile = null;

        StringBuilder indent = new StringBuilder();
        ArrayList<String> trackingData = new ArrayList<>();

        if (collectStepTrace == null && plugin != null) {

  private fun testRequestMethod(
    requestMethod: String,
    expectCached: Boolean,
    withOverride: Boolean = false,
  ) {
    // 1. Seed the cache (potentially).
    // 2. Expect a cache hit or miss.
    server.enqueue(
      MockResponse
        .Builder()
        .addHeader("Expires: " + formatDate(1, TimeUnit.HOURS))
        .addHeader("X-Response-ID: 1")
        .build(),
    )

        }

        if (cacheEntry == null) {
            try {
                cacheEntry = methodMap.find(name, params);
            } catch (MethodMap.AmbiguousException ae) {
                // that's a miss :)
                methodCache.put(methodKey, CACHE_MISS);
                throw ae;
            }

            if (cacheEntry == null) {
                methodCache.put(methodKey, CACHE_MISS);
            } else {

        return cacheWritingResponse(cacheRequest, response).also {
          if (cacheResponse != null) {
            // This will log a conditional cache miss only.
            call.eventListener.cacheMiss(call)
          }
        }
      }

      if (HttpMethod.invalidatesCache(networkRequest.method)) {
        try {
          cache.remove(networkRequest)

        else -> JavaNetSocket(route.proxy)
      }
    this.rawSocket = rawSocket

    // Handle the race where cancel() precedes connectSocket(). We don't want to miss a cancel.
    if (canceled) {
      throw IOException("canceled")
    }

    rawSocket.soTimeout = socketReadTimeoutMillis
    try {

    return (totalLoadCount == 0) ? 0.0 : (double) loadExceptionCount / totalLoadCount;
  }

  /**
   * Returns the total number of nanoseconds the cache has spent loading new values. This can be
   * used to calculate the miss penalty. This value is increased every time {@code loadSuccessCount}
   * or {@code loadExceptionCount} is incremented.
   */
  @SuppressWarnings("GoodTime") // should return a java.time.Duration

    return (totalLoadCount == 0) ? 0.0 : (double) loadExceptionCount / totalLoadCount;
  }

  /**
   * Returns the total number of nanoseconds the cache has spent loading new values. This can be
   * used to calculate the miss penalty. This value is increased every time {@code loadSuccessCount}
   * or {@code loadExceptionCount} is incremented.
   */
  @SuppressWarnings("GoodTime") // should return a java.time.Duration

    abstract String atomicHelperTypeForTest();
  }

  /**
   * {@link AtomicHelper} based on {@link sun.misc.Unsafe}.
   *
   * <p>Static initialization of this class will fail if the {@link sun.misc.Unsafe} object cannot
   * be accessed.
   */
  @SuppressWarnings("SunApi") // b/345822163
  private static final class UnsafeAtomicHelper extends AtomicHelper {

    @Override
    String atomicHelperTypeForTest() {
      return "VarHandleAtomicHelper";
    }
  }

  /**
   * {@link AtomicHelper} based on {@link sun.misc.Unsafe}.
   *
   * <p>Static initialization of this class will fail if the {@link sun.misc.Unsafe} object cannot
   * be accessed.
   */
  @SuppressWarnings("SunApi") // b/345822163
  private static final class UnsafeAtomicHelper extends AtomicHelper {