* [bytes] or [string]. Or stream the response with either [source], [byteStream], or [charStream].
 */
abstract class ResponseBody : Closeable {
  /** Multiple calls to [charStream] must return the same instance. */
  private var reader: Reader? = null

  abstract fun contentType(): MediaType?

  /**
   * Returns the number of bytes in that will returned by [bytes], or [byteStream], or -1 if
   * unknown.
   */

      )
    }
  }

  @Test
  fun byteStreamEmpty() {
    val body = body("")
    val bytes = body.byteStream()
    assertThat(bytes.read()).isEqualTo(-1)
  }

  @Test
  fun byteStreamSeesBom() {
    val body = body("efbbbf68656c6c6f")
    val bytes = body.byteStream()
    assertThat(bytes.read()).isEqualTo(0xef)
    assertThat(bytes.read()).isEqualTo(0xbb)

    val response1 = call1.execute()
    val in1 = response1.body.byteStream()
    assertThat(readAscii(in1, 5)).isEqualTo("ABCDE")
    in1.close()
    call1.cancel()
    val call2 = client.newCall(newRequest("/"))
    val response2 = call2.execute()
    val in2 = response2.body.byteStream()
    assertThat(readAscii(in2, 5)).isEqualTo("LMNOP")
    in2.close()
    call2.cancel()

      ),
    )
  }

  @Test
  fun readSingleByteInt() {
    assertThat(newReader(byteStream()).readInt(10, 31)).isEqualTo(10)
    assertThat(newReader(byteStream()).readInt(0xe0 or 10, 31)).isEqualTo(10)
  }

  @Test
  fun readMultibyteInt() {
    assertThat(newReader(byteStream(154, 10)).readInt(31, 31)).isEqualTo(1337)
  }

  @Test
  fun writeSingleByteInt() {

        Request
          .Builder()
          .url(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

        .build(),
    )
    val call = client.newCall(Request(server.url("/")))
    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 ->

        override fun contentLength(): Long = TODO()

        override fun source(): BufferedSource = TODO()

        override fun close() = TODO()
      }
    val byteStream = responseBody.byteStream()
    val source = responseBody.source()
    val bytes = responseBody.bytes()
    val charStream = responseBody.charStream()
    val string = responseBody.string()
    responseBody.close()

  fun emptyResponse(protocol: Protocol) {
    setUp(protocol)
    server.enqueue(MockResponse())
    val call = client.newCall(Request(server.url("/foo")))
    val response = call.execute()
    assertThat(response.body.byteStream().read()).isEqualTo(-1)
    response.body.close()
  }

  @ParameterizedTest
  @ArgumentsSource(ProtocolParamProvider::class)
  fun noDefaultContentLengthOnStreamingPost(protocol: Protocol) {

	public static final field Companion Lokhttp3/ResponseBody$Companion;
	public static final field EMPTY Lokhttp3/ResponseBody;
	public fun <init> ()V
	public final fun byteStream ()Ljava/io/InputStream;
	public final fun byteString ()Lokio/ByteString;
	public final fun bytes ()[B
	public final fun charStream ()Ljava/io/Reader;
	public fun close ()V
	public abstract fun contentLength ()J

	public static final field Companion Lokhttp3/ResponseBody$Companion;
	public static final field EMPTY Lokhttp3/ResponseBody;
	public fun <init> ()V
	public final fun byteStream ()Ljava/io/InputStream;
	public final fun byteString ()Lokio/ByteString;
	public final fun bytes ()[B
	public final fun charStream ()Ljava/io/Reader;
	public fun close ()V
	public abstract fun contentLength ()J