/*
 *    GeoTools - The Open Source Java GIS Toolkit
 *    http://geotools.org
 *
 *    (C) 2008, Open Source Geospatial Foundation (OSGeo)
 *
 *    This library is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation;
 *    version 2.1 of the License.
 *
 *    This library is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 */
package org.geotools.util;

import java.util.*;
import org.junit.*;
import static org.junit.Assert.*;


/**
 * Tests {@link IntegerList} implementations.
 *
 * @author Martin Desruisseaux
 *
 * @source $URL$
 * @version $Id$
 */
public final class IntegerListTest {
    /**
     * The random number generator used for this test suite.
     */
    private final Random random = new Random(1241962316404811189L);

    /**
     * The list of integers.
     */
    private IntegerList list;

    /**
     * Writes values and read them again for making sure they are the expected ones.
     *
     * @param maximalValue The maximal value allowed.
     */
    private void testReadWrite(final int maximalValue) {
        final int length = 400;
        // Use half the lenght as initial capacity in order to test dynamic resizing.
        list = new IntegerList(length / 2, maximalValue);
        assertTrue(list.maximalValue() >= maximalValue);
        final List<Integer> copy = new ArrayList<Integer>();
        for (int i=0; i<length; i++) {
            assertEquals(i, list.size());
            final Integer value = nextInt(maximalValue);
            assertTrue(copy.add(value));
            assertTrue(list.add(value));
        }
        assertEquals(copy, list);
        assertEquals(copy.hashCode(), list.hashCode());
        for (int i=0; i<length; i+=10) {
            final Integer value = nextInt(maximalValue);
            final Integer old = copy.set(i, value);
            assertNotNull(old);
            assertEquals(old, list.set(i, value));
        }
        for (int i=0; i<length; i++) {
            assertEquals(String.valueOf(i), copy.get(i), list.get(i));
        }
        assertEquals(copy, list);
        assertEquals(copy.hashCode(), list.hashCode());
    }

    /**
     * Returns the next number from the random number generator.
     */
    private int nextInt(final int maximalValue) {
        if (maximalValue == Integer.MAX_VALUE) {
            return Math.abs(random.nextInt());
        } else {
            return random.nextInt(maximalValue + 1);
        }
    }

    /**
     * Tests the fill value using the existing list, which is assumed
     * already filled with random values prior this method call.
     */
    private void testFill(final int value) {
        assertEquals(400, list.size());
        final Set<Integer> set = new HashSet<Integer>();
        list.fill(value);
        set.addAll(list);
        assertEquals(Collections.singleton(value), set);
        list.fill(0);
        set.clear();
        set.addAll(list);
        assertEquals(Collections.singleton(0), set);
    }

    /**
     * Tests with a maximal value of 1.
     */
    @Test
    public void test1() {
        testReadWrite(1);
        testFill(1);
    }

    /**
     * Tests with a maximal value of 2.
     */
    @Test
    public void test2() {
        testReadWrite(2);
        testFill(2);
    }

    /**
     * Tests with a maximal value of 3.
     */
    @Test
    public void test3() {
        testReadWrite(3);
        testFill(3);
    }

    /**
     * Tests with a maximal value of 10.
     */
    @Test
    public void test10() {
        testReadWrite(10);
        testFill(10);
    }

    /**
     * Tests with a maximal value of 100.
     */
    @Test
    public void test100() {
        testReadWrite(100);
        assertEquals(400, list.size());
        final int old100 = list.getInteger(100);
        final int old101 = list.getInteger(101);
        assertFalse(0 == old100);
        assertFalse(0 == old101);
        list.resize(101);
        assertEquals(old100, list.getInteger(100));
        list.resize(200);
        assertEquals(200, list.size());
        assertEquals(old100, list.getInteger(100));
        assertEquals(0, list.getInteger(101));
        for (int i=101; i<200; i++) {
            assertEquals(0, list.getInteger(i));
        }
        list.resize(400);
        testFill(100);
    }

    /**
     * Tests with a maximal value of 100000.
     */
    @Test
    public void test100000() {
        testReadWrite(100000);
        testFill(17);
    }

    /**
     * Tests with a maximal value of {@value Integer#MAX_VALUE}.
     */
    @Test
    public void testMax() {
        testReadWrite(Integer.MAX_VALUE);
        testFill(17);
    }
}