import org.gradle.api.specs.Spec;

/**
 * A predicate against objects of type T that can explain the unsatisfied reason.
 *
 * @param <T> The target type for this Spec
 */
public interface ExplainingSpec<T> extends Spec<T> {

    /**
     * Explains why the spec is not satisfied.
     *
     * @param element candidate

        String whyUnsatisfied(Object element) {
            ""
        }
    }

    def "maybeConnect() returns connection to any daemon that matches spec"() {
        given:
        startIdleDaemon()
        startIdleDaemon()

        expect:
        def connection = connector.maybeConnect({it.pid < 12} as ExplainingSpec)

public class ExplainingSpecs {

    private static final ExplainingSpec<Object> SATISFIES_ALL = new ExplainingSpec<Object>() {
        @Override
        public boolean isSatisfiedBy(Object element) {
            return true;
        }
        @Override
        public String whyUnsatisfied(Object element) {
            return null;
        }
    };

    public static <T> ExplainingSpec<T> satisfyAll() {

     */
    @Nullable
    DaemonClientConnection connect(ExplainingSpec<DaemonContext> constraint);

    /**
     * Starts a new daemon and returns a connection to it.
     */
    DaemonClientConnection startDaemon(ExplainingSpec<DaemonContext> constraint);

    /**
     * Starts a new daemon for single use and returns a connection to it.
     */

            assert spec.isSatisfiedBy(d1)
            connection
        }
        1 * connection.dispatch({it instanceof Stop})
        1 * connection.receive() >> new Failure(new RuntimeException())
        1 * connection.dispatch({it instanceof Finished})
        1 * connection.stop()

        1 * connector.maybeConnect(_) >> { ExplainingSpec spec ->

        final List<DaemonInfo> compatibleIdleDaemons = getCompatibleDaemons(idleDaemons, constraint);
        return findConnection(compatibleIdleDaemons);
    }

    private DaemonClientConnection connectToCanceledDaemon(Collection<DaemonInfo> busyDaemons, ExplainingSpec<DaemonContext> constraint) {

    private final Daemon daemon;
    private final ExplainingSpec<DaemonContext> compatibilitySpec;

    public static final String EXPIRATION_REASON = "other compatible daemons were started";

    CompatibleDaemonExpirationStrategy(Daemon daemon, ExplainingSpec<DaemonContext> compatibilitySpec) {
        this.daemon = daemon;
        this.compatibilitySpec = compatibilitySpec;
    }

     */
    public void stop() {
        CountdownTimer timer = Time.startCountdownTimer(STOP_TIMEOUT_SECONDS, TimeUnit.SECONDS);
        final Set<String> seen = new HashSet<String>();

        ExplainingSpec<DaemonContext> spec = new ExplainingSpec<DaemonContext>() {
            @Override
            public String whyUnsatisfied(DaemonContext element) {
                return "already seen";
            }

            @Override

 * limitations under the License.
 */

package org.gradle.launcher.daemon.client;

import org.gradle.api.internal.DocumentationRegistry;
import org.gradle.api.internal.specs.ExplainingSpec;
import org.gradle.api.logging.Logger;
import org.gradle.api.logging.Logging;
import org.gradle.internal.daemon.client.execution.ClientBuildRequestContext;
import org.gradle.internal.id.IdGenerator;

 */
package org.gradle.launcher.daemon.context;

import org.gradle.api.internal.specs.ExplainingSpec;
import org.gradle.internal.jvm.JavaInfo;
import org.gradle.internal.jvm.Jvm;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;

public class DaemonCompatibilitySpec implements ExplainingSpec<DaemonContext> {

    private final DaemonRequestContext desiredContext;