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 buffer = Buffer().writeString(this, charset)
      return buffer.asResponseBody(finalContentType, buffer.size)
    }

    /** Returns a new response body that transmits this byte array. */
    @JvmStatic
    @JvmName("create")
    fun ByteArray.toResponseBody(contentType: MediaType? = null): ResponseBody =
      Buffer()
        .write(this)

        !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

  }

  @Test
  fun stringClosesUnderlyingSource() {
    val closed = AtomicBoolean()
    val body: ResponseBody =
      object : ResponseBody() {
        override fun contentType(): MediaType? = null

        override fun contentLength(): Long = 5

        override fun source(): BufferedSource {
          val source = Buffer().writeUtf8("hello")

            .write(COLONSPACE)
            .writeUtf8(headers.value(h))
            .write(CRLF)
        }
      }

      val contentType = body.contentType()
      if (contentType != null) {
        sink
          .writeUtf8("Content-Type: ")
          .writeUtf8(contentType.toString())
          .write(CRLF)
      }

      // We can't measure the body's size without the sizes of its components.

        .Builder("123")
        .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)

      }

      // Append headers.
      for ((name, value) in headers) {
        if (contentType != null && name.equals("Content-Type", ignoreCase = true)) continue
        append(" \\\n  -H ${"$name: $value".shellEscape()}")
      }

      if (contentType != null) {
        append(" \\\n  -H ${"Content-Type: $contentType".shellEscape()}")
      }

      // Append body if present.

          @Throws(IOException::class)
          override fun close() {
            snapshot.close()
            super.close()
          }
        }.buffer()
    }

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

    override fun contentLength(): Long = contentLength?.toLongOrDefault(-1L) ?: -1L

    override fun source(): BufferedSource = bodySource
  }

  companion object {

  @Test
  fun noAttemptToReadResponseIfLoadingRequestBodyIsSourceOfFailure() {
    server.enqueue(MockResponse(body = "abc"))

    val requestBody =
      object : RequestBody() {
        override fun contentType(): MediaType? = null

        override fun writeTo(sink: BufferedSink) {
          throw IOException("boom") // Despite this exception, 'sink' is healthy.
        }
      }

    val callA =

    }
    assertThat(callRef.get()).isSameInstanceAs(call)
  }

  private fun uppercase(original: RequestBody?): RequestBody =
    object : RequestBody() {
      override fun contentType(): MediaType? = original!!.contentType()

      override fun contentLength(): Long = original!!.contentLength()

      override fun writeTo(sink: BufferedSink) {
        val uppercase = uppercase(sink)