.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());

    @Test
    fun `nightly promotion build type runs three gradle invocations`() {
        val model = setupModelFor("release")
        val nightlySnapshot = model.findBuildTypeByName("Nightly Snapshot")

        val steps = nightlySnapshot.steps.items
        assertEquals(3, steps.size)

        .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()
        .sslSocketFactory(

        .build()
    server.enqueue(
      MockResponse.Builder()
        .addHeader("SeNsItIvE", "Value").addHeader("Not-Sensitive", "Value")
        .build(),
    )
    val response =
      client
        .newCall(
          request()
            .addHeader("SeNsItIvE", "Value")
            .addHeader("Not-Sensitive", "Value")
            .build(),
        )
        .execute()

import org.apache.maven.project.MavenProject;

/**
 * Summarizes the result of a failed project build in the reactor.
 *
 */
public class BuildFailure extends BuildSummary {

    /**
     * The cause of the build failure.
     */
    private final Throwable cause;

    /**
     * Creates a new build summary for the specified project.
     *

See [Gradle runtimes](runtimes.md) for a list of these runtimes and more details.

## Build state model

As Gradle executes, it acts on various pieces of the build definition, such as each project in the build.
Gradle tracks the state of each piece and transitions each piece through its lifecycle as the build runs.

            .build()
            .newThread(monitoredRunnable)
            .getUncaughtExceptionHandler());
  }

  public void testBuildMutateBuild() {
    ThreadFactory factory1 = builder.setPriority(1).build();
    assertEquals(1, factory1.newThread(monitoredRunnable).getPriority());

    ThreadFactory factory2 = builder.setPriority(2).build();

    server.enqueue(
      MockResponse.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()
    assertThat(response.code).isEqualTo(200)

platforms/enterprise/enterprise-logging/                @gradle/bt-build-scan @gradle/dv-testing-team
platforms/enterprise/enterprise-operations/             @gradle/bt-build-scan
platforms/enterprise/enterprise-plugin-performance/     @gradle/bt-build-scan

# JVM platform
build-logic/java-api-extractor              @gradle/bt-jvm
platforms/jvm/                              @gradle/bt-jvm

    # "We were unable to automatically build your code", modify the matrix above
    # to set the build mode to "manual" for that language. Then modify this step
    # to build your code.
    # ℹ️ Command-line programs to run using the OS shell.
    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
    - if: matrix.build-mode == 'manual'
      shell: bash
      run: |