package org.apache.fulcrum.parser;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import static org.junit.jupiter.api.Assertions.*;

import java.math.BigDecimal;
import java.util.Calendar;
import java.util.Locale;

import org.apache.avalon.framework.component.ComponentException;
import org.apache.fulcrum.testcontainer.BaseUnit5Test;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;


/**
 * Testing of the BaseValueParser class
 *
 * @author <a href="mailto:quintonm@bellsouth.net">Quinton McCombs</a>
 * @version $Id: BaseValueParserTest.java 222043 2004-12-06 17:47:33Z painter $
 */
public class BaseValueParserTest extends BaseUnit5Test
{

	private BaseValueParser parser;

    private ParserService parserService;

    /**
     * Performs any initialization that must happen before each test is run.
     * @throws Exception if parser service not found
     */
    @BeforeEach
    public void setUp() throws Exception
    {
        try
        {
            parserService = (ParserService)this.lookup(ParserService.ROLE);
            parser = parserService.getParser(BaseValueParser.class);
        }
        catch (ComponentException e)
        {
            e.printStackTrace();
            fail(e.getMessage());
        }
    }

    /**
     * Clean up after each test is run.
     */
    @AfterEach
    public void tearDown()
    {
        parserService.putParser(parser);
        this.release(parserService);
    }
    
    @Test
    public void testDate()
    {
        parser.clear();
        parser.setLocale(Locale.US);

        assertEquals(0, parser.keySet().size(), "Wrong number of keys");

        parser.add("foo", "03/21/2008");

        Calendar cal = Calendar.getInstance(Locale.US);
        cal.clear();
        cal.set(2008, 2, 21, 0, 0, 0);

        assertEquals( cal.getTime(), parser.getDate("foo"), "Wrong Date value (US)");

        parser.clear();
        parser.setLocale(Locale.GERMANY);

        parser.add("foo", "21.03.2008");

        cal = Calendar.getInstance(Locale.GERMANY);
        cal.clear();
        cal.set(2008, 2, 21, 0, 0, 0);

        assertEquals( cal.getTime(), parser.getDate("foo"), "Wrong Date value (German)");
    }
    @Test
    public void testGetByte()
    {
        // no param
        byte result = parser.getByte("invalid");
        assertEquals(result, 0);

        // default
        result = parser.getByte("default", (byte)3);
        assertEquals(result, 3);

        // param exists
        parser.add("exists", "1");
        result = parser.getByte("exists");
        assertEquals(result, 1);

        // unparsable value
        parser.add("unparsable", "a");
        result = parser.getByte("unparsable");
        assertEquals(result, 0);
    }
    
    @Test
    public void testGetByteObject()
    {
        // no param
        Byte result = parser.getByteObject("invalid");
        assertNull(result);

        // default
        result = parser.getByteObject("default", new Byte((byte)3));
        assertEquals(result, new Byte((byte)3));

        // param exists
        parser.add("exists", "1");
        result = parser.getByteObject("exists");
        assertEquals(result, new Byte((byte)1));

        // unparsable value
        parser.add("unparsable", "a");
        result = parser.getByteObject("unparsable");
        assertNull(result);
    }
    
