.trailersDelay(1, TimeUnit.SECONDS)
        .build(),
    )

    val call = client.newCall(Request(server.url("/")))
    call.execute().use { response ->
      val source = response.body.source()
      assertThat(response.header("h1")).isEqualTo("v1")
      assertThat(source.readUtf8(5)).isEqualTo("Hello")
      call.cancelLater(500.milliseconds)
      val trailersDelay =
        measureTime {

  @ValueSource(booleans = [true, false])
  fun successfulCallEventSequence() {
    server!!.enqueue(MockResponse(body = "abc"))
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server!!.url("/"))
          .build(),
      )
    val response = call.execute()
    assertThat(response.code).isEqualTo(200)
    assertThat(response.body.string()).isEqualTo("abc")
    response.body.close()

        .setSocketPolicy(SocketPolicy.STALL_SOCKET_AT_START),
    )
    server.start()
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )
    call.enqueue(
      object : Callback {
        override fun onFailure(
          call: Call,
          e: okio.IOException,
        ) {
          callFailure.complete(e)
        }

 * (unless there are {@link Double#NaN NaN} values, see below); otherwise, the result is the average
 * of the values which would appear at the indexes floor(x) and ceil(x) weighted by (1-frac(x)) and
 * frac(x) respectively. This is the same definition as used by Excel and by S, it is the Type 7
 * definition in <a

          call: Call,
          e: IOException,
        ) {
          latch.countDown()
        }

        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          fail("")
        }
      },
    )
    assertThat(server.takeRequest().exchangeIndex)
      .isEqualTo(expectedSequenceNumber)
    responseDequeuedLatch!!.await()
    call.cancel()

        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,

   * {@code map} and the instances generated by {@code factory} are. Concurrent read operations will
   * work correctly. To allow concurrent update operations, wrap the multimap with a call to {@link
   * #synchronizedMultimap}.
   *
   * <p>Call this method only when the simpler methods {@link ArrayListMultimap#create()}, {@link
   * HashMultimap#create()}, {@link LinkedHashMultimap#create()}, {@link

   * {@code map} and the instances generated by {@code factory} are. Concurrent read operations will
   * work correctly. To allow concurrent update operations, wrap the multimap with a call to {@link
   * #synchronizedMultimap}.
   *
   * <p>Call this method only when the simpler methods {@link ArrayListMultimap#create()}, {@link
   * HashMultimap#create()}, {@link LinkedHashMultimap#create()}, {@link

    Route(
      address = address,
      proxy = proxy,
      socketAddress = socketAddress,
    )

  fun newChain(call: RealCall): RealInterceptorChain =
    RealInterceptorChain(
      call = call,
      interceptors = listOf(),
      index = 0,
      exchange = null,
      request = call.request(),
      connectTimeoutMillis = 10_000,
      readTimeoutMillis = 10_000,
      writeTimeoutMillis = 10_000,
    )

      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          continuation.resumeWithException(e)
        }

        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          continuation.resume(response) { _, value, _ ->
            value.closeQuietly()
          }
        }
      },
    )