maxParallelUsages = 1
            }

            task broken(type: Consumer) {
                // reference will be set by name
            }
        """
        enableStableConfigurationCache()
        executer.expectDocumentedDeprecationWarning(
            "Build service 'counter' is being used by task ':broken' without the corresponding declaration via 'Task#usesService'. " +

func FirstClass(goos, goarch string) bool {
	return distInfo[OSArch{goos, goarch}].FirstClass
}

// Broken reportsr whether goos/goarch is considered a broken port.
// (See https://go.dev/wiki/PortingPolicy#broken-ports.)
func Broken(goos, goarch string) bool {
	return distInfo[OSArch{goos, goarch}].Broken

    tasks {
        show(Task) {
            doLast {
                println "value = " + $.things.test.value
            }
        }
    }
    broken(Thing) {
        throw new RuntimeException('broken')
    }
    things {
        main(Thing) {
            value = $.broken.value
        }
        test(Thing) {
            value = "12"
        }
    }
}
'''
        when:
        succeeds "show"

			cniDaemonSet := getCNIDaemonSet(t, c)
			deleteCNIDaemonset(t, c)

			// Rollout restart instances in the echo namespace, and wait for a broken instance.
			t.Log("Rollout restart echo instance to get a broken instance")
			rolloutCmd := fmt.Sprintf("kubectl rollout restart deployment -n %s", ns.Name())
			if _, err := shell.Execute(true, rolloutCmd); err != nil {

        "unknown"            | "Task 'unknown' not found in root project 'broken' and its subprojects."
        "unknown:help"       | "Cannot locate tasks that match 'unknown:help' as project 'unknown' not found in root project 'broken'."
        ":unknown:help"      | "Cannot locate tasks that match ':unknown:help' as project 'unknown' not found in root project 'broken'."

        buildFile << """
            apply plugin: '${language.name}'
            dependencies {
                implementation files("broken.jar")
            }
        """
        file("broken.jar").text = "this is not a jar"
        file("src/main/${language.name}/Main.${language.name}") << "public class Main {}"

        expect:
        fails(language.compileTaskName)

		cfgs := store.List(colschema.GroupVersionKind(), "")
		broken := false
		for _, cfg := range cfgs {
			k := key{
				col, resource.FullName{
					Name:      resource.LocalName(cfg.Name),
					Namespace: resource.Namespace(cfg.Namespace),
				}, id,
			}
			if res, ok := i.found[k]; ok {
				if !broken && !fn(res) {
					broken = true
				}
				cache[k] = res
				continue
			}

This would lead to builds that are either totally broken, or worse, broken is a way that is subtle, flaky, and difficult to debug.

[source,groovy]
dependencies {
  // This publication model can make your build flaky and broken!
  implementation project(":other").tasks.someOtherJar
}

import java.util.concurrent.locks.Lock

abstract class AbstractQueueTest extends Specification {
    final Condition broken = Stub() {
        await() >> { throw new UnsupportedOperationException("should not be waiting") }
    }
    final Lock lock = Stub() {
        newCondition() >> broken
    }

    def unicast() {
        InterHubMessage message = Stub() {

    }

    @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()