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