Java Option类代码示例

import picocli.CommandLine.Option; //导入依赖的package包/类
@Test
public void testParentInjectedWhenAddedAsSubcommand() {
    class Top1 {
        @Option(names = {"-d", "--directory"}, description = "this option applies to all subcommands")
        private File baseDirectory;
    }
    class Sub1 {
        @ParentCommand private Top1 parent;
        @Parameters private int count;
    }
    List<CommandLine> result = new CommandLine(new Top1())
            .addSubcommand("sub1", new Sub1())
            .parse("-d/tmp/blah", "sub1", "3");
    Top1 top = result.get(0).getCommand();
    assertEquals(new File("/tmp/blah"), top.baseDirectory);
    Sub1 sub = result.get(1).getCommand();
    assertEquals(3, sub.count);
    assertSame(top, sub.parent);
}
 

import picocli.CommandLine.Option; //导入依赖的package包/类
@Test
public void testInitializationExceptionForTypeMismatch() {
    class Top1 {
        @Option(names = {"-d", "--directory"}, description = "this option applies to all subcommands")
        private File baseDirectory;
    }
    class Sub1 {
        @ParentCommand private String parent;
        @Parameters private int count;
    }
    Top1 top1 = new Top1();
    Sub1 sub1 = new Sub1();
    try {
        new CommandLine(top1).addSubcommand("sub1", sub1);
        fail("expected failure");
    } catch (InitializationException ex) {
        String prefix = "Unable to initialize @ParentCommand field: java.lang.IllegalArgumentException";
        if (prefix.equals(ex.getMessage())) { return; }
        String expected = prefix + ": Can not set java.lang.String field " + sub1.getClass().getName() + ".parent to " + top1.getClass().getName();
        assertEquals(expected, ex.getMessage());
    }
}
 

import picocli.CommandLine.Option; //导入依赖的package包/类
@Test
public void testArrayOptionArity2_nConsumesAllArgumentsUpToClusteredOption() {
    class ArrayOptionsArity2_nAndParameters {
        @Parameters String[] stringParams;
        @Option(names = "-s", arity = "2..*") String[] stringOptions;
        @Option(names = "-v") boolean verbose;
        @Option(names = "-f") File file;
    }
    ArrayOptionsArity2_nAndParameters
            params = CommandLine.populateCommand(new ArrayOptionsArity2_nAndParameters(), "-s 1.1 2.2 3.3 4.4 -vfFILE 5.5".split(" "));
    assertArrayEquals(Arrays.toString(params.stringOptions),
            new String[] {"1.1", "2.2", "3.3", "4.4"}, params.stringOptions);
    assertTrue(params.verbose);
    assertEquals(new File("FILE"), params.file);
    assertArrayEquals(new String[] {"5.5"}, params.stringParams);
}
 

import picocli.CommandLine.Option; //导入依赖的package包/类
@Test
public void testArrayOptionArity2_nConsumesAllArgumentIncludingQuotedSimpleOption() {
    class ArrayOptionArity2_nAndParameters {
        @Parameters String[] stringParams;
        @Option(names = "-s", arity = "2..*") String[] stringOptions;
        @Option(names = "-v") boolean verbose;
        @Option(names = "-f") File file;
    }
    ArrayOptionArity2_nAndParameters
            params = CommandLine.populateCommand(new ArrayOptionArity2_nAndParameters(), "-s 1.1 2.2 3.3 4.4 \"-v\" \"-f\" \"FILE\" 5.5".split(" "));
    assertArrayEquals(Arrays.toString(params.stringOptions),
            new String[] {"1.1", "2.2", "3.3", "4.4", "-v", "-f", "FILE", "5.5"}, params.stringOptions);
    assertFalse("verbose", params.verbose);
    assertNull("file", params.file);
    assertArrayEquals(null, params.stringParams);
}
 

