/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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 org.apache.commons.cli.avalon;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
// Renamed from org.apache.avalon.excalibur.cli
import java.util.List;
import org.junit.Test;
/**
*
*/
public final class ClutilTestCase {
private static final String[] ARGLIST1 = new String[] { "--you", "are", "--all", "-cler", "kid" };
private static final String[] ARGLIST2 = new String[] { "-Dstupid=idiot", "are", "--all", "here", "-d" };
private static final String[] ARGLIST3 = new String[] {
// duplicates
"-Dstupid=idiot", "are", "--all", "--all", "here" };
private static final String[] ARGLIST4 = new String[] {
// incompatible (blee/all)
"-Dstupid", "idiot", "are", "--all", "--blee", "here" };
private static final String[] ARGLIST5 = new String[] { "-f", "myfile.txt" };
private static final int DEFINE_OPT = 'D';
private static final int CASE_CHECK_OPT = 'd';
private static final int YOU_OPT = 'y';
private static final int ALL_OPT = 'a';
private static final int CLEAR1_OPT = 'c';
private static final int CLEAR2_OPT = 'l';
private static final int CLEAR3_OPT = 'e';
private static final int CLEAR5_OPT = 'r';
private static final int BLEE_OPT = 'b';
private static final int FILE_OPT = 'f';
private static final int TAINT_OPT = 'T';
private static final CLOptionDescriptor DEFINE = new CLOptionDescriptor("define",
CLOptionDescriptor.ARGUMENTS_REQUIRED_2, DEFINE_OPT, "define");
private static final CLOptionDescriptor DEFINE_MANY = new CLOptionDescriptor("define",
CLOptionDescriptor.ARGUMENTS_REQUIRED_2 | CLOptionDescriptor.DUPLICATES_ALLOWED, DEFINE_OPT, "define");
private static final CLOptionDescriptor CASE_CHECK = new CLOptionDescriptor("charCheck",
CLOptionDescriptor.ARGUMENT_DISALLOWED, CASE_CHECK_OPT, "check character case sensitivity");
private static final CLOptionDescriptor YOU = new CLOptionDescriptor("you", CLOptionDescriptor.ARGUMENT_DISALLOWED,
YOU_OPT, "you");
private static final CLOptionDescriptor CLEAR1 = new CLOptionDescriptor("c",
CLOptionDescriptor.ARGUMENT_DISALLOWED, CLEAR1_OPT, "c");
private static final CLOptionDescriptor CLEAR2 = new CLOptionDescriptor("l",
CLOptionDescriptor.ARGUMENT_DISALLOWED, CLEAR2_OPT, "l");
private static final CLOptionDescriptor CLEAR3 = new CLOptionDescriptor("e",
CLOptionDescriptor.ARGUMENT_DISALLOWED, CLEAR3_OPT, "e");
private static final CLOptionDescriptor CLEAR5 = new CLOptionDescriptor("r",
CLOptionDescriptor.ARGUMENT_DISALLOWED, CLEAR5_OPT, "r");
private static final CLOptionDescriptor BLEE = new CLOptionDescriptor("blee",
CLOptionDescriptor.ARGUMENT_DISALLOWED, BLEE_OPT, "blee");
private static final CLOptionDescriptor ALL = new CLOptionDescriptor("all",
CLOptionDescriptor.ARGUMENT_DISALLOWED,
ALL_OPT, "all", new CLOptionDescriptor[] { BLEE });
private static final CLOptionDescriptor FILE = new CLOptionDescriptor("file",
CLOptionDescriptor.ARGUMENT_REQUIRED, FILE_OPT, "the build file.");
private static final CLOptionDescriptor TAINT = new CLOptionDescriptor("taint",
CLOptionDescriptor.ARGUMENT_OPTIONAL, TAINT_OPT, "turn on tainting checks (optional level).");
private static final CLOptionDescriptor [] OPTIONS = new CLOptionDescriptor [] {
new CLOptionDescriptor("none",
CLOptionDescriptor.ARGUMENT_DISALLOWED | CLOptionDescriptor.DUPLICATES_ALLOWED,
'0', "no parameter"),
new CLOptionDescriptor("optional",
CLOptionDescriptor.ARGUMENT_OPTIONAL | CLOptionDescriptor.DUPLICATES_ALLOWED,
'?', "optional parameter"),
new CLOptionDescriptor("one",
CLOptionDescriptor.ARGUMENT_REQUIRED | CLOptionDescriptor.DUPLICATES_ALLOWED,
'1', "one parameter"),
new CLOptionDescriptor("two",
CLOptionDescriptor.ARGUMENTS_REQUIRED_2 | CLOptionDescriptor.DUPLICATES_ALLOWED,
'2', "two parameters")
};
@Test
public void testOptionalArgWithSpace() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { ALL, TAINT };
final String[] args = new String[] { "-T", "param", "-a" };
final CLArgsParser parser = new CLArgsParser(args, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals("Option count", 3, size);
final CLOption option0 = clOptions.get(0);
assertEquals("Option Code: " + option0.getDescriptor().getId(), TAINT_OPT, option0.getDescriptor().getId());
assertEquals("Option Arg: " + option0.getArgument(0), null, option0.getArgument(0));
final CLOption option1 = clOptions.get(1);
assertEquals(option1.getDescriptor().getId(), CLOption.TEXT_ARGUMENT);
assertEquals(option1.getArgument(0), "param");
final CLOption option2 = clOptions.get(2);
assertEquals(option2.getDescriptor().getId(), ALL_OPT);
assertEquals(option2.getArgument(0), null);
}
@Test
public void testOptionalArgLong() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { ALL, TAINT };
// Check that optional args work woth long options
final String[] args = new String[] { "--taint", "param", "-a" };
final CLArgsParser parser = new CLArgsParser(args, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals("Option count", 3, size);
final CLOption option0 = clOptions.get(0);
assertEquals("Option Code: " + option0.getDescriptor().getId(), TAINT_OPT, option0.getDescriptor().getId());
assertEquals("Option Arg: " + option0.getArgument(0), null, option0.getArgument(0));
final CLOption option1 = clOptions.get(1);
assertEquals(CLOption.TEXT_ARGUMENT, option1.getDescriptor().getId());
assertEquals("param", option1.getArgument(0));
final CLOption option2 = clOptions.get(2);
assertEquals(option2.getDescriptor().getId(), ALL_OPT);
assertEquals(option2.getArgument(0), null);
}
@Test
public void testOptionalArgLongEquals() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { ALL, TAINT };
// Check that optional args work with long options
final String[] args = new String[] { "--taint=param", "-a" };
final CLArgsParser parser = new CLArgsParser(args, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals("Option count", 2, size);
final CLOption option0 = clOptions.get(0);
assertEquals("Option Code: " + option0.getDescriptor().getId(), TAINT_OPT, option0.getDescriptor().getId());
assertEquals("Option Arg: " + option0.getArgument(0), "param", option0.getArgument(0));
final CLOption option2 = clOptions.get(1);
assertEquals(option2.getDescriptor().getId(), ALL_OPT);
assertEquals(option2.getArgument(0), null);
}
@Test
public void testShortOptArgUnenteredBeforeOtherOpt() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { ALL, TAINT };
final String[] args = new String[] { "-T", "-a" };
final CLArgsParser parser = new CLArgsParser(args, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals("Option count", 2, size);
final CLOption option0 = clOptions.get(0);
assertEquals("Option Code: " + option0.getDescriptor().getId(), TAINT_OPT, option0.getDescriptor().getId());
assertEquals("Option Arg: " + option0.getArgument(0), null, option0.getArgument(0));
final CLOption option1 = clOptions.get(1);
assertEquals(option1.getDescriptor().getId(), ALL_OPT);
assertEquals(option1.getArgument(0), null);
}
@Test
public void testOptionalArgsWithArgShortBeforeOtherOpt() {
// "-T3","-a"
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { ALL, TAINT };
final String[] args = new String[] { "-T3", "-a" };
final CLArgsParser parser = new CLArgsParser(args, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(size, 2);
final CLOption option0 = clOptions.get(0);
assertEquals(option0.getDescriptor().getId(), TAINT_OPT);
assertEquals(option0.getArgument(0), "3");
final CLOption option1 = clOptions.get(1);
assertEquals(ALL_OPT, option1.getDescriptor().getId());
assertEquals(null, option1.getArgument(0));
}
@Test
public void testOptionalArgsWithArgShortEqualsBeforeOtherOpt() {
// "-T3","-a"
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { ALL, TAINT };
final String[] args = new String[] { "-T=3", "-a" };
final CLArgsParser parser = new CLArgsParser(args, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(size, 2);
final CLOption option0 = clOptions.get(0);
assertEquals(option0.getDescriptor().getId(), TAINT_OPT);
assertEquals(option0.getArgument(0), "3");
final CLOption option1 = clOptions.get(1);
assertEquals(ALL_OPT, option1.getDescriptor().getId());
assertEquals(null, option1.getArgument(0));
}
@Test
public void testOptionalArgsNoArgShortBeforeOtherOpt() {
// "-T","-a"
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { ALL, TAINT };
final String[] args = new String[] { "-T", "-a" };
final CLArgsParser parser = new CLArgsParser(args, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(size, 2);
final CLOption option0 = clOptions.get(0);
assertEquals(TAINT_OPT, option0.getDescriptor().getId());
assertEquals(null, option0.getArgument(0));
final CLOption option1 = clOptions.get(1);
assertEquals(ALL_OPT, option1.getDescriptor().getId());
assertEquals(null, option1.getArgument(0));
}
@Test
public void testFullParse() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { YOU, ALL, CLEAR1, CLEAR2, CLEAR3, CLEAR5 };
final CLArgsParser parser = new CLArgsParser(ARGLIST1, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(size, 8);
assertEquals(clOptions.get(0).getDescriptor().getId(), YOU_OPT);
assertEquals(clOptions.get(1).getDescriptor().getId(), 0);
assertEquals(clOptions.get(2).getDescriptor().getId(), ALL_OPT);
assertEquals(clOptions.get(3).getDescriptor().getId(), CLEAR1_OPT);
assertEquals(clOptions.get(4).getDescriptor().getId(), CLEAR2_OPT);
assertEquals(clOptions.get(5).getDescriptor().getId(), CLEAR3_OPT);
assertEquals(clOptions.get(6).getDescriptor().getId(), CLEAR5_OPT);
assertEquals(clOptions.get(7).getDescriptor().getId(), 0);
}
@Test
public void testDuplicateOptions() {
// "-Dstupid=idiot","are","--all","--all","here"
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE, ALL, CLEAR1 };
final CLArgsParser parser = new CLArgsParser(ARGLIST3, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(size, 5);
assertEquals(clOptions.get(0).getDescriptor().getId(), DEFINE_OPT);
assertEquals(clOptions.get(1).getDescriptor().getId(), 0);
assertEquals(clOptions.get(2).getDescriptor().getId(), ALL_OPT);
assertEquals(clOptions.get(3).getDescriptor().getId(), ALL_OPT);
assertEquals(clOptions.get(4).getDescriptor().getId(), 0);
}
@Test
public void testIncompatableOptions() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE, ALL, CLEAR1, BLEE };
final CLArgsParser parser = new CLArgsParser(ARGLIST4, options);
assertNotNull(parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(size, 5);
assertEquals(clOptions.get(0).getDescriptor().getId(), DEFINE_OPT);
assertEquals(clOptions.get(1).getDescriptor().getId(), 0);
assertEquals(clOptions.get(2).getDescriptor().getId(), ALL_OPT);
assertEquals(clOptions.get(3).getDescriptor().getId(), BLEE_OPT);
assertEquals(clOptions.get(4).getDescriptor().getId(), 0);
}
@Test
public void testSingleArg() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { FILE };
final CLArgsParser parser = new CLArgsParser(ARGLIST5, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(size, 1);
assertEquals(clOptions.get(0).getDescriptor().getId(), FILE_OPT);
assertEquals(clOptions.get(0).getArgument(), "myfile.txt");
}
@Test
public void testSingleArg2() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { FILE };
final CLArgsParser parser = new CLArgsParser(new String[] { "-f-=,=-" } // Check
// delimiters
// are
// allowed
, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(1, size);
assertEquals(FILE_OPT, clOptions.get(0).getDescriptor().getId());
assertEquals("-=,=-", clOptions.get(0).getArgument());
}
@Test
public void testSingleArg3() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { FILE };
final CLArgsParser parser = new CLArgsParser(new String[] { "--file=-=,-" } // Check
// delimiters
// are
// allowed
, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(1, size);
assertEquals(FILE_OPT, clOptions.get(0).getDescriptor().getId());
assertEquals("-=,-", clOptions.get(0).getArgument());
}
@Test
public void testSingleArg4() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { FILE };
final CLArgsParser parser = new CLArgsParser(new String[] { "--file", "myfile.txt" }, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(1, size);
assertEquals(FILE_OPT, clOptions.get(0).getDescriptor().getId());
assertEquals("myfile.txt", clOptions.get(0).getArgument());
}
@Test
public void testSingleArg5() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { FILE };
final CLArgsParser parser = new CLArgsParser(new String[] { "-f", "myfile.txt" }, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(1, size);
assertEquals(FILE_OPT, clOptions.get(0).getDescriptor().getId());
assertEquals("myfile.txt", clOptions.get(0).getArgument());
}
@Test
public void testSingleArg6() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { FILE };
final CLArgsParser parser = new CLArgsParser(new String[] { "-f", "-=-" }, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(1, size);
assertEquals(FILE_OPT, clOptions.get(0).getDescriptor().getId());
assertEquals("-=-", clOptions.get(0).getArgument());
}
@Test
public void testSingleArg7() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { FILE };
final CLArgsParser parser = new CLArgsParser(new String[] { "--file=-=-" }, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(1, size);
assertEquals(FILE_OPT, clOptions.get(0).getDescriptor().getId());
assertEquals("-=-", clOptions.get(0).getArgument());
}
@Test
public void testSingleArg8() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { FILE };
final CLArgsParser parser = new CLArgsParser(new String[] { "--file", "-=-" }, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(1, size);
assertEquals(FILE_OPT, clOptions.get(0).getDescriptor().getId());
assertEquals("-=-", clOptions.get(0).getArgument());
}
@Test
public void testCombinedArgs1() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { BLEE, TAINT };
final CLArgsParser parser = new CLArgsParser(new String[] { "-bT", "rest" }, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(3, size);
assertEquals(BLEE_OPT, clOptions.get(0).getDescriptor().getId());
assertEquals(TAINT_OPT, clOptions.get(1).getDescriptor().getId());
assertEquals(0, clOptions.get(2).getDescriptor().getId());
assertEquals("rest", clOptions.get(2).getArgument());
}
@Test
public void testCombinedArgs2() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { BLEE, TAINT, FILE };
final CLArgsParser parser = new CLArgsParser(new String[] { "-bT", "-fa" }, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(3, size);
assertEquals(BLEE_OPT, clOptions.get(0).getDescriptor().getId());
assertEquals(TAINT_OPT, clOptions.get(1).getDescriptor().getId());
assertEquals(FILE_OPT, clOptions.get(2).getDescriptor().getId());
assertEquals("a", clOptions.get(2).getArgument());
}
@Test
public void testCombinedArgs3() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { BLEE, TAINT, FILE };
final CLArgsParser parser = new CLArgsParser(new String[] { "-bT", "--", "-fa" }// Should
// not
// detect
// trailing
// option
, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(3, size);
assertEquals(BLEE_OPT, clOptions.get(0).getDescriptor().getId());
assertEquals(TAINT_OPT, clOptions.get(1).getDescriptor().getId());
assertEquals(0, clOptions.get(2).getDescriptor().getId());
assertEquals("-fa", clOptions.get(2).getArgument());
}
@Test
public void testCombinedArgs4() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { BLEE, TAINT, FILE };
final CLArgsParser parser = new CLArgsParser(new String[] { "-bT", "rest", "-fa" } // should
// detect
// trailing
// option
, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(4, size);
assertEquals(BLEE_OPT, clOptions.get(0).getDescriptor().getId());
assertEquals(TAINT_OPT, clOptions.get(1).getDescriptor().getId());
assertEquals(0, clOptions.get(2).getDescriptor().getId());
assertEquals("rest", clOptions.get(2).getArgument());
assertEquals(FILE_OPT, clOptions.get(3).getDescriptor().getId());
assertEquals("a", clOptions.get(3).getArgument());
}
@Test
public void test2ArgsParse() {
// "-Dstupid=idiot","are","--all","here"
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE, ALL, CLEAR1, CASE_CHECK };
final CLArgsParser parser = new CLArgsParser(ARGLIST2, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(size, 5);
assertEquals(clOptions.get(0).getDescriptor().getId(), DEFINE_OPT);
assertEquals(clOptions.get(1).getDescriptor().getId(), 0);
assertEquals(clOptions.get(2).getDescriptor().getId(), ALL_OPT);
assertEquals(clOptions.get(3).getDescriptor().getId(), 0);
assertEquals(clOptions.get(4).getDescriptor().getId(), CASE_CHECK_OPT);
final CLOption option = clOptions.get(0);
assertEquals("stupid", option.getArgument(0));
assertEquals("idiot", option.getArgument(1));
}
@Test
public void test2ArgsParse2() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE };
final CLArgsParser parser = new CLArgsParser(new String[] { "--define", "a-b,c=d-e,f" }, // Check
// "-"
// is
// allowed
// in
// arg2
options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(1, size);
assertEquals(DEFINE_OPT, clOptions.get(0).getDescriptor().getId());
final CLOption option = clOptions.get(0);
assertEquals("a-b,c", option.getArgument(0));
assertEquals("d-e,f", option.getArgument(1));
}
@Test
public void test2ArgsParse3() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE };
final CLArgsParser parser = new CLArgsParser(new String[] { "-D", "A-b,c", "G-e,f" }, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(1, size);
assertEquals(DEFINE_OPT, clOptions.get(0).getDescriptor().getId());
final CLOption option = clOptions.get(0);
assertEquals("A-b,c", option.getArgument(0));
assertEquals("G-e,f", option.getArgument(1));
}
@Test
public void test2ArgsParse4() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE_MANY };
final CLArgsParser parser = new CLArgsParser(new String[] { "-Dval1=-1", "-D", "val2=-2", "--define=val-3=-3",
"--define", "val4-=-4" }, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(4, size);
for (CLOption clOption : clOptions) {
assertEquals(DEFINE_OPT, clOption.getDescriptor().getId());
}
CLOption option;
option = clOptions.get(0);
assertEquals("val1", option.getArgument(0));
assertEquals("-1", option.getArgument(1));
option = clOptions.get(1);
assertEquals("val2", option.getArgument(0));
assertEquals("-2", option.getArgument(1));
option = clOptions.get(2);
assertEquals("val-3", option.getArgument(0));
assertEquals("-3", option.getArgument(1));
option = clOptions.get(3);
assertEquals("val4-", option.getArgument(0));
assertEquals("-4", option.getArgument(1));
}
@Test
public void testPartParse() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { YOU };
final ParserControl control = new AbstractParserControl() {
@Override
public boolean isFinished(int lastOptionCode) {
return (lastOptionCode == YOU_OPT);
}
};
final CLArgsParser parser = new CLArgsParser(ARGLIST1, options, control);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(size, 1);
assertEquals(clOptions.get(0).getDescriptor().getId(), YOU_OPT);
}
@Test
public void test2PartParse() {
final CLOptionDescriptor[] options1 = new CLOptionDescriptor[] { YOU };
final CLOptionDescriptor[] options2 = new CLOptionDescriptor[] { ALL, CLEAR1, CLEAR2, CLEAR3, CLEAR5 };
final ParserControl control1 = new AbstractParserControl() {
@Override
public boolean isFinished(int lastOptionCode) {
return (lastOptionCode == YOU_OPT);
}
};
final CLArgsParser parser1 = new CLArgsParser(ARGLIST1, options1, control1);
assertNull(parser1.getErrorString(), parser1.getErrorString());
final List<CLOption> clOptions1 = parser1.getArguments();
final int size1 = clOptions1.size();
assertEquals(size1, 1);
assertEquals(clOptions1.get(0).getDescriptor().getId(), YOU_OPT);
final CLArgsParser parser2 = new CLArgsParser(parser1.getUnparsedArgs(), options2);
assertNull(parser2.getErrorString(), parser2.getErrorString());
final List<CLOption> clOptions2 = parser2.getArguments();
final int size2 = clOptions2.size();
assertEquals(size2, 7);
assertEquals(clOptions2.get(0).getDescriptor().getId(), 0);
assertEquals(clOptions2.get(1).getDescriptor().getId(), ALL_OPT);
assertEquals(clOptions2.get(2).getDescriptor().getId(), CLEAR1_OPT);
assertEquals(clOptions2.get(3).getDescriptor().getId(), CLEAR2_OPT);
assertEquals(clOptions2.get(4).getDescriptor().getId(), CLEAR3_OPT);
assertEquals(clOptions2.get(5).getDescriptor().getId(), CLEAR5_OPT);
assertEquals(clOptions2.get(6).getDescriptor().getId(), 0);
}
@Test
public void test2PartPartialParse() {
final CLOptionDescriptor[] options1 = new CLOptionDescriptor[] { YOU, ALL, CLEAR1 };
final CLOptionDescriptor[] options2 = new CLOptionDescriptor[] {};
final ParserControl control1 = new AbstractParserControl() {
@Override
public boolean isFinished(final int lastOptionCode) {
return (lastOptionCode == CLEAR1_OPT);
}
};
final CLArgsParser parser1 = new CLArgsParser(ARGLIST1, options1, control1);
assertNull(parser1.getErrorString(), parser1.getErrorString());
final List<CLOption> clOptions1 = parser1.getArguments();
final int size1 = clOptions1.size();
assertEquals(size1, 4);
assertEquals(clOptions1.get(0).getDescriptor().getId(), YOU_OPT);
assertEquals(clOptions1.get(1).getDescriptor().getId(), 0);
assertEquals(clOptions1.get(2).getDescriptor().getId(), ALL_OPT);
assertEquals(clOptions1.get(3).getDescriptor().getId(), CLEAR1_OPT);
assertEquals("ler",parser1.getUnparsedArgs()[0]);
final CLArgsParser parser2 = new CLArgsParser(parser1.getUnparsedArgs(), options2);
assertNull(parser2.getErrorString(), parser2.getErrorString());
final List<CLOption> clOptions2 = parser2.getArguments();
final int size2 = clOptions2.size();
assertEquals(size2, 2);
assertEquals(clOptions2.get(0).getDescriptor().getId(), 0);
assertEquals(clOptions2.get(1).getDescriptor().getId(), 0);
}
@Test
public void testDuplicatesFail() {
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { YOU, ALL, CLEAR1, CLEAR2, CLEAR3, CLEAR5 };
final CLArgsParser parser = new CLArgsParser(ARGLIST1, options);
assertNull(parser.getErrorString(), parser.getErrorString());
}
@Test
public void testIncomplete2Args() {
// "-Dstupid="
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE };
final CLArgsParser parser = new CLArgsParser(new String[] { "-Dstupid=" }, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(size, 1);
final CLOption option = clOptions.get(0);
assertEquals(option.getDescriptor().getId(), DEFINE_OPT);
assertEquals(option.getArgument(0), "stupid");
assertEquals(option.getArgument(1), "");
}
@Test
public void testIncomplete2ArgsMixed() {
// "-Dstupid=","-c"
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE, CLEAR1 };
final String[] args = new String[] { "-Dstupid=", "-c" };
final CLArgsParser parser = new CLArgsParser(args, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(size, 2);
assertEquals(clOptions.get(1).getDescriptor().getId(), CLEAR1_OPT);
final CLOption option = clOptions.get(0);
assertEquals(option.getDescriptor().getId(), DEFINE_OPT);
assertEquals(option.getArgument(0), "stupid");
assertEquals(option.getArgument(1), "");
}
@Test
public void testIncomplete2ArgsMixedNoEq() {
// "-Dstupid","-c"
final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE, CLEAR1 };
final String[] args = new String[] { "-DStupid", "-c" };
final CLArgsParser parser = new CLArgsParser(args, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
assertEquals(size, 2);
assertEquals(clOptions.get(1).getDescriptor().getId(), CLEAR1_OPT);
final CLOption option = clOptions.get(0);
assertEquals(option.getDescriptor().getId(), DEFINE_OPT);
assertEquals(option.getArgument(0), "Stupid");
assertEquals(option.getArgument(1), "");
}
/**
* Test the getArgumentById and getArgumentByName lookup methods.
*/
@Test
public void testArgumentLookup() {
final String[] args = { "-f", "testarg" };
final CLOptionDescriptor[] options = { FILE };
final CLArgsParser parser = new CLArgsParser(args, options);
assertNull(parser.getErrorString(), parser.getErrorString());
CLOption optionById = parser.getArgumentById(FILE_OPT);
assertNotNull(optionById);
assertEquals(FILE_OPT, optionById.getDescriptor().getId());
assertEquals("testarg", optionById.getArgument());
CLOption optionByName = parser.getArgumentByName(FILE.getName());
assertNotNull(optionByName);
assertEquals(FILE_OPT, optionByName.getDescriptor().getId());
assertEquals("testarg", optionByName.getArgument());
}
/**
* Test that you can have null long forms.
*/
@Test
public void testNullLongForm() {
final CLOptionDescriptor test = new CLOptionDescriptor(null, CLOptionDescriptor.ARGUMENT_DISALLOWED, 'n',
"test null long form");
final String[] args = { "-n", "testarg" };
final CLOptionDescriptor[] options = { test };
final CLArgsParser parser = new CLArgsParser(args, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final CLOption optionByID = parser.getArgumentById('n');
assertNotNull(optionByID);
assertEquals('n', optionByID.getDescriptor().getId());
final CLOption optionByName = parser.getArgumentByName(FILE.getName());
assertNull("Looking for non-existent option by name", optionByName);
}
/**
* Test that you can have null descriptions.
*/
@Test
public void testNullDescription() {
final CLOptionDescriptor test = new CLOptionDescriptor("nulltest", CLOptionDescriptor.ARGUMENT_DISALLOWED, 'n',
null);
final String[] args = { "-n", "testarg" };
final CLOptionDescriptor[] options = { test };
final CLArgsParser parser = new CLArgsParser(args, options);
assertNull(parser.getErrorString(), parser.getErrorString());
final CLOption optionByID = parser.getArgumentById('n');
assertNotNull(optionByID);
assertEquals('n', optionByID.getDescriptor().getId());
final StringBuilder sb = CLUtil.describeOptions(options);
final String lineSeparator = System.getProperty("line.separator");
assertEquals("Testing display of null description", "\t-n, --nulltest" + lineSeparator, sb.toString());
}
@Test
public void testCombinations() throws Exception {
check(new String [] {},"");
check(new String [] {"--none",
"-0"
},
"-0 -0"); // Canonical form
check(new String [] {"--one=a",
"--one","A",
"-1b",
"-1=c",
"-1","d"
},
"-1=[a] -1=[A] -1=[b] -1=[c] -1=[d]");
check(new String [] {"-2n=v",
"-2","N=V"
},
"-2=[n, v] -2=[N, V]");
check(new String [] {"--two=n=v",
"--two","N=V"
},
"-2=[n, v] -2=[N, V]");
// Test optional arguments
check(new String [] {"-?",
"A", // Separate argument
"-?=B",
"-?C",
"-?"
},
"-? [A] -?=[B] -?=[C] -?");
check(new String [] {"--optional=A", // OK
"--optional","B", // should treat B as separate
"--optional" // Should have no arg
},
"-?=[A] -? [B] -?");
}
private void check(String args[], String canon){
final CLArgsParser parser = new CLArgsParser(args, OPTIONS);
assertNull(parser.getErrorString(),parser.getErrorString());
final List<CLOption> clOptions = parser.getArguments();
final int size = clOptions.size();
StringBuilder sb = new StringBuilder();
for (int i=0; i< size; i++){
if (i>0) {
sb.append(" ");
}
sb.append(clOptions.get(i).toShortString());
}
assertEquals("Canonical form ("+size+")",canon,sb.toString());
}
/*
* TODO add tests to check for: - name clash - long option abbreviations
* (match shortest unique abbreviation)
*/
}