package gnu.trove.set.hash;

import gnu.trove.iterator.TIntIterator;
import gnu.trove.procedure.TIntProcedure;
import gnu.trove.set.TIntSet;
import junit.framework.TestCase;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.*;


/**
 * Test the primitive HashSet classes.
 */
public class TPrimitiveHashSetTest extends TestCase {

    public TPrimitiveHashSetTest(String name) {
        super(name);
    }


    public void setUp() throws Exception {
        super.setUp();
    }


    public void tearDown() throws Exception {
        super.tearDown();
    }


    public void testConstructors() throws Exception {
        TIntSet set = new TIntHashSet();
        assertNotNull(set);

        int[] ints = {1138, 42, 86, 99, 101};
        set.addAll(ints);

        TIntSet copy = new TIntHashSet(set);
        assertTrue("set not a copy: " + set + ", " + copy, set.equals(copy));

        TIntSet another = new TIntHashSet(20);
        another.addAll(ints);
        assertTrue("set not equal: " + set + ", " + copy, set.equals(another));

        another = new TIntHashSet(2, 1.0f);
        another.addAll(ints);
        assertTrue("set not equal: " + set + ", " + copy, set.equals(another));

        another = new TIntHashSet(ints);
        assertTrue("set not equal: " + set + ", " + copy, set.equals(another));
    }


    public void testIsEmpty() throws Exception {
        TIntSet s = new TIntHashSet();
        assertTrue("new set wasn't empty", s.isEmpty());

        s.add(1);
        assertTrue("set with element reports empty", !s.isEmpty());
        s.clear();
        assertTrue("cleared set reports not-empty", s.isEmpty());
    }


    public void testContains() throws Exception {
        TIntSet s = new TIntHashSet();
        int i = 100;
        s.add(i);
        assertTrue("contains failed", s.contains(i));
        assertFalse("contains failed", s.contains(1000));
    }


    @SuppressWarnings({"ForLoopReplaceableByForEach"})
    public void testContainsAll() throws Exception {

        int[] ints = {1138, 42, 13, 86, 99};

        TIntSet set = new TIntHashSet();
        set.addAll(ints);

        TIntSet other = new TIntHashSet();
        other.addAll(ints);

        List<Number> ints_list = new ArrayList<Number>();
        for (int element : ints) {
            ints_list.add(element);
        }

        for (int index = 0; index < ints.length; index++) {
            assertTrue(Integer.valueOf(ints[index]).toString(),
                    set.contains(ints[index]));
        }

        assertTrue("containsAll(Collection<?>) failed: " + set,
                set.containsAll(ints_list));
        ints_list.remove(Integer.valueOf(42));
        ints_list.add(Long.valueOf(42));
        assertFalse("containsAll(Collection<?>) failed: " + set,
                set.containsAll(ints_list));

        assertTrue("containsAll(TIntSet) failed (same set): " + set,
                set.containsAll(set));

        assertTrue("containsAll(TIntSet) failed (other set): " + set,
                set.containsAll(other));

        assertTrue("containsAll(int[]) failed: " + set,
                set.containsAll(ints));


        int[] failed = {42, 86, 99, 123456};

        TIntSet failed_set = new TIntHashSet();
        failed_set.addAll(failed);

        List<Integer> failed_list = new ArrayList<Integer>();
        for (int element : failed) {
            failed_list.add(element);
        }

        assertFalse("containsAll(Collection<?>) failed (false positive): " + set,
                set.containsAll(failed_list));

        assertFalse("containsAll(TIntSet) failed (false positive): " + set,
                set.containsAll(failed_set));

        assertFalse("containsAll(int[]) failed (false positive): " + set,
                set.containsAll(failed));
    }


