requestBuilder.header("Content-Length", contentLength.toString())
        requestBuilder.removeHeader("Transfer-Encoding")
      } else {
        requestBuilder.header("Transfer-Encoding", "chunked")
        requestBuilder.removeHeader("Content-Length")
      }
    }

    if (userRequest.header("Host") == null) {
      requestBuilder.header("Host", userRequest.url.toHostHeader())
    }

        val requestBuilder = HttpRequest.newBuilder().uri(URI(uri))
        if (githubToken.isPresent) {
            requestBuilder.header("Authorization", "token ${githubToken.get()}")
        }
        val response = HttpClient.newHttpClient().send(requestBuilder.build(), HttpResponse.BodyHandlers.ofString())
        if (response.statusCode() > 399) {

        try {
            final ListObjectsV2Request.Builder requestBuilder =
                    ListObjectsV2Request.builder().bucket(bucket).delimiter("/").maxKeys(maxItems);

            if (StringUtil.isNotBlank(prefix)) {
                final String normalizedPrefix = prefix.endsWith("/") ? prefix : prefix + "/";
                requestBuilder.prefix(normalizedPrefix);
            }

        final GetRequestBuilder requestBuilder = client.prepareGet(index, id);
        if (condition.build(requestBuilder)) {
            response = requestBuilder.execute().actionGet(ComponentUtil.getFessConfig().getIndexSearchTimeout());
        }
        final long execTime = systemHelper.getCurrentTimeAsLong() - startTime;

        requestBuilder.method("GET", null)
      } else {
        val requestBody = if (maintainBody) userResponse.request.body else null
        requestBuilder.method(method, requestBody)
      }
      if (!maintainBody) {
        requestBuilder.removeHeader("Transfer-Encoding")
        requestBuilder.removeHeader("Content-Length")
        requestBuilder.removeHeader("Content-Type")
      }
    }

            searchEngineClient.scrollSearch(fessConfig.getIndexDocumentUpdateIndex(), requestBuilder -> {
                requestBuilder.setQuery(queryBuilder).setSize((int) numFound);
                if (fields != null) {
                    requestBuilder.setFetchSource(fields, null);
                }
                return true;
            }, entity -> {

        try {
            final AtomicLong processedCount = new AtomicLong(0);
            final long count = searchEngineClient.scrollSearch(fessConfig.getIndexDocumentSearchIndex(), requestBuilder -> {
                requestBuilder.setQuery(query).setSize(scrollSize);
                return true;
            }, source -> {
                exportDocument(source, exportPath, excludeFields, resolvedFormatter);

    Request(
      url = "".toHttpUrl(),
      headers = headersOf(),
      method = "",
      body = "".toRequestBody(null),
    )
  }

  @Test
  fun requestBuilder() {
    val requestBody = "".toRequestBody(null)
    var builder = Request.Builder()
    builder = builder.url("".toHttpUrl())
    builder = builder.url("")
    builder = builder.url(URL(""))

  }

  @Test
  fun invalidScheme() {
    val requestBuilder = Request.Builder()
    assertFailsWith<IllegalArgumentException> {
      requestBuilder.url("ftp://hostname/path")
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Expected URL scheme 'http' or 'https' but was 'ftp'")
    }
  }

  @Test
  fun invalidPort() {
    val requestBuilder = Request.Builder()

    server.enqueue(MockResponse(body = "Page 2"))
    val requestBuilder =
      Request
        .Builder()
        .url(server.url("/page1"))
    if (method == "POST") {
      requestBuilder.post("ABCD".toRequestBody(null))
    } else {
      requestBuilder.method(method, null)
    }
    val response = getResponse(requestBuilder.build())