package v1

// ExecActionApplyConfiguration represents an declarative configuration of the ExecAction type for use
// with apply.
type ExecActionApplyConfiguration struct {
	Command []string `json:"command,omitempty"`
}

// ExecActionApplyConfiguration constructs an declarative configuration of the ExecAction type for use with
// apply.
func ExecAction() *ExecActionApplyConfiguration {
	return &ExecActionApplyConfiguration{}
}

 */
package org.gradle.process.internal;

import org.gradle.api.NonExtensible;
import org.gradle.process.ExecResult;
import org.gradle.process.ExecSpec;

@NonExtensible
public interface ExecAction extends ExecSpec {
    ExecResult execute() throws ExecException;

        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: