manager.reserveNewClient(options)
        listenerManager.getBroadcaster(BuildSessionLifecycleListener).beforeComplete()

        then:
        1 * client1.getKeepAliveMode() >> KeepAliveMode.SESSION
        1 * client2.getKeepAliveMode() >> KeepAliveMode.SESSION
        1 * client1.stop()
        1 * client2.stop()
    }

    def "Stopping session-scoped clients does not stop other clients"() {

                .withChild(compilerClasspath);

        return new DaemonForkOptionsBuilder(forkOptionsFactory)
            .javaForkOptions(javaForkOptions)
            .keepAliveMode(KeepAliveMode.SESSION)
            .withClassLoaderStructure(classLoaderStructure)
            .build();
    }

    private static FilteringClassLoader.Spec getMinimalGradleFilter() {

        return new DaemonForkOptionsBuilder(TestFiles.execFactory())
            .javaForkOptions(javaForkOptions(minHeap, maxHeap, jvmArgs))
            .keepAliveMode(KeepAliveMode.SESSION)
            .build()
    }

        workerClient.stopNow();
    }

    DaemonForkOptions getForkOptions() {
        return forkOptions;
    }

    public int getUses() {
        return uses;
    }

    public KeepAliveMode getKeepAliveMode() {
        return forkOptions.getKeepAliveMode();
    }

    public LogLevel getLogLevel() {
        return logLevel;
    }

    public boolean isFailed() {

            dependencies {
                implementation("${scalaDependency(version.toString())}")
            }

            tasks.withType(AbstractScalaCompile) {
                scalaCompileOptions.keepAliveMode = KeepAliveMode.SESSION
            }
        """
        file('src/main/scala/Foo.scala') << '''
            class Foo {
            }
        '''
        expect:
        succeeds(':compileScala', '--info')

        // Started Gradle worker daemon (0.399 secs) with fork options DaemonForkOptions{executable=/Library/Java/JavaVirtualMachines/adoptopenjdk-11.jdk/Contents/Home/bin/java, minHeapSize=null, maxHeapSize=234M, jvmArgs=[], keepAliveMode=DAEMON}.
        outputContains("maxHeapSize=234M")
    }

    def "scaladoc multi project"() {
        classes.baseline()
        settingsFile << """
            include(':utils')
        """

        if (configuration instanceof ProcessWorkerSpec) {
            DaemonForkOptionsBuilder builder = new DaemonForkOptionsBuilder(forkOptionsFactory)
                .keepAliveMode(KeepAliveMode.SESSION);
            ProcessWorkerSpec processConfiguration = (ProcessWorkerSpec) configuration;
            JavaForkOptions forkOptions = forkOptionsFactory.newJavaForkOptions();

import org.gradle.jvm.tasks.Jar;
import org.gradle.jvm.toolchain.JavaLauncher;
import org.gradle.jvm.toolchain.JavaToolchainService;
import org.gradle.language.scala.tasks.AbstractScalaCompile;
import org.gradle.language.scala.tasks.KeepAliveMode;

import javax.inject.Inject;
import java.io.File;
import java.util.concurrent.Callable;

import static org.gradle.api.attributes.Category.CATEGORY_ATTRIBUTE;

        public void beforeComplete() {
            synchronized (lock) {
                List<WorkerDaemonClient> sessionScopedClients = CollectionUtils.filter(allClients, client -> client.getKeepAliveMode() == KeepAliveMode.SESSION);
                stopWorkers(sessionScopedClients);
            }
        }
    }

    private static final Consumer<WorkerDaemonClient> STOP_CLIENT = WorkerDaemonClient::stop;

        spec.setWorkingDir(getProjectLayout().getProjectDirectory().getAsFile());
        spec.setTempDir(getTemporaryDir());
        List<File> effectiveClasspath;
        if (scalaCompileOptions.getKeepAliveMode().get() == KeepAliveMode.DAEMON) {
            effectiveClasspath = getCachedClasspathTransformer().transform(DefaultClassPath.of(getClasspath()), CachedClasspathTransformer.StandardTransform.None).getAsFiles();
        } else {