def reportsActionExecutionFailure() {
        given:
        def thrownFailure = new RuntimeException('broken')
        action { throw thrownFailure }

        when:
        main.run()

        then:
        outputs.stdErr.contains('FAILURE: Build failed with an exception')
        outputs.stdErr.contains('broken')
        completedWithFailure
        failure == thrownFailure
    }

    static def failure = TestFailure.fromTestFrameworkFailure(new RuntimeException('broken'))

    public static junit.framework.Test suite() {
        throw failure.rawFailure
    }
}

public class ATestSetUpWithBrokenSetUp extends TestSetup {
    static def failure = TestFailure.fromTestFrameworkFailure(new RuntimeException('broken'))

    def ATestSetUpWithBrokenSetUp() {

			if !*brokenFlag && platform.Broken(p.GOOS, p.GOARCH) {
				continue
			}
			fmt.Println(p)
		}
		return true
	}

	type jsonResult struct {
		GOOS         string
		GOARCH       string
		CgoSupported bool
		FirstClass   bool
		Broken       bool `json:",omitempty"`
	}

	var results []jsonResult
	for _, p := range platform.List {
		broken := platform.Broken(p.GOOS, p.GOARCH)

			desc: "auth ok",
			response: &authenticator.Response{
				User: &user.DefaultInfo{Name: "admin"},
			},
			status: true,
			want: `
				# HELP authenticated_user_requests [ALPHA] Counter of authenticated requests broken out by username.
				# TYPE authenticated_user_requests counter
				authenticated_user_requests{username="admin"} 1
        # HELP authentication_attempts [ALPHA] Counter of authenticated attempts.

    def reason = new ToolChainAvailability().unavailable("broken")
    def toolChain = new UnavailablePlatformToolProvider(Stub(OperatingSystemInternal), reason)

    def "is not available"() {
        expect:
        !toolChain.available

        def visitor = Mock(DiagnosticsVisitor)

        when:
        toolChain.explain(visitor)

        then:
        1 * visitor.node("broken")
    }

	if len(call.Args) != 2 {
		return
	}
	arg := call.Args[0]
	broken := false

	gofmt := func(e ast.Expr) string { return analysisutil.Format(pass.Fset, e) }

	if uarg, ok := arg.(*ast.UnaryExpr); ok && uarg.Op == token.AND {
		broken = gofmt(left) == gofmt(uarg.X)
	} else if star, ok := left.(*ast.StarExpr); ok {
		broken = gofmt(star.X) == gofmt(arg)
	}

	if broken {
		pass.ReportRangef(left, "direct assignment to atomic value")
	}

                components {
                    main(NativeExecutableSpec)
                }
            }
         """

        and:
        file("src/main/c/broken.c") << """
        #include <stdio.h>

        'broken
"""
        expect:
        fails "mainExecutable"
        failure.assertHasDescription("Execution failed for task ':compileMainExecutableMainC'.")

            $path($listener)
            task broken
        """

        when:
        executer.expectDocumentedDeprecationWarning("Listener registration using ${registrationPoint}() has been deprecated. This will fail with an error in Gradle 9.0. Consult the upgrading guide for further information: https://docs.gradle.org/current/userguide/upgrading_version_7.html#task_execution_events")
        run("broken")

        then:

        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