then:
        executedAndNotSkipped "${compileTaskPath('main')}", "${compileTaskPath('main2')}"

        and:
        assertOneCompilerDaemonIsRunning()

        when:
        executer.withWorkerDaemonsExpirationDisabled()
        succeeds("clean", "compileAll")

        then:
        executedAndNotSkipped "${compileTaskPath('main')}", "${compileTaskPath('main2')}"

        and:

        assertTwoCompilerDaemonsAreRunning()

        when:
        executer.withWorkerDaemonsExpirationDisabled()
        succeeds("clean", "compileAll", "--info")

        then:
        executedAndNotSkipped "${compileTaskPath('main')}", "${compileTaskPath('main2')}"

        and:

    def setup() {
        executer.requireDaemon()
        executer.requireIsolatedDaemons()
    }

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

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

    DaemonsFixture getDaemons() {

import org.gradle.integtests.fixtures.AbstractContinuousIntegrationTest

abstract class AbstractCompilerContinuousIntegrationTest extends AbstractContinuousIntegrationTest {

    def setup() {
        executer.withWorkerDaemonsExpirationDisabled()
        executer.requireIsolatedDaemons()
    }

    abstract String getCompileTaskName()
    abstract String getCompileTaskType()
    abstract String getSourceFileName()

    }

    def "worker daemons expiration can be disabled using a system property"() {
        when:
        withDebugLogging()
            .withWorkerDaemonsExpirationDisabled()
        succeeds('expireWorkers')

        then:
        outputDoesNotContain('Worker Daemon(s) expired to free some system memory')

    abstract String getCompileTaskType()

    abstract String getApplyAndConfigure()

    abstract TestJvmComponent getComponent()

    def setup() {
        executer.withWorkerDaemonsExpirationDisabled()
        executer.requireDaemon().requireIsolatedDaemons()
        buildFile << """
            import org.gradle.workers.internal.WorkerDaemonClientsManager

        def pid2 = pidFile().text.strip() as long
        pid2 == pid1
    }

    private void startBuild(String task) {
        executer
            .withArgument('--debug')
            .withWorkerDaemonsExpirationDisabled()
            .withTasks(task)

        client = new DaemonClientFixture(executer.start())
    }

    private void cancelBuild() {
        client.kill()

        when:
        args("--max-workers=${maxWorkers}")
        def gradle = executer.withTasks("parallelWorkTask")
                        .requireIsolatedDaemons()
                        .withWorkerDaemonsExpirationDisabled()
                        .start()

        then:
        handler.waitForAllPendingCalls()

        when:
        handler.release(3)

        then:

                }
            }
        """

        file("foo").text = "foo"
        file("anotherProject/foo").text = "foo2"

        when:
        executer.withWorkerDaemonsExpirationDisabled()
        succeeds("runInWorker2")

        then:
        assertWorkerExecuted("runInWorker")
        assertWorkerExecuted("runInWorker2")

        and:
        file("bar/foo").text == "foo"

        when:
        succeeds("run", "--parallel")

        then:
        noExceptionThrown()
    }

    def "re-uses an existing idle worker daemon"() {
        executer.withWorkerDaemonsExpirationDisabled()
        fixture.withWorkActionClassInBuildSrc()

        buildFile << """
            task runInDaemon(type: WorkerTask) {
                isolationMode = 'processIsolation'
            }