1 /*
2 * Copyright 2002-2005 The Apache Software Foundation
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
12 * implied.
13 *
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17 package org.apache.commons.cli.avalon;
18
19 // Renamed from org.apache.avalon.excalibur.cli
20
21 import java.util.List;
22
23 import junit.framework.TestCase;
24
25 /**
26 *
27 */
28 public final class ClutilTestCase extends TestCase {
29 private static final String[] ARGLIST1 = new String[] { "--you", "are", "--all", "-cler", "kid" };
30
31 private static final String[] ARGLIST2 = new String[] { "-Dstupid=idiot", "are", "--all", "here", "-d" };
32
33 private static final String[] ARGLIST3 = new String[] {
34 // duplicates
35 "-Dstupid=idiot", "are", "--all", "--all", "here" };
36
37 private static final String[] ARGLIST4 = new String[] {
38 // incompatable (blee/all)
39 "-Dstupid", "idiot", "are", "--all", "--blee", "here" };
40
41 private static final String[] ARGLIST5 = new String[] { "-f", "myfile.txt" };
42
43 private static final int DEFINE_OPT = 'D';
44
45 private static final int CASE_CHECK_OPT = 'd';
46
47 private static final int YOU_OPT = 'y';
48
49 private static final int ALL_OPT = 'a';
50
51 private static final int CLEAR1_OPT = 'c';
52
53 private static final int CLEAR2_OPT = 'l';
54
55 private static final int CLEAR3_OPT = 'e';
56
57 private static final int CLEAR5_OPT = 'r';
58
59 private static final int BLEE_OPT = 'b';
60
61 private static final int FILE_OPT = 'f';
62
63 private static final int TAINT_OPT = 'T';
64
65 private static final CLOptionDescriptor DEFINE = new CLOptionDescriptor("define",
66 CLOptionDescriptor.ARGUMENTS_REQUIRED_2, DEFINE_OPT, "define");
67
68 private static final CLOptionDescriptor DEFINE_MANY = new CLOptionDescriptor("define",
69 CLOptionDescriptor.ARGUMENTS_REQUIRED_2 | CLOptionDescriptor.DUPLICATES_ALLOWED, DEFINE_OPT, "define");
70
71 private static final CLOptionDescriptor CASE_CHECK = new CLOptionDescriptor("charCheck",
72 CLOptionDescriptor.ARGUMENT_DISALLOWED, CASE_CHECK_OPT, "check character case sensitivity");
73
74 private static final CLOptionDescriptor YOU = new CLOptionDescriptor("you", CLOptionDescriptor.ARGUMENT_DISALLOWED,
75 YOU_OPT, "you");
76
77 private static final CLOptionDescriptor CLEAR1 = new CLOptionDescriptor("c",
78 CLOptionDescriptor.ARGUMENT_DISALLOWED, CLEAR1_OPT, "c");
79
80 private static final CLOptionDescriptor CLEAR2 = new CLOptionDescriptor("l",
81 CLOptionDescriptor.ARGUMENT_DISALLOWED, CLEAR2_OPT, "l");
82
83 private static final CLOptionDescriptor CLEAR3 = new CLOptionDescriptor("e",
84 CLOptionDescriptor.ARGUMENT_DISALLOWED, CLEAR3_OPT, "e");
85
86 private static final CLOptionDescriptor CLEAR5 = new CLOptionDescriptor("r",
87 CLOptionDescriptor.ARGUMENT_DISALLOWED, CLEAR5_OPT, "r");
88
89 private static final CLOptionDescriptor BLEE = new CLOptionDescriptor("blee",
90 CLOptionDescriptor.ARGUMENT_DISALLOWED, BLEE_OPT, "blee");
91
92 private static final CLOptionDescriptor ALL = new CLOptionDescriptor("all", CLOptionDescriptor.ARGUMENT_DISALLOWED,
93 ALL_OPT, "all", new CLOptionDescriptor[] { BLEE });
94
95 private static final CLOptionDescriptor FILE = new CLOptionDescriptor("file", CLOptionDescriptor.ARGUMENT_REQUIRED,
96 FILE_OPT, "the build file.");
97
98 private static final CLOptionDescriptor TAINT = new CLOptionDescriptor("taint",
99 CLOptionDescriptor.ARGUMENT_OPTIONAL, TAINT_OPT, "turn on tainting checks (optional level).");
100
101 public ClutilTestCase() {
102 this("Command Line Interpreter Test Case");
103 }
104
105 public ClutilTestCase(String name) {
106 super(name);
107 }
108
109 public void testOptionalArgWithSpace() {
110 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { ALL, TAINT };
111
112 final String[] args = new String[] { "-T", "param", "-a" };
113
114 final CLArgsParser parser = new CLArgsParser(args, options);
115
116 assertNull(parser.getErrorString(), parser.getErrorString());
117
118 final List clOptions = parser.getArguments();
119 final int size = clOptions.size();
120
121 assertEquals("Option count", 3, size);
122
123 final CLOption option0 = (CLOption) clOptions.get(0);
124 assertEquals("Option Code: " + option0.getDescriptor().getId(), TAINT_OPT, option0.getDescriptor().getId());
125 assertEquals("Option Arg: " + option0.getArgument(0), null, option0.getArgument(0));
126
127 final CLOption option1 = (CLOption) clOptions.get(1);
128 assertEquals(option1.getDescriptor().getId(), CLOption.TEXT_ARGUMENT);
129 assertEquals(option1.getArgument(0), "param");
130
131 final CLOption option2 = (CLOption) clOptions.get(2);
132 assertEquals(option2.getDescriptor().getId(), ALL_OPT);
133 assertEquals(option2.getArgument(0), null);
134 }
135
136 public void testOptionalArgLong() {
137 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { ALL, TAINT };
138
139 // Check that optional args work woth long options
140 final String[] args = new String[] { "--taint", "param", "-a" };
141
142 final CLArgsParser parser = new CLArgsParser(args, options);
143
144 assertNull(parser.getErrorString(), parser.getErrorString());
145
146 final List clOptions = parser.getArguments();
147 final int size = clOptions.size();
148
149 assertEquals("Option count", 3, size);
150
151 final CLOption option0 = (CLOption) clOptions.get(0);
152 assertEquals("Option Code: " + option0.getDescriptor().getId(), TAINT_OPT, option0.getDescriptor().getId());
153 assertEquals("Option Arg: " + option0.getArgument(0), null, option0.getArgument(0));
154
155 final CLOption option1 = (CLOption) clOptions.get(1);
156 assertEquals(CLOption.TEXT_ARGUMENT, option1.getDescriptor().getId());
157 assertEquals("param", option1.getArgument(0));
158
159 final CLOption option2 = (CLOption) clOptions.get(2);
160 assertEquals(option2.getDescriptor().getId(), ALL_OPT);
161 assertEquals(option2.getArgument(0), null);
162 }
163
164 public void testShortOptArgUnenteredBeforeOtherOpt() {
165 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { ALL, TAINT };
166
167 final String[] args = new String[] { "-T", "-a" };
168
169 final CLArgsParser parser = new CLArgsParser(args, options);
170
171 assertNull(parser.getErrorString(), parser.getErrorString());
172
173 final List clOptions = parser.getArguments();
174 final int size = clOptions.size();
175
176 assertEquals("Option count", 2, size);
177
178 final CLOption option0 = (CLOption) clOptions.get(0);
179 assertEquals("Option Code: " + option0.getDescriptor().getId(), TAINT_OPT, option0.getDescriptor().getId());
180 assertEquals("Option Arg: " + option0.getArgument(0), null, option0.getArgument(0));
181
182 final CLOption option1 = (CLOption) clOptions.get(1);
183 assertEquals(option1.getDescriptor().getId(), ALL_OPT);
184 assertEquals(option1.getArgument(0), null);
185 }
186
187 public void testOptionalArgsWithArgShortBeforeOtherOpt() {
188 // "-T3","-a"
189 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { ALL, TAINT };
190
191 final String[] args = new String[] { "-T3", "-a" };
192
193 // System.out.println("[before parsing]");
194
195 final CLArgsParser parser = new CLArgsParser(args, options);
196
197 // System.out.println("[after parsing]");
198
199 assertNull(parser.getErrorString(), parser.getErrorString());
200
201 final List clOptions = parser.getArguments();
202 final int size = clOptions.size();
203
204 assertEquals(size, 2);
205 final CLOption option0 = (CLOption) clOptions.get(0);
206 assertEquals(option0.getDescriptor().getId(), TAINT_OPT);
207 assertEquals(option0.getArgument(0), "3");
208
209 final CLOption option1 = (CLOption) clOptions.get(1);
210 assertEquals(ALL_OPT, option1.getDescriptor().getId());
211 assertEquals(null, option1.getArgument(0));
212 }
213
214 public void testOptionalArgsNoArgShortBeforeOtherOpt() {
215 // "-T","-a"
216 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { ALL, TAINT };
217
218 final String[] args = new String[] { "-T", "-a" };
219
220 // System.out.println("[before parsing]");
221 final CLArgsParser parser = new CLArgsParser(args, options);
222
223 // System.out.println("[after parsing]");
224
225 assertNull(parser.getErrorString(), parser.getErrorString());
226
227 final List clOptions = parser.getArguments();
228 final int size = clOptions.size();
229
230 assertEquals(size, 2);
231 final CLOption option0 = (CLOption) clOptions.get(0);
232 assertEquals(TAINT_OPT, option0.getDescriptor().getId());
233 assertEquals(null, option0.getArgument(0));
234
235 final CLOption option1 = (CLOption) clOptions.get(1);
236 assertEquals(ALL_OPT, option1.getDescriptor().getId());
237 assertEquals(null, option1.getArgument(0));
238 }
239
240 public void testFullParse() {
241 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { YOU, ALL, CLEAR1, CLEAR2, CLEAR3, CLEAR5 };
242
243 final CLArgsParser parser = new CLArgsParser(ARGLIST1, options);
244
245 assertNull(parser.getErrorString(), parser.getErrorString());
246
247 final List clOptions = parser.getArguments();
248 final int size = clOptions.size();
249
250 assertEquals(size, 8);
251 assertEquals(((CLOption) clOptions.get(0)).getDescriptor().getId(), YOU_OPT);
252 assertEquals(((CLOption) clOptions.get(1)).getDescriptor().getId(), 0);
253 assertEquals(((CLOption) clOptions.get(2)).getDescriptor().getId(), ALL_OPT);
254 assertEquals(((CLOption) clOptions.get(3)).getDescriptor().getId(), CLEAR1_OPT);
255 assertEquals(((CLOption) clOptions.get(4)).getDescriptor().getId(), CLEAR2_OPT);
256 assertEquals(((CLOption) clOptions.get(5)).getDescriptor().getId(), CLEAR3_OPT);
257 assertEquals(((CLOption) clOptions.get(6)).getDescriptor().getId(), CLEAR5_OPT);
258 assertEquals(((CLOption) clOptions.get(7)).getDescriptor().getId(), 0);
259 }
260
261 public void testDuplicateOptions() {
262 // "-Dstupid=idiot","are","--all","--all","here"
263 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE, ALL, CLEAR1 };
264
265 final CLArgsParser parser = new CLArgsParser(ARGLIST3, options);
266
267 assertNull(parser.getErrorString(), parser.getErrorString());
268
269 final List clOptions = parser.getArguments();
270 final int size = clOptions.size();
271
272 assertEquals(size, 5);
273 assertEquals(((CLOption) clOptions.get(0)).getDescriptor().getId(), DEFINE_OPT);
274 assertEquals(((CLOption) clOptions.get(1)).getDescriptor().getId(), 0);
275 assertEquals(((CLOption) clOptions.get(2)).getDescriptor().getId(), ALL_OPT);
276 assertEquals(((CLOption) clOptions.get(3)).getDescriptor().getId(), ALL_OPT);
277 assertEquals(((CLOption) clOptions.get(4)).getDescriptor().getId(), 0);
278 }
279
280 public void testIncompatableOptions() {
281 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE, ALL, CLEAR1, BLEE };
282
283 final CLArgsParser parser = new CLArgsParser(ARGLIST4, options);
284
285 assertNotNull(parser.getErrorString());
286
287 final List clOptions = parser.getArguments();
288 final int size = clOptions.size();
289
290 assertEquals(size, 5);
291 assertEquals(((CLOption) clOptions.get(0)).getDescriptor().getId(), DEFINE_OPT);
292 assertEquals(((CLOption) clOptions.get(1)).getDescriptor().getId(), 0);
293 assertEquals(((CLOption) clOptions.get(2)).getDescriptor().getId(), ALL_OPT);
294 assertEquals(((CLOption) clOptions.get(3)).getDescriptor().getId(), BLEE_OPT);
295 assertEquals(((CLOption) clOptions.get(4)).getDescriptor().getId(), 0);
296 }
297
298 public void testSingleArg() {
299 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { FILE };
300
301 final CLArgsParser parser = new CLArgsParser(ARGLIST5, options);
302
303 assertNull(parser.getErrorString(), parser.getErrorString());
304
305 final List clOptions = parser.getArguments();
306 final int size = clOptions.size();
307
308 assertEquals(size, 1);
309 assertEquals(((CLOption) clOptions.get(0)).getDescriptor().getId(), FILE_OPT);
310 assertEquals(((CLOption) clOptions.get(0)).getArgument(), "myfile.txt");
311 }
312
313 public void testSingleArg2() {
314 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { FILE };
315
316 final CLArgsParser parser = new CLArgsParser(new String[] { "-f-=,=-" } // Check
317 // delimiters
318 // are
319 // allowed
320 , options);
321
322 assertNull(parser.getErrorString(), parser.getErrorString());
323
324 final List clOptions = parser.getArguments();
325 final int size = clOptions.size();
326
327 assertEquals(1, size);
328 assertEquals(FILE_OPT, ((CLOption) clOptions.get(0)).getDescriptor().getId());
329 assertEquals("-=,=-", ((CLOption) clOptions.get(0)).getArgument());
330 }
331
332 public void testSingleArg3() {
333 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { FILE };
334
335 final CLArgsParser parser = new CLArgsParser(new String[] { "--file=-=,-" } // Check
336 // delimiters
337 // are
338 // allowed
339 , options);
340
341 assertNull(parser.getErrorString(), parser.getErrorString());
342
343 final List clOptions = parser.getArguments();
344 final int size = clOptions.size();
345
346 assertEquals(1, size);
347 assertEquals(FILE_OPT, ((CLOption) clOptions.get(0)).getDescriptor().getId());
348 assertEquals("-=,-", ((CLOption) clOptions.get(0)).getArgument());
349 }
350
351 public void testSingleArg4() {
352 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { FILE };
353
354 final CLArgsParser parser = new CLArgsParser(new String[] { "--file", "myfile.txt" }, options);
355
356 assertNull(parser.getErrorString(), parser.getErrorString());
357
358 final List clOptions = parser.getArguments();
359 final int size = clOptions.size();
360
361 assertEquals(1, size);
362 assertEquals(FILE_OPT, ((CLOption) clOptions.get(0)).getDescriptor().getId());
363 assertEquals("myfile.txt", ((CLOption) clOptions.get(0)).getArgument());
364 }
365
366 public void testSingleArg5() {
367 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { FILE };
368
369 final CLArgsParser parser = new CLArgsParser(new String[] { "-f", "myfile.txt" }, options);
370
371 assertNull(parser.getErrorString(), parser.getErrorString());
372
373 final List clOptions = parser.getArguments();
374 final int size = clOptions.size();
375
376 assertEquals(1, size);
377 assertEquals(FILE_OPT, ((CLOption) clOptions.get(0)).getDescriptor().getId());
378 assertEquals("myfile.txt", ((CLOption) clOptions.get(0)).getArgument());
379 }
380
381 public void testSingleArg6() {
382 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { FILE };
383
384 final CLArgsParser parser = new CLArgsParser(new String[] { "-f", "-=-" }, options);
385
386 assertNull(parser.getErrorString(), parser.getErrorString());
387
388 final List clOptions = parser.getArguments();
389 final int size = clOptions.size();
390
391 assertEquals(1, size);
392 assertEquals(FILE_OPT, ((CLOption) clOptions.get(0)).getDescriptor().getId());
393 assertEquals("-=-", ((CLOption) clOptions.get(0)).getArgument());
394 }
395
396 public void testSingleArg7() {
397 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { FILE };
398
399 final CLArgsParser parser = new CLArgsParser(new String[] { "--file=-=-" }, options);
400
401 assertNull(parser.getErrorString(), parser.getErrorString());
402
403 final List clOptions = parser.getArguments();
404 final int size = clOptions.size();
405
406 assertEquals(1, size);
407 assertEquals(FILE_OPT, ((CLOption) clOptions.get(0)).getDescriptor().getId());
408 assertEquals("-=-", ((CLOption) clOptions.get(0)).getArgument());
409 }
410
411 public void testSingleArg8() {
412 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { FILE };
413
414 final CLArgsParser parser = new CLArgsParser(new String[] { "--file", "-=-" }, options);
415
416 assertNull(parser.getErrorString(), parser.getErrorString());
417
418 final List clOptions = parser.getArguments();
419 final int size = clOptions.size();
420
421 assertEquals(1, size);
422 assertEquals(FILE_OPT, ((CLOption) clOptions.get(0)).getDescriptor().getId());
423 assertEquals("-=-", ((CLOption) clOptions.get(0)).getArgument());
424 }
425
426 public void testSingleArg9() {
427 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { FILE };
428
429 final CLArgsParser parser = new CLArgsParser(new String[] { "--file", "-=-" }, options);
430
431 assertNull(parser.getErrorString(), parser.getErrorString());
432
433 final List clOptions = parser.getArguments();
434 final int size = clOptions.size();
435
436 assertEquals(1, size);
437 assertEquals(FILE_OPT, ((CLOption) clOptions.get(0)).getDescriptor().getId());
438 assertEquals("-=-", ((CLOption) clOptions.get(0)).getArgument());
439 }
440
441 public void testCombinedArgs1() {
442 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { BLEE, TAINT };
443
444 final CLArgsParser parser = new CLArgsParser(new String[] { "-bT", "rest" }, options);
445
446 assertNull(parser.getErrorString(), parser.getErrorString());
447
448 final List clOptions = parser.getArguments();
449 final int size = clOptions.size();
450 assertEquals(3, size);
451 assertEquals(BLEE_OPT, ((CLOption) clOptions.get(0)).getDescriptor().getId());
452 assertEquals(TAINT_OPT, ((CLOption) clOptions.get(1)).getDescriptor().getId());
453 assertEquals(0, ((CLOption) clOptions.get(2)).getDescriptor().getId());
454 assertEquals("rest", ((CLOption) clOptions.get(2)).getArgument());
455 }
456
457 public void testCombinedArgs2() {
458 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { BLEE, TAINT, FILE };
459
460 final CLArgsParser parser = new CLArgsParser(new String[] { "-bT", "-fa" }, options);
461
462 assertNull(parser.getErrorString(), parser.getErrorString());
463
464 final List clOptions = parser.getArguments();
465 final int size = clOptions.size();
466 assertEquals(3, size);
467 assertEquals(BLEE_OPT, ((CLOption) clOptions.get(0)).getDescriptor().getId());
468 assertEquals(TAINT_OPT, ((CLOption) clOptions.get(1)).getDescriptor().getId());
469 assertEquals(FILE_OPT, ((CLOption) clOptions.get(2)).getDescriptor().getId());
470 assertEquals("a", ((CLOption) clOptions.get(2)).getArgument());
471 }
472
473 public void testCombinedArgs3() {
474 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { BLEE, TAINT, FILE };
475
476 final CLArgsParser parser = new CLArgsParser(new String[] { "-bT", "--", "-fa" }// Should
477 // not
478 // detect
479 // trailing
480 // option
481 , options);
482
483 assertNull(parser.getErrorString(), parser.getErrorString());
484
485 final List clOptions = parser.getArguments();
486 final int size = clOptions.size();
487 assertEquals(3, size);
488 assertEquals(BLEE_OPT, ((CLOption) clOptions.get(0)).getDescriptor().getId());
489 assertEquals(TAINT_OPT, ((CLOption) clOptions.get(1)).getDescriptor().getId());
490 assertEquals(0, ((CLOption) clOptions.get(2)).getDescriptor().getId());
491 assertEquals("-fa", ((CLOption) clOptions.get(2)).getArgument());
492 }
493
494 public void testCombinedArgs4() {
495 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { BLEE, TAINT, FILE };
496
497 final CLArgsParser parser = new CLArgsParser(new String[] { "-bT", "rest", "-fa" } // should
498 // detect
499 // trailing
500 // option
501 , options);
502
503 assertNull(parser.getErrorString(), parser.getErrorString());
504
505 final List clOptions = parser.getArguments();
506 final int size = clOptions.size();
507 assertEquals(4, size);
508 assertEquals(BLEE_OPT, ((CLOption) clOptions.get(0)).getDescriptor().getId());
509 assertEquals(TAINT_OPT, ((CLOption) clOptions.get(1)).getDescriptor().getId());
510 assertEquals(0, ((CLOption) clOptions.get(2)).getDescriptor().getId());
511 assertEquals("rest", ((CLOption) clOptions.get(2)).getArgument());
512 assertEquals(FILE_OPT, ((CLOption) clOptions.get(3)).getDescriptor().getId());
513 assertEquals("a", ((CLOption) clOptions.get(3)).getArgument());
514 }
515
516 public void test2ArgsParse() {
517 // "-Dstupid=idiot","are","--all","here"
518 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE, ALL, CLEAR1, CASE_CHECK };
519
520 final CLArgsParser parser = new CLArgsParser(ARGLIST2, options);
521
522 assertNull(parser.getErrorString(), parser.getErrorString());
523
524 final List clOptions = parser.getArguments();
525 final int size = clOptions.size();
526
527 assertEquals(size, 5);
528 assertEquals(((CLOption) clOptions.get(0)).getDescriptor().getId(), DEFINE_OPT);
529 assertEquals(((CLOption) clOptions.get(1)).getDescriptor().getId(), 0);
530 assertEquals(((CLOption) clOptions.get(2)).getDescriptor().getId(), ALL_OPT);
531 assertEquals(((CLOption) clOptions.get(3)).getDescriptor().getId(), 0);
532 assertEquals(((CLOption) clOptions.get(4)).getDescriptor().getId(), CASE_CHECK_OPT);
533
534 final CLOption option = (CLOption) clOptions.get(0);
535 assertEquals("stupid", option.getArgument(0));
536 assertEquals("idiot", option.getArgument(1));
537 }
538
539 public void test2ArgsParse2() {
540 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE };
541
542 final CLArgsParser parser = new CLArgsParser(new String[] { "--define", "a-b,c=d-e,f" }, // Check
543 // "-"
544 // is
545 // allowed
546 // in
547 // arg2
548 options);
549
550 assertNull(parser.getErrorString(), parser.getErrorString());
551
552 final List clOptions = parser.getArguments();
553 final int size = clOptions.size();
554
555 assertEquals(1, size);
556 assertEquals(DEFINE_OPT, ((CLOption) clOptions.get(0)).getDescriptor().getId());
557
558 final CLOption option = (CLOption) clOptions.get(0);
559 assertEquals("a-b,c", option.getArgument(0));
560 assertEquals("d-e,f", option.getArgument(1));
561 }
562
563 public void test2ArgsParse3() {
564 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE };
565
566 final CLArgsParser parser = new CLArgsParser(new String[] { "-D", "A-b,c", "G-e,f" }, options);
567
568 assertNull(parser.getErrorString(), parser.getErrorString());
569
570 final List clOptions = parser.getArguments();
571 final int size = clOptions.size();
572
573 assertEquals(1, size);
574 assertEquals(DEFINE_OPT, ((CLOption) clOptions.get(0)).getDescriptor().getId());
575
576 final CLOption option = (CLOption) clOptions.get(0);
577 assertEquals("A-b,c", option.getArgument(0));
578 assertEquals("G-e,f", option.getArgument(1));
579 }
580
581 public void test2ArgsParse4() {
582 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE_MANY };
583
584 final CLArgsParser parser = new CLArgsParser(new String[] { "-Dval1=-1", "-D", "val2=-2", "--define=val-3=-3",
585 "--define", "val4-=-4" }, options);
586
587 assertNull(parser.getErrorString(), parser.getErrorString());
588
589 final List clOptions = parser.getArguments();
590 final int size = clOptions.size();
591
592 assertEquals(4, size);
593 for (int i = 0; i < size; i++) {
594 assertEquals(DEFINE_OPT, ((CLOption) clOptions.get(i)).getDescriptor().getId());
595 }
596
597 CLOption option;
598 option = (CLOption) clOptions.get(0);
599 assertEquals("val1", option.getArgument(0));
600 assertEquals("-1", option.getArgument(1));
601
602 option = (CLOption) clOptions.get(1);
603 assertEquals("val2", option.getArgument(0));
604 assertEquals("-2", option.getArgument(1));
605
606 option = (CLOption) clOptions.get(2);
607 assertEquals("val-3", option.getArgument(0));
608 assertEquals("-3", option.getArgument(1));
609
610 option = (CLOption) clOptions.get(3);
611 assertEquals("val4-", option.getArgument(0));
612 assertEquals("-4", option.getArgument(1));
613 }
614
615 public void testPartParse() {
616 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { YOU };
617
618 final ParserControl control = new AbstractParserControl() {
619 public boolean isFinished(int lastOptionCode) {
620 return (lastOptionCode == YOU_OPT);
621 }
622 };
623
624 final CLArgsParser parser = new CLArgsParser(ARGLIST1, options, control);
625
626 assertNull(parser.getErrorString(), parser.getErrorString());
627
628 final List clOptions = parser.getArguments();
629 final int size = clOptions.size();
630
631 assertEquals(size, 1);
632 assertEquals(((CLOption) clOptions.get(0)).getDescriptor().getId(), YOU_OPT);
633 }
634
635 public void test2PartParse() {
636 final CLOptionDescriptor[] options1 = new CLOptionDescriptor[] { YOU };
637
638 final CLOptionDescriptor[] options2 = new CLOptionDescriptor[] { ALL, CLEAR1, CLEAR2, CLEAR3, CLEAR5 };
639
640 final ParserControl control1 = new AbstractParserControl() {
641 public boolean isFinished(int lastOptionCode) {
642 return (lastOptionCode == YOU_OPT);
643 }
644 };
645
646 final CLArgsParser parser1 = new CLArgsParser(ARGLIST1, options1, control1);
647
648 assertNull(parser1.getErrorString(), parser1.getErrorString());
649
650 final List clOptions1 = parser1.getArguments();
651 final int size1 = clOptions1.size();
652
653 assertEquals(size1, 1);
654 assertEquals(((CLOption) clOptions1.get(0)).getDescriptor().getId(), YOU_OPT);
655
656 final CLArgsParser parser2 = new CLArgsParser(parser1.getUnparsedArgs(), options2);
657
658 assertNull(parser2.getErrorString(), parser2.getErrorString());
659
660 final List clOptions2 = parser2.getArguments();
661 final int size2 = clOptions2.size();
662
663 assertEquals(size2, 7);
664 assertEquals(((CLOption) clOptions2.get(0)).getDescriptor().getId(), 0);
665 assertEquals(((CLOption) clOptions2.get(1)).getDescriptor().getId(), ALL_OPT);
666 assertEquals(((CLOption) clOptions2.get(2)).getDescriptor().getId(), CLEAR1_OPT);
667 assertEquals(((CLOption) clOptions2.get(3)).getDescriptor().getId(), CLEAR2_OPT);
668 assertEquals(((CLOption) clOptions2.get(4)).getDescriptor().getId(), CLEAR3_OPT);
669 assertEquals(((CLOption) clOptions2.get(5)).getDescriptor().getId(), CLEAR5_OPT);
670 assertEquals(((CLOption) clOptions2.get(6)).getDescriptor().getId(), 0);
671 }
672
673 public void test2PartPartialParse() {
674 final CLOptionDescriptor[] options1 = new CLOptionDescriptor[] { YOU, ALL, CLEAR1 };
675
676 final CLOptionDescriptor[] options2 = new CLOptionDescriptor[] {};
677
678 final ParserControl control1 = new AbstractParserControl() {
679 public boolean isFinished(final int lastOptionCode) {
680 return (lastOptionCode == CLEAR1_OPT);
681 }
682 };
683
684 final CLArgsParser parser1 = new CLArgsParser(ARGLIST1, options1, control1);
685
686 assertNull(parser1.getErrorString(), parser1.getErrorString());
687
688 final List clOptions1 = parser1.getArguments();
689 final int size1 = clOptions1.size();
690
691 assertEquals(size1, 4);
692 assertEquals(((CLOption) clOptions1.get(0)).getDescriptor().getId(), YOU_OPT);
693 assertEquals(((CLOption) clOptions1.get(1)).getDescriptor().getId(), 0);
694 assertEquals(((CLOption) clOptions1.get(2)).getDescriptor().getId(), ALL_OPT);
695 assertEquals(((CLOption) clOptions1.get(3)).getDescriptor().getId(), CLEAR1_OPT);
696
697 assertTrue(parser1.getUnparsedArgs()[0].equals("ler"));
698
699 final CLArgsParser parser2 = new CLArgsParser(parser1.getUnparsedArgs(), options2);
700
701 assertNull(parser2.getErrorString(), parser2.getErrorString());
702
703 final List clOptions2 = parser2.getArguments();
704 final int size2 = clOptions2.size();
705
706 assertEquals(size2, 2);
707 assertEquals(((CLOption) clOptions2.get(0)).getDescriptor().getId(), 0);
708 assertEquals(((CLOption) clOptions2.get(1)).getDescriptor().getId(), 0);
709 }
710
711 public void testDuplicatesFail() {
712 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { YOU, ALL, CLEAR1, CLEAR2, CLEAR3, CLEAR5 };
713
714 final CLArgsParser parser = new CLArgsParser(ARGLIST1, options);
715
716 assertNull(parser.getErrorString(), parser.getErrorString());
717 }
718
719 public void testIncomplete2Args() {
720 // "-Dstupid="
721 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE };
722
723 final CLArgsParser parser = new CLArgsParser(new String[] { "-Dstupid=" }, options);
724
725 assertNull(parser.getErrorString(), parser.getErrorString());
726
727 final List clOptions = parser.getArguments();
728 final int size = clOptions.size();
729
730 assertEquals(size, 1);
731 final CLOption option = (CLOption) clOptions.get(0);
732 assertEquals(option.getDescriptor().getId(), DEFINE_OPT);
733 assertEquals(option.getArgument(0), "stupid");
734 assertEquals(option.getArgument(1), "");
735 }
736
737 public void testIncomplete2ArgsMixed() {
738 // "-Dstupid=","-c"
739 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE, CLEAR1 };
740
741 final String[] args = new String[] { "-Dstupid=", "-c" };
742
743 final CLArgsParser parser = new CLArgsParser(args, options);
744
745 assertNull(parser.getErrorString(), parser.getErrorString());
746
747 final List clOptions = parser.getArguments();
748 final int size = clOptions.size();
749
750 assertEquals(size, 2);
751 assertEquals(((CLOption) clOptions.get(1)).getDescriptor().getId(), CLEAR1_OPT);
752 final CLOption option = (CLOption) clOptions.get(0);
753 assertEquals(option.getDescriptor().getId(), DEFINE_OPT);
754 assertEquals(option.getArgument(0), "stupid");
755 assertEquals(option.getArgument(1), "");
756 }
757
758 public void testIncomplete2ArgsMixedNoEq() {
759 // "-Dstupid","-c"
760 final CLOptionDescriptor[] options = new CLOptionDescriptor[] { DEFINE, CLEAR1 };
761
762 final String[] args = new String[] { "-DStupid", "-c" };
763
764 final CLArgsParser parser = new CLArgsParser(args, options);
765
766 assertNull(parser.getErrorString(), parser.getErrorString());
767
768 final List clOptions = parser.getArguments();
769 final int size = clOptions.size();
770
771 assertEquals(size, 2);
772 assertEquals(((CLOption) clOptions.get(1)).getDescriptor().getId(), CLEAR1_OPT);
773 final CLOption option = (CLOption) clOptions.get(0);
774 assertEquals(option.getDescriptor().getId(), DEFINE_OPT);
775 assertEquals(option.getArgument(0), "Stupid");
776 assertEquals(option.getArgument(1), "");
777 }
778
779 /**
780 * Test the getArgumentById and getArgumentByName lookup methods.
781 */
782 public void testArgumentLookup() {
783 final String[] args = { "-f", "testarg" };
784 final CLOptionDescriptor[] options = { FILE };
785 final CLArgsParser parser = new CLArgsParser(args, options);
786
787 CLOption optionById = parser.getArgumentById(FILE_OPT);
788 assertNotNull(optionById);
789 assertEquals(FILE_OPT, optionById.getDescriptor().getId());
790
791 CLOption optionByName = parser.getArgumentByName(FILE.getName());
792 assertNotNull(optionByName);
793 assertEquals(FILE_OPT, optionByName.getDescriptor().getId());
794 }
795
796 /**
797 * Test that you can have null long forms.
798 */
799 public void testNullLongForm() {
800 final CLOptionDescriptor test = new CLOptionDescriptor(null, CLOptionDescriptor.ARGUMENT_DISALLOWED, 'n',
801 "test null long form");
802
803 final String[] args = { "-n", "testarg" };
804 final CLOptionDescriptor[] options = { test };
805 final CLArgsParser parser = new CLArgsParser(args, options);
806
807 final CLOption optionByID = parser.getArgumentById('n');
808 assertNotNull(optionByID);
809 assertEquals('n', optionByID.getDescriptor().getId());
810
811 final CLOption optionByName = parser.getArgumentByName(FILE.getName());
812 assertNull("Looking for non-existent option by name", optionByName);
813 }
814
815 /**
816 * Test that you can have null descriptions.
817 */
818 public void testNullDescription() {
819 final CLOptionDescriptor test = new CLOptionDescriptor("nulltest", CLOptionDescriptor.ARGUMENT_DISALLOWED, 'n',
820 null);
821
822 final String[] args = { "-n", "testarg" };
823 final CLOptionDescriptor[] options = { test };
824 final CLArgsParser parser = new CLArgsParser(args, options);
825
826 final CLOption optionByID = parser.getArgumentById('n');
827 assertNotNull(optionByID);
828 assertEquals('n', optionByID.getDescriptor().getId());
829
830 final StringBuffer sb = CLUtil.describeOptions(options);
831 final String lineSeparator = System.getProperty("line.separator");
832 assertEquals("Testing display of null description", "\t-n, --nulltest" + lineSeparator, sb.toString());
833 }
834 /*
835 * TODO add tests to check for: - name clash - long option abbreviations
836 * (match shortest unique abbreviation)
837 */
838
839 }