go tool dist list -v
stdout linux/amd64
cp stdout tool-v.txt

go tool dist list -broken
stdout $GOOS/$GOARCH
cp stdout tool-broken.txt

go tool dist list -json
stdout '"GOOS": "linux",\n\s*"GOARCH": "amd64",\n'
cp stdout tool-json.txt

go tool dist list -json -broken
stdout '"GOOS": "'$GOOS'",\n\s*"GOARCH": "'$GOARCH'",\n'
cp stdout tool-json-broken.txt

[short] stop

                }
            }
        """
        file("buildSrc/src/main/resources/META-INF/gradle-plugins/test.broken.properties") << """
            implementation-class=PluginImpl
        """
        buildFile << """
            plugins {
                id("test.broken")
            }
        """

        expect:
        2.times {
            fails("broken")

        loggedOncePerBuild('gradle.buildFinished failure=[java.lang.RuntimeException: build B broken, java.lang.RuntimeException: build C broken]', [':'])

        failure.assertHasFailures(3)
        failure.assertHasDescription("build A broken")
            .assertHasFileName("Build file '${buildA.buildFile}'")

        setupBuildWithProjectArtifactTransforms()
        taskQueriesFilesWithoutDeclaringInput()

        when:
        run("broken")

        then:
        assertTransformed("a.jar", "b.jar")
        output.contains("result = [a.jar.green, b.jar.green]")

        when:
        run("broken")

        then:
        assertTransformed()
        output.contains("result = [a.jar.green, b.jar.green]")
    }

                    broken b.flatMap { it.output }
                    broken b.flatMap { throw new RuntimeException("broken artifact") }
                }
            }

            project(':a') {
                dependencies {
                    implementation project(':b')
                }
            }
        """

        when:
        run(":a:resolve")

        then:
        noExceptionThrown()
    }

    }
}
configurations { broken }
dependencies {
    broken 'group:projectA:1.3'
}
task showBroken {
    def files = configurations.broken
    doLast { println files.files }
}
"""

        when:
        module.pom.expectGetBroken()
        fails("showBroken")

        then:
        failure.assertResolutionFailure(':broken')

        failure.assertHasCause("broken")
    }

    def "fails when @ComponentType registration is badly formed"() {
        buildFile << """
            @Managed
            interface BrokenComponentSpec extends ComponentSpec {
            }

            class Broken extends RuleSource {
                @ComponentType

        buildFile << """
            task broken {
                doLast {
                    throw new RuntimeException("broken")
                }
            }
        """

        expect:
        executer.withArguments("-Dorg.gradle.logging.level=${level}")
        fails("broken")

        and:
        // Ensure the failure is a location that the fixtures can see

    }

    def "transports exception with broken methods"() {
        def broken = new CompletelyBrokenException()

        when:
        def transported = transport(broken)

        then:
        transported.class == CompletelyBrokenException
    }

    def "transports unserializable exception with broken methods"() {
        def broken = new CompletelyBrokenException() {

        def location = URI.create("scheme:name")
        def failure = new RuntimeException()

        expect:
        def e = ResourceExceptions.failure(location, "broken", failure)
        e instanceof ResourceException
        e.location == location
        e.message == "broken"
        e.cause == failure
    }

    def "wraps failure with different location"() {
        def location = URI.create("scheme:name")