}
        return newValue;
    }

    /**
     * Builds the complete query string from the configured parameters.
     * Combines base query, extra queries, field filters, and sort field into a single query string.
     *
     * @return the complete formatted query string
     */
    public String build() {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();

        .addNetworkInterceptor(networkInterceptor)
        .addInterceptor(applicationInterceptor)
        .build()
    server.enqueue(
      MockResponse
        .Builder()
        .build(),
    )
    val response =
      client
        .newCall(
          request()
            .build(),
        ).execute()
    response.body.close()
    val redactedUrl = networkInterceptor.redactUrl(url)

            return;
        }

        Build build = model.getBuild();

        if (build != null) {
            build.setDirectory(alignToBaseDirectory(build.getDirectory(), basedir));

            build.setSourceDirectory(alignToBaseDirectory(build.getSourceDirectory(), basedir));

            build.setTestSourceDirectory(alignToBaseDirectory(build.getTestSourceDirectory(), basedir));

      - uses: actions/upload-artifact@v4
        if: always()
        with:
          name: build-receipt.properties
          path: platforms/core-runtime/base-services/build/generated-resources/build-receipt/org/gradle/build-receipt.properties
    outputs:
      matrix: ${{ steps.setup-matrix.outputs.matrix }}
      sys-prop-args: ${{ steps.determine-sys-prop-args.outputs.sys-prop-args }}

    codePoint: Int,
    codePointString: String,
    component: Component,
  ) {
    val builder = "http://host/".toHttpUrl().newBuilder()
    component[builder] = codePointString
    val url = builder.build()
    val expected = component.canonicalize(codePointString)
    val actual = component[url]
    if (expected != actual) {
      fail("Roundtrip $component $codePoint $url $expected != $actual")
    }
  }

        .commonName(server.hostName)
        .build()
    val certificatePinner =
      CertificatePinner
        .Builder()
        .add(server.hostName, pin(rootCa.certificate))
        .build()
    val handshakeCertificates =
      HandshakeCertificates
        .Builder()
        .addTrustedCertificate(rootCa.certificate)
        .build()
    val client =
      clientTestRule
        .newClientBuilder()

    assertThat(base.newBuilder("https://host2")!!.build())
      .isEqualTo(parse("https://host2/"))
    assertThat(base.newBuilder("//host2")!!.build())
      .isEqualTo(parse("http://host2/"))
    assertThat(base.newBuilder("/path")!!.build())
      .isEqualTo(parse("http://host/path"))
    assertThat(base.newBuilder("path")!!.build())
      .isEqualTo(parse("http://host/a/path"))

          .body("abc".toResponseBody("text/plain; charset=utf-8".toMediaType()))
          .build()
      }
    client =
      client
        .newBuilder()
        .addNetworkInterceptor(interceptor)
        .build()
    val request =
      Request
        .Builder()
        .url(server.url("/"))
        .build()
    assertFailsWith<IllegalStateException> {
      client.newCall(request).execute()

        .Builder()
        .body("abc")
        .build(),
    )
    val ipAddress = InetAddress.getLoopbackAddress().hostAddress
    val call =
      client.newCall(
        Request
          .Builder()
          .url(
            server
              .url("/")
              .newBuilder()
              .host(ipAddress!!)
              .build(),
          ).build(),
      )
    val response = call.execute()

        .socketHandler(body)
        .build(),
    )
    server.enqueue(
      MockResponse
        .Builder()
        .body("this is /b")
        .build(),
    )
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .post(AsyncRequestBody())
          .build(),
      )
    call.execute().use { response ->