    @Test
    public void testGetInt()
    {
        // no param
        int result = parser.getInt("invalid");
        assertEquals(result, 0);

        // default
        result = parser.getInt("default", 3);
        assertEquals(result, 3);

        // param exists
        parser.add("exists", "1");
        result = parser.getInt("exists");
        assertEquals(result, 1);

        // unparsable value
        parser.add("unparsable", "a");
        result = parser.getInt("unparsable");
        assertEquals(result, 0);

        // array
        parser.add("array", "1");
        parser.add("array", "2");
        parser.add("array", "3");
        int arrayResult[] = parser.getInts("array");
        int compare[] = {1,2,3};
        assertEquals(arrayResult.length, compare.length);
        for( int i=0; i<compare.length; i++)
        {
            assertEquals(compare[i], arrayResult[i]);
        }

        // array w/ unparsable element
        parser.add("array2", "1");
        parser.add("array2", "a");
        parser.add("array2", "3");
        int arrayResult2[] = parser.getInts("array2");
        int compare2[] = {1,0,3};
        assertEquals(arrayResult2.length, compare2.length);
        for( int i=0; i<compare2.length; i++)
        {
            assertEquals(compare2[i], arrayResult2[i] );
        }
    }
    @Test
    public void testGetIntObject()
    {
        // no param
        Integer result = parser.getIntObject("invalid");
        assertNull(result);

        // default
        result = parser.getIntObject("default", new Integer(3));
        assertEquals(result, new Integer(3));

        // param exists
        parser.add("exists", "1");
        result = parser.getIntObject("exists");
        assertEquals(result, new Integer(1));

        // unparsable value
        parser.add("unparsable", "a");
        result = parser.getIntObject("unparsable");
        assertNull(result);

        // array
        parser.add("array", "1");
        parser.add("array", "2");
        parser.add("array", "3");
        Integer arrayResult[] = parser.getIntObjects("array");
        Integer compare[] = {new Integer(1), new Integer(2), new Integer(3)};
        assertEquals(arrayResult.length, compare.length);
        for( int i=0; i<compare.length; i++)
        {
            assertEquals(compare[i], arrayResult[i]);
        }

        // array w/ unparsable element
        parser.add("array2", "1");
        parser.add("array2", "a");
        parser.add("array2", "3");
        Integer arrayResult2[] = parser.getIntObjects("array2");
        Integer compare2[] = {new Integer(1), null, new Integer(3)};
        assertEquals(arrayResult2.length, compare2.length);
        for( int i=0; i<compare2.length; i++)
        {
            assertEquals(compare2[i], arrayResult2[i] );
        }
    }
    @Test
    public void testGetFloat()
    {
        // no param
        float result = parser.getFloat("invalid");
        assertEquals(0, result);

        // default
        result = parser.getFloat("default", 3);
        assertEquals(3, result);

        // param exists
        parser.add("exists", "1");
        result = parser.getFloat("exists");
        assertEquals(1, result);

        // unparsable value
        parser.add("unparsable", "a");
        result = parser.getFloat("unparsable");
        assertEquals(0, result);

        // array
        parser.add("array", "1");
        parser.add("array", "2");
        parser.add("array", "3");
        float arrayResult[] = parser.getFloats("array");
        float compare[] = {1,2,3};
        assertEquals(arrayResult.length, compare.length);
        for( int i=0; i<compare.length; i++)
        {
            assertEquals(compare[i], arrayResult[i]);
        }

        // array w/ unparsable element
        parser.add("array2", "1");
        parser.add("array2", "a");
        parser.add("array2", "3");
        float arrayResult2[] = parser.getFloats("array2");
        float compare2[] = {1,0,3};
        assertEquals(compare2.length, arrayResult2.length);
        for( int i=0; i<compare2.length; i++)
        {
            assertEquals(compare2[i], arrayResult2[i]);
        }
    }
    @Test
    public void testGetFloatObject()
    {
        // no param
        Float result = parser.getFloatObject("invalid");
        assertNull(result);

        // default
        result = parser.getFloatObject("default", new Float(3));
        assertEquals(new Float(3), result);

        // param exists
        parser.add("exists", "1");
        result = parser.getFloatObject("exists");
        assertEquals(new Float(1), result);

        // unparsable value
        parser.add("unparsable", "a");
        result = parser.getFloatObject("unparsable");
        assertNull(result);

        // array
        parser.add("array", "1");
        parser.add("array", "2");
        parser.add("array", "3");
        Float arrayResult[] = parser.getFloatObjects("array");
        Float compare[] = {new Float(1), new Float(2), new Float(3)};
        assertEquals(compare.length, arrayResult.length);
        for( int i=0; i<compare.length; i++)
        {
            assertEquals(compare[i], arrayResult[i]);
        }

        // array w/ unparsable element
        parser.add("array2", "1");
        parser.add("array2", "a");
        parser.add("array2", "3");
        Float arrayResult2[] = parser.getFloatObjects("array2");
        Float compare2[] = {new Float(1), null, new Float(3)};
        assertEquals(compare2.length, arrayResult2.length);
        for( int i=0; i<compare2.length; i++)
        {
            assertEquals(arrayResult2[i], compare2[i] );
        }
    }
    @Test
    public void testGetDouble()
    {
        // no param
        double result = parser.getDouble("invalid");
        assertEquals(0, result);

        // default
        result = parser.getDouble("default", 3);
        assertEquals(3, result);

        // param exists
        parser.add("exists", "1");
        result = parser.getDouble("exists");
        assertEquals(1, result);

        // unparsable value
        parser.add("unparsable", "a");
        result = parser.getDouble("unparsable");
        assertEquals(0, result);

        // array
        parser.add("array", "1");
        parser.add("array", "2");
        parser.add("array", "3");
        double arrayResult[] = parser.getDoubles("array");
        double compare[] = {1,2,3};
        assertEquals(arrayResult.length, compare.length);
        for( int i=0; i<compare.length; i++)
        {
            assertEquals( arrayResult[i], compare[i]);
        }

        // array w/ unparsable element
        parser.add("array2", "1");
        parser.add("array2", "a");
        parser.add("array2", "3");
        double arrayResult2[] = parser.getDoubles("array2");
        double compare2[] = {1,0,3};
        assertEquals(arrayResult2.length, compare2.length);
        for( int i=0; i<compare2.length; i++)
        {
            assertEquals( arrayResult2[i], compare2[i]);
        }
    }
    @Test
    public void testGetDoubleObject()
    {
        // no param
        Double result = parser.getDoubleObject("invalid");
        assertNull(result);

        // default
        result = parser.getDoubleObject("default", new Double(3));
        assertEquals( new Double(3), result);

        // param exists
        parser.add("exists", "1");
        result = parser.getDoubleObject("exists");
        assertEquals( new Double(1), result);

        // unparsable value
        parser.add("unparsable", "a");
        result = parser.getDoubleObject("unparsable");
        assertNull(result);

        // array
        parser.add("array", "1");
        parser.add("array", "2");
        parser.add("array", "3");
        Double arrayResult[] = parser.getDoubleObjects("array");
        Double compare[] = {new Double(1), new Double(2), new Double(3)};
        assertEquals(arrayResult.length, compare.length);
        for( int i=0; i<compare.length; i++)
        {
            assertEquals( arrayResult[i], compare[i]);
        }

        // array w/ unparsable element
        parser.add("array2", "1");
        parser.add("array2", "a");
        parser.add("array2", "3");
        Double arrayResult2[] = parser.getDoubleObjects("array2");
        Double compare2[] = {new Double(1), null, new Double(3)};
        assertEquals(arrayResult2.length, compare2.length);
        for( int i=0; i<compare2.length; i++)
        {
            assertEquals( arrayResult2[i], compare2[i] );
        }
    }
    @Test
    public void testGetLong()
    {
        // no param
        long result = parser.getLong("invalid");
        assertEquals(0, result);

        // default
        result = parser.getLong("default", 3);
        assertEquals(3, result);

        // param exists
        parser.add("exists", "1");
        result = parser.getLong("exists");
        assertEquals(1, result);

        // unparsable value
        parser.add("unparsable", "a");
        result = parser.getLong("unparsable");
        assertEquals(0, result);

        // array
        parser.add("array", "1");
        parser.add("array", "2");
        parser.add("array", "3");
        long arrayResult[] = parser.getLongs("array");
        long compare[] = {1,2,3};
        assertEquals(arrayResult.length, compare.length);
        for( int i=0; i<compare.length; i++)
        {
            assertEquals(compare[i], arrayResult[i]);
        }

        // array w/ unparsable element
        parser.add("array2", "1");
        parser.add("array2", "a");
        parser.add("array2", "3");
        long arrayResult2[] = parser.getLongs("array2");
        long compare2[] = {1,0,3};
        assertEquals(arrayResult2.length, compare2.length);
        for( int i=0; i<compare2.length; i++)
        {
            assertEquals( arrayResult2[i], compare2[i]);
        }
    }
    @Test
    public void testGetLongObject()
    {
        // no param
        Long result = parser.getLongObject("invalid");
        assertNull(result);

        // default
        result = parser.getLongObject("default", new Long(3));
        assertEquals(result, new Long(3));

        // param exists
        parser.add("exists", "1");
        result = parser.getLongObject("exists");
        assertEquals(result, new Long(1));

        // unparsable value
        parser.add("unparsable", "a");
        result = parser.getLongObject("unparsable");
        assertNull(result);

        // array
        parser.add("array", "1");
        parser.add("array", "2");
        parser.add("array", "3");
        Long arrayResult[] = parser.getLongObjects("array");
        Long compare[] = {new Long(1), new Long(2), new Long(3)};
        assertEquals(arrayResult.length, compare.length);
        for( int i=0; i<compare.length; i++)
        {
            assertEquals(compare[i], arrayResult[i]);
        }

        // array w/ unparsable element
        parser.add("array2", "1");
        parser.add("array2", "a");
        parser.add("array2", "3");
        Long arrayResult2[] = parser.getLongObjects("array2");
        Long compare2[] = {new Long(1), null, new Long(3)};
        assertEquals(arrayResult2.length, compare2.length);
        for( int i=0; i<compare2.length; i++)
        {
            assertEquals(compare2[i], arrayResult2[i] );
        }
    }
    @Test
    public void testGetBoolean()
    {
        // no param
        boolean result = parser.getBoolean("invalid");
        assertEquals(result, false);

        // default
        result = parser.getBoolean("default", true);
        assertEquals(result, true);

        // true values - Case is intentional
        parser.add("true1", "trUe");
        result = parser.getBoolean("true1");
        assertEquals(result, true);
        parser.add("true2", "yEs");
        result = parser.getBoolean("true2");
        assertEquals(result, true);
        parser.add("true3", "1");
        result = parser.getBoolean("true3");
        assertEquals(result, true);
        parser.add("true4", "oN");
        result = parser.getBoolean("true4");
        assertEquals(result, true);

        // unparsable value
        parser.add("unparsable", "a");
        result = parser.getBoolean("unparsable");
        assertEquals(result, false);

    }
    @Test
    public void testGetBooleanObject()
    {
        // no param
        Boolean result = parser.getBooleanObject("invalid");
        assertNull(result);

        // default
        result = parser.getBooleanObject("default", Boolean.TRUE);
        assertEquals(result, Boolean.TRUE);

        // true values - Case is intentional
        parser.add("true1", "trUe");
        result = parser.getBooleanObject("true1");
        assertEquals(result, Boolean.TRUE);
        parser.add("true2", "yEs");
        result = parser.getBooleanObject("true2");
        assertEquals(result, Boolean.TRUE);
        parser.add("true3", "1");
        result = parser.getBooleanObject("true3");
        assertEquals(result, Boolean.TRUE);
        parser.add("true4", "oN");
        result = parser.getBooleanObject("true4");
        assertEquals(result, Boolean.TRUE);

        // false values - Case is intentional
        parser.add("false1", "falSe");
        result = parser.getBooleanObject("false1");
        assertEquals(result, Boolean.FALSE);
        parser.add("false2", "nO");
        result = parser.getBooleanObject("false2");
        assertEquals(result, Boolean.FALSE);
        parser.add("false3", "0");
        result = parser.getBooleanObject("false3");
        assertEquals(result, Boolean.FALSE);
        parser.add("false4", "oFf");
        result = parser.getBooleanObject("false4");
        assertEquals(result, Boolean.FALSE);


        // unparsable value
        parser.add("unparsable", "a");
        result = parser.getBooleanObject("unparsable");
        assertNull(result);
    }
    @Test
    public void testGetBigDecimal()
    {
        // no param
        BigDecimal result = parser.getBigDecimal("invalid");
        assertNull(result); // object returns NOT new BigDecimal(0)

        // default
        result = parser.getBigDecimal("default", new BigDecimal(3));
        assertEquals(result, new BigDecimal(3));

        // param exists
        parser.add("exists", "1");
        result = parser.getBigDecimal("exists");
        assertEquals(result, new BigDecimal(1));

        // unparsable value
        parser.add("unparsable", "a");
        result = parser.getBigDecimal("unparsable");
        assertNull(result); //assertEquals(new BigDecimal(0), result);

        // array
        parser.add("array", "1");
        parser.add("array", "2");
        parser.add("array", "3");
        BigDecimal arrayResult[] = parser.getBigDecimals("array");
        BigDecimal compare[] = {new BigDecimal(1), new BigDecimal(2),
                                new BigDecimal(3)};
        assertEquals(arrayResult.length, compare.length);
        for( int i=0; i<compare.length; i++)
        {
            assertEquals(compare[i], arrayResult[i]);
        }

        // array w/ unparsable element
        parser.add("array2", "1");
        parser.add("array2", "a");
        parser.add("array2", "3");
        BigDecimal arrayResult2[] = parser.getBigDecimals("array2");
        BigDecimal compare2[] = {new BigDecimal(1), null, new BigDecimal(3)};
        assertEquals(arrayResult2.length, compare2.length);
        for( int i=0; i<compare2.length; i++)
        {
            assertEquals(compare2[i], arrayResult2[i] );
        }
    }

