assertThat(get(url).body.string()).isEqualTo("B")
    assertThat(server.takeRequest().headers["If-None-Match"]).isNull()
    assertThat(server.takeRequest().headers["If-None-Match"]).isEqualTo("v1")
    assertThat(server.takeRequest().headers["If-None-Match"]).isEqualTo("v1")
    assertThat(server.takeRequest().headers["If-None-Match"]).isEqualTo("v2")
  }

  @Test
  fun combinedCacheHeadersCanBeNonAscii() {

      // will not be transmitted.
      val conditionName: String
      val conditionValue: String?
      when {
        etag != null -> {
          conditionName = "If-None-Match"
          conditionValue = etag
        }

        lastModified != null -> {
          conditionName = "If-Modified-Since"
          conditionValue = lastModifiedString
        }

     * both say in their comments that they're not really sure what the right approach is. We go
     * with Chrome's behavior (which also experimentally seems to match what IE does), but if you
     * actually want to have a good chance of things working, please avoid double-quotes, newlines,
     * percent signs, and the like in your field names.
     */

        fail("Encoding $component $codePoint using $encoding")
      }
      return
    }

    // If the URI has more escaping than the HttpURL, check that the decoded values still match.
    val uriEscaped = uriEscapedCodePoints.indexOf(codePointString) != -1
    if (uriEscaped) {
      if (uri.toString() == httpUrl.toString()) {
        fail("Encoding $component $codePoint using $encoding")
      }

          }

          try {
            trimToSize()
          } catch (_: IOException) {
            mostRecentTrimFailed = true
          }

          try {
            if (journalRebuildRequired()) {
              rebuildJournal()
              redundantOpCount = 0
            }
          } catch (_: IOException) {
            mostRecentRebuildFailed = true

    assertThat(cookie.matches("http://www.example.com".toHttpUrl())).isTrue()
    assertThat(cookie.matches("http://square.com".toHttpUrl())).isFalse()
  }

  /** If no domain is present, match only the origin domain.  */
  @Test fun domainMatchesNoDomain() {
    val cookie = parse(url, "a=b")
    assertThat(cookie!!.matches("http://example.com".toHttpUrl())).isTrue()

 *  **Fix: Disable ALPN on Android 4.4.** That release of the feature was
    unstable and prone to native crashes in the underlying OpenSSL code.
 *  Fix: Don't send both `If-None-Match` and `If-Modified-Since` cache headers
    when both are applicable.
 *  Fix: Fail early when a port is out of range.
 *  Fix: Offer `Content-Length` headers for multipart request bodies.

        ) {
          exceptionRef.set(e)
          latch.countDown()
        }

        @Throws(IOException::class)
        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          response.close()
          latch.countDown()
        }
      },
    )
    latch.await()
    assertThat(call.isCanceled()).isTrue()

    var exception: Exception? = null
    val latch = CountDownLatch(1)

    // assumes an IPv4 address
    AndroidAsyncDns.IPv4.query(
      hostname,
      object : AsyncDns.Callback {
        override fun onResponse(
          hostname: String,
          addresses: List<InetAddress>,
        ) {
          allAddresses.addAll(addresses)
          latch.countDown()
        }

    )
    server.enqueue(MockResponse(body = "ABC"))
    val latch = CountDownLatch(1)
    val responses: BlockingQueue<String?> = SynchronousQueue()
    val authenticator =
      okhttp3.Authenticator { route: Route?, response: Response? ->
        responses.offer(response!!.body.string())
        try {
          latch.await()
        } catch (e: InterruptedException) {
          throw AssertionError()
        }