.build()
    server.enqueue(MockResponse(body = "abc"))
    server.enqueue(MockResponse(body = "def"))
    server.enqueue(MockResponse(body = "ghi"))
    client = client.newBuilder().build()
    executeSynchronously("/a").assertBody("abc")
    client = client.newBuilder().build()
    executeSynchronously("/b").assertBody("def")
    client = client.newBuilder().build()

    init {
        artifactRules = """
        **/build/git-checkout/platforms/core-runtime/base-services/build/generated-resources/build-receipt/org/gradle/build-receipt.properties
        **/build/distributions/*.zip => promote-build-distributions
        **/build/website-checkout/data/releases.xml
        **/build/git-checkout/build/reports/integTest/** => distribution-tests
        **/smoke-tests/build/reports/tests/** => post-smoke-tests

    val builtRequestWithoutCache = requestWithoutCache.newBuilder().url("http://localhost/api/foo").build()
    assertThat(builtRequestWithoutCache.url).isEqualTo(
      "http://localhost/api/foo".toHttpUrl(),
    )
    val requestWithCache =
      Request.Builder()
        .url("http://localhost/api")
        .build()
    // cache url object
    requestWithCache.url

                .build());
        options.addOption(Option.builder(FAIL_AT_END)
                .longOpt("fail-at-end")
                .desc("Only fail the build afterwards; allow all non-impacted builds to continue")
                .build());
        options.addOption(Option.builder(FAIL_NEVER)
                .longOpt("fail-never")
                .desc("NEVER fail the build, regardless of project result")

    }

    /**
     * @deprecated use {@link #build(ReaderSupplier)}
     */
    @Deprecated
    public PluginDescriptor build(Reader reader) throws PlexusConfigurationException {
        return build(reader, null);
    }

    /**
     * @deprecated use {@link #build(ReaderSupplier, String)}
     */
    @Deprecated
    public PluginDescriptor build(Reader reader, String source) throws PlexusConfigurationException {

    .certificateAuthority(1)
    .build();

HeldCertificate intermediateCertificate = new HeldCertificate.Builder()
    .certificateAuthority(0)
    .signedBy(rootCertificate)
    .build();

HeldCertificate serverCertificate = new HeldCertificate.Builder()
    .addSubjectAlternativeName("localhost")
    .signedBy(intermediateCertificate)
    .build();
```

import org.gradle.api.provider.Provider
import org.gradle.build.event.BuildEventsListenerRegistry
// Using star import to workaround https://youtrack.jetbrains.com/issue/KTIJ-24390
import org.gradle.kotlin.dsl.*
import org.gradle.kotlin.dsl.support.serviceOf

/**
 * In build-logic and main build, register a BuildService instance separately,
 * which collects necessary information for build scan.
 */

    val get = Request.Builder().url("http://localhost/api").get().build()
    assertThat(get.method).isEqualTo("GET")
    assertThat(get.body).isNull()

    val head = Request.Builder().url("http://localhost/api").head().build()
    assertThat(head.method).isEqualTo("HEAD")
    assertThat(head.body).isNull()

    val delete = Request.Builder().url("http://localhost/api").delete().build()
    assertThat(delete.method).isEqualTo("DELETE")

                        .build())
                .build());
        Model expected = new Model(org.apache.maven.api.model.Model.newBuilder()
                .parent(org.apache.maven.api.model.Parent.newBuilder()
                        .groupId("GROUPID")
                        .artifactId("ARTIFACTID")
                        .version("1.0-SNAPSHOT")
                        .build())
                .build());

                    .build());
            options.addOption(Option.builder(QUIET)
                    .longOpt("quiet")
                    .desc("Quiet output - only show errors")
                    .build());
            options.addOption(Option.builder(VERBOSE)
                    .longOpt("verbose")
                    .desc("Produce execution verbose output")
                    .build());