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 }