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;

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