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