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.7 by dl, Wed Dec 3 21:08:24 2003 UTC vs.
Revision 1.13 by dl, Sat May 28 14:09:27 2005 UTC

# Line 1 | Line 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.
2 > * Written by Doug Lea with assistance from members of JCP JSR-166
3 > * Expert Group and released to the public domain, as explained at
4 > * http://creativecommons.org/licenses/publicdomain
5 > * Other contributors include Andrew Wright, Jeffrey Hayes,
6 > * Pat Fisher, Mike Judd.
7   */
8  
9   import junit.framework.*;
# Line 80 | Line 81 | public class ConcurrentHashMapTest exten
81       */
82      public void testContainsValue() {
83          ConcurrentHashMap map = map5();
84 <        assertTrue(map.contains("A"));
85 <        assertFalse(map.contains("Z"));
84 >        assertTrue(map.containsValue("A"));
85 >        assertFalse(map.containsValue("Z"));
86      }
87  
88      /**
# Line 100 | Line 101 | public class ConcurrentHashMapTest exten
101      }
102  
103      /**
103 –     *   Clone creates an equal map
104 –     */
105 –    public void testClone() {
106 –        ConcurrentHashMap map = map5();
107 –        ConcurrentHashMap m2 = (ConcurrentHashMap)(map.clone());
108 –        assertEquals(map, m2);
109 –    }
110 –
111 –    /**
104       *  get returns the correct element at the given key,
105       *  or null if not present
106       */
# Line 158 | Line 150 | public class ConcurrentHashMapTest exten
150      }
151  
152      /**
153 +     *  keySet.toArray returns contains all keys
154 +     */
155 +    public void testKeySetToArray() {
156 +        ConcurrentHashMap map = map5();
157 +        Set s = map.keySet();
158 +        Object[] ar = s.toArray();
159 +        assertTrue(s.containsAll(Arrays.asList(ar)));
160 +        assertEquals(5, ar.length);
161 +        ar[0] = m10;
162 +        assertFalse(s.containsAll(Arrays.asList(ar)));
163 +    }
164 +
165 +    /**
166 +     *  Values.toArray contains all values
167 +     */
168 +    public void testValuesToArray() {
169 +        ConcurrentHashMap map = map5();
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"));
179 +    }
180 +
181 +    /**
182 +     *  entrySet.toArray contains all entries
183 +     */
184 +    public void testEntrySetToArray() {
185 +        ConcurrentHashMap map = map5();
186 +        Set s = map.entrySet();
187 +        Object[] ar = s.toArray();
188 +        assertEquals(5, ar.length);
189 +        for (int i = 0; i < 5; ++i) {
190 +            assertTrue(map.containsKey(((Map.Entry)(ar[i])).getKey()));
191 +            assertTrue(map.containsValue(((Map.Entry)(ar[i])).getValue()));
192 +        }
193 +    }
194 +
195 +    /**
196       * values collection contains all values
197       */
198      public void testValues() {
# Line 227 | Line 262 | public class ConcurrentHashMapTest exten
262       */
263      public void testReplace() {
264          ConcurrentHashMap map = map5();
265 <        assertFalse(map.replace(six, "Z"));
265 >        assertNull(map.replace(six, "Z"));
266          assertFalse(map.containsKey(six));
267      }
268  
# Line 236 | Line 271 | public class ConcurrentHashMapTest exten
271       */
272      public void testReplace2() {
273          ConcurrentHashMap map = map5();
274 <        assertTrue(map.replace(one, "Z"));
274 >        assertNotNull(map.replace(one, "Z"));
275          assertEquals("Z", map.get(one));
276      }
277  
# Line 509 | Line 544 | public class ConcurrentHashMapTest exten
544      }
545  
546      /**
547 +     * remove(x, null) returns false
548 +     */
549 +    public void testRemove3() {
550 +        try {
551 +            ConcurrentHashMap c = new ConcurrentHashMap(5);
552 +            c.put("sadsdf", "asdads");
553 +            assertFalse(c.remove("sadsdf", null));
554 +        } catch(NullPointerException e){
555 +            fail();
556 +        }
557 +    }
558 +
559 +    /**
560       * A deserialized map equals original
561       */
562      public void testSerialization() {

Diff Legend

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