// The first call times out.
    val call1 = client.newCall(Request(server.url("/")))
    assertFailsWith<SocketTimeoutException> {
      call1.execute().use { response ->
        response.body.string()
      }
    }

    // The second call succeeds.
    val call2 = client.newCall(Request(server.url("/")))
    call2.execute().use { response ->
      assertThat(

    server.enqueue(
      MockResponse.Builder()
        .body("abc")
        .build(),
    )
    val call1 =
      client.newCall(
        Request.Builder()
          .url(server.url("/"))
          .build(),
      )
    val response1 = call1.execute()
    assertThat(response1.body.string()).isEqualTo("abc")
  }

  /**

    // makeSimpleCall() because it uses the MockResponse enqueued above.
    val callB = client.newCall(Request(server.url("/")))
    callB.execute().use { response ->
      assertThat(response.body.string()).isEqualTo("abc")
    }
  }

  private fun makeSimpleCall() {
    server.enqueue(MockResponse(body = "healthy"))
    val callB = client.newCall(Request(server.url("/")))

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

        override fun onResponse(
          call: Call,
          response: Response,
        ) {

        .build()
    val request = Request.Builder().url(sanUrl).build()
    val call1 = client1.newCall(request)
    call1.enqueue(
      object : Callback {
        @Throws(IOException::class)
        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          try {

    val call = calls[0]
    assertThat(call).contains("host=" + url.host)
    assertThat(call).contains("port=" + url.port)
    assertThat(call).contains("site=" + url.host)
    assertThat(call).contains("url=http://android.com")
    assertThat(call).contains("type=" + java.net.Authenticator.RequestorType.PROXY)
    assertThat(call).contains("prompt=Bar")
    assertThat(call).contains("protocol=http")

Calls are executed in one of two ways:

 * **Synchronous:** your thread blocks until the response is readable.
 * **Asynchronous:** you enqueue the request on any thread, and get [called back](https://square.github.io/okhttp/4.x/okhttp/okhttp3/-callback/) on another thread when the response is readable.

 */
package okhttp3

import okio.IOException
import okio.Timeout

/**
 * A call is a request that has been prepared for execution. A call can be canceled. As this object
 * represents a single request/response pair (stream), it cannot be executed twice.
 */
interface Call : Cloneable {
  /** Returns the original request that initiated this call. */
  fun request(): Request

  /**

  }

  @Override public void callStart(Call call) {
    printEvent("callStart");
  }

  @Override public void callEnd(Call call) {
    printEvent("callEnd");
  }

  @Override public void dnsStart(Call call, String domainName) {
    printEvent("dnsStart");
  }

  @Override public void dnsEnd(Call call, String domainName, List<InetAddress> inetAddressList) {
    printEvent("dnsEnd");

    return null
  }

  /**
   * Cancel all calls currently enqueued or executing. Includes calls executed both
   * [synchronously][Call.execute] and [asynchronously][Call.enqueue].
   */
  fun cancelAll() {
    this.withLock {
      for (call in readyAsyncCalls) {
        call.call.cancel()
      }
      for (call in runningAsyncCalls) {
        call.call.cancel()
      }
      for (call in runningSyncCalls) {