1   package org.apache.turbine.util;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *   http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import java.math.BigDecimal;
23  
24  import junit.framework.TestSuite;
25  
26  import org.apache.commons.configuration.BaseConfiguration;
27  import org.apache.commons.configuration.Configuration;
28  
29  import org.apache.turbine.services.ServiceManager;
30  import org.apache.turbine.services.TurbineServices;
31  import org.apache.turbine.test.BaseTestCase;
32  import org.apache.turbine.util.parser.BaseValueParser;
33  import org.apache.turbine.util.parser.ParserUtils;
34  
35  /***
36   * Testing of the BaseValueParser class
37   *
38   * @author <a href="mailto:quintonm@bellsouth.net">Quinton McCombs</a>
39   * @version $Id: BaseValueParserTest.java 645801 2008-04-08 09:08:05Z tv $
40   */
41  public class BaseValueParserTest extends BaseTestCase
42  {
43      private BaseValueParser parser;
44  
45      /***
46       * Constructor for test.
47       *
48       * @param testName name of the test being executed
49       */
50      public BaseValueParserTest(String testName)
51              throws Exception
52      {
53          super(testName);
54  
55          // Setup configuration
56          ServiceManager serviceManager = TurbineServices.getInstance();
57          serviceManager.setApplicationRoot(".");
58          Configuration cfg = new BaseConfiguration();
59          cfg.setProperty(ParserUtils.URL_CASE_FOLDING_KEY,
60                  ParserUtils.URL_CASE_FOLDING_LOWER_VALUE );
61          serviceManager.setConfiguration(cfg);
62  
63      }
64  
65      /***
66       * Performs any initialization that must happen before each test is run.
67       */
68      protected void setUp()
69      {
70          parser = new BaseValueParser();
71      }
72  
73      /***
74       * Clean up after each test is run.
75       */
76      protected void tearDown()
77      {
78          parser = null;
79      }
80  
81      /***
82       * Factory method for creating a TestSuite for this class.
83       *
84       * @return the test suite
85       */
86      public static TestSuite suite()
87      {
88          TestSuite suite = new TestSuite(BaseValueParserTest.class);
89          return suite;
90      }
91  
92      public void testGetByte()
93      {
94          // no param
95          byte result = parser.getByte("invalid");
96          assertEquals(result, 0);
97  
98          // default
99          result = parser.getByte("default", (byte)3);
100         assertEquals(result, 3);
101 
102         // param exists
103         parser.add("exists", "1");
104         result = parser.getByte("exists");
105         assertEquals(result, 1);
106 
107         // unparsable value
108         parser.add("unparsable", "a");
109         result = parser.getByte("unparsable");
110         assertEquals(result, 0);
111     }
112 
113     public void testGetByteObject()
114     {
115         // no param
116         Byte result = parser.getByteObject("invalid");
117         assertNull(result);
118 
119         // default
120         result = parser.getByteObject("default", new Byte((byte)3));
121         assertEquals(result, new Byte((byte)3));
122 
123         // param exists
124         parser.add("exists", "1");
125         result = parser.getByteObject("exists");
126         assertEquals(result, new Byte((byte)1));
127 
128         // unparsable value
129         parser.add("unparsable", "a");
130         result = parser.getByteObject("unparsable");
131         assertNull(result);
132     }
133 
134     public void testGetInt()
135     {
136         // no param
137         int result = parser.getInt("invalid");
138         assertEquals(result, 0);
139 
140         // default
141         result = parser.getInt("default", 3);
142         assertEquals(result, 3);
143 
144         // param exists
145         parser.add("exists", "1");
146         result = parser.getInt("exists");
147         assertEquals(result, 1);
148 
149         // unparsable value
150         parser.add("unparsable", "a");
151         result = parser.getInt("unparsable");
152         assertEquals(result, 0);
153 
154         // array
155         parser.add("array", "1");
156         parser.add("array", "2");
157         parser.add("array", "3");
158         int arrayResult[] = parser.getInts("array");
159         int compare[] = {1,2,3};
160         assertEquals(arrayResult.length, compare.length);
161         for( int i=0; i<compare.length; i++)
162         {
163             assertEquals(compare[i], arrayResult[i]);
164         }
165 
166         // array w/ unparsable element
167         parser.add("array2", "1");
168         parser.add("array2", "a");
169         parser.add("array2", "3");
170         int arrayResult2[] = parser.getInts("array2");
171         int compare2[] = {1,0,3};
172         assertEquals(arrayResult2.length, compare2.length);
173         for( int i=0; i<compare2.length; i++)
174         {
175             assertEquals(compare2[i], arrayResult2[i] );
176         }
177     }
178 
179     public void testGetIntObject()
180     {
181         // no param
182         Integer result = parser.getIntObject("invalid");
183         assertNull(result);
184 
185         // default
186         result = parser.getIntObject("default", new Integer(3));
187         assertEquals(result, new Integer(3));
188 
189         // param exists
190         parser.add("exists", "1");
191         result = parser.getIntObject("exists");
192         assertEquals(result, new Integer(1));
193 
194         // unparsable value
195         parser.add("unparsable", "a");
196         result = parser.getIntObject("unparsable");
197         assertNull(result);
198 
199         // array
200         parser.add("array", "1");
201         parser.add("array", "2");
202         parser.add("array", "3");
203         Integer arrayResult[] = parser.getIntObjects("array");
204         Integer compare[] = {new Integer(1), new Integer(2), new Integer(3)};
205         assertEquals(arrayResult.length, compare.length);
206         for( int i=0; i<compare.length; i++)
207         {
208             assertEquals(compare[i], arrayResult[i]);
209         }
210 
211         // array w/ unparsable element
212         parser.add("array2", "1");
213         parser.add("array2", "a");
214         parser.add("array2", "3");
215         Integer arrayResult2[] = parser.getIntObjects("array2");
216         Integer compare2[] = {new Integer(1), null, new Integer(3)};
217         assertEquals(arrayResult2.length, compare2.length);
218         for( int i=0; i<compare2.length; i++)
219         {
220             assertEquals(compare2[i], arrayResult2[i] );
221         }
222     }
223 
224     public void testGetFloat()
225     {
226         // no param
227         float result = parser.getFloat("invalid");
228         assertEquals(result, 0, 0);
229 
230         // default
231         result = parser.getFloat("default", 3);
232         assertEquals(result, 3, 0);
233 
234         // param exists
235         parser.add("exists", "1");
236         result = parser.getFloat("exists");
237         assertEquals(result, 1, 0);
238 
239         // unparsable value
240         parser.add("unparsable", "a");
241         result = parser.getFloat("unparsable");
242         assertEquals(result, 0, 0);
243 
244         // array
245         parser.add("array", "1");
246         parser.add("array", "2");
247         parser.add("array", "3");
248         float arrayResult[] = parser.getFloats("array");
249         float compare[] = {1,2,3};
250         assertEquals(arrayResult.length, compare.length);
251         for( int i=0; i<compare.length; i++)
252         {
253             assertEquals(compare[i], arrayResult[i], 0);
254         }
255 
256         // array w/ unparsable element
257         parser.add("array2", "1");
258         parser.add("array2", "a");
259         parser.add("array2", "3");
260         float arrayResult2[] = parser.getFloats("array2");
261         float compare2[] = {1,0,3};
262         assertEquals(arrayResult2.length, compare2.length);
263         for( int i=0; i<compare2.length; i++)
264         {
265             assertEquals(compare2[i], arrayResult2[i], 0);
266         }
267     }
268 
269     public void testGetFloatObject()
270     {
271         // no param
272         Float result = parser.getFloatObject("invalid");
273         assertNull(result);
274 
275         // default
276         result = parser.getFloatObject("default", new Float(3));
277         assertEquals(result, new Float(3));
278 
279         // param exists
280         parser.add("exists", "1");
281         result = parser.getFloatObject("exists");
282         assertEquals(result, new Float(1));
283 
284         // unparsable value
285         parser.add("unparsable", "a");
286         result = parser.getFloatObject("unparsable");
287         assertNull(result);
288 
289         // array
290         parser.add("array", "1");
291         parser.add("array", "2");
292         parser.add("array", "3");
293         Float arrayResult[] = parser.getFloatObjects("array");
294         Float compare[] = {new Float(1), new Float(2), new Float(3)};
295         assertEquals(arrayResult.length, compare.length);
296         for( int i=0; i<compare.length; i++)
297         {
298             assertEquals(compare[i], arrayResult[i]);
299         }
300 
301         // array w/ unparsable element
302         parser.add("array2", "1");
303         parser.add("array2", "a");
304         parser.add("array2", "3");
305         Float arrayResult2[] = parser.getFloatObjects("array2");
306         Float compare2[] = {new Float(1), null, new Float(3)};
307         assertEquals(arrayResult2.length, compare2.length);
308         for( int i=0; i<compare2.length; i++)
309         {
310             assertEquals(compare2[i], arrayResult2[i] );
311         }
312     }
313 
314     public void testGetDouble()
315     {
316         // no param
317         double result = parser.getDouble("invalid");
318         assertEquals(result, 0, 0);
319 
320         // default
321         result = parser.getDouble("default", 3);
322         assertEquals(result, 3, 0);
323 
324         // param exists
325         parser.add("exists", "1");
326         result = parser.getDouble("exists");
327         assertEquals(result, 1, 0);
328 
329         // unparsable value
330         parser.add("unparsable", "a");
331         result = parser.getDouble("unparsable");
332         assertEquals(result, 0, 0);
333 
334         // array
335         parser.add("array", "1");
336         parser.add("array", "2");
337         parser.add("array", "3");
338         double arrayResult[] = parser.getDoubles("array");
339         double compare[] = {1,2,3};
340         assertEquals(arrayResult.length, compare.length);
341         for( int i=0; i<compare.length; i++)
342         {
343             assertEquals(compare[i], arrayResult[i], 0);
344         }
345 
346         // array w/ unparsable element
347         parser.add("array2", "1");
348         parser.add("array2", "a");
349         parser.add("array2", "3");
350         double arrayResult2[] = parser.getDoubles("array2");
351         double compare2[] = {1,0,3};
352         assertEquals(arrayResult2.length, compare2.length);
353         for( int i=0; i<compare2.length; i++)
354         {
355             assertEquals(compare2[i], arrayResult2[i], 0);
356         }
357     }
358 
359     public void testGetDoubleObject()
360     {
361         // no param
362         Double result = parser.getDoubleObject("invalid");
363         assertNull(result);
364 
365         // default
366         result = parser.getDoubleObject("default", new Double(3));
367         assertEquals(result, new Double(3));
368 
369         // param exists
370         parser.add("exists", "1");
371         result = parser.getDoubleObject("exists");
372         assertEquals(result, new Double(1));
373 
374         // unparsable value
375         parser.add("unparsable", "a");
376         result = parser.getDoubleObject("unparsable");
377         assertNull(result);
378 
379         // array
380         parser.add("array", "1");
381         parser.add("array", "2");
382         parser.add("array", "3");
383         Double arrayResult[] = parser.getDoubleObjects("array");
384         Double compare[] = {new Double(1), new Double(2), new Double(3)};
385         assertEquals(arrayResult.length, compare.length);
386         for( int i=0; i<compare.length; i++)
387         {
388             assertEquals(compare[i], arrayResult[i]);
389         }
390 
391         // array w/ unparsable element
392         parser.add("array2", "1");
393         parser.add("array2", "a");
394         parser.add("array2", "3");
395         Double arrayResult2[] = parser.getDoubleObjects("array2");
396         Double compare2[] = {new Double(1), null, new Double(3)};
397         assertEquals(arrayResult2.length, compare2.length);
398         for( int i=0; i<compare2.length; i++)
399         {
400             assertEquals(compare2[i], arrayResult2[i] );
401         }
402     }
403 
404     public void testGetLong()
405     {
406         // no param
407         long result = parser.getLong("invalid");
408         assertEquals(result, 0);
409 
410         // default
411         result = parser.getLong("default", 3);
412         assertEquals(result, 3);
413 
414         // param exists
415         parser.add("exists", "1");
416         result = parser.getLong("exists");
417         assertEquals(result, 1);
418 
419         // unparsable value
420         parser.add("unparsable", "a");
421         result = parser.getLong("unparsable");
422         assertEquals(result, 0);
423 
424         // array
425         parser.add("array", "1");
426         parser.add("array", "2");
427         parser.add("array", "3");
428         long arrayResult[] = parser.getLongs("array");
429         long compare[] = {1,2,3};
430         assertEquals(arrayResult.length, compare.length);
431         for( int i=0; i<compare.length; i++)
432         {
433             assertEquals(compare[i], arrayResult[i]);
434         }
435 
436         // array w/ unparsable element
437         parser.add("array2", "1");
438         parser.add("array2", "a");
439         parser.add("array2", "3");
440         long arrayResult2[] = parser.getLongs("array2");
441         long compare2[] = {1,0,3};
442         assertEquals(arrayResult2.length, compare2.length);
443         for( int i=0; i<compare2.length; i++)
444         {
445             assertEquals(compare2[i], arrayResult2[i]);
446         }
447     }
448 
449     public void testGetLongObject()
450     {
451         // no param
452         Long result = parser.getLongObject("invalid");
453         assertNull(result);
454 
455         // default
456         result = parser.getLongObject("default", new Long(3));
457         assertEquals(result, new Long(3));
458 
459         // param exists
460         parser.add("exists", "1");
461         result = parser.getLongObject("exists");
462         assertEquals(result, new Long(1));
463 
464         // unparsable value
465         parser.add("unparsable", "a");
466         result = parser.getLongObject("unparsable");
467         assertNull(result);
468 
469         // array
470         parser.add("array", "1");
471         parser.add("array", "2");
472         parser.add("array", "3");
473         Long arrayResult[] = parser.getLongObjects("array");
474         Long compare[] = {new Long(1), new Long(2), new Long(3)};
475         assertEquals(arrayResult.length, compare.length);
476         for( int i=0; i<compare.length; i++)
477         {
478             assertEquals(compare[i], arrayResult[i]);
479         }
480 
481         // array w/ unparsable element
482         parser.add("array2", "1");
483         parser.add("array2", "a");
484         parser.add("array2", "3");
485         Long arrayResult2[] = parser.getLongObjects("array2");
486         Long compare2[] = {new Long(1), null, new Long(3)};
487         assertEquals(arrayResult2.length, compare2.length);
488         for( int i=0; i<compare2.length; i++)
489         {
490             assertEquals(compare2[i], arrayResult2[i] );
491         }
492     }
493 
494     public void testGetBoolean()
495     {
496         // no param
497         boolean result = parser.getBoolean("invalid");
498         assertEquals(result, false);
499 
500         // default
501         result = parser.getBoolean("default", true);
502         assertEquals(result, true);
503 
504         // true values - Case is intentional
505         parser.add("true1", "trUe");
506         result = parser.getBoolean("true1");
507         assertEquals(result, true);
508         parser.add("true2", "yEs");
509         result = parser.getBoolean("true2");
510         assertEquals(result, true);
511         parser.add("true3", "1");
512         result = parser.getBoolean("true3");
513         assertEquals(result, true);
514         parser.add("true4", "oN");
515         result = parser.getBoolean("true4");
516         assertEquals(result, true);
517 
518         // unparsable value
519         parser.add("unparsable", "a");
520         result = parser.getBoolean("unparsable");
521         assertEquals(result, false);
522 
523     }
524 
525     public void testGetBooleanObject()
526     {
527         // no param
528         Boolean result = parser.getBooleanObject("invalid");
529         assertNull(result);
530 
531         // default
532         result = parser.getBooleanObject("default", Boolean.TRUE);
533         assertEquals(result, Boolean.TRUE);
534 
535         // true values - Case is intentional
536         parser.add("true1", "trUe");
537         result = parser.getBooleanObject("true1");
538         assertEquals(result, Boolean.TRUE);
539         parser.add("true2", "yEs");
540         result = parser.getBooleanObject("true2");
541         assertEquals(result, Boolean.TRUE);
542         parser.add("true3", "1");
543         result = parser.getBooleanObject("true3");
544         assertEquals(result, Boolean.TRUE);
545         parser.add("true4", "oN");
546         result = parser.getBooleanObject("true4");
547         assertEquals(result, Boolean.TRUE);
548 
549         // false values - Case is intentional
550         parser.add("false1", "falSe");
551         result = parser.getBooleanObject("false1");
552         assertEquals(result, Boolean.FALSE);
553         parser.add("false2", "nO");
554         result = parser.getBooleanObject("false2");
555         assertEquals(result, Boolean.FALSE);
556         parser.add("false3", "0");
557         result = parser.getBooleanObject("false3");
558         assertEquals(result, Boolean.FALSE);
559         parser.add("false4", "oFf");
560         result = parser.getBooleanObject("false4");
561         assertEquals(result, Boolean.FALSE);
562 
563 
564         // unparsable value
565         parser.add("unparsable", "a");
566         result = parser.getBooleanObject("unparsable");
567         assertNull(result);
568     }
569 
570     public void testGetBigDecimal()
571     {
572         // no param
573         BigDecimal result = parser.getBigDecimal("invalid");
574         assertNull(result);
575 
576         // default
577         result = parser.getBigDecimal("default", new BigDecimal(3));
578         assertEquals(result, new BigDecimal(3));
579 
580         // param exists
581         parser.add("exists", "1");
582         result = parser.getBigDecimal("exists");
583         assertEquals(result, new BigDecimal(1));
584 
585         // unparsable value
586         parser.add("unparsable", "a");
587         result = parser.getBigDecimal("unparsable");
588         assertNull(result);
589 
590         // array
591         parser.add("array", "1");
592         parser.add("array", "2");
593         parser.add("array", "3");
594         BigDecimal arrayResult[] = parser.getBigDecimals("array");
595         BigDecimal compare[] = {new BigDecimal(1), new BigDecimal(2),
596                                 new BigDecimal(3)};
597         assertEquals(arrayResult.length, compare.length);
598         for( int i=0; i<compare.length; i++)
599         {
600             assertEquals(compare[i], arrayResult[i]);
601         }
602 
603         // array w/ unparsable element
604         parser.add("array2", "1");
605         parser.add("array2", "a");
606         parser.add("array2", "3");
607         BigDecimal arrayResult2[] = parser.getBigDecimals("array2");
608         BigDecimal compare2[] = {new BigDecimal(1), null, new BigDecimal(3)};
609         assertEquals(arrayResult2.length, compare2.length);
610         for( int i=0; i<compare2.length; i++)
611         {
612             assertEquals(compare2[i], arrayResult2[i] );
613         }
614     }
615 
616 
617     public void getString()
618     {
619         // no param
620         String result = parser.getString("invalid");
621         assertNull(result);
622 
623         // default
624         result = parser.getString("default", "default");
625         assertEquals(result, "default");
626 
627         // null value
628         parser.add("null", "null");
629         assertNull( parser.getString("null"));
630 
631         // only return the first added
632         parser.add("multiple", "test");
633         parser.add("multiple", "test2");
634         assertEquals("test2", parser.getString("multiple"));
635 
636         // array
637         parser.add("array", "line1");
638         parser.add("array", "line2");
639         parser.add("array", "line3");
640         String arrayResult[] = parser.getStrings("array");
641         String compare[] = {"line1","line2","line3"};
642         assertEquals(arrayResult.length, compare.length);
643         for( int i=0; i<compare.length; i++)
644         {
645             assertEquals(compare[i], arrayResult[i]);
646         }
647 
648     }
649 
650 }