}

  override fun cacheMiss(call: Call) {
    logWithTime("cacheMiss")

    delegate.cacheMiss(call)
  }

  override fun cacheHit(
    call: Call,
    response: Response,
  ) {
    logWithTime("cacheHit")

    delegate.cacheHit(call, response)
  }

  override fun cacheConditionalHit(
    call: Call,
    cachedResponse: Response,
  ) {

    // If we don't need the network, we're done.
    if (networkRequest == null) {
      return cacheResponse!!.newBuilder()
        .cacheResponse(cacheResponse.stripBody())
        .build().also {
          listener.cacheHit(call, it)
        }
    }

    if (cacheResponse != null) {
      listener.cacheConditionalHit(call, cacheResponse)
    } else if (cache != null) {
      listener.cacheMiss(call)
    }

  ) = logEvent(SatisfactionFailure(System.nanoTime(), call))

  override fun cacheMiss(call: Call) = logEvent(CacheMiss(System.nanoTime(), call))

  override fun cacheHit(
    call: Call,
    response: Response,
  ) = logEvent(CacheHit(System.nanoTime(), call))

  override fun cacheConditionalHit(
    call: Call,
    cachedResponse: Response,
  ) = logEvent(CacheConditionalHit(System.nanoTime(), call))

  override fun satisfactionFailure(
    call: Call,
    response: Response,
  ) {
    logWithTime("satisfactionFailure: $response")
  }

  override fun cacheHit(
    call: Call,
    response: Response,
  ) {
    logWithTime("cacheHit: $response")
  }

  override fun cacheMiss(call: Call) {
    logWithTime("cacheMiss")
  }

  override fun cacheConditionalHit(
    call: Call,

    Thread.sleep(10) // Make sure the timestamps are unique.
    val cacheHit =
      executeSynchronously(
        "/",
        "Accept-Language",
        "en-US",
        "Accept-Charset",
        "UTF-8",
      )

    // Check the merged response. The request is the application's original request.
    cacheHit.assertCode(200)
      .assertBody("A")
      .assertHeaders(

    listener.cacheConditionalHit(call, response)
    listener.cacheHit(call, response)
    listener.cacheMiss(call)
    listener.satisfactionFailure(call, response)
    logRecorder
      .assertLogMatch(Regex("""cacheConditionalHit: Response\{protocol=h2, code=200, message=, url=$url\}"""))
      .assertLogMatch(Regex("""cacheHit: Response\{protocol=h2, code=200, message=, url=$url\}"""))

        .build()

    val client = OkHttpClient.Builder()
        .sslSocketFactory(clientCertificates.sslSocketFactory(), clientCertificates.trustManager)
        .build()
    ```

 *  New: Add `cacheHit`, `cacheMiss`, and `cacheConditionalHit()` events to `EventListener`. Use
    these in logs, metrics, and even test cases to confirm your cache headers are configured as
    expected.

   * Response and normal event sequences will not be received.
   *
   * This event will only be received when a Cache is configured for the client.
   */
  open fun cacheHit(
    call: Call,
    response: Response,
  ) {
  }

  /**
   * Invoked when a response will be served from the network. The Response will be
   * available from normal event sequences.
   *

      .containsExactly("CallStart", "CacheHit", "CallEnd")
  }

  private fun enableCache(): Cache? {
    cache = makeCache()
    client = client.newBuilder().cache(cache).build()
    return cache
  }

  private fun makeCache(): Cache {
    val cacheDir = File.createTempFile("cache-", ".dir")
    cacheDir.delete()
    return Cache(cacheDir, (1024 * 1024).toLong())
  }

### Download

```kotlin
testImplementation("com.squareup.okhttp3:okhttp-dnsoverhttps:4.12.0")
```

### Usage

```
  val appCache = Cache(File("cacheDir", "okhttpcache"), 10 * 1024 * 1024)
  val bootstrapClient = OkHttpClient.Builder().cache(appCache).build()

  val dns = DnsOverHttps.Builder().client(bootstrapClient)
    .url("https://dns.google/dns-query".toHttpUrl())