1 /***
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements. See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License. You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17 package org.apache.commons.cli;
18
19 import junit.framework.Test;
20 import junit.framework.TestCase;
21 import junit.framework.TestSuite;
22
23 import java.util.Arrays;
24 import java.util.Properties;
25
26 public class ValueTest extends TestCase
27 {
28
29 public static Test suite() {
30 return new TestSuite(ValueTest.class);
31 }
32
33 private CommandLine _cl = null;
34 private CommandLine _clOptional = null;
35 private Options opts = new Options();
36
37 public ValueTest(String name)
38 {
39 super(name);
40 }
41
42 public void setUp()
43 {
44 opts.addOption("a",
45 false,
46 "toggle -a");
47
48 opts.addOption("b",
49 true,
50 "set -b");
51
52 opts.addOption("c",
53 "c",
54 false,
55 "toggle -c");
56
57 opts.addOption("d",
58 "d",
59 true,
60 "set -d");
61
62 opts.addOption( OptionBuilder.hasOptionalArg()
63 .create( 'e') );
64
65 opts.addOption( OptionBuilder.hasOptionalArg()
66 .withLongOpt( "fish" )
67 .create( ) );
68
69 opts.addOption( OptionBuilder.hasOptionalArgs()
70 .withLongOpt( "gravy" )
71 .create( ) );
72
73 opts.addOption( OptionBuilder.hasOptionalArgs( 2 )
74 .withLongOpt( "hide" )
75 .create( ) );
76
77 opts.addOption( OptionBuilder.hasOptionalArgs( 2 )
78 .create( 'i' ) );
79
80 opts.addOption( OptionBuilder.hasOptionalArgs( )
81 .create( 'j' ) );
82
83 opts.addOption( OptionBuilder.hasArgs( ).withValueSeparator( ',' )
84 .create( 'k' ) );
85
86 String[] args = new String[] { "-a",
87 "-b", "foo",
88 "--c",
89 "--d", "bar"
90 };
91
92 try
93 {
94 Parser parser = new PosixParser();
95 _cl = parser.parse(opts,args);
96 }
97 catch (ParseException e)
98 {
99 fail("Cannot setUp() CommandLine: " + e.toString());
100 }
101 }
102
103 public void tearDown()
104 {
105
106 }
107
108 public void testShortNoArg()
109 {
110 assertTrue( _cl.hasOption("a") );
111 assertNull( _cl.getOptionValue("a") );
112 }
113
114 public void testShortWithArg()
115 {
116 assertTrue( _cl.hasOption("b") );
117 assertNotNull( _cl.getOptionValue("b") );
118 assertEquals( _cl.getOptionValue("b"), "foo");
119 }
120
121 public void testLongNoArg()
122 {
123 assertTrue( _cl.hasOption("c") );
124 assertNull( _cl.getOptionValue("c") );
125 }
126
127 public void testLongWithArg()
128 {
129 assertTrue( _cl.hasOption("d") );
130 assertNotNull( _cl.getOptionValue("d") );
131 assertEquals( _cl.getOptionValue("d"), "bar");
132 }
133
134 public void testShortOptionalArgNoValue()
135 {
136 String[] args = new String[] { "-e"
137 };
138 try
139 {
140 Parser parser = new PosixParser();
141 CommandLine cmd = parser.parse(opts,args);
142 assertTrue( cmd.hasOption("e") );
143 assertNull( cmd.getOptionValue("e") );
144 }
145 catch (ParseException e)
146 {
147 fail("Cannot setUp() CommandLine: " + e.toString());
148 }
149 }
150
151 public void testShortOptionalArgValue()
152 {
153 String[] args = new String[] { "-e", "everything"
154 };
155 try
156 {
157 Parser parser = new PosixParser();
158 CommandLine cmd = parser.parse(opts,args);
159 assertTrue( cmd.hasOption("e") );
160 assertEquals( "everything", cmd.getOptionValue("e") );
161 }
162 catch (ParseException e)
163 {
164 fail("Cannot setUp() CommandLine: " + e.toString());
165 }
166 }
167
168 public void testLongOptionalNoValue()
169 {
170 String[] args = new String[] { "--fish"
171 };
172 try
173 {
174 Parser parser = new PosixParser();
175 CommandLine cmd = parser.parse(opts,args);
176 assertTrue( cmd.hasOption("fish") );
177 assertNull( cmd.getOptionValue("fish") );
178 }
179 catch (ParseException e)
180 {
181 fail("Cannot setUp() CommandLine: " + e.toString());
182 }
183 }
184
185 public void testLongOptionalArgValue()
186 {
187 String[] args = new String[] { "--fish", "face"
188 };
189 try
190 {
191 Parser parser = new PosixParser();
192 CommandLine cmd = parser.parse(opts,args);
193 assertTrue( cmd.hasOption("fish") );
194 assertEquals( "face", cmd.getOptionValue("fish") );
195 }
196 catch (ParseException e)
197 {
198 fail("Cannot setUp() CommandLine: " + e.toString());
199 }
200 }
201
202 public void testShortOptionalArgValues()
203 {
204 String[] args = new String[] { "-j", "ink", "idea"
205 };
206 try
207 {
208 Parser parser = new PosixParser();
209 CommandLine cmd = parser.parse(opts,args);
210 assertTrue( cmd.hasOption("j") );
211 assertEquals( "ink", cmd.getOptionValue("j") );
212 assertEquals( "ink", cmd.getOptionValues("j")[0] );
213 assertEquals( "idea", cmd.getOptionValues("j")[1] );
214 assertEquals( cmd.getArgs().length, 0 );
215 }
216 catch (ParseException e)
217 {
218 fail("Cannot setUp() CommandLine: " + e.toString());
219 }
220 }
221
222 public void testLongOptionalArgValues()
223 {
224 String[] args = new String[] { "--gravy", "gold", "garden"
225 };
226 try
227 {
228 Parser parser = new PosixParser();
229 CommandLine cmd = parser.parse(opts,args);
230 assertTrue( cmd.hasOption("gravy") );
231 assertEquals( "gold", cmd.getOptionValue("gravy") );
232 assertEquals( "gold", cmd.getOptionValues("gravy")[0] );
233 assertEquals( "garden", cmd.getOptionValues("gravy")[1] );
234 assertEquals( cmd.getArgs().length, 0 );
235 }
236 catch (ParseException e)
237 {
238 fail("Cannot setUp() CommandLine: " + e.toString());
239 }
240 }
241
242 public void testShortOptionalNArgValues()
243 {
244 String[] args = new String[] { "-i", "ink", "idea", "isotope", "ice"
245 };
246 try
247 {
248 Parser parser = new PosixParser();
249 CommandLine cmd = parser.parse(opts,args);
250 assertTrue( cmd.hasOption("i") );
251 assertEquals( "ink", cmd.getOptionValue("i") );
252 assertEquals( "ink", cmd.getOptionValues("i")[0] );
253 assertEquals( "idea", cmd.getOptionValues("i")[1] );
254 assertEquals( cmd.getArgs().length, 2 );
255 assertEquals( "isotope", cmd.getArgs()[0] );
256 assertEquals( "ice", cmd.getArgs()[1] );
257 }
258 catch (ParseException e)
259 {
260 fail("Cannot setUp() CommandLine: " + e.toString());
261 }
262 }
263
264 public void testLongOptionalNArgValues()
265 {
266 String[] args = new String[] {
267 "--hide", "house", "hair", "head"
268 };
269
270 Parser parser = new PosixParser();
271
272 try
273 {
274 CommandLine cmd = parser.parse(opts,args);
275 assertTrue( cmd.hasOption("hide") );
276 assertEquals( "house", cmd.getOptionValue("hide") );
277 assertEquals( "house", cmd.getOptionValues("hide")[0] );
278 assertEquals( "hair", cmd.getOptionValues("hide")[1] );
279 assertEquals( cmd.getArgs().length, 1 );
280 assertEquals( "head", cmd.getArgs()[0] );
281 }
282 catch (ParseException e)
283 {
284 fail("Cannot setUp() CommandLine: " + e.toString());
285 }
286 }
287
288 public void testPropertyOptionSingularValue()
289 {
290 Properties properties = new Properties();
291 properties.setProperty( "hide", "seek" );
292
293 Parser parser = new PosixParser();
294
295 try
296 {
297 CommandLine cmd = parser.parse(opts, null, properties);
298 assertTrue( cmd.hasOption("hide") );
299 assertEquals( "seek", cmd.getOptionValue("hide") );
300 assertTrue( !cmd.hasOption("fake") );
301 }
302 catch (ParseException e)
303 {
304 fail("Cannot setUp() CommandLine: " + e.toString());
305 }
306 }
307
308 public void testPropertyOptionFlags()
309 {
310 Properties properties = new Properties();
311 properties.setProperty( "a", "true" );
312 properties.setProperty( "c", "yes" );
313 properties.setProperty( "e", "1" );
314
315 Parser parser = new PosixParser();
316
317 try
318 {
319 CommandLine cmd = parser.parse(opts, null, properties);
320 assertTrue( cmd.hasOption("a") );
321 assertTrue( cmd.hasOption("c") );
322 assertTrue( cmd.hasOption("e") );
323 }
324 catch (ParseException e)
325 {
326 fail("Cannot setUp() CommandLine: " + e.toString());
327 }
328
329 properties = new Properties();
330 properties.setProperty( "a", "false" );
331 properties.setProperty( "c", "no" );
332 properties.setProperty( "e", "0" );
333 try
334 {
335 CommandLine cmd = parser.parse(opts, null, properties);
336 assertTrue( !cmd.hasOption("a") );
337 assertTrue( !cmd.hasOption("c") );
338 assertTrue( !cmd.hasOption("e") );
339 }
340 catch (ParseException e)
341 {
342 fail("Cannot setUp() CommandLine: " + e.toString());
343 }
344
345 properties = new Properties();
346 properties.setProperty( "a", "TRUE" );
347 properties.setProperty( "c", "nO" );
348 properties.setProperty( "e", "TrUe" );
349 try
350 {
351 CommandLine cmd = parser.parse(opts, null, properties);
352 assertTrue( cmd.hasOption("a") );
353 assertTrue( !cmd.hasOption("c") );
354 assertTrue( cmd.hasOption("e") );
355 }
356 catch (ParseException e)
357 {
358 fail("Cannot setUp() CommandLine: " + e.toString());
359 }
360
361 properties = new Properties();
362 properties.setProperty( "a", "just a string" );
363 properties.setProperty( "e", "" );
364 try
365 {
366 CommandLine cmd = parser.parse(opts, null, properties);
367 assertTrue( !cmd.hasOption("a") );
368 assertTrue( !cmd.hasOption("c") );
369 assertTrue( !cmd.hasOption("e") );
370 }
371 catch (ParseException e)
372 {
373 fail("Cannot setUp() CommandLine: " + e.toString());
374 }
375
376 }
377
378 public void testPropertyOptionMultipleValues()
379 {
380 Properties properties = new Properties();
381 properties.setProperty( "k", "one,two" );
382
383 Parser parser = new PosixParser();
384
385 String[] values = new String[] {
386 "one", "two"
387 };
388 try
389 {
390 CommandLine cmd = parser.parse(opts, null, properties);
391 assertTrue( cmd.hasOption("k") );
392 assertTrue( Arrays.equals( values, cmd.getOptionValues('k') ) );
393 }
394 catch (ParseException e)
395 {
396 fail("Cannot setUp() CommandLine: " + e.toString());
397 }
398 }
399
400 public void testPropertyOverrideValues()
401 {
402 String[] args = new String[] {
403 "-j",
404 "found",
405 "-i",
406 "ink"
407 };
408
409 Properties properties = new Properties();
410 properties.setProperty( "j", "seek" );
411 try
412 {
413 Parser parser = new PosixParser();
414 CommandLine cmd = parser.parse(opts, args, properties);
415 assertTrue( cmd.hasOption("j") );
416 assertEquals( "found", cmd.getOptionValue("j") );
417 assertTrue( cmd.hasOption("i") );
418 assertEquals( "ink", cmd.getOptionValue("i") );
419 assertTrue( !cmd.hasOption("fake") );
420 }
421 catch (ParseException e)
422 {
423 fail("Cannot setUp() CommandLine: " + e.toString());
424 }
425 }
426
427 }