then:
        progress.size() >= 2
        progress.removeLast() == ''
        progress.every { it }
    }

    def "tooling api reports build failure"() {
        file('build.gradle') << 'broken'

        when:
        withConnection {
            it.newBuild().forTasks('jar').run()
        }

        then:
        BuildException e = thrown()

        and:
        file("src/main/cpp/broken.cpp") << """
        #include <iostream>

        'broken
"""

        expect:
        fails "assemble"
        failure.assertHasDescription("Execution failed for task ':compileDebugCpp'.")
        failure.assertHasCause("A build operation failed.")
        failure.assertThatCause(containsText("C++ compiler failed while compiling broken.cpp"))
    }

		}

		return nil, fmt.Errorf("expect response status code: %d, but got: %d. response body: %s", http.StatusOK, resp.StatusCode, body)
	}

	// encounter watch bytes received, does not expect to be broken
	if url == urlWatch || url == urlWatchWithGoaway {
		ch := make(chan watchResponse)
		go func() {
			defer resp.Body.Close()

			body := make([]byte, 0)
			buffer := make([]byte, 1)
			for {

)

var (
	regenerationCounter = metrics.NewCounterVec(
		&metrics.CounterOpts{
			Name:           "apiextensions_openapi_v2_regeneration_count",
			Help:           "Counter of OpenAPI v2 spec regeneration count broken down by causing CRD name and reason.",
			StabilityLevel: metrics.ALPHA,
		},
		[]string{"crd", "reason"},
	)
)

func init() {
	legacyregistry.MustRegister(regenerationCounter)

        def action = Mock(BuildAction)
        def parameters = Stub(ConsumerOperationParameters)
        def failure = new GradleException("broken", new BuildCancelledException("cancelled."))

        when:
        connection.run(action, parameters)

        then:
        InternalBuildCancelledException e = thrown()
        e.cause == failure

            }
        }
    }

    val failingTask by registering {
        doLast {
            problems.forNamespace("buildscript").throwing {
                id("broken-task", "Task should not be called")
                    .contextualLabel("Task 'failingTask' should not be called")
                    .severity(Severity.ERROR)

import java.io.Serializable;

public class BrokenRemoteProcess implements Action<WorkerProcessContext>, Serializable {
    public void execute(WorkerProcessContext workerProcessContext) {
        throw new RuntimeException("broken");
    }

        toolchain.get().vendor == "IBM"
    }

    def "ignores invalid toolchains when finding a matching one"() {
        given:
        def queryService = setupInstallations(["8.0", "8.0.242.hs-adpt", "8.0.broken"])

        when:
        def filter = createSpec()
        filter.languageVersion.set(JavaLanguageVersion.of(8))
        def toolchain = queryService.findMatchingToolchain(filter).get()

        then:

        when:
        parser.parseNotation("broken")

        then:
        UnsupportedNotationException e = thrown()
        e.message == toPlatformLineSeparators("""Cannot convert the provided notation to an object of type Number: broken.
The following types/formats are supported:
  - a string containing a greeting, for example 'hello world'.""")
    }

        then:
        def e = thrown(BuildActionFailureException)
        e.cause instanceof RuntimeException
        TextUtil.normaliseLineSeparators(e.cause.message) == """Multiple build operations failed.
    broken: one
    broken: two"""
    }

    def setupBuildWithDependencyResolution() {
        server.start()

        settingsFile << """
            rootProject.name = 'root'
            include 'a', 'b'