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.14 by jsr166, Mon Jul 22 18:11:56 2013 UTC vs.
Revision 1.23 by jsr166, Fri Feb 27 19:47:57 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 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 289 | Line 298 | public class ConcurrentHashMap8Test exte
298              map.keySet(null);
299              shouldThrow();
300          } catch (NullPointerException e) {}
301 <        KeySetView set = map.keySet(one);
301 >        ConcurrentHashMap.KeySetView set = map.keySet(one);
302          set.add(one);
303          set.add(six);
304          set.add(seven);
# Line 299 | Line 308 | public class ConcurrentHashMap8Test exte
308          assertTrue(map.get(seven) == one);
309      }
310  
311 +    void checkSpliteratorCharacteristics(Spliterator<?> sp,
312 +                                         int requiredCharacteristics) {
313 +        assertEquals(requiredCharacteristics,
314 +                     requiredCharacteristics & sp.characteristics());
315 +    }
316 +
317      /**
318       * KeySetView.spliterator returns spliterator over the elements in this set
319       */
# Line 307 | Line 322 | public class ConcurrentHashMap8Test exte
322          ConcurrentHashMap map = map5();
323          Set set = map.keySet();
324          Spliterator<Integer> sp = set.spliterator();
325 +        checkSpliteratorCharacteristics(sp, CONCURRENT | DISTINCT | NONNULL);
326          assertEquals(sp.estimateSize(), map.size());
327          Spliterator<Integer> sp2 = sp.trySplit();
328          sp.forEachRemaining((Integer x) -> adder.add(x.longValue()));
# Line 356 | Line 372 | public class ConcurrentHashMap8Test exte
372       * KeySet.containsAll returns true for collections with subset of elements
373       */
374      public void testContainsAll() {
375 <        Set full = populatedSet(3);
376 <        Vector v = new Vector();
377 <        v.add(one);
378 <        v.add(two);
379 <        assertTrue(full.containsAll(v));
380 <        v.add(six);
365 <        assertFalse(full.containsAll(v));
375 >        Collection full = populatedSet(3);
376 >        assertTrue(full.containsAll(Arrays.asList()));
377 >        assertTrue(full.containsAll(Arrays.asList(one)));
378 >        assertTrue(full.containsAll(Arrays.asList(one, two)));
379 >        assertFalse(full.containsAll(Arrays.asList(one, two, six)));
380 >        assertFalse(full.containsAll(Arrays.asList(six)));
381      }
382  
383      /**
384       * KeySet.isEmpty is true when empty, else false
385       */
386      public void testIsEmpty() {
387 <        Set empty = ConcurrentHashMap.newKeySet();
388 <        Set full = populatedSet(3);
374 <        assertTrue(empty.isEmpty());
375 <        assertFalse(full.isEmpty());
387 >        assertTrue(populatedSet(0).isEmpty());
388 >        assertFalse(populatedSet(3).isEmpty());
389      }
390  
391      /**
# Line 399 | Line 412 | public class ConcurrentHashMap8Test exte
412              assertTrue(it.hasNext());
413              it.next();
414          }
415 <        assertFalse(it.hasNext());
416 <        try {
417 <            it.next();
418 <            shouldThrow();
419 <        } catch (NoSuchElementException success) {}
415 >        assertIteratorExhausted(it);
416 >    }
417 >
418 >    /**
419 >     * iterator of empty collections has no elements
420 >     */
421 >    public void testEmptyIterator() {
422 >        assertIteratorExhausted(ConcurrentHashMap.newKeySet().iterator());
423 >        assertIteratorExhausted(new ConcurrentHashMap().entrySet().iterator());
424 >        assertIteratorExhausted(new ConcurrentHashMap().values().iterator());
425 >        assertIteratorExhausted(new ConcurrentHashMap().keySet().iterator());
426      }
427  
428      /**
# Line 437 | Line 456 | public class ConcurrentHashMap8Test exte
456       */
457      public void testRemoveAll() {
458          Set full = populatedSet(3);
459 <        Vector v = new Vector();
460 <        v.add(one);
461 <        v.add(two);
443 <        full.removeAll(v);
459 >        assertTrue(full.removeAll(Arrays.asList(one, two)));
460 >        assertEquals(1, full.size());
461 >        assertFalse(full.removeAll(Arrays.asList(one, two)));
462          assertEquals(1, full.size());
463      }
464  
# Line 531 | Line 549 | public class ConcurrentHashMap8Test exte
549  
550          assertNotSame(x, y);
551          assertEquals(x.size(), y.size());
534 –        assertEquals(x.toString(), y.toString());
535 –        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
552          assertEquals(x, y);
553          assertEquals(y, x);
554      }
# Line 984 | Line 1000 | public class ConcurrentHashMap8Test exte
1000      public void testSearchValuesSequentially() {
1001          ConcurrentHashMap<Long, Long> m = longMap();
1002          Long r;
1003 <        r = m.searchValues(Long.MAX_VALUE, (Long x) -> x.longValue() == (long)(SIZE/2)? x : null);
1003 >        r = m.searchValues(Long.MAX_VALUE,
1004 >            (Long x) -> (x.longValue() == (long)(SIZE/2)) ? x : null);
1005          assertEquals((long)r, (long)(SIZE/2));
1006 <        r = m.searchValues(Long.MAX_VALUE, (Long x) -> x.longValue() < 0L ? x : null);
1006 >        r = m.searchValues(Long.MAX_VALUE,
1007 >            (Long x) -> (x.longValue() < 0L) ? x : null);
1008          assertNull(r);
1009      }
1010  

Diff Legend

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