private T chooseSpecFromCompileOptions(File fallbackJavaHome) {
        File forkJavaHome = compileOptions.getForkOptions().getJavaHome();
        if (forkJavaHome != null) {
            return getCommandLineSpec(Jvm.forHome(forkJavaHome).getJavacExecutable());
        }

        String forkExecutable = compileOptions.getForkOptions().getExecutable();
        if (forkExecutable != null) {

        super(workerDirectory, projectCacheDir, forkOptions.getClassLoaderStructure());
        this.forkOptions = forkOptions;
    }

    public DaemonForkOptions getForkOptions() {
        return forkOptions;
    }

        File defaultWorkingDir = spec.getForkOptions().getWorkingDir();
        File workingDirectory = workerDirectoryProvider.getWorkingDirectory();
        action.execute(spec);

        if (!defaultWorkingDir.equals(spec.getForkOptions().getWorkingDir())) {
            throw new IllegalArgumentException("Setting the working directory of a worker is not supported.");

    @TaskAction
    public void validateTaskClasses() throws IOException {
        getWorkerExecutor()
            .processIsolation(spec -> {
                if (getLauncher().isPresent()) {
                    spec.getForkOptions().setExecutable(getLauncher().get().getExecutablePath());
                } else {
                    DeprecationLogger.deprecateBehaviour("Using task ValidatePlugins without applying the Java Toolchain plugin.")

    public boolean isDryRun() {
        return isDryRun;
    }

    @Override
    public TestTaskFilters getFilters() {
        return filters;
    }

    @Override
    public TestTaskForkOptions getForkOptions() {
        return forkOptions;
    }

    @Override
    public Stream<CandidateClassFile> getCandidateClassFiles() {
        return candidateClassFiles.stream();
    }

    @Override

                }
            }

            private WorkerDaemonClient reserveClient() {
                DaemonForkOptions forkOptions = ((ForkedWorkerRequirement) workerRequirement).getForkOptions();
                WorkerDaemonClient client = clientsManager.reserveIdleClient(forkOptions);
                if (client == null) {
                    client = clientsManager.reserveNewClient(forkOptions);
                }

    protected DaemonForkOptions toDaemonForkOptions(GroovyJavaJointCompileSpec spec) {
        MinimalJavaCompilerDaemonForkOptions javaOptions = spec.getCompileOptions().getForkOptions();
        MinimalGroovyCompilerDaemonForkOptions groovyOptions = spec.getGroovyCompileOptions().getForkOptions();
        // Ant is optional dependency of groovy(-all) module but mandatory dependency of Groovy compiler;

    }

    @Override
    public void stop() {
        workerClient.stop();
    }

    public void kill() {
        workerClient.stopNow();
    }

    DaemonForkOptions getForkOptions() {
        return forkOptions;
    }

    public int getUses() {
        return uses;
    }

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

        JavaInfo jvm = Jvm.forHome(((ForkingJavaCompileSpec) spec).getJavaHome());

        MinimalJavaCompilerDaemonForkOptions forkOptions = spec.getCompileOptions().getForkOptions();
        JavaForkOptions javaForkOptions = new BaseForkOptionsConverter(forkOptionsFactory).transform(forkOptions);
        javaForkOptions.setWorkingDir(daemonWorkingDir);

    def reportsMemoryUsage = true
    def daemonStarter = Mock(WorkerDaemonStarter) {
        startDaemon(_) >> { DaemonForkOptions forkOptions ->
            Mock(WorkerDaemonClient) {
                getForkOptions() >> forkOptions
                isCompatibleWith(_) >> { DaemonForkOptions otherForkOptions ->
                    forkOptions.isCompatibleWith(otherForkOptions)
                }