* The list also contains an absolute path to the script (which may contain spaces).
     *
     * @return the list of command line elements to start this script.
     */
    abstract List<String> getCommandLine();

    /**
     * Returns a command line elements that can be used to start this script.
     * The resulting list can be used as an argument for the {@link ProcessBuilder} or Groovy's {@code execute} method.

        return this;
    }

    @Override
    default OutputStream getErrorOutput() {
        return getDelegate().getErrorOutput();
    }

    @Override
    default List<String> getCommandLine() {
        return getDelegate().getCommandLine();
    }

    @Override
    default String getExecutable() {
        return getDelegate().getExecutable();
    }

    @Override
    default void setExecutable(String executable) {

         * executable name. This is a mandatory property.
         *
         * @return the command line property
         */
        ListProperty<String> getCommandLine();

        // The ExecSpec's environment can be configured in two ways. First is to append some
        // variables to the current environment. We don't want to freeze the whole environment as an

        return DelegatingBaseExecSpec.super.copyTo(options);
    }

    public void copyToParameters(ProcessOutputValueSource.Parameters parameters) {
        parameters.getCommandLine().set(getCommandLine());
        parameters.getFullEnvironment().set(fullEnvironment);
        parameters.getAdditionalEnvironmentVariables().set(additionalEnvVars.isEmpty() ? null : additionalEnvVars);

        // BaseExecSpec
        copyBaseExecSpecTo(this, targetSpec);
        // Java fork options
        super.copyTo(targetSpec);
    }

    @Override
    public List<String> getCommandLine() {
        return argumentsSpec.getCommandLine();
    }

    @Override
    public JavaExecSpec args(Object... args) {
        argumentsSpec.args(args);
        return this;
    }

    @Override

        }

        try {
            execAction.execute();
        } catch (ExecException e) {
            LOG.info("Problems generating Javadoc."
                    + "\n  Command line issued: " + execAction.getCommandLine()
                    + "\n  Generated Javadoc options file has following contents:\n------\n{}------", GFileUtils.readFileQuietly(spec.getOptionsFile()));

import org.gradle.process.JavaExecSpec;

/**
 * The factory to build appropriate ExecSpec and JavaExecSpec instances. The returned
 * instances, especially JavaExecSpec, must conform to the {@link BaseExecSpec#getCommandLine()} contract.
 *
 * These instances will not be exposed to the user code directly, so there is no need of decoration.
 */
@ServiceScope(Scope.Build.class)
public interface ExecSpecFactory {
    ExecSpec newExecSpec();

        return execSpec.getArgumentProviders();
    }

    /**
     * {@inheritDoc}
     */
    @Internal
    @Override
    public List<String> getCommandLine() {
        return execSpec.getCommandLine();
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public void setCommandLine(List<String> args) {
        execSpec.setCommandLine(args);
    }

        this.classWorld = classWorld;
        this.request = new DefaultMavenExecutionRequest();
    }

    public String[] getArgs() {
        return args;
    }

    public CommandLine getCommandLine() {
        return commandLine;
    }

    public ClassWorld getClassWorld() {
        return classWorld;
    }

    public String getWorkingDirectory() {
        return workingDirectory;
    }

                withDefaultEnvironment(it)
            }
        }.get()

        then:
        1 * execOperations.exec(_) >> { Action<? super ExecSpec> action -> action.execute(spec) }
        spec.getCommandLine() == ["echo", "hello"]
        spec.environment == System.getenv()
    }

    def "full environment is propagated to execOperations"() {
        given:
        def spec = specFactory.newExecAction()