.build()
    val request = Request(server.url("/"))
    val response1: Response = client.newCall(request).execute()
    val bodySource = response1.body.source()
    assertThat(bodySource.readUtf8()).isEqualTo("ABC.1")

    corruptor()

    return client.newCall(request).execute()
  }

  /**

  fun tearDown() {
    Thread.interrupted() // Clear interrupted state.
  }

  @Test
  fun interruptWritingRequestBody() {
    server.enqueue(MockResponse())
    server.start()
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .post(
            object : RequestBody() {
              override fun contentType() = null

      }
    }
  }

  @Test
  fun socketFailureOnLargeRequestHeaders() {
    server.enqueue(MockResponse())
    server.enqueue(MockResponse())
    server.start()

    val call1 =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )
    call1.execute().use { response -> response.body.string() }

    listener.shouldClose = true

    Request request = new Request.Builder()
      .url(HttpUrl.get("https://square.com/"))
      .tag(Integer.class, 5)
      .tag(String.class, "hello")
      .build();
    Call call = client.newCall(request);

    assertEquals(5, call.tag(Integer.class));
    assertEquals("hello", call.tag(String.class));
    assertEquals(null, call.tag(Boolean.class));
    assertEquals(null, call.tag(Object.class));
  }

        .build()

    server.enqueue(MockResponse())

    val url =
      server
        .url("/")
        .newBuilder()
        .host("localhost.localdomain")
        .build()
    val call = client.newCall(Request(url = url))
    val response = call.execute()
    assertThat(response.isSuccessful).isTrue()

    val recordedRequest = server.takeRequest()
    // https://github.com/bcgit/bc-java/issues/1773

    client.newCall(request).execute().use {
      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)
      assertThat(it.handshake!!.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
    }
  }

  @Test
  @Disabled
  fun testGoogle() {
    assumeNetwork()

    val request = Request.Builder().url("https://google.com/robots.txt").build()

    client.newCall(request).execute().use {

    server.useHttps(handshakeCertificates.sslSocketFactory())

    server.enqueue(MockResponse())
    server.start()

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

    val response = client.newCall(request).execute()

    response.use {
      assertEquals(200, response.code)
    }

    while (client.connectionPool.connectionCount() > 0) {
      Thread.sleep(1000)
    }
  }

  @Test

      ).build()

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

    val response1Body =
      client.newCall(request).execute().use {
        if (!it.isSuccessful) throw IOException("Unexpected code $it")

        println("Response 1 response:          $it")
        println("Response 1 cache response:    ${it.cacheResponse}")

    client.newCall(request).execute().use {
      assertThat(it.protocol).isEqualTo(Protocol.HTTP_2)
      assertThat(it.handshake!!.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
    }

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

    client.newCall(request).execute().use {

    cacheDir.delete()
    return Cache(cacheDir, (1024 * 1024).toLong())
  }

  private fun OkHttpClient.newCallWithListener(request: Request): Call =
    newCall(request)
      .apply {
        addEventRecorder(eventRecorder)
      }

  private fun Call.cloneWithListener(): Call =
    clone()
      .apply {
        addEventRecorder(eventRecorder)