return new NoDaemonGradleExecuter(this, testDirectoryProvider, version, buildContext).withWarningMode(null);
    }

    @Override
    boolean worksWith(Jvm jvm) {
        // Milestone 4 was broken on the IBM jvm
        if (jvm.isIbmJvm() && isVersion("1.0-milestone-4")) {
            return false;
        }

        JavaVersion javaVersion = jvm.getJavaVersion();
        if (javaVersion == null) {

        when:
        coordinator.runCommand(command, "command")

        then:
        DaemonUnavailableException unavailableException = thrown()
        unavailableException.message == 'This daemon is in a broken state and will stop.'
    }

    def "cannot run command after finish command action has failed"() {
        Runnable command = Mock()
        RuntimeException failure = new RuntimeException()

        when:

     * If that's the case it means it's not necessary to perform more checks for this version, because we already
     * know it's broken in some way.
     *
     * @param result where to notify that metadata is broken, if broken
     * @param metadataProvider the metadata provider
     * @return true if metadata is not usable
     */

import java.io.Serializable;

public class NotDeserializable implements Action<WorkerProcessContext>, Serializable {
    private void readObject(ObjectInputStream instr) throws IOException {
        throw new IOException("Broken");
    }

    public void execute(WorkerProcessContext workerProcessContext) {
        throw new UnsupportedOperationException();
    }

        repositoryInteractions {
            'org.utils:api:2.1' {
                expectResolve()
            }
        }

        then:
        succeeds ":checkDeps"
    }

    def "reports broken module when component selection rule requires meta-data"() {
        buildFile << """
configurations {
    conf {
        resolutionStrategy.componentSelection {
            all { ComponentSelection selection ->

     * then the file type of the file metadata is of type
     * {@link org.gradle.internal.file.FileType#Missing}.
     * <p>
     * Such cases include:
     * <ul>
     *     <li>actual missing files</li>
     *     <li>broken symlinks</li>
     *     <li>circular symlinks</li>
     *     <li>named pipes</li>
     * </ul>
     */
    FileMetadata stat(File f);

 * limitations under the License.
 */
package org.gradle.tooling;

import org.gradle.api.Incubating;

import javax.annotation.Nullable;

/**
 * Represent a test assertion failure where the test fails due to a broken assertion.
 *
 * @since 7.6
 */
@Incubating
public interface TestAssertionFailure extends TestFailure {

    /**
     * Returns the string representation of the expected value.
     *

				break
			}
			brokers = append(brokers, *host)
		}
		if err != nil {
			return cfg, err
		}

		clientAuthCfgVal := getCfgVal(EnvKafkaTLSClientAuth, k, kv.Get(KafkaTLSClientAuth))
		clientAuth, err := strconv.Atoi(clientAuthCfgVal)
		if err != nil {
			return cfg, err
		}

		kafkaArgs := kafka.Config{
			Enabled: enabled,
			Brokers: brokers,

        public BrokenAction(String name) {
            this.name = name;
        }

        @Override
        public Object execute(BuildController controller) {
            throw new RuntimeException("broken: " + name);
        }
    }

        public boolean nightly;
        public boolean releaseNightly;
        public boolean activeRc;
        public String rcFor;
        public String milestoneFor;
        public boolean broken;
        public String downloadUrl;
        public String checksumUrl;
        public String wrapperChecksumUrl;
    }

    public static MyProductReleaseList retrieve() {