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

Last change on this file since 14435 was 14435, checked in by Don-vip, 5 years ago

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