)
    def "daemon spawned from embedded runner has agent enabled"() {
        given:
        executer.tap {
            // Force a separate daemon spawned by the InProcessGradleExecuter
            requireDaemon()
            requireIsolatedDaemons()
        }
        withAgent()
        withDumpAgentStatusTask()

        when:
        succeeds()

        then:
        agentWasApplied()
    }

import org.gradle.integtests.fixtures.executer.ExecutionResult


abstract class AbstractDaemonWorkerExecutorIntegrationSpec extends AbstractWorkerExecutorIntegrationTest {
    def setup() {
        executer.requireDaemon()
        executer.requireIsolatedDaemons()
    }

    @Override
    protected ExecutionResult succeeds(String... tasks) {
        executer.withWorkerDaemonsExpirationDisabled()
        return super.succeeds(tasks)

import org.junit.Before


abstract class AbstractScriptCachingIntegrationTest : AbstractKotlinIntegrationTest() {

    @Before
    fun isolatedDaemons() {
        executer.apply {
            requireDaemon()
            requireIsolatedDaemons()
        }
    }

    @After
    fun stopDaemons() {
        build("--stop")
    }

    protected

                return "using client JVM args"
            }

            @Override
            void setup(AbstractConfigurationCacheIntegrationTest test) {
                test.executer.requireDaemon().requireIsolatedDaemons()
                test.executer.withCommandLineGradleOpts("-D${prop}=${value}")
            }
        }
    }

import org.gradle.integtests.fixtures.executer.GradleHandle
import org.gradle.test.fixtures.ConcurrentTestUtil

abstract class DaemonIntegrationSpec extends AbstractIntegrationSpec {
    def setup() {
        executer.requireDaemon()
        executer.requireIsolatedDaemons()
    }

    void stopDaemonsNow() {
        result = executer.withArguments("--stop", "--info").run()
    }

    void buildSucceeds() {

@IntegrationTestTimeout(120)
class WorkerDaemonExpirationIntegrationTest extends AbstractIntegrationSpec {

    def setup() {
        given:
        executer.requireIsolatedDaemons()
        executer.requireDaemon()

        and:
        settingsFile << """
            rootProject.name = 'root'
            include 'a', 'b'
        """.stripIndent()
        buildFile << """

    def "still prints errors when exception misbehaves"() {
        // When running in-process, the NPE propagates out of the test fixtures
        executer.requireIsolatedDaemons()
        executer.requireDaemon()

        buildFile << """
class BadException extends Exception {
   String getMessage() {
     throw new NullPointerException()
   }
}

throw new BadException()
"""
        when:

        fails()

        then:
        assertCauseWithStacktrace('show stacktrace was ALWAYS')
    }

    def "emits actionable message when wrong configuration is used"() {
        setup:
        executer.requireDaemon().requireIsolatedDaemons()
        file('gradle.properties') << 'org.gradle.logging.stacktrace=suppress'

        when:
        fails()

        then:

            assert !gradle.isRunning()
        }
    }

    def "does not log daemon cancel message for continuous build"() {
        setup:
        executer.requireDaemon()
        executer.requireIsolatedDaemons()
        setupJavaProject()

        when:
        succeeds("build")

        and:
        sendEOT()

        then:

class DaemonToolchainIntegrationTest extends AbstractIntegrationSpec implements DaemonJvmPropertiesFixture, JavaToolchainFixture {
    def setup() {
        executer.requireIsolatedDaemons()
        executer.requireDaemon()
    }

    def "Given daemon toolchain version When executing any task Then daemon jvm was set up with expected configuration"() {
        given:
        writeJvmCriteria(Jvm.current())
        captureJavaHome()