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