*
   * This can be invoked more than 1 time for a single [Call]. For example, if the response
   * to the [Call.request] is a redirect to a different address.
   */
  open fun connectionAcquired(
    call: Call,
    connection: Connection,
  ) {
  }

  /**
   * Invoked after a connection has been released for the `call`.
   *

     */
    open fun addHeader(
      name: String,
      value: String,
    ) = commonAddHeader(name, value)

    /** Removes all headers named [name] on this builder. */
    open fun removeHeader(name: String) = commonRemoveHeader(name)

    /** Removes all headers on this builder and adds [headers]. */
    open fun headers(headers: Headers) = commonHeaders(headers)

    val client =
      OkHttpClient.Builder()
        .connectionPool(poolApi)
        .build()
    val call = client.newCall(Request(addressA.url)) as RealCall
    call.enterNetworkInterceptorExchange(call.request(), true, factory.newChain(call))
    c1.withLock { call.acquireConnectionNoEvents(c1) }

    // Running at time 50, the pool returns that nothing can be evicted until time 150.

        override fun requestHeadersEnd(
          call: Call,
          request: Request,
        ) = TODO()

        override fun requestBodyStart(call: Call) = TODO()

        override fun requestBodyEnd(
          call: Call,
          byteCount: Long,
        ) = TODO()

        override fun requestFailed(
          call: Call,
          ioe: IOException,

    hostname: String,
    networkRequests: List<Call>,
    responses: MutableList<InetAddress>,
    failures: MutableList<Exception>,
  ) {
    val latch = CountDownLatch(networkRequests.size)

    for (call in networkRequests) {
      call.enqueue(
        object : Callback {
          override fun onFailure(
            call: Call,
            e: IOException,
          ) {

    // rogue CA is trusted) but it should fail certificate pinning.
    val request =
      Request.Builder()
        .url(server.url("/"))
        .build()
    val call = client.newCall(request)
    assertFailsWith<SSLPeerUnverifiedException> {
      call.execute()
    }.also { expected ->
      // Certificate pinning fails!
      assertThat(expected.message!!).startsWith("Certificate pinning failure!")
    }
  }

        it.proceed(it.request())
      }
      .build()
  }

  private fun makeRequest(client: OkHttpClient): Handshake {
    val call = client.newCall(Request(server.url("/")))
    return call.execute().use { it.handshake!! }
  }

        body = "/a has moved!",
      ),
    )
    server.enqueue(
      MockResponse(body = "/b is here"),
    )
    val request = Request(server.url("/"))
    val call = client.newCall(request)
    call.execute().use { response ->
      assertThat(
        response.body.string(),
      ).isEqualTo("unrelated response body!")
    }
    assertThat(server.takeRequest().sequenceNumber).isEqualTo(0)

    assertThat(original.interceptors.size).isEqualTo(0)
    assertThat(original.networkInterceptors.size).isEqualTo(0)
  }

  /**
   * When copying the client, stateful things like the connection pool are shared across all
   * clients.
   */
  @Test fun cloneSharesStatefulInstances() {
    val client = clientTestRule.newClient()

    // Values should be non-null.
    val a = client.newBuilder().build()

        if (index != -1) { // Index -1 == new header.
          delta -= dynamicTable[dynamicTableIndex(index)]!!.hpackSize
        }

        // if the new or replacement header is too big, drop all entries.
        if (delta > maxDynamicTableByteCount) {
          clearDynamicTable()
          return
        }

        // Evict headers to the required length.