*
 * ```java
 * Call call = client.newCall(request);
 * call.enqueue(new Callback() {
 *   public void onResponse(Call call, Response response) throws IOException {
 *     try (ResponseBody responseBody = response.body()) {
 *     ... // Use the response.
 *     }
 *   }
 *
 *   public void onFailure(Call call, IOException e) {
 *   ... // Handle the failure.
 *   }
 * });
 * ```
 *

 */
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()
  }

  }

  private fun newResponse(
    responseBody: ResponseBody,
    code: Int = 200,
  ): Response =
    Response
      .Builder()
      .request(
        Request
          .Builder()
          .url("https://example.com/")
          .build(),
      ).protocol(Protocol.HTTP_1_1)
      .code(code)
      .message("OK")
      .body(responseBody)
      .build()

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

 * limitations under the License.
 */
package okhttp3

import okio.BufferedSource

open class ForwardingResponseBody(
  delegate: ResponseBody?,
) : ResponseBody() {
  private val delegate: ResponseBody

  fun delegate(): ResponseBody = delegate

  override fun contentType(): MediaType? = delegate.contentType()

  override fun contentLength(): Long = delegate.contentLength()

    assertThat(source.exhausted()).isTrue()
    assertThat(source.readUtf8()).isEqualTo("")
  }

  @Test
  fun sourceClosesUnderlyingSource() {
    var closed = false

    val body: ResponseBody =
      object : ResponseBody() {
        override fun contentType(): MediaType? = null

        override fun contentLength(): Long = 5

        override fun source(): BufferedSource {

	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;

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