this.workingDir = workingDir;
        this.runScript = runScript;
        this.path = path;
        this.testSelection = testSelection;
    }

    public File getWorkingDir() {
        return workingDir;
    }

    public File getRunScript() {
        return runScript;
    }

    public String getPath() {
        return path;
    }

import javax.annotation.Nullable;
import java.io.File;
import java.util.List;

public interface JvmLanguageCompileSpec extends CompileSpec {
    File getTempDir();

    void setTempDir(File tempDir);

    File getWorkingDir();

    void setWorkingDir(File workingDir);

    File getDestinationDir();

    void setDestinationDir(File destinationDir);

    Iterable<File> getSourceFiles();

            && getEnableAssertions() == options.getEnableAssertions()
            && normalized(getExecutable()).equals(normalized(options.getExecutable()))
            && getWorkingDir().equals(options.getWorkingDir())
            && normalized(getDefaultCharacterEncoding()).equals(normalized(options.getDefaultCharacterEncoding()))
            && getHeapSizeMb(getMinHeapSize()) >= getHeapSizeMb(options.getMinHeapSize())

        this.modulePath = modulePath;
        this.jvmArgs = ImmutableList.copyOf(jvmArgs);
        this.environment = ImmutableMap.copyOf(environment);
    }

    @Override
    public File getWorkingDir() {
        return workingDir;
    }

    @Override
    public String getExecutable() {
        return executable;
    }

    @Override
    public int getJavaMajorVersion() {

        JavadocExecHandleBuilder javadocExecHandleBuilder = new JavadocExecHandleBuilder(execActionFactory);
        javadocExecHandleBuilder.setExecutable(spec.getExecutable());
        javadocExecHandleBuilder.execDirectory(spec.getWorkingDir()).options(spec.getOptions()).optionsFile(spec.getOptionsFile());

        ExecAction execAction = javadocExecHandleBuilder.getExecHandle();
        if (spec.isIgnoreFailures()) {

    private Integer release;
    private String sourceCompatibility;
    private String targetCompatibility;
    private List<File> sourceRoots;

    @Override
    public File getWorkingDir() {
        return workingDir;
    }

    @Override
    public void setWorkingDir(File workingDir) {
        this.workingDir = workingDir;
    }

    @Override
    public File getDestinationDir() {

    }

    private ExecHandle createCompilerHandle(String executable, JavaCompileSpec spec) {
        ExecHandleBuilder builder = execHandleFactory.newExec();
        builder.setWorkingDir(spec.getWorkingDir());
        builder.setExecutable(executable);
        argumentsGenerator.collectArguments(spec, new ExecSpecBackedArgCollector(builder));
        builder.setIgnoreExitValue(true);
        return builder.build();
    }

    /**
     * Returns the working directory for the process. Defaults to the project directory.
     *
     * @return The working directory. Never returns null.
     */
    File getWorkingDir();

    /**
     * Sets the working directory for the process.
     *
     * @param dir The working directory. Must not be null.
     * @since 4.0
     */
    void setWorkingDir(File dir);

    /**

            throw new IllegalStateException("execCommand == null!");
        }

        StreamsHandler effectiveOutputHandler = getEffectiveStreamsHandler();
        return new DefaultExecHandle(getDisplayName(), getWorkingDir(), executable, getEffectiveArguments(), getActualEnvironment(),
            effectiveOutputHandler, inputHandler, listeners, redirectErrorStream, timeoutMillis, daemon, executor, buildCancellationToken);
    }

            executor.classLoaderIsolation(config -> config.getClasspath().from(mavenClasspath))
                    .submit(Maven2GradleWorkAction.class, params -> {
                        params.getWorkingDir().set(initSettings.getTarget());
                        params.getDsl().set(initSettings.getDsl());
                        params.getUseIncubatingAPIs().set(initSettings.isUseIncubatingAPIs());