--- jsr166/src/test/tck/ConcurrentHashMap8Test.java	2013/05/21 19:11:16	1.9
+++ jsr166/src/test/tck/ConcurrentHashMap8Test.java	2013/07/22 18:11:56	1.14
@@ -9,6 +9,7 @@ import java.util.*;
 import java.util.function.*;
 import java.util.concurrent.atomic.LongAdder;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentHashMap.KeySetView;
 
 public class ConcurrentHashMap8Test extends JSR166TestCase {
     public static void main(String[] args) {
@@ -53,7 +54,7 @@ public class ConcurrentHashMap8Test exte
     }
 
     /**
-     * computeIfAbsent does not replace  if the key is already present
+     * computeIfAbsent does not replace if the key is already present
      */
     public void testComputeIfAbsent2() {
         ConcurrentHashMap map = map5();
@@ -70,7 +71,7 @@ public class ConcurrentHashMap8Test exte
     }
 
     /**
-     * computeIfPresent does not replace  if the key is already present
+     * computeIfPresent does not replace if the key is already present
      */
     public void testComputeIfPresent() {
         ConcurrentHashMap map = map5();
@@ -87,7 +88,7 @@ public class ConcurrentHashMap8Test exte
     }
 
     /**
-     * compute does not replace  if the function returns null
+     * compute does not replace if the function returns null
      */
     public void testCompute() {
         ConcurrentHashMap map = map5();
@@ -165,6 +166,19 @@ public class ConcurrentHashMap8Test exte
         return a;
     }
 
+    /*
+     * replaceAll replaces all matching values.
+     */
+    public void testReplaceAll() {
+        ConcurrentHashMap<Integer, String> map = map5();
+        map.replaceAll((x, y) -> {return x > 3 ? "Z" : y;});
+        assertEquals("A", map.get(one));
+        assertEquals("B", map.get(two));
+        assertEquals("C", map.get(three));
+        assertEquals("Z", map.get(four));
+        assertEquals("Z", map.get(five));
+    }
+
     /**
      * Default-constructed set is empty
      */
@@ -174,6 +188,29 @@ public class ConcurrentHashMap8Test exte
     }
 
     /**
+     * keySet.add adds the key with the established value to the map;
+     * remove removes it.
+     */
+    public void testKeySetAddRemove() {
+        ConcurrentHashMap map = map5();
+        Set set1 = map.keySet();
+        Set set2 = map.keySet(true);
+        set2.add(six);
+        assertTrue(((KeySetView)set2).getMap() == map);
+        assertTrue(((KeySetView)set1).getMap() == map);
+        assertEquals(set2.size(), map.size());
+        assertEquals(set1.size(), map.size());
+        assertTrue((Boolean)map.get(six));
+        assertTrue(set1.contains(six));
+        assertTrue(set2.contains(six));
+        set2.remove(six);
+        assertNull(map.get(six));
+        assertFalse(set1.contains(six));
+        assertFalse(set2.contains(six));
+    }
+
+
+    /**
      * keySet.addAll adds each element from the given collection
      */
     public void testAddAll() {
@@ -219,6 +256,67 @@ public class ConcurrentHashMap8Test exte
     }
 
     /**
+     * keySet.add throws UnsupportedOperationException if no default
+     * mapped value
+     */
+    public void testAdd4() {
+        Set full = map5().keySet();
+        try {
+            full.add(three);
+            shouldThrow();
+        } catch (UnsupportedOperationException e){}
+    }
+
+    /**
+     * keySet.add throws NullPointerException if the specified key is
+     * null
+     */
+    public void testAdd5() {
+        Set full = populatedSet(3);
+        try {
+            full.add(null);
+            shouldThrow();
+        } catch (NullPointerException e){}
+    }
+
+    /**
+     * KeySetView.getMappedValue returns the map's mapped value
+     */
+    public void testGetMappedValue() {
+        ConcurrentHashMap map = map5();
+        assertNull(map.keySet().getMappedValue());
+        try {
+            map.keySet(null);
+            shouldThrow();
+        } catch (NullPointerException e) {}
+        KeySetView set = map.keySet(one);
+        set.add(one);
+        set.add(six);
+        set.add(seven);
+        assertTrue(set.getMappedValue() == one);
+        assertTrue(map.get(one) != one);
+        assertTrue(map.get(six) == one);
+        assertTrue(map.get(seven) == one);
+    }
+
+    /**
+     * KeySetView.spliterator returns spliterator over the elements in this set
+     */
+    public void testKeySetSpliterator() {
+        LongAdder adder = new LongAdder();
+        ConcurrentHashMap map = map5();
+        Set set = map.keySet();
+        Spliterator<Integer> sp = set.spliterator();
+        assertEquals(sp.estimateSize(), map.size());
+        Spliterator<Integer> sp2 = sp.trySplit();
+        sp.forEachRemaining((Integer x) -> adder.add(x.longValue()));
+        long v = adder.sumThenReset();
+        sp2.forEachRemaining((Integer x) -> adder.add(x.longValue()));
+        long v2 = adder.sum();
+        assertEquals(v + v2, 15);
+    }
+
+    /**
      * keyset.clear removes all elements from the set
      */
     public void testClear() {
@@ -431,7 +529,7 @@ public class ConcurrentHashMap8Test exte
         Set x = populatedSet(size);
         Set y = serialClone(x);
 
-        assertTrue(x != y);
+        assertNotSame(x, y);
         assertEquals(x.size(), y.size());
         assertEquals(x.toString(), y.toString());
         assertTrue(Arrays.equals(x.toArray(), y.toArray()));
@@ -439,7 +537,6 @@ public class ConcurrentHashMap8Test exte
         assertEquals(y, x);
     }
 
-
     static final int SIZE = 10000;
     static ConcurrentHashMap<Long, Long> longMap;
 
@@ -637,7 +734,6 @@ public class ConcurrentHashMap8Test exte
         assertEquals(adder.sum(), 3 * SIZE * (SIZE - 1) / 2);
     }
 
-
     /**
      * reduceKeysSequentially accumulates across all keys,
      */
@@ -658,7 +754,6 @@ public class ConcurrentHashMap8Test exte
         assertEquals((long)r, (long)SIZE * (SIZE - 1) / 2);
     }
 
-
     /**
      * reduceEntriesSequentially accumulates across all entries
      */
@@ -761,7 +856,6 @@ public class ConcurrentHashMap8Test exte
         assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
     }
 
-
     /**
      * reduceKeysToLongSequentially accumulates mapped keys
      */