trove/decorator/TPrimitiveObjectMapDecoratorTest.java

///////////////////////////////////////////////////////////////////////////////
// Copyright (c) 2002, Eric D. Friedman All Rights Reserved.
// Copyright (c) 2009, Robert D. Eden All Rights Reserved.
// Copyright (c) 2009, Jeff Randall All Rights Reserved.
//
// 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; either
// version 2.1 of the License, or (at your option) any later version.
//
// 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 General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
///////////////////////////////////////////////////////////////////////////////

package gnu.trove.decorator;

import gnu.trove.map.TIntObjectMap;
import gnu.trove.map.hash.TIntObjectHashMap;
import gnu.trove.TDecorators;
import gnu.trove.set.TIntSet;
import gnu.trove.set.hash.TIntHashSet;

import junit.framework.TestCase;

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


/**
 * Test the primitive key/Object value map decorators
 *
 * @author Eric D. Friedman
 * @author Robert D. Eden
 * @author Jeff Randall
 */
public class TPrimitiveObjectMapDecoratorTest extends TestCase {

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


    public void testConstructors() {
        int element_count = 20;
        int[] keys = new int[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
        for (int i = 0; i < element_count; i++) {
            keys[i] = i + 1;
            vals[i] = Integer.toString(i + 1);
            raw_map.put(keys[i], vals[i]);
        }
        Map<Integer, String> map = TDecorators.wrap(raw_map);

        TIntObjectMap<String> raw_capacity =
                new TIntObjectHashMap<String>(20);
        for (int i = 0; i < element_count; i++) {
            raw_capacity.put(keys[i], vals[i]);
        }
        Map<Integer, String> capacity = TDecorators.wrap(raw_capacity);
        assertEquals(map, capacity);

        TIntObjectMap<String> raw_cap_and_factor =
                new TIntObjectHashMap<String>(20, 0.75f);
        for (int i = 0; i < element_count; i++) {
            raw_cap_and_factor.put(keys[i], vals[i]);
        }
        Map<Integer, String> cap_and_factor = TDecorators.wrap(raw_cap_and_factor);
        assertEquals(map, cap_and_factor);

        TIntObjectMap<String> raw_fully_specified =
                new TIntObjectHashMap<String>(20, 0.75f, Integer.MIN_VALUE);
        for (int i = 0; i < element_count; i++) {
            raw_fully_specified.put(keys[i], vals[i]);
        }
        Map<Integer, String> fully_specified = TDecorators.wrap(raw_fully_specified);
        assertEquals(map, fully_specified);

        TIntObjectMap<String> raw_copy =
                new TIntObjectHashMap<String>(raw_map);
        Map<Integer, String> copy = TDecorators.wrap(raw_copy);
        assertEquals(map, copy);
    }


    public void testGet() {
        int element_count = 20;
        int[] keys = new int[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
        for (int i = 0; i < element_count; i++) {
            keys[i] = i + 1;
            vals[i] = Integer.toString(i + 1);
            raw_map.put(keys[i], vals[i]);
        }
        Map<Integer, String> map = TDecorators.wrap(raw_map);

        assertEquals(vals[10], map.get(Integer.valueOf(keys[10])));
        assertNull(map.get(Integer.valueOf(1138)));

        Integer key = Integer.valueOf(1138);
        map.put(key, null);
        assertTrue(map.containsKey(key));
        assertNull(map.get(key));

        Long long_key = Long.valueOf(1138);
        //noinspection SuspiciousMethodCalls
        assertNull(map.get(long_key));

        map.put(null, "null-key");
        assertEquals("null-key", map.get(null));
    }


    public void testContainsKey() {
        int element_count = 20;
        int[] keys = new int[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
        for (int i = 0; i < element_count; i++) {
            keys[i] = i + 1;
            vals[i] = Integer.toString(i + 1);
            raw_map.put(keys[i], vals[i]);
        }
        Map<Integer, String> map = TDecorators.wrap(raw_map);

        for (int i = 0; i < element_count; i++) {
            assertTrue("Key should be present: " + keys[i] + ", map: " + map,
                    map.containsKey(keys[i]));
        }

        int key = 1138;
        assertFalse("Key should not be present: " + key + ", map: " + map,
                map.containsKey(key));
    }


    public void testContainsValue() {
        int element_count = 20;
        int[] keys = new int[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
        for (int i = 0; i < element_count; i++) {
            keys[i] = i + 1;
            vals[i] = Integer.toString(i + 1);
            raw_map.put(keys[i], vals[i]);
        }
        Map<Integer, String> map = TDecorators.wrap(raw_map);

        for (int i = 0; i < element_count; i++) {
            assertTrue("Value should be present: " + vals[i] + ", map: " + map,
                    map.containsValue(vals[i]));
        }

        String val = "1138";
        assertFalse("Key should not be present: " + val + ", map: " + map,
                map.containsValue(val));

        //noinspection SuspiciousMethodCalls
        assertFalse("Random object should not be present in map: " + map,
                map.containsValue(new Object()));
    }


    public void testRemove() {
        int element_count = 20;
        int[] keys = new int[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
        for (int i = 0; i < element_count; i++) {
            keys[i] = i + 1;
            vals[i] = Integer.toString(i + 1);
            raw_map.put(keys[i], vals[i]);
        }
        Map<Integer, String> map = TDecorators.wrap(raw_map);

        for (int i = 0; i < element_count; i++) {
            if (i % 2 == 1) {
                assertEquals("Remove should have modified map: " + keys[i] + ", map: " + map,
                        vals[i], map.remove(keys[i]));
            }
        }

        for (int i = 0; i < element_count; i++) {
            if (i % 2 == 1) {
                assertTrue("Removed key still in map: " + keys[i] + ", map: " + map,
                        map.get(keys[i]) == null);
            } else {
                assertTrue("Key should still be in map: " + keys[i] + ", map: " + map,
                        map.get(keys[i]).equals(vals[i]));
            }
        }

        assertNull(map.get(1138));
        //noinspection SuspiciousMethodCalls
        assertNull(map.get(Integer.valueOf(1138)));
        assertNull(map.get(null));

        map.put(null, "null-value");
        assertEquals("null-value", raw_map.get(raw_map.getNoEntryKey()));
        assertTrue(map.containsKey(null));
        String value = map.get(null);
        assertEquals("value: " + value, "null-value", value);
        assertEquals("null-value", map.remove(null));
        assertFalse(map.containsKey(null));

        //noinspection SuspiciousMethodCalls
        assertNull(map.remove(Long.valueOf(1138)));
    }


    public void testPutAllMap() {
        int element_count = 20;
        int[] keys = new int[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_control = new TIntObjectHashMap<String>();
        for (int i = 0; i < element_count; i++) {
            keys[i] = i + 1;
            vals[i] = Integer.toString(i + 1);
            raw_control.put(keys[i], vals[i]);
        }
        Map<Integer, String> control = TDecorators.wrap(raw_control);

        TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
        Map<Integer, String> map = TDecorators.wrap(raw_map);

        Map<Integer, String> source = new HashMap<Integer, String>();
        for (int i = 0; i < element_count; i++) {
            source.put(keys[i], vals[i]);
        }

        map.putAll(source);
        assertEquals(control, map);
    }


    public void testPutAll() throws Exception {
        TIntObjectMap<String> raw_t = new TIntObjectHashMap<String>();
        Map<Integer, String> t = TDecorators.wrap(raw_t);
        TIntObjectMap<String> raw_m = new TIntObjectHashMap<String>();
        Map<Integer, String> m = TDecorators.wrap(raw_m);
        m.put(2, "one");
        m.put(4, "two");
        m.put(6, "three");

        t.put(5, "four");
        assertEquals(1, t.size());

        t.putAll(m);
        assertEquals(4, t.size());
        assertEquals("two", t.get(4));
    }


    public void testClear() {
        int element_count = 20;
        int[] keys = new int[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
        for (int i = 0; i < element_count; i++) {
            keys[i] = i + 1;
            vals[i] = Integer.toString(i + 1);
            raw_map.put(keys[i], vals[i]);
        }
        Map<Integer, String> map = TDecorators.wrap(raw_map);
        assertEquals(element_count, map.size());

        map.clear();
        assertTrue(map.isEmpty());
        assertEquals(0, map.size());

        assertNull(map.get(keys[5]));
    }


    @SuppressWarnings({"ToArrayCallWithZeroLengthArrayArgument"})
    public void testKeySet() {
        int element_count = 20;
        int[] keys = new int[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
        for (int i = 0; i < element_count; i++) {
            keys[i] = i + 1;
            vals[i] = Integer.toString(i + 1);
            raw_map.put(keys[i], vals[i]);
        }
        Map<Integer, String> map = TDecorators.wrap(raw_map);
        assertEquals(element_count, map.size());

        Set<Integer> keyset = map.keySet();
        for (int i = 0; i < keyset.size(); i++) {
            assertTrue(keyset.contains(keys[i]));
        }
        assertFalse(keyset.isEmpty());

        Object[] keys_object_array = keyset.toArray();
        int count = 0;
        Iterator<Integer> iter = keyset.iterator();
        while (iter.hasNext()) {
            int key = iter.next();
            assertTrue(keyset.contains(key));
            assertEquals(keys_object_array[count], key);
            count++;
        }

        Integer[] keys_array = keyset.toArray(new Integer[0]);
        count = 0;
        iter = keyset.iterator();
        while (iter.hasNext()) {
            Integer key = iter.next();
            assertTrue(keyset.contains(key));
            assertEquals(keys_array[count], key);
            count++;
        }

        keys_array = keyset.toArray(new Integer[keyset.size()]);
        count = 0;
        iter = keyset.iterator();
        while (iter.hasNext()) {
            Integer key = iter.next();
            assertTrue(keyset.contains(key));
            assertEquals(keys_array[count], key);
            count++;
        }

        keys_array = keyset.toArray(new Integer[keyset.size() * 2]);
        count = 0;
        iter = keyset.iterator();
        while (iter.hasNext()) {
            Integer key = iter.next();
            assertTrue(keyset.contains(key));
            assertEquals(keys_array[count], key);
            count++;
        }
        assertNull(keys_array[keyset.size()]);

        TIntSet raw_other = new TIntHashSet(keyset);
        Set<Integer> other = TDecorators.wrap(raw_other);
        assertFalse(keyset.retainAll(other));
        other.remove(keys[5]);
        assertTrue(keyset.retainAll(other));
        assertFalse(keyset.contains(keys[5]));
        assertFalse(map.containsKey(keys[5]));

        keyset.clear();
        assertTrue(keyset.isEmpty());


    }


    public void testKeySetAdds() {
        int element_count = 20;
        int[] keys = new int[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
        for (int i = 0; i < element_count; i++) {
            keys[i] = i + 1;
            vals[i] = Integer.toString(i + 1);
            raw_map.put(keys[i], vals[i]);
        }
        Map<Integer, String> map = TDecorators.wrap(raw_map);
        assertEquals(element_count, map.size());

        Set<Integer> keyset = map.keySet();
        for (int i = 0; i < keyset.size(); i++) {
            assertTrue(keyset.contains(keys[i]));
        }
        assertFalse(keyset.isEmpty());

        try {
            keyset.add(1138);
            fail("Expected UnsupportedOperationException");
        } catch (UnsupportedOperationException ex) {
            // Expected
        }

        try {
            Set<Integer> test = new HashSet<Integer>();
            test.add(Integer.valueOf(1138));
            keyset.addAll(test);
            fail("Expected UnsupportedOperationException");
        } catch (UnsupportedOperationException ex) {
            // Expected
        }

        try {
            Set<Integer> test = new HashSet<Integer>();
            test.add(1138);
            keyset.addAll(test);
            fail("Expected UnsupportedOperationException");
        } catch (UnsupportedOperationException ex) {
            // Expected
        }
    }


    @SuppressWarnings({"ToArrayCallWithZeroLengthArrayArgument"})
    public void testKeys() {
        int element_count = 20;
        int[] keys = new int[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
        for (int i = 0; i < element_count; i++) {
            keys[i] = i + 1;
            vals[i] = Integer.toString(i + 1);
            raw_map.put(keys[i], vals[i]);
        }
        Map<Integer, String> map = TDecorators.wrap(raw_map);
        assertEquals(element_count, map.size());

        // No argument
        Integer[] keys_array = map.keySet().toArray(new Integer[map.size()]);
        assertEquals(element_count, keys_array.length);
        List<Integer> keys_list = Arrays.asList(keys_array);
        for (int i = 0; i < element_count; i++) {
            assertTrue(keys_list.contains(keys[i]));
        }

        // Zero length array
        //noinspection ToArrayCallWithZeroLengthArrayArgument
        keys_array = map.keySet().toArray(new Integer[0]);
        assertEquals(element_count, keys_array.length);
        keys_list = Arrays.asList(keys_array);
        for (int i = 0; i < element_count; i++) {
            assertTrue(keys_list.contains(keys[i]));
        }

        // appropriate length array
        keys_array = map.keySet().toArray(new Integer[map.size()]);
        assertEquals(element_count, keys_array.length);
        keys_list = Arrays.asList(keys_array);
        for (int i = 0; i < element_count; i++) {
            assertTrue(keys_list.contains(keys[i]));
        }

        // longer array
        keys_array = map.keySet().toArray(new Integer[element_count * 2]);
        assertEquals(element_count * 2, keys_array.length);
        keys_list = Arrays.asList(keys_array);
        for (int i = 0; i < element_count; i++) {
            assertTrue(keys_list.contains(keys[i]));
        }
        assertNull(keys_array[element_count]);
    }


    public void testValueCollectionToArray() {
        int element_count = 20;
        int[] keys = new int[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
        for (int i = 0; i < element_count; i++) {
            keys[i] = i + 1;
            vals[i] = Integer.toString(i + 1);
            raw_map.put(keys[i], vals[i]);
        }
        Map<Integer, String> map = TDecorators.wrap(raw_map);
        assertEquals(element_count, map.size());

        Collection<String> collection = map.values();
        for (int i = 0; i < collection.size(); i++) {
            assertTrue(collection.contains(vals[i]));
        }
        assertFalse(collection.isEmpty());

        Object[] values_obj_array = collection.toArray();
        int count = 0;
        Iterator<String> iter = collection.iterator();
        while (iter.hasNext()) {
            String value = iter.next();
            assertTrue(collection.contains(value));
            assertEquals(values_obj_array[count], value);
            count++;
        }

        //noinspection ToArrayCallWithZeroLengthArrayArgument
        String[] values_array = collection.toArray(new String[0]);
        count = 0;
        iter = collection.iterator();
        while (iter.hasNext()) {
            String value = iter.next();
            assertTrue(collection.contains(value));
            assertEquals(values_array[count], value);
            count++;
        }

        values_array = collection.toArray(new String[collection.size()]);
        count = 0;
        iter = collection.iterator();
        while (iter.hasNext()) {
            String value = iter.next();
            assertTrue(collection.contains(value));
            assertEquals(values_array[count], value);
            count++;
        }

        values_array = collection.toArray(new String[collection.size() * 2]);
        count = 0;
        iter = collection.iterator();
        while (iter.hasNext()) {
            String value = iter.next();
            assertTrue(collection.contains(value));
            assertEquals(values_array[count], value);
            count++;
        }
        assertNull(values_array[collection.size()]);
        assertNull(values_array[collection.size()]);

        Collection<String> other = new ArrayList<String>(collection);
        assertFalse(collection.retainAll(other));
        other.remove(vals[5]);
        assertTrue(collection.retainAll(other));
        assertFalse(collection.contains(vals[5]));
        assertFalse(map.containsKey(keys[5]));

        collection.clear();
        assertTrue(collection.isEmpty());
    }


    public void testValueCollectionAdds() {
        int element_count = 20;
        int[] keys = new int[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
        for (int i = 0; i < element_count; i++) {
            keys[i] = i + 1;
            vals[i] = Integer.toString(i + 1);
            raw_map.put(keys[i], vals[i]);
        }
        Map<Integer, String> map = TDecorators.wrap(raw_map);
        assertEquals(element_count, map.size());

        Collection<String> collection = map.values();
        for (int i = 0; i < collection.size(); i++) {
            assertTrue(collection.contains(vals[i]));
        }
        assertFalse(collection.isEmpty());

        try {
            collection.add("1138");
            fail("Expected UnsupportedOperationException");
        } catch (UnsupportedOperationException ex) {
            // Expected
        }

        try {
            Set<String> test = new HashSet<String>();
            test.add("1138");
            collection.addAll(test);
            fail("Expected UnsupportedOperationException");
        } catch (UnsupportedOperationException ex) {
            // Expected
        }

        try {
            Collection<String> test = new ArrayList<String>();
            test.add("1138");
            collection.addAll(test);
            fail("Expected UnsupportedOperationException");
        } catch (UnsupportedOperationException ex) {
            // Expected
        }

        try {
            collection.addAll(Arrays.asList(vals));
            fail("Expected UnsupportedOperationException");
        } catch (UnsupportedOperationException ex) {
            // Expected
        }
    }


    public void testValueCollectionContainsAll() {
        int element_count = 20;
        int[] keys = new int[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
        for (int i = 0; i < element_count; i++) {
            keys[i] = i + 1;
            vals[i] = Integer.toString(i + 1);
            raw_map.put(keys[i], vals[i]);
        }
        Map<Integer, String> map = TDecorators.wrap(raw_map);
        assertEquals(element_count, map.size());

        Collection<String> collection = map.values();
        for (int i = 0; i < collection.size(); i++) {
            assertTrue(collection.contains(vals[i]));
        }
        assertFalse(collection.isEmpty());

        List<String> java_list = new ArrayList<String>();
        java_list.addAll(Arrays.asList(vals));
        assertTrue("collection: " + collection + ", should contain all in list: " +
                java_list, collection.containsAll(java_list));
        java_list.add(String.valueOf(1138));
        assertFalse("collection: " + collection + ", should not contain all in list: " +
                java_list, collection.containsAll(java_list));

        List<CharSequence> number_list = new ArrayList<CharSequence>();
        for (String value : vals) {
            if (value.equals("5")) {
                number_list.add(new StringBuilder().append(value));
            } else {
                number_list.add(String.valueOf(value));
            }
        }
        assertFalse("collection: " + collection + ", should not contain all in list: " +
                java_list, collection.containsAll(number_list));

        Collection<String> other = new ArrayList<String>(collection);
        assertTrue("collection: " + collection + ", should contain all in other: " +
                other, collection.containsAll(other));
        other.add("1138");
        assertFalse("collection: " + collection + ", should not contain all in other: " +
                other, collection.containsAll(other));
    }


    public void testValueCollectionRetainAllCollection() {
        int element_count = 20;
        int[] keys = new int[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
        for (int i = 0; i < element_count; i++) {
            keys[i] = i + 1;
            vals[i] = Integer.toString(i + 1);
            raw_map.put(keys[i], vals[i]);
        }
        Map<Integer, String> map = TDecorators.wrap(raw_map);
        assertEquals(element_count, map.size());

        Collection<String> collection = map.values();
        for (int i = 0; i < collection.size(); i++) {
            assertTrue(collection.contains(vals[i]));
        }
        assertFalse(collection.isEmpty());

        List<String> java_list = new ArrayList<String>();
        java_list.addAll(Arrays.asList(vals));
        assertFalse("collection: " + collection + ", should contain all in list: " +
                java_list, collection.retainAll(java_list));

        java_list.remove(5);
        assertTrue("collection: " + collection + ", should contain all in list: " +
                java_list, collection.retainAll(java_list));
        assertFalse(collection.contains(vals[5]));
        assertFalse(map.containsKey(keys[5]));
        assertFalse(map.containsValue(vals[5]));
        assertTrue("collection: " + collection + ", should contain all in list: " +
                java_list, collection.containsAll(java_list));
    }


    public void testValueCollectionRetainAllTCollection() {
        int element_count = 20;
        int[] keys = new int[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
        for (int i = 0; i < element_count; i++) {
            keys[i] = i + 1;
            vals[i] = Integer.toString(i + 1);
            raw_map.put(keys[i], vals[i]);
        }
        Map<Integer, String> map = TDecorators.wrap(raw_map);
        assertEquals(element_count, map.size());

        Collection<String> collection = map.values();
        for (int i = 0; i < collection.size(); i++) {
            assertTrue(collection.contains(vals[i]));
        }
        assertFalse(collection.isEmpty());

        assertFalse("collection: " + collection + ", should be unmodified.",
                collection.retainAll(collection));

        Collection<String> other = new ArrayList<String>(collection);
        assertFalse("collection: " + collection + ", should be unmodified. other: " +
                other, collection.retainAll(other));

        other.remove(vals[5]);
        assertTrue("collection: " + collection + ", should be modified. other: " +
                other, collection.retainAll(other));
        assertFalse(collection.contains(vals[5]));
        assertFalse(map.containsKey(keys[5]));
        assertFalse(map.containsValue(vals[5]));
        assertTrue("collection: " + collection + ", should contain all in other: " +
                other, collection.containsAll(other));
    }


    public void testValueCollectionRemoveAllCollection() {
        int element_count = 20;
        int[] keys = new int[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
        for (int i = 0; i < element_count; i++) {
            keys[i] = i + 1;
            vals[i] = Integer.toString(i + 1);
            raw_map.put(keys[i], vals[i]);
        }
        Map<Integer, String> map = TDecorators.wrap(raw_map);
        assertEquals(element_count, map.size());

        Collection<String> collection = map.values();
        for (int i = 0; i < collection.size(); i++) {
            assertTrue(collection.contains(vals[i]));
        }
        assertFalse(collection.isEmpty());

        List<String> java_list = new ArrayList<String>();
        assertFalse("collection: " + collection + ", should contain all in list: " +
                java_list, collection.removeAll(java_list));

        java_list.add(vals[5]);
        assertTrue("collection: " + collection + ", should contain all in list: " +
                java_list, collection.removeAll(java_list));
        assertFalse(collection.contains(vals[5]));
        assertFalse(map.containsKey(keys[5]));
        assertFalse(map.containsValue(vals[5]));

        java_list = new ArrayList<String>();
        java_list.addAll(Arrays.asList(vals));
        assertTrue("collection: " + collection + ", should contain all in list: " +
                java_list, collection.removeAll(java_list));
        assertTrue(collection.isEmpty());
    }


    public void testValueCollectionRemoveAllTCollection() {
        int element_count = 20;
        int[] keys = new int[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
        for (int i = 0; i < element_count; i++) {
            keys[i] = i + 1;
            vals[i] = Integer.toString(i + 1);
            raw_map.put(keys[i], vals[i]);
        }
        Map<Integer, String> map = TDecorators.wrap(raw_map);
        assertEquals(element_count, map.size());

        Collection<String> collection = map.values();
        for (int i = 0; i < collection.size(); i++) {
            assertTrue(collection.contains(vals[i]));
        }
        assertFalse(collection.isEmpty());

        Collection<String> other = new ArrayList<String>();
        assertFalse("collection: " + collection + ", should be unmodified.",
                collection.removeAll(other));

        other = new ArrayList<String>(collection);
        other.remove(vals[5]);
        assertTrue("collection: " + collection + ", should be modified. other: " +
                other, collection.removeAll(other));
        assertEquals(1, collection.size());
        for (int i = 0; i < element_count; i++) {
            if (i == 5) {
                assertTrue(collection.contains(vals[i]));
                assertTrue(map.containsKey(keys[i]));
                assertTrue(map.containsValue(vals[i]));
            } else {
                assertFalse(collection.contains(vals[i]));
                assertFalse(map.containsKey(keys[i]));
                assertFalse(map.containsValue(vals[i]));
            }
        }

        assertFalse("collection: " + collection + ", should be unmodified. other: " +
                other, collection.removeAll(other));

        assertTrue("collection: " + collection + ", should be modified. other: " +
                other, collection.removeAll(collection));
        assertTrue(collection.isEmpty());
    }


    public void testValues() {
        int element_count = 20;
        int[] keys = new int[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
        for (int i = 0; i < element_count; i++) {
            keys[i] = i + 1;
            vals[i] = Integer.toString(i + 1);
            raw_map.put(keys[i], vals[i]);
        }
        Map<Integer, String> map = TDecorators.wrap(raw_map);
        assertEquals(element_count, map.size());

        // No argument
        Object[] values_object_array = map.values().toArray();
        assertEquals(element_count, values_object_array.length);
        List<Object> values_object_list = Arrays.asList(values_object_array);
        for (int i = 0; i < element_count; i++) {
            assertTrue(values_object_list.contains(vals[i]));
        }

        // Zero length array
        //noinspection ToArrayCallWithZeroLengthArrayArgument
        String[] values_array = map.values().toArray(new String[0]);
        assertEquals(element_count, values_array.length);
        List<String> values_list = Arrays.asList(values_array);
        for (int i = 0; i < element_count; i++) {
            assertTrue(values_list.contains(vals[i]));
        }

        // appropriate length array
        values_array = map.values().toArray(new String[map.size()]);
        assertEquals(element_count, values_array.length);
        values_list = Arrays.asList(values_array);
        for (int i = 0; i < element_count; i++) {
            assertTrue(values_list.contains(vals[i]));
        }

        // longer array
        values_array = map.values().toArray(new String[element_count * 2]);
        assertEquals(element_count * 2, values_array.length);
        values_list = Arrays.asList(values_array);
        for (int i = 0; i < element_count; i++) {
            assertTrue(values_list.contains(vals[i]));
        }
        assertEquals(null, values_array[element_count]);
    }


    public void testEntrySet() {
        int element_count = 20;
        Integer[] keys = new Integer[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_map =
                new TIntObjectHashMap<String>(element_count, 0.5f, Integer.MIN_VALUE);
        Map<Integer, String> map = TDecorators.wrap(raw_map);

        for (int i = 0; i < element_count; i++) {
            keys[i] = Integer.valueOf(i + 1);
            vals[i] = Integer.toString(i + 1);
            map.put(keys[i], vals[i]);
        }
        assertEquals(element_count, map.size());

        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        assertEquals(element_count, entries.size());
        assertFalse(entries.isEmpty());
        //noinspection unchecked
        Map.Entry<Integer, String>[] array =
                entries.toArray(new Map.Entry[entries.size()]);
        for (Map.Entry<Integer, String> entry : array) {
            assertTrue(entries.contains(entry));
        }
        assertFalse(entries.contains(null));

        assertEquals(array[0].hashCode(), array[0].hashCode());
        assertTrue(array[0].hashCode() != array[1].hashCode());

        assertTrue(array[0].equals(array[0]));
        assertFalse(array[0].equals(array[1]));
        Integer key = array[0].getKey();
        Integer old_value = Integer.valueOf(array[0].getValue());
        assertEquals(Integer.toString(old_value),
                array[0].setValue(Integer.toString(old_value * 2)));
        assertEquals(Integer.toString(old_value * 2), map.get(key));
        assertEquals(Integer.toString(old_value * 2), array[0].getValue());

        // Adds are not allowed
        Map.Entry<Integer, String> invalid_entry = new Map.Entry<Integer, String>() {
            public Integer getKey() {
                return null;
            }

            public String getValue() {
                return null;
            }

            public String setValue(String value) {
                return null;
            }
        };
        List<Map.Entry<Integer, String>> invalid_entry_list =
                new ArrayList<Map.Entry<Integer, String>>();
        invalid_entry_list.add(invalid_entry);

        try {
            entries.add(invalid_entry);
            fail("Expected OperationUnsupportedException");
        } catch (UnsupportedOperationException ex) {
            // Expected
        }

        try {
            entries.addAll(invalid_entry_list);
            fail("Expected OperationUnsupportedException");
        } catch (UnsupportedOperationException ex) {
            // Expected
        }

        assertFalse(entries.containsAll(invalid_entry_list));
        assertFalse(entries.removeAll(invalid_entry_list));

        List<Map.Entry<Integer, String>> partial_list =
                new ArrayList<Map.Entry<Integer, String>>();
        partial_list.add(array[3]);
        partial_list.add(array[4]);
        assertTrue(entries.removeAll(partial_list));
        assertEquals(element_count - 2, entries.size());
        assertEquals(element_count - 2, map.size());

        entries.clear();
        assertTrue(entries.isEmpty());
        assertTrue(map.isEmpty());
    }


    public void testEquals() {
        int element_count = 20;
        int[] keys = new int[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_map =
                new TIntObjectHashMap<String>(element_count, 0.5f, Integer.MIN_VALUE);
        for (int i = 0; i < element_count; i++) {
            keys[i] = i + 1;
            vals[i] = Integer.toString(i + 1);
            raw_map.put(keys[i], vals[i]);
        }
        Map<Integer, String> map = TDecorators.wrap(raw_map);
        assertEquals(element_count, map.size());

        TIntObjectHashMap<String> raw_fully_specified =
                new TIntObjectHashMap<String>(20, 0.75f, Integer.MIN_VALUE);
        for (int i = 0; i < element_count; i++) {
            raw_fully_specified.put(keys[i], vals[i]);
        }
        Map<Integer, String> fully_specified = TDecorators.wrap(raw_fully_specified);
        assertEquals(map, fully_specified);

        assertFalse("shouldn't equal random object", map.equals(new Object()));

        assertSame(raw_map, ((TIntObjectMapDecorator) map).getMap());
    }


    @SuppressWarnings({"unchecked"})
    public void testSerialize() throws Exception {
        int element_count = 20;
        int[] keys = new int[element_count];
        String[] vals = new String[element_count];

        TIntObjectMap<String> raw_map = new TIntObjectHashMap<String>();
        for (int i = 0; i < element_count; i++) {
            keys[i] = i + 1;
            vals[i] = Integer.toString(i + 1);
            raw_map.put(keys[i], vals[i]);
        }
        Map<Integer, String> map = TDecorators.wrap(raw_map);

        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(map);

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

        Map<Integer, String> deserialized = (Map<Integer, String>) ois.readObject();

        assertEquals(map, deserialized);
    }


    public void testToString() {
        TIntObjectHashMap<String> raw_map = new TIntObjectHashMap<String>();
        Map<Integer, String> map = TDecorators.wrap(raw_map);
        map.put(11, "One");
        map.put(22, "Two");

        String to_string = map.toString();
        assertTrue(to_string, to_string.equals("{11=One, 22=Two}")
                || to_string.equals("{22=Two, 11=One}"));
    }

    public void testBug3432175() throws Exception {
        Map<Integer, Object> trove = new TIntObjectMapDecorator<Object>(new TIntObjectHashMap<Object>());
        trove.put(null, new Object());
        assertFalse(trove.isEmpty());
        assertEquals(1, trove.size());
        assertEquals(1, trove.entrySet().size());
        assertEquals(1, trove.keySet().size());
        assertEquals(null, trove.keySet().iterator().next());
    }
}