when:
        executer.withArgument("--continue")
        fails("broken1", "broken2", "broken3")

        then:
        failure.assertHasCause("Cannot call ${description} on task ':broken1' after task has started execution.")
        failure.assertHasCause("Cannot call ${description} on task ':broken2' after task has started execution.")

        where:
        config                                                      | description

    static class InvalidSignature extends RuleSource {
        @Rules
        void broken1(String string, RuleSource ruleSource) {
        }

        @Rules
        void broken2() {
        }

        @Rules
        String broken3(String string) {
            "broken"
        }
    }

            buildFile << """
                assert gradle.includedBuilds.empty
            """
            validationTask(buildFile, "broken1", """
                assert gradle.includedBuilds.empty
                gradle.includedBuild("buildA")
            """)
            validationTask(buildFile, "broken2", """
                assert gradle.includedBuilds.empty
                gradle.includedBuild("buildB")
            """)
        }

                assert gradle.includedBuilds.empty
            """
        }
        validationTask(buildB.buildFile, "broken1", """
            assert gradle.includedBuilds.empty
            gradle.includedBuild("buildA")
        """)
        validationTask(buildB.buildFile, "broken2", """
            assert gradle.includedBuilds.empty
            gradle.includedBuild("buildC")
        """)

Tom Tresansky <******@****.***> 1692994246 -0400

    }

    def "#description means do not run any tasks even when build logic injects tasks to execute"() {
        file('build.gradle') << """
            gradle.startParameter.taskNames = ["broken2"]

            gradle.taskGraph.whenReady {
                throw new RuntimeException()
            }
        """

        when:
        withConnection { ProjectConnection connection ->

        throw new RuntimeException('broken closure')
    }
    task broken {
        doLast { throw new RuntimeException('broken task') }
    }
"""

        when:
        fails("broken")

        then:
        failure.assertHasFailures(2)
        failure.assertHasDescription("Execution failed for task ':broken'.")
                .assertHasCause("broken task")

func TestMutexLock(t *testing.T) {
	var mu XFDMutex

	if !mu.Incref() {
		t.Fatal("broken")
	}
	if mu.Decref() {
		t.Fatal("broken")
	}

	if !mu.RWLock(true) {
		t.Fatal("broken")
	}
	if mu.RWUnlock(true) {
		t.Fatal("broken")
	}

	if !mu.RWLock(false) {
		t.Fatal("broken")
	}
	if mu.RWUnlock(false) {
		t.Fatal("broken")
	}
}

func TestMutexClose(t *testing.T) {
	var mu XFDMutex

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