/**

     * Please note that this tests make assumptions about the environment. It assumes

     * that user "root" exists and that the current user is not a "sudoer" already.

     */

    @Test(expected = ExecuteException.class, timeout = 2*TIMEOUT)

    public void testExec65WithSudoUsingShellScript() throws Exception

    {

        if(OS.isFamilyUnix())

        {

            final DefaultExecutor executor = new DefaultExecutor();

            executor.setStreamHandler(new PumpStreamHandler(System.out, System.err, System.in));

            final ExecuteWatchdog watchdog = new ExecuteWatchdog(TIMEOUT);

            executor.setWatchdog(watchdog);

            final CommandLine command = new CommandLine(TestUtil.resolveScriptForOS(testDir + "/issues/exec-65"));

            executor.execute(command);

        }

    }

    public ExecuteWatchdog(final long timeout) {

        this.killedProcess = false;

        this.watch = false;

        this.hasWatchdog = timeout != INFINITE_TIMEOUT;

        this.processStarted = false;

        if (this.hasWatchdog) {

            this.watchdog = new Watchdog(timeout);

            this.watchdog.addTimeoutObserver(this);

    }

        if (processToMonitor == null) {

        if (this.process != null) {

        this.caught = null;

        this.killedProcess = false;

        this.watch = true;

        this.process = processToMonitor;

        this.processStarted = true;

        this.notifyAll();

        if (this.hasWatchdog) {

            watchdog.start();

    }

        if (hasWatchdog) {

            watchdog.stop();

        watch = false;

        process = null;

    }

                if (process != null) {

            } catch (final IllegalThreadStateException itse) {

                if (watch) {

                    killedProcess = true;

                    process.destroy();

            cleanUp();

        }

    }

        if (caught != null) {

    }

        watch = false;

        process = null;

    }

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

            if (input == System.in) {

                inputThread = createSystemInPump(input, os);

                os.close();

            }

    }

        if (outputThread != null) {

            outputThread.start();

        if (errorThread != null) {

            errorThread.start();

        if (inputThread != null) {

            inputThread.start();

    }

        if (inputStreamPumper != null) {

            inputStreamPumper.stopProcessing();

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

            }

    }

        inputStreamPumper = new InputStreamPumper(is, os);

        final Thread result = new Thread(inputStreamPumper, "Exec Input Stream Pumper");

        result.setDaemon(true);

        return result;

        super(message + " (Exit value: " + exitValue + ")");

        this.cause = null;

        this.exitValue = exitValue;

    }

    public InputStreamPumper(final InputStream is, final OutputStream os) {

        this.is = is;

        this.os = os;

        this.stop = false;

    }

            while (!stop) {

                while (is.available() > 0 && !stop) {

                os.flush();

                Thread.sleep(SLEEPING_TIME);

        }

    }

        stop = true;

    }

public abstract class CommandLauncherImpl implements CommandLauncher {

        return exitValue != 0;

        {

            this.value = value.trim();

            this.handleQuoting = handleQuoting;

        }

            return value;

            return handleQuoting;

            PROCESSING_ENVIRONMENT_IMPLEMENTATION = new DefaultProcessingEnvironment();

    }

        if (environment == null) {

            return null;

    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;

    }

        this.watchdog = watchDog;

    }

      return this.processDestroyer;

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

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

                watchdog.start(process);

            int exitValue = Executor.INVALID_EXITVALUE;

                exitValue = process.waitFor();

                Thread.interrupted();

            }            

            if (watchdog != null) {

                watchdog.stop();

                streams.stop();

            }

            closeProcessStreams(process);

            if (getExceptionCaught() != null) {

            if (watchdog != null) {

                    watchdog.checkException();

                }

            if (this.isFailure(exitValue)) {

                throw new ExecuteException("Process exited with an error: " + exitValue, exitValue);

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

              this.getProcessDestroyer().remove(process);

        return this.exceptionCaught;

        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;

        if (OS.isFamilyOpenVms()) {

            launcher = new Java13CommandLauncher();

        return launcher;

    private final Vector observers = new Vector(1);

    private boolean stopped = false;

    public Watchdog(final long timeout) {

        if (timeout < 1) {

        this.timeout = timeout;

    }

        observers.addElement(to);

    }

        final Enumeration e = observers.elements();

        while (e.hasMoreElements()) {

            e.nextElement().timeoutOccured(this);

    }

        stopped = false;

        final Thread t = new Thread(this, "WATCHDOG");

        t.setDaemon(true);

        t.start();

    }

        stopped = true;

        notifyAll();

    }

        final long startTime = System.currentTimeMillis();

        synchronized (this) {

            long timeLeft = timeout - (System.currentTimeMillis() - startTime);

            isWaiting = timeLeft > 0;

            while (!stopped && isWaiting) {

                    wait(timeLeft);

                }

                timeLeft = timeout - (System.currentTimeMillis() - startTime);

                isWaiting = timeLeft > 0;

        }

        if (!isWaiting) {

            fireTimeoutOccured();

    }

public class DefaultProcessingEnvironment {

    public Java13CommandLauncher() {

    }

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

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

    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;

    private final Vector arguments = new Vector();

    public CommandLine(final String executable) {

        this.isFile=false;

        this.executable=toCleanExecutable(executable);

    }

    public CommandLine(final File executable) {

        this.isFile=true;

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

    }

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