    @Test
    public void testGetString()
    {
        // no param
        String result = parser.getString("invalid");
        assertNull(result);

        // default
        result = parser.getString("default", "default");
        assertEquals(result, "default");

        // null value
        parser.add("null", (String) null);
        assertNull( parser.getString("null"));

        // only return the first added
        parser.add("multiple", "test");
        parser.add("multiple", "test2");
        assertEquals("test", parser.getString("multiple"));

        // array
        parser.add("array", "line1");
        parser.add("array", "line2");
        parser.add("array", "line3");
        String arrayResult[] = parser.getStrings("array");
        String compare[] = {"line1","line2","line3"};
        assertEquals(arrayResult.length, compare.length);
        for( int i=0; i<compare.length; i++)
        {
            assertEquals(compare[i], arrayResult[i]);
        }

    }
    @Test
    public void testRecycling() throws Exception {
    		parser.setCharacterEncoding("fake");
    		parser.recycle();
    		assertEquals("US-ASCII",parser.getCharacterEncoding());
    }

    @Test
    public void testSetup()
    {
        try
        {
            BaseValueParser vp = parserService.getParser(BaseValueParser.class);
            assertFalse(vp.isDisposed());
            parserService.putParser(vp);
        }
        catch (InstantiationException e)
        {
            assertTrue(false, "Could not instantiate ValueParser object");
        }

        // TODO expose PARAMETER_ENCODING_DEFAULT

//        assertEquals( TurbineConstants.PARAMETER_ENCODING_DEFAULT, vp.getCharacterEncoding(),"Wrong Character Encoding");
    }

