001: package jargs.test.gnu;
002:
003: import jargs.gnu.CmdLineParser;
004:
005: import java.util.Enumeration;
006: import java.util.Locale;
007: import java.util.Vector;
008:
009: import junit.framework.TestCase;
010:
011: public class CmdLineParserTestCase extends TestCase {
012:
013: public CmdLineParserTestCase(String name) {
014: super (name);
015: }
016:
017: public void testStandardOptions() throws Exception {
018: CmdLineParser parser = new CmdLineParser();
019: CmdLineParser.Option verbose = parser.addBooleanOption('v',
020: "verbose");
021: CmdLineParser.Option size = parser
022: .addIntegerOption('s', "size");
023: CmdLineParser.Option name = parser.addStringOption('n', "name");
024: CmdLineParser.Option fraction = parser.addDoubleOption('f',
025: "fraction");
026: CmdLineParser.Option missing = parser.addBooleanOption('m',
027: "missing");
028: CmdLineParser.Option careful = parser
029: .addBooleanOption("careful");
030: CmdLineParser.Option bignum = parser.addLongOption('b',
031: "bignum");
032: assertEquals(null, parser.getOptionValue(size));
033: Long longValue = new Long(new Long(Integer.MAX_VALUE)
034: .longValue() + 1);
035: parser.parse(
036: new String[] { "-v", "--size=100", "-b",
037: longValue.toString(), "-n", "foo", "-f", "0.1",
038: "rest" }, Locale.US);
039: assertEquals(null, parser.getOptionValue(missing));
040: assertEquals(Boolean.TRUE, parser.getOptionValue(verbose));
041: assertEquals(100, ((Integer) parser.getOptionValue(size))
042: .intValue());
043: assertEquals("foo", parser.getOptionValue(name));
044: assertEquals(longValue, parser.getOptionValue(bignum));
045: assertEquals(0.1, ((Double) parser.getOptionValue(fraction))
046: .doubleValue(), 0.1e-6);
047: assertArrayEquals(new String[] { "rest" }, parser
048: .getRemainingArgs());
049: }
050:
051: public void testDefaults() throws Exception {
052: CmdLineParser parser = new CmdLineParser();
053: CmdLineParser.Option boolean1 = parser
054: .addBooleanOption("boolean1");
055: CmdLineParser.Option boolean2 = parser
056: .addBooleanOption("boolean2");
057: CmdLineParser.Option boolean3 = parser
058: .addBooleanOption("boolean3");
059: CmdLineParser.Option boolean4 = parser
060: .addBooleanOption("boolean4");
061: CmdLineParser.Option boolean5 = parser
062: .addBooleanOption("boolean5");
063:
064: CmdLineParser.Option int1 = parser.addIntegerOption("int1");
065: CmdLineParser.Option int2 = parser.addIntegerOption("int2");
066: CmdLineParser.Option int3 = parser.addIntegerOption("int3");
067: CmdLineParser.Option int4 = parser.addIntegerOption("int4");
068:
069: CmdLineParser.Option string1 = parser
070: .addStringOption("string1");
071: CmdLineParser.Option string2 = parser
072: .addStringOption("string2");
073: CmdLineParser.Option string3 = parser
074: .addStringOption("string3");
075: CmdLineParser.Option string4 = parser
076: .addStringOption("string4");
077:
078: parser.parse(new String[] { "--boolean1", "--boolean2",
079: "--int1=42", "--int2=42", "--string1=Hello",
080: "--string2=Hello", });
081:
082: assertEquals(Boolean.TRUE, parser.getOptionValue(boolean1));
083: assertEquals(Boolean.TRUE, parser.getOptionValue(boolean2,
084: Boolean.FALSE));
085: assertEquals(null, parser.getOptionValue(boolean3));
086: assertEquals(Boolean.FALSE, parser.getOptionValue(boolean4,
087: Boolean.FALSE));
088: assertEquals(Boolean.TRUE, parser.getOptionValue(boolean5,
089: Boolean.TRUE));
090:
091: Integer forty_two = new Integer(42);
092: Integer thirty_six = new Integer(36);
093:
094: assertEquals(forty_two, parser.getOptionValue(int1));
095: assertEquals(forty_two, parser.getOptionValue(int2, thirty_six));
096: assertEquals(null, parser.getOptionValue(int3));
097: assertEquals(thirty_six, parser
098: .getOptionValue(int4, thirty_six));
099:
100: assertEquals("Hello", parser.getOptionValue(string1));
101: assertEquals("Hello", parser.getOptionValue(string2, "Goodbye"));
102: assertEquals(null, parser.getOptionValue(string3));
103: assertEquals("Goodbye", parser.getOptionValue(string4,
104: "Goodbye"));
105: }
106:
107: public void testMultipleUses() throws Exception {
108: CmdLineParser parser = new CmdLineParser();
109: CmdLineParser.Option verbose = parser.addBooleanOption('v',
110: "verbose");
111: CmdLineParser.Option foo = parser.addBooleanOption('f', "foo");
112: CmdLineParser.Option bar = parser.addBooleanOption('b', "bar");
113:
114: parser.parse(new String[] { "--foo", "-v", "-v", "--verbose",
115: "-v", "-b", "rest" });
116:
117: int verbosity = 0;
118: while (true) {
119: Boolean b = (Boolean) parser.getOptionValue(verbose);
120:
121: if (b == null) {
122: break;
123: }
124:
125: if (b == Boolean.TRUE) {
126: verbosity++;
127: } else {
128: assertEquals(Boolean.FALSE, b);
129: verbosity--;
130: }
131: }
132:
133: assertEquals(4, verbosity);
134: }
135:
136: public void testCombinedFlags() throws Exception {
137: CmdLineParser parser = new CmdLineParser();
138: CmdLineParser.Option alt = parser.addBooleanOption('a', "alt");
139: CmdLineParser.Option debug = parser.addBooleanOption('d',
140: "debug");
141: CmdLineParser.Option verbose = parser.addBooleanOption('v',
142: "verbose");
143: parser.parse(new String[] { "-dv" });
144:
145: assertEquals(null, parser.getOptionValue(alt));
146: assertEquals(Boolean.TRUE, parser.getOptionValue(debug));
147: assertEquals(Boolean.TRUE, parser.getOptionValue(verbose));
148: }
149:
150: public void testExplictlyTerminatedOptions() throws Exception {
151: CmdLineParser parser = new CmdLineParser();
152: CmdLineParser.Option alt = parser.addBooleanOption('a', "alt");
153: CmdLineParser.Option debug = parser.addBooleanOption('d',
154: "debug");
155: CmdLineParser.Option verbose = parser.addBooleanOption('v',
156: "verbose");
157: CmdLineParser.Option fraction = parser.addDoubleOption('f',
158: "fraction");
159: parser.parse(new String[] { "-a", "hello", "-d", "-f", "10",
160: "--", "goodbye", "-v", "welcome", "-f", "-10" });
161:
162: assertEquals(Boolean.TRUE, parser.getOptionValue(alt));
163: assertEquals(Boolean.TRUE, parser.getOptionValue(debug));
164: assertEquals(null, parser.getOptionValue(verbose));
165: assertEquals(new Double(10), parser.getOptionValue(fraction));
166:
167: assertArrayEquals(new String[] { "hello", "goodbye", "-v",
168: "welcome", "-f", "-10" }, parser.getRemainingArgs());
169: }
170:
171: public void testGetOptionValues() throws Exception {
172: CmdLineParser parser = new CmdLineParser();
173: CmdLineParser.Option verbose = parser.addBooleanOption('v',
174: "verbose");
175: CmdLineParser.Option foo = parser.addBooleanOption('f', "foo");
176: CmdLineParser.Option bar = parser.addBooleanOption('b', "bar");
177:
178: parser.parse(new String[] { "--foo", "-v", "-v", "--verbose",
179: "-v", "-b", "rest" });
180:
181: int verbosity = 0;
182: Vector v = parser.getOptionValues(verbose);
183: Enumeration e = v.elements();
184: while (e.hasMoreElements()) {
185: Boolean b = (Boolean) e.nextElement();
186:
187: if (b == Boolean.TRUE) {
188: verbosity++;
189: } else {
190: assertEquals(Boolean.FALSE, b);
191: verbosity--;
192: }
193: }
194:
195: assertEquals(4, verbosity);
196: }
197:
198: public void testBadFormat() throws Exception {
199: CmdLineParser parser = new CmdLineParser();
200: CmdLineParser.Option size = parser
201: .addIntegerOption('s', "size");
202: try {
203: parser.parse(new String[] { "--size=blah" });
204: fail("Expected IllegalOptionValueException");
205: } catch (CmdLineParser.IllegalOptionValueException e) {
206: // pass
207: }
208: }
209:
210: public void testResetBetweenParse() throws Exception {
211: CmdLineParser parser = new CmdLineParser();
212: CmdLineParser.Option verbose = parser.addBooleanOption('v',
213: "verbose");
214: parser.parse(new String[] { "-v" });
215: assertEquals(Boolean.TRUE, parser.getOptionValue(verbose));
216: parser.parse(new String[] {});
217: assertEquals(null, parser.getOptionValue(verbose));
218: }
219:
220: public void testLocale() throws Exception {
221: CmdLineParser parser = new CmdLineParser();
222: CmdLineParser.Option fraction = parser.addDoubleOption('f',
223: "fraction");
224: parser.parse(new String[] { "--fraction=0.2" }, Locale.US);
225: assertEquals(0.2, ((Double) parser.getOptionValue(fraction))
226: .doubleValue(), 0.1e-6);
227: parser.parse(new String[] { "--fraction=0,2" }, Locale.GERMANY);
228: assertEquals(0.2, ((Double) parser.getOptionValue(fraction))
229: .doubleValue(), 0.1e-6);
230: }
231:
232: public void testDetachedOption() throws Exception {
233: CmdLineParser parser = new CmdLineParser();
234: CmdLineParser.Option detached = new CmdLineParser.Option.BooleanOption(
235: 'v', "verbose");
236: assertEquals(null, parser.getOptionValue(detached));
237: try {
238: parser.parse(new String[] { "-v" });
239: fail("UnknownOptionException expected");
240: } catch (CmdLineParser.UnknownOptionException e) {
241: // pass
242: }
243: assertEquals(null, parser.getOptionValue(detached));
244: }
245:
246: public void testMissingValueForStringOption() throws Exception {
247: CmdLineParser parser = new CmdLineParser();
248: parser.addBooleanOption('v', "verbose");
249: parser.addStringOption('c', "config");
250:
251: try {
252: parser.parse(new String[] { "-v", "-c" });
253: fail();
254: } catch (CmdLineParser.IllegalOptionValueException e) {
255: }
256: }
257:
258: private void assertArrayEquals(Object[] expected, Object[] actual) {
259: assertNotNull(actual);
260: assertEquals(expected.length, actual.length);
261: for (int i = 0; i < expected.length; ++i) {
262: assertEquals(expected[i], actual[i]);
263: }
264: }
265:
266: }
|