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.23 by jsr166, Fri Feb 27 19:47:57 2015 UTC vs.
Revision 1.31 by jsr166, Wed Aug 24 22:22:39 2016 UTC

# Line 11 | Line 11 | import static java.util.Spliterator.NONN
11   import java.util.AbstractMap;
12   import java.util.Arrays;
13   import java.util.Collection;
14 – import java.util.Collections;
14   import java.util.Iterator;
15   import java.util.Map;
16   import java.util.NoSuchElementException;
# Line 26 | Line 25 | import junit.framework.TestSuite;
25  
26   public class ConcurrentHashMap8Test extends JSR166TestCase {
27      public static void main(String[] args) {
28 <        junit.textui.TestRunner.run(suite());
28 >        main(suite(), args);
29      }
30      public static Test suite() {
31          return new TestSuite(ConcurrentHashMap8Test.class);
# Line 163 | Line 162 | public class ConcurrentHashMap8Test exte
162          Set<Integer> a = ConcurrentHashMap.<Integer>newKeySet();
163          assertTrue(a.isEmpty());
164          for (int i = 0; i < n; i++)
165 <            a.add(i);
165 >            assertTrue(a.add(i));
166          assertEquals(n == 0, a.isEmpty());
167          assertEquals(n, a.size());
168          return a;
# Line 173 | Line 172 | public class ConcurrentHashMap8Test exte
172          Set<Integer> a = ConcurrentHashMap.<Integer>newKeySet();
173          assertTrue(a.isEmpty());
174          for (int i = 0; i < elements.length; i++)
175 <            a.add(elements[i]);
175 >            assertTrue(a.add(elements[i]));
176          assertFalse(a.isEmpty());
177          assertEquals(elements.length, a.size());
178          return a;
# Line 251 | Line 250 | public class ConcurrentHashMap8Test exte
250       */
251      public void testAdd2() {
252          Set full = populatedSet(3);
253 <        full.add(one);
253 >        assertFalse(full.add(one));
254          assertEquals(3, full.size());
255      }
256  
# Line 260 | Line 259 | public class ConcurrentHashMap8Test exte
259       */
260      public void testAdd3() {
261          Set full = populatedSet(3);
262 <        full.add(three);
262 >        assertTrue(full.add(three));
263 >        assertTrue(full.contains(three));
264 >        assertFalse(full.add(three));
265          assertTrue(full.contains(three));
266      }
267  
# Line 273 | Line 274 | public class ConcurrentHashMap8Test exte
274          try {
275              full.add(three);
276              shouldThrow();
277 <        } catch (UnsupportedOperationException e){}
277 >        } catch (UnsupportedOperationException success) {}
278      }
279  
280      /**
# Line 285 | Line 286 | public class ConcurrentHashMap8Test exte
286          try {
287              full.add(null);
288              shouldThrow();
289 <        } catch (NullPointerException e){}
289 >        } catch (NullPointerException success) {}
290      }
291  
292      /**
# Line 297 | Line 298 | public class ConcurrentHashMap8Test exte
298          try {
299              map.keySet(null);
300              shouldThrow();
301 <        } catch (NullPointerException e) {}
301 >        } catch (NullPointerException success) {}
302          ConcurrentHashMap.KeySetView set = map.keySet(one);
303 <        set.add(one);
304 <        set.add(six);
305 <        set.add(seven);
303 >        assertFalse(set.add(one));
304 >        assertTrue(set.add(six));
305 >        assertTrue(set.add(seven));
306          assertTrue(set.getMappedValue() == one);
307          assertTrue(map.get(one) != one);
308          assertTrue(map.get(six) == one);
# Line 404 | Line 405 | public class ConcurrentHashMap8Test exte
405          Integer[] elements = new Integer[size];
406          for (int i = 0; i < size; i++)
407              elements[i] = i;
408 <        Collections.shuffle(Arrays.asList(elements));
408 >        shuffle(elements);
409          Collection<Integer> full = populatedSet(elements);
410  
411          Iterator it = full.iterator();
# Line 494 | Line 495 | public class ConcurrentHashMap8Test exte
495          Integer[] elements = new Integer[size];
496          for (int i = 0; i < size; i++)
497              elements[i] = i;
498 <        Collections.shuffle(Arrays.asList(elements));
498 >        shuffle(elements);
499          Collection<Integer> full = populatedSet(elements);
500  
501          assertTrue(Arrays.asList(elements).containsAll(Arrays.asList(full.toArray())));
# Line 514 | Line 515 | public class ConcurrentHashMap8Test exte
515          a = new Integer[0];
516          assertSame(a, empty.toArray(a));
517  
518 <        a = new Integer[size/2];
518 >        a = new Integer[size / 2];
519          Arrays.fill(a, 42);
520          assertSame(a, empty.toArray(a));
521          assertNull(a[0]);
# Line 524 | Line 525 | public class ConcurrentHashMap8Test exte
525          Integer[] elements = new Integer[size];
526          for (int i = 0; i < size; i++)
527              elements[i] = i;
528 <        Collections.shuffle(Arrays.asList(elements));
528 >        shuffle(elements);
529          Collection<Integer> full = populatedSet(elements);
530  
531          Arrays.fill(a, 42);

Diff Legend

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