/*
 * 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.
 */
package org.apache.commons.collections.primitives;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.apache.commons.collections.BulkTest;

/**
 * @version $Revision: 480451 $ $Date: 2006-11-29 02:45:08 -0500 (Wed, 29 Nov 2006) $
 * @author Rodney Waldhoff
 */
public class TestArrayUnsignedShortList extends TestIntList {

    // conventional
    // ------------------------------------------------------------------------

    public TestArrayUnsignedShortList(String testName) {
        super(testName);
    }

    public static Test suite() {
        TestSuite suite = BulkTest.makeSuite(TestArrayUnsignedShortList.class);
        return suite;
    }

    // collections testing framework
    // ------------------------------------------------------------------------

    protected IntList makeEmptyIntList() {
        return new ArrayUnsignedShortList();
    }

    public String[] ignoredTests() {
        // sublists are not serializable
        return new String[] { 
            "TestArrayUnsignedShortList.bulkTestSubList.testFullListSerialization",
            "TestArrayUnsignedShortList.bulkTestSubList.testEmptyListSerialization",
            "TestArrayUnsignedShortList.bulkTestSubList.testCanonicalEmptyCollectionExists",
            "TestArrayUnsignedShortList.bulkTestSubList.testCanonicalFullCollectionExists",
            "TestArrayUnsignedShortList.bulkTestSubList.testEmptyListCompatibility",
            "TestArrayUnsignedShortList.bulkTestSubList.testFullListCompatibility",
            "TestArrayUnsignedShortList.bulkTestSubList.testSerializeDeserializeThenCompare",
            "TestArrayUnsignedShortList.bulkTestSubList.testSimpleSerialization"
        };
    }

    // tests
    // ------------------------------------------------------------------------

    public void testArrayConstructor() {
        int[] data = new int[] { 1, 2, 3 };
        IntList list = new ArrayUnsignedShortList(data);
        for(int i=0;i<data.length;i++) {
            assertEquals(data[i],list.get(i));
        }
        data[0] = 17;
        assertEquals(1,list.get(0));
    }
    
    // @TODO need to add serialized form to cvs
    public void testCanonicalEmptyCollectionExists() {
        // XXX FIX ME XXX
        // need to add a serialized form to cvs
    }

    public void testCanonicalFullCollectionExists() {
        // XXX FIX ME XXX
        // need to add a serialized form to cvs
    }

    public void testEmptyListCompatibility() {
        // XXX FIX ME XXX
        // need to add a serialized form to cvs
    }

    public void testFullListCompatibility() {
        // XXX FIX ME XXX
        // need to add a serialized form to cvs
    }

    public void testZeroInitialCapacityIsValid() {
        assertNotNull(new ArrayUnsignedShortList(0));
    }
    
    public void testIllegalArgumentExceptionWhenElementOutOfRange() {
        ArrayUnsignedShortList list = new ArrayUnsignedShortList();
        list.add(ArrayUnsignedShortList.MIN_VALUE);
        list.add(ArrayUnsignedShortList.MAX_VALUE);
        try {
            list.add(-1);
            fail("Expected IllegalArgumentException");
        } catch(IllegalArgumentException e) {
            // expected
        }
        try {
            list.add(ArrayUnsignedShortList.MAX_VALUE+1);
            fail("Expected IllegalArgumentException");
        } catch(IllegalArgumentException e) {
            // expected
        }
    }

    public void testNegativeInitialCapacityIsInvalid() {
        try {
            new ArrayUnsignedShortList(-1);
            fail("Expected IllegalArgumentException");
        } catch(IllegalArgumentException e) {
            // expected
        }
    }

    public void testCopyConstructor() {
        ArrayUnsignedShortList expected = new ArrayUnsignedShortList();
        for(int i=0;i<10;i++) {
            expected.add(i);
        }
        ArrayUnsignedShortList list = new ArrayUnsignedShortList(expected);
        assertEquals(10,list.size());
        assertEquals(expected,list);
    }

    public void testCopyConstructorWithNull() {
        try {
            new ArrayUnsignedShortList((IntList)null);
            fail("Expected NullPointerException");
        } catch(NullPointerException e) {
            // expected
        }
    }


    public void testTrimToSize() {
        ArrayUnsignedShortList list = new ArrayUnsignedShortList();
        for(int j=0;j<3;j++) {
            assertTrue(list.isEmpty());
    
            list.trimToSize();
    
            assertTrue(list.isEmpty());
            
            for(int i=0;i<10;i++) {
                list.add(i);
            }
            
            for(int i=0;i<10;i++) {
                assertEquals(i,list.get(i));
            }
            
            list.trimToSize();
    
            for(int i=0;i<10;i++) {
                assertEquals(i,list.get(i));
            }
    
            for(int i=0;i<10;i+=2) {
                list.removeElement(i);
            }
            
            for(int i=0;i<5;i++) {
                assertEquals((2*i)+1,list.get(i));
            }
    
            list.trimToSize();
                    
            for(int i=0;i<5;i++) {
                assertEquals((2*i)+1,list.get(i));
            }
    
            list.trimToSize();
                    
            for(int i=0;i<5;i++) {
                assertEquals((2*i)+1,list.get(i));
            }

            list.clear();
        }
    }

}