server.enqueue(MockResponse(body = "abc"))
    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

    assertEquals(
        "\uD8AB\uDCABdef", Strings.commonSuffix("abc\uD8AB\uDCABdef", "xyz\uD8AB\uDCABdef"));
    // Differing valid surrogate pairs.
    assertEquals("def", Strings.commonSuffix("abc\uD8AB\uDCABdef", "abc\uD8AC\uDCABdef"));
    // One invalid pair.
    assertEquals("def", Strings.commonSuffix("abc\uD8AB\uDCABdef", "xyz\uDCAB\uDCABdef"));
    // Two identical invalid pairs.
    assertEquals(

   * | :--------------------- | :----------- |
   * | `http://host/`         | null         |
   * | `http://host/#`        | `""`         |
   * | `http://host/#abc`     | `"abc"`      |
   * | `http://host/#abc|def` | `"abc|def"`  |
   */
  @get:JvmName("fragment") val fragment: String?,
  /** Canonical URL. */
  private val url: String,
) {
  val isHttps: Boolean
    get() = scheme == "https"

    clientListener.assertOpen()
    val server = serverListener.assertOpen()
    webSocket.send("abc")
    serverListener.assertTextMessage("abc")
    server.send("def")
    clientListener.assertTextMessage("def")
    closeWebSockets(webSocket, server)
  }

  @Test
  @Throws(IOException::class)
  fun missingConnectionHeader() {
    webServer.enqueue(
      MockResponse

    )
    server.enqueue(
      MockResponse
        .Builder()
        .addHeader("Last-Modified: " + formatDate(-5, TimeUnit.MINUTES))
        .addHeader("Expires: " + formatDate(2, TimeUnit.HOURS))
        .body("DEF")
        .build(),
    )
    client =
      client
        .newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,

    server.useHttps(handshakeCertificates.sslSocketFactory())
    server.enqueue(MockResponse(body = "ABC"))
    server.enqueue(MockResponse(body = "DEF"))
    server.enqueue(MockResponse(body = "GHI"))
    assertContent("ABC", getResponse(newRequest("/")))
    assertContent("DEF", getResponse(newRequest("/")))
    assertContent("GHI", getResponse(newRequest("/")))
    assertThat(hostnameVerifier.calls)

    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # o isCheckColumnDefOrderDiff: (NotRequired - Default false)
    #  Does it check differences of column-def order?
    #  (except added or deleted columns)
    #
    #; isCheckColumnDefOrderDiff = false
    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

      MockResponse
        .Builder()
        .body("def")
        .onResponseEnd(ShutdownConnection)
        .build(),
    )
    val call2 =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),
      )
    val response2 = call2.execute()
    assertThat(response2.body.string()).isEqualTo("def")
    response2.close()
  }

  @Test

      override fun writeTo(sink: BufferedSink) {
        try {
          sink.writeUtf8("abc")
          sink.flush()
          Thread.sleep(sleepMillis.toLong())
          sink.writeUtf8("def")
        } catch (e: InterruptedException) {
          throw InterruptedIOException()
        }
      }
    }

  companion object {

  fun responseTimeout() {
    server.enqueue(
      MockResponse()
        .setBody("ABC")
        .clearHeaders()
        .addHeader("Content-Length: 4"),
    )
    server.enqueue(MockResponse().setBody("DEF"))
    val urlConnection = server.url("/").toUrl().openConnection()
    urlConnection.setReadTimeout(1000)
    val inputStream = urlConnection.getInputStream()
    assertThat(inputStream.read()).isEqualTo('A'.code)