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

        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'.")

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: