test/tck/ConcurrentHashMapTest.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 * Other contributors include Andrew Wright, Jeffrey Hayes,
 * Pat Fisher, Mike Judd.
 */

import junit.framework.*;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

public class ConcurrentHashMapTest extends JSR166TestCase {
    public static void main(String[] args) {
        junit.textui.TestRunner.run(suite());
    }
    public static Test suite() {
        return new TestSuite(ConcurrentHashMapTest.class);
    }

    /**
     * Returns a new map from Integers 1-5 to Strings "A"-"E".
     */
    private static ConcurrentHashMap map5() {
        ConcurrentHashMap map = new ConcurrentHashMap(5);
        assertTrue(map.isEmpty());
        map.put(one, "A");
        map.put(two, "B");
        map.put(three, "C");
        map.put(four, "D");
        map.put(five, "E");
        assertFalse(map.isEmpty());
        assertEquals(5, map.size());
        return map;
    }

    // classes for testing Comparable fallbacks
    static class BI implements Comparable<BI> {
        private final int value;
        BI(int value) { this.value = value; }
        public int compareTo(BI other) {
            return Integer.compare(value, other.value);
        }
        public boolean equals(Object x) {
            return (x instanceof BI) && ((BI)x).value == value;
        }
        public int hashCode() { return 42; }
    }
    static class CI extends BI { CI(int value) { super(value); } }
    static class DI extends BI { DI(int value) { super(value); } }

    static class BS implements Comparable<BS> {
        private final String value;
        BS(String value) { this.value = value; }
        public int compareTo(BS other) {
            return value.compareTo(other.value);
        }
        public boolean equals(Object x) {
            return (x instanceof BS) && value.equals(((BS)x).value);
        }
        public int hashCode() { return 42; }
    }

    static class LexicographicList<E extends Comparable<E>> extends ArrayList<E>
        implements Comparable<LexicographicList<E>> {
        LexicographicList(Collection<E> c) { super(c); }
        LexicographicList(E e) { super(Collections.singleton(e)); }
        public int compareTo(LexicographicList<E> other) {
            int common = Math.min(size(), other.size());
            int r = 0;
            for (int i = 0; i < common; i++) {
                if ((r = get(i).compareTo(other.get(i))) != 0)
                    break;
            }
            if (r == 0)
                r = Integer.compare(size(), other.size());
            return r;
        }
        private static final long serialVersionUID = 0;
    }

    /**
     * Inserted elements that are subclasses of the same Comparable
     * class are found.
     */
    public void testComparableFamily() {
        ConcurrentHashMap<BI, Boolean> m =
            new ConcurrentHashMap<BI, Boolean>();
        for (int i = 0; i < 1000; i++) {
            assertTrue(m.put(new CI(i), true) == null);
        }
        for (int i = 0; i < 1000; i++) {
            assertTrue(m.containsKey(new CI(i)));
            assertTrue(m.containsKey(new DI(i)));
        }
    }

    /**
     * Elements of classes with erased generic type parameters based
     * on Comparable can be inserted and found.
     */
    public void testGenericComparable() {
        ConcurrentHashMap<Object, Boolean> m =
            new ConcurrentHashMap<Object, Boolean>();
        for (int i = 0; i < 1000; i++) {
            BI bi = new BI(i);
            BS bs = new BS(String.valueOf(i));
            LexicographicList<BI> bis = new LexicographicList<BI>(bi);
            LexicographicList<BS> bss = new LexicographicList<BS>(bs);
            assertTrue(m.putIfAbsent(bis, true) == null);
            assertTrue(m.containsKey(bis));
            if (m.putIfAbsent(bss, true) == null)
                assertTrue(m.containsKey(bss));
            assertTrue(m.containsKey(bis));
        }
        for (int i = 0; i < 1000; i++) {
            assertTrue(m.containsKey(new ArrayList(Collections.singleton(new BI(i)))));
        }
    }

    /**
     * Elements of non-comparable classes equal to those of classes
     * with erased generic type parameters based on Comparable can be
     * inserted and found.
     */
    public void testGenericComparable2() {
        ConcurrentHashMap<Object, Boolean> m =
            new ConcurrentHashMap<Object, Boolean>();
        for (int i = 0; i < 1000; i++) {
            m.put(new ArrayList(Collections.singleton(new BI(i))), true);
        }

        for (int i = 0; i < 1000; i++) {
            LexicographicList<BI> bis = new LexicographicList<BI>(new BI(i));
            assertTrue(m.containsKey(bis));
        }
    }

    /**
     * clear removes all pairs
     */
    public void testClear() {
        ConcurrentHashMap map = map5();
        map.clear();
        assertEquals(0, map.size());
    }

    /**
     * Maps with same contents are equal
     */
    public void testEquals() {
        ConcurrentHashMap map1 = map5();
        ConcurrentHashMap map2 = map5();
        assertEquals(map1, map2);
        assertEquals(map2, map1);
        map1.clear();
        assertFalse(map1.equals(map2));
        assertFalse(map2.equals(map1));
    }

    /**
     * contains returns true for contained value
     */
    public void testContains() {
        ConcurrentHashMap map = map5();
        assertTrue(map.contains("A"));
        assertFalse(map.contains("Z"));
    }

    /**
     * containsKey returns true for contained key
     */
    public void testContainsKey() {
        ConcurrentHashMap map = map5();
        assertTrue(map.containsKey(one));
        assertFalse(map.containsKey(zero));
    }

    /**
     * containsValue returns true for held values
     */
    public void testContainsValue() {
        ConcurrentHashMap map = map5();
        assertTrue(map.containsValue("A"));
        assertFalse(map.containsValue("Z"));
    }

    /**
     * enumeration returns an enumeration containing the correct
     * elements
     */
    public void testEnumeration() {
        ConcurrentHashMap map = map5();
        Enumeration e = map.elements();
        int count = 0;
        while (e.hasMoreElements()) {
            count++;
            e.nextElement();
        }
        assertEquals(5, count);
    }

    /**
     * get returns the correct element at the given key,
     * or null if not present
     */
    public void testGet() {
        ConcurrentHashMap map = map5();
        assertEquals("A", (String)map.get(one));
        ConcurrentHashMap empty = new ConcurrentHashMap();
        assertNull(map.get("anything"));
    }

    /**
     * isEmpty is true of empty map and false for non-empty
     */
    public void testIsEmpty() {
        ConcurrentHashMap empty = new ConcurrentHashMap();
        ConcurrentHashMap map = map5();
        assertTrue(empty.isEmpty());
        assertFalse(map.isEmpty());
    }

    /**
     * keys returns an enumeration containing all the keys from the map
     */
    public void testKeys() {
        ConcurrentHashMap map = map5();
        Enumeration e = map.keys();
        int count = 0;
        while (e.hasMoreElements()) {
            count++;
            e.nextElement();
        }
        assertEquals(5, count);
    }

    /**
     * keySet returns a Set containing all the keys
     */
    public void testKeySet() {
        ConcurrentHashMap map = map5();
        Set s = map.keySet();
        assertEquals(5, s.size());
        assertTrue(s.contains(one));
        assertTrue(s.contains(two));
        assertTrue(s.contains(three));
        assertTrue(s.contains(four));
        assertTrue(s.contains(five));
    }

    /**
     * keySet.toArray returns contains all keys
     */
    public void testKeySetToArray() {
        ConcurrentHashMap map = map5();
        Set s = map.keySet();
        Object[] ar = s.toArray();
        assertTrue(s.containsAll(Arrays.asList(ar)));
        assertEquals(5, ar.length);
        ar[0] = m10;
        assertFalse(s.containsAll(Arrays.asList(ar)));
    }

    /**
     * Values.toArray contains all values
     */
    public void testValuesToArray() {
        ConcurrentHashMap map = map5();
        Collection v = map.values();
        Object[] ar = v.toArray();
        ArrayList s = new ArrayList(Arrays.asList(ar));
        assertEquals(5, ar.length);
        assertTrue(s.contains("A"));
        assertTrue(s.contains("B"));
        assertTrue(s.contains("C"));
        assertTrue(s.contains("D"));
        assertTrue(s.contains("E"));
    }

    /**
     * entrySet.toArray contains all entries
     */
    public void testEntrySetToArray() {
        ConcurrentHashMap map = map5();
        Set s = map.entrySet();
        Object[] ar = s.toArray();
        assertEquals(5, ar.length);
        for (int i = 0; i < 5; ++i) {
            assertTrue(map.containsKey(((Map.Entry)(ar[i])).getKey()));
            assertTrue(map.containsValue(((Map.Entry)(ar[i])).getValue()));
        }
    }

    /**
     * values collection contains all values
     */
    public void testValues() {
        ConcurrentHashMap map = map5();
        Collection s = map.values();
        assertEquals(5, s.size());
        assertTrue(s.contains("A"));
        assertTrue(s.contains("B"));
        assertTrue(s.contains("C"));
        assertTrue(s.contains("D"));
        assertTrue(s.contains("E"));
    }

    /**
     * entrySet contains all pairs
     */
    public void testEntrySet() {
        ConcurrentHashMap map = map5();
        Set s = map.entrySet();
        assertEquals(5, s.size());
        Iterator it = s.iterator();
        while (it.hasNext()) {
            Map.Entry e = (Map.Entry) it.next();
            assertTrue(
                       (e.getKey().equals(one) && e.getValue().equals("A")) ||
                       (e.getKey().equals(two) && e.getValue().equals("B")) ||
                       (e.getKey().equals(three) && e.getValue().equals("C")) ||
                       (e.getKey().equals(four) && e.getValue().equals("D")) ||
                       (e.getKey().equals(five) && e.getValue().equals("E")));
        }
    }

    /**
     * putAll adds all key-value pairs from the given map
     */
    public void testPutAll() {
        ConcurrentHashMap empty = new ConcurrentHashMap();
        ConcurrentHashMap map = map5();
        empty.putAll(map);
        assertEquals(5, empty.size());
        assertTrue(empty.containsKey(one));
        assertTrue(empty.containsKey(two));
        assertTrue(empty.containsKey(three));
        assertTrue(empty.containsKey(four));
        assertTrue(empty.containsKey(five));
    }

    /**
     * putIfAbsent works when the given key is not present
     */
    public void testPutIfAbsent() {
        ConcurrentHashMap map = map5();
        map.putIfAbsent(six, "Z");
        assertTrue(map.containsKey(six));
    }

    /**
     * putIfAbsent does not add the pair if the key is already present
     */
    public void testPutIfAbsent2() {
        ConcurrentHashMap map = map5();
        assertEquals("A", map.putIfAbsent(one, "Z"));
    }

    /**
     * replace fails when the given key is not present
     */
    public void testReplace() {
        ConcurrentHashMap map = map5();
        assertNull(map.replace(six, "Z"));
        assertFalse(map.containsKey(six));
    }

    /**
     * replace succeeds if the key is already present
     */
    public void testReplace2() {
        ConcurrentHashMap map = map5();
        assertNotNull(map.replace(one, "Z"));
        assertEquals("Z", map.get(one));
    }

    /**
     * replace value fails when the given key not mapped to expected value
     */
    public void testReplaceValue() {
        ConcurrentHashMap map = map5();
        assertEquals("A", map.get(one));
        assertFalse(map.replace(one, "Z", "Z"));
        assertEquals("A", map.get(one));
    }

    /**
     * replace value succeeds when the given key mapped to expected value
     */
    public void testReplaceValue2() {
        ConcurrentHashMap map = map5();
        assertEquals("A", map.get(one));
        assertTrue(map.replace(one, "A", "Z"));
        assertEquals("Z", map.get(one));
    }

    /**
     * remove removes the correct key-value pair from the map
     */
    public void testRemove() {
        ConcurrentHashMap map = map5();
        map.remove(five);
        assertEquals(4, map.size());
        assertFalse(map.containsKey(five));
    }

    /**
     * remove(key,value) removes only if pair present
     */
    public void testRemove2() {
        ConcurrentHashMap map = map5();
        map.remove(five, "E");
        assertEquals(4, map.size());
        assertFalse(map.containsKey(five));
        map.remove(four, "A");
        assertEquals(4, map.size());
        assertTrue(map.containsKey(four));
    }

    /**
     * size returns the correct values
     */
    public void testSize() {
        ConcurrentHashMap map = map5();
        ConcurrentHashMap empty = new ConcurrentHashMap();
        assertEquals(0, empty.size());
        assertEquals(5, map.size());
    }

    /**
     * toString contains toString of elements
     */
    public void testToString() {
        ConcurrentHashMap map = map5();
        String s = map.toString();
        for (int i = 1; i <= 5; ++i) {
            assertTrue(s.contains(String.valueOf(i)));
        }
    }

    // Exception tests

