return new TestScalaComponent()
    }

    @Requires(IntegTestPreconditions.NotParallelExecutor)
    @UnsupportedWithConfigurationCache(because = "parallel by default")
    def "reuses compiler daemons within a single project across multiple builds when enabled"() {
        withSingleProjectSources()
        withPersistentScalaCompilerDaemons()

        when:
        succeeds("compileAll")

        then:

        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:

    }

    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

    def "can stop a daemon that is using a different java home"() {
        given:
        succeeds()
        daemons.daemon.assertIdle()

        when:
        executer.withJavaHome(AvailableJavaHomes.differentJdk.javaHome)
        executer.withArguments("--stop").run()

        then:
        stopsSingleDaemon()
    }

    def "reports exact number of daemons stopped and keeps console output clean"() {

import org.gradle.launcher.daemon.context.DaemonConnectDetails;
import org.gradle.launcher.daemon.context.DaemonContext;
import org.gradle.launcher.daemon.diagnostics.DaemonStartupInfo;
import org.gradle.launcher.daemon.logging.DaemonMessages;
import org.gradle.launcher.daemon.protocol.Message;
import org.gradle.launcher.daemon.registry.DaemonInfo;
import org.gradle.launcher.daemon.registry.DaemonRegistry;

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

    def "daemons do some work - sit idle - then timeout and die"() {
        //in this particular test we need to make the daemon timeout
        //shorter than the state transition timeout so that
        //we can detect the daemon idling out within state verification window
        daemonIdleTimeout = stateTransitionTimeout / 2

        when:
        startBuild()

        then:
        busy()

        when:
        completeBuild()

import spock.lang.Issue

/**
 * Tests that init scripts are used from the _clients_ GRADLE_HOME, not the daemon server's.
 */
@Issue("https://issues.gradle.org/browse/GRADLE-2408")
@LeaksFileHandles("isolated daemons are not always stopped in time")
//may fail with 'Unable to delete file: daemon.out.log'
@Requires(value = IntegTestPreconditions.NotEmbeddedExecutor, reason = "tests a real Gradle distribution")

    public static final String ADVERTISING_DAEMON = "Advertising the daemon address to the clients: ";
    public static final String REMOVING_DAEMON_ADDRESS_ON_FAILURE = "Removing daemon from the registry due to communication failure. Daemon information: ";
    public static final String UNABLE_TO_STOP_DAEMON = "Unable to stop one of the daemons. The daemon may have crashed.";

 */

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