pax_global_header00006660000000000000000000000064125121053240014505gustar00rootroot0000000000000052 comment=14fbe2bc5a2c402b456ed68578a5d5dc2c343fa2 jcommander-jcommander-1.48/000077500000000000000000000000001251210532400156755ustar00rootroot00000000000000jcommander-jcommander-1.48/.gitignore000066400000000000000000000001331251210532400176620ustar00rootroot00000000000000target .classpath .project .settings test-output src/test/java/com/beust/jcommander/ignore jcommander-jcommander-1.48/CHANGELOG000066400000000000000000000120731251210532400171120ustar00rootroot00000000000000Current 1.30 2012/10/27 Added: JCommander#acceptUnknownOption and JCommander#getUnknownArgs Added: JCommander#allowAbbreviatedOptions (default: false) Added: JCommander#setCaseSensitiveOptions (default: true) Added: Support for enums (Scott M Stark) Fixed: Missing new lines in usage (styurin) Fixed: The description of commands is now displayed on the next line and indented. 1.29 2012/07/28 Fixed: Empty string defaults now displayed as "" in the usage Fixed: Bugs with the PositiveInteger validator Fixed: Parameters with a single double quote were not working properly 1.27 2012/07/05 Added: IValueValidator to validate parameter values (typed) as opposed to IParameterValidator which validates strings Added: echoInput, used when password=true to echo the characters (Jason Wheeler) Added: @Parameter(help = true) Fixed: wasn't handling parameters that start with " but don't end with one correctly Fixed: if using a different option prefix, unknown option are mistakenly reported as "no main parameter defined" (kurmasz) Fixed: 113: getCommandDescription() returns the description of the main parameter instead of that of the command Fixed: bug with several multiple arity parameters (VariableArityTest) Fixed: variable arities not working when same parameter appears multiple times. 1.25 2012/04/26 Added: Default passwords are no longer displayed in the usage (Paul Mendelson) Added: Variable arities now work magically, no need for IVariableArity any more Fixed: Commands using @Parameters(resourceBundle) were not i18n'ed properly in the usage() Fixed: StringIndexOutOfBoundsException if passing an empty parameter (bomanz) Fixed: GITHUB-105: If no description is given for an enum, use that enum's value (Adrian Muraru) Fixed: GITHUB-108: Dynamic parameters with "=" in them are not parsed correctly (szhem) Fixed: Commands with same prefix as options were not working properly. Fixed: GITHUB-97: Required password always complains that it is not specified (timoteoponce) 1.23 2012/01/12 Added: @DynamicParameter Fixed: Use JDK 6 Console() when available to improve support of non ascii chars (Julien Henry) 1.20 2011/11/24 Added: Support for delegating parameter definitions to child classes (rodionmoiseev) Added: @Parameter(commandNames) so that command names can be specified with annotations Added: Support for enums (Adrian Muraru) Fixed: Throw if an unknown option is found Fixed: Main parameters are now validated as well (Connor Mullen) 1.19 2011/10/10 Added: commandDescriptionKey to @Parameters, to allow internationalized command descriptions Added: JCommander#setParameterDescriptionComparator for better control over usage() Fixed: Fields of type Set (HashSet and SortedSet) are now supported Fixed: defaults for commands were not properly applied (Stevo Slavic) Fixed: "-args=a=b,b=c" was not being parsed correctly (Michael Lancaster) Fixed: GITHUB-73: descriptionKey was being ignored on main parameters 1.18 2011/07/20 Added: Default converter factories can be overridden (Scott Clasen) Added: IParameterValidator Added: Don't display "Options:" if none were defined Added: Enforce that the type of the main parameter is a List Added: usage() now displays the options for each command as well Fixed: Default values with a validator were being validate at parse() time instead of creation time. Fixed: Exception when using an @ file with empty lines between options Fixed: OOM when parsing certain descriptions with long URL's in them 1.15 2011/01/24 Added: Added a constructor that takes a Bundle only, https://github.com/cbeust/jcommander/pull/47 (Russell Egan) Fixed: NPE with calling getCommandDescription() of an unknown command 1.13 2010/12/15 Added: Boolean parameters with arity 0 (e.g. "foo -debug") Fixed: JCommander would sometimes just print a stack trace and continue, now rethrowing. 1.7 2010/09/06 Added: Command usages are now shown in the order they were added to the JCommander object Fixed: JCommander now compatible with Java 5 Fixed: Minor bug in the command display (Marc Ende) 1.6 2010/08/28 Added: @Parameters(commandDescription = "command description") Added: now throwing an exception if required main parameters are not supplied Fixed: usage() was changing default values after two runs (jstrachan) 1.5 2010/08/15 Added: overloaded versions of usage() with StringBuilders Added: inheritance support (Guillaume Sauthier) Added: support for commands (e.g. "main add --author=cbeust Foo.java") Added: support for converters for main parameters (e.g. List). 1.4 2010/07/28 Added: string converter factories Added: IDefaultProvider Added: PropertyFileDefaultProvider Added: Usage is now showing required parameters and default value Added: Support for values that look like parameters ("-integer -3", "/file /tmp/a") Added: @Parameters(optionPrefixes) to allow for different prefixes than "-" 1.2 2010/07/25 Usage is now aligned and alphabetically sorted Added the hidden attribute Added support for different separators than " " (e.g. "="). Deprecated @ResourceBundle, replaced with @Parameters 1.1 2010/08/15 Better internationalization Password support Type converters jcommander-jcommander-1.48/README.markdown000066400000000000000000000024161251210532400204010ustar00rootroot00000000000000JCommander ========== This is an annotation based parameter parsing framework for Java. Here is a quick example: ```java public class JCommanderTest { @Parameter public List parameters = Lists.newArrayList(); @Parameter(names = { "-log", "-verbose" }, description = "Level of verbosity") public Integer verbose = 1; @Parameter(names = "-groups", description = "Comma-separated list of group names to be run") public String groups; @Parameter(names = "-debug", description = "Debug mode") public boolean debug = false; @DynamicParameter(names = "-D", description = "Dynamic parameters go here") public Map dynamicParams = new HashMap(); } ``` and how you use it: ```java JCommanderTest jct = new JCommanderTest(); String[] argv = { "-log", "2", "-groups", "unit1,unit2,unit3", "-debug", "-Doption=value", "a", "b", "c" }; new JCommander(jct, argv); Assert.assertEquals(2, jct.verbose.intValue()); Assert.assertEquals("unit1,unit2,unit3", jct.groups); Assert.assertEquals(true, jct.debug); Assert.assertEquals("value", jct.dynamicParams.get("option")); Assert.assertEquals(Arrays.asList("a", "b", "c"), jct.parameters); ``` The full doc is available at http://beust.com/jcommander jcommander-jcommander-1.48/build-with-maven000077500000000000000000000013561251210532400210040ustar00rootroot00000000000000mvn -B clean source:jar javadoc:jar repository:bundle-create -P sign #v=6.5.2beta export TESTNG=`echo ../testng/target/testng-6.8.13.jar` run="java -classpath \"target/classes;target/test-classes;${TESTNG};$CLASSPATH\" org.testng.TestNG src/test/resources/testng.xml" echo "Launching tests: ${run}" $run #java -classpath target/classes:target/test-classes:${TESTNG}:$CLASSPATH org.testng.TestNG src/test/resources/testng.xml echo "To deploy to the snapshot repository: mvn deploy" echo "To deploy to the release directory: mvn -DskipTests=true release:clean release:prepare release:perform" echo "Nexus UI: https://oss.sonatype.org/index.html" echo "Wiki: https://docs.sonatype.org/display/Repository/Sonatype+OSS+Maven+Repository+Usage+Guide" jcommander-jcommander-1.48/doc/000077500000000000000000000000001251210532400164425ustar00rootroot00000000000000jcommander-jcommander-1.48/doc/index.html000066400000000000000000000714651251210532400204540ustar00rootroot00000000000000 JCommander

JCommander

Because life is too short to parse command line parameters
Created: July 13th, 2010
Last updated: January 14th, 2015
Cédric Beust

Table of contents

Overview

JCommander is a very small Java framework that makes it trivial to parse command line parameters.

You annotate fields with descriptions of your options: 

import com.beust.jcommander.Parameter;

public class JCommanderExample {
  @Parameter
  private List<String> parameters = new ArrayList<String>();

  @Parameter(names = { "-log", "-verbose" }, description = "Level of verbosity")
  private Integer verbose = 1;

  @Parameter(names = "-groups", description = "Comma-separated list of group names to be run")
  private String groups;

  @Parameter(names = "-debug", description = "Debug mode")
  private boolean debug = false;
}
and then you simply ask JCommander to parse: 
JCommanderExample jct = new JCommanderExample();
String[] argv = { "-log", "2", "-groups", "unit" };
new JCommander(jct, argv);

Assert.assertEquals(jct.verbose.intValue(), 2);

Types of options

The fields representing your parameters can be of any type. Basic types (Integer, Boolean., etc...) are supported by default and you can write type converters to support any other type (File, etc...).

Boolean

When a Parameter annotation is found on a field of type boolean or Boolean, JCommander interprets it as an option with an arity of 0: 
@Parameter(names = "-debug", description = "Debug mode")
private boolean debug = false;
Such a parameter does not require any additional parameter on the command line and if it's detected during parsing, the corresponding field will be set to true.

If you want to define a boolean parameter that's true by default, you can declare it as having an arity of 1. Users will then have to specify the value they want explicitly: 

    @Parameter(names = "-debug", description = "Debug mode", arity = 1)
    private boolean debug = true;
Invoke with either of: 
    program -debug true
    program -debug false

String, Integer, Long

When a Parameter annotation is found on a field of type String, Integer, int, Long or long, JCommander will parse the following parameter and it will attempt to cast it to the right type: 
@Parameter(names = "-log", description = "Level of verbosity")
private Integer verbose = 1;

java Main -log 3
will cause the field verbose to receive the value 3, however: 
java Main -log test
will cause an exception to be thrown.

Lists

When a Parameter annotation is found on a field of type List, JCommander will interpret it as an option that can occur multiple times: 
@Parameter(names = "-host", description = "The host")
private List<String> hosts = new ArrayList<String>();
will allow you to parse the following command line: 
java Main -host host1 -verbose -host host2
When JCommander is done parsing the line above, the field hosts will contain the strings "host1" and "host2".

Password

If one of your parameters is a password or some other value that you do not wish to appear in your history or in clear, you can declare it of type password and JCommander will then ask you to enter it in the console: 
public class ArgsPassword {
  @Parameter(names = "-password", description = "Connection password", password = true)
  private String password;
}
When you run your program, you will get the following prompt: 
Value for -password (Connection password):
You will need to type the value at this point before JCommander resumes.

Echo Input

In Java 6, by default, you will not be able to see what you type for passwords entered at the prompt (Java 5 and lower will always show the password). However, you can override this by setting echoInput to "true" (default is "false" and this setting only has an effect when password is "true"): 
public class ArgsPassword {
  @Parameter(names = "-password", description = "Connection password", password = true, echoInput = true)
  private String password;
}

Custom types

By annotation

By default, JCommander parses the command line into basic types only (strings, booleans, integers and longs). Very often, your application actually needs more complex types, such as files, host names, lists, etc... To achieve this, you can write a type converter by implementing the following interface: 
public interface IStringConverter<T> {
  T convert(String value);
}
For example, here is a converter that turns a string into a File: 
public class FileConverter implements IStringConverter<File> {
  @Override
  public File convert(String value) {
    return new File(value);
  }
}
Then, all you need to do is declare your field with the correct type and specify the converter as an attribute: 
@Parameter(names = "-file", converter = FileConverter.class)
File file;
JCommander ships with a few common converters (e.g. one that turns a comma separated list into a List<String>).

By factory

If the custom types you use appear multiple times in your application, having to specify the converter in each annotation can become tedious. To address this, you can use an IStringConverterFactory: 
public interface IStringConverterFactory {
  <T> Class<? extends IStringConverter<T>> getConverter(Class<T> forType);
}
For example, suppose you need to parse a string representing a host and a port: 
java App -target example.com:8080
You define the holder class : 
public class HostPort {
  private String host;
  private Integer port;
}
and the string converter to create instances of this class: 
class HostPortConverter implements IStringConverter<HostPort> {
  @Override
  public HostPort convert(String value) {
    HostPort result = new HostPort();
    String[] s = value.split(":");
    result.host = s[0];
    result.port = Integer.parseInt(s[1]);

    return result;
  }
}
The factory is straightforward: 
public class Factory implements IStringConverterFactory {
  public Class<? extends IStringConverter<?>> getConverter(Class forType) {
    if (forType.equals(HostPort.class)) return HostPortConverter.class;
    else return null;
  }
You can now use the type HostPort as a parameter without any converterClass attribute: 
public class ArgsConverterFactory {
  @Parameter(names = "-hostport")
  private HostPort hostPort;
}
All you need to do is add the factory to your JCommander object: 
  ArgsConverterFactory a = new ArgsConverterFactory();
  JCommander jc = new JCommander(a);
  jc.addConverterFactory(new Factory());
  jc.parse("-hostport", "example.com:8080");

  Assert.assertEquals(a.hostPort.host, "example.com");
  Assert.assertEquals(a.hostPort.port.intValue(), 8080);
Another advantage of using string converter factories is that your factories can come from a dependency injection framework.

Parameter validation

You can ask JCommander to perform early validation on your parameters by providing a class that implements the following interface: 
public interface IParameterValidator {
 /**
   * Validate the parameter.
   *
   * @param name The name of the parameter (e.g. "-host").
   * @param value The value of the parameter that we need to validate
   *
   * @throws ParameterException Thrown if the value of the parameter is invalid.
   */
  void validate(String name, String value) throws ParameterException;
}
Here is an example implementation that will make sure that the parameter is a positive integer: 
public class PositiveInteger implements IParameterValidator {
 public void validate(String name, String value)
      throws ParameterException {
    int n = Integer.parseInt(value);
    if (n < 0) {
      throw new ParameterException("Parameter " + name + " should be positive (found " + value +")");
    }
  }
}
Specify the name of a class implementing this interface in the validateWith attribute of your @Parameter annotations: 
@Parameter(names = "-age", validateWith = PositiveInteger.class)
private Integer age;
Attempting to pass a negative integer to this option will cause a ParameterException to be thrown.

Main parameter

So far, all the @Parameter annotations we have seen had defined an attribute called names. You can define one (and at most one) parameter without any such attribute. This parameter needs to be a List<String> and it will contain all the parameters that are not options: 
@Parameter(description = "Files")
private List<String> files = new ArrayList<String>();

@Parameter(names = "-debug", description = "Debugging level")
private Integer debug = 1;
will allow you to parse: 
java Main -debug file1 file2
and the field files will receive the strings "file1" and "file2".

Private parameters

Parameters can be private: 
public class ArgsPrivate {
  @Parameter(names = "-verbose")
  private Integer verbose = 1;

