@Managed interface Person {
    @Unmanaged
    InputStream getInput()
    void setInput(InputStream name)
}

model {
    barry(Person)
    barry {
        input {
            println "broken"
        }
    }
}
'''

        when:
        fails "model"

        then:
        failure.assertHasLineNumber(11)

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

            }
        }
    }

    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)

)

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

import java.io.Serializable;

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

        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'

        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'.""")
    }

import java.io.Serializable;

public class NotDeserializable implements Action<WorkerProcessContext>, Serializable {
    private void readObject(ObjectInputStream instr) throws IOException {
        throw new IOException("Broken");
    }

    public void execute(WorkerProcessContext workerProcessContext) {
        throw new UnsupportedOperationException();
    }

        public BrokenAction(String name) {
            this.name = name;
        }

        @Override
        public Object execute(BuildController controller) {
            throw new RuntimeException("broken: " + name);
        }
    }