commons-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jke...@apache.org
Subject cvs commit: jakarta-commons/cli/src/test/org/apache/commons/cli ApplicationTest.java GnuParseTest.java OptionBuilderTest.java OptionGroupTest.java OptionsTest.java ParseRequiredTest.java ParseTest.java ValueTest.java
Date Mon, 19 May 2003 20:50:24 GMT
jkeyes      2003/05/19 13:50:24

  Modified:    cli/src/test/org/apache/commons/cli Tag: cli_1_x
                        ApplicationTest.java GnuParseTest.java
                        OptionBuilderTest.java OptionGroupTest.java
                        OptionsTest.java ParseRequiredTest.java
                        ParseTest.java ValueTest.java
  Log:
  updated tests for version 2
  
  Revision  Changes    Path
  No                   revision
  
  
  No                   revision
  
  
  1.9.2.1   +188 -91   jakarta-commons/cli/src/test/org/apache/commons/cli/ApplicationTest.java
  
  Index: ApplicationTest.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/cli/src/test/org/apache/commons/cli/ApplicationTest.java,v
  retrieving revision 1.9
  retrieving revision 1.9.2.1
  diff -u -r1.9 -r1.9.2.1
  --- ApplicationTest.java	19 Sep 2002 22:59:44 -0000	1.9
  +++ ApplicationTest.java	19 May 2003 20:50:23 -0000	1.9.2.1
  @@ -1,5 +1,10 @@
   package org.apache.commons.cli;
   
  +import java.util.HashSet;
  +import java.util.List;
  +import java.util.Properties;
  +import java.util.Set;
  +
   import junit.framework.Test;
   import junit.framework.TestCase;
   import junit.framework.TestSuite;
  @@ -21,95 +26,187 @@
    */
   public class ApplicationTest extends TestCase {
   
  -    public static Test suite() { 
  -        return new TestSuite(ApplicationTest.class); 
  -    }
  -
  -    public ApplicationTest(String name)
  -    {
  -        super(name);
  -    }
  -    
  -    /**
  -     *	
  -     */
  -    public void testLs() {
  -        // create the command line parser
  -        CommandLineParser parser = new PosixParser();
  -        Options options = new Options();
  -        options.addOption( "a", "all", false, "do not hide entries starting with ." );
  -        options.addOption( "A", "almost-all", false, "do not list implied . and .." );
  -        options.addOption( "b", "escape", false, "print octal escapes for nongraphic characters" );
  -        options.addOption( OptionBuilder.withLongOpt( "block-size" )
  -                                        .withDescription( "use SIZE-byte blocks" )
  -                                        .withValueSeparator( '=' )
  -                                        .hasArg()
  -                                        .create() );
  -        options.addOption( "B", "ignore-backups", false, "do not list implied entried ending with ~");
  -        options.addOption( "c", false, "with -lt: sort by, and show, ctime (time of last modification of file status information) with -l:show ctime and sort by name otherwise: sort by ctime" );
  -        options.addOption( "C", false, "list entries by columns" );
  -
  -        String[] args = new String[]{ "--block-size=10" };
  -
  -        try {
  -            CommandLine line = parser.parse( options, args );
  -            assertTrue( line.hasOption( "block-size" ) );
  -            assertEquals( line.getOptionValue( "block-size" ), "10" );
  -        }
  -        catch( ParseException exp ) {
  -            fail( "Unexpected exception:" + exp.getMessage() );
  -        }
  -    }
  -
  -    /**
  -     * Ant test
  -     */
  -    public void testAnt() {
  -        // use the GNU parser
  -        CommandLineParser parser = new GnuParser( );
  -        Options options = new Options();
  -        options.addOption( "help", false, "print this message" );
  -        options.addOption( "projecthelp", false, "print project help information" );
  -        options.addOption( "version", false, "print the version information and exit" );
  -        options.addOption( "quiet", false, "be extra quiet" );
  -        options.addOption( "verbose", false, "be extra verbose" );
  -        options.addOption( "debug", false, "print debug information" );
  -        options.addOption( "version", false, "produce logging information without adornments" );
  -        options.addOption( "logfile", true, "use given file for log" );
  -        options.addOption( "logger", true, "the class which is to perform the logging" );
  -        options.addOption( "listener", true, "add an instance of a class as a project listener" );
  -        options.addOption( "buildfile", true, "use given buildfile" );
  -        options.addOption( OptionBuilder.withDescription( "use value for given property" )
  -                                        .hasArgs()
  -                                        .withValueSeparator()
  -                                        .create( 'D' ) );
  -                           //, null, true, , false, true );
  -        options.addOption( "find", true, "search for buildfile towards the root of the filesystem and use it" );
  -
  -        String[] args = new String[]{ "-buildfile", "mybuild.xml",
  -            "-Dproperty=value", "-Dproperty1=value1",
  -            "-projecthelp" };
  -
  -        try {
  -            CommandLine line = parser.parse( options, args );
  -
  -            // check multiple values
  -            String[] opts = line.getOptionValues( "D" );
  -            assertEquals( "property", opts[0] );
  -            assertEquals( "value", opts[1] );
  -            assertEquals( "property1", opts[2] );
  -            assertEquals( "value1", opts[3] );
  -
  -            // check single value
  -            assertEquals( line.getOptionValue( "buildfile"), "mybuild.xml" );
  -
  -            // check option
  -            assertTrue( line.hasOption( "projecthelp") );
  -        }
  -        catch( ParseException exp ) {
  -            fail( "Unexpected exception:" + exp.getMessage() );
  -        }
  -
  -    }
  -
  +	public static Test suite() {
  +		return new TestSuite(ApplicationTest.class);
  +	}
  +
  +	public ApplicationTest(String name) {
  +		super(name);
  +	}
  +
  +	/**
  +	 *	
  +	 */
  +	public void XtestLs() throws Exception {
  +		// create the command line parser
  +		CommandLineParser parser = new CommandLineParser();
  +		Options options = new Options();
  +
  +		OptionBuilder obuilder = new OptionBuilder();
  +		ArgumentBuilder abuilder = new ArgumentBuilder();
  +		Option a =
  +			obuilder.withDescription(
  +				"do not hide entries starting with .").create(
  +				"a",
  +				"all");
  +		options.add(a);
  +
  +		Option A =
  +			obuilder.withDescription("do not list implied . and ..").create(
  +				"A",
  +				"almost-all");
  +		options.add(A);
  +
  +		Option b =
  +			obuilder
  +				.withDescription("print octal escapes for nongraphic characters")
  +				.create("b", "escape");
  +		options.add(b);
  +
  +		Argument blockSize =
  +			abuilder.withDescription(
  +				"use SIZE-byte blocks").withValueSeparator(
  +				'=').create(
  +				null,
  +				"block-size");
  +		options.add(blockSize);
  +
  +		Option B =
  +			obuilder.withDescription(
  +				"do not list implied entried ending with ~").create(
  +				"B",
  +				"ignore-backups");
  +		options.add(B);
  +
  +		Option c =
  +			obuilder
  +				.withDescription("with -lt: sort by, and show, ctime (time of last modification of file status information) with -l:show ctime and sort by name otherwise: sort by ctime")
  +				.create("c");
  +		options.add(c);
  +
  +		Option C =
  +			obuilder.withDescription("list entries by columns").create("C");
  +		options.add(C);
  +
  +		String[] args = new String[] { "--block-size=10" };
  +
  +		CommandLine line = parser.parse(options, args);
  +		assertTrue(line.hasOption("--block-size"));
  +		assertEquals(line.getValue("--block-size"), "10");
  +	}
  +
  +	/**
  +	 * Ant test
  +	 */
  +	public void XtestAnt() throws Exception {
  +		CommandLineParser parser = new CommandLineParser();
  +		Options options = new Options();
  +
  +		OptionBuilder obuilder = new OptionBuilder();
  +		ArgumentBuilder abuilder = new ArgumentBuilder();
  +
  +		Option help =
  +			obuilder.withDescription("print this message").create("help");
  +		options.add(help);
  +		Option projecthelp =
  +			obuilder.withDescription("print project help information").create(
  +				"projecthelp");
  +		options.add(projecthelp);
  +		Option version =
  +			obuilder.withDescription(
  +				"print the version information and exit").create(
  +				"version");
  +		options.add(version);
  +		Option quiet =
  +			obuilder.withDescription("be extra quiet").create("quiet");
  +		options.add(quiet);
  +		Option verbose =
  +			obuilder.withDescription("be extra verbose").create("verbose");
  +		options.add(verbose);
  +		Option debug =
  +			obuilder.withDescription("print debug information").create("debug");
  +		options.add(debug);
  +
  +		Argument logfile =
  +			abuilder.withDescription("use given file for log").create(
  +				"logfile");
  +		options.add(logfile);
  +		Argument logger =
  +			abuilder.withDescription(
  +				"the class which is to perform the logging").create(
  +				"logger");
  +		options.add(logger);
  +		Argument listener =
  +			abuilder
  +				.withDescription("add an instance of a class as a project listener")
  +				.create("listener");
  +		options.add(listener);
  +		Argument buildfile =
  +			abuilder.withDescription("use given buildfile").create("buildfile");
  +		options.add(buildfile);
  +		Argument find =
  +			abuilder
  +				.withDescription("search for buildfile towards the root of the filesystem and use it")
  +				.create("find");
  +		options.add(find);
  +
  +		String[] args =
  +			new String[] {
  +				"-buildfile",
  +				"mybuild.xml",
  +				"-Dproperty=value",
  +				"-Dproperty1=value1",
  +				"-projecthelp" };
  +
  +		CommandLine line = parser.parse(options, args);
  +
  +		// check Java properties
  +		Properties props = line.getProperties();
  +		assertEquals("value", props.get("property"));
  +		assertEquals("value1", props.get("property1"));
  +
  +		// check single value
  +		assertEquals(line.getValue("-buildfile"), "mybuild.xml");
  +
  +		// check option
  +		assertTrue(line.hasOption("-projecthelp"));
  +
  +	}
  +
  +	public void testCVS() throws Exception {
  +		OptionBuilder obuilder = new OptionBuilder();
  +		ArgumentBuilder abuilder = new ArgumentBuilder();
  +		
  +		Option q = obuilder.withDescription("Cause CVS to be somewhat quiet.")
  +		    .create("q");
  +		
  +		Argument anon = abuilder.createAnonymous("command");
  +		    
  +		Option p = obuilder.withDescription("Prune empty directories.")
  +		    .create("p");
  +		Set opts = new HashSet();
  +		opts.add(p);
  +
  +		Options options = new Options();
  +		options.add(q);
  +		options.add(anon);
  +		
  +		Options co = new Options();
  +		co.addOptions(opts);
  +		
  +		String[] args = new String[] { "-q", "co", "-p" };
  +		CommandLineParser parser = new CommandLineParser();
  +		CommandLine line = parser.parse(options, args);
  +		
  +		assertTrue(line.hasOption("-q"));
  +		List values = line.getAnonymousValues();
  +		
  +		String command = (String)values.get(0);
  +		values.remove(0);
  +		if ("co".equals(command)) {
  +			line = parser.parse(co, (String[])values.toArray(new String[]{}));
  +		}
  +		assertTrue(line.hasOption("-p"));
  +		
  +	}
   }
  
  
  
  1.3.2.1   +121 -135  jakarta-commons/cli/src/test/org/apache/commons/cli/GnuParseTest.java
  
  Index: GnuParseTest.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/cli/src/test/org/apache/commons/cli/GnuParseTest.java,v
  retrieving revision 1.3
  retrieving revision 1.3.2.1
  diff -u -r1.3 -r1.3.2.1
  --- GnuParseTest.java	19 Sep 2002 22:59:44 -0000	1.3
  +++ GnuParseTest.java	19 May 2003 20:50:23 -0000	1.3.2.1
  @@ -30,21 +30,23 @@
   
       public void setUp()
       {
  -        _options = new Options()
  -            .addOption("a",
  -                       "enable-a",
  -                       false,
  -                       "turn [a] on or off")
  -            .addOption("b",
  -                       "bfile",
  -                       true,
  -                       "set the value of [b]")
  -            .addOption("c",
  -                       "copt",
  -                       false,
  -                       "turn [c] on or off");
  -
  -        _parser = new GnuParser( );
  +    	OptionBuilder obuilder = new OptionBuilder();
  +    	ArgumentBuilder abuilder = new ArgumentBuilder();
  +    	
  +        _options = new Options();
  +        
  +        Option a = obuilder.withDescription("turn [a] on or off")
  +                          .create("a","enable-a");
  +        _options.add( a ); 
  +        Argument b = abuilder.withDescription("set the values of [b]")
  +                          .create("b", "bfile");
  +		_options.add( b ); 
  +        Option c = obuilder.withDescription("turn [c] on or off")
  +                           .create("c", "copt");
  +		_options.add( c );
  +		
  +		_options.add( abuilder.createAnonymous("anon")); 
  +        _parser = new CommandLineParser( );
       }
   
       public void tearDown()
  @@ -52,49 +54,32 @@
   
       }
   
  -    public void testSimpleShort()
  +    public void testSimpleShort() throws Exception
       {
  -        String[] args = new String[] { "-a",
  -                                       "-b", "toast",
  -                                       "foo", "bar" };
  +		String[] args = new String[] { "-a", "-b", "toast", "foo", "bar" };
   
  -        try
  -        {
  -            CommandLine cl = _parser.parse(_options, args);
  -            
  -            assertTrue( "Confirm -a is set", cl.hasOption("a") );
  -            assertTrue( "Confirm -b is set", cl.hasOption("b") );
  -            assertTrue( "Confirm arg of -b", cl.getOptionValue("b").equals("toast") );
  -            assertTrue( "Confirm size of extra args", cl.getArgList().size() == 2);
  -        }
  -        catch (ParseException e)
  -        {
  -            fail( e.toString() );
  -        }
  +		CommandLine cl = _parser.parse(_options, args);
  +
  +		assertTrue("Confirm -a is set", cl.hasOption("-a"));
  +		assertTrue("Confirm -b is set", cl.hasOption("-b"));
  +		assertTrue("Confirm arg of -b", cl.getValue("-b").equals("toast"));
  +		assertTrue("Confirm size of extra args", cl.getAnonymousValues().size() == 2);
       }
   
  -    public void testSimpleLong()
  +    public void testSimpleLong() throws Exception
       {
  -        String[] args = new String[] { "--enable-a",
  -                                       "--bfile", "toast",
  -                                       "foo", "bar" };
  +		String[] args =
  +			new String[] { "--enable-a", "--bfile", "toast", "foo", "bar" };
   
  -        try
  -        {
  -            CommandLine cl = _parser.parse(_options, args);
  -            
  -            assertTrue( "Confirm -a is set", cl.hasOption("a") );
  -            assertTrue( "Confirm -b is set", cl.hasOption("b") );
  -            assertTrue( "Confirm arg of -b", cl.getOptionValue("b").equals("toast") );
  -            assertTrue( "Confirm size of extra args", cl.getArgList().size() == 2);
  -        } 
  -        catch (ParseException e)
  -        {
  -            fail( e.toString() );
  -        }
  +		CommandLine cl = _parser.parse(_options, args);
  +
  +		assertTrue("Confirm -a is set", cl.hasOption("-a"));
  +		assertTrue("Confirm -b is set", cl.hasOption("-b"));
  +		assertTrue("Confirm arg of -b", cl.getValue("-b").equals("toast"));
  +		assertTrue("Confirm size of extra args", cl.getAnonymousValues().size() == 2);
       }
   
  -    public void testExtraOption()
  +    public void testExtraOption() throws Exception
       {
           String[] args = new String[] { "-a", "-d", "-b", "toast",
                                          "foo", "bar" };
  @@ -105,12 +90,12 @@
           {
               CommandLine cl = _parser.parse(_options, args);
               
  -            assertTrue( "Confirm -a is set", cl.hasOption("a") );
  -            assertTrue( "Confirm -b is set", cl.hasOption("b") );
  -            assertTrue( "confirm arg of -b", cl.getOptionValue("b").equals("toast") );
  -            assertTrue( "Confirm size of extra args", cl.getArgList().size() == 3);
  +            assertTrue( "Confirm -a is set", cl.hasOption("-a") );
  +            assertTrue( "Confirm -b is set", cl.hasOption("-b") );
  +            assertTrue( "confirm arg of -b", cl.getValue("-b").equals("toast") );
  +            assertTrue( "Confirm size of extra args", cl.getAnonymousValues().size() == 3);
           }
  -        catch (UnrecognizedOptionException e)
  +        catch (UnknownOptionException e)
           {
               caught = true;
           }
  @@ -132,7 +117,7 @@
           {
               CommandLine cl = _parser.parse(_options, args);
           }
  -        catch (MissingArgumentException e)
  +        catch (MissingValueException e)
           {
               caught = true;
           }
  @@ -143,7 +128,7 @@
   
           assertTrue( "Confirm MissingArgumentException caught", caught );
       }
  -
  +/*
       public void testStop()
       {
           String[] args = new String[] { "-c",
  @@ -154,111 +139,112 @@
           try
           {
               CommandLine cl = _parser.parse(_options, args, true);
  -            assertTrue( "Confirm -c is set", cl.hasOption("c") );
  -            assertTrue( "Confirm  3 extra args: " + cl.getArgList().size(), cl.getArgList().size() == 3);
  +            assertTrue( "Confirm -c is set", cl.hasOption("-c") );
  +            assertTrue( "Confirm  3 extra args: " + cl.getAnonymousValues().size(), cl.getArgList().size() == 3);
           }
           catch (ParseException e)
           {
               fail( e.toString() );
           }
  -    }
  +    }*/
   
  -    public void testMultiple()
  +    /*public void testMultiple() throws Exception
       {
  -        String[] args = new String[] { "-c",
  -                                       "foobar",
  -                                       "-b",
  -                                       "toast" };
  +		String[] args = new String[] { "-c", "foobar", "-b", "toast" };
   
  -        try
  -        {
  -            CommandLine cl = _parser.parse(_options, args, true);
  -            assertTrue( "Confirm -c is set", cl.hasOption("c") );
  -            assertTrue( "Confirm  3 extra args: " + cl.getArgList().size(), cl.getArgList().size() == 3);
  +		CommandLine cl = _parser.parse(_options, args );//, true);
  +		assertTrue("Confirm -c is set", cl.hasOption("-c"));
  +		assertTrue(
  +			"Confirm  3 extra args: " + cl.getAnonymousValues().size(),
  +			cl.getAnonymousValues().size() == 3);
   
  -            cl = _parser.parse(_options, cl.getArgs() );
  +		cl = _parser.parse(_options, (String[])cl.getAnonymousValues().toArray(new String[cl.getAnonymousValues().size()]));
   
  -            assertTrue( "Confirm -c is not set", ! cl.hasOption("c") );
  -            assertTrue( "Confirm -b is set", cl.hasOption("b") );
  -            assertTrue( "Confirm arg of -b", cl.getOptionValue("b").equals("toast") );
  -            assertTrue( "Confirm  1 extra arg: " + cl.getArgList().size(), cl.getArgList().size() == 1);
  -            assertTrue( "Confirm  value of extra arg: " + cl.getArgList().get(0), cl.getArgList().get(0).equals("foobar") );
  -        }
  -        catch (ParseException e)
  -        {
  -            fail( e.toString() );
  -        }
  -    }
  -
  -    public void testMultipleWithLong()
  +		assertTrue("Confirm -c is not set", !cl.hasOption("-c"));
  +		assertTrue("Confirm -b is set", cl.hasOption("-b"));
  +		assertTrue("Confirm arg of -b", cl.getValue("-b").equals("toast"));
  +		assertTrue(
  +			"Confirm  1 extra args: " + cl.getAnonymousValues().size(),
  +			cl.getAnonymousValues().size() == 1);
  +		assertTrue(
  +			"Confirm  value of extra arg: " + cl.getAnonymousValues().get(0),
  +			cl.getAnonymousValues().get(0).equals("foobar"));
  +    }*/
  +    
  +/*
  +    public void testMultipleWithLong() throws Exception
       {
           String[] args = new String[] { "--copt",
                                          "foobar",
                                          "--bfile", "toast" };
   
  -        try
  -        {
               CommandLine cl = _parser.parse(_options,args,
                                               true);
  -            assertTrue( "Confirm -c is set", cl.hasOption("c") );
  -            assertTrue( "Confirm  3 extra args: " + cl.getArgList().size(), cl.getArgList().size() == 3);
  +            assertTrue( "Confirm -c is set", cl.hasOption("-c") );
  +            assertTrue( "Confirm  3 extra args: " + cl.getAnonymousValues().size(), cl.getAnonymousValues().size() == 3);
   
               cl = _parser.parse(_options, cl.getArgs() );
   
  -            assertTrue( "Confirm -c is not set", ! cl.hasOption("c") );
  -            assertTrue( "Confirm -b is set", cl.hasOption("b") );
  -            assertTrue( "Confirm arg of -b", cl.getOptionValue("b").equals("toast") );
  -            assertTrue( "Confirm  1 extra arg: " + cl.getArgList().size(), cl.getArgList().size() == 1);
  -            assertTrue( "Confirm  value of extra arg: " + cl.getArgList().get(0), cl.getArgList().get(0).equals("foobar") );
  -        }
  -        catch (ParseException e)
  -        {
  -            fail( e.toString() );
  -        }
  +            assertTrue( "Confirm -c is not set", ! cl.hasOption("-c") );
  +            assertTrue( "Confirm -b is set", cl.hasOption("-b") );
  +            assertTrue( "Confirm arg of -b", cl.getValue("-b").equals("toast") );
  +            assertTrue( "Confirm  1 extra arg: " + cl.getAnonymousValues().size(), cl.getAnonymousValues().size() == 1);
  +            assertTrue( "Confirm  value of extra arg: " + cl.getAnonymousValues().get(0), cl.getAnonymousValues().get(0).equals("foobar") );
       }
  -
  -    public void testDoubleDash()
  +*/
  +    public void testDoubleDash() throws Exception
       {
  -        String[] args = new String[] { "--copt",
  -                                       "--",
  -                                       "-b", "toast" };
  +		String[] args = new String[] { "--copt", "--", "-b", "toast" };
   
  -        try
  -        {
  -            CommandLine cl = _parser.parse(_options, args);
  +		CommandLine cl = _parser.parse(_options, args);
   
  -            assertTrue( "Confirm -c is set", cl.hasOption("c") );
  -            assertTrue( "Confirm -b is not set", ! cl.hasOption("b") );
  -            assertTrue( "Confirm 2 extra args: " + cl.getArgList().size(), cl.getArgList().size() == 2);
  -
  -        }
  -        catch (ParseException e)
  -        {
  -            fail( e.toString() );
  -        }
  +		assertTrue("Confirm -c is set", cl.hasOption("-c"));
  +		assertTrue("Confirm -b is not set", !cl.hasOption("-b"));
  +		assertTrue(
  +			"Confirm 2 unprocessed args: " + cl.getUnprocessed().size(),
  +			cl.getUnprocessed().size() == 2);
       }
   
  -    public void testSingleDash()
  +    public void testSingleDash() throws Exception
       {
  -        String[] args = new String[] { "--copt",
  -                                       "-b", "-",
  -                                       "-a",
  -                                       "-" };
  +		String[] args = new String[] { "--copt", "-b", "-", "-a" };
   
  -        try
  -        {
  -            CommandLine cl = _parser.parse(_options, args);
  +		CommandLine cl = _parser.parse(_options, args);
   
  -            assertTrue( "Confirm -a is set", cl.hasOption("a") );
  -            assertTrue( "Confirm -b is set", cl.hasOption("b") );
  -            assertTrue( "Confirm arg of -b", cl.getOptionValue("b").equals("-") );
  -            assertTrue( "Confirm 1 extra arg: " + cl.getArgList().size(), cl.getArgList().size() == 1);
  -            assertTrue( "Confirm value of extra arg: " + cl.getArgList().get(0), cl.getArgList().get(0).equals("-") );
  -        }
  -        catch (ParseException e)
  -        {
  -            fail( e.toString() );
  -        }
  -        
  +		assertTrue("Confirm -a is set", cl.hasOption("-a"));
  +		assertTrue("Confirm -b is set", cl.hasOption("-b"));
  +		assertTrue("Confirm arg of -b", cl.getValue("-b").equals("-"));
  +		assertTrue(
  +			"More than 0 anonymous values: " + cl.getAnonymousValues().size(),
  +			cl.getAnonymousValues().size() == 0);
       }
  +    
  +	public void testMandatoryDuplicates() throws Exception {
  +		OptionBuilder obuilder = new OptionBuilder();
  +		ArgumentBuilder abuilder = new ArgumentBuilder();
  +    	
  +		Options opts = new Options();
  +        
  +		opts.add( obuilder.isRequired()
  +					   .withDescription("toggle -a")
  +					   .create("a", "a"));
  +
  +		opts.add( abuilder.isRequired()
  +					   .withDescription("toggle -a*")
  +					   .create("a", "a"));
  +        
  +		assertEquals( "last one in wins", "toggle -a*", opts.getOption("-a").getDescription() );
  +		assertEquals( "last one in wins", "toggle -a*", opts.getOption("--a").getDescription() );
  +		
  +		String[] args = new String[] { "-a"};
  +		CommandLineParser parser = new CommandLineParser();
  +		
  +		try {
  +			CommandLine line = parser.parse( opts, args );
  +			fail("MissingValueException not caught.");
  +		}
  +		catch( MissingValueException exp ) {
  +		}
  +	}
  +
   }
  
  
  
  1.3.2.1   +4 -5      jakarta-commons/cli/src/test/org/apache/commons/cli/OptionBuilderTest.java
  
  Index: OptionBuilderTest.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/cli/src/test/org/apache/commons/cli/OptionBuilderTest.java,v
  retrieving revision 1.3
  retrieving revision 1.3.2.1
  diff -u -r1.3 -r1.3.2.1
  --- OptionBuilderTest.java	18 Nov 2002 08:41:26 -0000	1.3
  +++ OptionBuilderTest.java	19 May 2003 20:50:23 -0000	1.3.2.1
  @@ -21,16 +21,15 @@
       }
   
       public void testCompleteOption( ) {
  -        Option simple = OptionBuilder.withLongOpt( "simple option")
  -                                     .hasArg( )
  +/*        Option simple = ArgumentBuilder.hasArg( )
                                        .isRequired( )
                                        .hasArgs( )
                                        .withType( new Float( 10 ) )
                                        .withDescription( "this is a simple option" )
  -                                     .create( 's' );
  +                                     .create( 's', "simpleOption" );
   
           assertEquals( "s", simple.getOpt() );
  -        assertEquals( "simple option", simple.getLongOpt() );
  +        assertEquals( "simpleOption", simple.getLongOpt() );
           assertEquals( "this is a simple option", simple.getDescription() );
           assertEquals( simple.getType().getClass(), Float.class );
           assertTrue( simple.hasArg() );
  @@ -144,6 +143,6 @@
           }
           catch( IllegalArgumentException exp ) {
               fail( "IllegalArgumentException caught" );
  -        }
  +        }*/
       }
   }
  
  
  
  1.5.2.1   +148 -96   jakarta-commons/cli/src/test/org/apache/commons/cli/OptionGroupTest.java
  
  Index: OptionGroupTest.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/cli/src/test/org/apache/commons/cli/OptionGroupTest.java,v
  retrieving revision 1.5
  retrieving revision 1.5.2.1
  diff -u -r1.5 -r1.5.2.1
  --- OptionGroupTest.java	19 Nov 2002 00:16:18 -0000	1.5
  +++ OptionGroupTest.java	19 May 2003 20:50:23 -0000	1.5.2.1
  @@ -22,7 +22,7 @@
   {
   
       private Options _options = null;
  -    private CommandLineParser parser = new PosixParser();
  +    private CommandLineParser parser = new CommandLineParser();
   
   
       public static Test suite() 
  @@ -37,29 +37,52 @@
   
       public void setUp()
       {
  -        Option file = new Option( "f", "file", false, "file to process" );
  -        Option dir = new Option( "d", "directory", false, "directory to process" );
  -        OptionGroup group = new OptionGroup();
  -        group.addOption( file );
  -        group.addOption( dir );
  -        _options = new Options().addOptionGroup( group );
  -
  -        Option section = new Option( "s", "section", false, "section to process" );
  -        Option chapter = new Option( "c", "chapter", false, "chapter to process" );
  -        OptionGroup group2 = new OptionGroup();
  -        group2.addOption( section );
  -        group2.addOption( chapter );
  -
  -        _options.addOptionGroup( group2 );
  -
  -        Option importOpt = new Option( null, "import", false, "section to process" );
  -        Option exportOpt = new Option( null, "export", false, "chapter to process" );
  -        OptionGroup group3 = new OptionGroup();
  -        group3.addOption( importOpt );
  -        group3.addOption( exportOpt );
  -        _options.addOptionGroup( group3 );
  -
  -        _options.addOption( "r", "revision", false, "revision number" );
  +		OptionBuilder builder = new OptionBuilder();
  +		ArgumentBuilder abuilder = new ArgumentBuilder();
  +    	
  +		Option file = builder.withDescription("file to process")
  +							.create("f","file"); 
  +		Option dir = builder.withDescription("directory to process")
  +							.create("d","directory"); 
  +        //new Option( "f", "file", false, "file to process" );
  +        //Option dir = new Option( "d", "directory", false, "directory to process" );
  +        ExclusiveOptionGroup group = new ExclusiveOptionGroup();
  +        group.add( file );
  +        group.add( dir );
  +        _options = new Options();
  +        _options.add( group );
  +
  +		Option section = builder.withDescription("section to process")
  +							.create("s","section"); 
  +		Option chapter = builder.withDescription("chapter to process")
  +							.create("c","chapter"); 
  +
  +        //Option section = new Option( "s", "section", false, "section to process" );
  +        //Option chapter = new Option( "c", "chapter", false, "chapter to process" );
  +        ExclusiveOptionGroup group2 = new ExclusiveOptionGroup();
  +        group2.add( section );
  +        group2.add( chapter );
  +
  +        _options.add( group2 );
  +
  +		Option importOpt = builder.withDescription("import to process")
  +							.create(null,"import"); 
  +		Option exportOpt = builder.withDescription("export to process")
  +							.create(null,"export"); 
  +
  +        //Option importOpt = new Option( null, "import", false, "section to process" );
  +        //Option exportOpt = new Option( null, "export", false, "chapter to process" );
  +        ExclusiveOptionGroup group3 = new ExclusiveOptionGroup();
  +        group3.add( importOpt );
  +        group3.add( exportOpt );
  +        _options.add( group3 );
  +
  +		Option revision = builder.withDescription("revision number")
  +							.create("r","revision"); 
  +
  +        _options.add( revision );
  +        
  +        _options.add( abuilder.createAnonymous("anon"));
       }
   
       public void tearDown()
  @@ -74,12 +97,12 @@
           {
               CommandLine cl = parser.parse( _options, args);
   
  -            assertTrue( "Confirm -r is NOT set", !cl.hasOption("r") );
  -            assertTrue( "Confirm -f is set", cl.hasOption("f") );
  -            assertTrue( "Confirm -d is NOT set", !cl.hasOption("d") );
  -            assertTrue( "Confirm -s is NOT set", !cl.hasOption("s") );
  -            assertTrue( "Confirm -c is NOT set", !cl.hasOption("c") );
  -            assertTrue( "Confirm no extra args", cl.getArgList().size() == 0);
  +            assertTrue( "Confirm -r is NOT set", !cl.hasOption("-r") );
  +            assertTrue( "Confirm -f is set", cl.hasOption("-f") );
  +            assertTrue( "Confirm -d is NOT set", !cl.hasOption("-d") );
  +            assertTrue( "Confirm -s is NOT set", !cl.hasOption("-s") );
  +            assertTrue( "Confirm -c is NOT set", !cl.hasOption("-c") );
  +            //assertTrue( "Confirm no extra args", cl.getArgList().size() == 0);
           }
           catch (ParseException e)
           {
  @@ -95,12 +118,12 @@
           {
               CommandLine cl = parser.parse( _options, args);
   
  -            assertTrue( "Confirm -r is set", cl.hasOption("r") );
  -            assertTrue( "Confirm -f is NOT set", !cl.hasOption("f") );
  -            assertTrue( "Confirm -d is NOT set", !cl.hasOption("d") );
  -            assertTrue( "Confirm -s is NOT set", !cl.hasOption("s") );
  -            assertTrue( "Confirm -c is NOT set", !cl.hasOption("c") );
  -            assertTrue( "Confirm no extra args", cl.getArgList().size() == 0);
  +            assertTrue( "Confirm -r is set", cl.hasOption("-r") );
  +            assertTrue( "Confirm -f is NOT set", !cl.hasOption("-f") );
  +            assertTrue( "Confirm -d is NOT set", !cl.hasOption("-d") );
  +            assertTrue( "Confirm -s is NOT set", !cl.hasOption("-s") );
  +            assertTrue( "Confirm -c is NOT set", !cl.hasOption("-c") );
  +            //assertTrue( "Confirm no extra args", cl.getArgList().size() == 0);
           }
           catch (ParseException e)
           {
  @@ -116,12 +139,12 @@
           {
               CommandLine cl = parser.parse( _options, args);
   
  -            assertTrue( "Confirm -r is set", cl.hasOption("r") );
  -            assertTrue( "Confirm -f is set", cl.hasOption("f") );
  -            assertTrue( "Confirm -d is NOT set", !cl.hasOption("d") );
  -            assertTrue( "Confirm -s is NOT set", !cl.hasOption("s") );
  -            assertTrue( "Confirm -c is NOT set", !cl.hasOption("c") );
  -            assertTrue( "Confirm no extra args", cl.getArgList().size() == 0);
  +            assertTrue( "Confirm -r is set", cl.hasOption("-r") );
  +            assertTrue( "Confirm -f is set", cl.hasOption("-f") );
  +            assertTrue( "Confirm -d is NOT set", !cl.hasOption("-d") );
  +            assertTrue( "Confirm -s is NOT set", !cl.hasOption("-s") );
  +            assertTrue( "Confirm -c is NOT set", !cl.hasOption("-c") );
  +            //assertTrue( "Confirm no extra args", cl.getArgList().size() == 0);
           }
           catch (ParseException e)
           {
  @@ -137,12 +160,12 @@
           {
               CommandLine cl = parser.parse( _options, args);
   
  -            assertTrue( "Confirm -r is NOT set", !cl.hasOption("r") );
  -            assertTrue( "Confirm -f is set", cl.hasOption("f") );
  -            assertTrue( "Confirm -d is NOT set", !cl.hasOption("d") );
  -            assertTrue( "Confirm -s is NOT set", !cl.hasOption("s") );
  -            assertTrue( "Confirm -c is NOT set", !cl.hasOption("c") );
  -            assertTrue( "Confirm no extra args", cl.getArgList().size() == 0);
  +            assertTrue( "Confirm -r is NOT set", !cl.hasOption("-r") );
  +            assertTrue( "Confirm -f is set", cl.hasOption("-f") );
  +            assertTrue( "Confirm -d is NOT set", !cl.hasOption("-d") );
  +            assertTrue( "Confirm -s is NOT set", !cl.hasOption("-s") );
  +            assertTrue( "Confirm -c is NOT set", !cl.hasOption("-c") );
  +            //assertTrue( "Confirm no extra args", cl.getArgList().size() == 0);
           }
           catch (ParseException e)
           {
  @@ -158,12 +181,12 @@
           {
               CommandLine cl = parser.parse( _options, args);
   
  -            assertTrue( "Confirm -r is set", cl.hasOption("r") );
  -            assertTrue( "Confirm -f is set", cl.hasOption("f") );
  -            assertTrue( "Confirm -d is NOT set", !cl.hasOption("d") );
  -            assertTrue( "Confirm -s is NOT set", !cl.hasOption("s") );
  -            assertTrue( "Confirm -c is NOT set", !cl.hasOption("c") );
  -            assertTrue( "Confirm no extra args", cl.getArgList().size() == 0);
  +            assertTrue( "Confirm -r is set", cl.hasOption("-r") );
  +            assertTrue( "Confirm -f is set", cl.hasOption("-f") );
  +            assertTrue( "Confirm -d is NOT set", !cl.hasOption("-d") );
  +            assertTrue( "Confirm -s is NOT set", !cl.hasOption("-s") );
  +            assertTrue( "Confirm -c is NOT set", !cl.hasOption("-c") );
  +            //assertTrue( "Confirm no extra args", cl.getArgList().size() == 0);
           }
           catch (ParseException e)
           {
  @@ -171,25 +194,18 @@
           }
       }
   
  -    public void testNoOptionsExtraArgs()
  +    public void testNoOptionsExtraArgs() throws Exception
       {
  -        String[] args = new String[] { "arg1", "arg2" };
  +		String[] args = new String[] { "arg1", "arg2" };
   
  -        try
  -        {
  -            CommandLine cl = parser.parse( _options, args);
  +		CommandLine cl = parser.parse(_options, args);
   
  -            assertTrue( "Confirm -r is NOT set", !cl.hasOption("r") );
  -            assertTrue( "Confirm -f is NOT set", !cl.hasOption("f") );
  -            assertTrue( "Confirm -d is NOT set", !cl.hasOption("d") );
  -            assertTrue( "Confirm -s is NOT set", !cl.hasOption("s") );
  -            assertTrue( "Confirm -c is NOT set", !cl.hasOption("c") );
  -            assertTrue( "Confirm TWO extra args", cl.getArgList().size() == 2);
  -        }
  -        catch (ParseException e)
  -        {
  -            fail( e.toString() );
  -        }
  +		assertTrue("Confirm -r is NOT set", !cl.hasOption("-r"));
  +		assertTrue("Confirm -f is NOT set", !cl.hasOption("-f"));
  +		assertTrue("Confirm -d is NOT set", !cl.hasOption("-d"));
  +		assertTrue("Confirm -s is NOT set", !cl.hasOption("-s"));
  +		assertTrue("Confirm -c is NOT set", !cl.hasOption("-c"));
  +		assertTrue("Confirm TWO extra args", cl.getAnonymousValues().size() == 2);
       }
   
       public void testTwoOptionsFromGroup()
  @@ -235,12 +251,12 @@
           try
           {
               CommandLine cl = parser.parse( _options, args);
  -            assertTrue( "Confirm -r is NOT set", !cl.hasOption("r") );
  -            assertTrue( "Confirm -f is set", cl.hasOption("f") );
  -            assertTrue( "Confirm -d is NOT set", !cl.hasOption("d") );
  -            assertTrue( "Confirm -s is set", cl.hasOption("s") );
  -            assertTrue( "Confirm -c is NOT set", !cl.hasOption("c") );
  -            assertTrue( "Confirm NO extra args", cl.getArgList().size() == 0);
  +            assertTrue( "Confirm -r is NOT set", !cl.hasOption("-r") );
  +            assertTrue( "Confirm -f is set", cl.hasOption("-f") );
  +            assertTrue( "Confirm -d is NOT set", !cl.hasOption("-d") );
  +            assertTrue( "Confirm -s is set", cl.hasOption("-s") );
  +            assertTrue( "Confirm -c is NOT set", !cl.hasOption("-c") );
  +            //assertTrue( "Confirm NO extra args", cl.getArgList().size() == 0);
           }
           catch (ParseException e)
           {
  @@ -248,27 +264,63 @@
           }
       }
   
  -    public void testValidLongOnlyOptions()
  +    public void testValidLongOnlyOptions() throws Exception
       {
  -        try
  -        {
  -            CommandLine cl = parser.parse( _options, new String[]{"--export"});
  -            assertTrue( "Confirm --export is set", cl.hasOption("export") );
  -        }
  -        catch (ParseException e)
  -        {
  -            fail( e.toString() );
  -        }
  -                            
  -        try
  -        {
  -            CommandLine cl = parser.parse( _options, new String[]{"--import"});
  -            assertTrue( "Confirm --import is set", cl.hasOption("import") );
  -        }
  -        catch (ParseException e)
  -        {
  -            fail( e.toString() );
  -        }
  +		CommandLine cl = parser.parse( _options, new String[]{"--import"});
  +		assertTrue( "Confirm --import is set", cl.hasOption("--import") );
  +        
  +        cl = parser.parse( _options, new String[]{"--export"});
  +        assertTrue( "Confirm --export is set", cl.hasOption("--export") );
  +
  +        cl = parser.parse( _options, new String[]{"--import"});
  +        assertTrue( "Confirm --import is set", cl.hasOption("--import") );
  +    }
  +    
  +    public void testInclusiveOption() throws Exception {
  +    	OptionBuilder builder = new OptionBuilder();
  +		Option a = builder.create("a");	
  +		Option b = builder.create("b");
  +		InclusiveOptionGroup group = new InclusiveOptionGroup();
  +		group.add(a);
  +		group.add(b);
  +		
  +		Options options = new Options();
  +		options.add(group);
  +		
  +		CommandLineParser parser = new CommandLineParser();
  +		String[] args = new String[] { "-a", "-b" };
  +		parser.parse(options, args);
  +    }
  +    
  +    public void testSetAndOption() throws Exception {
  +		ArgumentBuilder builder = new ArgumentBuilder();
  +		Argument o = builder.create("o");
  +		Argument g = builder.isRequired().create("g");
  +		Argument I = builder.create("I");
  +		
  +	    ExclusiveOptionGroup group = new ExclusiveOptionGroup();
  +	    
  +	    InclusiveOptionGroup inc = new InclusiveOptionGroup();
  +		inc.add(I);
  +		inc.add(g);
  +		
  +	    group.setMandatory(true);
  +	    group.add(o);
  +	    group.add(inc);
  +	    
  +	    Options options = new Options();
  +	    options.add(group);
  +	    
  +	    CommandLineParser parser = new CommandLineParser();
  +		String[] args = new String[] {
  +			"-o", "value"
  +		};
  +		//parser.parse(options, args);
  +
  +		args = new String[] {
  +			"-I", "value", "-g", "value1"
  +		};
  +		parser.parse(options, args);
       }
   
   
  
  
  
  1.1.2.1   +63 -115   jakarta-commons/cli/src/test/org/apache/commons/cli/OptionsTest.java
  
  Index: OptionsTest.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/cli/src/test/org/apache/commons/cli/OptionsTest.java,v
  retrieving revision 1.1
  retrieving revision 1.1.2.1
  diff -u -r1.1 -r1.1.2.1
  --- OptionsTest.java	19 Nov 2002 00:16:18 -0000	1.1
  +++ OptionsTest.java	19 May 2003 20:50:23 -0000	1.1.2.1
  @@ -1,63 +1,13 @@
   /*
  - * $Header$
  - * $Revision$
  - * $Date$
  - *
  - * ====================================================================
  - *
  - * The Apache Software License, Version 1.1
  - *
  - * Copyright (c) 1999-2001 The Apache Software Foundation.  All rights
  - * reserved.
  - *
  - * Redistribution and use in source and binary forms, with or without
  - * modification, are permitted provided that the following conditions
  - * are met:
  - *
  - * 1. Redistributions of source code must retain the above copyright
  - *    notice, this list of conditions and the following disclaimer.
  - *
  - * 2. Redistributions in binary form must reproduce the above copyright
  - *    notice, this list of conditions and the following disclaimer in
  - *    the documentation and/or other materials provided with the
  - *    distribution.
  - *
  - * 3. The end-user documentation included with the redistribution, if
  - *    any, must include the following acknowlegement:
  - *       "This product includes software developed by the
  - *        Apache Software Foundation (http://www.apache.org/)."
  - *    Alternately, this acknowlegement may appear in the software itself,
  - *    if and wherever such third-party acknowlegements normally appear.
  - *
  - * 4. The names "The Jakarta Project", "Commons", and "Apache Software
  - *    Foundation" must not be used to endorse or promote products derived
  - *    from this software without prior written permission. For written
  - *    permission, please contact apache@apache.org.
  - *
  - * 5. Products derived from this software may not be called "Apache"
  - *    nor may "Apache" appear in their names without prior written
  - *    permission of the Apache Group.
  - *
  - * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  - * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  - * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  - * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  - * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  - * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  - * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  - * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  - * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  - * SUCH DAMAGE.
  - * ====================================================================
  - *
  - * This software consists of voluntary contributions made by many
  - * individuals on behalf of the Apache Software Foundation.  For more
  - * information on the Apache Software Foundation, please see
  - * <http://www.apache.org/>.
  + * Copyright (C) The Apache Software Foundation. All rights reserved.
    *
  + * This software is published under the terms of the Apache Software License
  + * version 1.1, a copy of which has been included with this distribution in
  + * the LICENSE file.
  + * 
  + * $Id$
    */
  +
   package org.apache.commons.cli;
   
   import java.util.ArrayList;
  @@ -67,78 +17,76 @@
   import junit.framework.TestCase;
   import junit.framework.TestSuite;
   
  -/**
  - * @author Rob Oxspring roxspring@apache.org
  - * @version $Revision$
  - */
   public class OptionsTest extends TestCase
   {
   
  -    public static Test suite() 
  -    { 
  -        return new TestSuite ( OptionsTest.class ); 
  -    }
  -
  -    public OptionsTest( String name )
  -    {
  -        super( name );
  -    }
  -
  -    public void setUp()
  -    {
  +    public static Test suite() { 
  +        return new TestSuite(OptionsTest.class); 
       }
   
  -    public void tearDown()
  +    public OptionsTest(String name)
       {
  +        super(name);
       }
       
  -    public void testHelpOptions(){
  +	public void testDuplicates() {
  +		OptionBuilder obuilder = new OptionBuilder();
  +		ArgumentBuilder abuilder = new ArgumentBuilder();
  +    	
  +		Options opts = new Options();
  +        
  +		opts.add( obuilder.withDescription("toggle -a")
  +					   .create("a", "a"));
  +
  +		opts.add(abuilder.withDescription("toggle -a*")
  +						   .create("a", "a"));
  +        
  +		assertEquals( "last one in wins", "toggle -a*", opts.getOption("-a").getDescription() );
  +		assertEquals( "last one in wins", "toggle -a*", opts.getOption("--a").getDescription() );
  +	}
  +	
  +	public void testHelpOptions(){
  +        OptionBuilder builder = new OptionBuilder();
  +        
  +		Option longOnly1 = builder
  +			.create(null, "long-only1");
           
  -        Option longOnly1 = OptionBuilder
  -            .withLongOpt("long-only1")
  -            .create();
  -        
  -        Option longOnly2 = OptionBuilder
  -            .withLongOpt("long-only2")
  -            .create();
  +		Option longOnly2 = builder
  +			.create(null, "long-only2");
                   
  -        Option shortOnly1 = OptionBuilder
  -            .create("1");
  +		Option shortOnly1 = builder
  +			.create("1");
                   
  -        Option shortOnly2 = OptionBuilder
  -            .create("2");
  +		Option shortOnly2 = builder
  +			.create("2");
                   
  -        Option bothA = OptionBuilder
  -            .withLongOpt("bothA")
  -            .create("a");
  +		Option bothA = builder
  +			.create("a", "bothA");
                   
  -        Option bothB = OptionBuilder
  -            .withLongOpt("bothB")
  -            .create("b");
  -        
  -        Options options = new Options();
  -        options.addOption(longOnly1);
  -        options.addOption(longOnly2);
  -        options.addOption(shortOnly1);
  -        options.addOption(shortOnly2);
  -        options.addOption(bothA);
  -        options.addOption(bothB);
  -        
  -        Collection allOptions = new ArrayList();
  -        allOptions.add(longOnly1);
  -        allOptions.add(longOnly2);
  -        allOptions.add(shortOnly1);
  -        allOptions.add(shortOnly2);
  -        allOptions.add(bothA);
  -        allOptions.add(bothB);
  -        
  -        Collection helpOptions = options.helpOptions();
  +		Option bothB = builder
  +			.create("b", "bothB");
           
  -        assertTrue("Everything in all should be in help",helpOptions.containsAll(allOptions));
  -        assertTrue("Everything in help should be in all",allOptions.containsAll(helpOptions));        
  -    }
  -
  +		Options options = new Options();
  +		options.add(longOnly1);
  +		options.add(longOnly2);
  +		options.add(shortOnly1);
  +		options.add(shortOnly2);
  +		options.add(bothA);
  +		options.add(bothB);
  +        
  +		Collection allOptions = new ArrayList();
  +		allOptions.add(longOnly1);
  +		allOptions.add(longOnly2);
  +		allOptions.add(shortOnly1);
  +		allOptions.add(shortOnly2);
  +		allOptions.add(bothA);
  +		allOptions.add(bothB);
  +        
  +		Collection helpOptions = options.getOptions();
  +        
  +		assertTrue("Everything in all should be in help",helpOptions.containsAll(allOptions));
  +		assertTrue("Everything in help should be in all",allOptions.containsAll(helpOptions));        
  +	}
   
   
   }
  -
  
  
  
  1.5.2.1   +35 -42    jakarta-commons/cli/src/test/org/apache/commons/cli/ParseRequiredTest.java
  
  Index: ParseRequiredTest.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/cli/src/test/org/apache/commons/cli/ParseRequiredTest.java,v
  retrieving revision 1.5
  retrieving revision 1.5.2.1
  diff -u -r1.5 -r1.5.2.1
  --- ParseRequiredTest.java	19 Sep 2002 22:59:44 -0000	1.5
  +++ ParseRequiredTest.java	19 May 2003 20:50:23 -0000	1.5.2.1
  @@ -22,7 +22,7 @@
   {
   
       private Options _options = null;
  -    private CommandLineParser parser = new PosixParser();
  +    private CommandLineParser parser = new CommandLineParser();
   
       public static Test suite() { 
           return new TestSuite(ParseRequiredTest.class); 
  @@ -35,16 +35,23 @@
   
       public void setUp()
       {
  -        _options = new Options()
  -            .addOption("a",
  -                       "enable-a",
  -                       false,
  -                       "turn [a] on or off")
  -            .addOption( OptionBuilder.withLongOpt( "bfile" )
  +        _options = new Options();
  +		OptionBuilder obuilder = new OptionBuilder();
  +		ArgumentBuilder abuilder = new ArgumentBuilder();
  +        
  +        _options.add( 
  +            obuilder.withDescription("turn [a] on or off")
  +               .create("a", "enable-a"));
  +               
  +        _options.add( abuilder.isRequired()
  +              .withDescription( "set the value of [b]" )
  +              .create("b", "bfile") );
  +        
  +        /*OptionBuilder.withLongOpt( "bfile" )
                                        .hasArg()
                                        .isRequired()
                                        .withDescription( "set the value of [b]" )
  -                                     .create( 'b' ) );
  +                                     .create( 'b' ) );*/
       }
   
       public void tearDown()
  @@ -52,45 +59,35 @@
   
       }
   
  -    public void testWithRequiredOption()
  +    public void testWithRequiredOption() throws Exception
       {
  -        String[] args = new String[] {  "-b", "file" };
  +		String[] args = new String[] { "-b", "file" };
   
  -        try
  -        {
  -            CommandLine cl = parser.parse(_options,args);
  -            
  -            assertTrue( "Confirm -a is NOT set", !cl.hasOption("a") );
  -            assertTrue( "Confirm -b is set", cl.hasOption("b") );
  -            assertTrue( "Confirm arg of -b", cl.getOptionValue("b").equals("file") );
  -            assertTrue( "Confirm NO of extra args", cl.getArgList().size() == 0);
  -        }
  -        catch (ParseException e)
  -        {
  -            fail( e.toString() );
  -        }
  +		CommandLine cl = parser.parse(_options, args);
  +
  +		assertTrue("Confirm -a is NOT set", !cl.hasOption("-a"));
  +		assertTrue("Confirm -b is set", cl.hasOption("-b"));
  +		assertTrue("Confirm arg of -b", cl.getValue("-b").equals("file"));
  +		assertTrue(
  +			"Confirm NO of anonymous values",
  +			cl.getAnonymousValues().size() == 0);
       }
   
  -    public void testOptionAndRequiredOption()
  +    public void testOptionAndRequiredOption() throws Exception
       {
           String[] args = new String[] {  "-a", "-b", "file" };
   
  -        try
  -        {
  -            CommandLine cl = parser.parse(_options,args);
  +		CommandLine cl = parser.parse(_options, args);
   
  -            assertTrue( "Confirm -a is set", cl.hasOption("a") );
  -            assertTrue( "Confirm -b is set", cl.hasOption("b") );
  -            assertTrue( "Confirm arg of -b", cl.getOptionValue("b").equals("file") );
  -            assertTrue( "Confirm NO of extra args", cl.getArgList().size() == 0);
  -        }
  -        catch (ParseException e)
  -        {
  -            fail( e.toString() );
  -        }
  +		assertTrue("Confirm -a is set", cl.hasOption("-a"));
  +		assertTrue("Confirm -b is set", cl.hasOption("-b"));
  +		assertTrue("Confirm arg of -b", cl.getValue("-b").equals("file"));
  +		assertTrue(
  +			"Confirm NO of anonymous values",
  +			cl.getAnonymousValues().size() == 0);
       }
   
  -    public void testMissingRequiredOption()
  +    public void testMissingRequiredOption() throws Exception
       {
           String[] args = new String[] { "-a" };
   
  @@ -99,12 +96,8 @@
               CommandLine cl = parser.parse(_options,args);
               fail( "exception should have been thrown" );
           }
  -        catch (ParseException e)
  +        catch (MissingOptionException e)
           {
  -            if( !( e instanceof MissingOptionException ) )
  -            {
  -                fail( "expected to catch MissingOptionException" );
  -            }
           }
       }
   
  
  
  
  1.6.2.1   +61 -146   jakarta-commons/cli/src/test/org/apache/commons/cli/ParseTest.java
  
  Index: ParseTest.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/cli/src/test/org/apache/commons/cli/ParseTest.java,v
  retrieving revision 1.6
  retrieving revision 1.6.2.1
  diff -u -r1.6 -r1.6.2.1
  --- ParseTest.java	14 Nov 2002 23:30:03 -0000	1.6
  +++ ParseTest.java	19 May 2003 20:50:23 -0000	1.6.2.1
  @@ -17,8 +17,8 @@
   public class ParseTest extends TestCase
   {
   
  -    private Options _options = null;
  -    private CommandLineParser _parser = null;
  +    private Options options = null;
  +    private CommandLineParser parser = null;
   
       public static Test suite() { 
           return new TestSuite(ParseTest.class); 
  @@ -31,21 +31,18 @@
   
       public void setUp()
       {
  -        _options = new Options()
  -            .addOption("a",
  -                       "enable-a",
  -                       false,
  -                       "turn [a] on or off")
  -            .addOption("b",
  -                       "bfile",
  -                       true,
  -                       "set the value of [b]")
  -            .addOption("c",
  -                       "copt",
  -                       false,
  -                       "turn [c] on or off");
  -
  -        _parser = new PosixParser();
  +		OptionBuilder obuilder = new OptionBuilder();
  +		ArgumentBuilder abuilder = new ArgumentBuilder();
  +    	
  +        options = new Options();
  +        options.add( obuilder.withDescription("turn [a] on or off")
  +             .create("a", "enable-a"));
  +        options.add( abuilder.withDescription("set the value of [b]")
  +		    .create("b","bfile"));
  +        options.add( obuilder.withDescription("turn [c] on or off")
  +            .create("c", "copt"));
  +		options.add( abuilder.createAnonymous("anon") );
  +	    parser = new CommandLineParser();
       }
   
       public void tearDown()
  @@ -53,121 +50,83 @@
   
       }
   
  -    public void testSimpleShort()
  +    public void testSimpleShort() throws Exception
       {
  -        String[] args = new String[] { "-a",
  -                                       "-b", "toast",
  -                                       "foo", "bar" };
  +		String[] args = new String[] { "-a", "-b", "toast", "foo", "bar" };
   
  -        try
  -        {
  -            CommandLine cl = _parser.parse(_options, args);
  -            
  -            assertTrue( "Confirm -a is set", cl.hasOption("a") );
  -            assertTrue( "Confirm -b is set", cl.hasOption("b") );
  -            assertTrue( "Confirm arg of -b", cl.getOptionValue("b").equals("toast") );
  -            assertTrue( "Confirm size of extra args", cl.getArgList().size() == 2);
  -        }
  -        catch (ParseException e)
  -        {
  -            fail( e.toString() );
  -        }
  +		CommandLine cl = parser.parse(options, args);
  +
  +		assertTrue("Confirm -a is set", cl.hasOption("-a"));
  +		assertTrue("Confirm -b is set", cl.hasOption("-b"));
  +		assertTrue("Confirm arg of -b", cl.getValue("-b").equals("toast"));
  +		assertTrue(
  +			"Confirm size of extra args",
  +			cl.getAnonymousValues().size() == 2);
       }
   
  -    public void testSimpleLong()
  +    public void testSimpleLong() throws Exception
       {
  -        String[] args = new String[] { "--enable-a",
  -                                       "--bfile", "toast",
  -                                       "foo", "bar" };
  +		String[] args =
  +			new String[] { "--enable-a", "--bfile", "toast", "foo", "bar" };
   
  -        try
  -        {
  -            CommandLine cl = _parser.parse(_options, args);
  -            
  -            assertTrue( "Confirm -a is set", cl.hasOption("a") );
  -            assertTrue( "Confirm -b is set", cl.hasOption("b") );
  -            assertTrue( "Confirm arg of -b", cl.getOptionValue("b").equals("toast") );
  -            assertTrue( "Confirm arg of --bfile", cl.getOptionValue( "bfile" ).equals( "toast" ) );
  -            assertTrue( "Confirm size of extra args", cl.getArgList().size() == 2);
  -        } 
  -        catch (ParseException e)
  -        {
  -            fail( e.toString() );
  -        }
  +		CommandLine cl = parser.parse(options, args);
  +
  +		assertTrue("Confirm -a is set", cl.hasOption("-a"));
  +		assertTrue("Confirm -b is set", cl.hasOption("-b"));
  +		assertTrue("Confirm arg of -b", cl.getValue("-b").equals("toast"));
  +		assertTrue(
  +			"Confirm arg of --bfile",
  +			cl.getValue("--bfile").equals("toast"));
  +		assertTrue("Confirm size of extra args", cl.getAnonymousValues().size() == 2);
       }
   
  -    public void testComplexShort()
  +    public void testComplexShort() throws Exception
       {
  -        String[] args = new String[] { "-acbtoast",
  -                                       "foo", "bar" };
  +		String[] args = new String[] { "-acbtoast", "foo", "bar" };
   
  -        try
  -        {
  -            CommandLine cl = _parser.parse(_options, args);
  -            
  -            assertTrue( "Confirm -a is set", cl.hasOption("a") );
  -            assertTrue( "Confirm -b is set", cl.hasOption("b") );
  -            assertTrue( "Confirm -c is set", cl.hasOption("c") );
  -            assertTrue( "Confirm arg of -b", cl.getOptionValue("b").equals("toast") );
  -            assertTrue( "Confirm size of extra args", cl.getArgList().size() == 2);
  -        }
  -        catch (ParseException e)
  -        {
  -            fail( e.toString() );
  -        }
  +		CommandLine cl = parser.parse(options, args);
  +
  +		assertTrue("Confirm -a is set", cl.hasOption("-a"));
  +		assertTrue("Confirm -b is set", cl.hasOption("-b"));
  +		assertTrue("Confirm -c is set", cl.hasOption("-c"));
  +		assertTrue("Confirm arg of -b", cl.getValue("-b").equals("toast"));
  +		assertTrue("Confirm size of extra args", cl.getAnonymousValues().size() == 2);
       }
   
  -    public void testExtraOption()
  +    public void testExtraOption() throws Exception
       {
           String[] args = new String[] { "-adbtoast",
                                          "foo", "bar" };
   
  -        boolean caught = false;
  -
           try
           {
  -            CommandLine cl = _parser.parse(_options, args);
  +            CommandLine cl = parser.parse(options, args);
               
  -            assertTrue( "Confirm -a is set", cl.hasOption("a") );
  -            assertTrue( "Confirm -b is set", cl.hasOption("b") );
  -            assertTrue( "confirm arg of -b", cl.getOptionValue("b").equals("toast") );
  -            assertTrue( "Confirm size of extra args", cl.getArgList().size() == 3);
  -        }
  -        catch (UnrecognizedOptionException e)
  -        {
  -            caught = true;
  +            assertTrue( "Confirm -a is set", cl.hasOption("-a") );
  +            assertTrue( "Confirm -b is set", cl.hasOption("-b") );
  +            assertTrue( "confirm arg of -b", cl.getValue("-b").equals("toast") );
  +            assertTrue( "Confirm size of extra args", cl.getAnonymousValues().size() == 3);
           }
  -        catch (ParseException e)
  +        catch (UnknownOptionException e)
           {
  -            fail( e.toString() );
           }
  -        assertTrue( "Confirm UnrecognizedOptionException caught", caught );
       }
   
  -    public void testMissingArg()
  +    public void testMissingArg() throws Exception
       {
   
           String[] args = new String[] { "-acb" };
   
  -        boolean caught = false;
  -
           try
           {
  -            CommandLine cl = _parser.parse(_options, args);
  -        }
  -        catch (MissingArgumentException e)
  -        {
  -            caught = true;
  +            CommandLine cl = parser.parse(options, args);
           }
  -        catch (ParseException e)
  +        catch (MissingValueException e)
           {
  -            fail( e.toString() );
           }
  -
  -        assertTrue( "Confirm MissingArgumentException caught", caught );
       }
   
  -    public void testStop()
  +    /*public void testStop()
       {
           String[] args = new String[] { "-c",
                                          "foober",
  @@ -183,9 +142,9 @@
           {
               fail( e.toString() );
           }
  -    }
  +    }*/
   
  -    public void testMultiple()
  +    /*public void testMultiple()
       {
           String[] args = new String[] { "-c",
                                          "foobar",
  @@ -209,9 +168,9 @@
           {
               fail( e.toString() );
           }
  -    }
  +    }*/
   
  -    public void testMultipleWithLong()
  +    /*public void testMultipleWithLong() throws Exception
       {
           String[] args = new String[] { "--copt",
                                          "foobar",
  @@ -236,50 +195,6 @@
           {
               fail( e.toString() );
           }
  -    }
  -
  -    public void testDoubleDash()
  -    {
  -        String[] args = new String[] { "--copt",
  -                                       "--",
  -                                       "-b", "toast" };
  -
  -        try
  -        {
  -            CommandLine cl = _parser.parse(_options, args);
  -
  -            assertTrue( "Confirm -c is set", cl.hasOption("c") );
  -            assertTrue( "Confirm -b is not set", ! cl.hasOption("b") );
  -            assertTrue( "Confirm 2 extra args: " + cl.getArgList().size(), cl.getArgList().size() == 2);
  -
  -        }
  -        catch (ParseException e)
  -        {
  -            fail( e.toString() );
  -        }
  -    }
  -
  -    public void testSingleDash()
  -    {
  -        String[] args = new String[] { "--copt",
  -                                       "-b", "-",
  -                                       "-a",
  -                                       "-" };
  +    }*/
   
  -        try
  -        {
  -            CommandLine cl = _parser.parse(_options, args);
  -
  -            assertTrue( "Confirm -a is set", cl.hasOption("a") );
  -            assertTrue( "Confirm -b is set", cl.hasOption("b") );
  -            assertTrue( "Confirm arg of -b", cl.getOptionValue("b").equals("-") );
  -            assertTrue( "Confirm 1 extra arg: " + cl.getArgList().size(), cl.getArgList().size() == 1);
  -            assertTrue( "Confirm value of extra arg: " + cl.getArgList().get(0), cl.getArgList().get(0).equals("-") );
  -        }
  -        catch (ParseException e)
  -        {
  -            fail( e.toString() );
  -        }
  -        
  -    }
   }
  
  
  
  1.7.2.1   +155 -112  jakarta-commons/cli/src/test/org/apache/commons/cli/ValueTest.java
  
  Index: ValueTest.java
  ===================================================================
  RCS file: /home/cvs/jakarta-commons/cli/src/test/org/apache/commons/cli/ValueTest.java,v
  retrieving revision 1.7
  retrieving revision 1.7.2.1
  diff -u -r1.7 -r1.7.2.1
  --- ValueTest.java	27 Nov 2002 23:24:38 -0000	1.7
  +++ ValueTest.java	19 May 2003 20:50:23 -0000	1.7.2.1
  @@ -14,9 +14,6 @@
   import junit.framework.TestCase;
   import junit.framework.TestSuite;
   
  -import java.util.Arrays;
  -import java.util.Properties;
  -
   public class ValueTest extends TestCase
   {
   
  @@ -33,65 +30,111 @@
           super(name);
       }
   
  -    public void setUp()
  +    public void setUp() throws Exception
       {
  -        opts.addOption("a",
  -                       false,
  -                       "toggle -a");
  -
  -        opts.addOption("b",
  -                       true,
  -                       "set -b");
  -
  -        opts.addOption("c",
  -                       "c",
  -                       false,
  -                       "toggle -c");
  -
  -        opts.addOption("d",
  -                       "d",
  -                       true,
  -                       "set -d");
  -
  -        opts.addOption( OptionBuilder.hasOptionalArg()
  -                        .create( 'e') );
  -
  -        opts.addOption( OptionBuilder.hasOptionalArg()
  -                        .withLongOpt( "fish" )
  -                        .create( ) );
  +    	OptionBuilder obuilder = new OptionBuilder();
  +    	ArgumentBuilder abuilder = new ArgumentBuilder();
  +    	
  +    	Option a = obuilder.withDescription("toggle -a")
  +    	    .create("a");
  +    	opts.add(a);   
  +        //opts.addOption("a",
  +        //               false,
  +        //               "toggle -a");
  +
  +		Argument b = abuilder.withDescription("set -b")
  +		    .create("b");
  +		opts.add(b);   
  +		    
  +        //opts.addOption("b",
  +        //               true,
  +        //               "set -b");
  +
  +        Option c = obuilder.withDescription("toggle -c")
  +            .create("c", "c");
  +		opts.add(c);   
  +            
  +        //opts.addOption("c",
  +        //               "c",
  +        //               false,
  +        //               "toggle -c");
  +
  +		Argument d = abuilder.withDescription("set -d")
  +			.create("d", "d");
  +		opts.add(d);   
  +			
  +        //opts.addOption("d",
  +        //               "d",
  +        //               true,
  +        //               "set -d");
  +
  +		Argument e = abuilder.hasOptionalValues()
  +			.create("e");
  +		opts.add(e);   
  +
  +        //opts.addOption( OptionBuilder.hasOptionalArg()
  +        //                .create( 'e') );
  +
  +		Argument fish = abuilder.hasOptionalValues()
  +			.create(null, "fish");
  +		opts.add(fish);   
  +			
  +        //opts.addOption( OptionBuilder.hasOptionalArg()
  +        //                .withLongOpt( "fish" )
  +        //                .create( ) );
  +
  +		Argument gravy = abuilder.hasOptionalValues()
  +		    .withSize(100)
  +			.create(null, "gravy");
  +		opts.add(gravy);   
  +
  +        //opts.addOption( OptionBuilder.hasOptionalArgs()
  +        //                .withLongOpt( "gravy" )
  +        //                .create( ) );
  +
  +		Argument hide = abuilder.hasOptionalValues()
  +		    .withSize(2)
  +			.create(null, "hide");
  +		opts.add(hide);   
  +
  +        //opts.addOption( OptionBuilder.hasOptionalArgs( 2 )
  +        //                .withLongOpt( "hide" )
  +        //                .create( ) );
  +
  +		Argument i = abuilder.hasOptionalValues()
  +		    .withSize(2)
  +			.create("i");
  +		opts.add(i);   
  +
  +        //opts.addOption( OptionBuilder.hasOptionalArgs( 2 )
  +        //                .create( 'i' ) );
  +
  +		Argument j = abuilder.hasOptionalValues()
  +		    .withSize(2)
  +			.create("j");
  +		opts.add(j);   
  +			
  +        //opts.addOption( OptionBuilder.hasOptionalArgs( )
  +        //                .create( 'j' ) );
  +
  +		Argument k = abuilder.hasOptionalValues()
  +		    .withValueSeparator(',')
  +			.create("k");
  +		opts.add(k);   
   
  -        opts.addOption( OptionBuilder.hasOptionalArgs()
  -                        .withLongOpt( "gravy" )
  -                        .create( ) );
  -
  -        opts.addOption( OptionBuilder.hasOptionalArgs( 2 )
  -                        .withLongOpt( "hide" )
  -                        .create( ) );
  -
  -        opts.addOption( OptionBuilder.hasOptionalArgs( 2 )
  -                        .create( 'i' ) );
  -
  -        opts.addOption( OptionBuilder.hasOptionalArgs( )
  -                        .create( 'j' ) );
  -
  -        opts.addOption( OptionBuilder.hasArgs( ).withValueSeparator( ',' )
  -                        .create( 'k' ) );
  +        //opts.addOption( OptionBuilder.hasArgs( ).withValueSeparator( ',' )
  +        //                .create( 'k' ) );
   
  +		opts.add( abuilder.createAnonymous("anon") );
  +		
           String[] args = new String[] { "-a",
               "-b", "foo",
               "--c",
               "--d", "bar" 
           };
   
  -        try
  -        {
  -            CommandLineParser parser = new PosixParser();
  -            _cl = parser.parse(opts,args);
  -        }
  -        catch (ParseException e)
  -        {
  -            fail("Cannot setUp() CommandLine: " + e.toString());
  -        }
  +        CommandLineParser parser = new CommandLineParser();
  +        _cl = parser.parse(opts,args);
       }
   
       public void tearDown()
  @@ -101,28 +144,28 @@
   
       public void testShortNoArg()
       {
  -        assertTrue( _cl.hasOption("a") );
  -        assertNull( _cl.getOptionValue("a") );
  +        assertTrue( _cl.hasOption("-a") );
  +        assertNull( _cl.getValue("-a") );
       }
   
       public void testShortWithArg()
       {
  -        assertTrue( _cl.hasOption("b") );
  -        assertNotNull( _cl.getOptionValue("b") );
  -        assertEquals( _cl.getOptionValue("b"), "foo");
  +        assertTrue( _cl.hasOption("-b") );
  +        assertNotNull( _cl.getValue("-b") );
  +        assertEquals( _cl.getValue("-b"), "foo");
       }
   
       public void testLongNoArg()
       {
  -        assertTrue( _cl.hasOption("c") );
  -        assertNull( _cl.getOptionValue("c") );
  +        assertTrue( _cl.hasOption("-c") );
  +        assertNull( _cl.getValue("-c") );
       }
   
       public void testLongWithArg()
       {
  -        assertTrue( _cl.hasOption("d") );
  -        assertNotNull( _cl.getOptionValue("d") );
  -        assertEquals( _cl.getOptionValue("d"), "bar");
  +        assertTrue( _cl.hasOption("-d") );
  +        assertNotNull( _cl.getValue("-d") );
  +        assertEquals( _cl.getValue("-d"), "bar");
       }
   
       public void testShortOptionalArgNoValue()
  @@ -131,10 +174,10 @@
           };
           try
           {
  -            CommandLineParser parser = new PosixParser();
  +            CommandLineParser parser = new CommandLineParser();
               CommandLine cmd = parser.parse(opts,args);
  -            assertTrue( cmd.hasOption("e") );
  -            assertNull( cmd.getOptionValue("e") );
  +            assertTrue( cmd.hasOption("-e") );
  +            assertNull( cmd.getValue("-e") );
           }
           catch (ParseException e)
           {
  @@ -148,10 +191,10 @@
           };
           try
           {
  -            CommandLineParser parser = new PosixParser();
  +            CommandLineParser parser = new CommandLineParser();
               CommandLine cmd = parser.parse(opts,args);
  -            assertTrue( cmd.hasOption("e") );
  -            assertEquals( "everything", cmd.getOptionValue("e") );
  +            assertTrue( cmd.hasOption("-e") );
  +            assertEquals( "everything", cmd.getValue("-e") );
           }
           catch (ParseException e)
           {
  @@ -165,10 +208,10 @@
           };
           try
           {
  -            CommandLineParser parser = new PosixParser();
  +            CommandLineParser parser = new CommandLineParser();
               CommandLine cmd = parser.parse(opts,args);
  -            assertTrue( cmd.hasOption("fish") );
  -            assertNull( cmd.getOptionValue("fish") );
  +            assertTrue( cmd.hasOption("--fish") );
  +            assertNull( cmd.getValue("--fish") );
           }
           catch (ParseException e)
           {
  @@ -182,10 +225,10 @@
           };
           try
           {
  -            CommandLineParser parser = new PosixParser();
  +            CommandLineParser parser = new CommandLineParser();
               CommandLine cmd = parser.parse(opts,args);
  -            assertTrue( cmd.hasOption("fish") );
  -            assertEquals( "face", cmd.getOptionValue("fish") );
  +            assertTrue( cmd.hasOption("--fish") );
  +            assertEquals( "face", cmd.getValue("--fish") );
           }
           catch (ParseException e)
           {
  @@ -199,13 +242,13 @@
           };
           try
           {
  -            CommandLineParser parser = new PosixParser();
  +            CommandLineParser parser = new CommandLineParser();
               CommandLine cmd = parser.parse(opts,args);
  -            assertTrue( cmd.hasOption("j") );
  -            assertEquals( "ink", cmd.getOptionValue("j") );
  -            assertEquals( "ink", cmd.getOptionValues("j")[0] );
  -            assertEquals( "idea", cmd.getOptionValues("j")[1] );
  -            assertEquals( cmd.getArgs().length, 0 );
  +            assertTrue( cmd.hasOption("-j") );
  +            assertEquals( "ink", cmd.getValue("-j") );
  +            assertEquals( "ink", cmd.getValues("-j").get(0) );
  +            assertEquals( "idea", cmd.getValues("-j").get(1) );
  +            assertEquals( cmd.getAnonymousValues().size(), 0 );
           }
           catch (ParseException e)
           {
  @@ -219,13 +262,13 @@
           };
           try
           {
  -            CommandLineParser parser = new PosixParser();
  +            CommandLineParser parser = new CommandLineParser();
               CommandLine cmd = parser.parse(opts,args);
  -            assertTrue( cmd.hasOption("gravy") );
  -            assertEquals( "gold", cmd.getOptionValue("gravy") );
  -            assertEquals( "gold", cmd.getOptionValues("gravy")[0] );
  -            assertEquals( "garden", cmd.getOptionValues("gravy")[1] );
  -            assertEquals( cmd.getArgs().length, 0 );
  +            assertTrue( cmd.hasOption("--gravy") );
  +            assertEquals( "gold", cmd.getValue("--gravy") );
  +            assertEquals( "gold", cmd.getValues("--gravy").get(0) );
  +            assertEquals( "garden", cmd.getValues("--gravy").get(1) );
  +            assertEquals( cmd.getAnonymousValues().size(), 0 );
           }
           catch (ParseException e)
           {
  @@ -239,15 +282,15 @@
           };
           try
           {
  -            CommandLineParser parser = new PosixParser();
  +            CommandLineParser parser = new CommandLineParser();
               CommandLine cmd = parser.parse(opts,args);
  -            assertTrue( cmd.hasOption("i") );
  -            assertEquals( "ink", cmd.getOptionValue("i") );
  -            assertEquals( "ink", cmd.getOptionValues("i")[0] );
  -            assertEquals( "idea", cmd.getOptionValues("i")[1] );
  -            assertEquals( cmd.getArgs().length, 2 );
  -            assertEquals( "isotope", cmd.getArgs()[0] );
  -            assertEquals( "ice", cmd.getArgs()[1] );
  +            assertTrue( cmd.hasOption("-i") );
  +            assertEquals( "ink", cmd.getValue("-i") );
  +            assertEquals( "ink", cmd.getValues("-i").get(0) );
  +            assertEquals( "idea", cmd.getValues("-i").get(1) );
  +            assertEquals( cmd.getAnonymousValues().size(), 2 );
  +            assertEquals( "isotope", cmd.getAnonymousValues().get(0) );
  +            assertEquals( "ice", cmd.getAnonymousValues().get(1) );
           }
           catch (ParseException e)
           {
  @@ -261,36 +304,36 @@
               "--hide", "house", "hair", "head"
           };
   
  -        CommandLineParser parser = new PosixParser();
  +        CommandLineParser parser = new CommandLineParser();
   
           try
           {
               CommandLine cmd = parser.parse(opts,args);
  -            assertTrue( cmd.hasOption("hide") );
  -            assertEquals( "house", cmd.getOptionValue("hide") );
  -            assertEquals( "house", cmd.getOptionValues("hide")[0] );
  -            assertEquals( "hair", cmd.getOptionValues("hide")[1] );
  -            assertEquals( cmd.getArgs().length, 1 );
  -            assertEquals( "head", cmd.getArgs()[0] );
  +            assertTrue( cmd.hasOption("--hide") );
  +            assertEquals( "house", cmd.getValue("--hide") );
  +            assertEquals( "house", cmd.getValues("--hide").get(0) );
  +            assertEquals( "hair", cmd.getValues("--hide").get(1) );
  +            assertEquals( cmd.getAnonymousValues().size(), 1 );
  +            assertEquals( "head", cmd.getAnonymousValues().get(0) );
           }
           catch (ParseException e)
           {
               fail("Cannot setUp() CommandLine: " + e.toString());
           }
       }
  -
  +    /*
       public void testPropertyOptionSingularValue()
       {
           Properties properties = new Properties();
           properties.setProperty( "hide", "seek" );
   
  -        CommandLineParser parser = new PosixParser();
  +        CommandLineParser parser = new CommandLineParser();
           
           try
           {
               CommandLine cmd = parser.parse(opts, null, properties);
               assertTrue( cmd.hasOption("hide") );
  -            assertEquals( "seek", cmd.getOptionValue("hide") );
  +            assertEquals( "seek", cmd.getValue("hide") );
               assertTrue( !cmd.hasOption("fake") );
           }
           catch (ParseException e)
  @@ -306,7 +349,7 @@
           properties.setProperty( "c", "yes" );
           properties.setProperty( "e", "1" );
   
  -        CommandLineParser parser = new PosixParser();
  +        CommandLineParser parser = new CommandLineParser();
           
           try
           {
  @@ -374,7 +417,7 @@
           Properties properties = new Properties();
           properties.setProperty( "k", "one,two" );
   
  -        CommandLineParser parser = new PosixParser();
  +        CommandLineParser parser = new CommandLineParser();
           
           String[] values = new String[] {
               "one", "two"
  @@ -383,7 +426,7 @@
           {
               CommandLine cmd = parser.parse(opts, null, properties);
               assertTrue( cmd.hasOption("k") );
  -            assertTrue( Arrays.equals( values, cmd.getOptionValues('k') ) );
  +            assertTrue( Arrays.equals( values, cmd.getValues('k') ) );
           }
           catch (ParseException e)
           {
  @@ -404,12 +447,12 @@
           properties.setProperty( "j", "seek" );
           try
           {
  -            CommandLineParser parser = new PosixParser();
  +            CommandLineParser parser = new CommandLineParser();
               CommandLine cmd = parser.parse(opts, args, properties);
               assertTrue( cmd.hasOption("j") );
  -            assertEquals( "found", cmd.getOptionValue("j") );
  +            assertEquals( "found", cmd.getValue("j") );
               assertTrue( cmd.hasOption("i") );
  -            assertEquals( "ink", cmd.getOptionValue("i") );
  +            assertEquals( "ink", cmd.getValue("i") );
               assertTrue( !cmd.hasOption("fake") );
           }
           catch (ParseException e)
  @@ -417,5 +460,5 @@
               fail("Cannot setUp() CommandLine: " + e.toString());
           }
       }
  -
  +    */
   }
  
  
  

---------------------------------------------------------------------
To unsubscribe, e-mail: commons-dev-unsubscribe@jakarta.apache.org
For additional commands, e-mail: commons-dev-help@jakarta.apache.org


Mime
View raw message