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

    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 key-element pairs from the map
     */
    public void testClear(){
        ConcurrentHashMap map = map5();
        map.clear();
        assertEquals(map.size(), 0);
    }

    /**
     *   contains gives the appropriate value
     */
    public void testContains(){
        ConcurrentHashMap map = map5();
        assertTrue(map.contains("A"));
        assertFalse(map.contains("Z"));
    }
    
    /**
     *   containsKey gives the appropriate value
     */
    public void testContainsKey(){
        ConcurrentHashMap map = map5();
        assertTrue(map.containsKey(one));
        assertFalse(map.containsKey(new Integer(100)));
    }

    /**
     *  Identical to normal contains
     */
    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 index
     */
    public void testGet(){
        ConcurrentHashMap map = map5();
        assertEquals("A", (String)map.get(one));
    }

    /**
     *   get on a nonexistant key returns null
     */
    public void testGet2(){
        ConcurrentHashMap empty = new ConcurrentHashMap();
        assertNull(empty.get("anything"));
    }

    /**
     *  Simple test to verify isEmpty returns the correct value
     */
    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));
    }

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

    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(new Integer(6), "Z");
        assertTrue(map.containsKey(new Integer(6)));
    }

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

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

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

    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
    
    public void testConstructor1(){
        try{
            new ConcurrentHashMap(-1,0,1);
            fail("ConcurrentHashMap(int, float, int) should throw Illegal Argument Exception");
        }catch(IllegalArgumentException e){}
    }

    public void testConstructor2(){
        try{
            new ConcurrentHashMap(1,0,-1);
            fail("ConcurrentHashMap(int, float, int) should throw Illegal Argument Exception");
        }catch(IllegalArgumentException e){}
    }

    public void testConstructor3(){
        try{
            new ConcurrentHashMap(-1);
            fail("ConcurrentHashMap(int) should throw Illegal Argument Exception");
        }catch(IllegalArgumentException e){}
    }

    public void testGet_NullPointerException(){
        try{
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.get(null);
            fail("ConcurrentHashMap - Object get(Object) should throw Null Pointer exception");
        }catch(NullPointerException e){}
    }

    public void testContainsKey_NullPointerException(){
        try{
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.containsKey(null);
            fail("ConcurrenthashMap - boolean containsKey(Object) should throw Null Pointer exception");
        }catch(NullPointerException e){}
    }

    public void testContainsValue_NullPointerException(){
        try{
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.containsValue(null);
            fail("ConcurrentHashMap - boolean containsValue(Object) should throw Null Pointer exception");
        }catch(NullPointerException e){}
    }

    public void testContains_NullPointerException(){
        try{
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.contains(null);
            fail("ConcurrentHashMap - boolean contains(Object) should throw Null Pointer exception");
        }catch(NullPointerException e){}
    }

    public void testPut1_NullPointerException(){
        try{
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.put(null, "whatever");
            fail("ConcurrentHashMap - Object put(Object, Object) should throw Null Pointer exception");
        }catch(NullPointerException e){}
    }

    public void testPut2_NullPointerException(){
        try{
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.put("whatever", null);
            fail("ConcurrentHashMap - Object put(Object, Object) should throw Null Pointer exception");
        }catch(NullPointerException e){}
    }

    public void testPutIfAbsent1_NullPointerException(){
        try{
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.putIfAbsent(null, "whatever");
            fail("ConcurrentHashMap - Object putIfAbsent(Object, Object) should throw Null Pointer exception");
        }catch(NullPointerException e){}
    }

    public void testPutIfAbsent2_NullPointerException(){
        try{
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.putIfAbsent("whatever", null);
            fail("COncurrentHashMap - Object putIfAbsent(Object, Object) should throw Null Pointer exception");
        }catch(NullPointerException e){}
    }


    public void testRemove1_NullPointerException(){
        try{
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.put("sadsdf", "asdads");
            c.remove(null);
            fail("ConcurrentHashMap - Object remove(Object) should throw Null pointer exceptione");
        }catch(NullPointerException e){}
    }

    public void testRemove2_NullPointerException(){
        try{
            ConcurrentHashMap c = new ConcurrentHashMap(5);
            c.put("sadsdf", "asdads");
            c.remove(null, "whatever");
            fail("ConcurrentHashMap - Object remove(Object, Object) should throw Null pointer exceptione");
        }catch(NullPointerException e){}
    }

    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();
            fail("unexpected exception");
        }
    }

    
}
Revision:	1.4
Committed:	Sat Sep 20 00:31:57 2003 UTC (20 years, 8 months ago) by dl
Branch:	MAIN
Changes since 1.3:	+11 -1 lines
Log Message:	Added tests
#	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			private static ConcurrentHashMap map5() {
23			ConcurrentHashMap map = new ConcurrentHashMap(5);
24			assertTrue(map.isEmpty());
25			map.put(one, "A");
26			map.put(two, "B");
27			map.put(three, "C");
28			map.put(four, "D");
29			map.put(five, "E");
30			assertFalse(map.isEmpty());
31			assertEquals(5, map.size());
32			return map;
33			}
34
35			/**
36	dl	1.3	* clear removes all key-element pairs from the map
37	dl	1.1	*/
38			public void testClear(){
39			ConcurrentHashMap map = map5();
40			map.clear();
41			assertEquals(map.size(), 0);
42			}
43
44			/**
45	dl	1.3	* contains gives the appropriate value
46	dl	1.1	*/
47			public void testContains(){
48			ConcurrentHashMap map = map5();
49			assertTrue(map.contains("A"));
50			assertFalse(map.contains("Z"));
51			}
52
53			/**
54	dl	1.3	* containsKey gives the appropriate value
55	dl	1.1	*/
56			public void testContainsKey(){
57			ConcurrentHashMap map = map5();
58			assertTrue(map.containsKey(one));
59			assertFalse(map.containsKey(new Integer(100)));
60			}
61
62			/**
63			* Identical to normal contains
64			*/
65			public void testContainsValue(){
66			ConcurrentHashMap map = map5();
67			assertTrue(map.contains("A"));
68			assertFalse(map.contains("Z"));
69			}
70
71			/**
72	dl	1.4	* enumeration returns an enumeration containing the correct
73			* elements
74	dl	1.1	*/
75			public void testEnumeration(){
76			ConcurrentHashMap map = map5();
77			Enumeration e = map.elements();
78			int count = 0;
79			while(e.hasMoreElements()){
80			count++;
81			e.nextElement();
82			}
83			assertEquals(5, count);
84	dl	1.4	}
85
86			/**
87			* Clone creates an equal map
88			*/
89			public void testClone(){
90			ConcurrentHashMap map = map5();
91			ConcurrentHashMap m2 = (ConcurrentHashMap)(map.clone());
92			assertEquals(map, m2);
93	dl	1.1	}
94
95			/**
96	dl	1.3	* get returns the correct element at the given index
97	dl	1.1	*/
98			public void testGet(){
99			ConcurrentHashMap map = map5();
100			assertEquals("A", (String)map.get(one));
101			}
102
103			/**
104	dl	1.3	* get on a nonexistant key returns null
105	dl	1.1	*/
106			public void testGet2(){
107			ConcurrentHashMap empty = new ConcurrentHashMap();
108			assertNull(empty.get("anything"));
109			}
110
111			/**
112			* Simple test to verify isEmpty returns the correct value
113			*/
114			public void testIsEmpty(){
115			ConcurrentHashMap empty = new ConcurrentHashMap();
116			ConcurrentHashMap map = map5();
117			assertTrue(empty.isEmpty());
118			assertFalse(map.isEmpty());
119			}
120
121			/**
122	dl	1.3	* keys returns an enumeration containing all the keys from the map
123	dl	1.1	*/
124			public void testKeys(){
125			ConcurrentHashMap map = map5();
126			Enumeration e = map.keys();
127			int count = 0;
128			while(e.hasMoreElements()){
129			count++;
130			e.nextElement();
131			}
132			assertEquals(5, count);
133			}
134
135			/**
136	dl	1.3	* keySet returns a Set containing all the keys
137	dl	1.1	*/
138			public void testKeySet(){
139			ConcurrentHashMap map = map5();
140			Set s = map.keySet();
141			assertEquals(5, s.size());
142			assertTrue(s.contains(one));
143			assertTrue(s.contains(two));
144			assertTrue(s.contains(three));
145			assertTrue(s.contains(four));
146			assertTrue(s.contains(five));
147			}
148
149			public void testValues(){
150			ConcurrentHashMap map = map5();
151			Collection s = map.values();
152			assertEquals(5, s.size());
153			assertTrue(s.contains("A"));
154			assertTrue(s.contains("B"));
155			assertTrue(s.contains("C"));
156			assertTrue(s.contains("D"));
157			assertTrue(s.contains("E"));
158			}
159
160			public void testEntrySet(){
161			ConcurrentHashMap map = map5();
162			Set s = map.entrySet();
163			assertEquals(5, s.size());
164			Iterator it = s.iterator();
165			while (it.hasNext()) {
166			Map.Entry e = (Map.Entry) it.next();
167			assertTrue(
168			(e.getKey().equals(one) && e.getValue().equals("A")) \|\|
169			(e.getKey().equals(two) && e.getValue().equals("B")) \|\|
170			(e.getKey().equals(three) && e.getValue().equals("C")) \|\|
171			(e.getKey().equals(four) && e.getValue().equals("D")) \|\|
172			(e.getKey().equals(five) && e.getValue().equals("E")));
173			}
174			}
175
176			/**
177	dl	1.3	* putAll adds all key-value pairs from the given map
178	dl	1.1	*/
179			public void testPutAll(){
180			ConcurrentHashMap empty = new ConcurrentHashMap();
181			ConcurrentHashMap map = map5();
182			empty.putAll(map);
183			assertEquals(5, empty.size());
184			assertTrue(empty.containsKey(one));
185			assertTrue(empty.containsKey(two));
186			assertTrue(empty.containsKey(three));
187			assertTrue(empty.containsKey(four));
188			assertTrue(empty.containsKey(five));
189			}
190
191			/**
192	dl	1.3	* putIfAbsent works when the given key is not present
193	dl	1.1	*/
194			public void testPutIfAbsent(){
195			ConcurrentHashMap map = map5();
196			map.putIfAbsent(new Integer(6), "Z");
197			assertTrue(map.containsKey(new Integer(6)));
198			}
199
200			/**
201	dl	1.3	* putIfAbsent does not add the pair if the key is already present
202	dl	1.1	*/
203			public void testPutIfAbsent2(){
204			ConcurrentHashMap map = map5();
205			assertEquals("A", map.putIfAbsent(one, "Z"));
206			}
207
208			/**
209	dl	1.3	* remove removes the correct key-value pair from the map
210	dl	1.1	*/
211			public void testRemove(){
212			ConcurrentHashMap map = map5();
213			map.remove(five);
214			assertEquals(4, map.size());
215			assertFalse(map.containsKey(five));
216			}
217
218			public void testRemove2(){
219			ConcurrentHashMap map = map5();
220			map.remove(five, "E");
221			assertEquals(4, map.size());
222			assertFalse(map.containsKey(five));
223			map.remove(four, "A");
224			assertEquals(4, map.size());
225			assertTrue(map.containsKey(four));
226
227			}
228
229			/**
230	dl	1.3	* size returns the correct values
231	dl	1.1	*/
232			public void testSize(){
233			ConcurrentHashMap map = map5();
234			ConcurrentHashMap empty = new ConcurrentHashMap();
235			assertEquals(0, empty.size());
236			assertEquals(5, map.size());
237			}
238
239			public void testToString(){
240			ConcurrentHashMap map = map5();
241			String s = map.toString();
242			for (int i = 1; i <= 5; ++i) {
243			assertTrue(s.indexOf(String.valueOf(i)) >= 0);
244			}
245			}
246
247			// Exception tests
248
249			public void testConstructor1(){
250			try{
251			new ConcurrentHashMap(-1,0,1);
252			fail("ConcurrentHashMap(int, float, int) should throw Illegal Argument Exception");
253			}catch(IllegalArgumentException e){}
254			}
255
256			public void testConstructor2(){
257			try{
258			new ConcurrentHashMap(1,0,-1);
259			fail("ConcurrentHashMap(int, float, int) should throw Illegal Argument Exception");
260			}catch(IllegalArgumentException e){}
261			}
262
263			public void testConstructor3(){
264			try{
265			new ConcurrentHashMap(-1);
266			fail("ConcurrentHashMap(int) should throw Illegal Argument Exception");
267			}catch(IllegalArgumentException e){}
268			}
269
270			public void testGet_NullPointerException(){
271			try{
272			ConcurrentHashMap c = new ConcurrentHashMap(5);
273			c.get(null);
274			fail("ConcurrentHashMap - Object get(Object) should throw Null Pointer exception");
275			}catch(NullPointerException e){}
276			}
277
278			public void testContainsKey_NullPointerException(){
279			try{
280			ConcurrentHashMap c = new ConcurrentHashMap(5);
281			c.containsKey(null);
282			fail("ConcurrenthashMap - boolean containsKey(Object) should throw Null Pointer exception");
283			}catch(NullPointerException e){}
284			}
285
286			public void testContainsValue_NullPointerException(){
287			try{
288			ConcurrentHashMap c = new ConcurrentHashMap(5);
289			c.containsValue(null);
290			fail("ConcurrentHashMap - boolean containsValue(Object) should throw Null Pointer exception");
291			}catch(NullPointerException e){}
292			}
293
294			public void testContains_NullPointerException(){
295			try{
296			ConcurrentHashMap c = new ConcurrentHashMap(5);
297			c.contains(null);
298			fail("ConcurrentHashMap - boolean contains(Object) should throw Null Pointer exception");
299			}catch(NullPointerException e){}
300			}
301
302			public void testPut1_NullPointerException(){
303			try{
304			ConcurrentHashMap c = new ConcurrentHashMap(5);
305			c.put(null, "whatever");
306			fail("ConcurrentHashMap - Object put(Object, Object) should throw Null Pointer exception");
307			}catch(NullPointerException e){}
308			}
309
310			public void testPut2_NullPointerException(){
311			try{
312			ConcurrentHashMap c = new ConcurrentHashMap(5);
313			c.put("whatever", null);
314			fail("ConcurrentHashMap - Object put(Object, Object) should throw Null Pointer exception");
315			}catch(NullPointerException e){}
316			}
317
318			public void testPutIfAbsent1_NullPointerException(){
319			try{
320			ConcurrentHashMap c = new ConcurrentHashMap(5);
321			c.putIfAbsent(null, "whatever");
322			fail("ConcurrentHashMap - Object putIfAbsent(Object, Object) should throw Null Pointer exception");
323			}catch(NullPointerException e){}
324			}
325
326			public void testPutIfAbsent2_NullPointerException(){
327			try{
328			ConcurrentHashMap c = new ConcurrentHashMap(5);
329			c.putIfAbsent("whatever", null);
330			fail("COncurrentHashMap - Object putIfAbsent(Object, Object) should throw Null Pointer exception");
331			}catch(NullPointerException e){}
332			}
333
334
335			public void testRemove1_NullPointerException(){
336			try{
337			ConcurrentHashMap c = new ConcurrentHashMap(5);
338			c.put("sadsdf", "asdads");
339			c.remove(null);
340			fail("ConcurrentHashMap - Object remove(Object) should throw Null pointer exceptione");
341			}catch(NullPointerException e){}
342			}
343
344			public void testRemove2_NullPointerException(){
345			try{
346			ConcurrentHashMap c = new ConcurrentHashMap(5);
347			c.put("sadsdf", "asdads");
348			c.remove(null, "whatever");
349			fail("ConcurrentHashMap - Object remove(Object, Object) should throw Null pointer exceptione");
350			}catch(NullPointerException e){}
351			}
352	dl	1.2
353			public void testSerialization() {
354			ConcurrentHashMap q = map5();
355
356			try {
357			ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
358			ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
359			out.writeObject(q);
360			out.close();
361
362			ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
363			ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
364			ConcurrentHashMap r = (ConcurrentHashMap)in.readObject();
365			assertEquals(q.size(), r.size());
366			assertTrue(q.equals(r));
367			assertTrue(r.equals(q));
368			} catch(Exception e){
369			e.printStackTrace();
370			fail("unexpected exception");
371			}
372			}
373
374	dl	1.1
375			}