/**

     * A generic test case to print the command line arguments to 'printargs' script to solve

     * even more command line puzzles.

     */

    public void testExecuteWithComplexArguments() throws Exception {

        CommandLine cl = new CommandLine(printArgsScript);

        cl.addArgument("gdal_translate");

        cl.addArgument("HDF5:\"/home/kk/grass/data/4404.he5\"://HDFEOS/GRIDS/OMI_Column_Amount_O3/Data_Fields/ColumnAmountO3/home/kk/4.tif", false);

        DefaultExecutor executor = new DefaultExecutor();

        int exitValue = executor.execute(cl);

        assertFalse(exec.isFailure(exitValue));

     }

        StringBuffer argBuf = new StringBuffer();

        if (argStr == null || argStr.length() == 0) {

        if (vars == null || vars.size() == 0) {

            return argBuf.append(argStr);

        return arg.replace(SLASH_CHAR, File.separatorChar).replace(

        String cleanedArgument = argument.trim();

        while(cleanedArgument.startsWith(SINGLE_QUOTE) || cleanedArgument.startsWith(DOUBLE_QUOTE)) {

        while(cleanedArgument.endsWith(SINGLE_QUOTE) || cleanedArgument.endsWith(DOUBLE_QUOTE)) {

        final StringBuffer buf = new StringBuffer();

        if (cleanedArgument.indexOf(DOUBLE_QUOTE) > -1) {

        } else if (cleanedArgument.indexOf(SINGLE_QUOTE) > -1

                || cleanedArgument.indexOf(" ") > -1) {

            return cleanedArgument;

    private static final String OS_NAME = System.getProperty("os.name")

            .toLowerCase(Locale.US);

    private static final String OS_ARCH = System.getProperty("os.arch")

            .toLowerCase(Locale.US);

    private static final String OS_VERSION = System.getProperty("os.version")

            .toLowerCase(Locale.US);

    private static final String PATH_SEP = System.getProperty("path.separator");

        return isOs(family, null, null, null);

        return isFamily(FAMILY_UNIX);

        return isFamily(FAMILY_WINDOWS);

        return isFamily(FAMILY_OPENVMS);

        boolean retValue = false;

        if (family != null || name != null || arch != null || version != null) {

            boolean isFamily = true;

            boolean isName = true;

            boolean isArch = true;

            boolean isVersion = true;

            if (family != null) {

                if (family.equals(FAMILY_WINDOWS)) {

                    isFamily = OS_NAME.indexOf(FAMILY_WINDOWS) > -1;

                } else if (family.equals(FAMILY_OS_2)) {

                } else if (family.equals(FAMILY_NETWARE)) {

                } else if (family.equals(FAMILY_DOS)) {

                } else if (family.equals(FAMILY_MAC)) {

                    isFamily = OS_NAME.indexOf(FAMILY_MAC) > -1;

                } else if (family.equals(FAMILY_TANDEM)) {

                } else if (family.equals(FAMILY_UNIX)) {

                    isFamily = PATH_SEP.equals(":")

                            && !isFamily(FAMILY_OPENVMS)

                            && (!isFamily(FAMILY_MAC) || OS_NAME.endsWith("x"));

                } else if (family.equals(FAMILY_WIN9X)) {

                } else if (family.equals(FAMILY_Z_OS)) {

                } else if (family.equals(FAMILY_OS_400)) {

                } else if (family.equals(FAMILY_OPENVMS)) {

                    isFamily = OS_NAME.indexOf(FAMILY_OPENVMS) > -1;

            if (name != null) {

            if (arch != null) {

            if (version != null) {

            retValue = isFamily && isName && isArch && isVersion;

        return retValue;

public abstract class CommandLauncherImpl implements CommandLauncher {

        return exitValue != 0;

    private final Vector arguments = new Vector();

    public CommandLine(File executable) {

        this.isFile=true;

        this.executable=getExecutable(executable.getAbsolutePath());

    }

        return StringUtils.fixFileSeparatorChar(expandArgument(executable));

        return this.addArgument(argument, true);

        if (argument == null) {

        if(handleQuoting) {

            arguments.add(StringUtils.quoteArgument(argument));

            arguments.add(argument);

        return this;

        String[] result = new String[arguments.size()];

        result = (String[]) arguments.toArray(result);

        return this.expandArguments(result);

        return substitutionMap;

        final String[] result = new String[arguments.size() + 1];

        result[0] = this.getExecutable();

        System.arraycopy(getArguments(), 0, result, 1, result.length-1);

        return result;

        StringBuffer stringBuffer = StringUtils.stringSubstitution(argument, this.getSubstitutionMap(), true);

        return stringBuffer.toString();

        String[] result = new String[arguments.length];

        for(int i=0; i

            result[i] = this.expandArgument(arguments[i]);

        return result;

        if (executable == null) {

        } else if(executable.trim().length() == 0) {

            return StringUtils.fixFileSeparatorChar(executable);

        if (OS.isFamilyOpenVms()) {

            launcher = new Java13CommandLauncher();

        return launcher;

public class DefaultProcessingEnvironment {

    private static final String LINE_SEPARATOR = System.getProperty("line.separator");

            final InputStream input) {

        this.out = out;

        this.err = err;

        this.input = input;

    }

        this(out, err, null);

    }

        this(System.out, System.err);

    }

        if (out != null) {

            createProcessOutputPump(is, out);

    }

        if (err != null) {

            createProcessErrorPump(is, err);

    }

        if (input != null) {

                os.close();

            }

    }

        if (outputThread != null) {

            outputThread.start();

        if (errorThread != null) {

            errorThread.start();

        if (inputThread != null) {

    }

        if (outputThread != null) {

                outputThread.join();

                outputThread = null;

            }

        if (errorThread != null) {

                errorThread.join();

                errorThread = null;

            }

        if (inputStreamPumper != null) {

        if (inputThread != null) {

         if (err != null && err != out) {

                 err.flush();

             }

         if (out != null) {

                 out.flush();

             }

    }

        outputThread = createPump(is, os);

    }

        errorThread = createPump(is, os);

    }

        return createPump(is, os, false);

        final Thread result = new Thread(new StreamPumper(is, os,

        result.setDaemon(true);

        return result;

    public DefaultExecutor() {

        this.streamHandler = new PumpStreamHandler();

        this.launcher = CommandLauncherFactory.createVMLauncher();

        this.exitValues = new int[0];

    }

        this.streamHandler = streamHandler;

    }

      return this.processDestroyer;

        return execute(command, (Map) null);

        if (workingDirectory != null && !workingDirectory.exists()) {

        return executeInternal(command, environment, workingDirectory, streamHandler);

        if(this.exitValues == null) {

        else if(this.exitValues.length == 0) {

            return this.launcher.isFailure(exitValue);

        if (this.launcher == null) {

        if (dir != null && !dir.exists()) {

        return this.launcher.exec(command, env, dir);

        IOException caught = null;

            process.getInputStream().close();

        }

            process.getOutputStream().close();

        }

            process.getErrorStream().close();

        }

        if(caught != null) {

    }

        final Process process = this.launch(command, environment, dir);

            streams.setProcessInputStream(process.getOutputStream());

            streams.setProcessOutputStream(process.getInputStream());

            streams.setProcessErrorStream(process.getErrorStream());

        }

        streams.start();

            if(this.getProcessDestroyer() != null) {

            if (watchdog != null) {

            int exitValue = Executor.INVALID_EXITVALUE;

                exitValue = process.waitFor();

            }

            if (watchdog != null) {

            streams.stop();

            closeStreams(process);

            if (watchdog != null) {

            if(this.isFailure(exitValue)) {

            return exitValue;

            if(this.getProcessDestroyer() != null) {

              this.getProcessDestroyer().remove(process);

            final boolean closeWhenExhausted) {

        this.is = is;

        this.os = os;

        this.size = DEFAULT_SIZE;

        this.closeWhenExhausted = closeWhenExhausted;

    }

        synchronized (this) {

            finished = false;

        }

        final byte[] buf = new byte[this.size];

            while ((length = is.read(buf)) > 0) {

                os.write(buf, 0, length);

            if (closeWhenExhausted) {

            synchronized (this) {

                finished = true;

                notifyAll();

            }

        }

    }

        if (OS.isFamilyOpenVms()) {

        	procEnvironment = new DefaultProcessingEnvironment();

	}

        if (environment == null) {

            return null;

    public Java13CommandLauncher() {

	}

		String[] envVars = EnvironmentUtils.toStrings(env);

		return Runtime.getRuntime().exec(cmd.toStrings(),