}

    @TargetGradleVersion(">=3.0 <7.3")
    def "does not run action when configuration fails"() {
        given:
        buildFile << 'throw new RuntimeException("broken")'

        when:
        withConnection {
            it.action(new ActionShouldNotBeCalled()).run()
        }

        then:
        BuildException e = thrown()

        given:
        buildFile << """
model {
    components {
        main(NativeExecutableSpec)
    }
}
         """

        and:
        file("src/main/cpp/broken.cpp") << """
        #include <iostream>

        'broken
"""

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

	)

	requestLatency = compbasemetrics.NewHistogramVec(
		&compbasemetrics.HistogramOpts{
			Name:           "apiserver_delegated_authn_request_duration_seconds",
			Help:           "Request latency in seconds. Broken down by status code.",
			Buckets:        []float64{0.25, 0.5, 0.7, 1, 1.5, 3, 5, 10},
			StabilityLevel: compbasemetrics.ALPHA,
		},
		[]string{"code"},
	)

	metrics = registerables{
		requestTotal,

var netpollBrokenLock mutex
var netpollBroken bool

func netpollGenericInit() {
	netpollInited.Store(1)
}

func netpollBreak() {
	lock(&netpollBrokenLock)
	broken := netpollBroken
	netpollBroken = true
	if !broken {
		notewakeup(&netpollNote)
	}
	unlock(&netpollBrokenLock)
}

// Polls for ready network connections.
// Returns list of goroutines that become runnable.

embedded file of xtest in subdirectory of package
-- broken_no_matching_files/go.mod --
module example.com/broken
go 1.16

require (
	example.com/brokendep v0.1.0
)

replace (
	example.com/brokendep v0.1.0 => ./brokendep
)
-- broken_no_matching_files/f.go --
package broken

import _ "example.com/brokendep"

func F() {}
-- broken_no_matching_files/brokendep/go.mod --

        buildFile << """
            assert gradle.includedBuilds.empty

            task broken {
                dependsOn classes
                doLast {
                    assert gradle.includedBuilds.empty
                    gradle.includedBuild("buildB")
                }
            }
        """

        when:
        fails("broken")

        then:

        result.graphState == graphState
        result.failure == null
    }

    def "can mark as failed"() {
        org.gradle.internal.Factory<String> broken = { "too bad" }
        def failure = new ModuleVersionResolveException(Stub(ModuleVersionSelector), broken)

        when:
        result.failed(failure)

        then:
        result.hasResult()
        result.failure == failure

        when:

	)

	requestLatency = compbasemetrics.NewHistogramVec(
		&compbasemetrics.HistogramOpts{
			Name:           "apiserver_delegated_authz_request_duration_seconds",
			Help:           "Request latency in seconds. Broken down by status code.",
			Buckets:        []float64{0.25, 0.5, 0.7, 1, 1.5, 3, 5, 10},
			StabilityLevel: compbasemetrics.ALPHA,
		},
		[]string{"code"},
	)
)

        def requested = newSelector(group, module, version)
        org.gradle.internal.Factory<String> broken = { "broken" }
        new DefaultUnresolvedDependencyResult(requested, false, ComponentSelectionReasons.requested(), newModule(group, module, selectedVersion), new ModuleVersionResolveException(newSelector(DefaultModuleIdentifier.newId(group, module), version), broken))
    }

        !lines.contains('lifecycle')
        !lines.contains('warn')
    }

    def "broken listener fails build but does not kill logging output"() {
        buildFile << """
            class BrokenListener implements StandardOutputListener {
                void onOutput(CharSequence output) {
                    throw new RuntimeException("broken")
                }
            }
            def output = new BrokenListener()