/**

     * Try to start an non-existing application where the exception is caught/processed

     * by the result handler. The watchdog in notified to avoid waiting for the

     * process infinitely.

     * @see EXEC-71

    public void testExecuteAsyncNonExistingApplicationWithWatchdog() throws Exception {

        final DefaultExecuteResultHandler resultHandler = new DefaultExecuteResultHandler() {

            @Override

            public void onProcessFailed(ExecuteException e) {

                System.out.println("Process did not stop gracefully, had exception '" + e.getMessage() + "' while executing process");

                super.onProcessFailed(e);

            }

        };

        final DefaultExecutor executor = new DefaultExecutor();

        executor.setWatchdog(new ExecuteWatchdog(ExecuteWatchdog.INFINITE_TIMEOUT));

        executor.execute(cl, resultHandler);

        resultHandler.waitFor();

        assertTrue(executor.isFailure(resultHandler.getExitValue()));

        assertNotNull(resultHandler.getException());

        assertFalse(executor.getWatchdog().isWatching());

        assertFalse(executor.getWatchdog().killedProcess());

        executor.getWatchdog().destroyProcess();

        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(

        {

                int exitValue = Executor.INVALID_EXITVALUE;

                } catch (final Exception e) {

                    handler.onProcessFailed(new ExecuteException("Execution failed", exitValue, e));

            }

    public ExecuteWatchdog(final long timeout) {

        this.killedProcess = false;

        this.watch = false;

        this.hasWatchdog = timeout != INFINITE_TIMEOUT;

        this.processStarted = false;

        if (this.hasWatchdog) {

            this.watchdog = null;

    }

        if (hasWatchdog) {

        watch = false;

        process = null;

    }

        ensureStarted();

        this.timeoutOccured(null);

        this.stop();

    }

                if (process != null) {

            }

            cleanUp();

        }

    }

        ensureStarted();

        return watch;

        return killedProcess;

        watch = false;

        process = null;

    }

        processStarted = false;

    }

    }

public abstract class CommandLauncherImpl implements CommandLauncher {

        return exitValue != 0;

public class DefaultProcessingEnvironment {

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

        this.watchdog = watchDog;

    }

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

        execute(command, null, handler);

    }

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

        if (watchdog != null) {

            watchdog.setProcessNotStarted();

        final Runnable runnable = new Runnable()

        this.executorThread = createThread(runnable, "Exec Default Executor");

        getExecutorThread().start();

    }

        if (this.exitValues == null) {

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

            return this.launcher.isFailure(exitValue);

        return new Thread(runnable, name);

        if (this.launcher == null) {

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

        return executorThread;

            PROCESSING_ENVIRONMENT_IMPLEMENTATION = new DefaultProcessingEnvironment();

    }

        if (environment == null) {

            return null;

    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;

    }

        super(message + " (Exit value: " + exitValue + ". Caused by " + cause + ")");

        this.cause = cause; // Two-argument version requires JDK 1.4 or later

        this.exitValue = exitValue;

    }

        return exitValue;

        if (OS.isFamilyOpenVms()) {

            launcher = new Java13CommandLauncher();

        return launcher;

    private final Vector arguments = new Vector();

    public CommandLine(final File executable) {

        this.isFile=true;

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

    }

        return StringUtils.fixFileSeparatorChar(expandArgument(executable));

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

        for (int i=0; i

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

    public DefaultExecuteResultHandler() {

        this.hasResult = false;

        this.exitValue = Executor.INVALID_EXITVALUE;

    }

        this.exitValue = e.getExitValue();            

        this.exception = e;

        this.hasResult = true;

    }

        if (!hasResult) {

        return exception;

        if (!hasResult) {

        return exitValue;

        return hasResult;

        while (!hasResult()) {

            Thread.sleep(SLEEP_TIME_MS);

    }

    public Java13CommandLauncher() {

    }

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

    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;