source: josm/trunk/test/unit/org/openstreetmap/josm/tools/OptionParserTest.java @ 14415

Last change on this file since 14415 was 14415, checked in by michael2402, 4 months ago

See #16866: Drop getopt, use own option parser.

File size: 14.0 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.tools;
3
4import static org.junit.Assert.assertEquals;
5
6import java.util.ArrayList;
7import java.util.Arrays;
8import java.util.List;
9import java.util.concurrent.atomic.AtomicBoolean;
10import java.util.concurrent.atomic.AtomicReference;
11
12import org.junit.Test;
13import org.openstreetmap.josm.tools.OptionParser.OptionCount;
14import org.openstreetmap.josm.tools.OptionParser.OptionParseException;
15
16/**
17 * Test for {@link OptionParser}
18 * @author Michael Zangl
19 */
20public class OptionParserTest {
21
22    // A reason for moving to jupter...
23    @Test(expected = OptionParseException.class)
24    public void testEmptyParserRejectsLongopt() {
25        new OptionParser("test").parseOptions(Arrays.asList("--long"));
26    }
27
28    @Test(expected = OptionParseException.class)
29    public void testEmptyParserRejectsShortopt() {
30        new OptionParser("test").parseOptions(Arrays.asList("-s"));
31    }
32
33    @Test(expected = OptionParseException.class)
34    public void testParserRejectsWrongShortopt() {
35        new OptionParser("test").addFlagParameter("test", this::nop).addShortAlias("test", "t")
36                .parseOptions(Arrays.asList("-s"));
37    }
38
39    @Test(expected = OptionParseException.class)
40    public void testParserRejectsWrongLongopt() {
41        new OptionParser("test").addFlagParameter("test", this::nop).parseOptions(Arrays.asList("--wrong"));
42    }
43
44    @Test
45    public void testparserOption() {
46        AtomicReference<String> argFound = new AtomicReference<>();
47        OptionParser parser = new OptionParser("test")
48                .addArgumentParameter("test", OptionCount.REQUIRED, argFound::set);
49
50        parser.parseOptions(Arrays.asList("--test", "arg"));
51        assertEquals("arg", argFound.get());
52    }
53
54    @Test(expected = OptionParseException.class)
55    public void testparserOptionFailsIfMissing() {
56        AtomicReference<String> argFound = new AtomicReference<>();
57        OptionParser parser = new OptionParser("test")
58                .addArgumentParameter("test", OptionCount.REQUIRED, argFound::set);
59
60        parser.parseOptions(Arrays.asList("--test2", "arg"));
61    }
62
63    @Test(expected = OptionParseException.class)
64    public void testparserOptionFailsIfMissingArgument() {
65        AtomicReference<String> argFound = new AtomicReference<>();
66        OptionParser parser = new OptionParser("test")
67                .addArgumentParameter("test", OptionCount.REQUIRED, argFound::set);
68
69        parser.parseOptions(Arrays.asList("--test2", "--other"));
70    }
71
72    @Test(expected = OptionParseException.class)
73    public void testparserOptionFailsIfMissing2() {
74        AtomicReference<String> argFound = new AtomicReference<>();
75        OptionParser parser = new OptionParser("test")
76                .addArgumentParameter("test", OptionCount.REQUIRED, argFound::set);
77
78        parser.parseOptions(Arrays.asList("--", "--test", "arg"));
79    }
80
81    @Test(expected = OptionParseException.class)
82    public void testparserOptionFailsIfTwice() {
83        AtomicReference<String> argFound = new AtomicReference<>();
84        OptionParser parser = new OptionParser("test")
85                .addArgumentParameter("test", OptionCount.REQUIRED, argFound::set);
86
87        parser.parseOptions(Arrays.asList("--test", "arg", "--test", "arg"));
88    }
89
90    @Test(expected = OptionParseException.class)
91    public void testparserOptionFailsIfTwiceForAlias() {
92        AtomicReference<String> argFound = new AtomicReference<>();
93        OptionParser parser = new OptionParser("test")
94                .addArgumentParameter("test", OptionCount.REQUIRED, argFound::set)
95                .addShortAlias("test", "t");
96
97        parser.parseOptions(Arrays.asList("--test", "arg", "-t", "arg"));
98    }
99
100    @Test(expected = OptionParseException.class)
101    public void testOptionalOptionFailsIfTwice() {
102        OptionParser parser = new OptionParser("test")
103                .addFlagParameter("test", this::nop);
104        parser.parseOptions(Arrays.asList("--test", "--test"));
105    }
106
107    @Test(expected = OptionParseException.class)
108    public void testOptionalOptionFailsIfTwiceForAlias() {
109        OptionParser parser = new OptionParser("test")
110                .addFlagParameter("test", this::nop)
111                .addShortAlias("test", "t");
112        parser.parseOptions(Arrays.asList("-t", "-t"));
113    }
114
115    @Test(expected = OptionParseException.class)
116    public void testOptionalOptionFailsIfTwiceForAlias2() {
117        OptionParser parser = new OptionParser("test")
118                .addFlagParameter("test", this::nop)
119                .addShortAlias("test", "t");
120        parser.parseOptions(Arrays.asList("-tt"));
121    }
122
123    @Test
124    public void testLongArgumentsUsingEqualSign() {
125        AtomicReference<String> argFound = new AtomicReference<>();
126        OptionParser parser = new OptionParser("test")
127                .addArgumentParameter("test", OptionCount.REQUIRED, argFound::set);
128
129        List<String> remaining = parser.parseOptions(Arrays.asList("--test=arg", "value"));
130
131        assertEquals(Arrays.asList("value"), remaining);
132        assertEquals("arg", argFound.get());
133
134        remaining = parser.parseOptions(Arrays.asList("--test=", "value"));
135
136        assertEquals(Arrays.asList("value"), remaining);
137        assertEquals("", argFound.get());
138
139        remaining = parser.parseOptions(Arrays.asList("--test=with space and=equals", "value"));
140
141        assertEquals(Arrays.asList("value"), remaining);
142        assertEquals("with space and=equals", argFound.get());
143    }
144
145    @Test(expected = OptionParseException.class)
146    public void testLongArgumentsMissingOption() {
147        OptionParser parser = new OptionParser("test")
148                .addArgumentParameter("test", OptionCount.REQUIRED, this::nop);
149
150        parser.parseOptions(Arrays.asList("--test"));
151    }
152
153    @Test(expected = OptionParseException.class)
154    public void testLongArgumentsMissingOption2() {
155        OptionParser parser = new OptionParser("test")
156                .addArgumentParameter("test", OptionCount.REQUIRED, this::nop);
157
158        parser.parseOptions(Arrays.asList("--test", "--", "x"));
159    }
160
161    @Test(expected = OptionParseException.class)
162    public void testShortArgumentsMissingOption() {
163        OptionParser parser = new OptionParser("test")
164                .addArgumentParameter("test", OptionCount.REQUIRED, this::nop)
165                .addShortAlias("test", "t");
166
167        parser.parseOptions(Arrays.asList("-t"));
168    }
169
170    @Test(expected = OptionParseException.class)
171    public void testShortArgumentsMissingOption2() {
172        OptionParser parser = new OptionParser("test")
173                .addArgumentParameter("test", OptionCount.REQUIRED, this::nop)
174                .addShortAlias("test", "t");
175
176        parser.parseOptions(Arrays.asList("-t", "--", "x"));
177    }
178
179    @Test(expected = OptionParseException.class)
180    public void testLongFlagHasOption() {
181        OptionParser parser = new OptionParser("test")
182                .addFlagParameter("test", this::nop);
183
184        parser.parseOptions(Arrays.asList("--test=arg"));
185    }
186
187    @Test(expected = OptionParseException.class)
188    public void testShortFlagHasOption() {
189        OptionParser parser = new OptionParser("test")
190                .addFlagParameter("test", this::nop)
191                .addShortAlias("test", "t");
192
193        parser.parseOptions(Arrays.asList("-t=arg"));
194    }
195
196    @Test
197    public void testShortArgumentsUsingEqualSign() {
198        AtomicReference<String> argFound = new AtomicReference<>();
199        OptionParser parser = new OptionParser("test")
200                .addArgumentParameter("test", OptionCount.REQUIRED, argFound::set)
201                .addShortAlias("test", "t");
202
203        List<String> remaining = parser.parseOptions(Arrays.asList("-t=arg", "value"));
204
205        assertEquals(Arrays.asList("value"), remaining);
206        assertEquals("arg", argFound.get());
207    }
208
209    @Test
210    public void testMultipleArguments() {
211        AtomicReference<String> argFound = new AtomicReference<>();
212        List<String> multiFound = new ArrayList<>();
213        AtomicBoolean usedFlag = new AtomicBoolean();
214        AtomicBoolean unusedFlag = new AtomicBoolean();
215        OptionParser parser = new OptionParser("test")
216                .addArgumentParameter("test", OptionCount.REQUIRED, argFound::set)
217                .addShortAlias("test", "t")
218                .addArgumentParameter("multi", OptionCount.MULTIPLE, multiFound::add)
219                .addFlagParameter("flag", () -> usedFlag.set(true))
220                .addFlagParameter("flag2", () -> unusedFlag.set(true));
221
222        List<String> remaining = parser.parseOptions(Arrays.asList(
223                "-t=arg", "--multi", "m1", "x1", "--flag", "--multi", "m2", "x2", "--", "x3", "--x4", "x5"));
224
225        assertEquals(Arrays.asList("x1", "x2", "x3", "--x4", "x5"), remaining);
226        assertEquals("arg", argFound.get());
227        assertEquals(Arrays.asList("m1", "m2"), multiFound);
228        assertEquals(true, usedFlag.get());
229        assertEquals(false, unusedFlag.get());
230    }
231
232    @Test
233    public void testUseAlternatives() {
234        AtomicReference<String> argFound = new AtomicReference<>();
235        AtomicBoolean usedFlag = new AtomicBoolean();
236        AtomicBoolean unusedFlag = new AtomicBoolean();
237
238        OptionParser parser = new OptionParser("test")
239                .addArgumentParameter("test", OptionCount.REQUIRED, argFound::set)
240                .addFlagParameter("flag", () -> usedFlag.set(true))
241                .addFlagParameter("fleg", () -> unusedFlag.set(true));
242
243        List<String> remaining = parser.parseOptions(Arrays.asList("--te=arg", "--fla"));
244
245        assertEquals(Arrays.asList(), remaining);
246        assertEquals("arg", argFound.get());
247        assertEquals(true, usedFlag.get());
248        assertEquals(false, unusedFlag.get());
249    }
250
251    @Test(expected = OptionParseException.class)
252    public void testAbigiousAlternatives() {
253        AtomicReference<String> argFound = new AtomicReference<>();
254        AtomicBoolean usedFlag = new AtomicBoolean();
255        AtomicBoolean unusedFlag = new AtomicBoolean();
256
257        OptionParser parser = new OptionParser("test")
258                .addArgumentParameter("test", OptionCount.REQUIRED, argFound::set)
259                .addFlagParameter("flag", () -> usedFlag.set(true))
260                .addFlagParameter("fleg", () -> unusedFlag.set(true));
261
262        parser.parseOptions(Arrays.asList("--te=arg", "--fl"));
263    }
264
265    @Test(expected = OptionParseException.class)
266    public void testMultipleShort() {
267        AtomicReference<String> argFound = new AtomicReference<>();
268        AtomicBoolean usedFlag = new AtomicBoolean();
269        AtomicBoolean unusedFlag = new AtomicBoolean();
270
271        OptionParser parser = new OptionParser("test")
272                .addArgumentParameter("test", OptionCount.REQUIRED, argFound::set)
273                .addShortAlias("test", "t")
274                .addFlagParameter("flag", () -> usedFlag.set(true))
275                .addShortAlias("flag", "f")
276                .addFlagParameter("fleg", () -> unusedFlag.set(true));
277
278        List<String> remaining = parser.parseOptions(Arrays.asList("-ft=arg", "x"));
279
280        assertEquals(Arrays.asList("x"), remaining);
281        assertEquals("arg", argFound.get());
282        assertEquals(true, usedFlag.get());
283        assertEquals(false, unusedFlag.get());
284
285        remaining = parser.parseOptions(Arrays.asList("-ft", "arg", "x"));
286
287        assertEquals(Arrays.asList("x"), remaining);
288        assertEquals("arg", argFound.get());
289        assertEquals(true, usedFlag.get());
290        assertEquals(false, unusedFlag.get());
291
292        remaining = parser.parseOptions(Arrays.asList("-f", "-t=arg", "x"));
293
294        assertEquals(Arrays.asList("x"), remaining);
295        assertEquals("arg", argFound.get());
296        assertEquals(true, usedFlag.get());
297        assertEquals(false, unusedFlag.get());
298    }
299
300    @Test(expected = IllegalArgumentException.class)
301    public void testIllegalOptionName() {
302        new OptionParser("test").addFlagParameter("", this::nop);
303    }
304
305    @Test(expected = IllegalArgumentException.class)
306    public void testIllegalOptionName2() {
307        new OptionParser("test").addFlagParameter("-", this::nop);
308    }
309
310    @Test(expected = IllegalArgumentException.class)
311    public void testIllegalOptionName3() {
312        new OptionParser("test").addFlagParameter("-test", this::nop);
313    }
314
315    @Test(expected = IllegalArgumentException.class)
316    public void testIllegalOptionName4() {
317        new OptionParser("test").addFlagParameter("$", this::nop);
318    }
319
320    @Test(expected = IllegalArgumentException.class)
321    public void testDupplicateOptionName() {
322        new OptionParser("test").addFlagParameter("test", this::nop).addFlagParameter("test", this::nop);
323    }
324
325    @Test(expected = IllegalArgumentException.class)
326    public void testDupplicateOptionName2() {
327        new OptionParser("test").addFlagParameter("test", this::nop)
328            .addArgumentParameter("test", OptionCount.OPTIONAL, this::nop);
329    }
330
331    @Test(expected = IllegalArgumentException.class)
332    public void testInvalidShortAlias() {
333        new OptionParser("test").addFlagParameter("test", this::nop).addShortAlias("test", "$");
334    }
335
336    @Test(expected = IllegalArgumentException.class)
337    public void testInvalidShortAlias2() {
338        new OptionParser("test").addFlagParameter("test", this::nop).addShortAlias("test", "");
339    }
340
341    @Test(expected = IllegalArgumentException.class)
342    public void testInvalidShortAlias3() {
343        new OptionParser("test").addFlagParameter("test", this::nop).addShortAlias("test", "xx");
344    }
345
346    @Test(expected = IllegalArgumentException.class)
347    public void testDupplicateShortAlias() {
348        new OptionParser("test").addFlagParameter("test", this::nop)
349        .addFlagParameter("test2", this::nop)
350        .addShortAlias("test", "t")
351        .addShortAlias("test2", "t");
352    }
353
354    @Test(expected = IllegalArgumentException.class)
355    public void testInvalidShortNoLong() {
356        new OptionParser("test").addFlagParameter("test", this::nop).addShortAlias("test2", "t");
357    }
358
359    private void nop() {
360        // nop
361    }
362
363    private void nop(String arg) {
364        // nop
365    }
366}
Note: See TracBrowser for help on using the repository browser.