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

Comparing jsr166/src/test/tck/ConcurrentHashMap8Test.java (file contents):
Revision 1.13 by jsr166, Mon Jul 22 15:55:43 2013 UTC vs.
Revision 1.25 by jsr166, Fri Feb 27 21:05:11 2015 UTC

# Line 4 | Line 4
4   * http://creativecommons.org/publicdomain/zero/1.0/
5   */
6  
7 < import junit.framework.*;
8 < import java.util.*;
9 < import java.util.function.*;
10 < import java.util.concurrent.atomic.LongAdder;
7 > import static java.util.Spliterator.CONCURRENT;
8 > import static java.util.Spliterator.DISTINCT;
9 > import static java.util.Spliterator.NONNULL;
10 >
11 > import java.util.AbstractMap;
12 > import java.util.Arrays;
13 > import java.util.Collection;
14 > import java.util.Collections;
15 > import java.util.Iterator;
16 > import java.util.Map;
17 > import java.util.NoSuchElementException;
18 > import java.util.Set;
19 > import java.util.Spliterator;
20   import java.util.concurrent.ConcurrentHashMap;
21 < import java.util.concurrent.ConcurrentHashMap.KeySetView;
21 > import java.util.concurrent.atomic.LongAdder;
22 > import java.util.function.BiFunction;
23 >
24 > import junit.framework.Test;
25 > import junit.framework.TestSuite;
26  
27   public class ConcurrentHashMap8Test extends JSR166TestCase {
28      public static void main(String[] args) {
# Line 54 | Line 67 | public class ConcurrentHashMap8Test exte
67      }
68  
69      /**
70 <     * computeIfAbsent does not replace  if the key is already present
70 >     * computeIfAbsent does not replace if the key is already present
71       */
72      public void testComputeIfAbsent2() {
73          ConcurrentHashMap map = map5();
# Line 71 | Line 84 | public class ConcurrentHashMap8Test exte
84      }
85  
86      /**
87 <     * computeIfPresent does not replace  if the key is already present
87 >     * computeIfPresent does not replace if the key is already present
88       */
89      public void testComputeIfPresent() {
90          ConcurrentHashMap map = map5();
# Line 88 | Line 101 | public class ConcurrentHashMap8Test exte
101      }
102  
103      /**
104 <     * compute does not replace  if the function returns null
104 >     * compute does not replace if the function returns null
105       */
106      public void testCompute() {
107          ConcurrentHashMap map = map5();
# Line 151 | Line 164 | public class ConcurrentHashMap8Test exte
164          assertTrue(a.isEmpty());
165          for (int i = 0; i < n; i++)
166              a.add(i);
167 <        assertFalse(a.isEmpty());
167 >        assertEquals(n == 0, a.isEmpty());
168          assertEquals(n, a.size());
169          return a;
170      }
# Line 166 | Line 179 | public class ConcurrentHashMap8Test exte
179          return a;
180      }
181  
182 <    /*
182 >    /**
183       * replaceAll replaces all matching values.
184       */
185      public void testReplaceAll() {
186          ConcurrentHashMap<Integer, String> map = map5();
187 <        map.replaceAll((x, y) -> {return x > 3 ? "Z" : y;});
187 >        map.replaceAll((x, y) -> { return x > 3 ? "Z" : y; });
188          assertEquals("A", map.get(one));
189          assertEquals("B", map.get(two));
190          assertEquals("C", map.get(three));
# Line 196 | Line 209 | public class ConcurrentHashMap8Test exte
209          Set set1 = map.keySet();
210          Set set2 = map.keySet(true);
211          set2.add(six);
212 <        assertTrue(((KeySetView)set2).getMap() == map);
213 <        assertTrue(((KeySetView)set1).getMap() == map);
212 >        assertTrue(((ConcurrentHashMap.KeySetView)set2).getMap() == map);
213 >        assertTrue(((ConcurrentHashMap.KeySetView)set1).getMap() == map);
214          assertEquals(set2.size(), map.size());
215          assertEquals(set1.size(), map.size());
216          assertTrue((Boolean)map.get(six));
# Line 209 | Line 222 | public class ConcurrentHashMap8Test exte
222          assertFalse(set2.contains(six));
223      }
224  
212 –
225      /**
226       * keySet.addAll adds each element from the given collection
227       */
228      public void testAddAll() {
229          Set full = populatedSet(3);
230 <        Vector v = new Vector();
231 <        v.add(three);
232 <        v.add(four);
221 <        v.add(five);
222 <        full.addAll(v);
230 >        assertTrue(full.addAll(Arrays.asList(three, four, five)));
231 >        assertEquals(6, full.size());
232 >        assertFalse(full.addAll(Arrays.asList(three, four, five)));
233          assertEquals(6, full.size());
234      }
235  
# Line 229 | Line 239 | public class ConcurrentHashMap8Test exte
239       */
240      public void testAddAll2() {
241          Set full = populatedSet(3);
242 <        Vector v = new Vector();
243 <        v.add(three);
244 <        v.add(four);
245 <        v.add(one); // will not add this element
236 <        full.addAll(v);
242 >        // "one" is duplicate and will not be added
243 >        assertTrue(full.addAll(Arrays.asList(three, four, one)));
244 >        assertEquals(5, full.size());
245 >        assertFalse(full.addAll(Arrays.asList(three, four, one)));
246          assertEquals(5, full.size());
247      }
248  
# Line 242 | Line 251 | public class ConcurrentHashMap8Test exte
251       */
252      public void testAdd2() {
253          Set full = populatedSet(3);
254 <        full.add(one);
254 >        assertFalse(full.add(one));
255          assertEquals(3, full.size());
256      }
257  
# Line 251 | Line 260 | public class ConcurrentHashMap8Test exte
260       */
261      public void testAdd3() {
262          Set full = populatedSet(3);
263 <        full.add(three);
263 >        assertTrue(full.add(three));
264 >        assertTrue(full.contains(three));
265 >        assertFalse(full.add(three));
266          assertTrue(full.contains(three));
267      }
268  
# Line 264 | Line 275 | public class ConcurrentHashMap8Test exte
275          try {
276              full.add(three);
277              shouldThrow();
278 <        } catch (UnsupportedOperationException e){}
278 >        } catch (UnsupportedOperationException success) {}
279      }
280  
281      /**
# Line 276 | Line 287 | public class ConcurrentHashMap8Test exte
287          try {
288              full.add(null);
289              shouldThrow();
290 <        } catch (NullPointerException e){}
290 >        } catch (NullPointerException success) {}
291      }
292  
293      /**
# Line 289 | Line 300 | public class ConcurrentHashMap8Test exte
300              map.keySet(null);
301              shouldThrow();
302          } catch (NullPointerException e) {}
303 <        KeySetView set = map.keySet(one);
303 >        ConcurrentHashMap.KeySetView set = map.keySet(one);
304          set.add(one);
305          set.add(six);
306          set.add(seven);
# Line 299 | Line 310 | public class ConcurrentHashMap8Test exte
310          assertTrue(map.get(seven) == one);
311      }
312  
313 +    void checkSpliteratorCharacteristics(Spliterator<?> sp,
314 +                                         int requiredCharacteristics) {
315 +        assertEquals(requiredCharacteristics,
316 +                     requiredCharacteristics & sp.characteristics());
317 +    }
318 +
319      /**
320       * KeySetView.spliterator returns spliterator over the elements in this set
321       */
# Line 307 | Line 324 | public class ConcurrentHashMap8Test exte
324          ConcurrentHashMap map = map5();
325          Set set = map.keySet();
326          Spliterator<Integer> sp = set.spliterator();
327 +        checkSpliteratorCharacteristics(sp, CONCURRENT | DISTINCT | NONNULL);
328          assertEquals(sp.estimateSize(), map.size());
329          Spliterator<Integer> sp2 = sp.trySplit();
330          sp.forEachRemaining((Integer x) -> adder.add(x.longValue()));
# Line 356 | Line 374 | public class ConcurrentHashMap8Test exte
374       * KeySet.containsAll returns true for collections with subset of elements
375       */
376      public void testContainsAll() {
377 <        Set full = populatedSet(3);
378 <        Vector v = new Vector();
379 <        v.add(one);
380 <        v.add(two);
381 <        assertTrue(full.containsAll(v));
382 <        v.add(six);
365 <        assertFalse(full.containsAll(v));
377 >        Collection full = populatedSet(3);
378 >        assertTrue(full.containsAll(Arrays.asList()));
379 >        assertTrue(full.containsAll(Arrays.asList(one)));
380 >        assertTrue(full.containsAll(Arrays.asList(one, two)));
381 >        assertFalse(full.containsAll(Arrays.asList(one, two, six)));
382 >        assertFalse(full.containsAll(Arrays.asList(six)));
383      }
384  
385      /**
386       * KeySet.isEmpty is true when empty, else false
387       */
388      public void testIsEmpty() {
389 <        Set empty = ConcurrentHashMap.newKeySet();
390 <        Set full = populatedSet(3);
374 <        assertTrue(empty.isEmpty());
375 <        assertFalse(full.isEmpty());
389 >        assertTrue(populatedSet(0).isEmpty());
390 >        assertFalse(populatedSet(3).isEmpty());
391      }
392  
393      /**
# Line 399 | Line 414 | public class ConcurrentHashMap8Test exte
414              assertTrue(it.hasNext());
415              it.next();
416          }
417 <        assertFalse(it.hasNext());
418 <        try {
419 <            it.next();
420 <            shouldThrow();
421 <        } catch (NoSuchElementException success) {}
417 >        assertIteratorExhausted(it);
418 >    }
419 >
420 >    /**
421 >     * iterator of empty collections has no elements
422 >     */
423 >    public void testEmptyIterator() {
424 >        assertIteratorExhausted(ConcurrentHashMap.newKeySet().iterator());
425 >        assertIteratorExhausted(new ConcurrentHashMap().entrySet().iterator());
426 >        assertIteratorExhausted(new ConcurrentHashMap().values().iterator());
427 >        assertIteratorExhausted(new ConcurrentHashMap().keySet().iterator());
428      }
429  
430      /**
# Line 437 | Line 458 | public class ConcurrentHashMap8Test exte
458       */
459      public void testRemoveAll() {
460          Set full = populatedSet(3);
461 <        Vector v = new Vector();
462 <        v.add(one);
463 <        v.add(two);
443 <        full.removeAll(v);
461 >        assertTrue(full.removeAll(Arrays.asList(one, two)));
462 >        assertEquals(1, full.size());
463 >        assertFalse(full.removeAll(Arrays.asList(one, two)));
464          assertEquals(1, full.size());
465      }
466  
# Line 531 | Line 551 | public class ConcurrentHashMap8Test exte
551  
552          assertNotSame(x, y);
553          assertEquals(x.size(), y.size());
534 –        assertEquals(x.toString(), y.toString());
535 –        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
554          assertEquals(x, y);
555          assertEquals(y, x);
556      }
# Line 984 | Line 1002 | public class ConcurrentHashMap8Test exte
1002      public void testSearchValuesSequentially() {
1003          ConcurrentHashMap<Long, Long> m = longMap();
1004          Long r;
1005 <        r = m.searchValues(Long.MAX_VALUE, (Long x) -> x.longValue() == (long)(SIZE/2)? x : null);
1005 >        r = m.searchValues(Long.MAX_VALUE,
1006 >            (Long x) -> (x.longValue() == (long)(SIZE/2)) ? x : null);
1007          assertEquals((long)r, (long)(SIZE/2));
1008 <        r = m.searchValues(Long.MAX_VALUE, (Long x) -> x.longValue() < 0L ? x : null);
1008 >        r = m.searchValues(Long.MAX_VALUE,
1009 >            (Long x) -> (x.longValue() < 0L) ? x : null);
1010          assertNull(r);
1011      }
1012  

Diff Legend

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