# 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"
    }

    def "cannot query strict task output file property until task starts execution"() {
        taskTypeWithOutputFileProperty()
        settingsFile << "rootProject.name = 'broken'"
        buildFile """
            task producer(type: FileProducer) {
                output.disallowUnsafeRead()
                output = layout.buildDir.file("text.out")
                def other = file('ignore')

// including known-broken ports.
var List = []OSArch{
{{range .}}	{ {{ printf "%q" .GOOS }}, {{ printf "%q" .GOARCH }} },
{{end}}
}

var distInfo = map[OSArch]osArchInfo {
{{range .}}	{ {{ printf "%q" .GOOS }}, {{ printf "%q" .GOARCH }} }:
{ {{if .CgoSupported}}CgoSupported: true, {{end}}{{if .FirstClass}}FirstClass: true, {{end}}{{if .Broken}} Broken: true, {{end}} },
{{end}}
}