id("gradlebuild.generate-subprojects-info")  // CI: Generate subprojects information for the CI testing pipeline fan out
    id("gradlebuild.cleanup")                    // CI: Advanced cleanup after the build (like stopping daemons started by tests)

    id("gradlebuild.update-versions")            // Local development: Convenience tasks to update versions in this build: 'released-versions.json', 'agp-versions.properties', ...

        } catch (UnsupportedOperationException e) {
            return -1;
        }
    }

    /**
     * Select idle daemon clients to stop.
     *
     * @param selectionFunction Gets all idle daemon clients, daemons of returned clients are stopped
     */
    @VisibleForTesting

            }
        });

        // User likely doesn't care about daemons that stopped a long time ago
        for (DaemonStopEvent event : sortedEvents) {
            Long pid = event.getPid();
            if (event.occurredInLastHours(RECENTLY) && !uniqueStoppedPids.contains(pid)) {
                // We can only determine if two DaemonStopEvent point at the same daemon if we know the PIDs
                if (pid != null) {

        this.daemon = daemon;
        this.compatibilitySpec = compatibilitySpec;
    }

    CompatibleDaemonExpirationStrategy(Daemon daemon) {
        this(daemon, new DaemonCompatibilitySpec(daemon.getDaemonContext().toRequest()));
    }

    @Override
    public DaemonExpirationResult checkExpiration() {

                doLast {
                    assert services.get(WorkerDaemonClientsManager).allClients.size() == 0
                }
            }
"""
    }

    def "reuses compiler daemons across continuous build instances" () {
        def inputFileName = sourceFileName
        def inputFile = file(inputFileName).createFile()
        def compilerDaemonIdentityFileName = "build/compilerId"

     *
     * Execution of the work may begin immediately.
     *
     * Work submitted using {@link WorkerExecutor#processIsolation()} will execute in an idle daemon that meets the requirements set
     * in the {@link ProcessWorkerSpec}.  If no idle daemons are available, a new daemon will be started.  Any errors
     * will be thrown from {@link #await()} or from the surrounding task action if {@link #await()} is not used.
     */

                    sync.releaseAll()
                    toolingApi.daemons.daemon.kill()
                    killed = true
                }
            }, EnumSet.of(OperationType.TEST)).run()
        }

        then: "build fails with a DaemonDisappearedException"
        GradleConnectionException ex = thrown()
        ex.cause.message.contains('Gradle build daemon disappeared unexpectedly')

        and:
        !result.empty

     * @return the number of builds that the daemon has run
     */
    int getNumberOfBuilds();

    /**
     * @return The time (milliseconds) since epoch at which the daemon was started
     */
    long getStartedAt();

    /**
     * @return The idle timeout (milliseconds) of the daemon
     */
    long getIdleTimeout();

    /**
     * @return The number of running daemons
     */

            for (daemon in daemonsFixture.daemons) {
                if (daemon.logContains('Could not receive message from client.')
                    && daemon.logContains('java.lang.NullPointerException')
                    && daemon.logContains('org.gradle.launcher.daemon.server.exec.LogToClient')) {

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

import java.util.concurrent.atomic.AtomicBoolean;

/**
 * A handler that stops all worker daemons when the build is cancelled.
 */
@ServiceScope(Scope.BuildSession.class)
@NonNullApi
public class WorkerDaemonClientCancellationHandler implements Stoppable {