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

        def runnable1 = {
            instant.broken1
            throw failure1
        }

        def failure2 = new RuntimeException()
        def runnable2 = {
            instant.broken2
            throw failure2
        }

        when:
        def executor = factory.create('test')
        executor.execute(runnable1)
        thread.blockUntil.broken1
        thread.block()

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

                    compile {
                        outgoing {
                            variants {
                                broken1 {
                                    attributes.attribute(attr, true)
                                }
                                broken2 {
                                    attributes.attribute(attr, false)
                                }
                            }

        then:
        allResults.empty
    }

    def "visual studio not available when broken installs found"() {
        def visitor = new TreeFormatter()
        def dir1 = tmpDir.createDir("broken1")
        def install1 = legacyVsInstall(dir1, "12")
        def dir2 = tmpDir.createDir("broken2")
        def install2 = legacyVsInstall(dir2, "13")

        given:

        adapter.completed('suite1', new TestCompleteEvent(200L))
        adapter.started(broken, new TestStartEvent(100L, 'suite2'))
        adapter.failure('broken', TestFailure.fromTestFrameworkFailure(new RuntimeException()))
        adapter.completed('broken', new TestCompleteEvent(200L))
        adapter.completed('suite2', new TestCompleteEvent(200L))

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

	config.Metadata.Retry.Backoff = (1 * time.Second)
	config.Metadata.RefreshFrequency = (15 * time.Minute)

	target.config = config

	brokers := []string{}
	for _, broker := range args.Brokers {
		brokers = append(brokers, broker.String())
	}

	client, err := sarama.NewClient(brokers, config)
	if err != nil {
		if !errors.Is(err, sarama.ErrOutOfBrokers) {
			target.loggerOnce(context.Background(), err, target.ID().String())