!contentEncoding.equals("gzip", ignoreCase = true)
    }

    private fun bodyIsStreaming(response: Response): Boolean {
      val contentType = response.body.contentType()
      return contentType != null && contentType.type == "text" && contentType.subtype == "event-stream"
    }

    companion object

import okio.BufferedSink
import okio.ByteString

fun ByteArray.commonToRequestBody(
  contentType: MediaType?,
  offset: Int,
  byteCount: Int,
): RequestBody {
  checkOffsetAndCount(size.toLong(), offset.toLong(), byteCount.toLong())
  return object : RequestBody() {
    override fun contentType() = contentType

    override fun contentLength() = byteCount.toLong()

    override fun writeTo(sink: BufferedSink) {

        .addPart("Hello, World!".toRequestBody(null))
        .build()
    assertThat(body.boundary).isEqualTo("123")
    assertThat(body.type).isEqualTo(MultipartBody.MIXED)
    assertThat(body.contentType().toString())
      .isEqualTo("multipart/mixed; boundary=123")
    assertThat(body.parts.size).isEqualTo(1)
    assertThat(body.contentLength()).isEqualTo(33L)
    val buffer = Buffer()
    body.writeTo(buffer)

    fun ByteString.toRequestBody(contentType: MediaType? = null): RequestBody = commonToRequestBody(contentType)

    /** Returns a new request body that transmits this. */
    @JvmStatic
    @JvmName("create")
    @ExperimentalOkHttpApi
    fun FileDescriptor.toRequestBody(contentType: MediaType? = null): RequestBody {
      return object : RequestBody() {
        override fun contentType() = contentType

            }

            String contentType = null;
            final Header contentTypeHeader = response.getFirstHeader("Content-Type");
            if (contentTypeHeader != null) {
                contentType = contentTypeHeader.getValue();
                final int idx = contentType.indexOf(';');
                if (idx > 0) {
                    contentType = contentType.substring(0, idx);

	if err := d.DecodeElement(&parsedArgs, &start); err != nil {
		return err
	}

	parsedArgs.ContentType = strings.ToLower(parsedArgs.ContentType)
	switch parsedArgs.ContentType {
	case document, lines:
	default:
		return errInvalidJSONType(fmt.Errorf("invalid ContentType '%v'", parsedArgs.ContentType))
	}

	*args = ReaderArgs(parsedArgs)
	args.unmarshaled = true
	return nil
}

    val userRequest = chain.request()
    val requestBuilder = userRequest.newBuilder()

    val body = userRequest.body
    if (body != null) {
      val contentType = body.contentType()
      if (contentType != null) {
        requestBuilder.header("Content-Type", contentType.toString())
      }

      val contentLength = body.contentLength()
      if (contentLength != -1L) {

        return FormatType.OTHER;
    }

    protected void write(final String text, final String contentType, final String encoding) {
        final StringBuilder buf = new StringBuilder(50);
        if (contentType == null) {
            buf.append("text/plain");
        } else {
            buf.append(contentType);
        }
        buf.append("; charset=");
        final String enc;
        if (encoding == null) {

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

  fun delegate(): ResponseBody {
    return delegate
  }

  override fun contentType(): MediaType? {
    return delegate.contentType()
  }

  override fun contentLength(): Long {
    return delegate.contentLength()
  }

  override fun source(): BufferedSource {
    return delegate.source()
  }

      System.out.printf("%03d: %s %s%n", responseCode, url, responseSource);

      String contentType = response.header("Content-Type");
      if (responseCode != 200 || contentType == null) {
        return;
      }

      MediaType mediaType = MediaType.parse(contentType);
      if (mediaType == null || !mediaType.subtype().equalsIgnoreCase("html")) {
        return;
      }