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.22 by jsr166, Sat Jan 17 22:55:06 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.Vector;
21   import java.util.concurrent.ConcurrentHashMap;
22 < import java.util.concurrent.ConcurrentHashMap.KeySetView;
22 > import java.util.concurrent.atomic.LongAdder;
23 > import java.util.function.BiFunction;
24 >
25 > import junit.framework.Test;
26 > import junit.framework.TestSuite;
27  
28   public class ConcurrentHashMap8Test extends JSR166TestCase {
29      public static void main(String[] args) {
# Line 166 | Line 180 | public class ConcurrentHashMap8Test exte
180          return a;
181      }
182  
183 <    /*
183 >    /**
184       * replaceAll replaces all matching values.
185       */
186      public void testReplaceAll() {
187          ConcurrentHashMap<Integer, String> map = map5();
188 <        map.replaceAll((x, y) -> {return x > 3 ? "Z" : y;});
188 >        map.replaceAll((x, y) -> { return x > 3 ? "Z" : y; });
189          assertEquals("A", map.get(one));
190          assertEquals("B", map.get(two));
191          assertEquals("C", map.get(three));
# Line 196 | Line 210 | public class ConcurrentHashMap8Test exte
210          Set set1 = map.keySet();
211          Set set2 = map.keySet(true);
212          set2.add(six);
213 <        assertTrue(((KeySetView)set2).getMap() == map);
214 <        assertTrue(((KeySetView)set1).getMap() == map);
213 >        assertTrue(((ConcurrentHashMap.KeySetView)set2).getMap() == map);
214 >        assertTrue(((ConcurrentHashMap.KeySetView)set1).getMap() == map);
215          assertEquals(set2.size(), map.size());
216          assertEquals(set1.size(), map.size());
217          assertTrue((Boolean)map.get(six));
# Line 209 | Line 223 | public class ConcurrentHashMap8Test exte
223          assertFalse(set2.contains(six));
224      }
225  
212 –
226      /**
227       * keySet.addAll adds each element from the given collection
228       */
# Line 289 | Line 302 | public class ConcurrentHashMap8Test exte
302              map.keySet(null);
303              shouldThrow();
304          } catch (NullPointerException e) {}
305 <        KeySetView set = map.keySet(one);
305 >        ConcurrentHashMap.KeySetView set = map.keySet(one);
306          set.add(one);
307          set.add(six);
308          set.add(seven);
# Line 299 | Line 312 | public class ConcurrentHashMap8Test exte
312          assertTrue(map.get(seven) == one);
313      }
314  
315 +    void checkSpliteratorCharacteristics(Spliterator<?> sp,
316 +                                         int requiredCharacteristics) {
317 +        assertEquals(requiredCharacteristics,
318 +                     requiredCharacteristics & sp.characteristics());
319 +    }
320 +
321      /**
322       * KeySetView.spliterator returns spliterator over the elements in this set
323       */
# Line 307 | Line 326 | public class ConcurrentHashMap8Test exte
326          ConcurrentHashMap map = map5();
327          Set set = map.keySet();
328          Spliterator<Integer> sp = set.spliterator();
329 +        checkSpliteratorCharacteristics(sp, CONCURRENT | DISTINCT | NONNULL);
330          assertEquals(sp.estimateSize(), map.size());
331          Spliterator<Integer> sp2 = sp.trySplit();
332          sp.forEachRemaining((Integer x) -> adder.add(x.longValue()));
# Line 399 | Line 419 | public class ConcurrentHashMap8Test exte
419              assertTrue(it.hasNext());
420              it.next();
421          }
422 <        assertFalse(it.hasNext());
423 <        try {
424 <            it.next();
425 <            shouldThrow();
426 <        } catch (NoSuchElementException success) {}
422 >        assertIteratorExhausted(it);
423 >    }
424 >
425 >    /**
426 >     * iterator of empty collections has no elements
427 >     */
428 >    public void testEmptyIterator() {
429 >        assertIteratorExhausted(ConcurrentHashMap.newKeySet().iterator());
430 >        assertIteratorExhausted(new ConcurrentHashMap().entrySet().iterator());
431 >        assertIteratorExhausted(new ConcurrentHashMap().values().iterator());
432 >        assertIteratorExhausted(new ConcurrentHashMap().keySet().iterator());
433      }
434  
435      /**
# Line 531 | Line 557 | public class ConcurrentHashMap8Test exte
557  
558          assertNotSame(x, y);
559          assertEquals(x.size(), y.size());
534 –        assertEquals(x.toString(), y.toString());
535 –        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
560          assertEquals(x, y);
561          assertEquals(y, x);
562      }
# Line 984 | Line 1008 | public class ConcurrentHashMap8Test exte
1008      public void testSearchValuesSequentially() {
1009          ConcurrentHashMap<Long, Long> m = longMap();
1010          Long r;
1011 <        r = m.searchValues(Long.MAX_VALUE, (Long x) -> x.longValue() == (long)(SIZE/2)? x : null);
1011 >        r = m.searchValues(Long.MAX_VALUE,
1012 >            (Long x) -> (x.longValue() == (long)(SIZE/2)) ? x : null);
1013          assertEquals((long)r, (long)(SIZE/2));
1014 <        r = m.searchValues(Long.MAX_VALUE, (Long x) -> x.longValue() < 0L ? x : null);
1014 >        r = m.searchValues(Long.MAX_VALUE,
1015 >            (Long x) -> (x.longValue() < 0L) ? x : null);
1016          assertNull(r);
1017      }
1018  

Diff Legend

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