/**

     * The same approach using a completely detached process works nicely on Mac OS X.

     *

     * @throws IOException

     */

    @Test(timeout = TEST_TIMEOUT)

    public void testExecutionOfDetachedProcess() throws IOException {

        if (!OS.isFamilyUnix()) {

            testNotSupportedForCurrentOperatingSystem();

        final CommandLine cmdLine = new CommandLine("sh").addArgument("-c").addArgument("./src/test/scripts/issues/exec-57-detached.sh", false);

        final DefaultExecutor executor = new DefaultExecutor();

        final PumpStreamHandler pumpStreamHandler = new PumpStreamHandler(System.out, System.err);

        executor.setStreamHandler(pumpStreamHandler);

        executor.execute(cmdLine);

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

            }

        }

    }

    private final Vector arguments = new Vector();

    public CommandLine(final String executable) {

        this.isFile=false;

        this.executable=toCleanExecutable(executable);

    }

        return StringUtils.fixFileSeparatorChar(expandArgument(executable));

        return this.addArgument(argument, true);

       if (argument == null)

       if (handleQuoting)

           StringUtils.quoteArgument(argument);

       arguments.add(new Argument(argument, handleQuoting));

       return this;

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

        for (int i=0; i

            currArgument = arguments.get(i);

            expandedArgument = expandArgument(currArgument.getValue());

            result[i] = currArgument.isHandleQuoting() ? StringUtils.quoteArgument(expandedArgument) : expandedArgument;

        return 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;

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

        return stringBuffer.toString();

        if (dirtyExecutable == null) {

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

            return StringUtils.fixFileSeparatorChar(dirtyExecutable);

        if (OS.isFamilyOpenVms()) {

            launcher = new Java13CommandLauncher();

        return launcher;

public class DefaultProcessingEnvironment {

            PROCESSING_ENVIRONMENT_IMPLEMENTATION = new DefaultProcessingEnvironment();

    }

        if (environment == null) {

            return null;

        {

            this.value = value.trim();

            this.handleQuoting = handleQuoting;

        }

            return value;

            return handleQuoting;

        final 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 StringBuilder buf = new StringBuilder();

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

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

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

            return cleanedArgument;

    public DefaultExecutor() {

        this.streamHandler = new PumpStreamHandler();

        this.launcher = CommandLauncherFactory.createVMLauncher();

        this.exitValues = new int[0];

        this.workingDirectory = new File(".");

        this.exceptionCaught = null;

    }

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

            process.getInputStream().close();

        }

            process.getOutputStream().close();

        }

            process.getErrorStream().close();

        }

    }

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

                Thread.interrupted();

            }            

            if (watchdog != null) {

                streams.stop();

            }

            closeProcessStreams(process);

            if (getExceptionCaught() != null) {

            if (watchdog != null) {

            if (this.isFailure(exitValue)) {

            return exitValue;

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

              this.getProcessDestroyer().remove(process);

        return this.exceptionCaught;

    private IOException caught = null;

        this(System.out, System.err);

    }

        this(out, err, null);

    }

    public PumpStreamHandler(final OutputStream out, final OutputStream err, final InputStream input) {

        this.out = out;

        this.err = err;

        this.input = input;

    }

        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 (inputStreamPumper != null) {

        stopThread(outputThread, stopTimeout);

        stopThread(errorThread, stopTimeout);

        stopThread(inputThread, stopTimeout);

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

                err.flush();

            }

        if (out != null) {

                out.flush();

            }

        if (caught != null) {

    }

        outputThread = createPump(is, os);

    }

        errorThread = createPump(is, os);

    }

        final boolean closeWhenExhausted = os instanceof PipedOutputStream ? true : false;

        return createPump(is, os, closeWhenExhausted);

        final Thread result = new Thread(new StreamPumper(is, os, closeWhenExhausted), "Exec Stream Pumper");

        result.setDaemon(true);

        return result;

        if (thread != null) {

                if (timeout == 0) {

                    thread.join();

            }

    }

public abstract class CommandLauncherImpl implements CommandLauncher {

        return exitValue != 0;

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

        return isFamily(FAMILY_UNIX);

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

                } 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 Java13CommandLauncher() {

    }

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

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