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

        }

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

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

    /**
     * Returns the full command line, including the executable plus its arguments.
     *
     * @return The full command line, including the executable plus its arguments
     */
    List<String> getCommandLine();

        assertThat(request.getUserProperties().getProperty("valTopDirectory"), is("myTopDirectory/pom.xml"));
        assertThat(request.getCommandLine().getOptionValue('f'), is("myRootDirectory/my-child"));
        assertThat(request.getCommandLine().getArgs(), equalTo(new String[] {"prefix:3.0.0:bar", "validate"}));
    }

    @ParameterizedTest
    @MethodSource("activateBatchModeArguments")

	if e != nil {
		return nil, NewSyscallError("OpenProcess", e)
	}
	return newHandleProcess(pid, uintptr(h)), nil
}

func init() {
	cmd := windows.UTF16PtrToString(syscall.GetCommandLine())
	if len(cmd) == 0 {
		arg0, _ := Executable()
		Args = []string{arg0}
	} else {
		Args = commandLineToArgv(cmd)
	}
}

// appendBSBytes appends n '\\' bytes to b and returns the resulting slice.