test/tck/ConcurrentHashMapTest.java

/*
 * Written by members of JCP JSR-166 Expert Group and released to the
 * public domain. Use, modify, and redistribute this code in any way
 * without acknowledgement. Other contributors include Andrew Wright,
 * Jeffrey Hayes, Pat Fischer, Mike Judd.
 */

import junit.framework.*;
import java.util.*;
import java.util.concurrent.*;
import java.util.Enumeration;
import java.io.*;

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);
    }

    /**
     * Create a 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;
    }

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

    /**
     *  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.contains("A"));
        assertFalse(map.contains("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);
    }

    /**
     *   Clone creates an equal map
     */
    public void testClone() {
        ConcurrentHashMap map = map5();
        ConcurrentHashMap m2 = (ConcurrentHashMap)(map.clone());
        assertEquals(map, m2);
    }

    /**
     *  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));
    }

    /**
     * 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.indexOf(String.valueOf(i)) >= 0);
        }
    }        

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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


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

    /**
     * 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 e){}
    }

    /**
     * A deserialized map equals original
     */
    public void testSerialization() {
        ConcurrentHashMap q = map5();

        try {
            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
            out.writeObject(q);
            out.close();

            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
            ConcurrentHashMap r = (ConcurrentHashMap)in.readObject();
            assertEquals(q.size(), r.size());
            assertTrue(q.equals(r));
            assertTrue(r.equals(q));
        } catch(Exception e){
            e.printStackTrace();
            unexpectedException();
        }
    }


    /**
     * 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();
        
        // assert that entry1 is not 16
        assertTrue("entry is 16, test not valid",
                   !entry1.getKey().equals(new Integer(16)));
        
        // remove 16 (a different key) from map 
        // which just happens to cause entry1 to be cloned in map
        map.remove(new Integer(16));
        entry1.setValue("XYZ");
        assertTrue(map.containsValue("XYZ")); // fails
    }
    
}
Revision:	1.8
Committed:	Sat Dec 6 00:22:26 2003 UTC (20 years, 5 months ago) by dl
Branch:	MAIN
CVS Tags:	JSR166_DEC9_PRE_ES_SUBMIT, JSR166_DEC9_POST_ES_SUBMIT
Changes since 1.7:	+2 -2 lines
Log Message:	replace returns old value
#	User	Rev	Content
1	dl	1.1	/*
2			* Written by members of JCP JSR-166 Expert Group and released to the
3			* public domain. Use, modify, and redistribute this code in any way
4			* without acknowledgement. Other contributors include Andrew Wright,
5			* Jeffrey Hayes, Pat Fischer, Mike Judd.
6			*/
7
8			import junit.framework.*;
9			import java.util.*;
10			import java.util.concurrent.*;
11			import java.util.Enumeration;
12	dl	1.2	import java.io.*;
13	dl	1.1
14	dl	1.3	public class ConcurrentHashMapTest extends JSR166TestCase{
15	dl	1.1	public static void main(String[] args) {
16			junit.textui.TestRunner.run (suite());
17			}
18			public static Test suite() {
19			return new TestSuite(ConcurrentHashMapTest.class);
20			}
21
22	dl	1.5	/**
23			* Create a map from Integers 1-5 to Strings "A"-"E".
24			*/
25	dl	1.1	private static ConcurrentHashMap map5() {
26			ConcurrentHashMap map = new ConcurrentHashMap(5);
27			assertTrue(map.isEmpty());
28			map.put(one, "A");
29			map.put(two, "B");
30			map.put(three, "C");
31			map.put(four, "D");
32			map.put(five, "E");
33			assertFalse(map.isEmpty());
34			assertEquals(5, map.size());
35			return map;
36			}
37
38			/**
39	dl	1.5	* clear removes all pairs
40	dl	1.1	*/
41	dl	1.5	public void testClear() {
42	dl	1.1	ConcurrentHashMap map = map5();
43			map.clear();
44			assertEquals(map.size(), 0);
45			}
46
47			/**
48	dl	1.5	* Maps with same contents are equal
49			*/
50			public void testEquals() {
51			ConcurrentHashMap map1 = map5();
52			ConcurrentHashMap map2 = map5();
53			assertEquals(map1, map2);
54			assertEquals(map2, map1);
55			map1.clear();
56			assertFalse(map1.equals(map2));
57			assertFalse(map2.equals(map1));
58			}
59
60			/**
61			* contains returns true for contained value
62	dl	1.1	*/
63	dl	1.5	public void testContains() {
64	dl	1.1	ConcurrentHashMap map = map5();
65			assertTrue(map.contains("A"));
66			assertFalse(map.contains("Z"));
67			}
68
69			/**
70	dl	1.5	* containsKey returns true for contained key
71	dl	1.1	*/
72	dl	1.5	public void testContainsKey() {
73	dl	1.1	ConcurrentHashMap map = map5();
74			assertTrue(map.containsKey(one));
75	dl	1.5	assertFalse(map.containsKey(zero));
76	dl	1.1	}
77
78			/**
79	dl	1.5	* containsValue returns true for held values
80	dl	1.1	*/
81	dl	1.5	public void testContainsValue() {
82	dl	1.1	ConcurrentHashMap map = map5();
83			assertTrue(map.contains("A"));
84			assertFalse(map.contains("Z"));
85			}
86
87			/**
88	dl	1.4	* enumeration returns an enumeration containing the correct
89			* elements
90	dl	1.1	*/
91	dl	1.5	public void testEnumeration() {
92	dl	1.1	ConcurrentHashMap map = map5();
93			Enumeration e = map.elements();
94			int count = 0;
95			while(e.hasMoreElements()){
96			count++;
97			e.nextElement();
98			}
99			assertEquals(5, count);
100	dl	1.4	}
101
102			/**
103			* Clone creates an equal map
104			*/
105	dl	1.5	public void testClone() {
106	dl	1.4	ConcurrentHashMap map = map5();
107			ConcurrentHashMap m2 = (ConcurrentHashMap)(map.clone());
108			assertEquals(map, m2);
109	dl	1.1	}
110
111			/**
112	dl	1.5	* get returns the correct element at the given key,
113			* or null if not present
114	dl	1.1	*/
115	dl	1.5	public void testGet() {
116	dl	1.1	ConcurrentHashMap map = map5();
117			assertEquals("A", (String)map.get(one));
118			ConcurrentHashMap empty = new ConcurrentHashMap();
119	dl	1.5	assertNull(map.get("anything"));
120	dl	1.1	}
121
122			/**
123	dl	1.5	* isEmpty is true of empty map and false for non-empty
124	dl	1.1	*/
125	dl	1.5	public void testIsEmpty() {
126	dl	1.1	ConcurrentHashMap empty = new ConcurrentHashMap();
127			ConcurrentHashMap map = map5();
128			assertTrue(empty.isEmpty());
129			assertFalse(map.isEmpty());
130			}
131
132			/**
133	dl	1.3	* keys returns an enumeration containing all the keys from the map
134	dl	1.1	*/
135	dl	1.5	public void testKeys() {
136	dl	1.1	ConcurrentHashMap map = map5();
137			Enumeration e = map.keys();
138			int count = 0;
139			while(e.hasMoreElements()){
140			count++;
141			e.nextElement();
142			}
143			assertEquals(5, count);
144			}
145
146			/**
147	dl	1.3	* keySet returns a Set containing all the keys
148	dl	1.1	*/
149	dl	1.5	public void testKeySet() {
150	dl	1.1	ConcurrentHashMap map = map5();
151			Set s = map.keySet();
152			assertEquals(5, s.size());
153			assertTrue(s.contains(one));
154			assertTrue(s.contains(two));
155			assertTrue(s.contains(three));
156			assertTrue(s.contains(four));
157			assertTrue(s.contains(five));
158			}
159
160	dl	1.5	/**
161			* values collection contains all values
162			*/
163			public void testValues() {
164	dl	1.1	ConcurrentHashMap map = map5();
165			Collection s = map.values();
166			assertEquals(5, s.size());
167			assertTrue(s.contains("A"));
168			assertTrue(s.contains("B"));
169			assertTrue(s.contains("C"));
170			assertTrue(s.contains("D"));
171			assertTrue(s.contains("E"));
172			}
173
174	dl	1.5	/**
175			* entrySet contains all pairs
176			*/
177			public void testEntrySet() {
178	dl	1.1	ConcurrentHashMap map = map5();
179			Set s = map.entrySet();
180			assertEquals(5, s.size());
181			Iterator it = s.iterator();
182			while (it.hasNext()) {
183			Map.Entry e = (Map.Entry) it.next();
184			assertTrue(
185			(e.getKey().equals(one) && e.getValue().equals("A")) \|\|
186			(e.getKey().equals(two) && e.getValue().equals("B")) \|\|
187			(e.getKey().equals(three) && e.getValue().equals("C")) \|\|
188			(e.getKey().equals(four) && e.getValue().equals("D")) \|\|
189			(e.getKey().equals(five) && e.getValue().equals("E")));
190			}
191			}
192
193			/**
194	dl	1.3	* putAll adds all key-value pairs from the given map
195	dl	1.1	*/
196	dl	1.5	public void testPutAll() {
197	dl	1.1	ConcurrentHashMap empty = new ConcurrentHashMap();
198			ConcurrentHashMap map = map5();
199			empty.putAll(map);
200			assertEquals(5, empty.size());
201			assertTrue(empty.containsKey(one));
202			assertTrue(empty.containsKey(two));
203			assertTrue(empty.containsKey(three));
204			assertTrue(empty.containsKey(four));
205			assertTrue(empty.containsKey(five));
206			}
207
208			/**
209	dl	1.3	* putIfAbsent works when the given key is not present
210	dl	1.1	*/
211	dl	1.5	public void testPutIfAbsent() {
212	dl	1.1	ConcurrentHashMap map = map5();
213	dl	1.7	map.putIfAbsent(six, "Z");
214			assertTrue(map.containsKey(six));
215	dl	1.1	}
216
217			/**
218	dl	1.3	* putIfAbsent does not add the pair if the key is already present
219	dl	1.1	*/
220	dl	1.5	public void testPutIfAbsent2() {
221	dl	1.1	ConcurrentHashMap map = map5();
222			assertEquals("A", map.putIfAbsent(one, "Z"));
223			}
224
225			/**
226	dl	1.7	* replace fails when the given key is not present
227			*/
228			public void testReplace() {
229			ConcurrentHashMap map = map5();
230	dl	1.8	assertNull(map.replace(six, "Z"));
231	dl	1.7	assertFalse(map.containsKey(six));
232			}
233
234			/**
235			* replace succeeds if the key is already present
236			*/
237			public void testReplace2() {
238			ConcurrentHashMap map = map5();
239	dl	1.8	assertNotNull(map.replace(one, "Z"));
240	dl	1.7	assertEquals("Z", map.get(one));
241			}
242
243
244			/**
245			* replace value fails when the given key not mapped to expected value
246			*/
247			public void testReplaceValue() {
248			ConcurrentHashMap map = map5();
249			assertEquals("A", map.get(one));
250			assertFalse(map.replace(one, "Z", "Z"));
251			assertEquals("A", map.get(one));
252			}
253
254			/**
255			* replace value succeeds when the given key mapped to expected value
256			*/
257			public void testReplaceValue2() {
258			ConcurrentHashMap map = map5();
259			assertEquals("A", map.get(one));
260			assertTrue(map.replace(one, "A", "Z"));
261			assertEquals("Z", map.get(one));
262			}
263
264
265			/**
266	dl	1.3	* remove removes the correct key-value pair from the map
267	dl	1.1	*/
268	dl	1.5	public void testRemove() {
269	dl	1.1	ConcurrentHashMap map = map5();
270			map.remove(five);
271			assertEquals(4, map.size());
272			assertFalse(map.containsKey(five));
273			}
274
275	dl	1.5	/**
276			* remove(key,value) removes only if pair present
277			*/
278			public void testRemove2() {
279	dl	1.1	ConcurrentHashMap map = map5();
280			map.remove(five, "E");
281			assertEquals(4, map.size());
282			assertFalse(map.containsKey(five));
283			map.remove(four, "A");
284			assertEquals(4, map.size());
285			assertTrue(map.containsKey(four));
286
287			}
288
289			/**
290	dl	1.3	* size returns the correct values
291	dl	1.1	*/
292	dl	1.5	public void testSize() {
293	dl	1.1	ConcurrentHashMap map = map5();
294			ConcurrentHashMap empty = new ConcurrentHashMap();
295			assertEquals(0, empty.size());
296			assertEquals(5, map.size());
297			}
298
299	dl	1.5	/**
300			* toString contains toString of elements
301			*/
302			public void testToString() {
303	dl	1.1	ConcurrentHashMap map = map5();
304			String s = map.toString();
305			for (int i = 1; i <= 5; ++i) {
306			assertTrue(s.indexOf(String.valueOf(i)) >= 0);
307			}
308			}
309
310			// Exception tests
311
312	dl	1.5	/**
313			* Cannot create with negative capacity
314			*/
315			public void testConstructor1() {
316			try {
317	dl	1.1	new ConcurrentHashMap(-1,0,1);
318	dl	1.5	shouldThrow();
319			} catch(IllegalArgumentException e){}
320	dl	1.1	}
321
322	dl	1.5	/**
323			* Cannot create with negative concurrency level
324			*/
325			public void testConstructor2() {
326			try {
327	dl	1.1	new ConcurrentHashMap(1,0,-1);
328	dl	1.5	shouldThrow();
329			} catch(IllegalArgumentException e){}
330	dl	1.1	}
331
332	dl	1.5	/**
333			* Cannot create with only negative capacity
334			*/
335			public void testConstructor3() {
336			try {
337	dl	1.1	new ConcurrentHashMap(-1);
338	dl	1.5	shouldThrow();
339			} catch(IllegalArgumentException e){}
340	dl	1.1	}
341
342	dl	1.5	/**
343			* get(null) throws NPE
344			*/
345			public void testGet_NullPointerException() {
346			try {
347	dl	1.1	ConcurrentHashMap c = new ConcurrentHashMap(5);
348			c.get(null);
349	dl	1.5	shouldThrow();
350			} catch(NullPointerException e){}
351	dl	1.1	}
352
353	dl	1.5	/**
354			* containsKey(null) throws NPE
355			*/
356			public void testContainsKey_NullPointerException() {
357			try {
358	dl	1.1	ConcurrentHashMap c = new ConcurrentHashMap(5);
359			c.containsKey(null);
360	dl	1.5	shouldThrow();
361			} catch(NullPointerException e){}
362	dl	1.1	}
363
364	dl	1.5	/**
365			* containsValue(null) throws NPE
366			*/
367			public void testContainsValue_NullPointerException() {
368			try {
369	dl	1.1	ConcurrentHashMap c = new ConcurrentHashMap(5);
370			c.containsValue(null);
371	dl	1.5	shouldThrow();
372			} catch(NullPointerException e){}
373	dl	1.1	}
374
375	dl	1.5	/**
376			* contains(null) throws NPE
377			*/
378			public void testContains_NullPointerException() {
379			try {
380	dl	1.1	ConcurrentHashMap c = new ConcurrentHashMap(5);
381			c.contains(null);
382	dl	1.5	shouldThrow();
383			} catch(NullPointerException e){}
384	dl	1.1	}
385
386	dl	1.5	/**
387			* put(null,x) throws NPE
388			*/
389			public void testPut1_NullPointerException() {
390			try {
391	dl	1.1	ConcurrentHashMap c = new ConcurrentHashMap(5);
392			c.put(null, "whatever");
393	dl	1.5	shouldThrow();
394			} catch(NullPointerException e){}
395	dl	1.1	}
396
397	dl	1.5	/**
398			* put(x, null) throws NPE
399			*/
400			public void testPut2_NullPointerException() {
401			try {
402	dl	1.1	ConcurrentHashMap c = new ConcurrentHashMap(5);
403			c.put("whatever", null);
404	dl	1.5	shouldThrow();
405			} catch(NullPointerException e){}
406	dl	1.1	}
407
408	dl	1.5	/**
409			* putIfAbsent(null, x) throws NPE
410			*/
411			public void testPutIfAbsent1_NullPointerException() {
412			try {
413	dl	1.1	ConcurrentHashMap c = new ConcurrentHashMap(5);
414			c.putIfAbsent(null, "whatever");
415	dl	1.5	shouldThrow();
416			} catch(NullPointerException e){}
417	dl	1.1	}
418
419	dl	1.5	/**
420	dl	1.7	* replace(null, x) throws NPE
421			*/
422			public void testReplace_NullPointerException() {
423			try {
424			ConcurrentHashMap c = new ConcurrentHashMap(5);
425			c.replace(null, "whatever");
426			shouldThrow();
427			} catch(NullPointerException e){}
428			}
429
430			/**
431			* replace(null, x, y) throws NPE
432			*/
433			public void testReplaceValue_NullPointerException() {
434			try {
435			ConcurrentHashMap c = new ConcurrentHashMap(5);
436			c.replace(null, one, "whatever");
437			shouldThrow();
438			} catch(NullPointerException e){}
439			}
440
441			/**
442	dl	1.5	* putIfAbsent(x, null) throws NPE
443			*/
444			public void testPutIfAbsent2_NullPointerException() {
445			try {
446	dl	1.1	ConcurrentHashMap c = new ConcurrentHashMap(5);
447			c.putIfAbsent("whatever", null);
448	dl	1.7	shouldThrow();
449			} catch(NullPointerException e){}
450			}
451
452
453			/**
454			* replace(x, null) throws NPE
455			*/
456			public void testReplace2_NullPointerException() {
457			try {
458			ConcurrentHashMap c = new ConcurrentHashMap(5);
459			c.replace("whatever", null);
460			shouldThrow();
461			} catch(NullPointerException e){}
462			}
463
464			/**
465			* replace(x, null, y) throws NPE
466			*/
467			public void testReplaceValue2_NullPointerException() {
468			try {
469			ConcurrentHashMap c = new ConcurrentHashMap(5);
470			c.replace("whatever", null, "A");
471			shouldThrow();
472			} catch(NullPointerException e){}
473			}
474
475			/**
476			* replace(x, y, null) throws NPE
477			*/
478			public void testReplaceValue3_NullPointerException() {
479			try {
480			ConcurrentHashMap c = new ConcurrentHashMap(5);
481			c.replace("whatever", one, null);
482	dl	1.5	shouldThrow();
483			} catch(NullPointerException e){}
484	dl	1.1	}
485
486
487	dl	1.5	/**
488			* remove(null) throws NPE
489			*/
490			public void testRemove1_NullPointerException() {
491			try {
492	dl	1.1	ConcurrentHashMap c = new ConcurrentHashMap(5);
493			c.put("sadsdf", "asdads");
494			c.remove(null);
495	dl	1.5	shouldThrow();
496			} catch(NullPointerException e){}
497	dl	1.1	}
498
499	dl	1.5	/**
500			* remove(null, x) throws NPE
501			*/
502			public void testRemove2_NullPointerException() {
503			try {
504	dl	1.1	ConcurrentHashMap c = new ConcurrentHashMap(5);
505			c.put("sadsdf", "asdads");
506			c.remove(null, "whatever");
507	dl	1.5	shouldThrow();
508			} catch(NullPointerException e){}
509	dl	1.1	}
510	dl	1.2
511	dl	1.5	/**
512			* A deserialized map equals original
513			*/
514	dl	1.2	public void testSerialization() {
515			ConcurrentHashMap q = map5();
516
517			try {
518			ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
519			ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
520			out.writeObject(q);
521			out.close();
522
523			ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
524			ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
525			ConcurrentHashMap r = (ConcurrentHashMap)in.readObject();
526			assertEquals(q.size(), r.size());
527			assertTrue(q.equals(r));
528			assertTrue(r.equals(q));
529			} catch(Exception e){
530			e.printStackTrace();
531	dl	1.5	unexpectedException();
532	dl	1.2	}
533			}
534	dl	1.6
535
536			/**
537			* SetValue of an EntrySet entry sets value in the map.
538			*/
539			public void testSetValueWriteThrough() {
540			// Adapted from a bug report by Eric Zoerner
541			ConcurrentHashMap map = new ConcurrentHashMap(2, 5.0f, 1);
542			assertTrue(map.isEmpty());
543			for (int i = 0; i < 20; i++)
544			map.put(new Integer(i), new Integer(i));
545			assertFalse(map.isEmpty());
546			Map.Entry entry1 = (Map.Entry)map.entrySet().iterator().next();
547
548			// assert that entry1 is not 16
549			assertTrue("entry is 16, test not valid",
550			!entry1.getKey().equals(new Integer(16)));
551
552			// remove 16 (a different key) from map
553			// which just happens to cause entry1 to be cloned in map
554			map.remove(new Integer(16));
555			entry1.setValue("XYZ");
556			assertTrue(map.containsValue("XYZ")); // fails
557			}
558	dl	1.1
559			}