1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.cli2;
18
19 import java.util.Arrays;
20 import java.util.List;
21 import java.util.Set;
22
23 import junit.framework.TestCase;
24
25 import org.apache.commons.cli2.builder.ArgumentBuilder;
26 import org.apache.commons.cli2.builder.DefaultOptionBuilder;
27 import org.apache.commons.cli2.builder.GroupBuilder;
28 import org.apache.commons.cli2.commandline.Parser;
29
30
31
32
33 public class PrecedenceTest extends TestCase {
34 private final String[] args = new String[] { "-file" };
35
36 public void testSimple() throws OptionException {
37 final DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();
38
39 final Group options =
40 new GroupBuilder()
41 .withOption(oBuilder.withShortName("file").create())
42 .create();
43
44 final CommandLine cl = buildCommandLine(options, args);
45 assertEquals(new String[] { "-file" }, cl);
46 }
47
48 public void testArgument() throws OptionException {
49 final DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();
50 final ArgumentBuilder aBuilder = new ArgumentBuilder();
51
52 final Group options =
53 new GroupBuilder()
54 .withOption(
55 oBuilder
56 .withShortName("f")
57 .withArgument(aBuilder.create())
58 .create())
59 .create();
60
61 final CommandLine cl = buildCommandLine(options, args);
62 assertEquals(new String[] { "-f" }, cl);
63 }
64
65 public void testBurst() throws OptionException {
66 final DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();
67 final GroupBuilder gBuilder = new GroupBuilder();
68 final Group options =
69 gBuilder
70 .withOption(oBuilder.withShortName("f").create())
71 .withOption(oBuilder.withShortName("i").create())
72 .withOption(oBuilder.withShortName("l").create())
73 .withOption(oBuilder.withShortName("e").create())
74 .create();
75
76 final CommandLine cl = buildCommandLine(options, args);
77 assertEquals(new String[] { "-f", "-i", "-l", "-e" }, cl);
78 }
79
80 public void testChildren() throws OptionException {
81 final DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();
82 final GroupBuilder gBuilder = new GroupBuilder();
83
84 final Group children =
85 gBuilder
86 .withOption(oBuilder.withShortName("i").create())
87 .withOption(oBuilder.withShortName("l").create())
88 .withOption(oBuilder.withShortName("e").create())
89 .create();
90 final Group options =
91 gBuilder
92 .withOption(
93 oBuilder
94 .withShortName("f")
95 .withChildren(children)
96 .create())
97 .create();
98
99 final CommandLine cl = buildCommandLine(options, args);
100 assertEquals(new String[] { "-f", "-i", "-l", "-e" }, cl);
101 }
102
103 public void XtestSimpleVsArgument() throws OptionException {
104 final DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();
105 final GroupBuilder gBuilder = new GroupBuilder();
106 final ArgumentBuilder aBuilder = new ArgumentBuilder();
107
108 final Group options =
109 gBuilder
110 .withOption(oBuilder.withShortName("file").create())
111 .withOption(
112 oBuilder
113 .withShortName("f")
114 .withArgument(aBuilder.create())
115 .create())
116 .create();
117
118 final CommandLine cl = buildCommandLine(options, args);
119 assertEquals(new String[] { "-f" }, cl);
120 }
121
122 public void XtestSimpleVsBurst() throws OptionException {
123 final DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();
124 final GroupBuilder gBuilder = new GroupBuilder();
125 final Group options =
126 gBuilder
127 .withOption(oBuilder.withShortName("file").create())
128 .withOption(oBuilder.withShortName("f").create())
129 .withOption(oBuilder.withShortName("i").create())
130 .withOption(oBuilder.withShortName("l").create())
131 .withOption(oBuilder.withShortName("e").create())
132 .create();
133
134 final CommandLine cl = buildCommandLine(options, args);
135 assertEquals(new String[] { "-f", "-i", "-l", "-e" }, cl);
136 }
137
138 public void XtestSimpleVsChildren() throws OptionException {
139 final DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();
140 final GroupBuilder gBuilder = new GroupBuilder();
141
142 final Group children =
143 gBuilder
144 .withOption(
145 oBuilder.withShortName("i").withLongName("ci").create())
146 .withOption(
147 oBuilder.withShortName("l").withLongName("cl").create())
148 .withOption(
149 oBuilder.withShortName("e").withLongName("ce").create())
150 .create();
151
152 final Group options =
153 gBuilder
154 .withOption(oBuilder.withShortName("file").create())
155 .withOption(
156 oBuilder
157 .withShortName("f")
158 .withChildren(children)
159 .create())
160 .create();
161
162 final CommandLine cl = buildCommandLine(options, args);
163 assertEquals(
164 new String[] { "-f", "-i", "--ci", "-l", "--cl", "-e", "--ce" },
165 cl);
166 }
167
168 public void testArgumentVsBurst() throws OptionException {
169 final DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();
170 final GroupBuilder gBuilder = new GroupBuilder();
171 final ArgumentBuilder aBuilder = new ArgumentBuilder();
172
173 final Group options =
174 gBuilder
175 .withOption(
176 oBuilder
177 .withShortName("f")
178 .withArgument(aBuilder.create())
179 .create())
180 .withOption(oBuilder.withShortName("i").create())
181 .withOption(oBuilder.withShortName("l").create())
182 .withOption(oBuilder.withShortName("e").create())
183 .create();
184
185 final CommandLine cl = buildCommandLine(options, args);
186 assertEquals(new String[] { "-f" }, cl);
187 }
188
189 public void testArgumentVsChildren() throws OptionException {
190 final DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();
191 final GroupBuilder gBuilder = new GroupBuilder();
192 final ArgumentBuilder aBuilder = new ArgumentBuilder();
193
194 final Group children =
195 gBuilder
196 .withOption(oBuilder.withShortName("i").create())
197 .withOption(oBuilder.withShortName("l").create())
198 .withOption(oBuilder.withShortName("e").create())
199 .create();
200 final Group options =
201 gBuilder
202 .withOption(
203 oBuilder
204 .withShortName("f")
205 .withChildren(children)
206 .withArgument(aBuilder.create())
207 .create())
208 .create();
209
210 final CommandLine cl = buildCommandLine(options, args);
211 assertEquals(new String[] { "-f" }, cl);
212 }
213
214 public void testBurstVsChildren() throws OptionException {
215 final DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();
216 final GroupBuilder gBuilder = new GroupBuilder();
217
218 final Group children =
219 gBuilder
220 .withOption(
221 oBuilder.withShortName("i").withLongName("ci").create())
222 .withOption(
223 oBuilder.withShortName("l").withLongName("cl").create())
224 .withOption(
225 oBuilder.withShortName("e").withLongName("ce").create())
226 .create();
227
228 final Group options =
229 gBuilder
230 .withOption(
231 oBuilder
232 .withShortName("f")
233 .withChildren(children)
234 .create())
235 .withOption(
236 oBuilder.withShortName("i").withLongName("bi").create())
237 .withOption(
238 oBuilder.withShortName("l").withLongName("bl").create())
239 .withOption(
240 oBuilder.withShortName("e").withLongName("be").create())
241 .create();
242
243 final CommandLine cl = buildCommandLine(options, args);
244 assertEquals(
245 new String[] { "-f", "-i", "--ci", "-l", "--cl", "-e", "--ce" },
246 cl);
247 }
248
249 public void XtestSimpleVsArgumentVsBurst() throws OptionException {
250 final DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();
251 final GroupBuilder gBuilder = new GroupBuilder();
252 final ArgumentBuilder aBuilder = new ArgumentBuilder();
253
254 final Group options =
255 gBuilder
256 .withOption(oBuilder.withShortName("file").create())
257 .withOption(
258 oBuilder
259 .withShortName("f")
260 .withArgument(aBuilder.create())
261 .create())
262 .withOption(oBuilder.withShortName("i").create())
263 .withOption(oBuilder.withShortName("l").create())
264 .withOption(oBuilder.withShortName("e").create())
265 .create();
266
267 final CommandLine cl = buildCommandLine(options, args);
268 assertEquals(new String[] { "-f" }, cl);
269 }
270
271 public void XtestSimpleVsArgumentVsChildren() throws OptionException {
272 final DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();
273 final GroupBuilder gBuilder = new GroupBuilder();
274 final ArgumentBuilder aBuilder = new ArgumentBuilder();
275
276 final Group children =
277 gBuilder
278 .withOption(
279 oBuilder.withShortName("i").withLongName("ci").create())
280 .withOption(
281 oBuilder.withShortName("l").withLongName("cl").create())
282 .withOption(
283 oBuilder.withShortName("e").withLongName("ce").create())
284 .create();
285
286 final Group options =
287 gBuilder
288 .withOption(oBuilder.withShortName("file").create())
289 .withOption(
290 oBuilder
291 .withShortName("f")
292 .withChildren(children)
293 .withArgument(aBuilder.create())
294 .create())
295 .create();
296
297 final CommandLine cl = buildCommandLine(options, args);
298 assertEquals(new String[] { "-f" }, cl);
299 }
300
301 public void XtestSimpleVsBurstVsChildren() throws OptionException {
302 final DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();
303 final GroupBuilder gBuilder = new GroupBuilder();
304
305 final Group children =
306 gBuilder
307 .withOption(
308 oBuilder.withShortName("i").withLongName("ci").create())
309 .withOption(
310 oBuilder.withShortName("l").withLongName("cl").create())
311 .withOption(
312 oBuilder.withShortName("e").withLongName("ce").create())
313 .create();
314
315 final Group options =
316 gBuilder
317 .withOption(oBuilder.withShortName("file").create())
318 .withOption(
319 oBuilder
320 .withShortName("f")
321 .withChildren(children)
322 .create())
323 .withOption(oBuilder.withShortName("i").create())
324 .withOption(oBuilder.withShortName("l").create())
325 .withOption(oBuilder.withShortName("e").create())
326 .create();
327
328 final CommandLine cl = buildCommandLine(options, args);
329 assertEquals(new String[] { "-f", "-i", "-l", "-e" }, cl);
330 }
331
332 public void testArgumentVsBurstVsChildren() throws OptionException {
333 final DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();
334 final GroupBuilder gBuilder = new GroupBuilder();
335 final ArgumentBuilder aBuilder = new ArgumentBuilder();
336
337 final Group children =
338 gBuilder
339 .withOption(
340 oBuilder.withShortName("i").withLongName("ci").create())
341 .withOption(
342 oBuilder.withShortName("l").withLongName("cl").create())
343 .withOption(
344 oBuilder.withShortName("e").withLongName("ce").create())
345 .create();
346
347 final Group options =
348 gBuilder
349 .withOption(
350 oBuilder
351 .withShortName("f")
352 .withChildren(children)
353 .withArgument(aBuilder.create())
354 .create())
355 .withOption(oBuilder.withShortName("i").create())
356 .withOption(oBuilder.withShortName("l").create())
357 .withOption(oBuilder.withShortName("e").create())
358 .create();
359
360 final CommandLine cl = buildCommandLine(options, args);
361 assertEquals(new String[] { "-f" }, cl);
362 }
363
364 public void XtestSimpleVsArgumentVsBurstVsChildren()
365 throws OptionException {
366 final DefaultOptionBuilder oBuilder = new DefaultOptionBuilder();
367 final GroupBuilder gBuilder = new GroupBuilder();
368 final ArgumentBuilder aBuilder = new ArgumentBuilder();
369
370 final Group children =
371 gBuilder
372 .withOption(
373 oBuilder.withShortName("i").withLongName("ci").create())
374 .withOption(
375 oBuilder.withShortName("l").withLongName("cl").create())
376 .withOption(
377 oBuilder.withShortName("e").withLongName("ce").create())
378 .create();
379
380 final Group options =
381 gBuilder
382 .withOption(oBuilder.withShortName("file").create())
383 .withOption(
384 oBuilder
385 .withShortName("f")
386 .withChildren(children)
387 .withArgument(aBuilder.create())
388 .create())
389 .withOption(oBuilder.withShortName("i").create())
390 .withOption(oBuilder.withShortName("l").create())
391 .withOption(oBuilder.withShortName("e").create())
392 .create();
393
394 final CommandLine cl = buildCommandLine(options, args);
395 assertEquals(new String[] { "-f" }, cl);
396 }
397
398 public CommandLine buildCommandLine(final Group group, final String[] arguments)
399 throws OptionException {
400 Parser p = new Parser();
401 p.setGroup(group);
402 return p.parse(arguments);
403 }
404
405 public void assertEquals(final String options[], final CommandLine line) {
406 final List expected = Arrays.asList(options);
407 final Set actual = line.getOptionTriggers();
408
409 assertTrue(expected.containsAll(actual));
410 assertTrue(actual.containsAll(expected));
411 }
412
413 }