cache =
      DiskLruCache(filesystem, cacheDir, appVersion, 2, maxSize.toLong(), taskRunner).also {
        toClose.add(it)
      }
    synchronized(cache) { cache.initialize() }
  }

  @BeforeEach
  fun setUp() {
    if (filesystem.exists(cacheDir)) {
      filesystem.deleteRecursively(cacheDir)
    }
    journalFile = cacheDir / DiskLruCache.JOURNAL_FILE
    journalBkpFile = cacheDir / DiskLruCache.JOURNAL_FILE_BACKUP

class AndroidHttpEngineTest {
  val context = InstrumentationRegistry.getInstrumentation().context

  val cacheDir =
    context.cacheDir.resolve("httpEngine").also {
      it.mkdirs()
    }
  val engine =
    HttpEngine
      .Builder(context)
      .setEnableBrotli(true)
      .setStoragePath(cacheDir.path)
      .setEnableHttpCache(HttpEngine.Builder.HTTP_CACHE_DISK, 10_000_000)
      .setConnectionMigrationOptions(

### Download

```kotlin
testImplementation("com.squareup.okhttp3:okhttp-dnsoverhttps:5.3.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())

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

  private fun OkHttpClient.newCallWithListener(request: Request): Call =
    newCall(request)
      .apply {

    server.enqueue(MockResponse(body = "abc"))

    val ctxt = InstrumentationRegistry.getInstrumentation().targetContext.applicationContext

    val cacheSize = 1L * 1024 * 1024 // 1MB
    val cache = Cache(ctxt.cacheDir.resolve("testCache"), cacheSize)

    try {
      client =
        client
          .newBuilder()
          .cache(cache)
          .build()

      val request =
        Request

 *
 * ```java
 * // The singleton HTTP client.
 * public final OkHttpClient client = new OkHttpClient.Builder()
 *     .addInterceptor(new HttpLoggingInterceptor())
 *     .cache(new Cache(cacheDir, cacheSize))
 *     .build();
 * ```
 *
 * ## Customize Your Client With newBuilder()
 *
 * You can customize a shared OkHttpClient instance with [newBuilder]. This builds a client that

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

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

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

  override fun cacheConditionalHit(
    call: Call,
    cachedResponse: Response,
  ) = onEvent(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,

    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\}"""))

  ) {
    logWithTime("satisfactionFailure")
  }

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

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

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