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 }