/**
     * Returns a new request body that transmits this string. If [contentType] is non-null and lacks
     * a charset, this will use UTF-8.
     */
    @JvmStatic
    @JvmName("create")
    fun String.toRequestBody(contentType: MediaType? = null): RequestBody {
      val (charset, finalContentType) = contentType.chooseCharset()
      val bytes = toByteArray(charset)

		statusCode   int
		body         string
		contentType  string
		expectStatus int
	}{
		{
			name:         "Success 206 Partial Content",
			statusCode:   206,
			body:         "partial-object-data",
			contentType:  "text/plain",
			expectStatus: 206,
		},
		{
			name:         "Success 200 OK",
			statusCode:   200,
			body:         "full-object-data",
			contentType:  "application/json",
			expectStatus: 200,
		},

    val contentType = "text/plain; charset=utf-16be".toMediaType()
    val body = "\u0800".toRequestBody(contentType)
    assertThat(body.contentType()).isEqualTo(contentType)
    assertThat(body.contentLength()).isEqualTo(2)
    assertThat(bodyToHex(body)).isEqualTo("0800")
  }

  @Test
  fun byteArray() {
    val contentType = "text/plain".toMediaType()
    val body: RequestBody = "abc".toByteArray().toRequestBody(contentType)

      val requestBody = fd.toRequestBody()

      assertThat(requestBody.contentType()).isNull()
    }
  }

  @Test
  fun testFileDescriptorMediaType() {
    assertOnFileDescriptor { fd ->
      val contentType = "text/plain".toMediaType()

      val requestBody = fd.toRequestBody(contentType)

      assertThat(requestBody.contentType()).isEqualTo(contentType)
    }
  }

  @Test
  fun testFileDescriptorReadTwice() {

        this.encoding = encoding;
    }

    /**
     * Sets the content type.
     *
     * @param contentType the content type
     */
    public void setContentType(final String contentType) {
        this.contentType = contentType;
    }

        !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

     * @param text The text content to write.
     * @param contentType The content type for the response.
     * @param encoding The character encoding for the response.
     */
    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 {

      } else {
        listener.onClosed(this)
      }
    }
  }

  private fun ResponseBody.isEventStream(): Boolean {
    val contentType = contentType() ?: return false
    return contentType.type == "text" && contentType.subtype == "event-stream"
  }

  override fun onFailure(
    call: Call,
    e: IOException,
  ) {
    listener.onFailure(this, e, null)
  }

            }

            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);

      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;
      }