Stops the PosixParser from bursting options unecessarily, i.e. if -file is an acceptible option then it won't be broken into -f -i -l -e.

PR: 32525
Submitted by:	David Morris


git-svn-id: https://svn.apache.org/repos/asf/jakarta/commons/proper/cli/trunk@130108 13f79535-47bb-0310-9956-ffa450edef68

Author: Robert James Oxspring

src/java/org/apache/commons/cli/PosixParser.java

@@ -25,7 +25,7 @@
  *
  * @author John Keyes (john at integralsource.com)
  * @see Parser
- * @version $Revision: 1.15 $
+ * @version $Revision: 1.16 $
  */
 public class PosixParser extends Parser {
 
@@ -135,7 +135,9 @@ else if (token.startsWith("-"))
                 {
                     processOptionToken(token, stopAtNonOption);
                 }
-
+                else if (options.hasOption(token)) {
+                	tokens.add(token);
+                }
                 // requires bursting
                 else
                 {

src/test/org/apache/commons/cli/ArgumentIsOptionTest.java

@@ -0,0 +1,99 @@
+/**
+ * Copyright 2001-2004 The Apache Software Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.cli;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+
+public class ArgumentIsOptionTest extends TestCase {
+    private Options options = null;
+    private CommandLineParser parser = null;
+
+    public ArgumentIsOptionTest(String name) {
+        super(name);
+    }
+
+    public static Test suite() {
+        return new TestSuite(ArgumentIsOptionTest.class);
+    }
+
+    public void setUp() {
+        options = new Options().addOption("p", false, "Option p").addOption("attr",
+                true, "Option accepts argument");
+
+        parser = new PosixParser();
+    }
+
+    public void tearDown() {
+    }
+
+    public void testOptionAndOptionWithArgument() {
+        String[] args = new String[] {
+                "-p",
+                "-attr",
+                "value"
+            };
+
+        try {
+            CommandLine cl = parser.parse(options, args);
+            assertTrue("Confirm -p is set", cl.hasOption("p"));
+            assertTrue("Confirm -attr is set", cl.hasOption("attr"));
+            assertTrue("Confirm arg of -attr",
+                cl.getOptionValue("attr").equals("value"));
+            assertTrue("Confirm all arguments recognized", cl.getArgs().length == 0);
+        }
+        catch (ParseException e) {
+            fail(e.toString());
+        }
+    }
+
+    public void testOptionWithArgument() {
+        String[] args = new String[] {
+                "-attr",
+                "value"
+            };
+
+        try {
+            CommandLine cl = parser.parse(options, args);
+            assertFalse("Confirm -p is set", cl.hasOption("p"));
+            assertTrue("Confirm -attr is set", cl.hasOption("attr"));
+            assertTrue("Confirm arg of -attr",
+                cl.getOptionValue("attr").equals("value"));
+            assertTrue("Confirm all arguments recognized", cl.getArgs().length == 0);
+        }
+        catch (ParseException e) {
+            fail(e.toString());
+        }
+    }
+
+    public void testOption() {
+        String[] args = new String[] {
+                "-p"
+            };
+
+        try {
+            CommandLine cl = parser.parse(options, args);
+            assertTrue("Confirm -p is set", cl.hasOption("p"));
+            assertFalse("Confirm -attr is not set", cl.hasOption("attr"));
+            assertTrue("Confirm all arguments recognized", cl.getArgs().length == 0);
+        }
+        catch (ParseException e) {
+            fail(e.toString());
+        }
+    }
+}

src/test/org/apache/commons/cli/LongOptionWithShort.java

@@ -0,0 +1,113 @@
+/**
+ * Copyright 2001-2004 The Apache Software Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.commons.cli;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+
+/**
+ * <p>
+ * This is a collection of tests that test real world
+ * applications command lines focusing on options with
+ * long and short names.
+ * </p>
+ */
+public class LongOptionWithShort extends TestCase {
+    public LongOptionWithShort(String name) {
+        super(name);
+    }
+
+    public static Test suite() {
+        return new TestSuite(LongOptionWithShort.class);
+    }
+
+    /**
+     *
+     */
+    public void testLongOptionWithShort() {
+        Option help = new Option("h", "help", false, "print this message");
+        Option version = new Option("v", "version", false,
+                "print version information");
+        Option newRun = new Option("n", "new", false,
+                "Create NLT cache entries only for new items");
+        Option trackerRun = new Option("t", "tracker", false,
+                "Create NLT cache entries only for tracker items");
+
+        Option timeLimit = OptionBuilder.withLongOpt("limit").hasArg()
+                                        .withValueSeparator()
+                                        .withDescription("Set time limit for execution, in mintues")
+                                        .create("l");
+
+        Option age = OptionBuilder.withLongOpt("age").hasArg()
+                                  .withValueSeparator()
+                                  .withDescription("Age (in days) of cache item before being recomputed")
+                                  .create("a");
+
+        Option server = OptionBuilder.withLongOpt("server").hasArg()
+                                     .withValueSeparator()
+                                     .withDescription("The NLT server address")
+                                     .create("s");
+
+        Option numResults = OptionBuilder.withLongOpt("results").hasArg()
+                                         .withValueSeparator()
+                                         .withDescription("Number of results per item")
+                                         .create("r");
+
+        Option configFile = OptionBuilder.withLongOpt("file").hasArg()
+                                         .withValueSeparator()
+                                         .withDescription("Use the specified configuration file")
+                                         .create();
+
+        Options options = new Options();
+        options.addOption(help);
+        options.addOption(version);
+        options.addOption(newRun);
+        options.addOption(trackerRun);
+        options.addOption(timeLimit);
+        options.addOption(age);
+        options.addOption(server);
+        options.addOption(numResults);
+        options.addOption(configFile);
+
+        // create the command line parser
+        CommandLineParser parser = new PosixParser();
+
+        String[] args = new String[] {
+                "-v",
+                "-l",
+                "10",
+                "-age",
+                "5",
+                "-file",
+                "filename"
+            };
+
+        try {
+            CommandLine line = parser.parse(options, args);
+            assertTrue(line.hasOption("v"));
+            assertEquals(line.getOptionValue("l"), "10");
+            assertEquals(line.getOptionValue("limit"), "10");
+            assertEquals(line.getOptionValue("a"), "5");
+            assertEquals(line.getOptionValue("age"), "5");
+            assertEquals(line.getOptionValue("file"), "filename");
+        }
+        catch (ParseException exp) {
+            fail("Unexpected exception:" + exp.getMessage());
+        }
+    }
+}