    public void testAddAll() throws Exception {

        int[] ints = {1138, 42, 13, 86, 99, 101};

        TIntSet set;

        List<Integer> list = new ArrayList<Integer>();
        for (int element : ints) {
            list.add(Integer.valueOf(element));
        }

        set = new TIntHashSet();
        assertTrue("addAll(Collection<?>) failed: " + set, set.addAll(list));
        for (int element : ints) {
            assertTrue("contains failed: ", set.contains(element));
        }

        set = new TIntHashSet();
        assertTrue("addAll(int[]) failed: " + set, set.addAll(ints));
        for (int element : ints) {
            assertTrue("contains failed: ", set.contains(element));
        }

        TIntSet test_set = new TIntHashSet();
        assertTrue("addAll(TIntSet) failed: " + test_set, test_set.addAll(set));
        for (int element : ints) {
            assertTrue("contains failed: ", set.contains(element));
        }


    }


    public void testRetainAll() throws Exception {

        int[] ints = {1138, 42, 13, 86, 99, 101};

        TIntSet set = new TIntHashSet();
        set.addAll(ints);

        TIntSet other = new TIntHashSet();
        other.addAll(ints);

        int[] to_retain = {13, 86, 99, 1138};

        TIntSet retain_set = new TIntHashSet();
        retain_set.addAll(to_retain);

        List<Integer> retain_list = new ArrayList<Integer>();
        for (int element : to_retain) {
            retain_list.add(element);
        }

        assertFalse("retainAll(TIntSet) failed (same set): " + set,
                set.retainAll(set));
        // Contains all the original elements
        assertTrue(set.toString(), set.containsAll(ints));
        assertTrue(retain_set.toString(), retain_set.containsAll(to_retain));

        assertTrue("retainAll(Collection<?>) failed: " + set,
                set.retainAll(retain_list));
        // Contains just the expected elements
        assertFalse(set.toString(), set.containsAll(ints));
        assertTrue(set.toString(), set.containsAll(to_retain));
        assertTrue(retain_set.toString(), retain_set.containsAll(to_retain));

        // reset the set.
        set = new TIntHashSet();
        set.addAll(ints);
        assertTrue("retainAll(TIntSet) failed: " + set,
                set.retainAll(retain_set));
        // Contains just the expected elements
        assertFalse(set.toString(), set.containsAll(ints));
        assertTrue(set.toString(), set.containsAll(to_retain));
        assertTrue(retain_set.toString(), retain_set.containsAll(to_retain));

        // reset the set.
        set = new TIntHashSet();
        set.addAll(ints);
        assertTrue("retainAll(int[]) failed: " + set,
                set.retainAll(to_retain));
        // Contains just the expected elements
        assertFalse(set.toString(), set.containsAll(ints));
        assertTrue(set.toString(), set.containsAll(to_retain));
        assertTrue(retain_set.toString(), retain_set.containsAll(to_retain));
    }


    public void testRemoveAll() throws Exception {

        int[] ints = {1138, 42, 13, 86, 99, 101};

        TIntSet set = new TIntHashSet();
        set.addAll(ints);

        TIntSet other = new TIntHashSet();
        other.addAll(ints);

        int[] to_remove = {13, 86, 99, 1138};

        TIntSet remove_set = new TIntHashSet();
        remove_set.addAll(to_remove);

        List<Integer> remove_list = new ArrayList<Integer>();
        for (int element : to_remove) {
            remove_list.add(element);
        }

        int[] remainder = {42, 101};

        try {
            assertFalse("removeAll(TIntSet) failed (same set): " + set,
                    set.removeAll(set));
            fail("should have thrown ConcurrentModificationException");
        } catch (ConcurrentModificationException cme) {
            // expected exception thrown.
        }

        // reset the set.
        set = new TIntHashSet();
        set.addAll(ints);
        assertTrue("removeAll(Collection<?>) failed: " + set,
                set.removeAll(remove_list));
        // Contains just the expected elements
        assertTrue(set.toString(), set.containsAll(remainder));
        assertFalse(set.toString(), set.containsAll(to_remove));
        assertTrue(remove_set.toString(), remove_set.containsAll(to_remove));

        // reset the set.
        set = new TIntHashSet();
        set.addAll(ints);
        assertTrue("removeAll(TIntSet) failed: " + set,
                set.removeAll(remove_set));
        // Contains just the expected elements
        assertTrue(set.toString(), set.containsAll(remainder));
        assertFalse(set.toString(), set.containsAll(to_remove));
        assertTrue(remove_set.toString(), remove_set.containsAll(to_remove));

        // reset the set.
        set = new TIntHashSet();
        set.addAll(ints);
        assertTrue("removeAll(int[]) failed: " + set,
                set.removeAll(to_remove));
        // Contains just the expected elements
        assertTrue(set.toString(), set.containsAll(remainder));
        assertFalse(set.toString(), set.containsAll(to_remove));
        assertTrue(remove_set.toString(), remove_set.containsAll(to_remove));
    }


    public void testAdd() throws Exception {
        TIntSet set = new TIntHashSet();
        assertTrue("add failed", set.add(1));
        assertFalse("duplicated add modified set", set.add(1));
    }


    public void testRemove() throws Exception {
        TIntSet set = new TIntHashSet();
        set.add(1);
        set.add(2);
        assertTrue("One was not added", set.contains(1));
        assertTrue("One was not removed", set.remove(1));
        assertFalse("One was not removed", set.contains(1));
        assertTrue("Two was also removed", set.contains(2));
    }


    public void testRemoveNonExistant() throws Exception {
        TIntSet set = new TIntHashSet();
        set.add(1);
        set.add(2);
        assertTrue("One was not added", set.contains(1));
        assertTrue("One was not removed", set.remove(1));
        assertFalse("One was not removed", set.contains(1));
        assertTrue("Two was also removed", set.contains(2));
        assertFalse("Three was removed (non-existant)", set.remove(3));
    }


    public void testSize() throws Exception {
        TIntSet set = new TIntHashSet();
        assertEquals("initial size was not 0", 0, set.size());

        for (int i = 0; i < 99; i++) {
            set.add(i);
            assertEquals("size did not increase after add", i + 1, set.size());
        }
    }


    public void testClear() throws Exception {
        TIntSet set = new TIntHashSet();
        set.addAll(new int[]{1, 2, 3});
        assertEquals("size was not 3", 3, set.size());
        set.clear();
        assertEquals("initial size was not 0", 0, set.size());
    }


    public void testSerialize() throws Exception {
        int[] ints = {1138, 42, 86, 99, 101};

        TIntSet set = new TIntHashSet();
        set.addAll(ints);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(set);

        ByteArrayInputStream bias = new ByteArrayInputStream(baos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bias);

        TIntSet deserialized = (TIntSet) ois.readObject();

        assertEquals(set, deserialized);
    }


    public void testToArray() {
        TIntSet set = new TIntHashSet();
        int[] ints = {42, 1138, 13, 86, 99};
        set.addAll(ints);
        int[] res = set.toArray();
        Arrays.sort(ints);
        Arrays.sort(res);
        assertTrue(Arrays.equals(ints, res));
    }


    public void testToArrayMatchesIteratorOrder() {
        TIntSet set = new TIntHashSet();
        int[] ints = {42, 1138, 13, 86, 99};
        set.addAll(ints);
        int[] toarray_ints = set.toArray();

        int[] iter_ints = new int[5];
        TIntIterator iter = set.iterator();

        int index = 0;
        while (iter.hasNext()) {
            iter_ints[index++] = iter.next();
        }

        assertTrue(Arrays.equals(iter_ints, toarray_ints));
    }


    public void testToArrayWithParams() {
        int no_entry_value = Integer.MIN_VALUE;
        TIntSet set = new TIntHashSet(10, 0.5f, no_entry_value);
        assertEquals(no_entry_value, set.getNoEntryValue());

        int[] ints = {42, 1138, 13, 86, 99};
        set.addAll(ints);

        int[] sink = new int[ints.length + 2];
        sink[sink.length - 1] = -1;
        sink[sink.length - 2] = -2;

        int[] res = set.toArray(sink);
        assertEquals(set.getNoEntryValue(), res[set.size()]);

        Set<Integer> copy = new HashSet<Integer>();
        for (int element : sink) {
            copy.add(Integer.valueOf(element));
        }

        Set<Integer> bogey = new HashSet<Integer>();
        for (int element : ints) {
            bogey.add(Integer.valueOf(element));
        }
        bogey.add(-1);
        bogey.add(no_entry_value);
        assertEquals(bogey, copy);
    }


    public void testRehashing() throws Exception {
        int size = 10000;
        TIntSet set = new TIntHashSet(10);
        for (int i = 0; i < size; i++) {
            set.add(i);
        }
        assertEquals(set.size(), size);
    }


    public void testIterator() {

        TIntSet set = new TIntHashSet();
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(4);

        TIntIterator iter = set.iterator();
        assertTrue("iterator should have a next item", iter.hasNext());

        int last = -1;
        while (iter.hasNext()) {
            int next = iter.next();
            assertTrue(Integer.valueOf(next).toString(),
                    next >= 1 && next <= 4);
            assertTrue(Integer.valueOf(next).toString(), next != last);
            last = next;
        }

        assertFalse("iterator should not have a next item", iter.hasNext());

        assertTrue("set should contain 1", set.contains(1));
        assertTrue("set should contain 2", set.contains(2));
        assertTrue("set should contain 3", set.contains(3));
        assertTrue("set should contain 4", set.contains(4));
        assertEquals(4, set.size());
    }


    public void testIteratorRemove() {

        TIntSet set = new TIntHashSet();
        set.add(1);
        set.add(2);
        set.add(3);
        set.add(4);

        TIntIterator iter = set.iterator();
        assertTrue("iterator should have a next item", iter.hasNext());

        int last = -1;
        while (iter.hasNext()) {
            int next = iter.next();
            assertTrue(next >= 1 && next <= 4);
            assertTrue(next != last);
            last = next;

            if (next == 3) {
                iter.remove();
            }
        }

        assertFalse("iterator should not have a next item", iter.hasNext());

        assertFalse("set should not contain 3", set.contains(3));
        assertTrue("set should contain 1", set.contains(1));
        assertTrue("set should contain 2", set.contains(2));
        assertTrue("set should contain 4", set.contains(4));
        assertEquals(3, set.size());

    }


    public void testForEach() {
        TIntSet set = new TIntHashSet(10, 0.5f);
        int[] ints = {1138, 42, 86, 99, 101};
        set.addAll(ints);

        class ForEach implements TIntProcedure {

            TIntSet built = new TIntHashSet();


            public boolean execute(int value) {
                built.add(value);
                return true;
            }


            TIntSet getBuilt() {
                return built;
            }
        }

        ForEach procedure = new ForEach();

        set.forEach(procedure);
        TIntSet built = procedure.getBuilt();

        assertEquals("inequal sizes: " + set + ", " + built, set.size(), built.size());
        assertTrue("inequal sets: " + set + ", " + built, set.equals(built));
    }


    public void testEquals() {
        int[] ints = {1138, 42, 86, 99, 101};
        TIntSet set = new TIntHashSet();
        set.addAll(ints);
        TIntSet other = new TIntHashSet();
        other.addAll(ints);

        assertTrue("sets incorrectly not equal: " + set + ", " + other,
                set.equals(other));

        int[] mismatched = {72, 49, 53, 1024, 999};
        TIntSet unequal = new TIntHashSet();
        unequal.addAll(mismatched);

        assertFalse("sets incorrectly equal: " + set + ", " + unequal,
                set.equals(unequal));

        // Change length, different code branch
        unequal.add(1);
        assertFalse("sets incorrectly equal: " + set + ", " + unequal,
                set.equals(unequal));
    }


    public void testHashcode() {
        int[] ints = {1138, 42, 86, 99, 101};
        TIntSet set = new TIntHashSet();
        set.addAll(ints);
        TIntSet other = new TIntHashSet();
        other.addAll(ints);

        assertTrue("hashcodes incorrectly not equal: " + set + ", " + other,
                set.hashCode() == other.hashCode());

        int[] mismatched = {72, 49, 53, 1024, 999};
        TIntSet unequal = new TIntHashSet();
        unequal.addAll(mismatched);

        assertFalse("hashcodes unlikely equal: " + set + ", " + unequal,
                set.hashCode() == unequal.hashCode());
    }

    public void test3445639() throws Exception {
        // Retain all bug AIOBE
        TIntHashSet hs = new TIntHashSet(23, 1f);
        hs.addAll(new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22});
        hs.retainAll(new int[]{11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22});
        hs.retainAll(new int[]{18});
    }
}