chain.proceed(chain.request())
          },
        ).eventListenerFactory(clientTestRule.wrap(listener1))
        .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 {

   * underlying [ResponseBody].
   *
   * ```java
   * // ensure the response (and underlying response body) is closed
   * try (Response response = client.newCall(request).execute()) {
   *   ...
   * }
   * ```
   *
   * The caller may read the response body with the response's [Response.body] method. To avoid

    showUrl("https://squareup.com/robots.txt")
    showUrl("https://publicobject.com/helloworld.txt")
  }

  private fun showUrl(url: String) {
    val request = Builder().url(url).build()
    client
      .newCall(request)
      .execute()
      .use { response ->
        if (!response.isSuccessful) {
          val responseHeaders = response.headers
          for (i in 0 until responseHeaders.size) {

    )
    server.enqueue(
      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")

      }
    }
  }

  private fun sendTestRequest(request: Request) {
    try {
      if (this.launch != CommandLine) {
        println(request.url)
      }

      client
        .newCall(request)
        .execute()
        .use {
          val firstLine =
            it.body
              .string()
              .lines()
              .first()
          if (this.launch != CommandLine) {

    server.enqueue(MockResponse(body = "ghi"))
    client.newCall(Request.Builder().url(server.url("/a")).build()).enqueue(callback)
    callback.await(server.url("/a")).assertBody("abc")
    client.newCall(Request.Builder().url(server.url("/b")).build()).enqueue(callback)
    callback.await(server.url("/b")).assertBody("def")
    client.newCall(Request.Builder().url(server.url("/c")).build()).enqueue(callback)

    }

  private lateinit var call: RealCall
  private val routeDatabase = RouteDatabase()

  @BeforeEach fun setUp() {
    call =
      clientTestRule.newClient().newCall(
        Request
          .Builder()
          .url("https://$uriHost:$uriPort/")
          .build(),
      ) as RealCall
  }

  @AfterEach fun tearDown() {
    factory.close()
  }

	public abstract fun timeout ()Lokio/Timeout;
}

public abstract interface class okhttp3/Call$Factory {
	public abstract fun newCall (Lokhttp3/Request;)Lokhttp3/Call;
}

public abstract interface class okhttp3/Callback {
	public abstract fun onFailure (Lokhttp3/Call;Ljava/io/IOException;)V

        .build(),
    )

    val call1 = client.newCall(Request(server.url("/")))
    call1.execute().use { response ->
      val source = response.body.source()
      assertThat(response.header("h1")).isEqualTo("v1")
      assertThat(source.readUtf8()).isEqualTo("Hello")
      assertThat(response.trailers()).isEqualTo(headersOf("t1", "v2"))
    }

    val call2 = client.newCall(Request(server.url("/")))

  fun increasingMaxRequestsPromotesJobsImmediately() {
    dispatcher.maxRequests = 2
    client.newCall(newRequest("http://a/1")).enqueue(callback)
    client.newCall(newRequest("http://b/1")).enqueue(callback)
    client.newCall(newRequest("http://c/1")).enqueue(callback)
    client.newCall(newRequest("http://a/2")).enqueue(callback)
    client.newCall(newRequest("http://b/2")).enqueue(callback)