executer.expectDeprecationWarnings(warningsCount)
        }
        executer.withWarningMode(warnings)
        warnings == WarningMode.Fail ? fails('thisIsADeprecatedTask', 'broken') : succeeds('thisIsADeprecatedTask', 'broken')

        then:
        output.contains('build.gradle:2)') == warningsCount > 0
        output.contains('build.gradle:4)') == warningsCount > 0

        and:
        file("src/main/cpp/broken.cpp") << "broken!"

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

# tag::cli[]
# gradle --quiet broken
# end::cli[]
executable: gradle
args: broken
flags: --quiet
expect-failure: true
expected-output-file: taskExecutionEvents.kotlin.out

    @ToBeFixedForConfigurationCache
    def "fails to build when project code is broken"() {
        useXcodebuildTool()

        given:
        buildFile << """
            apply plugin: 'swift-application'
         """

        and:
        file("src/main/swift/broken.swift") << "broken!"

        and:
        succeeds("xcode")

        expect:
        def failure = xcodebuild

Searched in the following locations:
    ${javadocArtifact.uri}""")
    }

    def "resolves and recovers from broken artifacts"() {
        given:
        module.artifact(type: "source", classifier: "broken-sources", ext: "jar", conf: "sources")
        module.publish()

        fixture.expectSourceArtifact("my-sources")
                .expectSourceArtifactFailure()

                throw new ArithmeticException('broken')
            }
        """
        expect:
        fails "do-stuff"

        failure.assertHasFileName(String.format("Build file '%s'", buildFile))
        failure.assertHasLineNumber(3)
        failure.assertHasDescription("Execution failed for task ':do-stuff'.")
        failure.assertHasCause("broken")
    }

    configurations {
        broken
    }
    configurations.broken.attributes.attribute(attr, $value)
"""

        when:
        fails()

        then:
        failure.assertHasCause("Could not isolate value ")
        failure.assertHasCause("Could not serialize value of type ")

        where:
        type      | value
        "Thing"   | "new Thing(name: 'broken')"
        "Project" | "project"

        pluginBuilder.publishTo(executer, file('external.jar'))

        buildFile << '''
buildscript {
    dependencies {
        classpath files('external.jar')
    }
}
apply plugin: 'broken'
'''

        when:
        fails()

        then:
        failure.assertHasCause("Failed to apply plugin 'broken'")
        failure.assertHasCause("throwing plugin")

        failure.assertThatDescription(CoreMatchers.startsWith("A problem occurred evaluating project ':other'"))
        failure.assertHasCause('broken')
    }

    def reportsBuildSrcFailure() {
        when:
        file('buildSrc/src/main/java/Broken.java') << 'broken!'

        then:
        fails()

        and:
        failure.assertHasDescription("Execution failed for task ':buildSrc:compileJava'.")
    }

tasks.register('ok')

tasks.register('broken') {
    dependsOn ok
    doLast {
        throw new RuntimeException('broken')
    }
}

gradle.taskGraph.beforeTask { Task task ->
    println "executing $task ..."
}

gradle.taskGraph.afterTask { Task task, TaskState state ->
    if (state.failure) {
        println "FAILED"
    }
    else {
        println "done"
    }