--- jsr166/src/test/tck/ConcurrentHashMap8Test.java	2014/12/31 21:39:07	1.20
+++ jsr166/src/test/tck/ConcurrentHashMap8Test.java	2015/04/25 04:55:30	1.28
@@ -17,7 +17,6 @@ import java.util.Map;
 import java.util.NoSuchElementException;
 import java.util.Set;
 import java.util.Spliterator;
-import java.util.Vector;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.atomic.LongAdder;
 import java.util.function.BiFunction;
@@ -27,7 +26,7 @@ import junit.framework.TestSuite;
 
 public class ConcurrentHashMap8Test extends JSR166TestCase {
     public static void main(String[] args) {
-        junit.textui.TestRunner.run(suite());
+        main(suite(), args);
     }
     public static Test suite() {
         return new TestSuite(ConcurrentHashMap8Test.class);
@@ -164,8 +163,8 @@ public class ConcurrentHashMap8Test exte
         Set<Integer> a = ConcurrentHashMap.<Integer>newKeySet();
         assertTrue(a.isEmpty());
         for (int i = 0; i < n; i++)
-            a.add(i);
-        assertFalse(a.isEmpty());
+            assertTrue(a.add(i));
+        assertEquals(n == 0, a.isEmpty());
         assertEquals(n, a.size());
         return a;
     }
@@ -174,7 +173,7 @@ public class ConcurrentHashMap8Test exte
         Set<Integer> a = ConcurrentHashMap.<Integer>newKeySet();
         assertTrue(a.isEmpty());
         for (int i = 0; i < elements.length; i++)
-            a.add(elements[i]);
+            assertTrue(a.add(elements[i]));
         assertFalse(a.isEmpty());
         assertEquals(elements.length, a.size());
         return a;
@@ -223,17 +222,14 @@ public class ConcurrentHashMap8Test exte
         assertFalse(set2.contains(six));
     }
 
-
     /**
      * keySet.addAll adds each element from the given collection
      */
     public void testAddAll() {
         Set full = populatedSet(3);
-        Vector v = new Vector();
-        v.add(three);
-        v.add(four);
-        v.add(five);
-        full.addAll(v);
+        assertTrue(full.addAll(Arrays.asList(three, four, five)));
+        assertEquals(6, full.size());
+        assertFalse(full.addAll(Arrays.asList(three, four, five)));
         assertEquals(6, full.size());
     }
 
@@ -243,11 +239,10 @@ public class ConcurrentHashMap8Test exte
      */
     public void testAddAll2() {
         Set full = populatedSet(3);
-        Vector v = new Vector();
-        v.add(three);
-        v.add(four);
-        v.add(one); // will not add this element
-        full.addAll(v);
+        // "one" is duplicate and will not be added
+        assertTrue(full.addAll(Arrays.asList(three, four, one)));
+        assertEquals(5, full.size());
+        assertFalse(full.addAll(Arrays.asList(three, four, one)));
         assertEquals(5, full.size());
     }
 
@@ -256,7 +251,7 @@ public class ConcurrentHashMap8Test exte
      */
     public void testAdd2() {
         Set full = populatedSet(3);
-        full.add(one);
+        assertFalse(full.add(one));
         assertEquals(3, full.size());
     }
 
@@ -265,7 +260,9 @@ public class ConcurrentHashMap8Test exte
      */
     public void testAdd3() {
         Set full = populatedSet(3);
-        full.add(three);
+        assertTrue(full.add(three));
+        assertTrue(full.contains(three));
+        assertFalse(full.add(three));
         assertTrue(full.contains(three));
     }
 
@@ -278,7 +275,7 @@ public class ConcurrentHashMap8Test exte
         try {
             full.add(three);
             shouldThrow();
-        } catch (UnsupportedOperationException e){}
+        } catch (UnsupportedOperationException success) {}
     }
 
     /**
@@ -290,7 +287,7 @@ public class ConcurrentHashMap8Test exte
         try {
             full.add(null);
             shouldThrow();
-        } catch (NullPointerException e){}
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -302,11 +299,11 @@ public class ConcurrentHashMap8Test exte
         try {
             map.keySet(null);
             shouldThrow();
-        } catch (NullPointerException e) {}
+        } catch (NullPointerException success) {}
         ConcurrentHashMap.KeySetView set = map.keySet(one);
-        set.add(one);
-        set.add(six);
-        set.add(seven);
+        assertFalse(set.add(one));
+        assertTrue(set.add(six));
+        assertTrue(set.add(seven));
         assertTrue(set.getMappedValue() == one);
         assertTrue(map.get(one) != one);
         assertTrue(map.get(six) == one);
@@ -377,23 +374,20 @@ public class ConcurrentHashMap8Test exte
      * KeySet.containsAll returns true for collections with subset of elements
      */
     public void testContainsAll() {
-        Set full = populatedSet(3);
-        Vector v = new Vector();
-        v.add(one);
-        v.add(two);
-        assertTrue(full.containsAll(v));
-        v.add(six);
-        assertFalse(full.containsAll(v));
+        Collection full = populatedSet(3);
+        assertTrue(full.containsAll(Arrays.asList()));
+        assertTrue(full.containsAll(Arrays.asList(one)));
+        assertTrue(full.containsAll(Arrays.asList(one, two)));
+        assertFalse(full.containsAll(Arrays.asList(one, two, six)));
+        assertFalse(full.containsAll(Arrays.asList(six)));
     }
 
     /**
      * KeySet.isEmpty is true when empty, else false
      */
     public void testIsEmpty() {
-        Set empty = ConcurrentHashMap.newKeySet();
-        Set full = populatedSet(3);
-        assertTrue(empty.isEmpty());
-        assertFalse(full.isEmpty());
+        assertTrue(populatedSet(0).isEmpty());
+        assertFalse(populatedSet(3).isEmpty());
     }
 
     /**
@@ -420,11 +414,17 @@ public class ConcurrentHashMap8Test exte
             assertTrue(it.hasNext());
             it.next();
         }
-        assertFalse(it.hasNext());
-        try {
-            it.next();
-            shouldThrow();
-        } catch (NoSuchElementException success) {}
+        assertIteratorExhausted(it);
+    }
+
+    /**
+     * iterator of empty collections has no elements
+     */
+    public void testEmptyIterator() {
+        assertIteratorExhausted(ConcurrentHashMap.newKeySet().iterator());
+        assertIteratorExhausted(new ConcurrentHashMap().entrySet().iterator());
+        assertIteratorExhausted(new ConcurrentHashMap().values().iterator());
+        assertIteratorExhausted(new ConcurrentHashMap().keySet().iterator());
     }
 
     /**
@@ -458,10 +458,9 @@ public class ConcurrentHashMap8Test exte
      */
     public void testRemoveAll() {
         Set full = populatedSet(3);
-        Vector v = new Vector();
-        v.add(one);
-        v.add(two);
-        full.removeAll(v);
+        assertTrue(full.removeAll(Arrays.asList(one, two)));
+        assertEquals(1, full.size());
+        assertFalse(full.removeAll(Arrays.asList(one, two)));
         assertEquals(1, full.size());
     }