    /**
     * Cannot create with negative capacity
     */
    public void testConstructor1() {
        try {
            new ConcurrentHashMap(-1,0,1);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
    }

    /**
     * Cannot create with negative concurrency level
     */
    public void testConstructor2() {
        try {
            new ConcurrentHashMap(1,0,-1);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
    }

    /**
     * Cannot create with only negative capacity
     */
    public void testConstructor3() {
        try {
            new ConcurrentHashMap(-1);
            shouldThrow();
        } catch (IllegalArgumentException success) {}
    }

    /**
     * get(null) throws NPE
     */
    public void testGet_NullPointerException() {
        try {
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.get(null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * containsKey(null) throws NPE
     */
    public void testContainsKey_NullPointerException() {
        try {
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.containsKey(null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * containsValue(null) throws NPE
     */
    public void testContainsValue_NullPointerException() {
        try {
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.containsValue(null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * contains(null) throws NPE
     */
    public void testContains_NullPointerException() {
        try {
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.contains(null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * put(null,x) throws NPE
     */
    public void testPut1_NullPointerException() {
        try {
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.put(null, "whatever");
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * put(x, null) throws NPE
     */
    public void testPut2_NullPointerException() {
        try {
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.put("whatever", null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * putIfAbsent(null, x) throws NPE
     */
    public void testPutIfAbsent1_NullPointerException() {
        try {
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.putIfAbsent(null, "whatever");
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * replace(null, x) throws NPE
     */
    public void testReplace_NullPointerException() {
        try {
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.replace(null, "whatever");
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * replace(null, x, y) throws NPE
     */
    public void testReplaceValue_NullPointerException() {
        try {
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.replace(null, one, "whatever");
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * putIfAbsent(x, null) throws NPE
     */
    public void testPutIfAbsent2_NullPointerException() {
        try {
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.putIfAbsent("whatever", null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * replace(x, null) throws NPE
     */
    public void testReplace2_NullPointerException() {
        try {
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.replace("whatever", null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * replace(x, null, y) throws NPE
     */
    public void testReplaceValue2_NullPointerException() {
        try {
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.replace("whatever", null, "A");
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * replace(x, y, null) throws NPE
     */
    public void testReplaceValue3_NullPointerException() {
        try {
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.replace("whatever", one, null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * remove(null) throws NPE
     */
    public void testRemove1_NullPointerException() {
        try {
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.put("sadsdf", "asdads");
            c.remove(null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * remove(null, x) throws NPE
     */
    public void testRemove2_NullPointerException() {
        try {
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.put("sadsdf", "asdads");
            c.remove(null, "whatever");
            shouldThrow();
        } catch (NullPointerException success) {}
    }

    /**
     * remove(x, null) returns false
     */
    public void testRemove3() {
        ConcurrentHashMap c = new ConcurrentHashMap(5);
        c.put("sadsdf", "asdads");
        assertFalse(c.remove("sadsdf", null));
    }

    /**
     * A deserialized map equals original
     */
    public void testSerialization() throws Exception {
        Map x = map5();
        Map y = serialClone(x);

        assertNotSame(x, y);
        assertEquals(x.size(), y.size());
        assertEquals(x, y);
        assertEquals(y, x);
    }

    /**
     * SetValue of an EntrySet entry sets value in the map.
     */
    public void testSetValueWriteThrough() {
        // Adapted from a bug report by Eric Zoerner
        ConcurrentHashMap map = new ConcurrentHashMap(2, 5.0f, 1);
        assertTrue(map.isEmpty());
        for (int i = 0; i < 20; i++)
            map.put(new Integer(i), new Integer(i));
        assertFalse(map.isEmpty());
        Map.Entry entry1 = (Map.Entry)map.entrySet().iterator().next();
        // Unless it happens to be first (in which case remainder of
        // test is skipped), remove a possibly-colliding key from map
        // which, under some implementations, may cause entry1 to be
        // cloned in map
        if (!entry1.getKey().equals(new Integer(16))) {
            map.remove(new Integer(16));
            entry1.setValue("XYZ");
            assertTrue(map.containsValue("XYZ")); // fails if write-through broken
        }
    }

}
Revision:	1.32
Committed:	Wed Jun 12 18:09:00 2013 UTC (10 years, 11 months ago) by jsr166
Branch:	MAIN
Changes since 1.31:	+6 -3 lines
Log Message:	un-diamond for maximal portability
#	User	Rev	Content
1	dl	1.1	/*
2	dl	1.9	* Written by Doug Lea with assistance from members of JCP JSR-166
3			* Expert Group and released to the public domain, as explained at
4	jsr166	1.23	* http://creativecommons.org/publicdomain/zero/1.0/
5	jsr166	1.14	* Other contributors include Andrew Wright, Jeffrey Hayes,
6			* Pat Fisher, Mike Judd.
7	dl	1.1	*/
8
9			import junit.framework.*;
10			import java.util.*;
11	jsr166	1.25	import java.util.concurrent.ConcurrentHashMap;
12	dl	1.1
13	jsr166	1.16	public class ConcurrentHashMapTest extends JSR166TestCase {
14	dl	1.1	public static void main(String[] args) {
15	jsr166	1.21	junit.textui.TestRunner.run(suite());
16	dl	1.1	}
17			public static Test suite() {
18	jsr166	1.17	return new TestSuite(ConcurrentHashMapTest.class);
19	dl	1.1	}
20
21	dl	1.5	/**
22	jsr166	1.28	* Returns a new map from Integers 1-5 to Strings "A"-"E".
23	dl	1.5	*/
24	jsr166	1.14	private static ConcurrentHashMap map5() {
25	jsr166	1.17	ConcurrentHashMap map = new ConcurrentHashMap(5);
26	dl	1.1	assertTrue(map.isEmpty());
27	jsr166	1.17	map.put(one, "A");
28			map.put(two, "B");
29			map.put(three, "C");
30			map.put(four, "D");
31			map.put(five, "E");
32	dl	1.1	assertFalse(map.isEmpty());
33			assertEquals(5, map.size());
34	jsr166	1.17	return map;
35	dl	1.1	}
36
37	jsr166	1.30	// classes for testing Comparable fallbacks
38			static class BI implements Comparable<BI> {
39			private final int value;
40			BI(int value) { this.value = value; }
41			public int compareTo(BI other) {
42			return Integer.compare(value, other.value);
43			}
44			public boolean equals(Object x) {
45			return (x instanceof BI) && ((BI)x).value == value;
46			}
47			public int hashCode() { return 42; }
48			}
49			static class CI extends BI { CI(int value) { super(value); } }
50			static class DI extends BI { DI(int value) { super(value); } }
51
52			static class BS implements Comparable<BS> {
53			private final String value;
54			BS(String value) { this.value = value; }
55			public int compareTo(BS other) {
56			return value.compareTo(other.value);
57			}
58			public boolean equals(Object x) {
59			return (x instanceof BS) && value.equals(((BS)x).value);
60			}
61			public int hashCode() { return 42; }
62			}
63
64			static class LexicographicList<E extends Comparable<E>> extends ArrayList<E>
65			implements Comparable<LexicographicList<E>> {
66			LexicographicList(Collection<E> c) { super(c); }
67			LexicographicList(E e) { super(Collections.singleton(e)); }
68			public int compareTo(LexicographicList<E> other) {
69			int common = Math.min(size(), other.size());
70			int r = 0;
71			for (int i = 0; i < common; i++) {
72			if ((r = get(i).compareTo(other.get(i))) != 0)
73			break;
74			}
75			if (r == 0)
76			r = Integer.compare(size(), other.size());
77			return r;
78			}
79			private static final long serialVersionUID = 0;
80			}
81
82			/**
83			* Inserted elements that are subclasses of the same Comparable
84			* class are found.
85			*/
86			public void testComparableFamily() {
87	jsr166	1.32	ConcurrentHashMap<BI, Boolean> m =
88			new ConcurrentHashMap<BI, Boolean>();
89	jsr166	1.30	for (int i = 0; i < 1000; i++) {
90			assertTrue(m.put(new CI(i), true) == null);
91			}
92			for (int i = 0; i < 1000; i++) {
93			assertTrue(m.containsKey(new CI(i)));
94			assertTrue(m.containsKey(new DI(i)));
95			}
96			}
97
98			/**
99			* Elements of classes with erased generic type parameters based
100			* on Comparable can be inserted and found.
101			*/
102			public void testGenericComparable() {
103	jsr166	1.32	ConcurrentHashMap<Object, Boolean> m =
104			new ConcurrentHashMap<Object, Boolean>();
105	jsr166	1.30	for (int i = 0; i < 1000; i++) {
106			BI bi = new BI(i);
107			BS bs = new BS(String.valueOf(i));
108			LexicographicList<BI> bis = new LexicographicList<BI>(bi);
109			LexicographicList<BS> bss = new LexicographicList<BS>(bs);
110			assertTrue(m.putIfAbsent(bis, true) == null);
111			assertTrue(m.containsKey(bis));
112			if (m.putIfAbsent(bss, true) == null)
113			assertTrue(m.containsKey(bss));
114			assertTrue(m.containsKey(bis));
115			}
116			for (int i = 0; i < 1000; i++) {
117			assertTrue(m.containsKey(new ArrayList(Collections.singleton(new BI(i)))));
118			}
119			}
120
121			/**
122			* Elements of non-comparable classes equal to those of classes
123			* with erased generic type parameters based on Comparable can be
124			* inserted and found.
125			*/
126			public void testGenericComparable2() {
127	jsr166	1.32	ConcurrentHashMap<Object, Boolean> m =
128			new ConcurrentHashMap<Object, Boolean>();
129	jsr166	1.30	for (int i = 0; i < 1000; i++) {
130			m.put(new ArrayList(Collections.singleton(new BI(i))), true);
131			}
132
133			for (int i = 0; i < 1000; i++) {
134			LexicographicList<BI> bis = new LexicographicList<BI>(new BI(i));
135			assertTrue(m.containsKey(bis));
136			}
137			}
138
139	dl	1.1	/**
140	jsr166	1.22	* clear removes all pairs
141	dl	1.1	*/
142	dl	1.5	public void testClear() {
143	dl	1.1	ConcurrentHashMap map = map5();
144	jsr166	1.17	map.clear();
145	jsr166	1.26	assertEquals(0, map.size());
146	dl	1.1	}
147
148			/**
149	jsr166	1.22	* Maps with same contents are equal
150	dl	1.5	*/
151			public void testEquals() {
152			ConcurrentHashMap map1 = map5();
153			ConcurrentHashMap map2 = map5();
154			assertEquals(map1, map2);
155			assertEquals(map2, map1);
156	jsr166	1.17	map1.clear();
157	dl	1.5	assertFalse(map1.equals(map2));
158			assertFalse(map2.equals(map1));
159			}
160
161			/**
162	jsr166	1.22	* contains returns true for contained value
163	dl	1.1	*/
164	dl	1.5	public void testContains() {
165	dl	1.1	ConcurrentHashMap map = map5();
166	jsr166	1.17	assertTrue(map.contains("A"));
167	dl	1.1	assertFalse(map.contains("Z"));
168			}
169	jsr166	1.14
170	dl	1.1	/**
171	jsr166	1.22	* containsKey returns true for contained key
172	dl	1.1	*/
173	dl	1.5	public void testContainsKey() {
174	dl	1.1	ConcurrentHashMap map = map5();
175	jsr166	1.17	assertTrue(map.containsKey(one));
176	dl	1.5	assertFalse(map.containsKey(zero));
177	dl	1.1	}
178
179			/**
180	jsr166	1.22	* containsValue returns true for held values
181	dl	1.1	*/
182	dl	1.5	public void testContainsValue() {
183	dl	1.1	ConcurrentHashMap map = map5();
184	jsr166	1.17	assertTrue(map.containsValue("A"));
185	dl	1.11	assertFalse(map.containsValue("Z"));
186	dl	1.1	}
187
188			/**
189	jsr166	1.22	* enumeration returns an enumeration containing the correct
190			* elements
191	dl	1.1	*/
192	dl	1.5	public void testEnumeration() {
193	dl	1.1	ConcurrentHashMap map = map5();
194	jsr166	1.17	Enumeration e = map.elements();
195			int count = 0;
196			while (e.hasMoreElements()) {
197			count++;
198			e.nextElement();
199			}
200			assertEquals(5, count);
201	dl	1.4	}
202
203			/**
204	jsr166	1.22	* get returns the correct element at the given key,
205			* or null if not present
206	dl	1.1	*/
207	dl	1.5	public void testGet() {
208	dl	1.1	ConcurrentHashMap map = map5();
209	jsr166	1.17	assertEquals("A", (String)map.get(one));
210	dl	1.1	ConcurrentHashMap empty = new ConcurrentHashMap();
211	dl	1.5	assertNull(map.get("anything"));
212	dl	1.1	}
213
214			/**
215	jsr166	1.22	* isEmpty is true of empty map and false for non-empty
216	dl	1.1	*/
217	dl	1.5	public void testIsEmpty() {
218	dl	1.1	ConcurrentHashMap empty = new ConcurrentHashMap();
219			ConcurrentHashMap map = map5();
220	jsr166	1.17	assertTrue(empty.isEmpty());
221	dl	1.1	assertFalse(map.isEmpty());
222			}
223
224			/**
225	jsr166	1.22	* keys returns an enumeration containing all the keys from the map
226	dl	1.1	*/
227	dl	1.5	public void testKeys() {
228	dl	1.1	ConcurrentHashMap map = map5();
229	jsr166	1.17	Enumeration e = map.keys();
230			int count = 0;
231			while (e.hasMoreElements()) {
232			count++;
233			e.nextElement();
234			}
235			assertEquals(5, count);
236	dl	1.1	}
237
238			/**
239	jsr166	1.22	* keySet returns a Set containing all the keys
240	dl	1.1	*/
241	dl	1.5	public void testKeySet() {
242	dl	1.1	ConcurrentHashMap map = map5();
243	jsr166	1.17	Set s = map.keySet();
244			assertEquals(5, s.size());
245			assertTrue(s.contains(one));
246			assertTrue(s.contains(two));
247			assertTrue(s.contains(three));
248			assertTrue(s.contains(four));
249			assertTrue(s.contains(five));
250	dl	1.1	}
251
252	dl	1.5	/**
253	jsr166	1.22	* keySet.toArray returns contains all keys
254	dl	1.13	*/
255			public void testKeySetToArray() {
256			ConcurrentHashMap map = map5();
257	jsr166	1.17	Set s = map.keySet();
258	dl	1.13	Object[] ar = s.toArray();
259			assertTrue(s.containsAll(Arrays.asList(ar)));
260	jsr166	1.17	assertEquals(5, ar.length);
261	dl	1.13	ar[0] = m10;
262			assertFalse(s.containsAll(Arrays.asList(ar)));
263			}
264
265			/**
266	jsr166	1.22	* Values.toArray contains all values
267	dl	1.13	*/
268			public void testValuesToArray() {
269			ConcurrentHashMap map = map5();
270	jsr166	1.17	Collection v = map.values();
271	dl	1.13	Object[] ar = v.toArray();
272			ArrayList s = new ArrayList(Arrays.asList(ar));
273	jsr166	1.17	assertEquals(5, ar.length);
274			assertTrue(s.contains("A"));
275			assertTrue(s.contains("B"));
276			assertTrue(s.contains("C"));
277			assertTrue(s.contains("D"));
278			assertTrue(s.contains("E"));
279	dl	1.13	}
280
281			/**
282	jsr166	1.22	* entrySet.toArray contains all entries
283	dl	1.13	*/
284			public void testEntrySetToArray() {
285			ConcurrentHashMap map = map5();
286	jsr166	1.17	Set s = map.entrySet();
287	dl	1.13	Object[] ar = s.toArray();
288			assertEquals(5, ar.length);
289			for (int i = 0; i < 5; ++i) {
290			assertTrue(map.containsKey(((Map.Entry)(ar[i])).getKey()));
291			assertTrue(map.containsValue(((Map.Entry)(ar[i])).getValue()));
292			}
293			}
294
295			/**
296	dl	1.5	* values collection contains all values
297			*/
298			public void testValues() {
299	dl	1.1	ConcurrentHashMap map = map5();
300	jsr166	1.17	Collection s = map.values();
301			assertEquals(5, s.size());
302			assertTrue(s.contains("A"));
303			assertTrue(s.contains("B"));
304			assertTrue(s.contains("C"));
305			assertTrue(s.contains("D"));
306			assertTrue(s.contains("E"));
307	dl	1.1	}
308
309	dl	1.5	/**
310			* entrySet contains all pairs
311			*/
312			public void testEntrySet() {
313	dl	1.1	ConcurrentHashMap map = map5();
314	jsr166	1.17	Set s = map.entrySet();
315			assertEquals(5, s.size());
316	dl	1.1	Iterator it = s.iterator();
317			while (it.hasNext()) {
318			Map.Entry e = (Map.Entry) it.next();
319	jsr166	1.14	assertTrue(
320	dl	1.1	(e.getKey().equals(one) && e.getValue().equals("A")) \|\|
321			(e.getKey().equals(two) && e.getValue().equals("B")) \|\|
322			(e.getKey().equals(three) && e.getValue().equals("C")) \|\|
323			(e.getKey().equals(four) && e.getValue().equals("D")) \|\|
324			(e.getKey().equals(five) && e.getValue().equals("E")));
325			}
326			}
327
328			/**
329	jsr166	1.22	* putAll adds all key-value pairs from the given map
330	dl	1.1	*/
331	dl	1.5	public void testPutAll() {
332	dl	1.1	ConcurrentHashMap empty = new ConcurrentHashMap();
333			ConcurrentHashMap map = map5();
334	jsr166	1.17	empty.putAll(map);
335			assertEquals(5, empty.size());
336			assertTrue(empty.containsKey(one));
337			assertTrue(empty.containsKey(two));
338			assertTrue(empty.containsKey(three));
339			assertTrue(empty.containsKey(four));
340			assertTrue(empty.containsKey(five));
341	dl	1.1	}
342
343			/**
344	jsr166	1.22	* putIfAbsent works when the given key is not present
345	dl	1.1	*/
346	dl	1.5	public void testPutIfAbsent() {
347	dl	1.1	ConcurrentHashMap map = map5();
348	jsr166	1.17	map.putIfAbsent(six, "Z");
349	dl	1.7	assertTrue(map.containsKey(six));
350	dl	1.1	}
351
352			/**
353	jsr166	1.22	* putIfAbsent does not add the pair if the key is already present
354	dl	1.1	*/
355	dl	1.5	public void testPutIfAbsent2() {
356	dl	1.1	ConcurrentHashMap map = map5();
357			assertEquals("A", map.putIfAbsent(one, "Z"));
358			}
359
360			/**
361	jsr166	1.22	* replace fails when the given key is not present
362	dl	1.7	*/
363			public void testReplace() {
364			ConcurrentHashMap map = map5();
365	jsr166	1.17	assertNull(map.replace(six, "Z"));
366	dl	1.7	assertFalse(map.containsKey(six));
367			}
368
369			/**
370	jsr166	1.22	* replace succeeds if the key is already present
371	dl	1.7	*/
372			public void testReplace2() {
373			ConcurrentHashMap map = map5();
374	dl	1.8	assertNotNull(map.replace(one, "Z"));
375	dl	1.7	assertEquals("Z", map.get(one));
376			}
377
378			/**
379			* replace value fails when the given key not mapped to expected value
380			*/
381			public void testReplaceValue() {
382			ConcurrentHashMap map = map5();
383			assertEquals("A", map.get(one));
384	jsr166	1.17	assertFalse(map.replace(one, "Z", "Z"));
385	dl	1.7	assertEquals("A", map.get(one));
386			}
387
388			/**
389			* replace value succeeds when the given key mapped to expected value
390			*/
391			public void testReplaceValue2() {
392			ConcurrentHashMap map = map5();
393			assertEquals("A", map.get(one));
394	jsr166	1.17	assertTrue(map.replace(one, "A", "Z"));
395	dl	1.7	assertEquals("Z", map.get(one));
396			}
397
398			/**
399	jsr166	1.22	* remove removes the correct key-value pair from the map
400	dl	1.1	*/
401	dl	1.5	public void testRemove() {
402	dl	1.1	ConcurrentHashMap map = map5();
403	jsr166	1.17	map.remove(five);
404			assertEquals(4, map.size());
405			assertFalse(map.containsKey(five));
406	dl	1.1	}
407
408	dl	1.5	/**
409			* remove(key,value) removes only if pair present
410			*/
411			public void testRemove2() {
412	dl	1.1	ConcurrentHashMap map = map5();
413	jsr166	1.17	map.remove(five, "E");
414			assertEquals(4, map.size());
415			assertFalse(map.containsKey(five));
416			map.remove(four, "A");
417			assertEquals(4, map.size());
418			assertTrue(map.containsKey(four));
419	dl	1.1	}
420
421			/**
422	jsr166	1.22	* size returns the correct values
423	dl	1.1	*/
424	dl	1.5	public void testSize() {
425	dl	1.1	ConcurrentHashMap map = map5();
426			ConcurrentHashMap empty = new ConcurrentHashMap();
427	jsr166	1.17	assertEquals(0, empty.size());
428			assertEquals(5, map.size());
429	dl	1.1	}
430
431	dl	1.5	/**
432			* toString contains toString of elements
433			*/
434			public void testToString() {
435	dl	1.1	ConcurrentHashMap map = map5();
436			String s = map.toString();
437			for (int i = 1; i <= 5; ++i) {
438	jsr166	1.24	assertTrue(s.contains(String.valueOf(i)));
439	dl	1.1	}
440	jsr166	1.14	}
441	dl	1.1
442			// Exception tests
443	jsr166	1.14
444	dl	1.5	/**
445	jsr166	1.14	* Cannot create with negative capacity
446	dl	1.5	*/
447			public void testConstructor1() {
448			try {
449	dl	1.1	new ConcurrentHashMap(-1,0,1);
450	dl	1.5	shouldThrow();
451	jsr166	1.19	} catch (IllegalArgumentException success) {}
452	dl	1.1	}
453
454	dl	1.5	/**
455			* Cannot create with negative concurrency level
456			*/
457			public void testConstructor2() {
458			try {
459	dl	1.1	new ConcurrentHashMap(1,0,-1);
460	dl	1.5	shouldThrow();
461	jsr166	1.19	} catch (IllegalArgumentException success) {}
462	dl	1.1	}
463
464	dl	1.5	/**
465			* Cannot create with only negative capacity
466			*/
467			public void testConstructor3() {
468			try {
469	dl	1.1	new ConcurrentHashMap(-1);
470	dl	1.5	shouldThrow();
471	jsr166	1.19	} catch (IllegalArgumentException success) {}
472	dl	1.1	}
473
474	dl	1.5	/**
475			* get(null) throws NPE
476			*/
477			public void testGet_NullPointerException() {
478			try {
479	dl	1.1	ConcurrentHashMap c = new ConcurrentHashMap(5);
480			c.get(null);
481	dl	1.5	shouldThrow();
482	jsr166	1.19	} catch (NullPointerException success) {}
483	dl	1.1	}
484
485	dl	1.5	/**
486			* containsKey(null) throws NPE
487			*/
488			public void testContainsKey_NullPointerException() {
489			try {
490	dl	1.1	ConcurrentHashMap c = new ConcurrentHashMap(5);
491			c.containsKey(null);
492	dl	1.5	shouldThrow();
493	jsr166	1.19	} catch (NullPointerException success) {}
494	dl	1.1	}
495
496	dl	1.5	/**
497			* containsValue(null) throws NPE
498			*/
499			public void testContainsValue_NullPointerException() {
500			try {
501	dl	1.1	ConcurrentHashMap c = new ConcurrentHashMap(5);
502			c.containsValue(null);
503	dl	1.5	shouldThrow();
504	jsr166	1.19	} catch (NullPointerException success) {}
505	dl	1.1	}
506
507	dl	1.5	/**
508			* contains(null) throws NPE
509			*/
510			public void testContains_NullPointerException() {
511			try {
512	dl	1.1	ConcurrentHashMap c = new ConcurrentHashMap(5);
513			c.contains(null);
514	dl	1.5	shouldThrow();
515	jsr166	1.19	} catch (NullPointerException success) {}
516	dl	1.1	}
517
518	dl	1.5	/**
519			* put(null,x) throws NPE
520			*/
521			public void testPut1_NullPointerException() {
522			try {
523	dl	1.1	ConcurrentHashMap c = new ConcurrentHashMap(5);
524			c.put(null, "whatever");
525	dl	1.5	shouldThrow();
526	jsr166	1.19	} catch (NullPointerException success) {}
527	dl	1.1	}
528
529	dl	1.5	/**
530			* put(x, null) throws NPE
531			*/
532			public void testPut2_NullPointerException() {
533			try {
534	dl	1.1	ConcurrentHashMap c = new ConcurrentHashMap(5);
535			c.put("whatever", null);
536	dl	1.5	shouldThrow();
537	jsr166	1.19	} catch (NullPointerException success) {}
538	dl	1.1	}
539
540	dl	1.5	/**
541			* putIfAbsent(null, x) throws NPE
542			*/
543			public void testPutIfAbsent1_NullPointerException() {
544			try {
545	dl	1.1	ConcurrentHashMap c = new ConcurrentHashMap(5);
546			c.putIfAbsent(null, "whatever");
547	dl	1.5	shouldThrow();
548	jsr166	1.19	} catch (NullPointerException success) {}
549	dl	1.1	}
550
551	dl	1.5	/**
552	dl	1.7	* replace(null, x) throws NPE
553			*/
554			public void testReplace_NullPointerException() {
555			try {
556			ConcurrentHashMap c = new ConcurrentHashMap(5);
557			c.replace(null, "whatever");
558			shouldThrow();
559	jsr166	1.19	} catch (NullPointerException success) {}
560	dl	1.7	}
561
562			/**
563			* replace(null, x, y) throws NPE
564			*/
565			public void testReplaceValue_NullPointerException() {
566			try {
567			ConcurrentHashMap c = new ConcurrentHashMap(5);
568			c.replace(null, one, "whatever");
569			shouldThrow();
570	jsr166	1.19	} catch (NullPointerException success) {}
571	dl	1.7	}
572
573			/**
574	dl	1.5	* putIfAbsent(x, null) throws NPE
575			*/
576			public void testPutIfAbsent2_NullPointerException() {
577			try {
578	dl	1.1	ConcurrentHashMap c = new ConcurrentHashMap(5);
579			c.putIfAbsent("whatever", null);
580	dl	1.7	shouldThrow();
581	jsr166	1.19	} catch (NullPointerException success) {}
582	dl	1.7	}
583
584			/**
585			* replace(x, null) throws NPE
586			*/
587			public void testReplace2_NullPointerException() {
588			try {
589			ConcurrentHashMap c = new ConcurrentHashMap(5);
590			c.replace("whatever", null);
591			shouldThrow();
592	jsr166	1.19	} catch (NullPointerException success) {}
593	dl	1.7	}
594
595			/**
596			* replace(x, null, y) throws NPE
597			*/
598			public void testReplaceValue2_NullPointerException() {
599			try {
600			ConcurrentHashMap c = new ConcurrentHashMap(5);
601			c.replace("whatever", null, "A");
602			shouldThrow();
603	jsr166	1.19	} catch (NullPointerException success) {}
604	dl	1.7	}
605
606			/**
607			* replace(x, y, null) throws NPE
608			*/
609			public void testReplaceValue3_NullPointerException() {
610			try {
611			ConcurrentHashMap c = new ConcurrentHashMap(5);
612			c.replace("whatever", one, null);
613	dl	1.5	shouldThrow();
614	jsr166	1.19	} catch (NullPointerException success) {}
615	dl	1.1	}
616
617	dl	1.5	/**
618			* remove(null) throws NPE
619			*/
620			public void testRemove1_NullPointerException() {
621			try {
622	dl	1.1	ConcurrentHashMap c = new ConcurrentHashMap(5);
623			c.put("sadsdf", "asdads");
624			c.remove(null);
625	dl	1.5	shouldThrow();
626	jsr166	1.19	} catch (NullPointerException success) {}
627	dl	1.1	}
628
629	dl	1.5	/**
630			* remove(null, x) throws NPE
631			*/
632			public void testRemove2_NullPointerException() {
633			try {
634	dl	1.1	ConcurrentHashMap c = new ConcurrentHashMap(5);
635			c.put("sadsdf", "asdads");
636			c.remove(null, "whatever");
637	dl	1.5	shouldThrow();
638	jsr166	1.19	} catch (NullPointerException success) {}
639	dl	1.1	}
640	dl	1.2
641	dl	1.5	/**
642	dl	1.12	* remove(x, null) returns false
643			*/
644			public void testRemove3() {
645	jsr166	1.19	ConcurrentHashMap c = new ConcurrentHashMap(5);
646			c.put("sadsdf", "asdads");
647			assertFalse(c.remove("sadsdf", null));
648	dl	1.12	}
649
650			/**
651	dl	1.5	* A deserialized map equals original
652			*/
653	jsr166	1.18	public void testSerialization() throws Exception {
654	jsr166	1.25	Map x = map5();
655			Map y = serialClone(x);
656	dl	1.2
657	jsr166	1.31	assertNotSame(x, y);
658	jsr166	1.25	assertEquals(x.size(), y.size());
659			assertEquals(x, y);
660			assertEquals(y, x);
661	dl	1.2	}
662	dl	1.6
663			/**
664			* SetValue of an EntrySet entry sets value in the map.
665			*/
666			public void testSetValueWriteThrough() {
667	jsr166	1.14	// Adapted from a bug report by Eric Zoerner
668	dl	1.6	ConcurrentHashMap map = new ConcurrentHashMap(2, 5.0f, 1);
669			assertTrue(map.isEmpty());
670			for (int i = 0; i < 20; i++)
671			map.put(new Integer(i), new Integer(i));
672			assertFalse(map.isEmpty());
673			Map.Entry entry1 = (Map.Entry)map.entrySet().iterator().next();
674	dl	1.29	// Unless it happens to be first (in which case remainder of
675			// test is skipped), remove a possibly-colliding key from map
676			// which, under some implementations, may cause entry1 to be
677			// cloned in map
678			if (!entry1.getKey().equals(new Integer(16))) {
679			map.remove(new Integer(16));
680			entry1.setValue("XYZ");
681			assertTrue(map.containsValue("XYZ")); // fails if write-through broken
682			}
683	dl	1.6	}
684	jsr166	1.14
685	dl	1.1	}