server.protocols = listOf(Protocol.HTTP_2, Protocol.HTTP_1_1)
    server.enqueue(MockResponse())
    server.enqueue(MockResponse())

    client
      .newCall(Request(server.url("/")))
      .execute()
      .close()

    client
      .newCall(Request(server.url("/")))
      .execute()
      .close()

    assertThat(listener.recordedEventTypes()).containsExactly(
      "ConnectStart",

    }
  }

  @Test
  fun none() {
    server.enqueue(MockResponse())
    client.newCall(request().build()).execute()
    applicationLogs.assertNoMoreLogs()
    networkLogs.assertNoMoreLogs()
  }

  @Test
  fun basicGet() {
    setLevel(Level.BASIC)
    server.enqueue(MockResponse())
    client.newCall(request().build()).execute()
    applicationLogs
      .assertLogEqual("--> GET $url")

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

    client.newCall(request).execute().use { response ->
      assertEquals(200, response.code)
    }

    client.connectionPool.evictAll()
    assertEquals(0, client.connectionPool.connectionCount())

    client.newCall(request).execute().use { response ->
      assertEquals(200, response.code)
    }

    ```kotlin
      private val client = OkHttpClient()

      fun run() {
        val request = Request.Builder()
            .url("https://publicobject.com/helloworld.txt")
            .build()

        client.newCall(request).execute().use { response ->
          if (!response.isSuccessful) throw IOException("Unexpected code $response")

          for ((name, value) in response.headers) {
            println("$name: $value")
          }

        .header("Connection", "upgrade")
        .build()
    assertFailsWith<ProtocolException> {
      client.newCall(requestWithUpgrade).execute()
    }
  }

  @Test
  fun upgradesOnReusedConnection() {
    server.enqueue(MockResponse(body = "normal request"))
    client.newCall(Request(server.url("/"))).execute().use { response ->
      assertThat(response.body.string()).isEqualTo("normal request")
    }

            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

    )
    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)