    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}