  public Integer getVerbose() {
    return verbose;
  }
}

ArgsPrivate args = new ArgsPrivate();
new JCommander(args, "-verbose", "3");
Assert.assertEquals(args.getVerbose().intValue(), 3);

Parameter separators

By default, parameters are separated by spaces, but you can change this setting to allow different separators: 
java Main -log:3
or 
java Main -level=42
You define the separator with the @Parameters annotation: 
@Parameters(separators = "=")
public class SeparatorEqual {
  @Parameter(names = "-level")
  private Integer level = 2;
}

Multiple descriptions

You can spread the description of your parameters on more than one class. For example, you can define the following two classes:

ArgsMaster.java

public class ArgsMaster {
  @Parameter(names = "-master")
  private String master;
}

ArgsSlave.java

public class ArgsSlave {
  @Parameter(names = "-slave")
  private String slave;
}
and pass these two objects to JCommander: 
ArgsMaster m = new ArgsMaster();
ArgsSlave s = new ArgsSlave();
String[] argv = { "-master", "master", "-slave", "slave" };
new JCommander(new Object[] { m , s }, argv);

Assert.assertEquals(m.master, "master");
Assert.assertEquals(s.slave, "slave");

@ syntax

JCommander supports the @ syntax, which allows you to put all your options into a file and pass this file as parameter:

/tmp/parameters
-verbose
file1
file2
file3

java Main @/tmp/parameters

Arities (multiple values for parameters)

Fixed arities

If some of your parameters require more than one value, such as the following example where two values are expected after -pairs: 
java Main -pairs slave master foo.xml
then you need to define your parameter with the arity attribute and make that parameter a List<String>: 
@Parameter(names = "-pairs", arity = 2, description = "Pairs")
private List<String> pairs;
You don't need to specify an arity for parameters of type boolean or Boolean (which have a default arity of 0) and of types String, Integer, int, Long and long (which have a default arity of 1).

Also, note that only List<String> is allowed for parameters that define an arity. You will have to convert these values yourself if the parameters you need are of type Integer or other (this limitation is due to Java's erasure).

Variable arities

You can specify that a parameter can receive an indefinite number of parameters, up to the next option. For example: 
program -foo a1 a2 a3 -bar
program -foo a1 -bar
Such a parameter must be of type List<String> and have the boolean variableArity set to true 
@Parameter(names = "-foo", variableArity = true)
public List<String> foo = new ArrayList<String>();

Multiple option names

You can specify more than one option name: 

  @Parameter(names = { "-d", "--outputDirectory" }, description = "Directory")
  private String outputDirectory;
will allow both following syntaxes: 
java Main -d /tmp
java Main --outputDirectory /tmp

Other option configurations

You can configure how options are looked up in a few different ways:
  • JCommander#setCaseSensitiveOptions(boolean): specify whether options are case sensitive. If you call this method with false, then "-param" and "-PARAM" are considered equal.
  • JCommander#setAllowAbbreviatedOptions(boolean): specify whether users can pass abbreviated options. If you call this method with true then users can pass "-par" to specify an option called -param. JCommander will throw a ParameterException if the abbreviated name is ambiguous.

Required and optional parameters

If some of your parameters are mandatory, you can use the required attribute (which default to false): 

  @Parameter(names = "-host", required = true)
  private String host;
If this parameter is not specified, JCommander will throw an exception telling you which options are missing.

Default values

The most common way to specify a default value for your parameters is to initialize the field at declaration time: 
private Integer logLevel = 3;
For more complicated cases, you might want to be able to reuse identical default values across several main classes or be able to specify these default values in a centralized location such as a .properties or an XML fie. In this case, you can use an IDefaultProvider 
public interface IDefaultProvider {
  /**
   * @param optionName The name of the option as specified in the names() attribute
   * of the @Parameter option (e.g. "-file").
   * 
   * @return the default value for this option.
   */
  String getDefaultValueFor(String optionName);
}
By passing an implementation of this interface to your JCommander object, you can now control which default value will be used for your options. Note that the value returned by this method will then be passed to a string converter, if any is applicable, thereby allowing you to specify default values for any types you need.

For example, here is a default provider that will assign a default value of 42 for all your parameters except "-debug": 

private static final IDefaultProvider DEFAULT_PROVIDER = new IDefaultProvider() {
  @Override
  public String getDefaultValueFor(String optionName) {
    return "-debug".equals(optionName) ? "false" : "42";
  }
};

// ...

JCommander jc = new JCommander(new Args());
jc.setDefaultProvider(DEFAULT_PROVIDER);

Help parameter

If one of your parameters is used to display some help or usage, you need use the help attribute: 
  @Parameter(names = "--help", help = true)
  private boolean help;
If you omit this boolean, JCommander will instead issue an error message when it tries to validate your command and it finds that you didn't specify some of the required parameters.

More complex syntaxes (commands)

Complex tools such as git or svn understand a whole set of commands, each of which with their own specific syntax: 
  git commit --amend -m "Bug fix"
Words such as "commit" above are called "commands" in JCommander, and you can specify them by creating one arg object per command: 
@Parameters(separators = "=", commandDescription = "Record changes to the repository")
private class CommandCommit {

  @Parameter(description = "The list of files to commit")
  private List<String> files;

  @Parameter(names = "--amend", description = "Amend")
  private Boolean amend = false;

  @Parameter(names = "--author")
  private String author;
}

@Parameters(commandDescription = "Add file contents to the index")
public class CommandAdd {

  @Parameter(description = "File patterns to add to the index")
  private List<String> patterns;

  @Parameter(names = "-i")
  private Boolean interactive = false;
}
Then you register these commands with your JCommander object. After the parsing phase, you call getParsedCommand() on your JCommander object, and based on the command that is returned, you know which arg object to inspect (you can still use a main arg object if you want to support options before the first command appears on the command line): 
CommandMain cm = new CommandMain();
JCommander jc = new JCommander(cm);

CommandAdd add = new CommandAdd();
jc.addCommand("add", add);
CommandCommit commit = new CommandCommit();
jc.addCommand("commit", commit);

jc.parse("-v", "commit", "--amend", "--author=cbeust", "A.java", "B.java");

Assert.assertTrue(cm.verbose);
Assert.assertEquals(jc.getParsedCommand(), "commit");
Assert.assertTrue(commit.amend);
Assert.assertEquals(commit.author, "cbeust");
Assert.assertEquals(commit.files, Arrays.asList("A.java", "B.java"));

Exception

Whenever JCommander detects an error, it will throw a ParameterException. Note that this is a Runtime Exception, since your application is probably not initialized correctly at this point.

Usage

You can invoke usage() on the JCommander instance that you used to parse your command line in order to generate a summary of all the options that your program understands: 
Usage: <main class> [options] 
  Options:
    -debug          Debug mode (default: false)
    -groups         Comma-separated list of group names to be run
  * -log, -verbose  Level of verbosity (default: 1)
    -long           A long number (default: 0)
You can customize the name of your program by calling setProgramName() on your JCommander object. Options preceded by an asterisk are required.

Hiding parameters

If you don't want certain parameters to appear in the usage, you can mark them as "hidden": 
@Parameter(names = "-debug", description = "Debug mode", hidden = true)
private boolean debug = false;

Internationalization

You can internationalize the descriptions of your parameters.

First you use the @Parameters annotation at the top of your class to define the name of your message bundle, and then you use the descriptionKey attribute instead of description on all the @Parameters that require translations. This descriptionKey is the key to the string into your message bundle:

I18N.java

@Parameters(resourceBundle = "MessageBundle")
private class ArgsI18N2 {
  @Parameter(names = "-host", description = "Host", descriptionKey = "host")
  String hostName;
}
Your bundle needs to define this key:

MessageBundle_fr_FR.properties

host: Hôte
JCommander will then use the default locale to resolve your descriptions.

Parameter delegates

If you are writing many different tools in the same project, you will probably find that most of these tools can share configurations. While you can use inheritance with your objects to avoid repeating this code, the restriction to single inheritance of implementation might limit your flexibility. To address this problem, JCommander supports parameter delegates.

When JCommander encounters an object annotated with @ParameterDelegate in one of your objects, it acts as if this object had been added as a description object itself: 

class Delegate {
  @Parameter(names = "-port")
  private int port;
}

class MainParams {
  @Parameter(names = "-v")
  private boolean verbose;

  @ParametersDelegate
  private Delegate delegate = new Delegate();
}
The example above specifies a delegate parameter Delegate which is then referenced in MainParams. You only need to add a MainParams object to your JCommander configuration in order to use the delegate: 
MainParams p = new MainParams();
new JCommander(p).parse("-v", "-port", "1234");
Assert.assertTrue(p.isVerbose);
Assert.assertEquals(p.delegate.port, 1234);

Dynamic parameters

JCommander allows you to specify parameters that are not known at compile time, such as "-Da=b -Dc=d". Such parameters are specified with the @DynamicParameter annotation and must be of type Map<String, String>. Dynamic parameters are allowed to appear multiple times on the command line: 
@DynamicParameter(names = "-D", description = "Dynamic parameters go here")
private Map<String, String> params = new HashMap<String, String>();
You can specify a different assignment string than = by using the attribute assignment.

JCommander in Scala

Here is a quick example of how to use JCommander in Scala (courtesy of Patrick Linskey): 
import java.io.File
import com.beust.jcommander.{JCommander, Parameter}
import collection.JavaConversions._

object Main {
  object Args {
    // Declared as var because JCommander assigns a new collection declared
    // as java.util.List because that's what JCommander will replace it with.
    // It'd be nice if JCommander would just use the provided List so this
    // could be a val and a Scala LinkedList.
    @Parameter(
      names = Array("-f", "--file"),
      description = "File to load. Can be specified multiple times.")
    var file: java.util.List[String] = null
  }

  def main(args: Array[String]): Unit = {
    new JCommander(Args, args.toArray: _*)
    for (filename <- Args.file) {
      val f = new File(filename)
      printf("file: %s\n", f.getName)
    }
  }
}

JCommander in Groovy

Here is a quick example of how to use JCommander in Groovy (courtesy of Paul King): 
import com.beust.jcommander.*

class Args {
  @Parameter(names = ["-f", "--file"], description = "File to load. Can be specified multiple times.")
  List<String> file
}

new Args().with {
  new JCommander(it, args)
  file.each { println "file: ${new File(it).name}" }
}

More examples

TestNG uses JCommander to parse its own command line, here is its definition file.

Mailing list

Join the JCommander Google group if you are interested in discussions about JCommander.

Javadocs

The Javadocs for JCommander can be found here.

License

JCommander is released under the Apache 2.0 license.

Download

You can download JCommander from the following locations:
  • Source on github
  • If you are using Maven, add the following dependency to your pom.xml: 
    

  <groupId>com.beust</groupId>
  <artifactId>jcommander</artifactId>
  <version>1.30</version>
jcommander-jcommander-1.48/license.txt000077500000000000000000000261211251210532400200650ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright 2012, Cedric Beust 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. jcommander-jcommander-1.48/notice.md000066400000000000000000000001541251210532400175000ustar00rootroot00000000000000JCommander Copyright Notices ============================ Copyright 2010 Cedric Beust jcommander-jcommander-1.48/pom.xml000066400000000000000000000214621251210532400172170ustar00rootroot00000000000000 4.0.0 com.beust jcommander jar JCommander 1.48 A Java framework to parse command line options with annotations. http://beust.com/jcommander The Apache Software License, Version 2.0 http://www.apache.org/licenses/LICENSE-2.0.txt repo scm:git:git@github.com:cbeust/jcommander.git scm:git:git@github.com:cbeust/jcommander.git git@github.com:cbeust/jcommander.git sonatype-nexus-staging Nexus Staging Repository https://oss.sonatype.org/service/local/staging/deploy/maven2/ Cedric Beust org.sonatype.oss oss-parent 3 org.apache.maven.plugins maven-source-plugin 2.1.1 attach-sources jar org.apache.maven.plugins maven-compiler-plugin 2.3.1 1.5 1.5 UTF-8 org.apache.maven.plugins maven-resources-plugin 2.4.1 UTF-8 org.apache.felix maven-bundle-plugin 2.1.0 bundle-manifest process-classes manifest <_versionpolicy>$(@) org.apache.maven.plugins maven-jar-plugin 2.3.1 ${project.build.outputDirectory}/META-INF/MANIFEST.MF org.apache.maven.plugins maven-surefire-plugin 2.10 true com.beust jcommander 1.30 org.apache.maven.plugins maven-javadoc-plugin 2.7 *.internal org.eclipse.m2e lifecycle-mapping 1.0.0 org.apache.felix maven-bundle-plugin [2.1.0,) manifest org.testng testng 6.1.1 jar test jcommander com.beust license com.mycila.maven-license-plugin maven-license-plugin 1.7.0 false
src/main/license/license-header.txt
src/** pom.xml **/.git/** **/target/** false check sign maven-gpg-plugin 1.4 sign-artifacts verify sign jcommander-jcommander-1.48/release000066400000000000000000000004441251210532400172420ustar00rootroot00000000000000# UI : https://oss.sonatype.org/index.html # Wiki: https://docs.sonatype.org/display/Repository/Sonatype+OSS+Maven+Repository+Usage+Guide # # deploy without tagging: mvn deploy -DperformRelease # mvn release:clean javadoc:javadoc release:prepare release:perform mvn release:perform -P sign jcommander-jcommander-1.48/src/000077500000000000000000000000001251210532400164645ustar00rootroot00000000000000jcommander-jcommander-1.48/src/main/000077500000000000000000000000001251210532400174105ustar00rootroot00000000000000jcommander-jcommander-1.48/src/main/java/000077500000000000000000000000001251210532400203315ustar00rootroot00000000000000jcommander-jcommander-1.48/src/main/java/com/000077500000000000000000000000001251210532400211075ustar00rootroot00000000000000jcommander-jcommander-1.48/src/main/java/com/beust/000077500000000000000000000000001251210532400222315ustar00rootroot00000000000000jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/000077500000000000000000000000001251210532400243505ustar00rootroot00000000000000jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/DynamicParameter.java000066400000000000000000000022731251210532400304440ustar00rootroot00000000000000package com.beust.jcommander; import static java.lang.annotation.ElementType.FIELD; import com.beust.jcommander.validators.NoValidator; import com.beust.jcommander.validators.NoValueValidator; import java.lang.annotation.Retention; import java.lang.annotation.Target; @Retention(java.lang.annotation.RetentionPolicy.RUNTIME) @Target({ FIELD }) public @interface DynamicParameter { /** * An array of allowed command line parameters (e.g. "-D", "--define", etc...). */ String[] names() default {}; /** * Whether this option is required. */ boolean required() default false; /** * A description of this option. */ String description() default ""; /** * The key used to find the string in the message bundle. */ String descriptionKey() default ""; /** * If true, this parameter won't appear in the usage(). */ boolean hidden() default false; /** * The validation class to use. */ Class validateWith() default NoValidator.class; /** * The character(s) used to assign the values. */ String assignment() default "="; Class validateValueWith() default NoValueValidator.class; } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/FuzzyMap.java000066400000000000000000000030271251210532400270020ustar00rootroot00000000000000package com.beust.jcommander; import com.beust.jcommander.internal.Maps; import java.util.Map; /** * Helper class to perform fuzzy key look ups: looking up case insensitive or * abbreviated keys. */ public class FuzzyMap { interface IKey { String getName(); } public static V findInMap(Map map, IKey name, boolean caseSensitive, boolean allowAbbreviations) { if (allowAbbreviations) { return findAbbreviatedValue(map, name, caseSensitive); } else { if (caseSensitive) { return map.get(name); } else { for (IKey c : map.keySet()) { if (c.getName().equalsIgnoreCase(name.getName())) { return map.get(c); } } } } return null; } private static V findAbbreviatedValue(Map map, IKey name, boolean caseSensitive) { String string = name.getName(); Map results = Maps.newHashMap(); for (IKey c : map.keySet()) { String n = c.getName(); boolean match = (caseSensitive && n.startsWith(string)) || ((! caseSensitive) && n.toLowerCase().startsWith(string.toLowerCase())); if (match) { results.put(n, map.get(c)); } } V result; if (results.size() > 1) { throw new ParameterException("Ambiguous option: " + name + " matches " + results.keySet()); } else if (results.size() == 1) { result = results.values().iterator().next(); } else { result = null; } return result; } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/IDefaultProvider.java000066400000000000000000000021461251210532400304260ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander; /** * Allows the specification of default values. * * @author cbeust */ public interface IDefaultProvider { /** * @param optionName The name of the option as specified in the names() attribute * of the @Parameter option (e.g. "-file"). * * @return the default value for this option. */ String getDefaultValueFor(String optionName); } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/IParameterValidator.java000066400000000000000000000023241251210532400311130ustar00rootroot00000000000000/** * Copyright (C) 2011 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander; /** * The class used to validate parameters. * * @author Cedric Beust */ public interface IParameterValidator { /** * Validate the parameter. * * @param name The name of the parameter (e.g. "-host"). * @param value The value of the parameter that we need to validate * * @throws ParameterException Thrown if the value of the parameter is invalid. */ void validate(String name, String value) throws ParameterException; } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/IParameterValidator2.java000066400000000000000000000023331251210532400311750ustar00rootroot00000000000000/** * Copyright (C) 2011 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander; public interface IParameterValidator2 extends IParameterValidator { /** * Validate the parameter. * * @param name The name of the parameter (e.g. "-host"). * @param value The value of the parameter that we need to validate * @param pd The description of this parameter * * @throws ParameterException Thrown if the value of the parameter is invalid. */ void validate(String name, String value, ParameterDescription pd) throws ParameterException; } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/IStringConverter.java000066400000000000000000000025311251210532400304630ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander; /** * An interface that converts strings to any arbitrary type. * * If your class implements a constructor that takes a String, this * constructor will be used to instantiate your converter and the * parameter will receive the name of the option that's being parsed, * which can be useful to issue a more useful error message if the * conversion fails. * * You can also extend BaseConverter to make your life easier. * * @author cbeust */ public interface IStringConverter { /** * @return an object of type created from the parameter value. */ T convert(String value); } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/IStringConverterFactory.java000066400000000000000000000020721251210532400320130ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander; /** * A factory for IStringConverter. This interface lets you specify your * converters in one place instead of having them repeated all over * your argument classes. * * @author cbeust */ public interface IStringConverterFactory { Class> getConverter(Class forType); } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/IValueValidator.java000066400000000000000000000006161251210532400302510ustar00rootroot00000000000000package com.beust.jcommander; public interface IValueValidator { /** * Validate the parameter. * * @param name The name of the parameter (e.g. "-host"). * @param value The value of the parameter that we need to validate * * @throws ParameterException Thrown if the value of the parameter is invalid. */ void validate(String name, T value) throws ParameterException; } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/IVariableArity.java000066400000000000000000000006471251210532400300710ustar00rootroot00000000000000package com.beust.jcommander; /** * Must be implemented by argument classes that contain at least one * \@Parameter with "variableArity = true". */ public interface IVariableArity { /** * @param optionName the name of the option to process. * @param options the entire list of options. * * @return how many options were processed. */ int processVariableArity(String optionName, String[] options); } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/JCommander.java000066400000000000000000001456551251210532400272520ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.EnumSet; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.ResourceBundle; import com.beust.jcommander.FuzzyMap.IKey; import com.beust.jcommander.converters.IParameterSplitter; import com.beust.jcommander.converters.NoConverter; import com.beust.jcommander.converters.StringConverter; import com.beust.jcommander.internal.Console; import com.beust.jcommander.internal.DefaultConsole; import com.beust.jcommander.internal.DefaultConverterFactory; import com.beust.jcommander.internal.JDK6Console; import com.beust.jcommander.internal.Lists; import com.beust.jcommander.internal.Maps; import com.beust.jcommander.internal.Nullable; /** * The main class for JCommander. It's responsible for parsing the object that contains * all the annotated fields, parse the command line and assign the fields with the correct * values and a few other helper methods, such as usage(). * * The object(s) you pass in the constructor are expected to have one or more * \@Parameter annotations on them. You can pass either a single object, an array of objects * or an instance of Iterable. In the case of an array or Iterable, JCommander will collect * the \@Parameter annotations from all the objects passed in parameter. * * @author Cedric Beust */ public class JCommander { public static final String DEBUG_PROPERTY = "jcommander.debug"; /** * A map to look up parameter description per option name. */ private Map m_descriptions; /** * The objects that contain fields annotated with @Parameter. */ private List m_objects = Lists.newArrayList(); private boolean m_firstTimeMainParameter = true; /** * This field/method will contain whatever command line parameter is not an option. * It is expected to be a List. */ private Parameterized m_mainParameter = null; /** * The object on which we found the main parameter field. */ private Object m_mainParameterObject; /** * The annotation found on the main parameter field. */ private Parameter m_mainParameterAnnotation; private ParameterDescription m_mainParameterDescription; /** * A set of all the parameterizeds that are required. During the reflection phase, * this field receives all the fields that are annotated with required=true * and during the parsing phase, all the fields that are assigned a value * are removed from it. At the end of the parsing phase, if it's not empty, * then some required fields did not receive a value and an exception is * thrown. */ private Map m_requiredFields = Maps.newHashMap(); /** * A map of all the parameterized fields/methods. */ private Map m_fields = Maps.newHashMap(); private ResourceBundle m_bundle; /** * A default provider returns default values for the parameters. */ private IDefaultProvider m_defaultProvider; /** * List of commands and their instance. */ private Map m_commands = Maps.newLinkedHashMap(); /** * Alias database for reverse lookup */ private Map aliasMap = Maps.newLinkedHashMap(); /** * The name of the command after the parsing has run. */ private String m_parsedCommand; /** * The name of command or alias as it was passed to the * command line */ private String m_parsedAlias; private ProgramName m_programName; private Comparator m_parameterDescriptionComparator = new Comparator() { @Override public int compare(ParameterDescription p0, ParameterDescription p1) { return p0.getLongestName().compareTo(p1.getLongestName()); } }; private int m_columnSize = 79; private boolean m_helpWasSpecified; private List m_unknownArgs = Lists.newArrayList(); private boolean m_acceptUnknownOptions = false; private boolean m_allowParameterOverwriting = false; private static Console m_console; /** * The factories used to look up string converters. */ private static LinkedList CONVERTER_FACTORIES = Lists.newLinkedList(); static { CONVERTER_FACTORIES.addFirst(new DefaultConverterFactory()); }; /** * Creates a new un-configured JCommander object. */ public JCommander() { } /** * @param object The arg object expected to contain {@link Parameter} annotations. */ public JCommander(Object object) { addObject(object); createDescriptions(); } /** * @param object The arg object expected to contain {@link Parameter} annotations. * @param bundle The bundle to use for the descriptions. Can be null. */ public JCommander(Object object, @Nullable ResourceBundle bundle) { addObject(object); setDescriptionsBundle(bundle); } /** * @param object The arg object expected to contain {@link Parameter} annotations. * @param bundle The bundle to use for the descriptions. Can be null. * @param args The arguments to parse (optional). */ public JCommander(Object object, ResourceBundle bundle, String... args) { addObject(object); setDescriptionsBundle(bundle); parse(args); } /** * @param object The arg object expected to contain {@link Parameter} annotations. * @param args The arguments to parse (optional). */ public JCommander(Object object, String... args) { addObject(object); parse(args); } public static Console getConsole() { if (m_console == null) { try { Method consoleMethod = System.class.getDeclaredMethod("console", new Class[0]); Object console = consoleMethod.invoke(null, new Object[0]); m_console = new JDK6Console(console); } catch (Throwable t) { m_console = new DefaultConsole(); } } return m_console; } /** * Adds the provided arg object to the set of objects that this commander * will parse arguments into. * * @param object The arg object expected to contain {@link Parameter} * annotations. If object is an array or is {@link Iterable}, * the child objects will be added instead. */ // declared final since this is invoked from constructors public final void addObject(Object object) { if (object instanceof Iterable) { // Iterable for (Object o : (Iterable) object) { m_objects.add(o); } } else if (object.getClass().isArray()) { // Array for (Object o : (Object[]) object) { m_objects.add(o); } } else { // Single object m_objects.add(object); } } /** * Sets the {@link ResourceBundle} to use for looking up descriptions. * Set this to null to use description text directly. */ // declared final since this is invoked from constructors public final void setDescriptionsBundle(ResourceBundle bundle) { m_bundle = bundle; } /** * Parse and validate the command line parameters. */ public void parse(String... args) { parse(true /* validate */, args); } /** * Parse the command line parameters without validating them. */ public void parseWithoutValidation(String... args) { parse(false /* no validation */, args); } private void parse(boolean validate, String... args) { StringBuilder sb = new StringBuilder("Parsing \""); sb.append(join(args).append("\"\n with:").append(join(m_objects.toArray()))); p(sb.toString()); if (m_descriptions == null) createDescriptions(); initializeDefaultValues(); parseValues(expandArgs(args), validate); if (validate) validateOptions(); } private StringBuilder join(Object[] args) { StringBuilder result = new StringBuilder(); for (int i = 0; i < args.length; i++) { if (i > 0) result.append(" "); result.append(args[i]); } return result; } private void initializeDefaultValues() { if (m_defaultProvider != null) { for (ParameterDescription pd : m_descriptions.values()) { initializeDefaultValue(pd); } for (Map.Entry entry : m_commands.entrySet()) { entry.getValue().initializeDefaultValues(); } } } /** * Make sure that all the required parameters have received a value. */ private void validateOptions() { // No validation if we found a help parameter if (m_helpWasSpecified) { return; } if (! m_requiredFields.isEmpty()) { StringBuilder missingFields = new StringBuilder(); for (ParameterDescription pd : m_requiredFields.values()) { missingFields.append(pd.getNames()).append(" "); } throw new ParameterException("The following " + pluralize(m_requiredFields.size(), "option is required: ", "options are required: ") + missingFields); } if (m_mainParameterDescription != null) { if (m_mainParameterDescription.getParameter().required() && !m_mainParameterDescription.isAssigned()) { throw new ParameterException("Main parameters are required (\"" + m_mainParameterDescription.getDescription() + "\")"); } } } private static String pluralize(int quantity, String singular, String plural) { return quantity == 1 ? singular : plural; } /** * Expand the command line parameters to take @ parameters into account. * When @ is encountered, the content of the file that follows is inserted * in the command line. * * @param originalArgv the original command line parameters * @return the new and enriched command line parameters */ private String[] expandArgs(String[] originalArgv) { List vResult1 = Lists.newArrayList(); // // Expand @ // for (String arg : originalArgv) { if (arg.startsWith("@")) { String fileName = arg.substring(1); vResult1.addAll(readFile(fileName)); } else { List expanded = expandDynamicArg(arg); vResult1.addAll(expanded); } } // Expand separators // List vResult2 = Lists.newArrayList(); for (int i = 0; i < vResult1.size(); i++) { String arg = vResult1.get(i); String[] v1 = vResult1.toArray(new String[0]); if (isOption(v1, arg)) { String sep = getSeparatorFor(v1, arg); if (! " ".equals(sep)) { String[] sp = arg.split("[" + sep + "]", 2); for (String ssp : sp) { vResult2.add(ssp); } } else { vResult2.add(arg); } } else { vResult2.add(arg); } } return vResult2.toArray(new String[vResult2.size()]); } private List expandDynamicArg(String arg) { for (ParameterDescription pd : m_descriptions.values()) { if (pd.isDynamicParameter()) { for (String name : pd.getParameter().names()) { if (arg.startsWith(name) && !arg.equals(name)) { return Arrays.asList(name, arg.substring(name.length())); } } } } return Arrays.asList(arg); } private boolean isOption(String[] args, String arg) { String prefixes = getOptionPrefixes(args, arg); return arg.length() > 0 && prefixes.indexOf(arg.charAt(0)) >= 0; } private ParameterDescription getPrefixDescriptionFor(String arg) { for (Map.Entry es : m_descriptions.entrySet()) { if (arg.startsWith(es.getKey().getName())) return es.getValue(); } return null; } /** * If arg is an option, we can look it up directly, but if it's a value, * we need to find the description for the option that precedes it. */ private ParameterDescription getDescriptionFor(String[] args, String arg) { ParameterDescription result = getPrefixDescriptionFor(arg); if (result != null) return result; for (String a : args) { ParameterDescription pd = getPrefixDescriptionFor(arg); if (pd != null) result = pd; if (a.equals(arg)) return result; } throw new ParameterException("Unknown parameter: " + arg); } private String getSeparatorFor(String[] args, String arg) { ParameterDescription pd = getDescriptionFor(args, arg); // Could be null if only main parameters were passed if (pd != null) { Parameters p = pd.getObject().getClass().getAnnotation(Parameters.class); if (p != null) return p.separators(); } return " "; } private String getOptionPrefixes(String[] args, String arg) { ParameterDescription pd = getDescriptionFor(args, arg); // Could be null if only main parameters were passed if (pd != null) { Parameters p = pd.getObject().getClass() .getAnnotation(Parameters.class); if (p != null) return p.optionPrefixes(); } String result = Parameters.DEFAULT_OPTION_PREFIXES; // See if any of the objects contains a @Parameters(optionPrefixes) StringBuilder sb = new StringBuilder(); for (Object o : m_objects) { Parameters p = o.getClass().getAnnotation(Parameters.class); if (p != null && !Parameters.DEFAULT_OPTION_PREFIXES.equals(p.optionPrefixes())) { sb.append(p.optionPrefixes()); } } if (! Strings.isStringEmpty(sb.toString())) { result = sb.toString(); } return result; } /** * Reads the file specified by filename and returns the file content as a string. * End of lines are replaced by a space. * * @param fileName the command line filename * @return the file content as a string. */ private static List readFile(String fileName) { List result = Lists.newArrayList(); try { BufferedReader bufRead = new BufferedReader(new FileReader(fileName)); String line; // Read through file one line at time. Print line # and line while ((line = bufRead.readLine()) != null) { // Allow empty lines and # comments in these at files if (line.length() > 0 && ! line.trim().startsWith("#")) { result.add(line); } } bufRead.close(); } catch (IOException e) { throw new ParameterException("Could not read file " + fileName + ": " + e); } return result; } /** * Remove spaces at both ends and handle double quotes. */ private static String trim(String string) { String result = string.trim(); if (result.startsWith("\"") && result.endsWith("\"") && result.length() > 1) { result = result.substring(1, result.length() - 1); } return result; } /** * Create the ParameterDescriptions for all the \@Parameter found. */ private void createDescriptions() { m_descriptions = Maps.newHashMap(); for (Object object : m_objects) { addDescription(object); } } private void addDescription(Object object) { Class cls = object.getClass(); List parameterizeds = Parameterized.parseArg(object); for (Parameterized parameterized : parameterizeds) { WrappedParameter wp = parameterized.getWrappedParameter(); if (wp != null && wp.getParameter() != null) { Parameter annotation = wp.getParameter(); // // @Parameter // Parameter p = annotation; if (p.names().length == 0) { p("Found main parameter:" + parameterized); if (m_mainParameter != null) { throw new ParameterException("Only one @Parameter with no names attribute is" + " allowed, found:" + m_mainParameter + " and " + parameterized); } m_mainParameter = parameterized; m_mainParameterObject = object; m_mainParameterAnnotation = p; m_mainParameterDescription = new ParameterDescription(object, p, parameterized, m_bundle, this); } else { ParameterDescription pd = new ParameterDescription(object, p, parameterized, m_bundle, this); for (String name : p.names()) { if (m_descriptions.containsKey(new StringKey(name))) { throw new ParameterException("Found the option " + name + " multiple times"); } p("Adding description for " + name); m_fields.put(parameterized, pd); m_descriptions.put(new StringKey(name), pd); if (p.required()) m_requiredFields.put(parameterized, pd); } } } else if (parameterized.getDelegateAnnotation() != null) { // // @ParametersDelegate // Object delegateObject = parameterized.get(object); if (delegateObject == null){ throw new ParameterException("Delegate field '" + parameterized.getName() + "' cannot be null."); } addDescription(delegateObject); } else if (wp != null && wp.getDynamicParameter() != null) { // // @DynamicParameter // DynamicParameter dp = wp.getDynamicParameter(); for (String name : dp.names()) { if (m_descriptions.containsKey(name)) { throw new ParameterException("Found the option " + name + " multiple times"); } p("Adding description for " + name); ParameterDescription pd = new ParameterDescription(object, dp, parameterized, m_bundle, this); m_fields.put(parameterized, pd); m_descriptions.put(new StringKey(name), pd); if (dp.required()) m_requiredFields.put(parameterized, pd); } } } // while (!Object.class.equals(cls)) { // for (Field f : cls.getDeclaredFields()) { // p("Field:" + cls.getSimpleName() + "." + f.getName()); // f.setAccessible(true); // Annotation annotation = f.getAnnotation(Parameter.class); // Annotation delegateAnnotation = f.getAnnotation(ParametersDelegate.class); // Annotation dynamicParameter = f.getAnnotation(DynamicParameter.class); // if (annotation != null) { // // // // @Parameter // // // Parameter p = (Parameter) annotation; // if (p.names().length == 0) { // p("Found main parameter:" + f); // if (m_mainParameterField != null) { // throw new ParameterException("Only one @Parameter with no names attribute is" // + " allowed, found:" + m_mainParameterField + " and " + f); // } // m_mainParameterField = parameterized; // m_mainParameterObject = object; // m_mainParameterAnnotation = p; // m_mainParameterDescription = new ParameterDescription(object, p, f, m_bundle, this); // } else { // for (String name : p.names()) { // if (m_descriptions.containsKey(name)) { // throw new ParameterException("Found the option " + name + " multiple times"); // } // p("Adding description for " + name); // ParameterDescription pd = new ParameterDescription(object, p, f, m_bundle, this); // m_fields.put(f, pd); // m_descriptions.put(name, pd); // // if (p.required()) m_requiredFields.put(f, pd); // } // } // } else if (delegateAnnotation != null) { // // // // @ParametersDelegate // // // try { // Object delegateObject = f.get(object); // if (delegateObject == null){ // throw new ParameterException("Delegate field '" + f.getName() + "' cannot be null."); // } // addDescription(delegateObject); // } catch (IllegalAccessException e) { // } // } else if (dynamicParameter != null) { // // // // @DynamicParameter // // // DynamicParameter dp = (DynamicParameter) dynamicParameter; // for (String name : dp.names()) { // if (m_descriptions.containsKey(name)) { // throw new ParameterException("Found the option " + name + " multiple times"); // } // p("Adding description for " + name); // ParameterDescription pd = new ParameterDescription(object, dp, f, m_bundle, this); // m_fields.put(f, pd); // m_descriptions.put(name, pd); // // if (dp.required()) m_requiredFields.put(f, pd); // } // } // } // // Traverse the super class until we find Object.class // cls = cls.getSuperclass(); // } } private void initializeDefaultValue(ParameterDescription pd) { for (String optionName : pd.getParameter().names()) { String def = m_defaultProvider.getDefaultValueFor(optionName); if (def != null) { p("Initializing " + optionName + " with default value:" + def); pd.addValue(def, true /* default */); return; } } } /** * Main method that parses the values and initializes the fields accordingly. */ private void parseValues(String[] args, boolean validate) { // This boolean becomes true if we encounter a command, which indicates we need // to stop parsing (the parsing of the command will be done in a sub JCommander // object) boolean commandParsed = false; int i = 0; boolean isDashDash = false; // once we encounter --, everything goes into the main parameter while (i < args.length && ! commandParsed) { String arg = args[i]; String a = trim(arg); args[i] = a; p("Parsing arg: " + a); JCommander jc = findCommandByAlias(arg); int increment = 1; if (! isDashDash && ! "--".equals(a) && isOption(args, a) && jc == null) { // // Option // ParameterDescription pd = findParameterDescription(a); if (pd != null) { if (pd.getParameter().password()) { // // Password option, use the Console to retrieve the password // char[] password = readPassword(pd.getDescription(), pd.getParameter().echoInput()); pd.addValue(new String(password)); m_requiredFields.remove(pd.getParameterized()); } else { if (pd.getParameter().variableArity()) { // // Variable arity? // increment = processVariableArity(args, i, pd); } else { // // Regular option // Class fieldType = pd.getParameterized().getType(); // Boolean, set to true as soon as we see it, unless it specified // an arity of 1, in which case we need to read the next value if ((fieldType == boolean.class || fieldType == Boolean.class) && pd.getParameter().arity() == -1) { pd.addValue("true"); m_requiredFields.remove(pd.getParameterized()); } else { increment = processFixedArity(args, i, pd, fieldType); } // If it's a help option, remember for later if (pd.isHelp()) { m_helpWasSpecified = true; } } } } else { if (m_acceptUnknownOptions) { m_unknownArgs.add(arg); i++; while (i < args.length && ! isOption(args, args[i])) { m_unknownArgs.add(args[i++]); } increment = 0; } else { throw new ParameterException("Unknown option: " + arg); } } } else { // // Main parameter // if (! Strings.isStringEmpty(arg)) { if ("--".equals(arg)) { isDashDash = true; a = trim(args[++i]); } if (m_commands.isEmpty()) { // // Regular (non-command) parsing // List mp = getMainParameter(arg); String value = a; // If there's a non-quoted version, prefer that one Object convertedValue = value; if (m_mainParameter.getGenericType() instanceof ParameterizedType) { ParameterizedType p = (ParameterizedType) m_mainParameter.getGenericType(); Type cls = p.getActualTypeArguments()[0]; if (cls instanceof Class) { convertedValue = convertValue(m_mainParameter, (Class) cls, value); } } ParameterDescription.validateParameter(m_mainParameterDescription, m_mainParameterAnnotation.validateWith(), "Default", value); m_mainParameterDescription.setAssigned(true); mp.add(convertedValue); } else { // // Command parsing // if (jc == null && validate) { throw new MissingCommandException("Expected a command, got " + arg); } else if (jc != null){ m_parsedCommand = jc.m_programName.m_name; m_parsedAlias = arg; //preserve the original form // Found a valid command, ask it to parse the remainder of the arguments. // Setting the boolean commandParsed to true will force the current // loop to end. jc.parse(subArray(args, i + 1)); commandParsed = true; } } } } i += increment; } // Mark the parameter descriptions held in m_fields as assigned for (ParameterDescription parameterDescription : m_descriptions.values()) { if (parameterDescription.isAssigned()) { m_fields.get(parameterDescription.getParameterized()).setAssigned(true); } } } private class DefaultVariableArity implements IVariableArity { @Override public int processVariableArity(String optionName, String[] options) { int i = 0; while (i < options.length && !isOption(options, options[i])) { i++; } return i; } } private final IVariableArity DEFAULT_VARIABLE_ARITY = new DefaultVariableArity(); private int m_verbose = 0; private boolean m_caseSensitiveOptions = true; private boolean m_allowAbbreviatedOptions = false; /** * @return the number of options that were processed. */ private int processVariableArity(String[] args, int index, ParameterDescription pd) { Object arg = pd.getObject(); IVariableArity va; if (! (arg instanceof IVariableArity)) { va = DEFAULT_VARIABLE_ARITY; } else { va = (IVariableArity) arg; } List currentArgs = Lists.newArrayList(); for (int j = index + 1; j < args.length; j++) { currentArgs.add(args[j]); } int arity = va.processVariableArity(pd.getParameter().names()[0], currentArgs.toArray(new String[0])); int result = processFixedArity(args, index, pd, List.class, arity); return result; } private int processFixedArity(String[] args, int index, ParameterDescription pd, Class fieldType) { // Regular parameter, use the arity to tell use how many values // we need to consume int arity = pd.getParameter().arity(); int n = (arity != -1 ? arity : 1); return processFixedArity(args, index, pd, fieldType, n); } private int processFixedArity(String[] args, int originalIndex, ParameterDescription pd, Class fieldType, int arity) { int index = originalIndex; String arg = args[index]; // Special case for boolean parameters of arity 0 if (arity == 0 && (Boolean.class.isAssignableFrom(fieldType) || boolean.class.isAssignableFrom(fieldType))) { pd.addValue("true"); m_requiredFields.remove(pd.getParameterized()); } else if (index < args.length - 1) { int offset = "--".equals(args[index + 1]) ? 1 : 0; if (index + arity < args.length) { for (int j = 1; j <= arity; j++) { pd.addValue(trim(args[index + j + offset])); m_requiredFields.remove(pd.getParameterized()); } index += arity + offset; } else { throw new ParameterException("Expected " + arity + " values after " + arg); } } else { throw new ParameterException("Expected a value after parameter " + arg); } return arity + 1; } /** * Invoke Console.readPassword through reflection to avoid depending * on Java 6. */ private char[] readPassword(String description, boolean echoInput) { getConsole().print(description + ": "); return getConsole().readPassword(echoInput); } private String[] subArray(String[] args, int index) { int l = args.length - index; String[] result = new String[l]; System.arraycopy(args, index, result, 0, l); return result; } /** * @return the field that's meant to receive all the parameters that are not options. * * @param arg the arg that we're about to add (only passed here to output a meaningful * error message). */ private List getMainParameter(String arg) { if (m_mainParameter == null) { throw new ParameterException( "Was passed main parameter '" + arg + "' but no main parameter was defined"); } List result = (List) m_mainParameter.get(m_mainParameterObject); if (result == null) { result = Lists.newArrayList(); if (! List.class.isAssignableFrom(m_mainParameter.getType())) { throw new ParameterException("Main parameter field " + m_mainParameter + " needs to be of type List, not " + m_mainParameter.getType()); } m_mainParameter.set(m_mainParameterObject, result); } if (m_firstTimeMainParameter) { result.clear(); m_firstTimeMainParameter = false; } return result; } public String getMainParameterDescription() { if (m_descriptions == null) createDescriptions(); return m_mainParameterAnnotation != null ? m_mainParameterAnnotation.description() : null; } // private int longestName(Collection objects) { // int result = 0; // for (Object o : objects) { // int l = o.toString().length(); // if (l > result) result = l; // } // // return result; // } /** * Set the program name (used only in the usage). */ public void setProgramName(String name) { setProgramName(name, new String[0]); } /** * Set the program name * * @param name program name * @param aliases aliases to the program name */ public void setProgramName(String name, String... aliases) { m_programName = new ProgramName(name, Arrays.asList(aliases)); } /** * Display the usage for this command. */ public void usage(String commandName) { StringBuilder sb = new StringBuilder(); usage(commandName, sb); getConsole().println(sb.toString()); } /** * Store the help for the command in the passed string builder. */ public void usage(String commandName, StringBuilder out) { usage(commandName, out, ""); } /** * Store the help for the command in the passed string builder, indenting * every line with "indent". */ public void usage(String commandName, StringBuilder out, String indent) { String description = getCommandDescription(commandName); JCommander jc = findCommandByAlias(commandName); if (description != null) { out.append(indent).append(description); out.append("\n"); } jc.usage(out, indent); } /** * @return the description of the command. */ public String getCommandDescription(String commandName) { JCommander jc = findCommandByAlias(commandName); if (jc == null) { throw new ParameterException("Asking description for unknown command: " + commandName); } Object arg = jc.getObjects().get(0); Parameters p = arg.getClass().getAnnotation(Parameters.class); ResourceBundle bundle = null; String result = null; if (p != null) { result = p.commandDescription(); String bundleName = p.resourceBundle(); if (!"".equals(bundleName)) { bundle = ResourceBundle.getBundle(bundleName, Locale.getDefault()); } else { bundle = m_bundle; } if (bundle != null) { result = getI18nString(bundle, p.commandDescriptionKey(), p.commandDescription()); } } return result; } /** * @return The internationalized version of the string if available, otherwise * return def. */ private String getI18nString(ResourceBundle bundle, String key, String def) { String s = bundle != null ? bundle.getString(key) : null; return s != null ? s : def; } /** * Display the help on System.out. */ public void usage() { StringBuilder sb = new StringBuilder(); usage(sb); getConsole().println(sb.toString()); } /** * Store the help in the passed string builder. */ public void usage(StringBuilder out) { usage(out, ""); } public void usage(StringBuilder out, String indent) { if (m_descriptions == null) createDescriptions(); boolean hasCommands = !m_commands.isEmpty(); // // First line of the usage // String programName = m_programName != null ? m_programName.getDisplayName() : "
"; out.append(indent).append("Usage: " + programName + " [options]"); if (hasCommands) out.append(indent).append(" [command] [command options]"); if (m_mainParameterDescription != null) { out.append(" " + m_mainParameterDescription.getDescription()); } out.append("\n"); // // Align the descriptions at the "longestName" column // int longestName = 0; List sorted = Lists.newArrayList(); for (ParameterDescription pd : m_fields.values()) { if (! pd.getParameter().hidden()) { sorted.add(pd); // + to have an extra space between the name and the description int length = pd.getNames().length() + 2; if (length > longestName) { longestName = length; } } } // // Sort the options // Collections.sort(sorted, getParameterDescriptionComparator()); // // Display all the names and descriptions // int descriptionIndent = 6; if (sorted.size() > 0) out.append(indent).append(" Options:\n"); for (ParameterDescription pd : sorted) { WrappedParameter parameter = pd.getParameter(); out.append(indent).append(" " + (parameter.required() ? "* " : " ") + pd.getNames() + "\n" + indent + s(descriptionIndent)); int indentCount = indent.length() + descriptionIndent; wrapDescription(out, indentCount, pd.getDescription()); Object def = pd.getDefault(); if (pd.isDynamicParameter()) { out.append("\n" + s(indentCount + 1)) .append("Syntax: " + parameter.names()[0] + "key" + parameter.getAssignment() + "value"); } if (def != null) { String displayedDef = Strings.isStringEmpty(def.toString()) ? "" : def.toString(); out.append("\n" + s(indentCount + 1)) .append("Default: " + (parameter.password()?"********" : displayedDef)); } Class type = pd.getParameterized().getType(); if(type.isEnum()){ out.append("\n" + s(indentCount + 1)) .append("Possible Values: " + EnumSet.allOf((Class) type)); } out.append("\n"); } // // If commands were specified, show them as well // if (hasCommands) { out.append(" Commands:\n"); // The magic value 3 is the number of spaces between the name of the option // and its description for (Map.Entry commands : m_commands.entrySet()) { Object arg = commands.getValue().getObjects().get(0); Parameters p = arg.getClass().getAnnotation(Parameters.class); if (!p.hidden()) { ProgramName progName = commands.getKey(); String dispName = progName.getDisplayName(); out.append(indent).append(" " + dispName); // + s(spaceCount) + getCommandDescription(progName.name) + "\n"); // Options for this command usage(progName.getName(), out, " "); out.append("\n"); } } } } private Comparator getParameterDescriptionComparator() { return m_parameterDescriptionComparator; } public void setParameterDescriptionComparator(Comparator c) { m_parameterDescriptionComparator = c; } public void setColumnSize(int columnSize) { m_columnSize = columnSize; } public int getColumnSize() { return m_columnSize; } private void wrapDescription(StringBuilder out, int indent, String description) { int max = getColumnSize(); String[] words = description.split(" "); int current = indent; int i = 0; while (i < words.length) { String word = words[i]; if (word.length() > max || current + word.length() <= max) { out.append(" ").append(word); current += word.length() + 1; } else { out.append("\n").append(s(indent + 1)).append(word); current = indent; } i++; } } /** * @return a Collection of all the \@Parameter annotations found on the * target class. This can be used to display the usage() in a different * format (e.g. HTML). */ public List getParameters() { return new ArrayList(m_fields.values()); } /** * @return the main parameter description or null if none is defined. */ public ParameterDescription getMainParameter() { return m_mainParameterDescription; } private void p(String string) { if (m_verbose > 0 || System.getProperty(JCommander.DEBUG_PROPERTY) != null) { getConsole().println("[JCommander] " + string); } } /** * Define the default provider for this instance. */ public void setDefaultProvider(IDefaultProvider defaultProvider) { m_defaultProvider = defaultProvider; for (Map.Entry entry : m_commands.entrySet()) { entry.getValue().setDefaultProvider(defaultProvider); } } public void addConverterFactory(IStringConverterFactory converterFactory) { CONVERTER_FACTORIES.addFirst(converterFactory); } public Class> findConverter(Class cls) { for (IStringConverterFactory f : CONVERTER_FACTORIES) { Class> result = f.getConverter(cls); if (result != null) return result; } return null; } public Object convertValue(ParameterDescription pd, String value) { return convertValue(pd.getParameterized(), pd.getParameterized().getType(), value); } /** * @param type The type of the actual parameter * @param value The value to convert */ public Object convertValue(Parameterized parameterized, Class type, String value) { Parameter annotation = parameterized.getParameter(); // Do nothing if it's a @DynamicParameter if (annotation == null) return value; Class> converterClass = annotation.converter(); boolean listConverterWasSpecified = annotation.listConverter() != NoConverter.class; // // Try to find a converter on the annotation // if (converterClass == null || converterClass == NoConverter.class) { // If no converter specified and type is enum, used enum values to convert if (type.isEnum()){ converterClass = type; } else { converterClass = findConverter(type); } } if (converterClass == null) { Type elementType = parameterized.findFieldGenericType(); converterClass = elementType != null ? findConverter((Class>) elementType) : StringConverter.class; // Check for enum type parameter if (converterClass == null && Enum.class.isAssignableFrom((Class) elementType)) { converterClass = (Class>) elementType; } } IStringConverter converter; Object result = null; try { String[] names = annotation.names(); String optionName = names.length > 0 ? names[0] : "[Main class]"; if (converterClass != null && converterClass.isEnum()) { try { result = Enum.valueOf((Class) converterClass, value); } catch (IllegalArgumentException e) { try { result = Enum.valueOf((Class) converterClass, value.toUpperCase()); } catch (IllegalArgumentException ex) { throw new ParameterException("Invalid value for " + optionName + " parameter. Allowed values:" + EnumSet.allOf((Class) converterClass)); } } catch (Exception e) { throw new ParameterException("Invalid value for " + optionName + " parameter. Allowed values:" + EnumSet.allOf((Class) converterClass)); } } else { converter = instantiateConverter(optionName, converterClass); if (type.isAssignableFrom(List.class) && parameterized.getGenericType() instanceof ParameterizedType) { // The field is a List if (listConverterWasSpecified) { // If a list converter was specified, pass the value to it // for direct conversion IStringConverter listConverter = instantiateConverter(optionName, annotation.listConverter()); result = listConverter.convert(value); } else { // No list converter: use the single value converter and pass each // parsed value to it individually result = convertToList(value, converter, annotation.splitter()); } } else { result = converter.convert(value); } } } catch (InstantiationException e) { throw new ParameterException(e); } catch (IllegalAccessException e) { throw new ParameterException(e); } catch (InvocationTargetException e) { throw new ParameterException(e); } return result; } /** * Use the splitter to split the value into multiple values and then convert * each of them individually. */ private Object convertToList(String value, IStringConverter converter, Class splitterClass) throws InstantiationException, IllegalAccessException { IParameterSplitter splitter = splitterClass.newInstance(); List result = Lists.newArrayList(); for (String param : splitter.split(value)) { result.add(converter.convert(param)); } return result; } private IStringConverter instantiateConverter(String optionName, Class> converterClass) throws IllegalArgumentException, InstantiationException, IllegalAccessException, InvocationTargetException { Constructor> ctor = null; Constructor> stringCtor = null; Constructor>[] ctors = (Constructor>[]) converterClass.getDeclaredConstructors(); for (Constructor> c : ctors) { Class[] types = c.getParameterTypes(); if (types.length == 1 && types[0].equals(String.class)) { stringCtor = c; } else if (types.length == 0) { ctor = c; } } IStringConverter result = stringCtor != null ? stringCtor.newInstance(optionName) : (ctor != null ? ctor.newInstance() : null); return result; } /** * Add a command object. */ public void addCommand(String name, Object object) { addCommand(name, object, new String[0]); } public void addCommand(Object object) { Parameters p = object.getClass().getAnnotation(Parameters.class); if (p != null && p.commandNames().length > 0) { for (String commandName : p.commandNames()) { addCommand(commandName, object); } } else { throw new ParameterException("Trying to add command " + object.getClass().getName() + " without specifying its names in @Parameters"); } } /** * Add a command object and its aliases. */ public void addCommand(String name, Object object, String... aliases) { JCommander jc = new JCommander(object); jc.setProgramName(name, aliases); jc.setDefaultProvider(m_defaultProvider); jc.setAcceptUnknownOptions(m_acceptUnknownOptions); ProgramName progName = jc.m_programName; m_commands.put(progName, jc); /* * Register aliases */ //register command name as an alias of itself for reverse lookup //Note: Name clash check is intentionally omitted to resemble the // original behaviour of clashing commands. // Aliases are, however, are strictly checked for name clashes. aliasMap.put(new StringKey(name), progName); for (String a : aliases) { IKey alias = new StringKey(a); //omit pointless aliases to avoid name clash exception if (!alias.equals(name)) { ProgramName mappedName = aliasMap.get(alias); if (mappedName != null && !mappedName.equals(progName)) { throw new ParameterException("Cannot set alias " + alias + " for " + name + " command because it has already been defined for " + mappedName.m_name + " command"); } aliasMap.put(alias, progName); } } } public Map getCommands() { Map res = Maps.newLinkedHashMap(); for (Map.Entry entry : m_commands.entrySet()) { res.put(entry.getKey().m_name, entry.getValue()); } return res; } public String getParsedCommand() { return m_parsedCommand; } /** * The name of the command or the alias in the form it was * passed to the command line. null if no * command or alias was specified. * * @return Name of command or alias passed to command line. If none passed: null. */ public String getParsedAlias() { return m_parsedAlias; } /** * @return n spaces */ private String s(int count) { StringBuilder result = new StringBuilder(); for (int i = 0; i < count; i++) { result.append(" "); } return result.toString(); } /** * @return the objects that JCommander will fill with the result of * parsing the command line. */ public List getObjects() { return m_objects; } private ParameterDescription findParameterDescription(String arg) { return FuzzyMap.findInMap(m_descriptions, new StringKey(arg), m_caseSensitiveOptions, m_allowAbbreviatedOptions); } private JCommander findCommand(ProgramName name) { return FuzzyMap.findInMap(m_commands, name, m_caseSensitiveOptions, m_allowAbbreviatedOptions); // if (! m_caseSensitiveOptions) { // return m_commands.get(name); // } else { // for (ProgramName c : m_commands.keySet()) { // if (c.getName().equalsIgnoreCase(name.getName())) { // return m_commands.get(c); // } // } // } // return null; } private ProgramName findProgramName(String name) { return FuzzyMap.findInMap(aliasMap, new StringKey(name), m_caseSensitiveOptions, m_allowAbbreviatedOptions); } /* * Reverse lookup JCommand object by command's name or its alias */ private JCommander findCommandByAlias(String commandOrAlias) { ProgramName progName = findProgramName(commandOrAlias); if (progName == null) { return null; } JCommander jc = findCommand(progName); if (jc == null) { throw new IllegalStateException( "There appears to be inconsistency in the internal command database. " + " This is likely a bug. Please report."); } return jc; } /** * Encapsulation of either a main application or an individual command. */ private static final class ProgramName implements IKey { private final String m_name; private final List m_aliases; ProgramName(String name, List aliases) { m_name = name; m_aliases = aliases; } @Override public String getName() { return m_name; } private String getDisplayName() { StringBuilder sb = new StringBuilder(); sb.append(m_name); if (!m_aliases.isEmpty()) { sb.append("("); Iterator aliasesIt = m_aliases.iterator(); while (aliasesIt.hasNext()) { sb.append(aliasesIt.next()); if (aliasesIt.hasNext()) { sb.append(","); } } sb.append(")"); } return sb.toString(); } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((m_name == null) ? 0 : m_name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; ProgramName other = (ProgramName) obj; if (m_name == null) { if (other.m_name != null) return false; } else if (!m_name.equals(other.m_name)) return false; return true; } /* * Important: ProgramName#toString() is used by longestName(Collection) function * to format usage output. */ @Override public String toString() { return getDisplayName(); } } public void setVerbose(int verbose) { m_verbose = verbose; } public void setCaseSensitiveOptions(boolean b) { m_caseSensitiveOptions = b; } public void setAllowAbbreviatedOptions(boolean b) { m_allowAbbreviatedOptions = b; } public void setAcceptUnknownOptions(boolean b) { m_acceptUnknownOptions = b; } public List getUnknownOptions() { return m_unknownArgs; } public void setAllowParameterOverwriting(boolean b) { m_allowParameterOverwriting = b; } public boolean isParameterOverwritingAllowed() { return m_allowParameterOverwriting; } // public void setCaseSensitiveCommands(boolean b) { // m_caseSensitiveCommands = b; // } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/MissingCommandException.java000066400000000000000000000021101251210532400317740ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander; /** * Thrown when a command was expected. * * @author Cedric Beust */ @SuppressWarnings("serial") public class MissingCommandException extends ParameterException { public MissingCommandException(String string) { super(string); } public MissingCommandException(Throwable t) { super(t); } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/Parameter.java000066400000000000000000000100601251210532400271300ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander; import static java.lang.annotation.ElementType.FIELD; import static java.lang.annotation.ElementType.METHOD; import com.beust.jcommander.converters.CommaParameterSplitter; import com.beust.jcommander.converters.IParameterSplitter; import com.beust.jcommander.converters.NoConverter; import com.beust.jcommander.validators.NoValidator; import com.beust.jcommander.validators.NoValueValidator; import java.lang.annotation.Retention; import java.lang.annotation.Target; @Retention(java.lang.annotation.RetentionPolicy.RUNTIME) @Target({ FIELD, METHOD }) public @interface Parameter { /** * An array of allowed command line parameters (e.g. "-d", "--outputdir", etc...). * If this attribute is omitted, the field it's annotating will receive all the * unparsed options. There can only be at most one such annotation. */ String[] names() default {}; /** * A description of this option. */ String description() default ""; /** * Whether this option is required. */ boolean required() default false; /** * The key used to find the string in the message bundle. */ String descriptionKey() default ""; /** * How many parameter values this parameter will consume. For example, * an arity of 2 will allow "-pair value1 value2". */ int arity() default -1; /** * If true, this parameter is a password and it will be prompted on the console * (if available). */ boolean password() default false; /** * The string converter to use for this field. If the field is of type List * and not listConverter attribute was specified, JCommander will split * the input in individual values and convert each of them separately. */ Class> converter() default NoConverter.class; /** * The list string converter to use for this field. If it's specified, the * field has to be of type List and the converter needs to return * a List that's compatible with that type. */ Class> listConverter() default NoConverter.class; /** * If true, this parameter won't appear in the usage(). */ boolean hidden() default false; /** * Validate the parameter found on the command line. */ Class validateWith() default NoValidator.class; /** * Validate the value for this parameter. */ Class validateValueWith() default NoValueValidator.class; /** * @return true if this parameter has a variable arity. See @{IVariableArity} */ boolean variableArity() default false; /** * What splitter to use (applicable only on fields of type List). By default, * a comma separated splitter will be used. */ Class splitter() default CommaParameterSplitter.class; /** * If true, console will not echo typed input * Used in conjunction with password = true */ boolean echoInput() default false; /** * If true, this parameter is for help. If such a parameter is specified, * required parameters are no longer checked for their presence. */ boolean help() default false; /** * If true, this parameter can be overwritten through a file or another appearance of the parameter * @return */ boolean forceNonOverwritable() default false; } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/ParameterDescription.java000066400000000000000000000275231251210532400313500ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander; import com.beust.jcommander.validators.NoValidator; import com.beust.jcommander.validators.NoValueValidator; import java.util.ArrayList; import java.util.Collection; import java.util.EnumSet; import java.util.HashSet; import java.util.LinkedHashSet; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.ResourceBundle; import java.util.Set; import java.util.SortedSet; import java.util.TreeSet; public class ParameterDescription { private Object m_object; private WrappedParameter m_wrappedParameter; private Parameter m_parameterAnnotation; private DynamicParameter m_dynamicParameterAnnotation; /** The field/method */ private Parameterized m_parameterized; /** Keep track of whether a value was added to flag an error */ private boolean m_assigned = false; private ResourceBundle m_bundle; private String m_description; private JCommander m_jCommander; private Object m_default; /** Longest of the names(), used to present usage() alphabetically */ private String m_longestName = ""; public ParameterDescription(Object object, DynamicParameter annotation, Parameterized parameterized, ResourceBundle bundle, JCommander jc) { if (! Map.class.isAssignableFrom(parameterized.getType())) { throw new ParameterException("@DynamicParameter " + parameterized.getName() + " should be of type " + "Map but is " + parameterized.getType().getName()); } m_dynamicParameterAnnotation = annotation; m_wrappedParameter = new WrappedParameter(m_dynamicParameterAnnotation); init(object, parameterized, bundle, jc); } public ParameterDescription(Object object, Parameter annotation, Parameterized parameterized, ResourceBundle bundle, JCommander jc) { m_parameterAnnotation = annotation; m_wrappedParameter = new WrappedParameter(m_parameterAnnotation); init(object, parameterized, bundle, jc); } /** * Find the resource bundle in the annotations. * @return */ @SuppressWarnings("deprecation") private ResourceBundle findResourceBundle(Object o) { ResourceBundle result = null; Parameters p = o.getClass().getAnnotation(Parameters.class); if (p != null && ! isEmpty(p.resourceBundle())) { result = ResourceBundle.getBundle(p.resourceBundle(), Locale.getDefault()); } else { com.beust.jcommander.ResourceBundle a = o.getClass().getAnnotation( com.beust.jcommander.ResourceBundle.class); if (a != null && ! isEmpty(a.value())) { result = ResourceBundle.getBundle(a.value(), Locale.getDefault()); } } return result; } private boolean isEmpty(String s) { return s == null || "".equals(s); } private void initDescription(String description, String descriptionKey, String[] names) { m_description = description; if (! "".equals(descriptionKey)) { if (m_bundle != null) { m_description = m_bundle.getString(descriptionKey); } else { // JCommander.getConsole().println("Warning: field " + object.getClass() + "." + field.getName() // + " has a descriptionKey but no bundle was defined with @ResourceBundle, using " + // "default description:'" + m_description + "'"); } } for (String name : names) { if (name.length() > m_longestName.length()) m_longestName = name; } } @SuppressWarnings("unchecked") private void init(Object object, Parameterized parameterized, ResourceBundle bundle, JCommander jCommander) { m_object = object; m_parameterized = parameterized; m_bundle = bundle; if (m_bundle == null) { m_bundle = findResourceBundle(object); } m_jCommander = jCommander; if (m_parameterAnnotation != null) { String description; if (Enum.class.isAssignableFrom(parameterized.getType()) && m_parameterAnnotation.description().isEmpty()) { description = "Options: " + EnumSet.allOf((Class) parameterized.getType()); }else { description = m_parameterAnnotation.description(); } initDescription(description, m_parameterAnnotation.descriptionKey(), m_parameterAnnotation.names()); } else if (m_dynamicParameterAnnotation != null) { initDescription(m_dynamicParameterAnnotation.description(), m_dynamicParameterAnnotation.descriptionKey(), m_dynamicParameterAnnotation.names()); } else { throw new AssertionError("Shound never happen"); } try { m_default = parameterized.get(object); } catch (Exception e) { } // // Validate default values, if any and if applicable // if (m_default != null) { if (m_parameterAnnotation != null) { validateDefaultValues(m_parameterAnnotation.names()); } } } private void validateDefaultValues(String[] names) { String name = names.length > 0 ? names[0] : ""; validateValueParameter(name, m_default); } public String getLongestName() { return m_longestName; } public Object getDefault() { return m_default; } public String getDescription() { return m_description; } public Object getObject() { return m_object; } public String getNames() { StringBuilder sb = new StringBuilder(); String[] names = m_wrappedParameter.names(); for (int i = 0; i < names.length; i++) { if (i > 0) sb.append(", "); sb.append(names[i]); } return sb.toString(); } public WrappedParameter getParameter() { return m_wrappedParameter; } public Parameterized getParameterized() { return m_parameterized; } private boolean isMultiOption() { Class fieldType = m_parameterized.getType(); return fieldType.equals(List.class) || fieldType.equals(Set.class) || m_parameterized.isDynamicParameter(); } public void addValue(String value) { addValue(value, false /* not default */); } /** * @return true if this parameter received a value during the parsing phase. */ public boolean isAssigned() { return m_assigned; } public void setAssigned(boolean b) { m_assigned = b; } /** * Add the specified value to the field. First, validate the value if a * validator was specified. Then look up any field converter, then any type * converter, and if we can't find any, throw an exception. */ public void addValue(String value, boolean isDefault) { p("Adding " + (isDefault ? "default " : "") + "value:" + value + " to parameter:" + m_parameterized.getName()); String name = m_wrappedParameter.names()[0]; if (m_assigned && ! isMultiOption() && !m_jCommander.isParameterOverwritingAllowed() || isNonOverwritableForced()) { throw new ParameterException("Can only specify option " + name + " once."); } validateParameter(name, value); Class type = m_parameterized.getType(); Object convertedValue = m_jCommander.convertValue(this, value); validateValueParameter(name, convertedValue); boolean isCollection = Collection.class.isAssignableFrom(type); if (isCollection) { @SuppressWarnings("unchecked") Collection l = (Collection) m_parameterized.get(m_object); if (l == null || fieldIsSetForTheFirstTime(isDefault)) { l = newCollection(type); m_parameterized.set(m_object, l); } if (convertedValue instanceof Collection) { l.addAll((Collection) convertedValue); } else { // if (isMainParameter || m_parameterAnnotation.arity() > 1) { l.add(convertedValue); // } else { // l. } } else { m_wrappedParameter.addValue(m_parameterized, m_object, convertedValue); } if (! isDefault) m_assigned = true; } private void validateParameter(String name, String value) { Class validator = m_wrappedParameter.validateWith(); if (validator != null) { validateParameter(this, validator, name, value); } } private void validateValueParameter(String name, Object value) { Class validator = m_wrappedParameter.validateValueWith(); if (validator != null) { validateValueParameter(validator, name, value); } } public static void validateValueParameter(Class validator, String name, Object value) { try { if (validator != NoValueValidator.class) { p("Validating value parameter:" + name + " value:" + value + " validator:" + validator); } validator.newInstance().validate(name, value); } catch (InstantiationException e) { throw new ParameterException("Can't instantiate validator:" + e); } catch (IllegalAccessException e) { throw new ParameterException("Can't instantiate validator:" + e); } } public static void validateParameter(ParameterDescription pd, Class validator, String name, String value) { try { if (validator != NoValidator.class) { p("Validating parameter:" + name + " value:" + value + " validator:" + validator); } validator.newInstance().validate(name, value); if (IParameterValidator2.class.isAssignableFrom(validator)) { IParameterValidator2 instance = (IParameterValidator2) validator.newInstance(); instance.validate(name, value, pd); } } catch (InstantiationException e) { throw new ParameterException("Can't instantiate validator:" + e); } catch (IllegalAccessException e) { throw new ParameterException("Can't instantiate validator:" + e); } catch(ParameterException ex) { throw ex; } catch(Exception ex) { throw new ParameterException(ex); } } /* * Creates a new collection for the field's type. * * Currently only List and Set are supported. Support for * Queues and Stacks could be useful. */ @SuppressWarnings("unchecked") private Collection newCollection(Class type) { if (SortedSet.class.isAssignableFrom(type)) return new TreeSet(); else if (LinkedHashSet.class.isAssignableFrom(type)) return new LinkedHashSet(); else if (Set.class.isAssignableFrom(type)) return new HashSet(); else if (List.class.isAssignableFrom(type)) return new ArrayList(); else { throw new ParameterException("Parameters of Collection type '" + type.getSimpleName() + "' are not supported. Please use List or Set instead."); } } /* * Tests if its the first time a non-default value is * being added to the field. */ private boolean fieldIsSetForTheFirstTime(boolean isDefault) { return (!isDefault && !m_assigned); } private static void p(String string) { if (System.getProperty(JCommander.DEBUG_PROPERTY) != null) { JCommander.getConsole().println("[ParameterDescription] " + string); } } @Override public String toString() { return "[ParameterDescription " + m_parameterized.getName() + "]"; } public boolean isDynamicParameter() { return m_dynamicParameterAnnotation != null; } public boolean isHelp() { return m_wrappedParameter.isHelp(); } public boolean isNonOverwritableForced() { return m_wrappedParameter.isNonOverwritableForced(); } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/ParameterException.java000066400000000000000000000023231251210532400310120ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander; /** * The main exception that JCommand will throw when something goes wrong while * parsing parameters. * * @author Cedric Beust */ @SuppressWarnings("serial") public class ParameterException extends RuntimeException { public ParameterException(Throwable t) { super(t); } public ParameterException(String string) { super(string); } public ParameterException(String string, Throwable t) { super(string, t); } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/Parameterized.java000066400000000000000000000161711251210532400300150ustar00rootroot00000000000000package com.beust.jcommander; import com.beust.jcommander.internal.Lists; import java.lang.annotation.Annotation; import java.lang.reflect.Field; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import java.util.List; /** * Encapsulate a field or a method annotated with @Parameter or @DynamicParameter */ public class Parameterized { // Either a method or a field private Field m_field; private Method m_method; private Method m_getter; // Either of these two private WrappedParameter m_wrappedParameter; private ParametersDelegate m_parametersDelegate; public Parameterized(WrappedParameter wp, ParametersDelegate pd, Field field, Method method) { m_wrappedParameter = wp; m_method = method; m_field = field; if (m_field != null) { m_field.setAccessible(true); } m_parametersDelegate = pd; } public static List parseArg(Object arg) { List result = Lists.newArrayList(); Class cls = arg.getClass(); while (!Object.class.equals(cls)) { for (Field f : cls.getDeclaredFields()) { Annotation annotation = f.getAnnotation(Parameter.class); Annotation delegateAnnotation = f.getAnnotation(ParametersDelegate.class); Annotation dynamicParameter = f.getAnnotation(DynamicParameter.class); if (annotation != null) { result.add(new Parameterized(new WrappedParameter((Parameter) annotation), null, f, null)); } else if (dynamicParameter != null) { result.add(new Parameterized(new WrappedParameter((DynamicParameter) dynamicParameter), null, f, null)); } else if (delegateAnnotation != null) { result.add(new Parameterized(null, (ParametersDelegate) delegateAnnotation, f, null)); } } cls = cls.getSuperclass(); } // Reassigning cls = arg.getClass(); while (!Object.class.equals(cls)) { for (Method m : cls.getDeclaredMethods()) { Annotation annotation = m.getAnnotation(Parameter.class); Annotation delegateAnnotation = m.getAnnotation(ParametersDelegate.class); Annotation dynamicParameter = m.getAnnotation(DynamicParameter.class); if (annotation != null) { result.add(new Parameterized(new WrappedParameter((Parameter) annotation), null, null, m)); } else if (dynamicParameter != null) { result.add(new Parameterized(new WrappedParameter((DynamicParameter) annotation), null, null, m)); } else if (delegateAnnotation != null) { result.add(new Parameterized(null, (ParametersDelegate) delegateAnnotation, null, m)); } } cls = cls.getSuperclass(); } return result; } public WrappedParameter getWrappedParameter() { return m_wrappedParameter; } public Class getType() { if (m_method != null) { return m_method.getParameterTypes()[0]; } else { return m_field.getType(); } } public String getName() { if (m_method != null) { return m_method.getName(); } else { return m_field.getName(); } } public Object get(Object object) { try { if (m_method != null) { if (m_getter == null) { m_getter = m_method.getDeclaringClass() .getMethod("g" + m_method.getName().substring(1), new Class[0]); } return m_getter.invoke(object); } else { return m_field.get(object); } } catch (SecurityException e) { throw new ParameterException(e); } catch (NoSuchMethodException e) { // Try to find a field String name = m_method.getName(); String fieldName = Character.toLowerCase(name.charAt(3)) + name.substring(4); Object result = null; try { Field field = m_method.getDeclaringClass().getDeclaredField(fieldName); if (field != null) { field.setAccessible(true); result = field.get(object); } } catch(NoSuchFieldException ex) { // ignore } catch(IllegalAccessException ex) { // ignore } return result; } catch (IllegalArgumentException e) { throw new ParameterException(e); } catch (IllegalAccessException e) { throw new ParameterException(e); } catch (InvocationTargetException e) { throw new ParameterException(e); } } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((m_field == null) ? 0 : m_field.hashCode()); result = prime * result + ((m_method == null) ? 0 : m_method.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Parameterized other = (Parameterized) obj; if (m_field == null) { if (other.m_field != null) return false; } else if (!m_field.equals(other.m_field)) return false; if (m_method == null) { if (other.m_method != null) return false; } else if (!m_method.equals(other.m_method)) return false; return true; } public boolean isDynamicParameter(Field field) { if (m_method != null) { return m_method.getAnnotation(DynamicParameter.class) != null; } else { return m_field.getAnnotation(DynamicParameter.class) != null; } } public void set(Object object, Object value) { try { if (m_method != null) { m_method.invoke(object, value); } else { m_field.set(object, value); } } catch (IllegalArgumentException ex) { throw new ParameterException(ex); } catch (IllegalAccessException ex) { throw new ParameterException(ex); } catch (InvocationTargetException ex) { // If a ParameterException was thrown, don't wrap it into another one if (ex.getTargetException() instanceof ParameterException) { throw (ParameterException) ex.getTargetException(); } else { throw new ParameterException(ex); } } } public ParametersDelegate getDelegateAnnotation() { return m_parametersDelegate; } public Type getGenericType() { if (m_method != null) { return m_method.getGenericParameterTypes()[0]; } else { return m_field.getGenericType(); } } public Parameter getParameter() { return m_wrappedParameter.getParameter(); } /** * @return the generic type of the collection for this field, or null if not applicable. */ public Type findFieldGenericType() { if (m_method != null) { return null; } else { if (m_field.getGenericType() instanceof ParameterizedType) { ParameterizedType p = (ParameterizedType) m_field.getGenericType(); Type cls = p.getActualTypeArguments()[0]; if (cls instanceof Class) { return cls; } } } return null; } public boolean isDynamicParameter() { return m_wrappedParameter.getDynamicParameter() != null; } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/Parameters.java000066400000000000000000000041261251210532400273210ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander; import java.lang.annotation.Inherited; import java.lang.annotation.Retention; import java.lang.annotation.Target; import static java.lang.annotation.ElementType.TYPE; /** * An annotation used to specify settings for parameter parsing. * * @author cbeust */ @Retention(java.lang.annotation.RetentionPolicy.RUNTIME) @Target({ TYPE }) @Inherited public @interface Parameters { public static final String DEFAULT_OPTION_PREFIXES = "-"; /** * The name of the resource bundle to use for this class. */ String resourceBundle() default ""; /** * The character(s) that separate options. */ String separators() default " "; /** * What characters an option starts with. */ String optionPrefixes() default DEFAULT_OPTION_PREFIXES; /** * If the annotated class was added to {@link JCommander} as a command with * {@link JCommander#addCommand}, then this string will be displayed in the * description when @{link JCommander#usage} is invoked. */ String commandDescription() default ""; /** * @return the key used to find the command description in the resource bundle. */ String commandDescriptionKey() default ""; /** * An array of allowed command names. */ String[] commandNames() default {}; /** * If true, this command won't appear in the usage(). */ boolean hidden() default false; } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/ParametersDelegate.java000066400000000000000000000030511251210532400307500ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander; import java.lang.annotation.Retention; import java.lang.annotation.Target; import static java.lang.annotation.ElementType.FIELD; /** *

When applied to a field all of its child fields annotated * with {@link Parameter} will be included during arguments * parsing.

* *

Mainly useful when creating complex command based CLI interfaces, * where several commands can share a set of arguments, but using * object inheritance is not enough, due to no-multiple-inheritance * restriction. Using {@link ParametersDelegate} any number of * command sets can be shared by using composition pattern.

* *

Delegations can be chained (nested).

* * @author rodionmoiseev */ @Retention(java.lang.annotation.RetentionPolicy.RUNTIME) @Target({ FIELD }) public @interface ParametersDelegate { } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/ResourceBundle.java000066400000000000000000000022401251210532400301320ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander; import static java.lang.annotation.ElementType.TYPE; import java.lang.annotation.Retention; import java.lang.annotation.Target; /** * @deprecated use @Parameters * * @author Cedric Beust */ @Retention(java.lang.annotation.RetentionPolicy.RUNTIME) @Target({ TYPE }) public @interface ResourceBundle { /** * The name of the resource bundle to use for this class. */ String value(); } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/StringKey.java000066400000000000000000000016151251210532400271350ustar00rootroot00000000000000package com.beust.jcommander; import com.beust.jcommander.FuzzyMap.IKey; public class StringKey implements IKey { private String m_name; public StringKey(String name) { m_name = name; } @Override public String getName() { return m_name; } @Override public String toString() { return m_name; } @Override public int hashCode() { final int prime = 31; int result = 1; result = prime * result + ((m_name == null) ? 0 : m_name.hashCode()); return result; } @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; StringKey other = (StringKey) obj; if (m_name == null) { if (other.m_name != null) return false; } else if (!m_name.equals(other.m_name)) return false; return true; } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/Strings.java000066400000000000000000000002241251210532400266420ustar00rootroot00000000000000package com.beust.jcommander; public class Strings { public static boolean isStringEmpty(String s) { return s == null || "".equals(s); } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/WrappedParameter.java000066400000000000000000000063011251210532400304560ustar00rootroot00000000000000package com.beust.jcommander; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Method; /** * Encapsulates the operations common to @Parameter and @DynamicParameter */ public class WrappedParameter { private Parameter m_parameter; private DynamicParameter m_dynamicParameter; public WrappedParameter(Parameter p) { m_parameter = p; } public WrappedParameter(DynamicParameter p) { m_dynamicParameter = p; } public Parameter getParameter() { return m_parameter; } public DynamicParameter getDynamicParameter() { return m_dynamicParameter; } public int arity() { return m_parameter != null ? m_parameter.arity() : 1; } public boolean hidden() { return m_parameter != null ? m_parameter.hidden() : m_dynamicParameter.hidden(); } public boolean required() { return m_parameter != null ? m_parameter.required() : m_dynamicParameter.required(); } public boolean password() { return m_parameter != null ? m_parameter.password() : false; } public String[] names() { return m_parameter != null ? m_parameter.names() : m_dynamicParameter.names(); } public boolean variableArity() { return m_parameter != null ? m_parameter.variableArity() : false; } public Class validateWith() { return m_parameter != null ? m_parameter.validateWith() : m_dynamicParameter.validateWith(); } public Class validateValueWith() { return m_parameter != null ? m_parameter.validateValueWith() : m_dynamicParameter.validateValueWith(); } public boolean echoInput() { return m_parameter != null ? m_parameter.echoInput() : false; } public void addValue(Parameterized parameterized, Object object, Object value) { if (m_parameter != null) { parameterized.set(object, value); } else { String a = m_dynamicParameter.assignment(); String sv = value.toString(); int aInd = sv.indexOf(a); if (aInd == -1) { throw new ParameterException( "Dynamic parameter expected a value of the form a" + a + "b" + " but got:" + sv); } callPut(object, parameterized, sv.substring(0, aInd), sv.substring(aInd + 1)); } } private void callPut(Object object, Parameterized parameterized, String key, String value) { try { Method m; m = findPut(parameterized.getType()); m.invoke(parameterized.get(object), key, value); } catch (SecurityException e) { e.printStackTrace(); } catch(IllegalAccessException e) { e.printStackTrace(); } catch(InvocationTargetException e) { e.printStackTrace(); } catch (NoSuchMethodException e) { e.printStackTrace(); } } private Method findPut(Class cls) throws SecurityException, NoSuchMethodException { return cls.getMethod("put", Object.class, Object.class); } public String getAssignment() { return m_dynamicParameter != null ? m_dynamicParameter.assignment() : ""; } public boolean isHelp() { return m_parameter != null && m_parameter.help(); } public boolean isNonOverwritableForced() { return m_parameter != null && m_parameter.forceNonOverwritable(); } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/converters/000077500000000000000000000000001251210532400265425ustar00rootroot00000000000000jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/converters/BaseConverter.java000066400000000000000000000024531251210532400321530ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.converters; import com.beust.jcommander.IStringConverter; /** * Base class for converters that stores the name of the option. * * @author cbeust */ abstract public class BaseConverter implements IStringConverter { private String m_optionName; public BaseConverter(String optionName) { m_optionName = optionName; } public String getOptionName() { return m_optionName; } protected String getErrorString(String value, String to) { return "\"" + getOptionName() + "\": couldn't convert \"" + value + "\" to " + to; } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/converters/BigDecimalConverter.java000066400000000000000000000024221251210532400332550ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.converters; import com.beust.jcommander.ParameterException; import java.math.BigDecimal; /** * Converts a String to a BigDecimal. * * @author Angus Smithson */ public class BigDecimalConverter extends BaseConverter { public BigDecimalConverter(String optionName) { super(optionName); } public BigDecimal convert(String value) { try { return new BigDecimal(value); } catch (NumberFormatException nfe) { throw new ParameterException(getErrorString(value, "a BigDecimal")); } } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/converters/BooleanConverter.java000066400000000000000000000024101251210532400326510ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.converters; import com.beust.jcommander.ParameterException; /** * Converts a string to a boolean. * * @author cbeust */ public class BooleanConverter extends BaseConverter { public BooleanConverter(String optionName) { super(optionName); } public Boolean convert(String value) { if ("false".equalsIgnoreCase(value) || "true".equalsIgnoreCase(value)) { return Boolean.parseBoolean(value); } else { throw new ParameterException(getErrorString(value, "a boolean")); } } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/converters/CommaParameterSplitter.java000066400000000000000000000003771251210532400340400ustar00rootroot00000000000000package com.beust.jcommander.converters; import java.util.Arrays; import java.util.List; public class CommaParameterSplitter implements IParameterSplitter { public List split(String value) { return Arrays.asList(value.split(",")); } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/converters/DoubleConverter.java000066400000000000000000000023301251210532400325050ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.converters; import com.beust.jcommander.ParameterException; /** * Convert a string to a double. * * @author acornejo */ public class DoubleConverter extends BaseConverter { public DoubleConverter(String optionName) { super(optionName); } public Double convert(String value) { try { return Double.parseDouble(value); } catch(NumberFormatException ex) { throw new ParameterException(getErrorString(value, "a double")); } } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/converters/FileConverter.java000066400000000000000000000020261251210532400321540ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.converters; import com.beust.jcommander.IStringConverter; import java.io.File; /** * Convert a string into a file. * * @author cbeust */ public class FileConverter implements IStringConverter { public File convert(String value) { return new File(value); } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/converters/FloatConverter.java000066400000000000000000000023201251210532400323370ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.converters; import com.beust.jcommander.ParameterException; /** * Convert a string to a float. * * @author acornejo */ public class FloatConverter extends BaseConverter { public FloatConverter(String optionName) { super(optionName); } public Float convert(String value) { try { return Float.parseFloat(value); } catch(NumberFormatException ex) { throw new ParameterException(getErrorString(value, "a float")); } } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/converters/IParameterSplitter.java000066400000000000000000000004271251210532400331700ustar00rootroot00000000000000package com.beust.jcommander.converters; import java.util.List; /** * Convert a string representing several parameters (e.g. "a,b,c" or "d/e/f") into a * list of arguments ([a,b,c] and [d,e,f]). */ public interface IParameterSplitter { List split(String value); } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/converters/ISO8601DateConverter.java000066400000000000000000000030651251210532400330500ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.converters; import com.beust.jcommander.ParameterException; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Date; /** * Converts a String to a Date. * TODO Modify to work with all valid ISO 8601 date formats (currently only works with yyyy-MM-dd). * * @author Angus Smithson */ public class ISO8601DateConverter extends BaseConverter { private final static SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd"); public ISO8601DateConverter(String optionName) { super(optionName); } public Date convert(String value) { try { return DATE_FORMAT.parse(value); } catch (ParseException pe) { throw new ParameterException(getErrorString(value, String.format("an ISO-8601 formatted date (%s)", DATE_FORMAT.toPattern()))); } } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/converters/IntegerConverter.java000066400000000000000000000023351251210532400326750ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.converters; import com.beust.jcommander.ParameterException; /** * Convert a string to an integer. * * @author cbeust */ public class IntegerConverter extends BaseConverter { public IntegerConverter(String optionName) { super(optionName); } public Integer convert(String value) { try { return Integer.parseInt(value); } catch(NumberFormatException ex) { throw new ParameterException(getErrorString(value, "an integer")); } } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/converters/LongConverter.java000066400000000000000000000023071251210532400321760ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.converters; import com.beust.jcommander.ParameterException; /** * Convert a string to a long. * * @author cbeust */ public class LongConverter extends BaseConverter { public LongConverter(String optionName) { super(optionName); } public Long convert(String value) { try { return Long.parseLong(value); } catch(NumberFormatException ex) { throw new ParameterException(getErrorString(value, "a long")); } } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/converters/NoConverter.java000066400000000000000000000020551251210532400316530ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.converters; import com.beust.jcommander.IStringConverter; /** * Default value for a converter when none is specified. * * @author cbeust */ public class NoConverter implements IStringConverter { public String convert(String value) { throw new UnsupportedOperationException(); } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/converters/PathConverter.java000066400000000000000000000020741251210532400321740ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.converters; import com.beust.jcommander.IStringConverter; import java.nio.file.Path; import java.nio.file.Paths; /** * Convert a string into a path. * * @author samvv */ public class PathConverter implements IStringConverter { public Path convert(String value) { return Paths.get(value); } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/converters/StringConverter.java000066400000000000000000000017751251210532400325550ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.converters; import com.beust.jcommander.IStringConverter; /** * Default converter for strings. * * @author cbeust */ public class StringConverter implements IStringConverter { public String convert(String value) { return value; } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/converters/URIConverter.java000066400000000000000000000024301251210532400317330ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.converters; import com.beust.jcommander.ParameterException; import java.net.URI; import java.net.URISyntaxException; /** * Convert a string into a URI. * * @author samvv */ public class URIConverter extends BaseConverter { public URIConverter(String optionName) { super(optionName); } public URI convert(String value) { try { return new URI(value); } catch (URISyntaxException e) { throw new ParameterException(getErrorString(value, "a RFC 2396 and RFC 2732 compliant URI")); } } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/converters/URLConverter.java000066400000000000000000000024161251210532400317420ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.converters; import com.beust.jcommander.ParameterException; import java.net.MalformedURLException; import java.net.URL; /** * Convert a string into a URI. * * @author samvv */ public class URLConverter extends BaseConverter { public URLConverter(String optionName) { super(optionName); } public URL convert(String value) { try { return new URL(value); } catch (MalformedURLException e) { throw new ParameterException( getErrorString(value, "a RFC 2396 and RFC 2732 compliant URL")); } } }jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/defaultprovider/000077500000000000000000000000001251210532400275475ustar00rootroot00000000000000PropertyFileDefaultProvider.java000066400000000000000000000041731251210532400360040ustar00rootroot00000000000000jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/defaultprovider/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.defaultprovider; import com.beust.jcommander.IDefaultProvider; import com.beust.jcommander.ParameterException; import java.io.IOException; import java.net.URL; import java.util.Properties; /** * A default provider that reads its default values from a property file. * * @author cbeust */ public class PropertyFileDefaultProvider implements IDefaultProvider { public static final String DEFAULT_FILE_NAME = "jcommander.properties"; private Properties m_properties; public PropertyFileDefaultProvider() { init(DEFAULT_FILE_NAME); } public PropertyFileDefaultProvider(String fileName) { init(fileName); } private void init(String fileName) { try { m_properties = new Properties(); URL url = ClassLoader.getSystemResource(fileName); if (url != null) { m_properties.load(url.openStream()); } else { throw new ParameterException("Could not find property file: " + fileName + " on the class path"); } } catch (IOException e) { throw new ParameterException("Could not open property file: " + fileName); } } public String getDefaultValueFor(String optionName) { int index = 0; while (index < optionName.length() && ! Character.isLetterOrDigit(optionName.charAt(index))) { index++; } String key = optionName.substring(index); return m_properties.getProperty(key); } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/internal/000077500000000000000000000000001251210532400261645ustar00rootroot00000000000000jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/internal/Console.java000066400000000000000000000002501251210532400304260ustar00rootroot00000000000000package com.beust.jcommander.internal; public interface Console { void print(String msg); void println(String msg); char[] readPassword(boolean echoInput); } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/internal/DefaultConsole.java000066400000000000000000000014051251210532400317360ustar00rootroot00000000000000package com.beust.jcommander.internal; import com.beust.jcommander.ParameterException; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; public class DefaultConsole implements Console { public void print(String msg) { System.out.print(msg); } public void println(String msg) { System.out.println(msg); } public char[] readPassword(boolean echoInput) { try { // Do not close the readers since System.in should not be closed InputStreamReader isr = new InputStreamReader(System.in); BufferedReader in = new BufferedReader(isr); String result = in.readLine(); return result.toCharArray(); } catch (IOException e) { throw new ParameterException(e); } } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/internal/DefaultConverterFactory.java000066400000000000000000000061461251210532400336420ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.internal; import com.beust.jcommander.IStringConverter; import com.beust.jcommander.IStringConverterFactory; import com.beust.jcommander.converters.BigDecimalConverter; import com.beust.jcommander.converters.BooleanConverter; import com.beust.jcommander.converters.DoubleConverter; import com.beust.jcommander.converters.FileConverter; import com.beust.jcommander.converters.FloatConverter; import com.beust.jcommander.converters.ISO8601DateConverter; import com.beust.jcommander.converters.IntegerConverter; import com.beust.jcommander.converters.LongConverter; import com.beust.jcommander.converters.StringConverter; import com.beust.jcommander.converters.PathConverter; import com.beust.jcommander.converters.URIConverter; import com.beust.jcommander.converters.URLConverter; import java.io.File; import java.math.BigDecimal; import java.util.Date; import java.net.URI; import java.net.URL; import java.nio.file.Path; import java.util.Map; public class DefaultConverterFactory implements IStringConverterFactory { /** * A map of converters per class. */ private static Map>> m_classConverters; static { m_classConverters = Maps.newHashMap(); m_classConverters.put(String.class, StringConverter.class); m_classConverters.put(Integer.class, IntegerConverter.class); m_classConverters.put(int.class, IntegerConverter.class); m_classConverters.put(Long.class, LongConverter.class); m_classConverters.put(long.class, LongConverter.class); m_classConverters.put(Float.class, FloatConverter.class); m_classConverters.put(float.class, FloatConverter.class); m_classConverters.put(Double.class, DoubleConverter.class); m_classConverters.put(double.class, DoubleConverter.class); m_classConverters.put(Boolean.class, BooleanConverter.class); m_classConverters.put(boolean.class, BooleanConverter.class); m_classConverters.put(File.class, FileConverter.class); m_classConverters.put(BigDecimal.class, BigDecimalConverter.class); m_classConverters.put(Date.class, ISO8601DateConverter.class); m_classConverters.put(Path.class, PathConverter.class); m_classConverters.put(URI.class, URIConverter.class); m_classConverters.put(URL.class, URLConverter.class); } public Class> getConverter(Class forType) { return m_classConverters.get(forType); } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/internal/JDK6Console.java000066400000000000000000000022461251210532400310540ustar00rootroot00000000000000package com.beust.jcommander.internal; import com.beust.jcommander.ParameterException; import java.io.PrintWriter; import java.lang.reflect.Method; public class JDK6Console implements Console { private Object console; private PrintWriter writer; public JDK6Console(Object console) throws Exception { this.console = console; Method writerMethod = console.getClass().getDeclaredMethod("writer", new Class[0]); writer = (PrintWriter) writerMethod.invoke(console, new Object[0]); } public void print(String msg) { writer.print(msg); } public void println(String msg) { writer.println(msg); } public char[] readPassword(boolean echoInput) { try { writer.flush(); Method method; if (echoInput) { method = console.getClass().getDeclaredMethod("readLine", new Class[0]); return ((String) method.invoke(console, new Object[0])).toCharArray(); } else { method = console.getClass().getDeclaredMethod("readPassword", new Class[0]); return (char[]) method.invoke(console, new Object[0]); } } catch (Exception e) { throw new ParameterException(e); } } }jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/internal/Lists.java000066400000000000000000000030151251210532400301240ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.internal; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.LinkedList; import java.util.List; public class Lists { public static List newArrayList() { return new ArrayList(); } public static List newArrayList(Collection c) { return new ArrayList(c); } public static List newArrayList(K... c) { return new ArrayList(Arrays.asList(c)); } public static List newArrayList(int size) { return new ArrayList(size); } public static LinkedList newLinkedList() { return new LinkedList(); } public static LinkedList newLinkedList(Collection c) { return new LinkedList(c); } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/internal/Maps.java000066400000000000000000000024201251210532400277250ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.internal; import java.util.HashMap; import java.util.LinkedHashMap; import java.util.Map; public class Maps { public static Map newHashMap() { return new HashMap(); } public static Map newLinkedHashMap() { return new LinkedHashMap(); } public static Map newHashMap(T... parameters) { Map result = Maps.newHashMap(); for (int i = 0; i < parameters.length; i += 2) { result.put(parameters[i], parameters[i + 1]); } return result; } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/internal/Nullable.java000066400000000000000000000005311251210532400305640ustar00rootroot00000000000000package com.beust.jcommander.internal; import static java.lang.annotation.ElementType.FIELD; import static java.lang.annotation.ElementType.PARAMETER; import java.lang.annotation.Retention; import java.lang.annotation.Target; @Retention(java.lang.annotation.RetentionPolicy.RUNTIME) @Target({FIELD, PARAMETER}) public @interface Nullable { } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/internal/Sets.java000066400000000000000000000020231251210532400277420ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.internal; import java.util.HashSet; import java.util.LinkedHashSet; import java.util.Set; public class Sets { public static Set newHashSet() { return new HashSet(); } public static Set newLinkedHashSet() { return new LinkedHashSet(); } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/validators/000077500000000000000000000000001251210532400265205ustar00rootroot00000000000000jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/validators/NoValidator.java000066400000000000000000000022051251210532400316040ustar00rootroot00000000000000/** * Copyright (C) 2011 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.validators; import com.beust.jcommander.IParameterValidator; import com.beust.jcommander.ParameterException; /** * This is the default value of the validateWith attribute. * * @author Cedric Beust */ public class NoValidator implements IParameterValidator { public void validate(String parameterName, String parameterValue) throws ParameterException { } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/validators/NoValueValidator.java000066400000000000000000000022101251210532400325750ustar00rootroot00000000000000/** * Copyright (C) 2011 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.validators; import com.beust.jcommander.IValueValidator; import com.beust.jcommander.ParameterException; /** * This is the default value of the validateValueWith attribute. * * @author Cedric Beust */ public class NoValueValidator implements IValueValidator { public void validate(String parameterName, T parameterValue) throws ParameterException { } } jcommander-jcommander-1.48/src/main/java/com/beust/jcommander/validators/PositiveInteger.java000066400000000000000000000024701251210532400325060ustar00rootroot00000000000000/** * Copyright (C) 2011 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.validators; import com.beust.jcommander.IParameterValidator; import com.beust.jcommander.ParameterException; /** * A validator that makes sure the value of the parameter is a positive integer. * * @author Cedric Beust */ public class PositiveInteger implements IParameterValidator { public void validate(String name, String value) throws ParameterException { int n = Integer.parseInt(value); if (n < 0) { throw new ParameterException("Parameter " + name + " should be positive (found " + value +")"); } } } jcommander-jcommander-1.48/src/main/license/000077500000000000000000000000001251210532400210325ustar00rootroot00000000000000jcommander-jcommander-1.48/src/main/license/license-header.txt000066400000000000000000000012731251210532400244460ustar00rootroot00000000000000Copyright (C) 2010 the original author or authors. See the notice.md file distributed with this work for additional information regarding copyright ownership. 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. jcommander-jcommander-1.48/src/test/000077500000000000000000000000001251210532400174435ustar00rootroot00000000000000jcommander-jcommander-1.48/src/test/java/000077500000000000000000000000001251210532400203645ustar00rootroot00000000000000jcommander-jcommander-1.48/src/test/java/com/000077500000000000000000000000001251210532400211425ustar00rootroot00000000000000jcommander-jcommander-1.48/src/test/java/com/beust/000077500000000000000000000000001251210532400222645ustar00rootroot00000000000000jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/000077500000000000000000000000001251210532400244035ustar00rootroot00000000000000jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/ArgsRequiredWrongMain.java000066400000000000000000000001731251210532400314660ustar00rootroot00000000000000package com.beust.jcommander; public class ArgsRequiredWrongMain { @Parameter(required = true) public String[] file; }jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/ArgsValidate2.java000066400000000000000000000013371251210532400277020ustar00rootroot00000000000000package com.beust.jcommander; import com.beust.jcommander.converters.FileConverter; import java.io.File; public class ArgsValidate2 { public static class FailingValidator implements IValueValidator { public void validate(String name, File value) throws ParameterException { throw new ParameterException("Validation will always fail:" + name + " " + value); } } public static final String POSSIBLE_TEMPLATE_FILE = "mayOrMayNotExist.template"; @Parameter(names = { "-template"}, description = "The default file may or may not exist", converter = FileConverter.class, validateValueWith = FailingValidator.class ) public File template = new File(POSSIBLE_TEMPLATE_FILE); } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/CmdTest.java000066400000000000000000000056131251210532400266160ustar00rootroot00000000000000package com.beust.jcommander; import org.testng.Assert; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import java.util.Arrays; import java.util.LinkedList; import java.util.List; public class CmdTest { @Parameters(commandNames = "--cmd-one") public static class CmdOne { } @Parameters(commandNames = "--cmd-two") class CmdTwo { @Parameter List params = new java.util.LinkedList(); } public String parseArgs(boolean withDefault, String[] args) { JCommander jc = new JCommander(); jc.addCommand(new CmdOne()); jc.addCommand(new CmdTwo()); if (withDefault) { // First check if a command was given, when not prepend default // command (--cmd-two") // In version up to 1.23 JCommander throws an Exception in this // line, // which might be incorrect, at least its not reasonable if the // method // is named "WithoutValidation". jc.parseWithoutValidation(args); if (jc.getParsedCommand() == null) { LinkedList newArgs = new LinkedList(); newArgs.add("--cmd-two"); newArgs.addAll(Arrays.asList(args)); jc.parse(newArgs.toArray(new String[0])); } } else { jc.parse(args); } return jc.getParsedCommand(); } @DataProvider public Object[][] testData() { return new Object[][] { new Object[] { "--cmd-one", false, new String[] { "--cmd-one" } }, new Object[] { "--cmd-two", false, new String[] { "--cmd-two" } }, new Object[] { "--cmd-two", false, new String[] { "--cmd-two", "param1", "param2" } }, // This is the relevant test case to test default commands new Object[] { "--cmd-two", true, new String[] { "param1", "param2" } } }; } @Test(dataProvider = "testData") public void testArgsWithoutDefaultCmd(String expected, boolean requireDefault, String[] args) { if (!requireDefault) { Assert.assertEquals(parseArgs(false, args), expected); } } @Test(dataProvider = "testData", expectedExceptions = MissingCommandException.class) public void testArgsWithoutDefaultCmdFail(String expected, boolean requireDefault, String[] args) { if (requireDefault) { parseArgs(false, args); } else { throw new MissingCommandException("irrelevant test case"); } } // We do not expect a MissingCommandException! @Test(dataProvider = "testData") public void testArgsWithDefaultCmd(String expected, boolean requireDefault, String[] args) { Assert.assertEquals(parseArgs(true, args), expected); } }jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/ConverterFactoryTest.java000066400000000000000000000053461251210532400314150ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander; import com.beust.jcommander.args.ArgsConverterFactory; import com.beust.jcommander.args.ArgsMainParameter1; import com.beust.jcommander.args.ArgsMainParameter2; import com.beust.jcommander.args.IHostPorts; import org.testng.Assert; import org.testng.annotations.Test; import java.util.HashMap; import java.util.Map; /** * Test the converter factory feature. * * @author cbeust */ public class ConverterFactoryTest { private static final Map>> MAP = new HashMap() {{ put(HostPort.class, HostPortConverter.class); }}; private static final IStringConverterFactory CONVERTER_FACTORY = new IStringConverterFactory() { public Class> getConverter(Class forType) { return MAP.get(forType); } }; @Test public void parameterWithHostPortParameters() { ArgsConverterFactory a = new ArgsConverterFactory(); JCommander jc = new JCommander(a); jc.addConverterFactory(CONVERTER_FACTORY); jc.parse("-hostport", "example.com:8080"); Assert.assertEquals(a.hostPort.host, "example.com"); Assert.assertEquals(a.hostPort.port.intValue(), 8080); } /** * Test that main parameters can be used with string converters, * either with a factory or from the annotation. */ private void mainWithHostPortParameters(IStringConverterFactory f, IHostPorts a) { JCommander jc = new JCommander(a); if (f != null) jc.addConverterFactory(f); jc.parse("a.com:10", "b.com:20"); Assert.assertEquals(a.getHostPorts().get(0).host, "a.com"); Assert.assertEquals(a.getHostPorts().get(0).port.intValue(), 10); Assert.assertEquals(a.getHostPorts().get(1).host, "b.com"); Assert.assertEquals(a.getHostPorts().get(1).port.intValue(), 20); } @Test public void mainWithoutFactory() { mainWithHostPortParameters(null, new ArgsMainParameter1()); } @Test public void mainWithFactory() { mainWithHostPortParameters(CONVERTER_FACTORY, new ArgsMainParameter2()); } } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/DefaultProviderTest.java000066400000000000000000000071331251210532400312110ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander; import com.beust.jcommander.args.ArgsDefault; import com.beust.jcommander.defaultprovider.PropertyFileDefaultProvider; import org.testng.Assert; import org.testng.annotations.Test; public class DefaultProviderTest { private static final IDefaultProvider DEFAULT_PROVIDER = new IDefaultProvider() { public String getDefaultValueFor(String optionName) { return "-debug".equals(optionName) ? "false" : "42"; } }; private ArgsDefault defaultProvider(IDefaultProvider provider, String... args) { ArgsDefault a = new ArgsDefault(); JCommander jc = new JCommander(a); jc.setDefaultProvider(provider); jc.parse(args); return a; } @Test public void defaultProvider1() { ArgsDefault a = defaultProvider(DEFAULT_PROVIDER, "f"); Assert.assertEquals(a.groups, "42"); Assert.assertEquals(a.level, 42); Assert.assertEquals(a.log.intValue(), 42); } @Test public void defaultProvider2() { ArgsDefault a = defaultProvider(DEFAULT_PROVIDER, "-groups", "foo", "f"); Assert.assertEquals(a.groups, "foo"); Assert.assertEquals(a.level, 42); Assert.assertEquals(a.log.intValue(), 42); } @Test public void defaultProvider3() { ArgsDefault a = defaultProvider(DEFAULT_PROVIDER, "-groups", "foo", "-level", "13", "f"); Assert.assertEquals(a.groups, "foo"); Assert.assertEquals(a.level, 13); Assert.assertEquals(a.log.intValue(), 42); } @Test public void defaultProvider4() { ArgsDefault a = defaultProvider(DEFAULT_PROVIDER, "-log", "19", "-groups", "foo", "-level", "13", "f"); Assert.assertEquals(a.groups, "foo"); Assert.assertEquals(a.level, 13); Assert.assertEquals(a.log.intValue(), 19); } @Test public void propertyFileDefaultProvider1() { ArgsDefault a = defaultProvider(new PropertyFileDefaultProvider(), "f"); Assert.assertEquals(a.groups, "unit"); Assert.assertEquals(a.level, 17); Assert.assertEquals(a.log.intValue(), 18); } @Test public void propertyFileDefaultProvider2() { ArgsDefault a = defaultProvider(new PropertyFileDefaultProvider(), "-groups", "foo", "f"); Assert.assertEquals(a.groups, "foo"); Assert.assertEquals(a.level, 17); Assert.assertEquals(a.log.intValue(), 18); } @Test public void propertyFileDefaultProvider3() { ArgsDefault a = defaultProvider(new PropertyFileDefaultProvider(), "-groups", "foo", "-level", "13", "f"); Assert.assertEquals(a.groups, "foo"); Assert.assertEquals(a.level, 13); Assert.assertEquals(a.log.intValue(), 18); } @Test public void propertyFileDefaultProvider4() { ArgsDefault a = defaultProvider(new PropertyFileDefaultProvider(), "-log", "19", "-groups", "foo", "-level", "13", "f"); Assert.assertEquals(a.groups, "foo"); Assert.assertEquals(a.level, 13); Assert.assertEquals(a.log.intValue(), 19); } } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/DefaultValueTest.java000066400000000000000000000075641251210532400305030ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander; import com.beust.jcommander.internal.Lists; import com.beust.jcommander.internal.Sets; import org.testng.Assert; import org.testng.annotations.Test; import java.util.Iterator; import java.util.List; import java.util.Set; /** * Test behaviour of default parameter values * @author rodionmoiseev */ public class DefaultValueTest { @Test public void emptyDefaultValueForListParameterStaysEmptyIfNotAssignedOrIsSetOtherwise() { MyOptsWithEmptyDefaults opts = new MyOptsWithEmptyDefaults(); JCommander cmd = new JCommander(opts); cmd.parse(new String[]{"-a", "anotherValue"}); Assert.assertEquals(opts.list.size(), 1); Assert.assertEquals(opts.list.get(0), "anotherValue"); Assert.assertEquals(opts.set.size(), 0); } @Test public void defaultValueForListParametersGetsOverwrittenWithSpecifiedValueOrStaysAsDefaultOtherwise() { MyOptsWithDefaultValues opts = new MyOptsWithDefaultValues(); JCommander cmd = new JCommander(opts); cmd.parse(new String[]{"-a", "anotherValue"}); Assert.assertEquals(opts.list.size(), 1); Assert.assertEquals(opts.list.get(0), "anotherValue"); Assert.assertEquals(opts.set.size(), 1); Assert.assertEquals(opts.set.iterator().next(), "defaultValue"); } @Test public void anyNumberOfValuesCanBeSetToListParameters_ForEmptyDefaults(){ MyOptsWithEmptyDefaults opts = new MyOptsWithEmptyDefaults(); testSettingMultipleValuesToListTypeParameters(opts); } @Test public void anyNumberOfValuesCanBeSetToListParameters_ForNonEmptyDefaults(){ MyOptsWithDefaultValues opts = new MyOptsWithDefaultValues(); testSettingMultipleValuesToListTypeParameters(opts); } private void testSettingMultipleValuesToListTypeParameters(MyOpts opts) { JCommander cmd = new JCommander(opts); cmd.parse(new String[]{"-a", "anotherValue", "-a", "anotherValue2", "-b", "anotherValue3", "-b", "anotherValue4"}); Assert.assertEquals(opts.list.size(), 2); Assert.assertEquals(opts.list.get(0), "anotherValue"); Assert.assertEquals(opts.list.get(1), "anotherValue2"); Assert.assertEquals(opts.set.size(), 2); Iterator arg2it = opts.set.iterator(); Assert.assertEquals(arg2it.next(), "anotherValue3"); Assert.assertEquals(arg2it.next(), "anotherValue4"); } public static class MyOpts { @Parameter(names = "-a") public List list; @Parameter(names = "-b") public Set set; } public static final class MyOptsWithDefaultValues extends MyOpts { public MyOptsWithDefaultValues(){ this.list = singletonList("defaultValue"); this.set = singletonSet("defaultValue"); } } public static final class MyOptsWithEmptyDefaults extends MyOpts { public MyOptsWithEmptyDefaults(){ this.list = Lists.newArrayList(); this.set = Sets.newLinkedHashSet(); } } public static final List singletonList(String value) { List list = Lists.newArrayList(); list.add(value); return list; } public static final Set singletonSet(String value){ Set set = Sets.newLinkedHashSet(); set.add(value); return set; } } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/FinderTest.java000066400000000000000000000053541251210532400273240ustar00rootroot00000000000000package com.beust.jcommander; import com.beust.jcommander.JCommanderTest.BaseArgs; import com.beust.jcommander.JCommanderTest.ConfigureArgs; import org.testng.Assert; import org.testng.annotations.Test; @Test public class FinderTest { public void caseInsensitiveOption() { class Arg { @Parameter(names = { "-p", "--param" }) private String param; } Arg a = new Arg(); JCommander jc = new JCommander(a); jc.setCaseSensitiveOptions(false); jc.parse(new String[] { "--PARAM", "foo" }); Assert.assertEquals(a.param, "foo"); } public void caseInsensitiveCommand() { BaseArgs a = new BaseArgs(); ConfigureArgs conf = new ConfigureArgs(); JCommander jc = new JCommander(a); jc.addCommand(conf); jc.setCaseSensitiveOptions(false); // jc.setCaseSensitiveCommands(false); jc.parse("--CONFIGURE"); String command = jc.getParsedCommand(); Assert.assertEquals(command, "--configure"); } public void abbreviatedOptions() { class Arg { @Parameter(names = { "-p", "--param" }) private String param; } Arg a = new Arg(); JCommander jc = new JCommander(a); jc.setAllowAbbreviatedOptions(true); jc.parse(new String[] { "--par", "foo" }); Assert.assertEquals(a.param, "foo"); } public void abbreviatedOptionsCaseInsensitive() { class Arg { @Parameter(names = { "-p", "--param" }) private String param; } Arg a = new Arg(); JCommander jc = new JCommander(a); jc.setCaseSensitiveOptions(false); jc.setAllowAbbreviatedOptions(true); jc.parse(new String[] { "--PAR", "foo" }); Assert.assertEquals(a.param, "foo"); } @Test(expectedExceptions = ParameterException.class) public void ambiguousAbbreviatedOptions() { class Arg { @Parameter(names = { "--param" }) private String param; @Parameter(names = { "--parb" }) private String parb; } Arg a = new Arg(); JCommander jc = new JCommander(a); jc.setAllowAbbreviatedOptions(true); jc.parse(new String[] { "--par", "foo" }); Assert.assertEquals(a.param, "foo"); } @Test(expectedExceptions = ParameterException.class) public void ambiguousAbbreviatedOptionsCaseInsensitive() { class Arg { @Parameter(names = { "--param" }) private String param; @Parameter(names = { "--parb" }) private String parb; } Arg a = new Arg(); JCommander jc = new JCommander(a); jc.setCaseSensitiveOptions(false); jc.setAllowAbbreviatedOptions(true); jc.parse(new String[] { "--PAR", "foo" }); Assert.assertEquals(a.param, "foo"); } @Test(enabled = false) public static void main(String[] args) throws Exception { new FinderTest().ambiguousAbbreviatedOptionsCaseInsensitive(); } } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/HostPort.java000066400000000000000000000016471251210532400270400ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander; public class HostPort { public String host; public Integer port; @Override public String toString() { return "[Host:" + host + " port:" + port + "]"; } } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/HostPortConverter.java000066400000000000000000000020251251210532400307170ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander; public class HostPortConverter implements IStringConverter { public HostPort convert(String value) { HostPort result = new HostPort(); String[] s = value.split(":"); result.host = s[0]; result.port = Integer.parseInt(s[1]); return result; } }jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/JCommanderTest.java000066400000000000000000001052511251210532400301310ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander; import java.io.ByteArrayInputStream; import java.io.File; import java.io.FileWriter; import java.io.IOException; import java.io.InputStream; import java.math.BigDecimal; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Arrays; import java.util.EnumSet; import java.util.Iterator; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.ResourceBundle; import java.util.TreeSet; import org.testng.Assert; import org.testng.annotations.DataProvider; import org.testng.annotations.Test; import com.beust.jcommander.args.AlternateNamesForListArgs; import com.beust.jcommander.args.Args1; import com.beust.jcommander.args.Args1Setter; import com.beust.jcommander.args.Args2; import com.beust.jcommander.args.ArgsArityString; import com.beust.jcommander.args.ArgsBooleanArity; import com.beust.jcommander.args.ArgsBooleanArity0; import com.beust.jcommander.args.ArgsConverter; import com.beust.jcommander.args.ArgsEnum; import com.beust.jcommander.args.ArgsEnum.ChoiceType; import com.beust.jcommander.args.ArgsEquals; import com.beust.jcommander.args.ArgsHelp; import com.beust.jcommander.args.ArgsI18N1; import com.beust.jcommander.args.ArgsI18N2; import com.beust.jcommander.args.ArgsI18N2New; import com.beust.jcommander.args.ArgsInherited; import com.beust.jcommander.args.ArgsList; import com.beust.jcommander.args.ArgsMainParameter1; import com.beust.jcommander.args.ArgsMaster; import com.beust.jcommander.args.ArgsMultipleUnparsed; import com.beust.jcommander.args.ArgsOutOfMemory; import com.beust.jcommander.args.ArgsPrivate; import com.beust.jcommander.args.ArgsRequired; import com.beust.jcommander.args.ArgsSlave; import com.beust.jcommander.args.ArgsSlaveBogus; import com.beust.jcommander.args.ArgsValidate1; import com.beust.jcommander.args.ArgsWithSet; import com.beust.jcommander.args.Arity1; import com.beust.jcommander.args.SeparatorColon; import com.beust.jcommander.args.SeparatorEqual; import com.beust.jcommander.args.SeparatorMixed; import com.beust.jcommander.args.SlashSeparator; import com.beust.jcommander.args.VariableArity; import com.beust.jcommander.command.CommandAdd; import com.beust.jcommander.command.CommandCommit; import com.beust.jcommander.command.CommandMain; import com.beust.jcommander.internal.Lists; import com.beust.jcommander.internal.Maps; @Test public class JCommanderTest { public void simpleArgs() throws ParseException { Args1 args = new Args1(); String[] argv = { "-debug", "-log", "2", "-float", "1.2", "-double", "1.3", "-bigdecimal", "1.4", "-date", "2011-10-26", "-groups", "unit", "a", "b", "c" }; new JCommander(args, argv); Assert.assertTrue(args.debug); Assert.assertEquals(args.verbose.intValue(), 2); Assert.assertEquals(args.groups, "unit"); Assert.assertEquals(args.parameters, Arrays.asList("a", "b", "c")); Assert.assertEquals(args.floa, 1.2f, 0.1f); Assert.assertEquals(args.doub, 1.3f, 0.1f); Assert.assertEquals(args.bigd, new BigDecimal("1.4")); Assert.assertEquals(args.date, new SimpleDateFormat("yyyy-MM-dd").parse("2011-10-26")); } @DataProvider public Object[][] alternateNamesListArgs() { return new Object[][] { new String[][] {new String[] {"--servers", "1", "-s", "2", "--servers", "3"}}, new String[][] {new String[] {"-s", "1", "-s", "2", "--servers", "3"}}, new String[][] {new String[] {"--servers", "1", "--servers", "2", "-s", "3"}}, new String[][] {new String[] {"-s", "1", "--servers", "2", "-s", "3"}}, new String[][] {new String[] {"-s", "1", "-s", "2", "--servers", "3"}}, }; } /** * Confirm that List parameters with alternate names return the correct * List regardless of how the arguments are specified */ @Test(dataProvider = "alternateNamesListArgs") public void testAlternateNamesForListArguments(String[] argv) { AlternateNamesForListArgs args = new AlternateNamesForListArgs(); new JCommander(args, argv); Assert.assertEquals(args.serverNames.size(), 3); Assert.assertEquals(args.serverNames.get(0), argv[1]); Assert.assertEquals(args.serverNames.get(1), argv[3]); Assert.assertEquals(args.serverNames.get(2), argv[5]); } /** * Make sure that if there are args with multiple names (e.g. "-log" and "-verbose"), * the usage will only display it once. */ public void repeatedArgs() { Args1 args = new Args1(); String[] argv = { "-log", "2" }; JCommander jc = new JCommander(args, argv); Assert.assertEquals(jc.getParameters().size(), 8); } /** * Not specifying a required option should throw an exception. */ @Test(expectedExceptions = ParameterException.class) public void requiredFields1Fail() { Args1 args = new Args1(); String[] argv = { "-debug" }; new JCommander(args, argv); } /** * Getting the description of a nonexistent command should throw an exception. */ @Test(expectedExceptions = ParameterException.class) public void nonexistentCommandShouldThrow() { String[] argv = { }; JCommander jc = new JCommander(new Object(), argv); jc.getCommandDescription("foo"); } /** * Required options with multiple names should work with all names. */ private void multipleNames(String option) { Args1 args = new Args1(); String[] argv = { option, "2" }; new JCommander(args, argv); Assert.assertEquals(args.verbose.intValue(), 2); } public void multipleNames1() { multipleNames("-log"); } public void multipleNames2() { multipleNames("-verbose"); } private void i18n1(String bundleName, Locale locale, String expectedString) { ResourceBundle bundle = locale != null ? ResourceBundle.getBundle(bundleName, locale) : null; ArgsI18N1 i18n = new ArgsI18N1(); String[] argv = { "-host", "localhost" }; JCommander jc = new JCommander(i18n, bundle, argv); // jc.usage(); ParameterDescription pd = jc.getParameters().get(0); Assert.assertEquals(pd.getDescription(), expectedString); } public void i18nNoLocale() { i18n1("MessageBundle", null, "Host"); } public void i18nUsLocale() { i18n1("MessageBundle", new Locale("en", "US"), "Host"); } public void i18nFrLocale() { i18n1("MessageBundle", new Locale("fr", "FR"), "Hôte"); } private void i18n2(Object i18n) { String[] argv = { "-host", "localhost" }; Locale.setDefault(new Locale("fr", "FR")); JCommander jc = new JCommander(i18n, argv); ParameterDescription pd = jc.getParameters().get(0); Assert.assertEquals(pd.getDescription(), "Hôte"); } public void i18nWithResourceAnnotation() { i18n2(new ArgsI18N2()); } public void i18nWithResourceAnnotationNew() { i18n2(new ArgsI18N2New()); } public void noParseConstructor() { JCommander jCommander = new JCommander(new ArgsMainParameter1()); jCommander.usage(new StringBuilder()); // Before fix, this parse would throw an exception, because it calls createDescription, which // was already called by usage(), and can only be called once. jCommander.parse(); } /** * Test a use case where there are required parameters, but you still want * to interrogate the options which are specified. */ public void usageWithRequiredArgsAndResourceBundle() { ArgsHelp argsHelp = new ArgsHelp(); JCommander jc = new JCommander(new Object[]{argsHelp, new ArgsRequired()}, java.util.ResourceBundle.getBundle("MessageBundle")); // Should be able to display usage without triggering validation jc.usage(new StringBuilder()); try { jc.parse("-h"); Assert.fail("Should have thrown a required parameter exception"); } catch (ParameterException e) { Assert.assertTrue(e.getMessage().contains("are required")); } Assert.assertTrue(argsHelp.help); } public void multiObjects() { ArgsMaster m = new ArgsMaster(); ArgsSlave s = new ArgsSlave(); String[] argv = { "-master", "master", "-slave", "slave" }; new JCommander(new Object[] { m , s }, argv); Assert.assertEquals(m.master, "master"); Assert.assertEquals(s.slave, "slave"); } @Test(expectedExceptions = ParameterException.class) public void multiObjectsWithDuplicatesFail() { ArgsMaster m = new ArgsMaster(); ArgsSlave s = new ArgsSlaveBogus(); String[] argv = { "-master", "master", "-slave", "slave" }; new JCommander(new Object[] { m , s }, argv); } public void arityString() { ArgsArityString args = new ArgsArityString(); String[] argv = { "-pairs", "pair0", "pair1", "rest" }; new JCommander(args, argv); Assert.assertEquals(args.pairs.size(), 2); Assert.assertEquals(args.pairs.get(0), "pair0"); Assert.assertEquals(args.pairs.get(1), "pair1"); Assert.assertEquals(args.rest.size(), 1); Assert.assertEquals(args.rest.get(0), "rest"); } @Test(expectedExceptions = ParameterException.class) public void arity2Fail() { ArgsArityString args = new ArgsArityString(); String[] argv = { "-pairs", "pair0" }; new JCommander(args, argv); } @Test(expectedExceptions = ParameterException.class) public void multipleUnparsedFail() { ArgsMultipleUnparsed args = new ArgsMultipleUnparsed(); String[] argv = { }; new JCommander(args, argv); } public void privateArgs() { ArgsPrivate args = new ArgsPrivate(); new JCommander(args, "-verbose", "3"); Assert.assertEquals(args.getVerbose().intValue(), 3); } public void converterArgs() { ArgsConverter args = new ArgsConverter(); String fileName = "a"; new JCommander(args, "-file", "/tmp/" + fileName, "-listStrings", "Tuesday,Thursday", "-listInts", "-1,8", "-listBigDecimals", "-11.52,100.12"); Assert.assertEquals(args.file.getName(), fileName); Assert.assertEquals(args.listStrings.size(), 2); Assert.assertEquals(args.listStrings.get(0), "Tuesday"); Assert.assertEquals(args.listStrings.get(1), "Thursday"); Assert.assertEquals(args.listInts.size(), 2); Assert.assertEquals(args.listInts.get(0).intValue(), -1); Assert.assertEquals(args.listInts.get(1).intValue(), 8); Assert.assertEquals(args.listBigDecimals.size(), 2); Assert.assertEquals(args.listBigDecimals.get(0), new BigDecimal("-11.52")); Assert.assertEquals(args.listBigDecimals.get(1), new BigDecimal("100.12")); } private void argsBoolean1(String[] params, Boolean expected) { ArgsBooleanArity args = new ArgsBooleanArity(); new JCommander(args, params); Assert.assertEquals(args.debug, expected); } private void argsBoolean0(String[] params, Boolean expected) { ArgsBooleanArity0 args = new ArgsBooleanArity0(); new JCommander(args, params); Assert.assertEquals(args.debug, expected); } public void booleanArity1() { argsBoolean1(new String[] {}, Boolean.FALSE); argsBoolean1(new String[] { "-debug", "true" }, Boolean.TRUE); } public void booleanArity0() { argsBoolean0(new String[] {}, Boolean.FALSE); argsBoolean0(new String[] { "-debug"}, Boolean.TRUE); } @Test(expectedExceptions = ParameterException.class) public void badParameterShouldThrowParameter1Exception() { Args1 args = new Args1(); String[] argv = { "-log", "foo" }; new JCommander(args, argv); } @Test(expectedExceptions = ParameterException.class) public void badParameterShouldThrowParameter2Exception() { Args1 args = new Args1(); String[] argv = { "-long", "foo" }; new JCommander(args, argv); } public void listParameters() { Args2 a = new Args2(); String[] argv = {"-log", "2", "-groups", "unit", "a", "b", "c", "-host", "host2"}; new JCommander(a, argv); Assert.assertEquals(a.verbose.intValue(), 2); Assert.assertEquals(a.groups, "unit"); Assert.assertEquals(a.hosts, Arrays.asList("host2")); Assert.assertEquals(a.parameters, Arrays.asList("a", "b", "c")); } public void separatorEqual() { SeparatorEqual s = new SeparatorEqual(); String[] argv = { "-log=3", "--longoption=10" }; new JCommander(s, argv); Assert.assertEquals(s.log.intValue(), 3); Assert.assertEquals(s.longOption.intValue(), 10); } public void separatorColon() { SeparatorColon s = new SeparatorColon(); String[] argv = { "-verbose:true" }; new JCommander(s, argv); Assert.assertTrue(s.verbose); } public void separatorBoth() { SeparatorColon s = new SeparatorColon(); SeparatorEqual s2 = new SeparatorEqual(); String[] argv = { "-verbose:true", "-log=3" }; new JCommander(new Object[] { s, s2 }, argv); Assert.assertTrue(s.verbose); Assert.assertEquals(s2.log.intValue(), 3); } public void separatorMixed1() { SeparatorMixed s = new SeparatorMixed(); String[] argv = { "-long:1", "-level=42" }; new JCommander(s, argv); Assert.assertEquals(s.l.longValue(), 1l); Assert.assertEquals(s.level.intValue(), 42); } public void slashParameters() { SlashSeparator a = new SlashSeparator(); String[] argv = { "/verbose", "/file", "/tmp/a" }; new JCommander(a, argv); Assert.assertTrue(a.verbose); Assert.assertEquals(a.file, "/tmp/a"); } public void inheritance() { ArgsInherited args = new ArgsInherited(); String[] argv = { "-log", "3", "-child", "2" }; new JCommander(args, argv); Assert.assertEquals(args.child.intValue(), 2); Assert.assertEquals(args.log.intValue(), 3); } public void negativeNumber() { Args1 a = new Args1(); String[] argv = { "-verbose", "-3" }; new JCommander(a, argv); Assert.assertEquals(a.verbose.intValue(), -3); } @Test(expectedExceptions = ParameterException.class) public void requiredMainParameters() { ArgsRequired a = new ArgsRequired(); String[] argv = {}; new JCommander(a, argv); } public void usageShouldNotChange() { JCommander jc = new JCommander(new Args1(), new String[]{"-log", "1"}); StringBuilder sb = new StringBuilder(); jc.usage(sb); String expected = sb.toString(); jc = new JCommander(new Args1(), new String[]{"-debug", "-log", "2", "-long", "5"}); sb = new StringBuilder(); jc.usage(sb); String actual = sb.toString(); Assert.assertEquals(actual, expected); } private void verifyCommandOrdering(String[] commandNames, Object[] commands) { CommandMain cm = new CommandMain(); JCommander jc = new JCommander(cm); for (int i = 0; i < commands.length; i++) { jc.addCommand(commandNames[i], commands[i]); } Map c = jc.getCommands(); Assert.assertEquals(c.size(), commands.length); Iterator it = c.keySet().iterator(); for (int i = 0; i < commands.length; i++) { Assert.assertEquals(it.next(), commandNames[i]); } } public void commandsShouldBeShownInOrderOfInsertion() { verifyCommandOrdering(new String[] { "add", "commit" }, new Object[] { new CommandAdd(), new CommandCommit() }); verifyCommandOrdering(new String[] { "commit", "add" }, new Object[] { new CommandCommit(), new CommandAdd() }); } @DataProvider public static Object[][] f() { return new Integer[][] { new Integer[] { 3, 5, 1 }, new Integer[] { 3, 8, 1 }, new Integer[] { 3, 12, 2 }, new Integer[] { 8, 12, 2 }, new Integer[] { 9, 10, 1 }, }; } @Test(expectedExceptions = ParameterException.class) public void arity1Fail() { final Arity1 arguments = new Arity1(); final JCommander jCommander = new JCommander(arguments); final String[] commands = { "-inspect" }; jCommander.parse(commands); } public void arity1Success1() { final Arity1 arguments = new Arity1(); final JCommander jCommander = new JCommander(arguments); final String[] commands = { "-inspect", "true" }; jCommander.parse(commands); Assert.assertTrue(arguments.inspect); } public void arity1Success2() { final Arity1 arguments = new Arity1(); final JCommander jCommander = new JCommander(arguments); final String[] commands = { "-inspect", "false" }; jCommander.parse(commands); Assert.assertFalse(arguments.inspect); } @Parameters(commandDescription = "Help for the given commands.") public static class Help { public static final String NAME = "help"; @Parameter(description = "List of commands.") public List commands=new ArrayList(); } @Test(expectedExceptions = ParameterException.class, description = "Verify that the main parameter's type is checked to be a List") public void wrongMainTypeShouldThrow() { JCommander jc = new JCommander(new ArgsRequiredWrongMain()); jc.parse(new String[] { "f1", "f2" }); } @Test(description = "This used to run out of memory") public void oom() { JCommander jc = new JCommander(new ArgsOutOfMemory()); jc.usage(new StringBuilder()); } @Test public void getParametersShouldNotNpe() { JCommander jc = new JCommander(new Args1()); List parameters = jc.getParameters(); } public void validationShouldWork1() { ArgsValidate1 a = new ArgsValidate1(); JCommander jc = new JCommander(a); jc.parse(new String[] { "-age", "2 "}); Assert.assertEquals(a.age, new Integer(2)); } @Test(expectedExceptions = ParameterException.class) public void validationShouldWorkWithDefaultValues() { ArgsValidate2 a = new ArgsValidate2(); new JCommander(a); } @Test(expectedExceptions = ParameterException.class) public void validationShouldWork2() { ArgsValidate1 a = new ArgsValidate1(); JCommander jc = new JCommander(a); jc.parse(new String[] { "-age", "-2 "}); } public void atFileCanContainEmptyLines() throws IOException { File f = File.createTempFile("JCommander", null); f.deleteOnExit(); FileWriter fw = new FileWriter(f); fw.write("-log\n"); fw.write("\n"); fw.write("2\n"); fw.close(); new JCommander(new Args1(), "@" + f.getAbsolutePath()); } public void handleEqualSigns() { ArgsEquals a = new ArgsEquals(); JCommander jc = new JCommander(a); jc.parse(new String[] { "-args=a=b,b=c" }); Assert.assertEquals(a.args, "a=b,b=c"); } @SuppressWarnings("serial") public void handleSets() { ArgsWithSet a = new ArgsWithSet(); new JCommander(a, new String[] { "-s", "3,1,2" }); Assert.assertEquals(a.set, new TreeSet() {{ add(1); add(2); add(3); }}); } private static final List V = Arrays.asList("a", "b", "c", "d"); @DataProvider public Object[][] variable() { return new Object[][] { new Object[] { 0, V.subList(0, 0), V }, new Object[] { 1, V.subList(0, 1), V.subList(1, 4) }, new Object[] { 2, V.subList(0, 2), V.subList(2, 4) }, new Object[] { 3, V.subList(0, 3), V.subList(3, 4) }, new Object[] { 4, V.subList(0, 4), V.subList(4, 4) }, }; } @Test(dataProvider = "variable") public void variableArity(int count, List var, List main) { VariableArity va = new VariableArity(count); new JCommander(va).parse("-variable", "a", "b", "c", "d"); Assert.assertEquals(var, va.var); Assert.assertEquals(main, va.main); } public void enumArgs() { ArgsEnum args = new ArgsEnum(); String[] argv = { "-choice", "ONE", "-choices", "ONE", "Two" }; JCommander jc = new JCommander(args, argv); Assert.assertEquals(args.choice, ArgsEnum.ChoiceType.ONE); List expected = Arrays.asList(ChoiceType.ONE, ChoiceType.Two); Assert.assertEquals(expected, args.choices); Assert.assertEquals(jc.getParameters().get(0).getDescription(), "Options: " + EnumSet.allOf((Class) ArgsEnum.ChoiceType.class)); } public void enumArgsCaseInsensitive() { ArgsEnum args = new ArgsEnum(); String[] argv = { "-choice", "one"}; JCommander jc = new JCommander(args, argv); Assert.assertEquals(args.choice, ArgsEnum.ChoiceType.ONE); } @Test(expectedExceptions = ParameterException.class) public void enumArgsFail() { ArgsEnum args = new ArgsEnum(); String[] argv = { "-choice", "A" }; new JCommander(args, argv); } public void testListAndSplitters() { ArgsList al = new ArgsList(); JCommander j = new JCommander(al); j.parse("-groups", "a,b", "-ints", "41,42", "-hp", "localhost:1000;example.com:1001", "-hp2", "localhost:1000,example.com:1001", "-uppercase", "ab,cd"); Assert.assertEquals(al.groups.get(0), "a"); Assert.assertEquals(al.groups.get(1), "b"); Assert.assertEquals(al.ints.get(0).intValue(), 41); Assert.assertEquals(al.ints.get(1).intValue(), 42); Assert.assertEquals(al.hostPorts.get(0).host, "localhost"); Assert.assertEquals(al.hostPorts.get(0).port.intValue(), 1000); Assert.assertEquals(al.hostPorts.get(1).host, "example.com"); Assert.assertEquals(al.hostPorts.get(1).port.intValue(), 1001); Assert.assertEquals(al.hp2.get(1).host, "example.com"); Assert.assertEquals(al.hp2.get(1).port.intValue(), 1001); Assert.assertEquals(al.uppercase.get(0), "AB"); Assert.assertEquals(al.uppercase.get(1), "CD"); } @Test(expectedExceptions = ParameterException.class) public void shouldThrowIfUnknownOption() { class A { @Parameter(names = "-long") public long l; } A a = new A(); new JCommander(a).parse("-lon", "32"); } @Test(expectedExceptions = ParameterException.class) public void mainParameterShouldBeValidate() { class V implements IParameterValidator { @Override public void validate(String name, String value) throws ParameterException { Assert.assertEquals("a", value); } } class A { @Parameter(validateWith = V.class) public List m; } A a = new A(); new JCommander(a).parse("b"); } @Parameters(commandNames = { "--configure" }) public static class ConfigureArgs { } public static class BaseArgs { @Parameter(names = { "-h", "--help" }, description = "Show this help screen") private boolean help = false; @Parameter(names = { "--version", "-version" }, description = "Show the program version") private boolean version; } public void commandsWithSamePrefixAsOptionsShouldWork() { BaseArgs a = new BaseArgs(); ConfigureArgs conf = new ConfigureArgs(); JCommander jc = new JCommander(a); jc.addCommand(conf); jc.parse("--configure"); } // Tests: // required unparsed parameter @Test(enabled = false, description = "For some reason, this test still asks the password on stdin") public void askedRequiredPassword() { class A { @Parameter(names = { "--password", "-p" }, description = "Private key password", password = true, required = true) public String password; @Parameter(names = { "--port", "-o" }, description = "Port to bind server to", required = true) public int port; } A a = new A(); InputStream stdin = System.in; try { System.setIn(new ByteArrayInputStream("password".getBytes())); new JCommander(a,new String[]{"--port", "7","--password"}); Assert.assertEquals(a.port, 7); Assert.assertEquals(a.password, "password"); } finally { System.setIn(stdin); } } public void dynamicParameters() { class Command { @DynamicParameter(names = {"-P"}, description = "Additional command parameters") private Map params = Maps.newHashMap(); } JCommander commander = new JCommander(); Command c = new Command(); commander.addCommand("command", c); commander.parse(new String[] { "command", "-Pparam='name=value'" }); Assert.assertEquals(c.params.get("param"), "'name=value'"); } public void exeParser() { class Params { @Parameter( names= "-i") private String inputFile; } String args[] = { "-i", "" }; Params p = new Params(); new JCommander(p, args); } public void multiVariableArityList() { class Params { @Parameter(names = "-paramA", description = "ParamA", variableArity = true) private List paramA = Lists.newArrayList(); @Parameter(names = "-paramB", description = "ParamB", variableArity = true) private List paramB = Lists.newArrayList(); } { String args[] = { "-paramA", "a1", "a2", "-paramB", "b1", "b2", "b3" }; Params p = new Params(); new JCommander(p, args).parse(); Assert.assertEquals(p.paramA, Arrays.asList(new String[] { "a1", "a2" })); Assert.assertEquals(p.paramB, Arrays.asList(new String[] { "b1", "b2", "b3" })); } { String args[] = { "-paramA", "a1", "a2", "-paramB", "b1", "-paramA", "a3" }; Params p = new Params(); new JCommander(p, args).parse(); Assert.assertEquals(p.paramA, Arrays.asList(new String[] { "a1", "a2", "a3" })); Assert.assertEquals(p.paramB, Arrays.asList(new String[] { "b1" })); } } @Test(enabled = false, description = "Need to double check that the command description is i18n'ed in the usage") public void commandKey() { @Parameters(resourceBundle = "MessageBundle", commandDescriptionKey = "command") class Args { @Parameter(names="-myoption", descriptionKey="myoption") private boolean option; } JCommander j = new JCommander(); Args a = new Args(); j.addCommand("comm", a); j.usage(); } public void tmp() { class A { @Parameter(names = "-b") public String b; } new JCommander(new A()).parse(""); } public void unknownOptionWithDifferentPrefix() { @Parameters(optionPrefixes = "/") class SlashSeparator { @Parameter(names = "/verbose") public boolean verbose = false; @Parameter(names = "/file") public String file; } SlashSeparator ss = new SlashSeparator(); try { new JCommander(ss).parse("/notAParam"); } catch (ParameterException ex) { boolean result = ex.getMessage().contains("Unknown option"); Assert.assertTrue(result); } } public void equalSeparator() { @Parameters(separators = "=", commandDescription = "My command") class MyClass { @Parameter(names = { "-p", "--param" }, required = true, description = "param desc...") private String param; } MyClass c = new MyClass(); String expected = "\"hello\"world"; new JCommander(c).parse("--param=" + expected); Assert.assertEquals(expected, c.param); } public void simpleArgsSetter() throws ParseException { Args1Setter args = new Args1Setter(); String[] argv = { "-debug", "-log", "2", "-float", "1.2", "-double", "1.3", "-bigdecimal", "1.4", "-date", "2011-10-26", "-groups", "unit", "a", "b", "c" }; new JCommander(args, argv); Assert.assertTrue(args.debug); Assert.assertEquals(args.verbose.intValue(), 2); Assert.assertEquals(args.groups, "unit"); Assert.assertEquals(args.parameters, Arrays.asList("a", "b", "c")); Assert.assertEquals(args.floa, 1.2f, 0.1f); Assert.assertEquals(args.doub, 1.3f, 0.1f); Assert.assertEquals(args.bigd, new BigDecimal("1.4")); Assert.assertEquals(args.date, new SimpleDateFormat("yyyy-MM-dd").parse("2011-10-26")); } public void verifyHelp() { class Arg { @Parameter(names = "--help", help = true) public boolean help = false; @Parameter(names = "file", required = true) public String file; } Arg arg = new Arg(); String[] argv = { "--help" }; new JCommander(arg, argv); Assert.assertTrue(arg.help); } public void helpTest() { class Arg { @Parameter(names = { "?", "-help", "--help" }, description = "Shows help", help = true) private boolean help = false; } Arg arg = new Arg(); JCommander jc = new JCommander(arg); jc.parse(new String[] { "-help" }); // System.out.println("helpTest:" + arg.help); } @Test(enabled = false, description = "Should only be enable once multiple parameters are allowed") public void duplicateParameterNames() { class ArgBase { @Parameter(names = { "-host" }) protected String host; } class Arg1 extends ArgBase {} Arg1 arg1 = new Arg1(); class Arg2 extends ArgBase {} Arg2 arg2 = new Arg2(); JCommander jc = new JCommander(new Object[] { arg1, arg2}); jc.parse(new String[] { "-host", "foo" }); Assert.assertEquals(arg1.host, "foo"); Assert.assertEquals(arg2.host, "foo"); } public void parameterWithOneDoubleQuote() { @Parameters(separators = "=") class Arg { @Parameter(names = { "-p", "--param" }) private String param; } JCommander jc = new JCommander(new MyClass()); jc.parse("-p=\""); } public void emptyStringAsDefault() { class Arg { @Parameter(names = "-x") String s = ""; } Arg a = new Arg(); StringBuilder sb = new StringBuilder(); new JCommander(a).usage(sb); Assert.assertTrue(sb.toString().contains("Default: ")); } public void spaces() { class Arg { @Parameter(names = "-rule", description = "rule") private List rules = new ArrayList(); } Arg a = new Arg(); new JCommander(a, "-rule", "some test"); Assert.assertEquals(a.rules, Arrays.asList("some test")); } static class V2 implements IParameterValidator2 { final static List names = Lists.newArrayList(); static boolean validateCalled = false; @Override public void validate(String name, String value) throws ParameterException { validateCalled = true; } @Override public void validate(String name, String value, ParameterDescription pd) throws ParameterException { names.addAll(Arrays.asList(pd.getParameter().names())); } } public void validator2() { class Arg { @Parameter(names = { "-h", "--host" }, validateWith = V2.class) String host; } Arg a = new Arg(); V2.names.clear(); V2.validateCalled = false; JCommander jc = new JCommander(a, "--host", "h"); jc.setAcceptUnknownOptions(true); Assert.assertEquals(V2.names, Arrays.asList(new String[] { "-h", "--host" })); Assert.assertTrue(V2.validateCalled); } public void usageCommandsUnderUsage() { class Arg { } @Parameters(commandDescription = "command a") class ArgCommandA { @Parameter(description = "command a parameters") List parameters; } @Parameters(commandDescription = "command b") class ArgCommandB { @Parameter(description = "command b parameters") List parameters; } Arg a = new Arg(); JCommander c = new JCommander(a); c.addCommand("a", new ArgCommandA()); c.addCommand("b", new ArgCommandB()); StringBuilder sb = new StringBuilder(); c.usage(sb); Assert.assertTrue(sb.toString().contains("[command options]\n Commands:")); } public void usageWithEmpytLine() { class Arg { } @Parameters(commandDescription = "command a") class ArgCommandA { @Parameter(description = "command a parameters") List parameters; } @Parameters(commandDescription = "command b") class ArgCommandB { @Parameter(description = "command b parameters") List parameters; } Arg a = new Arg(); JCommander c = new JCommander(a); c.addCommand("a", new ArgCommandA()); c.addCommand("b", new ArgCommandB()); StringBuilder sb = new StringBuilder(); c.usage(sb); Assert.assertTrue(sb.toString().contains("command a parameters\n\n b")); } public void partialValidation() { class Arg { @Parameter(names = { "-h", "--host" }) String host; } Arg a = new Arg(); JCommander jc = new JCommander(); jc.setAcceptUnknownOptions(true); jc.addObject(a); jc.parse("-a", "foo", "-h", "host"); Assert.assertEquals(a.host, "host"); Assert.assertEquals(jc.getUnknownOptions(), Lists.newArrayList("-a", "foo")); } /** * GITHUB-137. */ public void listArgShouldBeCleared() { class Args { @Parameter(description = "[endpoint]") public List endpoint = Lists.newArrayList("prod"); } Args a = new Args(); new JCommander(a, new String[] { "dev" }); Assert.assertEquals(a.endpoint, Lists.newArrayList("dev")); } public void dashDashParameter() { class Arguments { @Parameter(names = { "-name" }) public String name; @Parameter public List mainParameters; } Arguments a = new Arguments(); new JCommander(a, new String[] { "-name", "theName", "--", "param1", "param2"} ); Assert.assertEquals(a.name, "theName"); Assert.assertEquals(a.mainParameters.size(), 2); Assert.assertEquals(a.mainParameters.get(0), "param1"); Assert.assertEquals(a.mainParameters.get(1), "param2"); } public void dashDashParameter2() { class Arguments { @Parameter(names = { "-name" }) public String name; @Parameter public List mainParameters; } Arguments a = new Arguments(); new JCommander(a, new String[] { "param1", "param2", "--", "param3", "-name", "theName"} ); Assert.assertNull(a.name); Assert.assertEquals(a.mainParameters.size(), 5); Assert.assertEquals(a.mainParameters.get(0), "param1"); Assert.assertEquals(a.mainParameters.get(1), "param2"); Assert.assertEquals(a.mainParameters.get(2), "param3"); Assert.assertEquals(a.mainParameters.get(3), "-name"); Assert.assertEquals(a.mainParameters.get(4), "theName"); } @Test(enabled = false) public static void main(String[] args) throws Exception { new JCommanderTest().enumArgsFail(); // class A { // @Parameter(names = "-short", required = true) // List parameters; // // @Parameter(names = "-long", required = true) // public long l; // } // A a = new A(); // new JCommander(a).parse(); // System.out.println(a.l); // System.out.println(a.parameters); // ArgsList al = new ArgsList(); // JCommander j = new JCommander(al); // j.setColumnSize(40); // j.usage(); // new JCommanderTest().testListAndSplitters(); // new JCommanderTest().converterArgs(); } // Tests: // required unparsed parameter } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/MethodSetterTest.java000066400000000000000000000051551251210532400305230ustar00rootroot00000000000000package com.beust.jcommander; import org.testng.Assert; import org.testng.annotations.Test; import java.util.List; /** * Tests for @Parameter on top of methods. */ @Test public class MethodSetterTest { public void arityStringsSetter() { class ArgsArityStringSetter { @Parameter(names = "-pairs", arity = 2, description = "Pairs") public void setPairs(List pairs) { this.pairs = pairs; } public List getPairs() { return this.pairs; } public List pairs; @Parameter(description = "Rest") public void setRest(List rest) { this.rest = rest; } // public List getRest() { // return this.rest; // } public List rest; } ArgsArityStringSetter args = new ArgsArityStringSetter(); String[] argv = { "-pairs", "pair0", "pair1", "rest" }; new JCommander(args, argv); Assert.assertEquals(args.pairs.size(), 2); Assert.assertEquals(args.pairs.get(0), "pair0"); Assert.assertEquals(args.pairs.get(1), "pair1"); Assert.assertEquals(args.rest.size(), 1); Assert.assertEquals(args.rest.get(0), "rest"); } public void setterThatThrows() { class Arg { @Parameter(names = "--host") public void setHost(String host) { throw new ParameterException("Illegal host"); } } boolean passed = false; try { new JCommander(new Arg(), new String[] { "--host", "host" }); } catch(ParameterException ex) { Assert.assertEquals(ex.getCause(), null); passed = true; } Assert.assertTrue(passed, "Should have thrown an exception"); } public void getterReturningNonString() { class Arg { private Integer port; @Parameter(names = "--port") public void setPort(String port) { this.port = Integer.parseInt(port); } public Integer getPort() { return port; } } Arg arg = new Arg(); new JCommander(arg, new String[] { "--port", "42" }); Assert.assertEquals(arg.port, new Integer(42)); } public void noGetterButWithField() { class Arg { private Integer port = 43; @Parameter(names = "--port") public void setPort(String port) { this.port = Integer.parseInt(port); } } Arg arg = new Arg(); JCommander jc = new JCommander(arg, new String[] { "--port", "42" }); ParameterDescription pd = jc.getParameters().get(0); Assert.assertEquals(pd.getDefault(), 43); } @Test(enabled = false) public static void main(String[] args) throws Exception { new MethodSetterTest().noGetterButWithField(); } } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/MyClass.java000066400000000000000000000010751251210532400266240ustar00rootroot00000000000000package com.beust.jcommander; import org.testng.Assert; @Parameters(separators = "=") public class MyClass { @Parameter(names = { "-p", "--param" }, validateWith = MyValidator.class) private String param; public static void main(String[] args) { JCommander jCommander = new JCommander(new MyClass()); jCommander.parse("--param=value"); } public static class MyValidator implements IParameterValidator { @Override public void validate(String name, String value) throws ParameterException { Assert.assertEquals(value, "\""); } } }jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/ParametersDelegateTest.java000066400000000000000000000143171251210532400316520ustar00rootroot00000000000000package com.beust.jcommander; import org.testng.Assert; import org.testng.annotations.Test; import java.util.ArrayList; import java.util.List; /** * @author rodionmoiseev */ public class ParametersDelegateTest { @Test public void delegatingEmptyClassHasNoEffect() { class EmptyDelegate { public String nonParamString = "a"; } class MainParams { @Parameter(names = "-a") public boolean isA; @Parameter(names = {"-b", "--long-b"}) public String bValue = ""; @ParametersDelegate public EmptyDelegate delegate = new EmptyDelegate(); } MainParams p = new MainParams(); JCommander cmd = new JCommander(p); cmd.parse("-a", "-b", "someValue"); Assert.assertTrue(p.isA); Assert.assertEquals(p.bValue, "someValue"); Assert.assertEquals(p.delegate.nonParamString, "a"); } @Test public void delegatingSetsFieldsOnBothMainParamsAndTheDelegatedParams() { class ComplexDelegate { @Parameter(names = "-c") public boolean isC; @Parameter(names = {"-d", "--long-d"}) public Integer d; } class MainParams { @Parameter(names = "-a") public boolean isA; @Parameter(names = {"-b", "--long-b"}) public String bValue = ""; @ParametersDelegate public ComplexDelegate delegate = new ComplexDelegate(); } MainParams p = new MainParams(); JCommander cmd = new JCommander(p); cmd.parse("-c", "--long-d", "123", "--long-b", "bValue"); Assert.assertFalse(p.isA); Assert.assertEquals(p.bValue, "bValue"); Assert.assertTrue(p.delegate.isC); Assert.assertEquals(p.delegate.d, Integer.valueOf(123)); } @Test public void combinedAndNestedDelegates() { abstract class LeafAbstractDelegate { abstract float getFloat(); } class LeafDelegate { @Parameter(names = "--list") public List list = new ArrayList() {{ add("value1"); add("value2"); }}; @Parameter(names = "--bool") public boolean bool; } class NestedDelegate1 { @ParametersDelegate public LeafDelegate leafDelegate = new LeafDelegate(); @Parameter(names = {"-d", "--long-d"}) public Integer d; } class NestedDelegate2 { @Parameter(names = "-c") public boolean isC; @ParametersDelegate public NestedDelegate1 nestedDelegate1 = new NestedDelegate1(); @ParametersDelegate public LeafAbstractDelegate anonymousDelegate = new LeafAbstractDelegate() { @Parameter(names = "--anon-float") public float anon = 999f; @Override float getFloat() { return anon; } }; } class MainParams { @Parameter(names = "-a") public boolean isA; @Parameter(names = {"-b", "--long-b"}) public String bValue = ""; @ParametersDelegate public NestedDelegate2 nestedDelegate2 = new NestedDelegate2(); } MainParams p = new MainParams(); JCommander cmd = new JCommander(p); cmd.parse("--anon-float 1.2 -d 234 --list a --list b -a".split(" ")); Assert.assertEquals(p.nestedDelegate2.anonymousDelegate.getFloat(), 1.2f); Assert.assertEquals(p.nestedDelegate2.nestedDelegate1.leafDelegate.list, new ArrayList() {{ add("a"); add("b"); }}); Assert.assertFalse(p.nestedDelegate2.nestedDelegate1.leafDelegate.bool); Assert.assertEquals(p.nestedDelegate2.nestedDelegate1.d, Integer.valueOf(234)); Assert.assertFalse(p.nestedDelegate2.isC); Assert.assertTrue(p.isA); Assert.assertEquals(p.bValue, ""); } @Test public void commandTest() { class Delegate { @Parameter(names = "-a") public String a = "b"; } class Command { @ParametersDelegate public Delegate delegate = new Delegate(); } Command c = new Command(); JCommander cmd = new JCommander(); cmd.addCommand("command", c); cmd.parse("command -a a".split(" ")); Assert.assertEquals(c.delegate.a, "a"); } @Test public void mainParametersTest() { class Delegate { @Parameter public List mainParams = new ArrayList(); } class Command { @ParametersDelegate public Delegate delegate = new Delegate(); } Command c = new Command(); JCommander cmd = new JCommander(); cmd.addCommand("command", c); cmd.parse("command main params".split(" ")); Assert.assertEquals(c.delegate.mainParams, new ArrayList() {{ add("main"); add("params"); }}); } @Test(expectedExceptions = ParameterException.class, expectedExceptionsMessageRegExp = ".*delegate.*null.*") public void nullDelegatesAreProhibited() { class ComplexDelegate { } class MainParams { @ParametersDelegate public ComplexDelegate delegate; } MainParams p = new MainParams(); JCommander cmd = new JCommander(p); cmd.parse(); } @Test(expectedExceptions = ParameterException.class, expectedExceptionsMessageRegExp = ".*-a.*") public void duplicateDelegateThrowDuplicateOptionException() { class Delegate { @Parameter(names = "-a") public String a; } class MainParams { @ParametersDelegate public Delegate d1 = new Delegate(); @ParametersDelegate public Delegate d2 = new Delegate(); } MainParams p = new MainParams(); JCommander cmd = new JCommander(p); cmd.parse("-a value".split(" ")); } @Test(expectedExceptions = ParameterException.class, expectedExceptionsMessageRegExp = "Only one.*is allowed.*") public void duplicateMainParametersAreNotAllowed() { class Delegate1 { @Parameter public List mainParams1 = new ArrayList(); } class Delegate2 { @Parameter public List mainParams2 = new ArrayList(); } class Command { @ParametersDelegate public Delegate1 delegate1 = new Delegate1(); @ParametersDelegate public Delegate2 delegate2 = new Delegate2(); } Command c = new Command(); JCommander cmd = new JCommander(); cmd.addCommand("command", c); cmd.parse("command main params".split(" ")); } public static void main(String[] args) { new ParametersDelegateTest().commandTest(); } } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/PositiveIntegerTest.java000066400000000000000000000036131251210532400312310ustar00rootroot00000000000000package com.beust.jcommander; import com.beust.jcommander.validators.PositiveInteger; import org.testng.annotations.Test; public class PositiveIntegerTest { @Test public void validateTest() { class Arg { @Parameter(names = { "-p", "--port" }, description = "Shows help", validateWith = PositiveInteger.class) private int port = 0; } Arg arg = new Arg(); JCommander jc = new JCommander(arg); jc.parse(new String[] { "-p", "8080" }); } @Test(expectedExceptions = ParameterException.class) public void validateTest2() { class Arg { @Parameter(names = { "-p", "--port" }, description = "Shows help", validateWith = PositiveInteger.class) private int port = 0; } Arg arg = new Arg(); JCommander jc = new JCommander(arg); jc.parse(new String[] { "-p", "" }); } @Test(expectedExceptions = ParameterException.class) public void validateTest3() { class Arg { @Parameter(names = { "-p", "--port" }, description = "Shows help", validateWith = PositiveInteger.class) private int port = 0; } Arg arg = new Arg(); JCommander jc = new JCommander(arg); jc.parse(new String[] { "-p", "-1" }); } @Test(expectedExceptions = ParameterException.class) public void validateTest4() { class Arg { @Parameter(names = { "-p", "--port" }, description = "Port Number", validateWith = PositiveInteger.class) private int port = 0; } Arg arg = new Arg(); JCommander jc = new JCommander(arg); jc.parse(new String[] { "-p", "abc" }); } @Test(expectedExceptions = ParameterException.class) public void validateTest5() { class Arg { @Parameter(names = { "-p", "--port" }, description = "Port Number", validateWith = PositiveInteger.class) private int port = 0; } Arg arg = new Arg(); JCommander jc = new JCommander(arg); jc.parse(new String[] { "--port", " " }); } }jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/SetConverter.java000066400000000000000000000006271251210532400276760ustar00rootroot00000000000000package com.beust.jcommander; import java.util.SortedSet; import java.util.TreeSet; public class SetConverter implements IStringConverter> { public SortedSet convert(String value) { SortedSet set = new TreeSet(); String[] values = value.split(","); for (String num : values) { set.add(Integer.parseInt(num)); } return set; } } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/ValidatePropertiesWhenParsingTest.java000066400000000000000000000016771251210532400340750ustar00rootroot00000000000000package com.beust.jcommander; import org.testng.annotations.Test; public class ValidatePropertiesWhenParsingTest { @Test public void f() throws Exception { JCommander cmd = new JCommander(); cmd.addCommand("a", new A()); // cmd.addCommand("b", new B()); cmd.parse(new String[] { "a", "-path", "myPathToHappiness" }); } public static class MyPathValidator implements IParameterValidator { public void validate(String name, String value) throws ParameterException { throw new RuntimeException("I shouldn't be called for command A!"); } } @Parameters public static class A { @Parameter(names = "-path") private String path = "W"; } @Parameters public static class B { @Parameter(names = "-path", validateWith = MyPathValidator.class) private String path = "W"; } public static void main(String[] args) throws Exception { new ValidatePropertiesWhenParsingTest().f(); } }jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/VariableArityTest.java000066400000000000000000000045411251210532400306500ustar00rootroot00000000000000package com.beust.jcommander; import org.testng.Assert; import org.testng.annotations.Test; import java.util.Arrays; import java.util.LinkedList; import java.util.List; public class VariableArityTest { public static class ModelGenerationConfig { @Parameter(names = { "-m", "--matrixData" }, variableArity = true, description = "File containing a list of instances and their runtimes on various configurations", required = false) public List modelMatrixFile = new LinkedList(); @Parameter(names = { "-f", "--featureData" }, variableArity = true, description = "File containing a list of instances and their corresponding features", required = true) public List featureFile = new LinkedList(); @Parameter(names = { "-c", "--configData" }, variableArity = true, description = "File containing a list of configuration parameter values") public List configFile = new LinkedList(); @Parameter(names = { "-o", "--outputFile" }, description = "File to output the resulting data to. Defaults to ./matrix-generation.zip", required = false) public String outputFile = "matrix-generation.zip"; @Parameter(names = { "--seed" }, description = "Seed used for PRNG [0 means don't use a Seed]") public long seed = 0; public void print() { System.out.println("modelMatrixFile: " + modelMatrixFile); System.out.println("featureData: " + featureFile); System.out.println("configFile: " + configFile); System.out.println("output: " + outputFile); System.out.println("seed: " + seed); } } @Test public void verifyVariableArity() { String input = "-m foo --seed 1024 -c foo -o foo -f foo "; String[] split = input.split("\\s+"); ModelGenerationConfig config = new ModelGenerationConfig(); JCommander com = new JCommander(config); com.setProgramName("modelgen"); com.parse(split); // config.print(); Assert.assertNotEquals(config.seed, 0); Assert.assertEquals(config.modelMatrixFile, Arrays.asList(new String[] { "foo" })); Assert.assertEquals(config.featureFile, Arrays.asList(new String[] { "foo" })); Assert.assertEquals(config.seed, 1024); Assert.assertEquals(config.outputFile, "foo"); } public static void main(String[] args) { new VariableArityTest().verifyVariableArity(); } }jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/000077500000000000000000000000001251210532400253375ustar00rootroot00000000000000jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/AlternateNamesForListArgs.java000066400000000000000000000021221251210532400332220ustar00rootroot00000000000000/* * Copyright (C) 2014 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; import com.beust.jcommander.internal.Lists; import java.util.List; /** * * @author Andy Law */ public class AlternateNamesForListArgs { @Parameter(names = {"-s", "--servers"}, description = "blah") public List serverNames = Lists.newLinkedList(); } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/Args1.java000066400000000000000000000034171251210532400271640ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import java.math.BigDecimal; import java.util.List; import java.util.Date; import org.testng.collections.Lists; import com.beust.jcommander.Parameter; public class Args1 { @Parameter public List parameters = Lists.newArrayList(); @Parameter(names = { "-log", "-verbose" }, description = "Level of verbosity", required = true) public Integer verbose = 1; @Parameter(names = "-groups", description = "Comma-separated list of group names to be run") public String groups; @Parameter(names = "-debug", description = "Debug mode") public boolean debug = false; @Parameter(names = "-long", description = "A long number") public long l; @Parameter(names = "-double", description = "A double number") public double doub; @Parameter(names = "-float", description = "A float number") public float floa; @Parameter(names = "-bigdecimal", description = "A BigDecimal number") public BigDecimal bigd; @Parameter(names = "-date", description = "An ISO 8601 formatted date.") public Date date; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/Args1Setter.java000066400000000000000000000045501251210532400303520ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; import com.beust.jcommander.internal.Lists; import java.math.BigDecimal; import java.util.Date; import java.util.List; public class Args1Setter { @Parameter public void setParameters(List p) { parameters = p; } public List getParameters() { return this.parameters; } public List parameters = Lists.newArrayList(); @Parameter(names = { "-log", "-verbose" }, description = "Level of verbosity", required = true) public void setVerbose(Integer v) { verbose = v; } public Integer verbose = 1; @Parameter(names = "-groups", description = "Comma-separated list of group names to be run") public void setGroups(String g) { groups = g; } public String groups; @Parameter(names = "-debug", description = "Debug mode") public void setDebug(boolean d) { debug = d; } public boolean debug = false; @Parameter(names = "-long", description = "A long number") public void setLong(long ll) { l = ll; } public long l; @Parameter(names = "-double", description = "A double number") public void setDouble(double d) { doub = d; } public double doub; @Parameter(names = "-float", description = "A float number") public void setFloat(float f) { floa = f; } public float floa; @Parameter(names = "-bigdecimal", description = "A BigDecimal number") public void setBigDecimal(BigDecimal bd) { bigd = bd; } public BigDecimal bigd; @Parameter(names = "-date", description = "An ISO 8601 formatted date.") public void setDate(Date d) { date = d; } public Date date; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/Args2.java000066400000000000000000000026461251210532400271700ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; import com.beust.jcommander.internal.Lists; import java.util.ArrayList; import java.util.List; public class Args2 { @Parameter(description = "List of parameters") public List parameters = Lists.newArrayList(); @Parameter(names = {"-log", "-verbose"}, description = "Level of verbosity") public Integer verbose = 1; @Parameter(names = "-groups", description = "Comma-separated list of group names to be run") public String groups; @Parameter(names = "-debug", description = "Debug mode") public boolean debug = false; @Parameter(names = "-host", description = "The host") public List hosts = new ArrayList(); } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsArityInteger.java000066400000000000000000000020741251210532400314300ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; import java.util.List; /** * Test parameter arity. * * @author cbeust */ public class ArgsArityInteger { @Parameter(names = "-pairs", arity = 2, description = "Pairs") public List pairs; @Parameter(description = "Rest") public List rest; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsArityString.java000066400000000000000000000020721251210532400312770ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; import java.util.List; /** * Test parameter arity. * * @author cbeust */ public class ArgsArityString { @Parameter(names = "-pairs", arity = 2, description = "Pairs") public List pairs; @Parameter(description = "Rest") public List rest; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsBooleanArity.java000066400000000000000000000016271251210532400314150ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; public class ArgsBooleanArity { @Parameter(names = "-debug", arity = 1) public Boolean debug = false; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsBooleanArity0.java000066400000000000000000000016301251210532400314670ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; public class ArgsBooleanArity0 { @Parameter(names = "-debug", arity = 0) public Boolean debug = false; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsConverter.java000066400000000000000000000033441251210532400307720ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; import com.beust.jcommander.converters.FileConverter; import com.beust.jcommander.converters.PathConverter; import com.beust.jcommander.converters.URIConverter; import com.beust.jcommander.converters.URLConverter; import java.io.File; import java.math.BigDecimal; import java.net.URI; import java.net.URL; import java.nio.file.Path; import java.util.List; public class ArgsConverter { @Parameter(names = "-file", converter = FileConverter.class) public File file; @Parameter(names = "-url", converter = URLConverter.class) public URL url; @Parameter(names = "-uri", converter = URIConverter.class) public URI uri; @Parameter(names = "-path", converter = PathConverter.class) public Path path; @Parameter(names = "-listStrings") public List listStrings; @Parameter(names = "-listInts") public List listInts; @Parameter(names = "-listBigDecimals") public List listBigDecimals; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsConverterFactory.java000066400000000000000000000016661251210532400323270ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.HostPort; import com.beust.jcommander.Parameter; public class ArgsConverterFactory { @Parameter(names = "-hostport") public HostPort hostPort; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsDefault.java000066400000000000000000000025211251210532400304030ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; import org.testng.collections.Lists; import java.util.List; public class ArgsDefault { @Parameter public List parameters = Lists.newArrayList(); @Parameter(names = "-log", description = "Level of verbosity") public Integer log = 1; @Parameter(names = "-groups", description = "Comma-separated list of group names to be run") public String groups; @Parameter(names = "-debug", description = "Debug mode") public boolean debug = false; @Parameter(names = "-level", description = "A long number") public long level; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsEnum.java000066400000000000000000000031361251210532400277260ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import java.util.ArrayList; import java.util.EnumSet; import java.util.List; import org.testng.Assert; import com.beust.jcommander.JCommander; import com.beust.jcommander.Parameter; /** * Test enums. * * @author Adrian Muraru */ public class ArgsEnum { public enum ChoiceType { ONE, Two, THREE }; @Parameter(names = "-choice") public ChoiceType choice = ChoiceType.ONE; @Parameter(names = "-choices", variableArity = true) public List choices = new ArrayList(); public static void main(String[] args1) { ArgsEnum args = new ArgsEnum(); String[] argv = { "-choice", "ONE"}; JCommander jc = new JCommander(args, argv); jc.usage(); Assert.assertEquals(jc.getParameters().get(0).getDescription(), "Options: " + EnumSet.allOf((Class) ArgsEnum.ChoiceType.class)); } } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsEquals.java000066400000000000000000000003431251210532400302510ustar00rootroot00000000000000package com.beust.jcommander.args; import com.beust.jcommander.Parameter; import com.beust.jcommander.Parameters; @Parameters(separators = "=") public class ArgsEquals { @Parameter(names = "-args") public String args; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsHelp.java000066400000000000000000000017511251210532400277130ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; /** * Test a help option which overrides other options and option validations */ public class ArgsHelp { @Parameter(names = "-h", description = "Display help") public boolean help; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsI18N1.java000066400000000000000000000016471251210532400275670ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; public class ArgsI18N1 { @Parameter(names = "-host", description = "Host", descriptionKey = "host") String hostName; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsI18N2.java000066400000000000000000000020251251210532400275570ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; import com.beust.jcommander.ResourceBundle; @SuppressWarnings("deprecation") @ResourceBundle("MessageBundle") public class ArgsI18N2 { @Parameter(names = "-host", description = "Host", descriptionKey = "host") String hostName; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsI18N2New.java000066400000000000000000000021261251210532400302330ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; import com.beust.jcommander.Parameters; import java.util.List; @Parameters(resourceBundle = "MessageBundle") public class ArgsI18N2New { @Parameter(names = "-host", description = "Host", descriptionKey = "host") String hostName; @Parameter(descriptionKey = "files") List files; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsInherited.java000066400000000000000000000017001251210532400307300ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; public class ArgsInherited extends ArgsDefault { @Parameter(names = "-child", description = "Child parameter") public Integer child = 1; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsList.java000066400000000000000000000026061251210532400277360ustar00rootroot00000000000000package com.beust.jcommander.args; import com.beust.jcommander.HostPort; import com.beust.jcommander.HostPortConverter; import com.beust.jcommander.IStringConverter; import com.beust.jcommander.Parameter; import com.beust.jcommander.converters.IParameterSplitter; import org.testng.collections.Lists; import java.util.Arrays; import java.util.List; public class ArgsList { @Parameter(names = "-groups", description = "Comma-separated list of group names to be run") public List groups; @Parameter(names = "-ints") public List ints; @Parameter(names = "-hp", converter = HostPortConverter.class, splitter = SemiColonSplitter.class) public List hostPorts; @Parameter(names = "-hp2", converter = HostPortConverter.class) public List hp2; @Parameter(names = "-uppercase", listConverter = UppercaseConverter.class) public List uppercase; public static class UppercaseConverter implements IStringConverter> { public List convert(String value) { List result = Lists.newArrayList(); String[] s = value.split(","); for (String p : s) { result.add(p.toUpperCase()); } return result; } } public static class SemiColonSplitter implements IParameterSplitter { public List split(String value) { return Arrays.asList(value.split(";")); } } } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsLongDescription.java000066400000000000000000000017521251210532400321270ustar00rootroot00000000000000package com.beust.jcommander.args; import com.beust.jcommander.Parameter; public class ArgsLongDescription { @Parameter(names = "--classpath", description = "The classpath. This is a very long " + "description in order to test the line wrapping. Let's see how this works." + "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor" + " incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis " + "nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.") public String classpath = "/tmp"; @Parameter(names = { "-c", "--convention" }, description = "The convention", required = true) public String convention = "Java"; @Parameter(names = { "-d", "--destination" }, description = "The destination to go to") public String destination; @Parameter(names = "--configure", description = "How to configure") public String configure; @Parameter(names = "--filespec") public String filespec; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsMainParameter1.java000066400000000000000000000022561251210532400316320ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.HostPort; import com.beust.jcommander.Parameter; import org.testng.collections.Lists; import java.util.List; /** * A class with main parameter that is not a List * * @author cbeust */ public class ArgsMainParameter1 implements IHostPorts { @Parameter public List parameters = Lists.newArrayList(); public List getHostPorts() { return parameters; } } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsMainParameter2.java000066400000000000000000000024021251210532400316240ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.HostPort; import com.beust.jcommander.HostPortConverter; import com.beust.jcommander.Parameter; import org.testng.collections.Lists; import java.util.List; /** * A class with main parameter that is not a List * * @author cbeust */ public class ArgsMainParameter2 implements IHostPorts { @Parameter(converter = HostPortConverter.class) public List parameters = Lists.newArrayList(); public List getHostPorts() { return parameters; } } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsMaster.java000066400000000000000000000017211251210532400302530ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; /** * Test multi-object parsing, along with ArgsSlave. * * @author cbeust */ public class ArgsMaster { @Parameter(names = "-master") public String master; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsMultipleUnparsed.java000066400000000000000000000021071251210532400323140ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; /** * Error case if multiple unparsed (without a names attribute) arguments are defined. * * @author cbeust */ public class ArgsMultipleUnparsed { @Parameter(description = "Bogus1") public String unparsed1; @Parameter(description = "Bogus2") public String unparsed2; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsOutOfMemory.java000066400000000000000000000006671251210532400312550ustar00rootroot00000000000000package com.beust.jcommander.args; import com.beust.jcommander.Parameter; public class ArgsOutOfMemory { @Parameter(names = { "-p", "--pattern" }, description = "pattern used by 'tail'. See http://logback.qos.ch/manual/layouts.html#ClassicPatternLayout and http://logback.qos.ch/manual/layouts.html#AccessPatternLayout") public String pattern; @Parameter(names = "-q", description = "Filler arg") public String filler; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsPassword.java000066400000000000000000000016731251210532400306300ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; public class ArgsPassword { @Parameter(names = "-password", description = "Connection password", password = true) public String password; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsPrivate.java000066400000000000000000000017011251210532400304300ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; public class ArgsPrivate { @Parameter(names = "-verbose") private Integer verbose = 1; public Integer getVerbose() { return verbose; } } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsRequired.java000066400000000000000000000020051251210532400305740ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; import com.beust.jcommander.internal.Lists; import java.util.List; public class ArgsRequired { @Parameter(description = "List of files", required = true) public List parameters = Lists.newArrayList(); } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsSlave.java000066400000000000000000000017161251210532400300760ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; /** * Test multi-object parsing, along with ArgsSlave. * * @author cbeust */ public class ArgsSlave { @Parameter(names = "-slave") public String slave; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsSlaveBogus.java000066400000000000000000000017471251210532400311020ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; /** * Same as ArgsMaster class, should cause an error. * * @author cbeust */ public class ArgsSlaveBogus extends ArgsSlave { @Parameter(names = "-master") public String master; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsValidate1.java000066400000000000000000000003751251210532400306360ustar00rootroot00000000000000package com.beust.jcommander.args; import com.beust.jcommander.Parameter; import com.beust.jcommander.validators.PositiveInteger; public class ArgsValidate1 { @Parameter(names = "-age", validateWith = PositiveInteger.class) public Integer age; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/ArgsWithSet.java000066400000000000000000000004131251210532400304040ustar00rootroot00000000000000package com.beust.jcommander.args; import com.beust.jcommander.Parameter; import com.beust.jcommander.SetConverter; import java.util.SortedSet; public class ArgsWithSet { @Parameter(names = "-s", converter = SetConverter.class) public SortedSet set; }jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/Arity1.java000066400000000000000000000003161251210532400273530ustar00rootroot00000000000000package com.beust.jcommander.args; import com.beust.jcommander.Parameter; public class Arity1 { @Parameter(arity = 1, names = "-inspect", description = "", required = false) public boolean inspect; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/CommandLineArgs.java000066400000000000000000000104041251210532400312040ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; import com.beust.jcommander.internal.Lists; import java.util.List; public class CommandLineArgs { @Parameter(description = "The XML suite files to run") public List suiteFiles = Lists.newArrayList(); @Parameter(names = { "-log", "-verbose" }, description = "Level of verbosity") public Integer verbose; @Parameter(names = "-groups", description = "Comma-separated list of group names to be run") public String groups; @Parameter(names = "-excludedgroups", description ="Comma-separated list of group names to be " + "run") public String excludedGroups; @Parameter(names = "-d", description ="Output directory") public String outputDirectory; @Parameter(names = "-junit", description ="JUnit mode") public Boolean junit = Boolean.FALSE; @Parameter(names = "-listener", description = "List of .class files or list of class names" + " implementing ITestListener or ISuiteListener") public String listener; @Parameter(names = "-methodselectors", description = "List of .class files or list of class " + "names implementing IMethodSelector") public String methodSelectors; @Parameter(names = "-objectfactory", description = "List of .class files or list of class " + "names implementing ITestRunnerFactory") public String objectFactory; @Parameter(names = "-parallel", description = "Parallel mode (methods, tests or classes)") public String parallelMode; @Parameter(names = "-configfailurepolicy", description = "Configuration failure policy (skip or continue)") public String configFailurePolicy; @Parameter(names = "-threadcount", description = "Number of threads to use when running tests " + "in parallel") public Integer threadCount; @Parameter(names = "-dataproviderthreadcount", description = "Number of threads to use when " + "running data providers") public Integer dataProviderThreadCount; @Parameter(names = "-suitename", description = "Default name of test suite, if not specified " + "in suite definition file or source code") public String suiteName; @Parameter(names = "-testname", description = "Default name of test, if not specified in suite" + "definition file or source code") public String testName; @Parameter(names = "-reporter", description = "Extended configuration for custom report listener") public String reporter; /** * Used as map key for the complete list of report listeners provided with the above argument */ @Parameter(names = "-reporterslist") public String reportersList; @Parameter(names = "-usedefaultlisteners", description = "Whether to use the default listeners") public String useDefaultListeners = "true"; @Parameter(names = "-skipfailedinvocationcounts") public Boolean skipFailedInvocationCounts; @Parameter(names = "-testclass", description = "The list of test classes") public String testClass; @Parameter(names = "-testnames", description = "The list of test names to run") public String testNames; @Parameter(names = "-testjar", description = "") public String testJar; @Parameter(names = "-testRunFactory", description = "") public String testRunFactory; @Parameter(names = "-port", description = "The port") public Integer port; @Parameter(names = "-host", description = "The host") public String host; @Parameter(names = "-master", description ="Host where the master is") public String master; @Parameter(names = "-slave", description ="Host where the slave is") public String slave; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/CommandLineArgs2.java000066400000000000000000000055451251210532400313000ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; import com.beust.jcommander.converters.FileConverter; import java.io.File; import java.util.List; public class CommandLineArgs2 { @Parameter(description = "list of files") List list; @Parameter(names = { "-v", "--verbose" }, description = "print verbose log messages.", arity = 1) public boolean verbose = false; @Parameter(names = { "-h", "--help" }, description = "show this help.") public boolean showHelp = false; @Parameter(names = { "-F", "--flush-preferences" }, description = "flush gui preferences.") public boolean flushPreferences = false; @Parameter(names = { "-L", "--flush-licensed" }, description = "flush licensed.") public boolean flushLicensed = false; @Parameter(names = { "-I", "--index-file" }, description = "indexes the given file.") public Long indexFile; @Parameter(names = { "-b", "--bonjour" }, description = "enable Bonjour.") public boolean enableBonjour = false; @Parameter(names = { "-m", "--md5" }, description = "create an MD5 checksum for the given file.", converter = FileConverter.class) public File md5File; @Parameter(names = { "-c", "--cat" }, description = "'cat' the given Lilith logfile.", converter = FileConverter.class) public File catFile; @Parameter(names = { "-t", "--tail" }, description = "'tail' the given Lilith logfile.", converter = FileConverter.class) public File tailFile; @Parameter(names = { "-p", "--pattern" }, description = "pattern used by 'cat' or 'tail'.") public String pattern; @Parameter(names = { "-f", "--keep-running" }, description = "keep tailing the given Lilith logfile.") public boolean keepRunning = false; @Parameter(names = { "-n", "--number-of-lines" }, description = "number of entries printed by cat or tail") public Integer numberOfLines = -1; @Parameter(names = { "-e", "--export-preferences" }, description = "export preferences into the given file.") public String exportPreferencesFile; @Parameter(names = { "-i", "--import-preferences" }, description = "import preferences from the given file.") public String importPreferencesFile; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/IHostPorts.java000066400000000000000000000016031251210532400302600ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.HostPort; import java.util.List; public interface IHostPorts { List getHostPorts(); } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/SeparatorColon.java000066400000000000000000000017401251210532400311370ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; import com.beust.jcommander.Parameters; @Parameters(separators = ":") public class SeparatorColon { @Parameter(names = "-verbose", arity = 1) public boolean verbose = false; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/SeparatorEqual.java000066400000000000000000000020141251210532400311270ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; import com.beust.jcommander.Parameters; @Parameters(separators = "=") public class SeparatorEqual { @Parameter(names = "-log") public Integer log = 2; @Parameter(names = "--longoption") public Integer longOption; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/SeparatorMixed.java000066400000000000000000000020031251210532400311240ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; import com.beust.jcommander.Parameters; @Parameters(separators = ":=") public class SeparatorMixed { @Parameter(names = "-level") public Integer level = 0; @Parameter(names = "-long") public Long l = 0l; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/SlashSeparator.java000066400000000000000000000020161251210532400311340ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.args; import com.beust.jcommander.Parameter; import com.beust.jcommander.Parameters; @Parameters(optionPrefixes = "/") public class SlashSeparator { @Parameter(names = "/verbose") public boolean verbose = false; @Parameter(names = "/file") public String file; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/args/VariableArity.java000066400000000000000000000011171251210532400307400ustar00rootroot00000000000000package com.beust.jcommander.args; import com.beust.jcommander.IVariableArity; import com.beust.jcommander.Parameter; import java.util.ArrayList; import java.util.List; public class VariableArity implements IVariableArity { private int m_count; public VariableArity(int count) { m_count = count; } @Parameter public List main = new ArrayList(); @Parameter(names = "-variable", variableArity = true) public List var = new ArrayList(); public int processVariableArity(String optionName, String[] options) { return m_count; } } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/command/000077500000000000000000000000001251210532400260215ustar00rootroot00000000000000jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/command/CommandAdd.java000066400000000000000000000021551251210532400306560ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.command; import com.beust.jcommander.Parameter; import com.beust.jcommander.Parameters; import java.util.List; @Parameters(commandDescription = "Add file contents to the index") public class CommandAdd { @Parameter(description = "Patterns of files to be added") public List patterns; @Parameter(names = "-i") public Boolean interactive = false; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/command/CommandAliasTest.java000066400000000000000000000134761251210532400320670ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.command; import com.beust.jcommander.JCommander; import com.beust.jcommander.ParameterException; import org.testng.Assert; import org.testng.annotations.Test; import java.util.Arrays; import java.util.regex.Matcher; import java.util.regex.Pattern; /** * Tests command alias functionality * * @author rodionmoiseev */ public class CommandAliasTest { @Test public void oneCommandWithSingleAlias() { CommandMain cm = new CommandMain(); JCommander jc = new JCommander(cm); CommandAdd add = new CommandAdd(); jc.addCommand("add", add, "a"); jc.parse("a", "-i", "A.java"); Assert.assertEquals(jc.getParsedCommand(), "add"); Assert.assertEquals(jc.getParsedAlias(), "a"); Assert.assertEquals(add.interactive.booleanValue(), true); Assert.assertEquals(add.patterns, Arrays.asList("A.java")); } @Test public void oneCommandWithMultipleAliases_commit_ci() { testCommitWithAlias("ci"); } @Test public void oneCommandWithMultipleAliases_commit_cmt() { testCommitWithAlias("cmt"); } private void testCommitWithAlias(String alias) { CommandMain cm = new CommandMain(); JCommander jc = new JCommander(cm); CommandCommit commit = new CommandCommit(); jc.addCommand("commit", commit, "ci", "cmt"); jc.parse(alias, "--amend", "--author", "jack", "file1.txt"); Assert.assertEquals(jc.getParsedCommand(), "commit"); Assert.assertEquals(jc.getParsedAlias(), alias); Assert.assertEquals(commit.amend.booleanValue(), true); Assert.assertEquals(commit.author, "jack"); Assert.assertEquals(commit.files, Arrays.asList("file1.txt")); } @Test public void twoCommandsWithAliases() { CommandMain cm = new CommandMain(); JCommander jc = new JCommander(cm); CommandAdd add = new CommandAdd(); jc.addCommand("add", add, "a"); CommandCommit commit = new CommandCommit(); jc.addCommand("commit", commit, "ci", "cmt"); jc.parse("a", "-i", "A.java"); Assert.assertEquals(jc.getParsedCommand(), "add"); Assert.assertEquals(add.interactive.booleanValue(), true); Assert.assertEquals(add.patterns, Arrays.asList("A.java")); } @Test public void clashingAliasesAreNotAllowed() { CommandMain cm = new CommandMain(); JCommander jc = new JCommander(cm); CommandAdd add = new CommandAdd(); jc.addCommand("add", add, "xx"); CommandCommit commit = new CommandCommit(); try { jc.addCommand("commit", commit, "ci", "xx"); Assert.fail("Should not be able to register clashing alias 'xx'"); } catch (ParameterException pe) { //Make sure the message mentions that "xx" aliases is already //defined for "add" command Assert.assertTrue(pe.getMessage().contains("xx")); Assert.assertTrue(pe.getMessage().contains("add")); } } @Test public void mainCommandReturnsNullsForGetCommandAndGetParsedAlias() { CommandMain cm = new CommandMain(); JCommander jc = new JCommander(cm); Assert.assertNull(jc.getParsedCommand()); Assert.assertNull(jc.getParsedAlias()); } @Test public void usageCanBeRetrievedWithBothCommandAndAlias() { CommandMain cm = new CommandMain(); JCommander jc = new JCommander(cm); CommandCommit commit = new CommandCommit(); jc.addCommand("commit", commit, "ci", "cmt"); StringBuilder out = new StringBuilder(); jc.usage("commit", out); patternMatchesTimes("commit\\(ci,cmt\\)", out.toString(), 1); out = new StringBuilder(); jc.usage("ci", out); patternMatchesTimes("commit\\(ci,cmt\\)", out.toString(), 1); out = new StringBuilder(); jc.usage("cmt", out); patternMatchesTimes("commit\\(ci,cmt\\)", out.toString(), 1); } @Test public void usageDisplaysCommandWithAliasesOnlyOnce() { CommandMain cm = new CommandMain(); JCommander jc = new JCommander(cm); CommandCommit commit = new CommandCommit(); jc.addCommand("commit", commit, "ci", "cmt"); StringBuilder out = new StringBuilder(); jc.usage(out); // The usage should display this string twice: one as the command name // and one after Usage: patternMatchesTimes("commit\\(ci,cmt\\)", out.toString(), 2); } /** * Visually test the formatting for "prettiness" */ @Test(enabled = false, description = "TODO: test the output instead of displaying it") public void formattingLooksNice(){ CommandMain cm = new CommandMain(); JCommander jc = new JCommander(cm); CommandAdd add = new CommandAdd(); jc.addCommand("add", add, "a"); CommandCommit commit = new CommandCommit(); jc.addCommand("commit", commit, "ci", "cmt"); StringBuilder sb = new StringBuilder(); jc.usage(sb); System.out.println("--- usage() formatting ---"); System.out.println(sb.toString()); sb = new StringBuilder(); jc.usage("commit", sb); System.out.println("--- usage('commit') formatting ---"); System.out.println(sb.toString()); } private void patternMatchesTimes(String pattern, String input, int times) { Matcher m = Pattern.compile(pattern).matcher(input); int matches = 0; while (m.find()) matches++; Assert.assertEquals(matches, times); } } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/command/CommandCommit.java000066400000000000000000000023001251210532400314060ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.command; import com.beust.jcommander.Parameter; import com.beust.jcommander.Parameters; import java.util.List; @Parameters(separators = "=", commandDescription = "Record changes to the repository") public class CommandCommit { @Parameter(description = "List of files") public List files; @Parameter(names = "--amend", description = "Amend") public Boolean amend = false; @Parameter(names = "--author") public String author; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/command/CommandHidden.java000066400000000000000000000007201251210532400313550ustar00rootroot00000000000000package com.beust.jcommander.command; import com.beust.jcommander.Parameter; import com.beust.jcommander.Parameters; import java.util.List; @Parameters(commandNames = "add", commandDescription = "Hidden command to add file contents to the index", hidden = true) public class CommandHidden { @Parameter(description = "Patterns of files to be added") public List patterns; @Parameter(names = "-i") public Boolean interactive = false; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/command/CommandMain.java000066400000000000000000000016471251210532400310570ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.command; import com.beust.jcommander.Parameter; public class CommandMain { @Parameter(names = "-v", description = "Verbose mode") public Boolean verbose = false; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/command/CommandTest.java000066400000000000000000000075641251210532400311160ustar00rootroot00000000000000/** * Copyright (C) 2010 the original author or authors. * See the notice.md file distributed with this work for additional * information regarding copyright ownership. * * 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 com.beust.jcommander.command; import com.beust.jcommander.JCommander; import com.beust.jcommander.ParameterException; import org.testng.Assert; import org.testng.annotations.Test; import java.util.Arrays; public class CommandTest { @Test public void namedCommandTest1() { CommandMain cm = new CommandMain(); JCommander jc = new JCommander(cm); NamedCommandAdd add = new NamedCommandAdd(); jc.addCommand(add); CommandCommit commit = new CommandCommit(); jc.addCommand("commit", commit); jc.parse("add", "-i", "A.java"); Assert.assertEquals(jc.getParsedCommand(), "add"); Assert.assertEquals(add.interactive.booleanValue(), true); Assert.assertEquals(add.patterns, Arrays.asList("A.java")); } @Test(expectedExceptions = ParameterException.class) public void shouldComplainIfNoAnnotations() { CommandMain cm = new CommandMain(); JCommander jc = new JCommander(cm); CommandAdd add = new CommandAdd(); jc.addCommand(add); } @Test public void commandTest1() { CommandMain cm = new CommandMain(); JCommander jc = new JCommander(cm); CommandAdd add = new CommandAdd(); jc.addCommand("add", add); CommandCommit commit = new CommandCommit(); jc.addCommand("commit", commit); jc.parse("add", "-i", "A.java"); Assert.assertEquals(jc.getParsedCommand(), "add"); Assert.assertEquals(add.interactive.booleanValue(), true); Assert.assertEquals(add.patterns, Arrays.asList("A.java")); } @Test public void commandTest2() { CommandMain cm = new CommandMain(); JCommander jc = new JCommander(cm); CommandAdd add = new CommandAdd(); jc.addCommand("add", add); CommandCommit commit = new CommandCommit(); jc.addCommand("commit", commit); jc.parse("-v", "commit", "--amend", "--author=cbeust", "A.java", "B.java"); // jc.setProgramName("TestCommander"); // jc.usage(); // jc.usage("add"); // jc.usage("commit"); Assert.assertTrue(cm.verbose); Assert.assertEquals(jc.getParsedCommand(), "commit"); Assert.assertTrue(commit.amend); Assert.assertEquals(commit.author, "cbeust"); Assert.assertEquals(commit.files, Arrays.asList("A.java", "B.java")); } @Test public void hiddenCommandTest() { CommandMain cm = new CommandMain(); JCommander jc = new JCommander(cm); CommandAdd add = new CommandAdd(); jc.addCommand("add", add); CommandHidden hidden = new CommandHidden(); jc.addCommand("hidden", hidden); jc.parse("hidden", "-i", "A.java"); Assert.assertEquals(jc.getParsedCommand(), "hidden"); Assert.assertEquals(hidden.interactive.booleanValue(), true); Assert.assertEquals(hidden.patterns, Arrays.asList("A.java")); jc.setProgramName("TestCommander"); StringBuilder out = new StringBuilder(); jc.usage(out); Assert.assertTrue(out.toString().contains("add Add file contents to the index")); Assert.assertFalse(out.toString().contains("hidden Hidden command to add file contents to the index")); } public static void main(String[] args) { new CommandTest().shouldComplainIfNoAnnotations(); } } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/command/NamedCommandAdd.java000066400000000000000000000006511251210532400316220ustar00rootroot00000000000000package com.beust.jcommander.command; import com.beust.jcommander.Parameter; import com.beust.jcommander.Parameters; import java.util.List; @Parameters(commandNames = "add", commandDescription = "Add file contents to the index") public class NamedCommandAdd { @Parameter(description = "Patterns of files to be added") public List patterns; @Parameter(names = "-i") public Boolean interactive = false; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/dynamic/000077500000000000000000000000001251210532400260275ustar00rootroot00000000000000jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/dynamic/DSimple.java000066400000000000000000000006421251210532400302310ustar00rootroot00000000000000package com.beust.jcommander.dynamic; import com.beust.jcommander.DynamicParameter; import org.testng.collections.Maps; import java.util.Map; public class DSimple { @DynamicParameter(names = "-D", description = "Dynamic parameters go here") public Map params = Maps.newHashMap(); @DynamicParameter(names = "-A", assignment = "@") public Map params2 = Maps.newHashMap(); } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/dynamic/DSimpleBad.java000066400000000000000000000003131251210532400306330ustar00rootroot00000000000000package com.beust.jcommander.dynamic; import com.beust.jcommander.DynamicParameter; import java.util.List; public class DSimpleBad { @DynamicParameter(names = "-D") public List params; } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/dynamic/DynamicParameterTest.java000066400000000000000000000031711251210532400327610ustar00rootroot00000000000000package com.beust.jcommander.dynamic; import com.beust.jcommander.JCommander; import com.beust.jcommander.ParameterException; import com.beust.jcommander.internal.Maps; import org.testng.Assert; import org.testng.annotations.Test; @Test public class DynamicParameterTest { @Test(expectedExceptions = ParameterException.class) public void nonMapShouldThrow() { new JCommander(new DSimpleBad()).parse("-D", "a=b", "-D", "c=d"); } @Test(expectedExceptions = ParameterException.class) public void wrongSeparatorShouldThrow() { DSimple ds = new DSimple(); new JCommander(ds).parse("-D", "a:b", "-D", "c=d"); } private void simple(String... parameters) { DSimple ds = new DSimple(); new JCommander(ds).parse(parameters); Assert.assertEquals(ds.params, Maps.newHashMap("a", "b", "c", "d")); } public void simpleWithSpaces() { simple("-D", "a=b", "-D", "c=d"); } public void simpleWithoutSpaces() { simple("-Da=b", "-Dc=d"); } public void usage() { DSimple ds = new DSimple(); new JCommander(ds).usage(new StringBuilder()); } public void differentAssignment() { DSimple ds = new DSimple(); new JCommander(ds).parse("-D", "a=b", "-A", "c@d"); Assert.assertEquals(ds.params, Maps.newHashMap("a", "b")); Assert.assertEquals(ds.params2, Maps.newHashMap("c", "d")); } @Test(enabled = false) public static void main(String[] args) { DynamicParameterTest dpt = new DynamicParameterTest(); dpt.simpleWithSpaces(); // dpt.nonMapShouldThrow(); // dpt.wrongSeparatorShouldThrow(); // dpt.differentAssignment(); // dpt.arity0(); // dpt.usage(); } } jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/internal/000077500000000000000000000000001251210532400262175ustar00rootroot00000000000000jcommander-jcommander-1.48/src/test/java/com/beust/jcommander/internal/DefaultConsoleTest.java000066400000000000000000000031371251210532400326350ustar00rootroot00000000000000package com.beust.jcommander.internal; import java.io.IOException; import java.io.InputStream; import org.testng.Assert; import org.testng.annotations.Test; @Test public class DefaultConsoleTest { public void readPasswordCanBeCalledMultipleTimes() { final InputStream inBackup = System.in; try { final StringInputStream in = new StringInputStream(); System.setIn(in); final Console console = new DefaultConsole(); in.setData("password1\n"); char[] password = console.readPassword(false); Assert.assertEquals(password, "password1".toCharArray()); Assert.assertFalse(in.isClosedCalled(), "System.in stream shouldn't be closed"); in.setData("password2\n"); password = console.readPassword(false); Assert.assertEquals(password, "password2".toCharArray()); Assert.assertFalse(in.isClosedCalled(), "System.in stream shouldn't be closed"); } finally { System.setIn(inBackup); } } private static class StringInputStream extends InputStream { private byte[] data = new byte[0]; private int offset = 0; private boolean closedCalled; StringInputStream() { super(); } void setData(final String strData) { data = strData.getBytes(); offset = 0; } boolean isClosedCalled() { return closedCalled; } @Override public int read() throws IOException { if (offset >= data.length) { return -1; } return 0xFFFF & data[offset++]; } @Override public void close() throws IOException { closedCalled = true; super.close(); } } } jcommander-jcommander-1.48/src/test/java/test/000077500000000000000000000000001251210532400213435ustar00rootroot00000000000000jcommander-jcommander-1.48/src/test/java/test/QuotedMainTest.java000066400000000000000000000011371251210532400251160ustar00rootroot00000000000000package test; import java.util.ArrayList; import java.util.List; import org.testng.Assert; import org.testng.annotations.Test; import com.beust.jcommander.JCommander; import com.beust.jcommander.Parameter; public class QuotedMainTest { @Parameter List args = new ArrayList(); String quoted = "\" \""; @Test public void testMain() { JCommander jc = new JCommander(this); jc.parse(quoted); Assert.assertEquals(args.size(), 1); Assert.assertEquals(args.get(0), " "); } public static void main(String[] args) { new QuotedMainTest().testMain(); } } jcommander-jcommander-1.48/src/test/resources/000077500000000000000000000000001251210532400214555ustar00rootroot00000000000000jcommander-jcommander-1.48/src/test/resources/MessageBundle_en_US.properties000066400000000000000000000014161251210532400274040ustar00rootroot00000000000000# # Copyright (C) 2010 the original author or authors. # See the notice.md file distributed with this work for additional # information regarding copyright ownership. # # 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. # host = Host command = Command from the bundle myoption = My optionjcommander-jcommander-1.48/src/test/resources/MessageBundle_fr_FR.properties000066400000000000000000000013551251210532400273730ustar00rootroot00000000000000# # Copyright (C) 2010 the original author or authors. # See the notice.md file distributed with this work for additional # information regarding copyright ownership. # # 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. # host = Hôte files = Les fichiers jcommander-jcommander-1.48/src/test/resources/jcommander.properties000066400000000000000000000013471251210532400257170ustar00rootroot00000000000000# # Copyright (C) 2010 the original author or authors. # See the notice.md file distributed with this work for additional # information regarding copyright ownership. # # 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. # groups=unit level=17 log=18jcommander-jcommander-1.48/src/test/resources/testng-single.xml000066400000000000000000000006441251210532400247660ustar00rootroot00000000000000 jcommander-jcommander-1.48/src/test/resources/testng.xml000066400000000000000000000017431251210532400235100ustar00rootroot00000000000000 jcommander-jcommander-1.48/upload000077500000000000000000000003001251210532400171000ustar00rootroot00000000000000scp doc/index.html target/jcommander-1.27.jar beust.com@beust.com:domains/jcommander.org/html mvn javadoc:javadoc scp -r target/site/apidocs beust.com@beust.com:domains/jcommander.org/html