--- jsr166/src/test/tck/ConcurrentHashMap8Test.java	2013/03/22 16:10:19	1.4
+++ jsr166/src/test/tck/ConcurrentHashMap8Test.java	2013/04/11 20:03:44	1.8
@@ -699,7 +699,7 @@ public class ConcurrentHashMap8Test exte
         assertEquals(r.getKey().longValue(), (long)SIZE * (SIZE - 1) / 2);
     }
 
-    /*
+    /**
      * Mapped reduceKeysSequentially accumulates mapped keys
      */
     public void testMapReduceKeysSequentially() {
@@ -709,7 +709,7 @@ public class ConcurrentHashMap8Test exte
         assertEquals((long)r, (long)4 * SIZE * (SIZE - 1) / 2);
     }
 
-    /*
+    /**
      * Mapped reduceValuesSequentially accumulates mapped values
      */
     public void testMapReduceValuesSequentially() {
@@ -730,7 +730,7 @@ public class ConcurrentHashMap8Test exte
         assertEquals((long)r, (long)3 * SIZE * (SIZE - 1) / 2);
     }
 
-    /*
+    /**
      * Mapped reduceKeysInParallel, accumulates mapped keys
      */
     public void testMapReduceKeysInParallel() {
@@ -740,7 +740,7 @@ public class ConcurrentHashMap8Test exte
         assertEquals((long)r, (long)4 * SIZE * (SIZE - 1) / 2);
     }
 
-    /*
+    /**
      * Mapped reduceValuesInParallel accumulates mapped values
      */
     public void testMapReduceValuesInParallel() {
@@ -762,7 +762,7 @@ public class ConcurrentHashMap8Test exte
     }
 
 
-    /*
+    /**
      * reduceKeysToLongSequentially accumulates mapped keys
      */
     public void testReduceKeysToLongSequentially() {
@@ -771,16 +771,16 @@ public class ConcurrentHashMap8Test exte
         assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
     }
 
-    /*
+    /**
      * reduceKeysToIntSequentially accumulates mapped keys
      */
     public void testReduceKeysToIntSequentially() {
         ConcurrentHashMap<Long, Long> m = longMap();
         int ir = m.reduceKeysToIntSequentially((Long x) -> x.intValue(), 0, Integer::sum);
-        assertEquals(ir, (int)SIZE * (SIZE - 1) / 2);
+        assertEquals(ir, SIZE * (SIZE - 1) / 2);
     }
 
-    /*
+    /**
      * reduceKeysToDoubleSequentially accumulates mapped keys
      */
     public void testReduceKeysToDoubleSequentially() {
@@ -789,7 +789,7 @@ public class ConcurrentHashMap8Test exte
         assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
     }
 
-    /*
+    /**
      * reduceValuesToLongSequentially accumulates mapped values
      */
     public void testReduceValuesToLongSequentially() {
@@ -798,16 +798,16 @@ public class ConcurrentHashMap8Test exte
         assertEquals(lr, (long)SIZE * (SIZE - 1));
     }
 
-    /*
+    /**
      * reduceValuesToIntSequentially accumulates mapped values
      */
     public void testReduceValuesToIntSequentially() {
         ConcurrentHashMap<Long, Long> m = longMap();
         int ir = m.reduceValuesToIntSequentially((Long x) -> x.intValue(), 0, Integer::sum);
-        assertEquals(ir, (int)SIZE * (SIZE - 1));
+        assertEquals(ir, SIZE * (SIZE - 1));
     }
 
-    /*
+    /**
      * reduceValuesToDoubleSequentially accumulates mapped values
      */
     public void testReduceValuesToDoubleSequentially() {
@@ -816,7 +816,7 @@ public class ConcurrentHashMap8Test exte
         assertEquals(dr, (double)SIZE * (SIZE - 1));
     }
 
-    /*
+    /**
      * reduceKeysToLongInParallel accumulates mapped keys
      */
     public void testReduceKeysToLongInParallel() {
@@ -825,16 +825,16 @@ public class ConcurrentHashMap8Test exte
         assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
     }
 
-    /*
+    /**
      * reduceKeysToIntInParallel accumulates mapped keys
      */
     public void testReduceKeysToIntInParallel() {
         ConcurrentHashMap<Long, Long> m = longMap();
         int ir = m.reduceKeysToIntInParallel((Long x) -> x.intValue(), 0, Integer::sum);
-        assertEquals(ir, (int)SIZE * (SIZE - 1) / 2);
+        assertEquals(ir, SIZE * (SIZE - 1) / 2);
     }
 
-    /*
+    /**
      * reduceKeysToDoubleInParallel accumulates mapped values
      */
     public void testReduceKeysToDoubleInParallel() {
@@ -843,7 +843,7 @@ public class ConcurrentHashMap8Test exte
         assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
     }
 
-    /*
+    /**
      * reduceValuesToLongInParallel accumulates mapped values
      */
     public void testReduceValuesToLongInParallel() {
@@ -852,16 +852,16 @@ public class ConcurrentHashMap8Test exte
         assertEquals(lr, (long)SIZE * (SIZE - 1));
     }
 
-    /*
+    /**
      * reduceValuesToIntInParallel accumulates mapped values
      */
     public void testReduceValuesToIntInParallel() {
         ConcurrentHashMap<Long, Long> m = longMap();
         int ir = m.reduceValuesToIntInParallel((Long x) -> x.intValue(), 0, Integer::sum);
-        assertEquals(ir, (int)SIZE * (SIZE - 1));
+        assertEquals(ir, SIZE * (SIZE - 1));
     }
 
-    /*
+    /**
      * reduceValuesToDoubleInParallel accumulates mapped values
      */
     public void testReduceValuesToDoubleInParallel() {
@@ -1043,7 +1043,7 @@ public class ConcurrentHashMap8Test exte
         assertEquals(lr, (long)SIZE * (SIZE - 1) / 2);
         ir = ConcurrentHashMap.ForkJoinTasks.reduceKeysToInt
             (m, (Long x) -> x.intValue(), 0, Integer::sum).invoke();
-        assertEquals(ir, (int)SIZE * (SIZE - 1) / 2);
+        assertEquals(ir, SIZE * (SIZE - 1) / 2);
         dr = ConcurrentHashMap.ForkJoinTasks.reduceKeysToDouble
             (m, (Long x) -> x.doubleValue(), 0.0, Double::sum).invoke();
         assertEquals(dr, (double)SIZE * (SIZE - 1) / 2);
@@ -1056,7 +1056,7 @@ public class ConcurrentHashMap8Test exte
         assertEquals(lr, (long)SIZE * (SIZE - 1));
         ir = ConcurrentHashMap.ForkJoinTasks.reduceValuesToInt
             (m, (Long x) -> x.intValue(), 0, Integer::sum).invoke();
-        assertEquals(ir, (int)SIZE * (SIZE - 1));
+        assertEquals(ir, SIZE * (SIZE - 1));
         dr = ConcurrentHashMap.ForkJoinTasks.reduceValuesToDouble
             (m, (Long x) -> x.doubleValue(), 0.0, Double::sum).invoke();
         assertEquals(dr, (double)SIZE * (SIZE - 1));