import picocli.CommandLine.Option; //导入依赖的package包/类
@Test
public void testArrayOptionArity2_nConsumesAllArgumentIncludingQuotedClusteredOption() {
    class ArrayOptionArity2_nAndParameters {
        @Parameters String[] stringParams;
        @Option(names = "-s", arity = "2..*") String[] stringOptions;
        @Option(names = "-v") boolean verbose;
        @Option(names = "-f") File file;
    }
    ArrayOptionArity2_nAndParameters
            params = CommandLine.populateCommand(new ArrayOptionArity2_nAndParameters(), "-s 1.1 2.2 3.3 4.4 \"-vfFILE\" 5.5".split(" "));
    assertArrayEquals(Arrays.toString(params.stringOptions),
            new String[] {"1.1", "2.2", "3.3", "4.4", "-vfFILE", "5.5"}, params.stringOptions);
    assertFalse("verbose", params.verbose);
    assertNull("file", params.file);
    assertArrayEquals(null, params.stringParams);
}
 

import picocli.CommandLine.Option; //导入依赖的package包/类
@Test
public void testArrayOptionArity2_nConsumesAllArgumentsUpToNextSimpleOption() {
    class ArrayOptionArity2_nAndParameters {
        @Parameters double[] doubleParams;
        @Option(names = "-s", arity = "2..*") String[] stringOptions;
        @Option(names = "-v") boolean verbose;
        @Option(names = "-f") File file;
    }
    ArrayOptionArity2_nAndParameters
            params = CommandLine.populateCommand(new ArrayOptionArity2_nAndParameters(), "-s 1.1 2.2 3.3 4.4 -v -f=FILE 5.5".split(" "));
    assertArrayEquals(Arrays.toString(params.stringOptions),
            new String[] {"1.1", "2.2", "3.3", "4.4"}, params.stringOptions);
    assertTrue(params.verbose);
    assertEquals(new File("FILE"), params.file);
    assertArrayEquals(new double[] {5.5}, params.doubleParams, 0.000001);
}
 

import picocli.CommandLine.Option; //导入依赖的package包/类
@Test
public void testArrayOptionArity2_nConsumesAllArgumentsUpToNextOptionWithAttachment() {
    class ArrayOptionArity2_nAndParameters {
        @Parameters double[] doubleParams;
        @Option(names = "-s", arity = "2..*") String[] stringOptions;
        @Option(names = "-v") boolean verbose;
        @Option(names = "-f") File file;
    }
    ArrayOptionArity2_nAndParameters
            params = CommandLine.populateCommand(new ArrayOptionArity2_nAndParameters(), "-s 1.1 2.2 3.3 4.4 -f=FILE -v 5.5".split(" "));
    assertArrayEquals(Arrays.toString(params.stringOptions),
            new String[] {"1.1", "2.2", "3.3", "4.4"}, params.stringOptions);
    assertTrue(params.verbose);
    assertEquals(new File("FILE"), params.file);
    assertArrayEquals(new double[] {5.5}, params.doubleParams, 0.000001);
}
 

import picocli.CommandLine.Option; //导入依赖的package包/类
@Test
public void testNoMissingRequiredParamErrorIfHelpOptionSpecified() {
    class App {
        @Parameters(hidden = true)  // "hidden": don't show this parameter in usage help message
                List<String> allParameters; // no "index" attribute: captures _all_ arguments (as Strings)

        @Parameters(index = "0")    InetAddress  host;
        @Parameters(index = "1")    int          port;
        @Parameters(index = "2..*") File[]       files;

        @Option(names = "-?", help = true) boolean help;
    }
    CommandLine.populateCommand(new App(), new String[] {"-?"});
    try {
        CommandLine.populateCommand(new App(), new String[0]);
        fail("Should not accept missing mandatory parameter");
    } catch (MissingParameterException ex) {
        assertEquals("Missing required parameters: <host>, <port>", ex.getMessage());
    }
}
 

import picocli.CommandLine.Option; //导入依赖的package包/类
@Test
public void testNoMissingRequiredParamErrorWithLabelIfHelpOptionSpecified() {
    class App {
        @Parameters(hidden = true)  // "hidden": don't show this parameter in usage help message
                List<String> allParameters; // no "index" attribute: captures _all_ arguments (as Strings)

        @Parameters(index = "0", paramLabel = "HOST")     InetAddress  host;
        @Parameters(index = "1", paramLabel = "PORT")     int          port;
        @Parameters(index = "2..*", paramLabel = "FILES") File[]       files;

        @Option(names = "-?", help = true) boolean help;
    }
    CommandLine.populateCommand(new App(), new String[] {"-?"});
    try {
        CommandLine.populateCommand(new App(), new String[0]);
        fail("Should not accept missing mandatory parameter");
    } catch (MissingParameterException ex) {
        assertEquals("Missing required parameters: HOST, PORT", ex.getMessage());
    }
}
 

import picocli.CommandLine.Option; //导入依赖的package包/类
@Test
public void testArrayOptionWithArity1Consumes1Argument() {
    class Options1ArityAndParameters {
        @Parameters double[] doubleParams;
        @Option(names = "-doubles", arity = "1") double[] doubleOptions;
    }
    Options1ArityAndParameters
            params = CommandLine.populateCommand(new Options1ArityAndParameters(), "-doubles 1.1 2.2 3.3 4.4".split(" "));
    assertArrayEquals(Arrays.toString(params.doubleOptions),
            new double[] {1.1}, params.doubleOptions, 0.000001);
    assertArrayEquals(new double[]{2.2, 3.3, 4.4}, params.doubleParams, 0.000001);

    // repeated occurrence
    params = CommandLine.populateCommand(new Options1ArityAndParameters(), "-doubles 1.1 -doubles 2.2 -doubles 3.3 4.4".split(" "));
    assertArrayEquals(Arrays.toString(params.doubleOptions),
            new double[] {1.1, 2.2, 3.3}, params.doubleOptions, 0.000001);
    assertArrayEquals(new double[]{4.4}, params.doubleParams, 0.000001);

}
 

import picocli.CommandLine.Option; //导入依赖的package包/类
@Test
public void testArrayOptionWithoutArityConsumesOneArgument() { // #192
    class OptionsNoArityAndParameters {
        @Parameters char[] charParams;
        @Option(names = "-chars") char[] charOptions;
    }
    OptionsNoArityAndParameters
            params = CommandLine.populateCommand(new OptionsNoArityAndParameters(), "-chars a b c d".split(" "));
    assertArrayEquals(Arrays.toString(params.charOptions),
            new char[] {'a', }, params.charOptions);
    assertArrayEquals(Arrays.toString(params.charParams), new char[] {'b', 'c', 'd'}, params.charParams);

    // repeated occurrence
    params = CommandLine.populateCommand(new OptionsNoArityAndParameters(), "-chars a -chars b c d".split(" "));
    assertArrayEquals(Arrays.toString(params.charOptions),
            new char[] {'a', 'b', }, params.charOptions);
    assertArrayEquals(Arrays.toString(params.charParams), new char[] {'c', 'd'}, params.charParams);

    try {
        CommandLine.populateCommand(new OptionsNoArityAndParameters(), "-chars".split(" "));
        fail("expected MissingParameterException");
    } catch (MissingParameterException ok) {
        assertEquals("Missing required parameter for option '-chars' (<charOptions>)", ok.getMessage());
    }
}
 

import picocli.CommandLine.Option; //导入依赖的package包/类
@Test
public void testMixPositionalParamsWithOptions_ParamsUnboundedArity_isGreedy() {
    class Arg {
        @Parameters(arity = "1..*") List<String> parameters;
        @Option(names = "-o")    List<String> options;
    }
    Arg result = CommandLine.populateCommand(new Arg(), "-o", "v1", "p1", "p2", "-o", "v2", "p3", "p4");
    assertEquals(Arrays.asList("p1", "p2", "-o", "v2", "p3", "p4"), result.parameters);
    assertEquals(Arrays.asList("v1"), result.options);

    Arg result2 = CommandLine.populateCommand(new Arg(), "-o", "v1", "p1", "-o", "v2", "p3");
    assertEquals(Arrays.asList("p1", "-o", "v2", "p3"), result2.parameters);
    assertEquals(Arrays.asList("v1"), result2.options);

    try {
        CommandLine.populateCommand(new Arg(), "-o", "v1", "-o", "v2");
        fail("Expected MissingParameterException");
    } catch (MissingParameterException ex) {
        assertEquals("Missing required parameters at positions 0..*: <parameters>", ex.getMessage());
    }
}
 

import picocli.CommandLine.Option; //导入依赖的package包/类
@Test
public void testSystemPropertiesOverrideDefaultColorScheme() {
    @CommandLine.Command(separator = "=") class App {
        @Option(names = {"--verbose", "-v"}) boolean verbose;
        @Option(names = {"--count", "-c"}) int count;
        @Option(names = {"--help", "-h"}, hidden = true) boolean helpRequested;
        @Parameters(paramLabel = "FILE", arity = "1..*") File[] files;
    }
    Help.Ansi ansi = Help.Ansi.ON;
    // default color scheme
    assertEquals(ansi.new Text("@|bold <main class>|@ [@|yellow -v|@] [@|yellow -c|@[email protected]|italic <count>|@] @|yellow FILE|@..." + LINESEP),
            new Help(new App(), ansi).synopsis(0));

    System.setProperty("picocli.color.commands", "blue");
    System.setProperty("picocli.color.options", "green");
    System.setProperty("picocli.color.parameters", "cyan");
    System.setProperty("picocli.color.optionParams", "magenta");
    assertEquals(ansi.new Text("@|blue <main class>|@ [@|green -v|@] [@|green -c|@[email protected]|magenta <count>|@] @|cyan FILE|@..." + LINESEP),
            new Help(new App(), ansi).synopsis(0));
}
 

import picocli.CommandLine.Option; //导入依赖的package包/类
@Test
public void testAnnotatedCustomConverterDoesNotConflictWithExistingType() {
    class App {
        @Parameters(index = "0", converter = SqlTypeConverter.class)
        int sqlTypeParam;

        @Parameters(index = "1")
        int normalIntParam;

        @Option(names = "-t", converter = SqlTypeConverter.class)
        int sqlTypeOption;

        @Option(names = "-x")
        int normalIntOption;
    }
    App app = new App();
    CommandLine commandLine = new CommandLine(app);

    String[] args = {"-x", "1234", "-t", "BLOB", "CLOB", "5678"};
    commandLine.parse(args);
    assertEquals(1234, app.normalIntOption);
    assertEquals(Types.BLOB, app.sqlTypeOption);
    assertEquals(Types.CLOB, app.sqlTypeParam);
    assertEquals(5678, app.normalIntParam);
}
 

import picocli.CommandLine.Option; //导入依赖的package包/类
@Test
public void testUsageParamLabels() throws Exception {
    @Command()
    class ParamLabels {
        @Option(names = "-P",    paramLabel = "KEY=VALUE", type  = {String.class, String.class},
                description = "Project properties (key-value pairs)")              Map<String, String> props;
        @Option(names = "-f",    paramLabel = "FILE", description = "files")      File[] f;
        @Option(names = "-n",    description = "a number option")                  int number;
        @Parameters(index = "0", paramLabel = "NUM", description = "number param") int n;
        @Parameters(index = "1", description = "the host parameter")               InetAddress host;
    }
    String result = usageString(new ParamLabels(), Help.Ansi.OFF);
    assertEquals(format("" +
                    "Usage: <main class> [-n=<number>] [-f=FILE]... [-P=KEY=VALUE]... NUM <host>%n" +
                    "      NUM                     number param%n" +
                    "      <host>                  the host parameter%n" +
                    "  -f= FILE                    files%n" +
                    "  -n= <number>                a number option%n" +
                    "  -P= KEY=VALUE               Project properties (key-value pairs)%n",
            ""), result);
}