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 TestCase{
    public static void main(String[] args) {
        junit.textui.TestRunner.run (suite());  
    }
    public static Test suite() {
        return new TestSuite(ConcurrentHashMapTest.class);
    }

    static final Integer one = new Integer(1);
    static final Integer two = new Integer(2);
    static final Integer three = new Integer(3);
    static final Integer four = new Integer(4);
    static final Integer five = new Integer(5);

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

    /**
     *  Test to verify clear correctly removes all key-element pairs from the map
     */
    public void testClear(){
        ConcurrentHashMap map = map5();
        map.clear();
        assertEquals(map.size(), 0);
    }

    /**
     *  Test to verify contains gives the appropriate value
     */
    public void testContains(){
        ConcurrentHashMap map = map5();
        assertTrue(map.contains("A"));
        assertFalse(map.contains("Z"));
    }
    
    /**
     *  Test to verify 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"));
    }

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

    /**
     *  Test to verify get returns the correct element at the given index
     */
    public void testGet(){
        ConcurrentHashMap map = map5();
        assertEquals("A", (String)map.get(one));
    }

    /**
     *  Test to verify 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());
    }

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

    /**
     *  Test to verify 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")));
        }
    }

    /**
     *  Test to verify putAll correctly 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));
    }

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

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

    /**
     *  Test to verify 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));

    }

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