then:
        out =~ """^$DaemonMessages.NO_DAEMONS_RUNNING

$ReportDaemonStatusClient.STATUS_FOOTER.*""".toString()
    }

    def "reports idle, busy and stopped statuses of daemons"() {
        given:
        server.start()
        buildFile << """
task block {
    doLast {
        ${server.callFromBuild("block")}
    }
}
"""

import org.junit.Rule
import spock.lang.Specification

import static org.gradle.internal.nativeintegration.services.NativeServices.NativeServicesMode
import static org.gradle.launcher.daemon.server.api.DaemonStateControl.State.Idle

class DaemonRegistryServicesTest extends Specification {
    def lockManager = new DefaultFileLockManager(Stub(ProcessMetaDataProvider), Stub(FileLockContentionHandler))
    def chmod = Stub(Chmod)

        // Expire under high JVM memory or GC pressure
        strategies.add(healthExpirationStrategy);

        // Expire compatible, idle, not recently used Daemons after a short time
        strategies.add(new AllDaemonExpirationStrategy(ImmutableList.of(
            new CompatibleDaemonExpirationStrategy(daemon),

	// regardless of maxPerCore (set maxPerCore=0 to leave the limit as-is).
	Min *int32
	// tcpEstablishedTimeout is how long an idle TCP connection will be kept open
	// (e.g. '2s').  Must be greater than 0 to set.
	TCPEstablishedTimeout *metav1.Duration
	// tcpCloseWaitTimeout is how long an idle conntrack entry
	// in CLOSE_WAIT state will remain in the conntrack
	// table. (e.g. '60s'). Must be greater than 0 to set.

class DaemonReuseIntegrationTest extends DaemonIntegrationSpec {
    @Rule BlockingHttpServer server = new BlockingHttpServer()

    def setup() {
        server.start()
    }

    def "idle daemon is reused in preference to starting a new daemon"() {
        given:
        executer.run()
        daemons.daemon.assertIdle()

        when:
        5.times {
            executer.run()
        }

  }

  @Test
  fun idleCallbackInvokedWhenIdle() {
    val idle = AtomicBoolean()
    dispatcher.idleCallback = Runnable { idle.set(true) }
    client.newCall(newRequest("http://a/1")).enqueue(callback)
    client.newCall(newRequest("http://a/2")).enqueue(callback)
    executor.finishJob("http://a/1")
    assertThat(idle.get()).isFalse()
    val ready = CountDownLatch(1)
    val proceed = CountDownLatch(1)

        given:
        toolingApi.close()

        when:
        toolingApi.withConnection {}

        then:
        thrown(IllegalStateException)
    }

    def "cleans up idle daemons when tooling API session is shutdown"() {
        withConnection { connection ->
            connection.model(GradleBuild).setJvmArguments(buildJvmArguments).get()
        }
        toolingApi.daemons.daemon.assertIdle()

        this.connector = connector;
        this.idGenerator = idGenerator;
        this.stopDispatcher = new StopDispatcher();
    }

    /**
     * Requests that the given daemons stop when idle. Does not block and returns before the daemons have all stopped.
     */
    public void gracefulStop(Collection<DaemonConnectDetails> daemons) {
        for (DaemonConnectDetails daemon : daemons) {

import spock.lang.Specification
import spock.lang.Subject

import static org.gradle.internal.nativeintegration.services.NativeServices.NativeServicesMode
import static org.gradle.launcher.daemon.server.api.DaemonStateControl.State.Idle
import static org.gradle.launcher.daemon.server.expiry.DaemonExpirationStatus.DO_NOT_EXPIRE
import static org.gradle.launcher.daemon.server.expiry.DaemonExpirationStatus.GRACEFUL_EXPIRE

    /**
     * Asserts that this daemon becomes idle within a short timeout. Blocks until this has happened.
     */
    DaemonFixture becomesIdle();

    /**
     * Asserts that this daemon stops and is no longer visible to any clients within a short timeout. Blocks until this has happened.
     */
    DaemonFixture stops();

    /**
     * Asserts that this daemon is currently idle.
     */
    void assertIdle();

    /**