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()
    }

     */
    List<? extends DaemonFixture> getVisible();

    /**
     * Convenience to get a single daemon. Fails if there is not exactly 1 daemon.
     */
    DaemonFixture getDaemon();

    /**
     * Returns the base dir of the daemon.
     */
    File getDaemonBaseDir();

    /**

    }

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

        cancelBuild(task)

        assert daemons.daemons.size() == 1
    }

    private void assertTaskIsCancellable(String task, boolean buildCacheEnabled = false) {
        startBuild(task, buildCacheEnabled)
        cancelBuild(task)

        def build = executer.withTasks("help").withArguments("--debug").start()
        build.waitForFinish()
        assert daemons.daemons.size() == 1
    }

    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:

    }

    DaemonsFixture daemons(String gradleVersion) {
        new DaemonLogsAnalyzer(executer.daemonBaseDir, gradleVersion)
    }

    GradleHandle startAForegroundDaemon() {
        int currentSize = daemons.getRegistry().getAll().size()
        def daemon = executer.withArgument("--foreground").start()
        // Wait for foreground daemon to be ready

        1 * client1.stop()
        1 * client2.stop()
        0 * client3.stop()

        and:
        reserveIdleClient(oneGbOptions) == client3
    }

    def "expires all idle daemons when requested memory is equal than what all daemons consume"() {
        given:
        def client1 = reserveNewClient(oneGbOptions)
        def client2 = reserveNewClient(threeGbOptions)

        and: