/**
* 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<String, JCommander> c = jc.getCommands();
Assert.assertEquals(c.size(), commands.length);
Iterator<String> 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<String> commands=new ArrayList<String>();
}
@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<ParameterDescription> 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<Integer>() {{ add(1); add(2); add(3); }});
}
private static final List<String> 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<String> var, List<String> 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<ChoiceType> expected = Arrays.asList(ChoiceType.ONE, ChoiceType.Two);
Assert.assertEquals(expected, args.choices);
Assert.assertEquals(jc.getParameters().get(0).getDescription(),
"Options: " + EnumSet.allOf((Class<? extends Enum>) 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<String> 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<String, String> 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<String> paramA = Lists.newArrayList();
@Parameter(names = "-paramB", description = "ParamB", variableArity = true)
private List<String> 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: <empty string>"));
}
public void spaces() {
class Arg {
@Parameter(names = "-rule", description = "rule")
private List<String> rules = new ArrayList<String>();
}
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<String> 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<String> parameters;
}
@Parameters(commandDescription = "command b")
class ArgCommandB {
@Parameter(description = "command b parameters")
List<String> 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<String> parameters;
}
@Parameters(commandDescription = "command b")
class ArgCommandB {
@Parameter(description = "command b parameters")
List<String> 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<String> 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<String> 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<String> 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<String> 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
}