@Test

    private final Vector arguments = new Vector();

        return parse(line, null);

        if (line == null) {

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

            final String[] tmp = translateCommandline(line);

            final CommandLine cl = new CommandLine(tmp[0]);

            cl.setSubstitutionMap(substitutionMap);

            for (int i = 1; i < tmp.length; i++) {

                cl.addArgument(tmp[i]);

            return cl;

    public CommandLine(final String executable) {

        this.isFile=false;

        this.executable=getExecutable(executable);

    }

        return StringUtils.fixFileSeparatorChar(expandArgument(executable));

        return this.addArguments(addArguments, true);

        if (addArguments != null) {

            for (int i = 0; i < addArguments.length; i++) {

                addArgument(addArguments[i], handleQuoting);

        return this;

        return this.addArguments(addArguments, true);

        if (addArguments != null) {

            final String[] argumentsArray = translateCommandline(addArguments);

            addArguments(argumentsArray, handleQuoting);

        return this;

        return this.addArgument(argument, true);

       if (argument == null)

           return this;

       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 = (Argument) arguments.get(i);

            expandedArgument = expandArgument(currArgument.getValue());

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

        return result;

        return substitutionMap;

        this.substitutionMap = substitutionMap;

    }

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

        result[0] = this.getExecutable();

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

        return result;

        return "[" + StringUtils.toString(toStrings(), ", ") + "]";

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

        return stringBuffer.toString();

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

        final int normal = 0;

        final int inQuote = 1;

        final int inDoubleQuote = 2;

        int state = normal;

        final StringTokenizer tok = new StringTokenizer(toProcess, "\"\' ", true);

        final Vector v = new Vector();

        StringBuffer current = new StringBuffer();

        boolean lastTokenHasBeenQuoted = false;

        while (tok.hasMoreTokens()) {

            final String nextTok = tok.nextToken();

            switch (state) {

                if ("\'".equals(nextTok)) {

                    lastTokenHasBeenQuoted = true;

                    state = normal;

                    current.append(nextTok);

                break;

                if ("\"".equals(nextTok)) {

                    lastTokenHasBeenQuoted = true;

                    state = normal;

                    current.append(nextTok);

                break;

                if ("\'".equals(nextTok)) {

                    state = inQuote;

                } else if ("\"".equals(nextTok)) {

                    state = inDoubleQuote;

                } else if (" ".equals(nextTok)) {

                    if (lastTokenHasBeenQuoted || current.length() != 0) {

                        v.addElement(current.toString());

                        current = new StringBuffer();

                    current.append(nextTok);

                lastTokenHasBeenQuoted = false;

        }

        if (lastTokenHasBeenQuoted || current.length() != 0) {

            v.addElement(current.toString());

        if (state == inQuote || state == inDoubleQuote) {

            throw new IllegalArgumentException("Unbalanced quotes in "

        final String[] args = new String[v.size()];

        v.copyInto(args);

        return args;

        if (executable == null) {

            throw new IllegalArgumentException("Executable can not be null");

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

            throw new IllegalArgumentException("Executable can not be empty");

            return StringUtils.fixFileSeparatorChar(executable);

        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(

        final StringBuffer sb = new StringBuffer();

        for (int i = 0; i < strings.length; i++) {

            if (i > 0) {

                sb.append(separator);

            sb.append(strings[i]);

        return sb.toString();

        String cleanedArgument = argument.trim();

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

            cleanedArgument = cleanedArgument.substring(1);

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

            cleanedArgument = cleanedArgument.substring(0, cleanedArgument.length() - 1);

        final StringBuffer buf = new StringBuffer();

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

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

                throw new IllegalArgumentException(

			return buf.append(SINGLE_QUOTE).append(cleanedArgument).append(

			        SINGLE_QUOTE).toString();

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

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

            return buf.append(DOUBLE_QUOTE).append(cleanedArgument).append(

                    DOUBLE_QUOTE).toString();

            return cleanedArgument;

        {

            this.value = value.trim();

            this.handleQuoting = handleQuoting;

        }

            return value;

            return handleQuoting;