public void setIgnoreFailures(boolean ignoreFailures) {
        this.ignoreFailures = ignoreFailures;
    }

    public boolean isIgnoreFailures() {
        return ignoreFailures;
    }

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

    public File getWorkingDir() {
        return workingDir;
    }

    public void setOptionsFile(File optionsFile) {

    public ExecHandle build(List<String> args, File workingDir, DaemonOutputConsumer outputConsumer, InputStream inputStream, ExecHandleBuilder builder) {
        builder.commandLine(args);
        builder.setWorkingDir(workingDir);
        builder.setStandardInput(inputStream);
        builder.redirectErrorStream();
        builder.setTimeout(30000);
        builder.setDaemon(true);
        builder.setDisplayName("Gradle build daemon");

            builder.applicationClasspath(antlrClasspath);
        }
        builder.sharedPackages("antlr", "org.antlr");
        JavaExecHandleBuilder javaCommand = builder.getJavaCommand();
        javaCommand.setWorkingDir(workingDir);
        javaCommand.setMaxHeapSize(spec.getMaxHeapSize());
        javaCommand.systemProperty("ANTLR_DO_NOT_EXIT", "true");
        javaCommand.redirectErrorStream();
        return builder.build();
    }

    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() {
        return destinationDir;
    }

    @Override

        return WorkResults.didWork(true);
    }

    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);

        def target = Mock(ProcessForkOptions)

        when:
        options.executable('executable')
        options.environment('key', 12)
        options.copyTo(target)

        then:
        1 * target.setWorkingDir(baseDir)
        1 * target.setExecutable('executable')
        1 * target.setEnvironment({ !it.empty })
    }

    }

    @TaskAction
    @Override
    protected void exec() {
        // Make convention mapping work
        getOutputDir().mkdirs();
        setExecutable(getExecutable());
        setWorkingDir(getOutputDir());

        try {
            super.exec();
        } catch (Exception e) {
            handleTestFailures(e);
        }

    }

    private void handleTestFailures(Exception e) {

            throw new IllegalArgumentException("Setting the working directory of a worker is not supported.");
        } else {
            spec.getForkOptions().setWorkingDir(workingDirectory);
        }

        return instantiator.newInstance(DefaultWorkQueue.class, this, spec, daemonWorkerFactory);
    }

            return newJavaForkOptions()
        }

        @Override
        JavaForkOptionsInternal newJavaForkOptions() {
            def forkOptions = delegate.newJavaForkOptions()
            forkOptions.setWorkingDir(temporaryFolder)
            return forkOptions
        }

        @Override
        JavaForkOptionsInternal immutableCopy(JavaForkOptionsInternal options) {
            return delegate.immutableCopy(options)

        ExecAction exec = execActionFactory.newExecAction();
        exec.args(args);
        exec.executable(vswhereBinary.getAbsolutePath());
        exec.setWorkingDir(vswhereBinary.getParentFile());

        StreamByteBuffer buffer = new StreamByteBuffer();
        exec.setStandardOutput(buffer.getOutputStream());
        exec.setErrorOutput(NullOutputStream.INSTANCE);