MockResponse(body = "GHI"),
    )
    val call1 = client.newCall(Request(server.url("/")))
    val response1 = call1.execute()
    val call2 = client.newCall(Request(server.url("/")))
    val response2 = call2.execute()
    val call3 = client.newCall(Request(server.url("/")))
    val response3 = call3.execute()
    assertThat(response1.body.string()).isEqualTo("ABC")
    assertThat(response2.body.string()).isEqualTo("DEF")

              val responseA = client.newCall(requestA).execute()
              assertThat(responseA.body.string()).isEqualTo("a")
            }
            chain.proceed(chain.request())
          },
        )
        .build()
    val requestB =
      Request.Builder()
        .url(server.url("/b"))
        .build()
    val responseB = client.newCall(requestB).execute()
    assertThat(responseB.body.string()).isEqualTo("b")

  fun cancel()

  /**
   * Returns true if this call has been either [executed][execute] or [enqueued][enqueue]. It is an
   * error to execute a call more than once.
   */
  fun isExecuted(): Boolean

  fun isCanceled(): Boolean

  /**
   * Returns a timeout that spans the entire call: resolving DNS, connecting, writing the request

    }
  }

  /**
   * Returns an immediately-executable task for the calling thread to execute, sleeping as necessary
   * until one is ready. If there are no ready queues, or if other threads have everything under
   * control this will return null. If there is more than a single task ready to execute immediately
   * this will start another thread to handle that work.
   */
  fun awaitTaskToRun(): Task? {

      MockResponse(body = "unexpected call to IPv4"),
    )
    serverIpv6.enqueue(
      MockResponse(body = "hello from IPv6"),
    )

    val call = client.newCall(Request(url))
    val response = call.execute()
    assertThat(response.body.string()).isEqualTo("hello from IPv6")

    // In the process we made one successful connection attempt.
    assertThat(listener.recordedEventTypes().filter { it == "ConnectStart" }).hasSize(1)

   * was run [asynchronously][Call.enqueue] or [synchronously][Call.execute]. Asynchronous calls
   * become idle after the [onResponse][Callback.onResponse] or [onFailure][Callback.onFailure]
   * callback has returned. Synchronous calls become idle once [execute()][Call.execute] returns.
   * This means that if you are doing synchronous calls the network layer will not truly be idle

        .build()
    val request1 = Request.Builder().url(server.url("/")).build()
    val response1 = client.newCall(request1).execute()
    assertThat(response1.body.string()).isEqualTo("abc")
    val request2 = Request.Builder().url(server.url("/")).build()
    val response2 = client.newCall(request2).execute()
    assertThat(response2.body.string()).isEqualTo("def")

    // The HTTP calls should share a single connection.

    client.newCall(
      Request.Builder()
        .url(server.url("/"))
        .build(),
    ).execute().close()
    listener.removeUpToEvent<CallEnd>()
    val call =
      client.newCall(
        Request.Builder()
          .url(server.url("/"))
          .build(),
      )
    val response = call.execute()
    response.close()
    assertThat(listener.recordedEventTypes()).containsExactly(
      "CallStart",

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

    val request = Request(server.url("/"))

    val call = client.newCall(request)
    val response1 = call.execute()

    val cloned = call.clone()
    val response2 = cloned.execute()

    assertThat("abc").isEqualTo(response1.body.string())
    assertThat("def").isEqualTo(response2.body.string())
  }

  @Test
  @Flaky
  fun testMockWebserverRequest() {

        .post(sleepingRequestBody(500))
        .build()
    val call = client.newCall(request)
    call.timeout().timeout(250, TimeUnit.MILLISECONDS)
    assertFailsWith<IOException> {
      call.execute()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("timeout")
      assertThat(call.isCanceled()).isTrue()
    }
  }

  @Test
  fun timeoutWritingRequestWithEnqueue() {