@Test public void testUsageComputationWhenUsingNotRequiredArgument() { final CLI cli = CLI.create("test") .addArgument(new Argument().setArgName("foo").setRequired(false)); StringBuilder builder = new StringBuilder(); cli.usage(builder); assertThat(builder.toString()) .contains("test [foo]"); }
@Test(expected = CLIException.class) public void testThatNonUniqueArgumentIndexAreDetected() { CLI cli = new DefaultCLI().setName("test"); cli.addArgument(new Argument().setIndex(0)); cli.addArgument(new Argument().setIndex(1)); cli.addArgument(new Argument().setIndex(1)); // conflict cli.parse(Arrays.asList("a", "b", "c")); }
@Test public void testThatArgumentsAreOrdered() throws CLIException { cli.addArgument(new TypedArgument<String>().setIndex(1).setArgName("1").setType(String.class)); cli.addArgument(new TypedArgument<String>().setIndex(0).setArgName("2").setType(String.class)); cli.addArgument(new TypedArgument<String>().setIndex(2).setArgName("3").setType(String.class)); assertThat(cli.getArguments()).hasSize(3); evaluated = cli.parse(Arrays.asList("a", "b", "c")); Iterator<Argument> iterator = cli.getArguments().iterator(); assertThat(iterator.next().getArgName()).isEqualTo("2"); assertThat(iterator.next().getArgName()).isEqualTo("1"); assertThat(iterator.next().getArgName()).isEqualTo("3"); assertThat((String) evaluated.getArgumentValue("2")).isEqualTo("a"); assertThat((String) evaluated.getArgumentValue("1")).isEqualTo("b"); assertThat((String) evaluated.getArgumentValue("3")).isEqualTo("c"); }
@Test public void testThatArgumentIndexCanBeGenerated() { CLI cli = new DefaultCLI().setName("test"); cli.addArgument(new Argument()); cli.addArgument(new Argument()); cli.addArgument(new Argument().setMultiValued(true)); CommandLine line = cli.parse(Arrays.asList("a", "b", "c", "d")); assertThat((String) line.getArgumentValue(0)).isEqualToIgnoringCase("a"); assertThat((String) line.getArgumentValue(1)).isEqualToIgnoringCase("b"); assertThat(line.getArgumentValues(2)).containsExactly("c", "d"); }
@Test public void testWithMultipleArgumentReceivingSingleValues() { CLI cli = new DefaultCLI().setName("test"); cli.addArgument(new Argument().setIndex(0)); cli.addArgument(new Argument().setIndex(1).setMultiValued(true)); CommandLine cl = cli.parse(Arrays.asList("a", "b")); assertThat((String) cl.getArgumentValue(0)).isEqualTo("a"); assertThat(cl.getArgumentValues(1)).containsExactly("b"); assertThat((String) cl.getArgumentValue(1)).isEqualTo("b"); }
@Test(expected = CLIException.class) public void testThatOnlyTheLastArgumentCanBeMultivalued() { CLI cli = new DefaultCLI().setName("test"); cli.addArgument(new Argument().setIndex(0)); cli.addArgument(new Argument().setIndex(1).setMultiValued(true)); cli.addArgument(new Argument().setIndex(2)); cli.parse(Arrays.asList("a", "b", "c", "d")); }
@Test public void testThatArgumentIndexCanBeGeneratedWithPartiallyNumberedArguments() { CLI cli = new DefaultCLI().setName("test"); cli.addArgument(new Argument()); cli.addArgument(new Argument().setIndex(1)); cli.addArgument(new Argument().setMultiValued(true)); CommandLine line = cli.parse(Arrays.asList("a", "b", "c", "d")); assertThat((String) line.getArgumentValue(0)).isEqualToIgnoringCase("a"); assertThat((String) line.getArgumentValue(1)).isEqualToIgnoringCase("b"); assertThat(line.getArgumentValues(2)).containsExactly("c", "d"); }
@Test public void testThatDefaultValuesAreHandled() throws CLIException { cli.addArgument(new TypedArgument<String>().setIndex(0).setArgName("1").setType(String.class) .setDefaultValue("hello").setRequired(false)); evaluated = cli.parse(Collections.singletonList("a")); assertThat((String) evaluated.getArgumentValue(0)).isEqualTo("a"); evaluated = cli.parse(Collections.emptyList()); assertThat((String) evaluated.getArgumentValue(0)).isEqualTo("hello"); }
@Test(expected = CLIException.class) public void testThatArgumentWithTheSameIndexAreDetected() throws CLIException { cli.addArgument(new TypedArgument<String>().setIndex(0).setType(String.class)); cli.addArgument(new TypedArgument<String>().setIndex(0).setType(String.class)); evaluated = cli.parse(Arrays.asList("a", "b")); }
@Test public void testCommandLineValidationWhenValid() { final CLI cli = CLI.create("test") .addArgument(new Argument().setArgName("foo").setRequired(true)); CommandLine commandLine = cli.parse(Collections.singletonList("foo")); assertThat(commandLine.isValid()).isTrue(); }
@Test public void testCommandLineValidationWhenInvalidWithValidationDisabled() { final CLI cli = CLI.create("test") .addArgument(new Argument().setArgName("foo").setRequired(true)); CommandLine commandLine = cli.parse(Collections.<String>emptyList(), false); assertThat(commandLine.isValid()).isEqualTo(false); }
@Test public void testWithArgumentReceivingMultipleValues() { CLI cli = new DefaultCLI().setName("test"); cli.addArgument(new Argument().setIndex(0).setArgName("arg").setDescription("argument1")); cli.addArgument(new Argument().setIndex(1).setMultiValued(true).setArgName("m").setDescription("multiple arg")); CommandLine cl = cli.parse(Arrays.asList("a", "b", "c")); assertThat((String) cl.getArgumentValue(0)).isEqualTo("a"); assertThat(cl.getArgumentValues(1)).containsExactly("b", "c"); assertThat((String) cl.getArgumentValue(1)).isEqualTo("b"); StringBuilder builder = new StringBuilder(); cli.usage(builder); assertThat(builder.toString()).contains("test arg m..."); }
@Test(expected = CLIException.class) public void testThatOnlyOneArgumentCanBeMultivalued() { CLI cli = new DefaultCLI().setName("test"); cli.addArgument(new Argument().setIndex(0)); cli.addArgument(new Argument().setIndex(1).setMultiValued(true)); cli.addArgument(new Argument().setIndex(2).setMultiValued(true)); cli.parse(Arrays.asList("a", "b", "c", "d")); }
@Test public void testThatInvalidValuesAsDefaultValueAreReported() throws CLIException { try { cli.addArgument(new TypedArgument<Integer>() .setIndex(0).setArgName("1").setType(Integer.class).setDefaultValue("a")); } catch (IllegalArgumentException e) { assertThat(e.getCause()).isInstanceOf(InvalidValueException.class); InvalidValueException cause = (InvalidValueException) e.getCause(); assertThat(cause.getArgument().getIndex()).isEqualTo(0); assertThat(cause.getArgument().getArgName()).isEqualTo("1"); assertThat(cause.getValue()).isEqualTo("a"); } }
@Test public void testThatConvertersAreHandled() throws CLIException { final TypedArgument<Person4> arg = new TypedArgument<Person4>() .setIndex(0).setArgName("person").setType(Person4.class) .setConverter(ReflectionUtils.newInstance(Person4Converter.class)) .setDefaultValue("Bill,Ballantine") .setRequired(false); cli.addArgument(arg); evaluated = cli.parse(Collections.singletonList("Bob,Morane")); Person4 person = evaluated.getArgumentValue("person"); assertThat(person.first).isEqualTo("Bob"); assertThat(person.last).isEqualTo("Morane"); evaluated = cli.parse(Collections.emptyList()); person = evaluated.getArgumentValue("person"); assertThat(person.first).isEqualTo("Bill"); assertThat(person.last).isEqualTo("Ballantine"); }
@Test public void testUsageComputationWithSeveralArguments() { final CLI cli = CLI.create("test") .addOption(new Option().setLongName("file").setShortName("f").setDescription("a file").setRequired(true)) .addArgument(new Argument().setIndex(0).setArgName("foo").setDescription("foo")) .addArgument(new Argument().setIndex(1)) .addArgument(new Argument().setIndex(2).setArgName("bar").setDescription("bar")); StringBuilder builder = new StringBuilder(); cli.usage(builder); assertThat(builder.toString()) .contains("test -f <value> foo value bar") .contains(" -f,--file <value> a file") .contains("<foo> foo") .contains("<value>") .contains("<bar> bar"); }
@Test public void testThatInvalidValuesAreReported() throws CLIException { cli.addArgument(new TypedArgument<Integer>() .setIndex(0).setArgName("1").setType(Integer.class)); try { evaluated = cli.parse(Collections.singletonList("a")); evaluated.getArgumentValue(0); fail("Exception expected"); } catch (CLIException e) { assertThat(e).isInstanceOf(InvalidValueException.class); InvalidValueException cause = (InvalidValueException) e; assertThat(cause.getArgument().getIndex()).isEqualTo(0); assertThat(cause.getArgument().getArgName()).isEqualTo("1"); assertThat(cause.getValue()).isEqualTo("a"); } }
@Test public void testUsageComputationWhenUsingRequiredOptionAndArgument() { final CLI cli = CLI.create("test") .addOption(new Option().setLongName("file").setShortName("f").setDescription("a file").setRequired(true)) .addArgument(new Argument().setArgName("foo").setDescription("foo").setRequired(true)); StringBuilder builder = new StringBuilder(); cli.usage(builder); assertThat(builder.toString()) .contains("test -f <value> foo") .contains(" -f,--file <value> a file") .contains("<foo> foo"); }
@Test(expected = MissingValueException.class) public void testCommandLineValidationWhenInvalid() { final CLI cli = CLI.create("test") .addArgument(new Argument().setArgName("foo").setRequired(true)); cli.parse(Collections.<String>emptyList()); }
@Test public void testUsageComputationWithHiddenArguments() { final CLI cli = CLI.create("test") .addOption(new Option().setLongName("file").setShortName("f").setDescription("a file").setRequired(true)) .addArgument(new Argument().setIndex(0).setArgName("foo").setDescription("foo")) .addArgument(new Argument().setIndex(1)) .addArgument(new Argument().setIndex(2).setArgName("bar").setDescription("bar").setHidden(true)); StringBuilder builder = new StringBuilder(); cli.usage(builder); assertThat(builder.toString()) .contains("test -f <value> foo value") .contains(" -f,--file <value> a file") .contains("<foo> foo") .contains("<value>") .doesNotContain("bar"); }