ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ConcurrentHashMapTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ConcurrentHashMapTest.java (file contents):
Revision 1.16 by jsr166, Mon Nov 16 05:30:07 2009 UTC vs.
Revision 1.17 by jsr166, Sat Nov 21 02:07:26 2009 UTC

# Line 14 | Line 14 | import java.io.*;
14  
15   public class ConcurrentHashMapTest extends JSR166TestCase {
16      public static void main(String[] args) {
17 <        junit.textui.TestRunner.run (suite());
17 >        junit.textui.TestRunner.run (suite());
18      }
19      public static Test suite() {
20 <        return new TestSuite(ConcurrentHashMapTest.class);
20 >        return new TestSuite(ConcurrentHashMapTest.class);
21      }
22  
23      /**
24       * Create a map from Integers 1-5 to Strings "A"-"E".
25       */
26      private static ConcurrentHashMap map5() {
27 <        ConcurrentHashMap map = new ConcurrentHashMap(5);
27 >        ConcurrentHashMap map = new ConcurrentHashMap(5);
28          assertTrue(map.isEmpty());
29 <        map.put(one, "A");
30 <        map.put(two, "B");
31 <        map.put(three, "C");
32 <        map.put(four, "D");
33 <        map.put(five, "E");
29 >        map.put(one, "A");
30 >        map.put(two, "B");
31 >        map.put(three, "C");
32 >        map.put(four, "D");
33 >        map.put(five, "E");
34          assertFalse(map.isEmpty());
35          assertEquals(5, map.size());
36 <        return map;
36 >        return map;
37      }
38  
39      /**
# Line 41 | Line 41 | public class ConcurrentHashMapTest exten
41       */
42      public void testClear() {
43          ConcurrentHashMap map = map5();
44 <        map.clear();
45 <        assertEquals(map.size(), 0);
44 >        map.clear();
45 >        assertEquals(map.size(), 0);
46      }
47  
48      /**
# Line 53 | Line 53 | public class ConcurrentHashMapTest exten
53          ConcurrentHashMap map2 = map5();
54          assertEquals(map1, map2);
55          assertEquals(map2, map1);
56 <        map1.clear();
56 >        map1.clear();
57          assertFalse(map1.equals(map2));
58          assertFalse(map2.equals(map1));
59      }
# Line 63 | Line 63 | public class ConcurrentHashMapTest exten
63       */
64      public void testContains() {
65          ConcurrentHashMap map = map5();
66 <        assertTrue(map.contains("A"));
66 >        assertTrue(map.contains("A"));
67          assertFalse(map.contains("Z"));
68      }
69  
# Line 72 | Line 72 | public class ConcurrentHashMapTest exten
72       */
73      public void testContainsKey() {
74          ConcurrentHashMap map = map5();
75 <        assertTrue(map.containsKey(one));
75 >        assertTrue(map.containsKey(one));
76          assertFalse(map.containsKey(zero));
77      }
78  
# Line 81 | Line 81 | public class ConcurrentHashMapTest exten
81       */
82      public void testContainsValue() {
83          ConcurrentHashMap map = map5();
84 <        assertTrue(map.containsValue("A"));
84 >        assertTrue(map.containsValue("A"));
85          assertFalse(map.containsValue("Z"));
86      }
87  
# Line 91 | Line 91 | public class ConcurrentHashMapTest exten
91       */
92      public void testEnumeration() {
93          ConcurrentHashMap map = map5();
94 <        Enumeration e = map.elements();
95 <        int count = 0;
96 <        while (e.hasMoreElements()) {
97 <            count++;
98 <            e.nextElement();
99 <        }
100 <        assertEquals(5, count);
94 >        Enumeration e = map.elements();
95 >        int count = 0;
96 >        while (e.hasMoreElements()) {
97 >            count++;
98 >            e.nextElement();
99 >        }
100 >        assertEquals(5, count);
101      }
102  
103      /**
# Line 106 | Line 106 | public class ConcurrentHashMapTest exten
106       */
107      public void testGet() {
108          ConcurrentHashMap map = map5();
109 <        assertEquals("A", (String)map.get(one));
109 >        assertEquals("A", (String)map.get(one));
110          ConcurrentHashMap empty = new ConcurrentHashMap();
111          assertNull(map.get("anything"));
112      }
# Line 117 | Line 117 | public class ConcurrentHashMapTest exten
117      public void testIsEmpty() {
118          ConcurrentHashMap empty = new ConcurrentHashMap();
119          ConcurrentHashMap map = map5();
120 <        assertTrue(empty.isEmpty());
120 >        assertTrue(empty.isEmpty());
121          assertFalse(map.isEmpty());
122      }
123  
# Line 126 | Line 126 | public class ConcurrentHashMapTest exten
126       */
127      public void testKeys() {
128          ConcurrentHashMap map = map5();
129 <        Enumeration e = map.keys();
130 <        int count = 0;
131 <        while (e.hasMoreElements()) {
132 <            count++;
133 <            e.nextElement();
134 <        }
135 <        assertEquals(5, count);
129 >        Enumeration e = map.keys();
130 >        int count = 0;
131 >        while (e.hasMoreElements()) {
132 >            count++;
133 >            e.nextElement();
134 >        }
135 >        assertEquals(5, count);
136      }
137  
138      /**
# Line 140 | Line 140 | public class ConcurrentHashMapTest exten
140       */
141      public void testKeySet() {
142          ConcurrentHashMap map = map5();
143 <        Set s = map.keySet();
144 <        assertEquals(5, s.size());
145 <        assertTrue(s.contains(one));
146 <        assertTrue(s.contains(two));
147 <        assertTrue(s.contains(three));
148 <        assertTrue(s.contains(four));
149 <        assertTrue(s.contains(five));
143 >        Set s = map.keySet();
144 >        assertEquals(5, s.size());
145 >        assertTrue(s.contains(one));
146 >        assertTrue(s.contains(two));
147 >        assertTrue(s.contains(three));
148 >        assertTrue(s.contains(four));
149 >        assertTrue(s.contains(five));
150      }
151  
152      /**
# Line 154 | Line 154 | public class ConcurrentHashMapTest exten
154       */
155      public void testKeySetToArray() {
156          ConcurrentHashMap map = map5();
157 <        Set s = map.keySet();
157 >        Set s = map.keySet();
158          Object[] ar = s.toArray();
159          assertTrue(s.containsAll(Arrays.asList(ar)));
160 <        assertEquals(5, ar.length);
160 >        assertEquals(5, ar.length);
161          ar[0] = m10;
162          assertFalse(s.containsAll(Arrays.asList(ar)));
163      }
# Line 167 | Line 167 | public class ConcurrentHashMapTest exten
167       */
168      public void testValuesToArray() {
169          ConcurrentHashMap map = map5();
170 <        Collection v = map.values();
170 >        Collection v = map.values();
171          Object[] ar = v.toArray();
172          ArrayList s = new ArrayList(Arrays.asList(ar));
173 <        assertEquals(5, ar.length);
174 <        assertTrue(s.contains("A"));
175 <        assertTrue(s.contains("B"));
176 <        assertTrue(s.contains("C"));
177 <        assertTrue(s.contains("D"));
178 <        assertTrue(s.contains("E"));
173 >        assertEquals(5, ar.length);
174 >        assertTrue(s.contains("A"));
175 >        assertTrue(s.contains("B"));
176 >        assertTrue(s.contains("C"));
177 >        assertTrue(s.contains("D"));
178 >        assertTrue(s.contains("E"));
179      }
180  
181      /**
# Line 183 | Line 183 | public class ConcurrentHashMapTest exten
183       */
184      public void testEntrySetToArray() {
185          ConcurrentHashMap map = map5();
186 <        Set s = map.entrySet();
186 >        Set s = map.entrySet();
187          Object[] ar = s.toArray();
188          assertEquals(5, ar.length);
189          for (int i = 0; i < 5; ++i) {
# Line 197 | Line 197 | public class ConcurrentHashMapTest exten
197       */
198      public void testValues() {
199          ConcurrentHashMap map = map5();
200 <        Collection s = map.values();
201 <        assertEquals(5, s.size());
202 <        assertTrue(s.contains("A"));
203 <        assertTrue(s.contains("B"));
204 <        assertTrue(s.contains("C"));
205 <        assertTrue(s.contains("D"));
206 <        assertTrue(s.contains("E"));
200 >        Collection s = map.values();
201 >        assertEquals(5, s.size());
202 >        assertTrue(s.contains("A"));
203 >        assertTrue(s.contains("B"));
204 >        assertTrue(s.contains("C"));
205 >        assertTrue(s.contains("D"));
206 >        assertTrue(s.contains("E"));
207      }
208  
209      /**
# Line 211 | Line 211 | public class ConcurrentHashMapTest exten
211       */
212      public void testEntrySet() {
213          ConcurrentHashMap map = map5();
214 <        Set s = map.entrySet();
215 <        assertEquals(5, s.size());
214 >        Set s = map.entrySet();
215 >        assertEquals(5, s.size());
216          Iterator it = s.iterator();
217          while (it.hasNext()) {
218              Map.Entry e = (Map.Entry) it.next();
# Line 231 | Line 231 | public class ConcurrentHashMapTest exten
231      public void testPutAll() {
232          ConcurrentHashMap empty = new ConcurrentHashMap();
233          ConcurrentHashMap map = map5();
234 <        empty.putAll(map);
235 <        assertEquals(5, empty.size());
236 <        assertTrue(empty.containsKey(one));
237 <        assertTrue(empty.containsKey(two));
238 <        assertTrue(empty.containsKey(three));
239 <        assertTrue(empty.containsKey(four));
240 <        assertTrue(empty.containsKey(five));
234 >        empty.putAll(map);
235 >        assertEquals(5, empty.size());
236 >        assertTrue(empty.containsKey(one));
237 >        assertTrue(empty.containsKey(two));
238 >        assertTrue(empty.containsKey(three));
239 >        assertTrue(empty.containsKey(four));
240 >        assertTrue(empty.containsKey(five));
241      }
242  
243      /**
# Line 245 | Line 245 | public class ConcurrentHashMapTest exten
245       */
246      public void testPutIfAbsent() {
247          ConcurrentHashMap map = map5();
248 <        map.putIfAbsent(six, "Z");
248 >        map.putIfAbsent(six, "Z");
249          assertTrue(map.containsKey(six));
250      }
251  
# Line 262 | Line 262 | public class ConcurrentHashMapTest exten
262       */
263      public void testReplace() {
264          ConcurrentHashMap map = map5();
265 <        assertNull(map.replace(six, "Z"));
265 >        assertNull(map.replace(six, "Z"));
266          assertFalse(map.containsKey(six));
267      }
268  
# Line 282 | Line 282 | public class ConcurrentHashMapTest exten
282      public void testReplaceValue() {
283          ConcurrentHashMap map = map5();
284          assertEquals("A", map.get(one));
285 <        assertFalse(map.replace(one, "Z", "Z"));
285 >        assertFalse(map.replace(one, "Z", "Z"));
286          assertEquals("A", map.get(one));
287      }
288  
# Line 292 | Line 292 | public class ConcurrentHashMapTest exten
292      public void testReplaceValue2() {
293          ConcurrentHashMap map = map5();
294          assertEquals("A", map.get(one));
295 <        assertTrue(map.replace(one, "A", "Z"));
295 >        assertTrue(map.replace(one, "A", "Z"));
296          assertEquals("Z", map.get(one));
297      }
298  
# Line 302 | Line 302 | public class ConcurrentHashMapTest exten
302       */
303      public void testRemove() {
304          ConcurrentHashMap map = map5();
305 <        map.remove(five);
306 <        assertEquals(4, map.size());
307 <        assertFalse(map.containsKey(five));
305 >        map.remove(five);
306 >        assertEquals(4, map.size());
307 >        assertFalse(map.containsKey(five));
308      }
309  
310      /**
# Line 312 | Line 312 | public class ConcurrentHashMapTest exten
312       */
313      public void testRemove2() {
314          ConcurrentHashMap map = map5();
315 <        map.remove(five, "E");
316 <        assertEquals(4, map.size());
317 <        assertFalse(map.containsKey(five));
318 <        map.remove(four, "A");
319 <        assertEquals(4, map.size());
320 <        assertTrue(map.containsKey(four));
315 >        map.remove(five, "E");
316 >        assertEquals(4, map.size());
317 >        assertFalse(map.containsKey(five));
318 >        map.remove(four, "A");
319 >        assertEquals(4, map.size());
320 >        assertTrue(map.containsKey(four));
321  
322      }
323  
# Line 327 | Line 327 | public class ConcurrentHashMapTest exten
327      public void testSize() {
328          ConcurrentHashMap map = map5();
329          ConcurrentHashMap empty = new ConcurrentHashMap();
330 <        assertEquals(0, empty.size());
331 <        assertEquals(5, map.size());
330 >        assertEquals(0, empty.size());
331 >        assertEquals(5, map.size());
332      }
333  
334      /**

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines