when:
        buildSucceeds()

        then:
        def daemon = daemons.daemon

        when:
        daemon.assertIdle()
        daemon.kill()

        then:
        buildSucceeds()

        and:
        def analyzer = daemons
        analyzer.daemons.size() == 2        //2 daemon participated
        analyzer.visible.size() == 1        //only one address in the registry
    }

        wasForked()

        and:
        daemons.daemon.stops()
    }

    def "stops single use daemon when build fails"() {
        requireJvmArg('-Xmx64m')

        file('build.gradle') << "throw new RuntimeException('bad')"

        when:
        fails()

        then:
        wasForked()
        failureHasCause "bad"

        and:
        daemons.daemon.stops()
    }

    }

    private int countExecutedCommands() {
        toolingApi.daemons.daemon.log.count("command = ")
    }

    private void createIdleDaemon() {
        withConnection { connection ->
            connection.model(GradleBuild).get()
        }
        toolingApi.daemons.daemon.assertIdle()
    }

    def cleanup() {
        toolingApi.close()
    }

Live Daemons appear under the name `GradleDaemon`.
Because this command uses the JDK, you can view Daemons running any version of Gradle.

[[enable_deamon]]
== Enable Daemon

Gradle enables the Daemon by default since Gradle 3.0.
If your project doesn't use the Daemon, you can enable it for a single build with the `--daemon` flag when you run a build:

----
$ gradle <task> --daemon
----

    private final Set<DaemonConnectDetails> daemons = new CopyOnWriteArraySet<DaemonConnectDetails>();
    private final DaemonStopClient client;

    public ShutdownCoordinator(DaemonStopClient client) {
        this.client = client;
    }

    @Override
    public void daemonStarted(DaemonConnectDetails daemon) {
        daemons.add(daemon);
    }

    @Override
    public void stop() {

        reason = "Testing the daemons"
    )
    def "daemon with the same agent status is reused"() {
        given:
        executer.requireIsolatedDaemons()
        withDumpAgentStatusTask()

        when:
        withAgentApplied(useAgentOnFirstRun)
        succeeds()

        then:
        daemons.daemon.becomesIdle()

        when:

                // This notifies the cancellation handler that a worker daemon has been in use during this build session.  If the
                // build session is cancelled, we can't guarantee that all worker daemons are in a safe state, so the cancellation
                // handler will stop any long-lived worker daemons.  If a worker is not used during this session (i.e. this method

 */

package org.gradle.integtests.fixtures.daemon

import org.gradle.internal.logging.services.LoggingServiceRegistry
import org.gradle.internal.service.ServiceRegistryBuilder
import org.gradle.internal.service.scopes.BasicGlobalScopeServices
import org.gradle.launcher.daemon.client.DaemonClientGlobalServices
import org.gradle.launcher.daemon.registry.DaemonRegistry
import org.gradle.launcher.daemon.registry.DaemonRegistryServices

    }

    void assertNoRunningDaemons() {
        waitFor.eventually {
            toolingApi.daemons.daemons*.assertStopped()
        }
    }

    void assertNumberOfRunningDaemons(number) {
        waitFor.eventually {
            assert toolingApi.daemons.daemons.size() == number
            toolingApi.daemons.daemons*.assertBusy()
        }
        // `eventually` throws a runtime exception when the condition is never met

    }

    /**
     * Creates the services for sending simple messages to daemons.
     *
     * Currently, there are two clients which can be used from this registry:
     * - {@link DaemonStopClient} that can be used to stop daemons.
     * - {@link NotifyDaemonAboutChangedPathsClient} that can be used to notify daemons about changed paths.
     */