beust/jcommander/JCommanderTest.java

/**
 * 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", "--", "-name", "theName"}
    );
    Assert.assertNull(a.name);
    Assert.assertEquals(a.mainParameters.size(), 4);
    Assert.assertEquals(a.mainParameters.get(0), "param1");
    Assert.assertEquals(a.mainParameters.get(1), "param2");
    Assert.assertEquals(a.mainParameters.get(2), "-name");
    Assert.assertEquals(a.mainParameters.get(3), "theName");
  }

  @Test(enabled = false)
  public static void main(String[] args) throws Exception {
//    new JCommanderTest().a();
//    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
}