    /**
     * TODO expose the PARAMETER_ENCODING_DEFAULT INSIDE THE VALUEPARSER
     *
     */
//    public void testChangeEncoding()
//    {
//        ValueParser vp = new BaseValueParser();
//
//        assertEquals( TurbineConstants.PARAMETER_ENCODING_DEFAULT, vp.getCharacterEncoding(),"Wrong Character Encoding");
//
//        String encoding = "ISO-8859-2";
//        vp.setCharacterEncoding(encoding);
//
//        assertEquals( encoding, vp.getCharacterEncoding(),"Wrong Character Encoding");
//    }
    @Test
    public void testClear()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(), "Wrong number of keys");

        parser.add("foo", "bar");

        assertEquals( 1, parser.keySet().size(), "Wrong number of keys");

        parser.clear();

        assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
    }

    @Test
    public void testDispose()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(), "Wrong number of keys");

        parser.add("foo", "bar");

        assertEquals( 1, parser.keySet().size(), "Wrong number of keys");

        parser.dispose();

        assertEquals( 0, parser.keySet().size(), "Wrong number of keys");

        assertTrue(parser.isDisposed());
    }
    @Test
    public void testKeyArray()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(), "Wrong number of keys");

        parser.add("bar", "foo");

        assertEquals( 1, parser.keySet().size(), "Wrong number of keys");

        parser.add("bar", "baz");

        assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
    }

    public void testDoubleAdd()
    {
        parser.clear();
        parser.setLocale(Locale.US);

        assertEquals( 0, parser.keySet().size(), "Wrong number of keys");

        double testValue = 2.2;

        parser.add("foo", testValue);

        assertEquals( 1, parser.keySet().size(), "Wrong number of keys");

        assertEquals( "2.2", parser.getString("foo"), "Wrong string value");
        assertEquals( testValue, parser.getDouble("foo"), 0.001, "Wrong double value");
        assertEquals( testValue, parser.getDoubleObject("foo").doubleValue(), 0.001, "Wrong Double value");

        double [] doubles = parser.getDoubles("foo");
        assertEquals( 1, doubles.length,"Wrong Array Size");

        assertEquals( testValue, doubles[0], 0.001,"Wrong double array value");

        Double [] doubleObjs = parser.getDoubleObjects("foo");
        assertEquals( 1, doubleObjs.length,"Wrong Array Size");

        assertEquals( testValue, doubleObjs[0].doubleValue(), 0.001,"Wrong Double array value");

        parser.clear();
        parser.setLocale(Locale.GERMANY);

        String testDouble = "2,3";
        parser.add("foo", testDouble);
        assertEquals( 2.3, parser.getDouble("foo"), 0.001,"Wrong double value");

        parser.add("unparsable2", "1a");
        Double result = parser.getDoubleObject("unparsable2");
        assertNull(result, "Double object should be null");
    }
    @Test
    public void testIntAdd()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        int testValue = 123;

        parser.add("foo", testValue);

        assertEquals( 1, parser.keySet().size(),"Wrong number of keys");

        assertEquals( "123", parser.getString("foo"),"Wrong string value");
        assertEquals( testValue, parser.getInt("foo"),"Wrong int value");
        assertEquals( testValue, parser.getIntObject("foo").intValue(),"Wrong Int value");

        int [] ints = parser.getInts("foo");
        assertEquals( 1, ints.length,"Wrong Array Size");

        assertEquals( testValue, ints[0],"Wrong int array value");

        Integer [] intObjs = parser.getIntObjects("foo");
        assertEquals( 1, intObjs.length,"Wrong Array Size");

        assertEquals( testValue, intObjs[0].intValue(),"Wrong Int array value");
    }
    @Test
    public void testIntegerAdd()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        Integer testValue = new Integer(123);

        parser.add("foo", testValue);

        assertEquals( 1, parser.keySet().size(),"Wrong number of keys");

        assertEquals( "123", parser.getString("foo"),"Wrong string value");
        assertEquals( testValue.intValue(), parser.getInt("foo"),"Wrong int value");
        assertEquals( testValue.intValue(), parser.getIntObject("foo").intValue(),"Wrong Int value");

        int [] ints = parser.getInts("foo");
        assertEquals( 1, ints.length,"Wrong Array Size");

        assertEquals( testValue.intValue(), ints[0],"Wrong int array value");

        Integer [] intObjs = parser.getIntObjects("foo");
        assertEquals( 1, intObjs.length,"Wrong Array Size");

        assertEquals( testValue.intValue(), intObjs[0].intValue(),"Wrong Int array value");
    }
    @Test
    public void testLongAdd()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        long testValue = 9223372036854775807l;

        parser.add("foo", testValue);

        assertEquals( 1, parser.keySet().size(),"Wrong number of keys");

        assertEquals( "9223372036854775807", parser.getString("foo"),"Wrong string value");
        assertEquals( testValue, parser.getLong("foo"),"Wrong long value");
        assertEquals( testValue, parser.getLongObject("foo").longValue(),"Wrong Long value");

        long [] longs = parser.getLongs("foo");
        assertEquals( 1, longs.length,"Wrong Array Size");

        assertEquals( testValue, longs[0],"Wrong long array value");

        Long [] longObjs = parser.getLongObjects("foo");
        assertEquals( 1, longObjs.length,"Wrong Array Size");

        assertEquals( testValue, longObjs[0].longValue(),"Wrong Long array value");
    }
    @Test
    public void testLongToInt()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        long testValue = 1234l;

        parser.add("foo", testValue);

        assertEquals( 1, parser.keySet().size(),"Wrong number of keys");

        assertEquals( "1234", parser.getString("foo"),"Wrong string value");
        assertEquals( (int) testValue, parser.getInt("foo"),"Wrong int value");
        assertEquals( (int) testValue, parser.getIntObject("foo").intValue(),"Wrong Int value");

        int [] ints = parser.getInts("foo");
        assertEquals( 1, ints.length,"Wrong Array Size");

        assertEquals( testValue, ints[0],"Wrong int array value");

        Integer [] intObjs = parser.getIntObjects("foo");
        assertEquals( 1, intObjs.length,"Wrong Array Size");

        assertEquals( testValue, intObjs[0].intValue(),"Wrong Int array value");
    }

    public void testIntToLong()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        int testValue = 123;

        parser.add("foo", testValue);

        assertEquals( 1, parser.keySet().size(),"Wrong number of keys");

        assertEquals( "123", parser.getString("foo"),"Wrong string value");
        assertEquals( testValue, parser.getLong("foo"),"Wrong long value");
        assertEquals( testValue, parser.getLongObject("foo").longValue(),"Wrong Long value");

        long [] longs = parser.getLongs("foo");
        assertEquals( 1, longs.length,"Wrong Array Size");

        assertEquals( testValue, longs[0],"Wrong long array value");

        Long [] longObjs = parser.getLongObjects("foo");
        assertEquals( 1, longObjs.length,"Wrong Array Size");

        assertEquals( testValue, longObjs[0].longValue(),"Wrong Long array value");
    }
    @Test
    public void testIntToDouble()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        int testValue = 123;

        parser.add("foo", testValue);

        assertEquals( 1, parser.keySet().size(),"Wrong number of keys");

        assertEquals( "123", parser.getString("foo"),"Wrong string value");
        assertEquals( testValue, parser.getDouble("foo"), 0.001,"Wrong double value");
        assertEquals( testValue, parser.getDoubleObject("foo").doubleValue(), 0.001,"Wrong Double value");

        double [] doubles = parser.getDoubles("foo");
        assertEquals( 1, doubles.length,"Wrong Array Size");

        assertEquals( testValue, doubles[0], 0.001,"Wrong double array value");

        Double [] doubleObjs = parser.getDoubleObjects("foo");
        assertEquals( 1, doubleObjs.length,"Wrong Array Size");

        assertEquals( testValue, doubleObjs[0].doubleValue(), 0.001,"Wrong Double array value");
    }
    @Test
    public void testLongToDouble()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        long testValue = 9223372036854775807l;

        parser.add("foo", testValue);

        assertEquals( 1, parser.keySet().size(),"Wrong number of keys");

        assertEquals( "9223372036854775807", parser.getString("foo"),"Wrong string value");
        assertEquals( testValue, parser.getDouble("foo"), 0.001,"Wrong double value");
        assertEquals( testValue, parser.getDoubleObject("foo").doubleValue(), 0.001,"Wrong Double value");

        double [] doubles = parser.getDoubles("foo");
        assertEquals( 1, doubles.length,"Wrong Array Size");

        assertEquals( testValue, doubles[0], 0.001,"Wrong double array value");

        Double [] doubleObjs = parser.getDoubleObjects("foo");
        assertEquals( 1, doubleObjs.length,"Wrong Array Size");

        assertEquals( testValue, doubleObjs[0].doubleValue(), 0.001,"Wrong Double array value");
    }

    public void testStringAdd()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        String testValue = "the quick brown fox";

        parser.add("foo", testValue);

        assertEquals( 1, parser.keySet().size(),"Wrong number of keys");

        assertEquals( testValue, parser.getString("foo"),"Wrong string value");

        String [] Strings = parser.getStrings("foo");
        assertEquals( 1, Strings.length,"Wrong Array Size");

        assertEquals( testValue, Strings[0],"Wrong String array value");
    }

    public void testStringToInt()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        String testValue = "123456";

        parser.add("foo", testValue);

        assertEquals( 1, parser.keySet().size(),"Wrong number of keys");

        assertEquals( testValue, parser.getString("foo"),"Wrong string value");

        assertEquals( Integer.parseInt(testValue), parser.getInt("foo"),"Wrong int value");
        assertEquals( Integer.valueOf(testValue).intValue(), parser.getIntObject("foo").intValue(),"Wrong Int value");

        int [] ints = parser.getInts("foo");
        assertEquals( 1, ints.length,"Wrong Array Size");

        assertEquals( Integer.parseInt(testValue), ints[0],"Wrong int array value");

        Integer [] intObjs = parser.getIntObjects("foo");
        assertEquals( 1, intObjs.length,"Wrong Array Size");

        assertEquals( Integer.valueOf(testValue).intValue(), intObjs[0].intValue(),"Wrong Int array value");
    }

    public void testStringToLong()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        String testValue = "123456";

        parser.add("foo", testValue);

        assertEquals( 1, parser.keySet().size(),"Wrong number of keys");

        assertEquals( testValue, parser.getString("foo"),"Wrong string value");

        assertEquals( Long.parseLong(testValue), parser.getLong("foo"),"Wrong long value");
        assertEquals( Long.valueOf(testValue).longValue(), parser.getLongObject("foo").longValue(),"Wrong Long value");

        long [] longs = parser.getLongs("foo");
        assertEquals( 1, longs.length,"Wrong Array Size");

        assertEquals( Long.parseLong(testValue), longs[0],"Wrong long array value");

        Long [] longObjs = parser.getLongObjects("foo");
        assertEquals( 1, longObjs.length,"Wrong Array Size");

        assertEquals( Long.valueOf(testValue).longValue(), longObjs[0].longValue(),"Wrong Long array value");
    }
    @Test
    public void testStringArray()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        String [] testValue = new String [] {
            "foo", "bar", "baz"
        };

        parser.add("foo", testValue);

        assertEquals( 1, parser.keySet().size(),"Wrong number of keys");

        String [] res = parser.getStrings("foo");

        assertEquals( 3, res.length,"Wrong number of elements");

        for (int i = 0; i < res.length; i++)
        {
            assertEquals( res[i], testValue[i],"Wrong value");
        }

        assertEquals( testValue[0], parser.getString("foo"),"Wrong element returned");

        parser.add("foo", "xxx");

        res = parser.getStrings("foo");

        assertEquals( 4, res.length,"Wrong number of elements");

        for (int i = 0; i < 3; i++)
        {
            assertEquals( res[i], testValue[i],"Wrong value");
        }

        assertEquals(res[3], "xxx");

        // should append at the end.
        assertEquals( testValue[0], parser.getString("foo"),"Wrong element returned");
    }
    @Test
    public void testRemove()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        String testValue = "the quick brown fox";

        parser.add("foo", testValue);

        assertEquals( 1, parser.keySet().size(),"Wrong number of keys");

        assertEquals( testValue, parser.getString("foo"),"Wrong string value");

        assertNotNull(parser.remove("foo"));

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        assertNull(parser.getString("foo"));

        // Test non-existing key
        assertNull(parser.remove("baz"));

        // Test removing null value
        assertNull(parser.remove(null));
    }
    @Test
    public void testRemoveArray()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        String testValue = "the quick brown fox";

        parser.add("foo", testValue);

        assertEquals( 1, parser.keySet().size(),"Wrong number of keys");

        parser.add("foo", testValue);

        assertEquals( 1, parser.keySet().size(),"Wrong number of keys");

        assertEquals( testValue, parser.getString("foo"),"Wrong string value");

        String [] res = parser.getStrings("foo");

        assertEquals( 2, res.length,"Wrong number of elements");

        for (int i = 0; i < res.length; i++)
        {
            assertEquals( res[i], testValue,"Wrong value");
        }

        parser.remove("foo");

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        assertNull(parser.getString("foo"));
    }
    @Test
    public void testContainsKey()
    {
        parser.clear();

        parser.add("foo", "bar");
        parser.add("bar", new String [] { "foo", "bar" });

        assertTrue(parser.containsKey("foo"));
        assertTrue(parser.containsKey("bar"));
        assertFalse(parser.containsKey("baz"));
    }
    @Test
    public void testBooleanObject()
    {
        parser.clear();

        parser.add("t1", "true");
        parser.add("t2", "yes");
        parser.add("t3", "on");
        parser.add("t4", "1");
        parser.add("t5", 1);

        parser.add("f1", "false");
        parser.add("f2", "no");
        parser.add("f3", "off");
        parser.add("f4", "0");
        parser.add("f5", 0);

        parser.add("e1", "nix");
        parser.add("e2", "weg");
        parser.add("e3", 200);
        parser.add("e4", -2.5);

        assertEquals( Boolean.TRUE, parser.getBooleanObject("t1"),"Value is not true");
        assertEquals( Boolean.TRUE, parser.getBooleanObject("t2"),"Value is not true");
        assertEquals( Boolean.TRUE, parser.getBooleanObject("t3"),"Value is not true");
        assertEquals( Boolean.TRUE, parser.getBooleanObject("t4"),"Value is not true");
        assertEquals( Boolean.TRUE, parser.getBooleanObject("t5"),"Value is not true");

        assertEquals( Boolean.FALSE, parser.getBooleanObject("f1"),"Value is not false");
        assertEquals( Boolean.FALSE, parser.getBooleanObject("f2"),"Value is not false");
        assertEquals( Boolean.FALSE, parser.getBooleanObject("f3"),"Value is not false");
        assertEquals( Boolean.FALSE, parser.getBooleanObject("f4"),"Value is not false");
        assertEquals( Boolean.FALSE, parser.getBooleanObject("f5"),"Value is not false");

        assertNull(parser.getBooleanObject("e1"));
        assertNull(parser.getBooleanObject("e2"));
        assertNull(parser.getBooleanObject("e3"));
        assertNull(parser.getBooleanObject("e4"));

        assertNull(parser.getBooleanObject("does-not-exist"));
    }
    @Test
    public void testBoolDefault()
    {
        parser.clear();

        parser.add("t1", "true");
        parser.add("f1", "false");

        assertTrue(parser.getBoolean("t1"));
        assertFalse(parser.getBoolean("f1"));

        assertFalse(parser.getBoolean("does not exist"));

        assertTrue(parser.getBoolean("t1", false));
        assertFalse(parser.getBoolean("f1", true));

        assertFalse(parser.getBoolean("does not exist", false));
        assertTrue(parser.getBoolean("does not exist", true));
    }
    @Test
    public void testBooleanDefault()
    {
        parser.clear();

        parser.add("t1", "true");
        parser.add("f1", "false");

        assertEquals(  Boolean.TRUE, parser.getBooleanObject("t1"),"Value is not true");
        assertEquals( Boolean.FALSE, parser.getBooleanObject("f1"),"Value is not false");

        assertNull(parser.getBooleanObject("does not exist"));

        assertEquals(  Boolean.TRUE, parser.getBooleanObject("t1", Boolean.FALSE),"Value is not true");
        assertEquals(  Boolean.TRUE, parser.getBooleanObject("t1", null),"Value is not true");
        assertEquals( Boolean.FALSE, parser.getBooleanObject("f1", Boolean.TRUE),"Value is not false");
        assertEquals( Boolean.FALSE, parser.getBooleanObject("f1", null),"Value is not false");

        assertNull(parser.getBooleanObject("does not exist", null));
    }
    @Test
    public void testDoubleArray()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        double [] testValue = {
            1.0, 2.0, 3.0
        };

        for (int i = 0; i < testValue.length; i++)
        {
            parser.add("foo", testValue[i]);

            String [] res = parser.getStrings("foo");
            assertEquals( res.length, i + 1,"Wrong number of elements");
        }

        assertEquals( 1, parser.keySet().size(),"Wrong number of keys");

        double [] res = parser.getDoubles("foo");

        assertEquals( 3, res.length,"Wrong number of elements");

        for (int i = 0; i < res.length; i++)
        {
            assertEquals( res[i], testValue[i], 0.001,"Wrong value");
        }

        Double [] resObj = parser.getDoubleObjects("foo");

        assertEquals( 3, resObj.length,"Wrong number of elements");

        for (int i = 0; i < resObj.length; i++)
        {
            assertEquals( resObj[i].doubleValue(), testValue[i], 0.001,"Wrong value");
        }

        assertEquals( testValue[0], parser.getDoubleObject("foo").doubleValue(), 0.001,"Wrong element returned");

        parser.add("foo", 4.0);

        res = parser.getDoubles("foo");

        assertEquals( 4, res.length,"Wrong number of elements");

        for (int i = 0; i < 3; i++)
        {
            assertEquals( res[i], testValue[i], 0.001,"Wrong value");
        }

        assertEquals(res[3], 4.0, 0.001);

        resObj = parser.getDoubleObjects("foo");

        assertEquals( 4, resObj.length,"Wrong number of elements");

        for (int i = 0; i < 3; i++)
        {
            assertEquals( resObj[i].doubleValue(), testValue[i], 0.001,"Wrong value");
        }

        assertEquals(resObj[3].doubleValue(), 4.0, 0.001);

        // should append at the end.
        assertEquals( testValue[0], parser.getDouble("foo"), 0.001,"Wrong element returned");
    }
    @Test
    public void testFloatArray()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        float [] testValue = {
            1.0f, 2.0f, 3.0f
        };

        for (int i = 0; i < testValue.length; i++)
        {
            parser.add("foo", testValue[i]);

            String [] res = parser.getStrings("foo");
            assertEquals( res.length, i + 1,"Wrong number of elements");
        }

        assertEquals( 1, parser.keySet().size(),"Wrong number of keys");

        float [] res = parser.getFloats("foo");

        assertEquals( 3, res.length,"Wrong number of elements");

        for (int i = 0; i < res.length; i++)
        {
            assertEquals( res[i], testValue[i], 0.001f,"Wrong value");
        }

        Float [] resObj = parser.getFloatObjects("foo");

        assertEquals( 3, resObj.length,"Wrong number of elements");

        for (int i = 0; i < resObj.length; i++)
        {
            assertEquals( resObj[i].floatValue(), testValue[i], 0.001f,"Wrong value");
        }

        assertEquals( testValue[0], parser.getFloatObject("foo").floatValue(), 0.001f,"Wrong element returned");

        parser.add("foo", 4.0f);

        res = parser.getFloats("foo");

        assertEquals( 4, res.length,"Wrong number of elements");

        for (int i = 0; i < 3; i++)
        {
            assertEquals( res[i], testValue[i], 0.001f,"Wrong value");
        }

        assertEquals(res[3], 4.0f, 0.001f);

        resObj = parser.getFloatObjects("foo");

        assertEquals( 4, resObj.length,"Wrong number of elements");

        for (int i = 0; i < 3; i++)
        {
            assertEquals( resObj[i].floatValue(), testValue[i], 0.001f,"Wrong value");
        }

        assertEquals(resObj[3].floatValue(), 4.0f, 0.001f);

        // should append at the end.
        assertEquals( testValue[0], parser.getFloat("foo"), 0.001f,"Wrong element returned");
    }
    @Test
    public void testBigDecimalArray()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        long [] testValue = {
            12345678,87654321,1092837465,
        };

        for (int i = 0; i < testValue.length; i++)
        {
            parser.add("foo", testValue[i]);

            String [] res = parser.getStrings("foo");
            assertEquals( res.length, i + 1,"Wrong number of elements");
        }

        assertEquals( 1, parser.keySet().size(),"Wrong number of keys");

        BigDecimal [] res = parser.getBigDecimals("foo");

        assertEquals( 3, res.length,"Wrong number of elements");

        for (int i = 0; i < res.length; i++)
        {
            assertEquals( res[i].longValue(), testValue[i],"Wrong value");
        }

        assertEquals( testValue[0], parser.getBigDecimal("foo").longValue(),"Wrong element returned");

        parser.add("foo", 77777777);

        res = parser.getBigDecimals("foo");

        assertEquals( 4, res.length,"Wrong number of elements");

        for (int i = 0; i < 3; i++)
        {
            assertEquals( res[i].longValue(), testValue[i], 0.001,"Wrong value");
        }

        assertEquals(res[3].longValue(), 77777777);

        // should append at the end.
        assertEquals( testValue[0], parser.getBigDecimal("foo").longValue(),"Wrong element returned");
    }
    @Test
    public void testIntegerArray()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        int [] testValue = {
            1, 2, 3
        };

        for (int i = 0; i < testValue.length; i++)
        {
            parser.add("foo", testValue[i]);

            String [] res = parser.getStrings("foo");
            assertEquals( res.length, i + 1,"Wrong number of elements");
        }

        assertEquals( 1, parser.keySet().size(),"Wrong number of keys");

        int [] res = parser.getInts("foo");

        assertEquals( 3, res.length,"Wrong number of elements");

        for (int i = 0; i < res.length; i++)
        {
            assertEquals( res[i], testValue[i],"Wrong value");
        }

        Integer [] resObj = parser.getIntObjects("foo");

        assertEquals( 3, resObj.length,"Wrong number of elements");

        for (int i = 0; i < resObj.length; i++)
        {
            assertEquals( resObj[i].intValue(), testValue[i],"Wrong value");
        }

        assertEquals( testValue[0], parser.getIntObject("foo").intValue(),"Wrong element returned");

        parser.add("foo", 4);

        res = parser.getInts("foo");

        assertEquals( 4, res.length,"Wrong number of elements");

        for (int i = 0; i < 3; i++)
        {
            assertEquals( res[i], testValue[i],"Wrong value");
        }

        assertEquals(res[3], 4);

        resObj = parser.getIntObjects("foo");

        assertEquals( 4, resObj.length,"Wrong number of elements");

        for (int i = 0; i < 3; i++)
        {
            assertEquals( resObj[i].intValue(), testValue[i],"Wrong value");
        }

        assertEquals(resObj[3].intValue(), 4);

        // should append at the end.
        assertEquals( testValue[0], parser.getInt("foo"),"Wrong element returned");
    }
    @Test
    public void testLongArray()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        long [] testValue = {
            1l, 2l, 3l
        };

        for (int i = 0; i < testValue.length; i++)
        {
            parser.add("foo", testValue[i]);

            String [] res = parser.getStrings("foo");
            assertEquals( res.length, i + 1,"Wrong number of elements");
        }

        assertEquals( 1, parser.keySet().size(),"Wrong number of keys");

        long [] res = parser.getLongs("foo");

        assertEquals( 3, res.length,"Wrong number of elements");

        for (int i = 0; i < res.length; i++)
        {
            assertEquals( res[i], testValue[i],"Wrong value");
        }

        Long [] resObj = parser.getLongObjects("foo");

        assertEquals( 3, resObj.length,"Wrong number of elements");

        for (int i = 0; i < resObj.length; i++)
        {
            assertEquals( resObj[i].longValue(), testValue[i],"Wrong value");
        }

        assertEquals( testValue[0], parser.getLongObject("foo").longValue(),"Wrong element returned");

        parser.add("foo", 4);

        res = parser.getLongs("foo");

        assertEquals( 4, res.length,"Wrong number of elements");

        for (int i = 0; i < 3; i++)
        {
            assertEquals( res[i], testValue[i],"Wrong value");
        }

        assertEquals(res[3], 4);

        resObj = parser.getLongObjects("foo");

        assertEquals( 4, resObj.length,"Wrong number of elements");

        for (int i = 0; i < 3; i++)
        {
            assertEquals( resObj[i].longValue(), testValue[i],"Wrong value");
        }

        assertEquals(resObj[3].longValue(), 4);

        // should append at the end.
        assertEquals( testValue[0], parser.getLong("foo"),"Wrong element returned");
    }
    @Test
    public void testByteArray()
            throws Exception
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        String  testValue = "abcdefg";

        parser.add("foo", testValue);

        assertEquals( 1, parser.keySet().size(),"Wrong number of keys");

        byte [] res = parser.getBytes("foo");

        assertEquals( 7, res.length,"Wrong number of elements");

        for (int i = 0; i < res.length; i++)
        {
            byte [] testByte = testValue.substring(i, i + 1).getBytes(parser.getCharacterEncoding());
            assertEquals( 1, testByte.length,"More than one byte for a char!");
            assertEquals( res[i], testByte[0],"Wrong value");
        }
    }
    @Test
    public void testByte()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        String [] testValue = {
            "0", "127", "-1",
            "0", "-127", "100"
        };


        for (int i = 0; i < testValue.length; i++)
        {
            parser.add("foo" + i, testValue[i]);
        }

        assertEquals( 6, parser.keySet().size(),"Wrong number of keys");

        assertEquals( (byte) 0,    parser.getByte("foo0"),"Wrong value");
        assertEquals( (byte) 127,  parser.getByte("foo1"),"Wrong value");
        assertEquals( (byte) -1,   parser.getByte("foo2"),"Wrong value");
        assertEquals( (byte) 0,    parser.getByte("foo3"),"Wrong value");
        assertEquals( (byte) -127, parser.getByte("foo4"),"Wrong value");
        assertEquals( (byte) 100,  parser.getByte("foo5"),"Wrong value");

        assertEquals( new Byte((byte) 0),    parser.getByteObject("foo0"),"Wrong value");
        assertEquals( new Byte((byte) 127),  parser.getByteObject("foo1"),"Wrong value");
        assertEquals( new Byte((byte) -1),   parser.getByteObject("foo2"),"Wrong value");
        assertEquals( new Byte((byte) 0),    parser.getByteObject("foo3"),"Wrong value");
        assertEquals( new Byte((byte) -127), parser.getByteObject("foo4"),"Wrong value");
        assertEquals( new Byte((byte) 100),  parser.getByteObject("foo5"),"Wrong value");

    }
    @Test
    public void testStringDefault()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(),"Wrong number of keys");

        parser.add("foo", "bar");

        assertEquals( "bar", parser.getString("foo", "xxx"),"Wrong value found");
        assertEquals( "bar", parser.getString("foo", null),"Wrong value found");

        assertEquals( "baz", parser.getString("does-not-exist", "baz"),"Wrong value found");
        assertNull(parser.getString("does-not-exist", null));
    }
    @Test
    public void testSetString()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(), "Wrong number of keys");

        parser.add("foo", "bar");

        assertEquals( 1, parser.keySet().size(), "Wrong number of keys");

        parser.add("bar", "foo");

        assertEquals( 2, parser.keySet().size(), "Wrong number of keys");

        parser.add("bar", "baz");

        assertEquals( 2, parser.keySet().size(), "Wrong number of keys");

        String [] res = parser.getStrings("bar");
        assertEquals( 2, res.length, "Wrong number of values");
        assertEquals( "foo", res[0], "Wrong value found");
        assertEquals( "baz", res[1], "Wrong value found");

        parser.setString("bar", "xxx");

        assertEquals( 2, parser.keySet().size(), "Wrong number of keys");

        res = parser.getStrings("bar");
        assertEquals( 1, res.length, "Wrong number of values");
        assertEquals( "xxx", res[0], "Wrong value found");
    }
    @Test
    public void testSetStrings()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(), "Wrong number of keys");

        parser.add("foo", "bar");

        assertEquals( 1, parser.keySet().size(), "Wrong number of keys");

        parser.add("bar", "foo");

        assertEquals( 2, parser.keySet().size(), "Wrong number of keys");

        parser.add("bar", "baz");

        assertEquals( 2, parser.keySet().size(), "Wrong number of keys");

        String [] res = parser.getStrings("bar");
        assertEquals( 2, res.length, "Wrong number of values");
        assertEquals( "foo", res[0], "Wrong value found");
        assertEquals( "baz", res[1], "Wrong value found");

        String [] newValues = new String [] { "aaa", "bbb", "ccc", "ddd" };

        parser.setStrings("bar", newValues);

        assertEquals( 2, parser.keySet().size(),"Wrong number of keys");

        res = parser.getStrings("bar");
        assertEquals( newValues.length, res.length,"Wrong number of values");

        for (int i = 0 ; i < newValues.length; i++)
        {
            assertEquals( newValues[i], res[i],"Wrong value found");
        }
    }
    @Test
    public void testSetProperties()
            throws Exception
    {
        parser.clear();

        parser.add("longValue", 12345l);
        parser.add("doubleValue", 2.0);
        parser.add("intValue", 200);
        parser.add("stringValue", "foobar");
        parser.add("booleanValue", "true");

        PropertyBean bp = new PropertyBean();
        bp.setDoNotTouchValue("abcdef");

        parser.setProperties(bp);

        assertEquals( "abcdef", bp.getDoNotTouchValue(), "Wrong value in bean");
        assertEquals( "foobar", bp.getStringValue(), "Wrong value in bean");
        assertEquals( 200,      bp.getIntValue(), "Wrong value in bean");
        assertEquals( 2.0,      bp.getDoubleValue(), 0.001, "Wrong value in bean");
        assertEquals( 12345l,   bp.getLongValue(), "Wrong value in bean");
        assertEquals( Boolean.TRUE, bp.getBooleanValue(), "Wrong value in bean");
    }

    public void testAddNulls()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(), "Wrong number of keys");

        parser.add("foo", (Integer) null);

        assertEquals( 0, parser.keySet().size(), "Wrong number of keys");

        parser.add("foo", (String) null);

        assertEquals( 0, parser.keySet().size(), "Wrong number of keys");

        parser.add("bar", "null");

        assertEquals( 1, parser.keySet().size(), "Wrong number of keys");

    }
    @Test
    public void testAddNullArrays()
    {
        String [] res = null;

        parser.clear();

        assertEquals( 0, parser.keySet().size(), "Wrong number of keys");

        parser.add("foo", new String [] { "foo", "bar" });
        res = parser.getStrings("foo");
        assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
        assertEquals( 2, res.length,"Wrong number of values");

        // null value should not change contents
        parser.add("foo", (String) null);
        res = parser.getStrings("foo");
        assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
        assertEquals( 2, res.length,"Wrong number of values");

        // null value should not change contents
        parser.add("foo", (String []) null);
        res = parser.getStrings("foo");
        assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
        assertEquals( 2, res.length,"Wrong number of values");

        // empty String array should not change contents
        parser.add("foo", new String [0]);
        res = parser.getStrings("foo");
        assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
        assertEquals( 2, res.length, "Wrong number of values");

        // String array with null value should not change contents
        parser.add("foo", new String [] { null });
        res = parser.getStrings("foo");
        assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
        assertEquals( 2, res.length, "Wrong number of values");

        // String array with null value should only add non-null values
        parser.add("foo", new String [] { "bla", null, "foo" });
        res = parser.getStrings("foo");
        assertEquals( 1, parser.keySet().size(), "Wrong number of keys");
        assertEquals( 4, res.length, "Wrong number of values");
    }
    @Test
    public void testNonExistingResults()
    {
        parser.clear();

        assertEquals( 0, parser.keySet().size(), "Wrong number of keys");

        assertEquals( 0.0, parser.getDouble("foo"), 0.001, "Wrong value for non existing key");
        assertNull(parser.getDoubles("foo"));
        assertNull(parser.getDoubleObject("foo"));
        assertNull(parser.getDoubleObjects("foo"));

        assertEquals( 0, parser.keySet().size(), "Wrong number of keys");

        assertNull(parser.getString("foo"));
        assertNull(parser.getStrings("foo"));

        assertEquals( 0.0f, parser.getFloat("foo"), 0.001, "Wrong value for non existing key");
        assertNull(parser.getFloats("foo"));
        assertNull(parser.getFloatObject("foo"));
        assertNull(parser.getFloatObjects("foo"));

        assertEquals( 0, parser.keySet().size(), "Wrong number of keys");

        assertNull(parser.getBigDecimal("foo"));
        assertNull(parser.getBigDecimals("foo"));

        assertEquals( 0, parser.keySet().size(), "Wrong number of keys");

        assertEquals( 0, parser.getInt("foo"), "Wrong value for non existing key");
        assertNull(parser.getInts("foo"));
        assertNull(parser.getIntObject("foo"));
        assertNull(parser.getIntObjects("foo"));

        assertEquals( 0, parser.keySet().size(), "Wrong number of keys");

        assertEquals( 0, parser.getLong("foo"), "Wrong value for non existing key");
        assertNull(parser.getLongs("foo"));
        assertNull(parser.getLongObject("foo"));
        assertNull(parser.getLongObjects("foo"));

        assertEquals( 0, parser.keySet().size(), "Wrong number of keys");

        assertEquals( 0, parser.getByte("foo"), "Wrong value for non existing key");
        assertNull(parser.getByteObject("foo"));

        assertEquals( 0, parser.keySet().size(), "Wrong number of keys");
    }

    @Test
    public void testBooleanArray() {
        String[] booleanString = {"on", "off", "false", "true", " ", "justaword"};
        parser.add("foo", booleanString);
        boolean[] theArray = parser.getBooleans("foo");

        assertEquals(6, theArray.length);
        assertTrue(theArray[0]);
        assertFalse(theArray[1]);
        assertFalse(theArray[2]);
        assertTrue(theArray[3]);
        assertFalse(theArray[4]);
        assertFalse(theArray[5]);

        assertNull(parser.getBooleans("keydontexist"));
    }
    @Test
    public void testBooleanObjectArray() {
        String[] booleanString = {"on", "off", "false", "true", " ", "justaword"};
        parser.add("foo", booleanString);
        Boolean[] theArray = parser.getBooleanObjects("foo");

        assertEquals(6, theArray.length);
        assertEquals(Boolean.TRUE, theArray[0]);
        assertEquals(Boolean.FALSE, theArray[1]);
        assertEquals(Boolean.FALSE, theArray[2]);
        assertEquals(Boolean.TRUE, theArray[3]);
        assertEquals(null, theArray[4]);
        assertEquals(null, theArray[5]);

        assertNull(parser.getBooleanObjects("keydontexist"));
    }
    @Test
    public void testGet() {

        // no param
        String result = parser.get("invalid");
        assertNull(result);

        // null value
        parser.add("valid", "value");
        assertEquals("value", parser.get("valid"));

        // only return the first added
        parser.add("multiple", "test");
        parser.add("multiple", "test2");
        assertEquals("test", parser.get("multiple"));


    }

}