1 /*Copyright (C) 2014 Red Hat, Inc.
2 
3 This file is part of IcedTea.
4 
5 IcedTea is free software; you can redistribute it and/or
6 modify it under the terms of the GNU General Public License as published by
7 the Free Software Foundation, version 2.
8 
9 IcedTea is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12 General Public License for more details.
13 
14 You should have received a copy of the GNU General Public License
15 along with IcedTea; see the file COPYING.  If not, write to
16 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17 02110-1301 USA.
18 
19 Linking this library statically or dynamically with other modules is
20 making a combined work based on this library.  Thus, the terms and
21 conditions of the GNU General Public License cover the whole
22 combination.
23 
24 As a special exception, the copyright holders of this library give you
25 permission to link this library with independent modules to produce an
26 executable, regardless of the license terms of these independent
27 modules, and to copy and distribute the resulting executable under
28 terms of your choice, provided that you also meet, for each linked
29 independent module, the terms and conditions of the license of that
30 module.  An independent module is a module which is not derived from
31 or based on this library.  If you modify this library, you may extend
32 this exception to your version of the library, but you are not
33 obligated to do so.  If you do not wish to do so, delete this
34 exception statement from your version.
35  */
36 
37 
38 package net.sourceforge.jnlp.util.optionparser;
39 
40 import static org.junit.Assert.assertEquals;
41 import static org.junit.Assert.assertFalse;
42 import static org.junit.Assert.assertNotEquals;
43 import static org.junit.Assert.assertTrue;
44 
45 import net.sourceforge.jnlp.OptionsDefinitions;
46 import org.junit.Test;
47 
48 import java.util.List;
49 
50 public class OptionParserTest {
51 
52     @Test
testGetSingleOptionValue()53     public void testGetSingleOptionValue() {
54         String[] args = {"-update", "blob"};
55         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
56 
57         String value = parser.getParam(OptionsDefinitions.OPTIONS.UPDATE);
58         assertEquals("blob", value);
59     }
60 
61     @Test
testGetSingleOptionMultipleValues()62     public void testGetSingleOptionMultipleValues() {
63         String[] args = {"-arg", "blob", "meow"};
64         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
65 
66         List<String> values = parser.getParams(OptionsDefinitions.OPTIONS.ARG);
67         assertEquals(0, values.indexOf("blob"));
68         assertEquals(1, values.indexOf("meow"));
69         assertEquals(2, values.size());
70     }
71 
72     @Test
testGetDifferentOptionValues()73     public void testGetDifferentOptionValues() {
74         String[] args = {"-param", "blob", "-arg", "yelp"};
75         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
76 
77         List<String> values = parser.getParams(OptionsDefinitions.OPTIONS.PARAM);
78         assertEquals(0, values.indexOf("blob"));
79         assertEquals(1, values.size());
80 
81         values = parser.getParams(OptionsDefinitions.OPTIONS.ARG);
82         assertEquals(0, values.indexOf("yelp"));
83         assertEquals(1, values.size());
84 
85     }
86 
87     @Test
testSupportedOptionValueNotBeingUsed()88     public void testSupportedOptionValueNotBeingUsed() {
89         String[] args = {};
90         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
91 
92         List<String> values = parser.getParams(OptionsDefinitions.OPTIONS.ARG);
93         assertEquals(0, values.size());
94     }
95 
96     @Test
testOptionValueWithNoArgument()97     public void testOptionValueWithNoArgument() {
98         String[] args = {"-arg"};
99         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
100 
101         List<String> values = parser.getParams(OptionsDefinitions.OPTIONS.ARG);
102         assertEquals(0, values.size());
103     }
104 
105     @Test
testOneOptionMultipleTimesMultipleValues()106     public void testOneOptionMultipleTimesMultipleValues() {
107         String[] args = {"-arg", "poke", "blob", "-arg", "meep"};
108         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
109 
110         List<String> values = parser.getParams(OptionsDefinitions.OPTIONS.ARG);
111         assertEquals(3, values.size());
112         assertEquals(0, values.indexOf("poke"));
113         assertEquals(1, values.indexOf("blob"));
114         assertEquals(2, values.indexOf("meep"));
115     }
116 
117     @Test
testMultipleOptionsMultipleValues()118     public void testMultipleOptionsMultipleValues() {
119         String[] args = {"-param", "poke", "blob", "-arg", "meep", "feep", "blurp"};
120         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
121 
122         List<String> values = parser.getParams(OptionsDefinitions.OPTIONS.PARAM);
123         assertEquals(2, values.size());
124         assertEquals(0, values.indexOf("poke"));
125         assertEquals(1, values.indexOf("blob"));
126         values = parser.getParams(OptionsDefinitions.OPTIONS.ARG);
127         assertEquals(3, values.size());
128         assertEquals(0, values.indexOf("meep"));
129         assertEquals(1, values.indexOf("feep"));
130         assertEquals(2, values.indexOf("blurp"));
131     }
132 
133     @Test
testCheckOptionExists()134     public void testCheckOptionExists() {
135         String[] args = {"-headless", "-fish", "-busybee", "boat"};
136         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
137 
138         boolean value = parser.hasOption(OptionsDefinitions.OPTIONS.HEADLESS);
139         assertTrue(value);
140     }
141 
142     @Test
testCheckOptionExistsAsNotFirstArg()143     public void testCheckOptionExistsAsNotFirstArg() {
144         String[] args = {"-run", "fish", "-castle", "-headless"};
145         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
146 
147         boolean value = parser.hasOption(OptionsDefinitions.OPTIONS.HEADLESS);
148         assertTrue(value);
149     }
150 
151     @Test
testCheckOptionNotExists()152     public void testCheckOptionNotExists() {
153         String[] args = {"-run", "fish", "-castle", "cat"};
154         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
155 
156         boolean value = parser.hasOption(OptionsDefinitions.OPTIONS.HEADLESS);
157         assertFalse(value);
158     }
159 
160     @Test
testMultipleOptionsWithMainArgAtTheEnd()161     public void testMultipleOptionsWithMainArgAtTheEnd() {
162         String[] args = {"-arg", "-update=green", "-version",
163                 "-headless", "-arg", "-about",
164                 "-arg", "blah1", "blah2", "blah3", "-noupdate", "-arg",
165                 "blah4", "blah5", "blah6", "-headless", "File.jnlp"};
166         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
167 
168         List<String> values = parser.getParams(OptionsDefinitions.OPTIONS.ARG);
169         assertEquals(6, values.size());
170         assertTrue(parser.mainArgExists());
171         assertEquals("File.jnlp",parser.getMainArg());
172         assertEquals(0, values.indexOf("blah1"));
173         assertEquals(1, values.indexOf("blah2"));
174         assertEquals(2, values.indexOf("blah3"));
175         assertEquals(3, values.indexOf("blah4"));
176         assertEquals(4, values.indexOf("blah5"));
177         assertEquals(5, values.indexOf("blah6"));
178     }
179 
180     @Test
testMultipleOptionsWithNoArgsCombinedWithMultipleOptions()181     public void testMultipleOptionsWithNoArgsCombinedWithMultipleOptions() {
182         String[] args = {"-arg", "-update=green", "-version",
183                 "-arg", "-about",
184                 "-arg", "blah1", "blah2", "blah3","-about", "-arg",
185                 "blah4", "blah5", "blah6", "File.jnlp", "-headless", "-noupdate"};
186         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
187         assertTrue(parser.hasOption(OptionsDefinitions.OPTIONS.ABOUT));
188     }
189 
190     @Test
testMainArgExists()191     public void testMainArgExists() {
192         String[] args = {"File.jnlp"};
193         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
194 
195         assertTrue(parser.mainArgExists());
196         assertEquals("File.jnlp", parser.getMainArg());
197     }
198 
199     @Test
testMultipleMainArgsReturnsFirstMainArg()200     public void testMultipleMainArgsReturnsFirstMainArg() {
201         String[] args = {"File.jnlp", "FileTwo,jnlp", "FileThree.jnlp"};
202         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
203 
204         assertTrue(parser.mainArgExists());
205         assertEquals("File.jnlp", parser.getMainArg());
206     }
207 
208     @Test
testSameTagMultipleTimesWithMainArg()209     public void testSameTagMultipleTimesWithMainArg() {
210         String[] args = {"-headless", "-headless","File.jnlp", "-headless", "-headless", "-headless"};
211         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
212 
213         assertTrue(parser.mainArgExists());
214         assertEquals("File.jnlp", parser.getMainArg());
215         assertTrue(parser.hasOption(OptionsDefinitions.OPTIONS.HEADLESS));
216     }
217 
218     @Test
testSameTagMultipleTimesWithoutMainArg()219     public void testSameTagMultipleTimesWithoutMainArg() {
220         String[] args = {"-headless", "-headless", "-headless", "-headless", "-headless"};
221         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
222 
223         assertFalse(parser.mainArgExists());
224         assertEquals("",parser.getMainArg());
225         assertTrue(parser.hasOption(OptionsDefinitions.OPTIONS.HEADLESS));
226     }
227 
228     @Test
testMultipleArgTagSurroundingMainArgAfterNoArgOption()229     public void testMultipleArgTagSurroundingMainArgAfterNoArgOption() {
230         String[] args = {"-arg", "blue", "green", "red", "-headless", "File.jnlp", "-arg", "yellow", "purple"};
231         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
232         List<String> values = parser.getParams(OptionsDefinitions.OPTIONS.ARG);
233         assertEquals(0, values.indexOf("blue"));
234         assertEquals(1, values.indexOf("green"));
235         assertEquals(2, values.indexOf("red"));
236         assertEquals(3, values.indexOf("yellow"));
237         assertEquals(4, values.indexOf("purple"));
238         assertTrue(parser.mainArgExists());
239         assertEquals("File.jnlp", parser.getMainArg());
240         assertTrue(parser.hasOption(OptionsDefinitions.OPTIONS.HEADLESS));
241     }
242 
243     @Test
testOptionWithDashInMiddleWontBeAltered()244     public void testOptionWithDashInMiddleWontBeAltered() {
245         String[] args = {"ar-g", "blue", "green", "red"};
246 
247         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
248         List<String> values = parser.getParams(OptionsDefinitions.OPTIONS.ARG);
249         assertEquals(values.size(), 0);
250     }
251 
252     @Test
testGetParamsWithNoValueHasNoValues()253     public void testGetParamsWithNoValueHasNoValues() {
254         String[] args = {"-arg"};
255 
256         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
257         List<String> values = parser.getParams(OptionsDefinitions.OPTIONS.ARG);
258         assertEquals(0, values.size());
259     }
260 
261     @Test
testOnlyFirstDashIsAcceptable()262     public void testOnlyFirstDashIsAcceptable() {
263         String[] args = {"-arg", "blue", "a-rg", "-headless", "-arg", "green", "-ar-g"};
264 
265         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
266         List<String> values = parser.getParams(OptionsDefinitions.OPTIONS.ARG);
267         assertEquals(4, values.size());
268         assertEquals(0, values.indexOf("blue"));
269         assertEquals(1, values.indexOf("a-rg"));
270         assertEquals(2, values.indexOf("green"));
271         assertEquals(3, values.indexOf("-ar-g"));
272     }
273 
274     @Test
testOptionsSyntaxPositive()275     public void testOptionsSyntaxPositive() {
276         assertTrue(OptionParser.stringEqualsOption("-headless", OptionsDefinitions.OPTIONS.HEADLESS));
277         assertTrue(OptionParser.stringEqualsOption("headless", OptionsDefinitions.OPTIONS.HEADLESS));
278         assertTrue(OptionParser.stringEqualsOption("--headless", OptionsDefinitions.OPTIONS.HEADLESS));
279         assertTrue(OptionParser.stringEqualsOption("---headless", OptionsDefinitions.OPTIONS.HEADLESS));
280     }
281 
282     @Test
testOptionsSyntaxNegative()283     public void testOptionsSyntaxNegative() {
284         assertFalse(OptionParser.stringEqualsOption(" -headless", OptionsDefinitions.OPTIONS.HEADLESS));
285         assertFalse(OptionParser.stringEqualsOption("h-eadless", OptionsDefinitions.OPTIONS.HEADLESS));
286         assertFalse(OptionParser.stringEqualsOption("headless-", OptionsDefinitions.OPTIONS.HEADLESS));
287         assertFalse(OptionParser.stringEqualsOption("- -headless", OptionsDefinitions.OPTIONS.HEADLESS));
288         assertFalse(OptionParser.stringEqualsOption("--- ---headless", OptionsDefinitions.OPTIONS.HEADLESS));
289         assertFalse(OptionParser.stringEqualsOption("- ---headless", OptionsDefinitions.OPTIONS.HEADLESS));
290         assertFalse(OptionParser.stringEqualsOption("--- -headless", OptionsDefinitions.OPTIONS.HEADLESS));
291     }
292 
293     @Test
testOptionWithEqualsParamIsValid()294     public void testOptionWithEqualsParamIsValid() {
295         String[] args = {"-arg=blue"};
296         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
297 
298         List<String> values = parser.getParams(OptionsDefinitions.OPTIONS.ARG);
299         assertEquals(1, values.size());
300         assertEquals(0, values.indexOf("blue"));
301     }
302 
303     @Test
testMultipleOptionWithEqualsParamIsValid()304     public void testMultipleOptionWithEqualsParamIsValid() {
305         String[] args = {"-arg=blue", "-property=red", "-param=green"};
306         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
307 
308         List<String> values = parser.getParams(OptionsDefinitions.OPTIONS.ARG);
309         assertEquals(1, values.size());
310         assertEquals(0, values.indexOf("blue"));
311         values = parser.getParams(OptionsDefinitions.OPTIONS.PROPERTY);
312         assertEquals(1, values.size());
313         assertEquals(0, values.indexOf("red"));
314         values = parser.getParams(OptionsDefinitions.OPTIONS.PARAM);
315         assertEquals(1, values.size());
316         assertEquals(0, values.indexOf("green"));
317     }
318 
319     @Test
testSameOptionWithEqualsParamMultipleTimesIsValid()320     public void testSameOptionWithEqualsParamMultipleTimesIsValid() {
321         String[] args = {"-arg=blue", "-arg=red", "-arg=green"};
322         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
323 
324         List<String> values = parser.getParams(OptionsDefinitions.OPTIONS.ARG);
325         assertEquals(3, values.size());
326         assertEquals(0, values.indexOf("blue"));
327         assertEquals(1, values.indexOf("red"));
328         assertEquals(2, values.indexOf("green"));
329     }
330 
331     @Test
testParamsCanHaveEqualsSigns()332     public void testParamsCanHaveEqualsSigns() {
333         String[] args = {"-arg", "colour=red", "height=50", "width=222", "circular=true"};
334         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
335 
336         List<String> values = parser.getParams(OptionsDefinitions.OPTIONS.ARG);
337         assertEquals(4, values.size());
338         assertEquals(0, values.indexOf("colour=red"));
339         assertEquals(1, values.indexOf("height=50"));
340         assertEquals(2, values.indexOf("width=222"));
341         assertEquals(3, values.indexOf("circular=true"));
342     }
343 
344     @Test
testParamsCanHaveDashes()345     public void testParamsCanHaveDashes() {
346         String[] args = {"-arg", "-red", "-koala", "-panda", "-grizzly"};
347         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
348 
349         List<String> values = parser.getParams(OptionsDefinitions.OPTIONS.ARG);
350         assertEquals(4, values.size());
351         assertEquals(0, values.indexOf("-red"));
352         assertEquals(1, values.indexOf("-koala"));
353         assertEquals(2, values.indexOf("-panda"));
354         assertEquals(3, values.indexOf("-grizzly"));
355     }
356 
357     @Test
testParamsCanHaveDashesAndEqualsSigns()358     public void testParamsCanHaveDashesAndEqualsSigns() {
359         String[] args = {"-arg", "-red=colour", "-koala=animal", "-panda=bear", "-grizzly=bear"};
360         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
361 
362         List<String> values = parser.getParams(OptionsDefinitions.OPTIONS.ARG);
363         assertEquals(4, values.size());
364         assertEquals(0, values.indexOf("-red=colour"));
365         assertEquals(1, values.indexOf("-koala=animal"));
366         assertEquals(2, values.indexOf("-panda=bear"));
367         assertEquals(3, values.indexOf("-grizzly=bear"));
368     }
369 
370     @Test
testMainArgAfterNoArgOption()371     public void testMainArgAfterNoArgOption() {
372         String[] args = {"-arg", "-red=colour", "-headless", "File.jnlp", "-arg", "-grizzly=bear"};
373         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
374 
375         assertEquals("File.jnlp", parser.getMainArg());
376     }
377 
378     @Test
testMainArgAfterOneArgOption()379     public void testMainArgAfterOneArgOption() {
380         String[] args = {"-arg", "-red=colour", "-update", "200", "File.jnlp", "-arg", "-grizzly=bear"};
381         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
382 
383         assertEquals("File.jnlp", parser.getMainArg());
384     }
385 
386     @Test
testMainArgAfterManyArgsOptionIsNotAccepted()387     public void testMainArgAfterManyArgsOptionIsNotAccepted() {
388         String[] args = {"-arg", "-red=colour", "-arg", "200", "File.jnlp", "-arg", "-grizzly=bear"};
389         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
390 
391         assertFalse(parser.mainArgExists());
392         assertNotEquals("File.jnlp", parser.getMainArg());
393     }
394 
395     @Test
testOptionWithMultipleEqualSignsOnlyParsesFirstEquals()396     public void testOptionWithMultipleEqualSignsOnlyParsesFirstEquals() {
397         String[] args = {"-arg=grizzly=panda=goldfish=mouse"};
398         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
399 
400         List<String> values = parser.getParams(OptionsDefinitions.OPTIONS.ARG);
401 
402         assertEquals(1, values.size());
403         assertEquals(0, values.indexOf("grizzly=panda=goldfish=mouse"));
404     }
405 
406     @Test
testGetParam()407     public void testGetParam() {
408         String[] args = {"-arg", "blue"};
409         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
410 
411         String value = parser.getParam(OptionsDefinitions.OPTIONS.ARG);
412         assertEquals("blue", value);
413     }
414 
415     @Test
testGetParamWithManyParams()416     public void testGetParamWithManyParams() {
417         String[] args = {"-arg", "blue", "red", "green"};
418         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
419 
420         String value = parser.getParam(OptionsDefinitions.OPTIONS.ARG);
421         assertEquals("blue", value);
422     }
423 
424     @Test
testGetParamWithNoParams()425     public void testGetParamWithNoParams() {
426         String[] args = {"-arg"};
427         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
428 
429         String value = parser.getParam(OptionsDefinitions.OPTIONS.ARG);
430         assertEquals("", value);
431     }
432 
433     @Test
testGetNumberOfOptions()434     public void testGetNumberOfOptions() {
435         String[] args = {"-arg", "-version", "-param", "-property", "-update"};
436         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
437         assertEquals(5, parser.getNumberOfOptions());
438     }
439 
440     @Test
testGetNumberOfOptionsWithOtherOptions()441     public void testGetNumberOfOptionsWithOtherOptions() {
442         String[] args = {"-arg", "-version", "-param", "-property", "-update", "-set", "-reset"};
443         OptionParser parser = new OptionParser(args, OptionsDefinitions.getJavaWsOptions());
444         assertEquals(5, parser.getNumberOfOptions());
445     }
446 
447     @Test
testEvenNumberSupportsEqualsChar()448     public void testEvenNumberSupportsEqualsChar() {
449         String[] args = {"-set", "yes", "no", "blue=red", "green", "orange", "yellow=purple=roseyred"};
450         OptionParser parser = new OptionParser(args, OptionsDefinitions.getItwsettingsCommands());
451         List<String> values = parser.getParams(OptionsDefinitions.OPTIONS.SET);
452         assertEquals("yes", values.get(0));
453         assertEquals("no", values.get(1));
454         assertEquals("blue", values.get(2));
455         assertEquals("red", values.get(3));
456         assertEquals("green", values.get(4));
457         assertEquals("orange", values.get(5));
458         assertEquals("yellow", values.get(6));
459         assertEquals("purple=roseyred", values.get(7));
460     }
461 
462     @Test(expected = UnevenParameterException.class)
testEvenNumberSupportsEqualsCharThrowsExceptionWhenParametersIsUneven()463     public void testEvenNumberSupportsEqualsCharThrowsExceptionWhenParametersIsUneven() {
464         String[] args = {"-set", "yes", "no", "blue=red", "green"};
465         OptionParser parser = new OptionParser(args, OptionsDefinitions.getItwsettingsCommands());
466     }
467 }