return this;
    }

    public ExecAction getExecHandle() {
        try {
            options.write(optionsFile);
        } catch (IOException e) {
            throw new GradleException("Failed to store javadoc options.", e);
        }

        ExecAction execAction = execActionFactory.newExecAction();
        execAction.workingDir(execDirectory);

                ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
                ExecAction execAction = execActionFactory.newExecAction();
                execAction.executable("xcrun");
                execAction.workingDir(System.getProperty("user.dir"));
                execAction.args(getXcrunFlags());

                String developerDir = System.getenv("DEVELOPER_DIR");

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

        try {
            execAction.execute();
        } catch (ExecException e) {
            LOG.info("Problems generating Javadoc."
                    + "\n  Command line issued: " + execAction.getCommandLine()

import org.gradle.process.internal.ExecAction
import org.gradle.process.internal.ExecActionFactory
import org.gradle.process.internal.ExecException
import spock.lang.Specification

class DefaultCommandLineToolInvocationWorkerTest extends Specification {
    def "throws exception when exec fails"() {
        given:
        def execAction = Mock(ExecAction)
        def execActionFactory = Stub(ExecActionFactory) {

import org.gradle.process.ExecResult
import org.gradle.process.internal.ExecAction
import org.gradle.process.internal.ExecActionFactory
import spock.lang.Specification

class CompilerMetaDataProviderFactoryTest extends Specification {

    def execActionFactory = Mock(ExecActionFactory)
    def execAction = Mock(ExecAction)
    def execResult = Mock(ExecResult)

        JavaExecAction execAction = newDecoratedJavaExecAction();
        action.execute(execAction);
        return execAction.execute();
    }

    @Override
    public ExecResult exec(Action<? super ExecSpec> action) {
        ExecAction execAction = newDecoratedExecAction();
        action.execute(execAction);
        return execAction.execute();
    }

    void vswhereResults(String jsonResult) {
        OutputStream outputStream

        1 * execActionFactory.newExecAction() >> execAction
        1 * execAction.setStandardOutput(_ as OutputStream) >> { args ->
            outputStream = args[0]
            return null
        }
        1 * execAction.execute() >> {
            outputStream.write(jsonResult.bytes)
            return Stub(ExecResult)
        }
    }

        def action = Mock(ExecAction)

        when:
        javadocExecHandleBuilder.execHandle

        then:
        1 * execActionFactory.newExecAction() >> action
        1 * action.executable(Jvm.current().javadocExecutable)
    }

    def testCheckCustomExecutable() {
        String executable = "somepath"
        def action = Mock(ExecAction)

        when:

        ExecAction execAction = getExecActionFactory().newExecAction();
        execAction.setWorkingDir(new File(".").getAbsolutePath());
        execAction.commandLine(cygpathExe.getAbsolutePath(), "-w", cygwinPath);
        StreamByteBuffer buffer = new StreamByteBuffer();
        StreamByteBuffer errorBuffer = new StreamByteBuffer();
        execAction.setStandardOutput(buffer.getOutputStream());

        throw new UnsupportedOperationException();
    }

    @TaskAction
    protected void exec() {
        ExecAction execAction = getExecActionFactory().newExecAction();
        execSpec.copyTo(execAction);
        execResult.set(execAction.execute());
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public T commandLine(Object... arguments) {