}

      response.isChunked -> {
        newChunkedSource(response.request.url)
      }

      else -> {
        val contentLength = response.headersContentLength()
        if (contentLength != -1L) {
          newFixedLengthSource(response.request.url, contentLength)
        } else {
          newUnknownLengthSource(response.request.url)
        }
      }
    }

                  }
                }
                println(bytesWritten)
                if (contentLength != -1L) {
                  println("${100 * bytesWritten / contentLength}% done")
                }
              }
            }
          }

          val file = File("docs/images/logo-square.png")
          val requestBody: RequestBody = file.asRequestBody(MEDIA_TYPE_PNG)

                    final long contentLength = Long.parseLong(value);
                    if (contentLengthHelper != null) {
                        final long maxLength = contentLengthHelper.getMaxLength("text/plain");
                        if (contentLength > maxLength) {
                            throw new MaxLengthExceededException("The content length (" + contentLength + " byte) is over " + maxLength

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

      val contentLength = body.contentLength()
      if (contentLength != -1L) {
        requestBuilder.header("Content-Length", contentLength.toString())
        requestBuilder.removeHeader("Transfer-Encoding")
      } else {
        requestBuilder.header("Transfer-Encoding", "chunked")

                    final long contentLength = Long.parseLong(value);
                    if (contentLengthHelper != null) {
                        final long maxLength = contentLengthHelper.getMaxLength("text/plain");
                        if (contentLength > maxLength) {
                            throw new MaxLengthExceededException("The content length (" + contentLength + " byte) is over " + maxLength

            expectedByteCount = contentLength,
            socket = socket,
          ).buffer()
      requestBodySink.use {
        when {
          peek.doNotReadRequestBody -> {
            hasBody = false // Ignore the body completely.
          }

          contentLength != -1L -> {
            hasBody = contentLength > 0L || HttpMethod.permitsRequestBody(request.method)

     * Fields to fetch for access result list without data.
     */
    private static final String[] ACCESS_RESULT_FIELDS = { "parentUrl", "method", "mimeType", "sessionId", "url", "executionTime",
            "createTime", "contentLength", "lastModified", "ruleId", "httpStatusCode", "status" };

    /**
     * Creates a new instance of OpenSearchDataService.
     * @param crawlerConfig The crawler configuration.
     */

            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 {
    private const val VERSION = 201105
    private const val ENTRY_METADATA = 0

          }
          source.close()
        }
      }

    val contentType = response.header("Content-Type")
    val contentLength = response.body.contentLength()
    return response
      .newBuilder()
      .body(RealResponseBody(contentType, contentLength, cacheWritingSource.buffer()))
      .build()
  }

  companion object {

    assertThat(body.contentLength()).isEqualTo(3)
    assertThat(bodyToHex(body)).isEqualTo("e0a080")
  }

  @Test
  fun stringWithNonDefaultCharsetSpecified() {
    val contentType = "text/plain; charset=utf-16be".toMediaType()
    val body = "\u0800".toRequestBody(contentType)
    assertThat(body.contentType()).isEqualTo(contentType)
    assertThat(body.contentLength()).isEqualTo(2)