*/
package okhttp3

import assertk.assertThat
import assertk.assertions.isEmpty
import assertk.assertions.isEqualTo
import kotlin.test.assertFailsWith
import okhttp3.ResponseBody.Companion.asResponseBody
import okhttp3.ResponseBody.Companion.toResponseBody
import okio.Buffer
import okio.BufferedSource
import okio.Source
import okio.Timeout
import okio.buffer
import org.junit.jupiter.api.Test

      val responseBody = response.body.source()
      assertThat(responseBody.readUtf8Line())
        .isEqualTo("response A")
      assertThat(responseBody.readUtf8Line())
        .isEqualTo("response B")
      requestBody.writeUtf8("request C\n")
      requestBody.close()
      assertThat(responseBody.readUtf8Line()).isNull()
    }
    body.awaitSuccess()
  }

   * [closed][ResponseBody] and may be consumed only once.
   *
   * If this is a [cacheResponse], [networkResponse], or [priorResponse], the server's response body
   * is not available, and it is always an error to attempt read its streamed content. Reading from
   * [ResponseBody.source] always throws on such instances.
   *
   * It is safe and supported to call [ResponseBody.contentType] and [ResponseBody.contentLength] on

    val bytes = responseBody.bytes()
    val charStream = responseBody.charStream()
    val string = responseBody.string()
    responseBody.close()
    responseBody = "".toResponseBody("".toMediaType())
    responseBody = "".toResponseBody(null)
    responseBody = ByteString.EMPTY.toResponseBody("".toMediaType())
    responseBody = ByteString.EMPTY.toResponseBody(null)

	public final fun create (Lokhttp3/MediaType;JLokio/BufferedSource;)Lokhttp3/ResponseBody;
	public final fun create (Lokhttp3/MediaType;Ljava/lang/String;)Lokhttp3/ResponseBody;
	public final fun create (Lokhttp3/MediaType;Lokio/ByteString;)Lokhttp3/ResponseBody;
	public final fun create (Lokhttp3/MediaType;[B)Lokhttp3/ResponseBody;
	public final fun create (Lokio/BufferedSource;Lokhttp3/MediaType;J)Lokhttp3/ResponseBody;

  }

  private fun peekTrailers(protocol: Protocol) {
    val responseBody = "a".repeat(OKHTTP_CLIENT_WINDOW_SIZE)
    enableProtocol(protocol)

    server.enqueue(
      MockResponse
        .Builder()
        .addHeader("h1", "v1")
        .trailers(headersOf("t1", "v2"))
        .body(protocol, responseBody)
        .build(),
    )

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

          .build(),
      )
    val response = call.execute()
    interruptLater(500)
    val responseBody = response.body.byteStream()
    val buffer = ByteArray(1024)
    assertFailsWith<IOException> {
      while (responseBody.read(buffer) != -1) {
      }
    }
    responseBody.close()
  }

  @Test
  fun forciblyStopDispatcher() {
    client =
      client
        .newBuilder()

    val response = call.execute()
    cancelLater(call, 500)
    val responseBody = response.body.byteStream()
    val buffer = ByteArray(1024)
    assertFailsWith<IOException> {
      while (responseBody.read(buffer) != -1) {
      }
    }.also { expected ->
      assertEquals(cancelMode == INTERRUPT, Thread.interrupted())
    }
    responseBody.close()

    /**
     * Sets the response body from a byte array.
     *
     * @param responseBody the byte array containing the response body
     */
    public void setResponseBody(final byte[] responseBody) {
        responseBodyBytes = responseBody;
    }

    /**
     * Sets the response body from a file.
     *
     * @param responseBody the file containing the response body

          },
        )
        throw e
      }

      val tookMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNs)

      val responseBody = response.body!!
      val contentLength = responseBody.contentLength()
      val bodySize = if (contentLength != -1L) "$contentLength-byte" else "unknown-length"
      logger.log(
        buildString {
          append("<-- ${response.code}")