From 0a0a8a57912eabdef88d671b53a8b05b82865bf3 Mon Sep 17 00:00:00 2001
From: Doug Lea <dl@openjdk.org>
Date: Mon, 25 Jun 2018 09:59:16 -0700
Subject: [PATCH] 8203681: Miscellaneous changes imported from jsr166 CVS
 2018-06

Reviewed-by: martin, psandoz
---
 .../util/concurrent/ArrayBlockingQueue.java   |  2 +-
 .../concurrent/ConcurrentSkipListMap.java     |  4 +--
 .../util/concurrent/CopyOnWriteArrayList.java |  4 +++
 .../java/util/concurrent/ForkJoinTask.java    |  2 +-
 .../java/util/concurrent/TimeUnit.java        |  6 +++-
 .../java/util/concurrent/locks/Condition.java |  6 ++--
 .../jdk/java/util/Collection/HotPotatoes.java |  3 +-
 .../Collection/IteratorMicroBenchmark.java    |  2 +-
 .../util/Collection/RemoveMicroBenchmark.java |  2 +-
 test/jdk/java/util/Map/LockStep.java          | 33 +++++++++----------
 .../ArrayBlockingQueue/WhiteBox.java          |  1 -
 .../ConcurrentHashMap/MapCheck.java           |  4 +--
 .../ConcurrentHashMap/MapLoops.java           |  3 +-
 .../ReentrantReadWriteLock/MapLoops.java      |  6 ++--
 .../AbstractQueuedLongSynchronizerTest.java   |  8 ++---
 .../tck/AbstractQueuedSynchronizerTest.java   |  8 ++---
 .../concurrent/tck/CompletableFutureTest.java |  4 +--
 .../tck/ConcurrentHashMap8Test.java           |  4 +--
 .../tck/ConcurrentLinkedDequeTest.java        | 13 +++++---
 .../tck/ConcurrentLinkedQueueTest.java        | 13 +++++---
 .../tck/ConcurrentSkipListSetTest.java        | 13 +++++---
 .../tck/ConcurrentSkipListSubSetTest.java     | 13 +++++---
 .../util/concurrent/tck/DelayQueueTest.java   | 15 +++++----
 .../tck/LinkedBlockingDequeTest.java          | 13 +++++---
 .../tck/LinkedBlockingQueueTest.java          | 13 +++++---
 .../util/concurrent/tck/LinkedListTest.java   | 13 +++++---
 .../tck/LinkedTransferQueueTest.java          | 15 +++++----
 .../tck/PriorityBlockingQueueTest.java        | 15 +++++----
 .../concurrent/tck/PriorityQueueTest.java     | 15 +++++----
 .../concurrent/tck/RecursiveActionTest.java   |  4 +--
 .../tck/SubmissionPublisherTest.java          |  4 +--
 .../java/util/concurrent/tck/TreeSetTest.java | 13 +++++---
 .../util/concurrent/tck/TreeSubSetTest.java   | 13 +++++---
 33 files changed, 164 insertions(+), 123 deletions(-)

diff --git a/src/java.base/share/classes/java/util/concurrent/ArrayBlockingQueue.java b/src/java.base/share/classes/java/util/concurrent/ArrayBlockingQueue.java
index c856b686c33..13fc3cee7f0 100644
--- a/src/java.base/share/classes/java/util/concurrent/ArrayBlockingQueue.java
+++ b/src/java.base/share/classes/java/util/concurrent/ArrayBlockingQueue.java
@@ -1129,7 +1129,7 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
                 final int len = items.length;
                 // how far takeIndex has advanced since the previous
                 // operation of this iterator
-                long dequeues = (cycles - prevCycles) * len
+                long dequeues = (long) (cycles - prevCycles) * len
                     + (takeIndex - prevTakeIndex);
 
                 // Check indices for invalidation
diff --git a/src/java.base/share/classes/java/util/concurrent/ConcurrentSkipListMap.java b/src/java.base/share/classes/java/util/concurrent/ConcurrentSkipListMap.java
index 8b179db6932..db14d4baf3a 100644
--- a/src/java.base/share/classes/java/util/concurrent/ConcurrentSkipListMap.java
+++ b/src/java.base/share/classes/java/util/concurrent/ConcurrentSkipListMap.java
@@ -1764,9 +1764,7 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
                 }
                 return true;
             }
-        } catch (ClassCastException unused) {
-            return false;
-        } catch (NullPointerException unused) {
+        } catch (ClassCastException | NullPointerException unused) {
             return false;
         }
     }
diff --git a/src/java.base/share/classes/java/util/concurrent/CopyOnWriteArrayList.java b/src/java.base/share/classes/java/util/concurrent/CopyOnWriteArrayList.java
index e725b1da740..a4414b54df8 100644
--- a/src/java.base/share/classes/java/util/concurrent/CopyOnWriteArrayList.java
+++ b/src/java.base/share/classes/java/util/concurrent/CopyOnWriteArrayList.java
@@ -34,6 +34,7 @@
 
 package java.util.concurrent;
 
+import java.lang.invoke.VarHandle;
 import java.lang.reflect.Field;
 import java.util.Arrays;
 import java.util.Collection;
@@ -299,6 +300,9 @@ public class CopyOnWriteArrayList<E>
             CopyOnWriteArrayList<E> clone =
                 (CopyOnWriteArrayList<E>) super.clone();
             clone.resetLock();
+            // Unlike in readObject, here we cannot visibility-piggyback on the
+            // volatile write in setArray().
+            VarHandle.releaseFence();
             return clone;
         } catch (CloneNotSupportedException e) {
             // this shouldn't happen, since we are Cloneable
diff --git a/src/java.base/share/classes/java/util/concurrent/ForkJoinTask.java b/src/java.base/share/classes/java/util/concurrent/ForkJoinTask.java
index b388992dad5..a451226f8d3 100644
--- a/src/java.base/share/classes/java/util/concurrent/ForkJoinTask.java
+++ b/src/java.base/share/classes/java/util/concurrent/ForkJoinTask.java
@@ -826,7 +826,7 @@ public abstract class ForkJoinTask<V> implements Future<V>, Serializable {
      */
     public static <T extends ForkJoinTask<?>> Collection<T> invokeAll(Collection<T> tasks) {
         if (!(tasks instanceof RandomAccess) || !(tasks instanceof List<?>)) {
-            invokeAll(tasks.toArray(new ForkJoinTask<?>[tasks.size()]));
+            invokeAll(tasks.toArray(new ForkJoinTask<?>[0]));
             return tasks;
         }
         @SuppressWarnings("unchecked")
diff --git a/src/java.base/share/classes/java/util/concurrent/TimeUnit.java b/src/java.base/share/classes/java/util/concurrent/TimeUnit.java
index 7942fb55816..f02aa9f5931 100644
--- a/src/java.base/share/classes/java/util/concurrent/TimeUnit.java
+++ b/src/java.base/share/classes/java/util/concurrent/TimeUnit.java
@@ -202,6 +202,10 @@ public enum TimeUnit {
      * {@code unit.convert(Duration.of(n, unit.toChronoUnit()))}
      * is equivalent to {@code n} (in the absence of overflow).
      *
+     * @apiNote
+     * This method differs from {@link Duration#toNanos()} in that it
+     * does not throw {@link ArithmeticException} on numeric overflow.
+     *
      * @param duration the time duration
      * @return the converted duration in this unit,
      * or {@code Long.MIN_VALUE} if conversion would negatively overflow,
@@ -216,7 +220,7 @@ public enum TimeUnit {
         if (secs < 0 && nano > 0) {
             // use representation compatible with integer division
             secs++;
-            nano -= SECOND_SCALE;
+            nano -= (int) SECOND_SCALE;
         }
         final long s, nanoVal;
         // Optimize for the common case - NANOSECONDS without overflow
diff --git a/src/java.base/share/classes/java/util/concurrent/locks/Condition.java b/src/java.base/share/classes/java/util/concurrent/locks/Condition.java
index c5cf2c0d06d..cf747024d3d 100644
--- a/src/java.base/share/classes/java/util/concurrent/locks/Condition.java
+++ b/src/java.base/share/classes/java/util/concurrent/locks/Condition.java
@@ -312,13 +312,13 @@ public interface Condition {
      * <pre> {@code
      * boolean aMethod(long timeout, TimeUnit unit)
      *     throws InterruptedException {
-     *   long nanos = unit.toNanos(timeout);
+     *   long nanosRemaining = unit.toNanos(timeout);
      *   lock.lock();
      *   try {
      *     while (!conditionBeingWaitedFor()) {
-     *       if (nanos <= 0L)
+     *       if (nanosRemaining <= 0L)
      *         return false;
-     *       nanos = theCondition.awaitNanos(nanos);
+     *       nanosRemaining = theCondition.awaitNanos(nanosRemaining);
      *     }
      *     // ...
      *     return true;
diff --git a/test/jdk/java/util/Collection/HotPotatoes.java b/test/jdk/java/util/Collection/HotPotatoes.java
index 2570b1ce774..ea43c393943 100644
--- a/test/jdk/java/util/Collection/HotPotatoes.java
+++ b/test/jdk/java/util/Collection/HotPotatoes.java
@@ -70,7 +70,8 @@ public class HotPotatoes {
             System.out.printf("implClazz=%s, argClazz=%s\n",
                               implClazz.getName(), argClazz.getName());
             final int iterations = 100000;
-            final List<Integer> list = (List<Integer>) argClazz.newInstance();
+            final List<Integer> list = (List<Integer>)
+                argClazz.getDeclaredConstructor().newInstance();
             final Integer one = Integer.valueOf(1);
             final List<Integer> oneElementList = Collections.singletonList(one);
             final Constructor<? extends Collection> constr
diff --git a/test/jdk/java/util/Collection/IteratorMicroBenchmark.java b/test/jdk/java/util/Collection/IteratorMicroBenchmark.java
index ed7afc5c241..9020e2e33c3 100644
--- a/test/jdk/java/util/Collection/IteratorMicroBenchmark.java
+++ b/test/jdk/java/util/Collection/IteratorMicroBenchmark.java
@@ -325,7 +325,7 @@ public class IteratorMicroBenchmark {
     }
 
     @SafeVarargs @SuppressWarnings("varargs")
-    private <T> Stream<T> concatStreams(Stream<T> ... streams) {
+    private static <T> Stream<T> concatStreams(Stream<T> ... streams) {
         return Stream.of(streams).flatMap(s -> s);
     }
 
diff --git a/test/jdk/java/util/Collection/RemoveMicroBenchmark.java b/test/jdk/java/util/Collection/RemoveMicroBenchmark.java
index 951ad7bafc5..fedbd6f06fd 100644
--- a/test/jdk/java/util/Collection/RemoveMicroBenchmark.java
+++ b/test/jdk/java/util/Collection/RemoveMicroBenchmark.java
@@ -284,7 +284,7 @@ public class RemoveMicroBenchmark {
     }
 
     @SafeVarargs @SuppressWarnings("varargs")
-    private <T> Stream<T> concatStreams(Stream<T> ... streams) {
+    private static <T> Stream<T> concatStreams(Stream<T> ... streams) {
         return Stream.of(streams).flatMap(s -> s);
     }
 
diff --git a/test/jdk/java/util/Map/LockStep.java b/test/jdk/java/util/Map/LockStep.java
index 440088794e2..0560a5ab695 100644
--- a/test/jdk/java/util/Map/LockStep.java
+++ b/test/jdk/java/util/Map/LockStep.java
@@ -28,7 +28,6 @@
  * @key randomness
  */
 
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.Hashtable;
@@ -104,23 +103,21 @@ public class LockStep {
         final Random r = new Random();
 
         for (int i = 0; i < iterations; i++) {
-            List<Map> maps = Arrays.asList(
-                new Map[] {
-                    new IdentityHashMap(11),
-                    new HashMap(16),
-                    new LinkedHashMap(16),
-                    new WeakHashMap(16),
-                    new Hashtable(16),
-                    new TreeMap(),
-                    new ConcurrentHashMap(16),
-                    new ConcurrentSkipListMap(),
-                    Collections.checkedMap(new HashMap(16), Integer.class, Integer.class),
-                    Collections.checkedSortedMap(new TreeMap(), Integer.class, Integer.class),
-                    Collections.checkedNavigableMap(new TreeMap(), Integer.class, Integer.class),
-                    Collections.synchronizedMap(new HashMap(16)),
-                    Collections.synchronizedSortedMap(new TreeMap()),
-                    Collections.synchronizedNavigableMap(new TreeMap())
-                    });
+            List<Map> maps = List.of(
+                new IdentityHashMap(11),
+                new HashMap(16),
+                new LinkedHashMap(16),
+                new WeakHashMap(16),
+                new Hashtable(16),
+                new TreeMap(),
+                new ConcurrentHashMap(16),
+                new ConcurrentSkipListMap(),
+                Collections.checkedMap(new HashMap(16), Integer.class, Integer.class),
+                Collections.checkedSortedMap(new TreeMap(), Integer.class, Integer.class),
+                Collections.checkedNavigableMap(new TreeMap(), Integer.class, Integer.class),
+                Collections.synchronizedMap(new HashMap(16)),
+                Collections.synchronizedSortedMap(new TreeMap()),
+                Collections.synchronizedNavigableMap(new TreeMap()));
 
             for (int j = 0; j < 10; j++)
                 put(maps, r.nextInt(100), r.nextInt(100));
diff --git a/test/jdk/java/util/concurrent/ArrayBlockingQueue/WhiteBox.java b/test/jdk/java/util/concurrent/ArrayBlockingQueue/WhiteBox.java
index c1489c95ac1..3e3bc315899 100644
--- a/test/jdk/java/util/concurrent/ArrayBlockingQueue/WhiteBox.java
+++ b/test/jdk/java/util/concurrent/ArrayBlockingQueue/WhiteBox.java
@@ -59,7 +59,6 @@ import java.util.Queue;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ThreadLocalRandom;
-import java.util.concurrent.TimeUnit;
 import java.util.function.BooleanSupplier;
 
 @Test
diff --git a/test/jdk/java/util/concurrent/ConcurrentHashMap/MapCheck.java b/test/jdk/java/util/concurrent/ConcurrentHashMap/MapCheck.java
index 5c77baccebd..942e2e81fd7 100644
--- a/test/jdk/java/util/concurrent/ConcurrentHashMap/MapCheck.java
+++ b/test/jdk/java/util/concurrent/ConcurrentHashMap/MapCheck.java
@@ -109,7 +109,7 @@ public class MapCheck {
 
     static Map newMap(Class cl) {
         try {
-            return (Map)cl.newInstance();
+            return (Map)cl.getDeclaredConstructor().newInstance();
         } catch (Exception e) {
             throw new RuntimeException("Can't instantiate " + cl + ": " + e);
         }
@@ -407,7 +407,7 @@ public class MapCheck {
         timer.start("Put (putAll)           ", size * 2);
         Map s2 = null;
         try {
-            s2 = (Map) (s.getClass().newInstance());
+            s2 = (Map) s.getClass().getDeclaredConstructor().newInstance();
             s2.putAll(s);
         }
         catch (Exception e) { e.printStackTrace(); return; }
diff --git a/test/jdk/java/util/concurrent/ConcurrentHashMap/MapLoops.java b/test/jdk/java/util/concurrent/ConcurrentHashMap/MapLoops.java
index 9ac21a75dd3..028dabb00dd 100644
--- a/test/jdk/java/util/concurrent/ConcurrentHashMap/MapLoops.java
+++ b/test/jdk/java/util/concurrent/ConcurrentHashMap/MapLoops.java
@@ -156,7 +156,8 @@ public class MapLoops {
 
     static void test(int i, int nkeys, Class mapClass) throws Exception {
         System.out.print("Threads: " + i + "\t:");
-        Map<Integer, Integer> map = (Map<Integer,Integer>)mapClass.newInstance();
+        Map<Integer, Integer> map = (Map<Integer, Integer>)
+            mapClass.getDeclaredConstructor().newInstance();
         Integer[] key = makeKeys(nkeys);
         // Uncomment to start with a non-empty table
         //        for (int j = 0; j < nkeys; j += 4) // start 1/4 occupied
diff --git a/test/jdk/java/util/concurrent/locks/ReentrantReadWriteLock/MapLoops.java b/test/jdk/java/util/concurrent/locks/ReentrantReadWriteLock/MapLoops.java
index 4c44f6a2dbe..aec57e0cbd0 100644
--- a/test/jdk/java/util/concurrent/locks/ReentrantReadWriteLock/MapLoops.java
+++ b/test/jdk/java/util/concurrent/locks/ReentrantReadWriteLock/MapLoops.java
@@ -104,7 +104,8 @@ public class MapLoops {
         // warmup
         System.out.println("Warmup...");
         for (int k = 0; k < 2; ++k) {
-            Map<Integer, Integer> map = (Map<Integer,Integer>)mapClass.newInstance();
+            Map<Integer, Integer> map = (Map<Integer, Integer>)
+                mapClass.getDeclaredConstructor().newInstance();
             LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
             CyclicBarrier barrier = new CyclicBarrier(1, timer);
             new Runner(map, key, barrier, rnd.split()).run();
@@ -113,7 +114,8 @@ public class MapLoops {
 
         for (int i = 1; i <= maxThreads; i += (i+1) >>> 1) {
             System.out.print("Threads: " + i + "\t:");
-            Map<Integer, Integer> map = (Map<Integer,Integer>)mapClass.newInstance();
+            Map<Integer, Integer> map = (Map<Integer, Integer>)
+                mapClass.getDeclaredConstructor().newInstance();
             LoopHelpers.BarrierTimer timer = new LoopHelpers.BarrierTimer();
             CyclicBarrier barrier = new CyclicBarrier(i+1, timer);
             for (int k = 0; k < i; ++k)
diff --git a/test/jdk/java/util/concurrent/tck/AbstractQueuedLongSynchronizerTest.java b/test/jdk/java/util/concurrent/tck/AbstractQueuedLongSynchronizerTest.java
index 9f64f1e5a3a..578b289c26a 100644
--- a/test/jdk/java/util/concurrent/tck/AbstractQueuedLongSynchronizerTest.java
+++ b/test/jdk/java/util/concurrent/tck/AbstractQueuedLongSynchronizerTest.java
@@ -251,8 +251,8 @@ public class AbstractQueuedLongSynchronizerTest extends JSR166TestCase {
             assertTrue(c.await(timeoutMillis, MILLISECONDS));
             break;
         case awaitNanos:
-            long nanosTimeout = MILLISECONDS.toNanos(timeoutMillis);
-            long nanosRemaining = c.awaitNanos(nanosTimeout);
+            long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
+            long nanosRemaining = c.awaitNanos(timeoutNanos);
             assertTrue(nanosRemaining > 0);
             break;
         case awaitUntil:
@@ -279,8 +279,8 @@ public class AbstractQueuedLongSynchronizerTest extends JSR166TestCase {
                 break;
             case awaitNanos:
                 startTime = System.nanoTime();
-                long nanosTimeout = MILLISECONDS.toNanos(timeoutMillis);
-                long nanosRemaining = c.awaitNanos(nanosTimeout);
+                long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
+                long nanosRemaining = c.awaitNanos(timeoutNanos);
                 assertTrue(nanosRemaining <= 0);
                 assertTrue(nanosRemaining > -MILLISECONDS.toNanos(LONG_DELAY_MS));
                 assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
diff --git a/test/jdk/java/util/concurrent/tck/AbstractQueuedSynchronizerTest.java b/test/jdk/java/util/concurrent/tck/AbstractQueuedSynchronizerTest.java
index 8749166b183..73d92c9d40d 100644
--- a/test/jdk/java/util/concurrent/tck/AbstractQueuedSynchronizerTest.java
+++ b/test/jdk/java/util/concurrent/tck/AbstractQueuedSynchronizerTest.java
@@ -255,8 +255,8 @@ public class AbstractQueuedSynchronizerTest extends JSR166TestCase {
             assertTrue(c.await(timeoutMillis, MILLISECONDS));
             break;
         case awaitNanos:
-            long nanosTimeout = MILLISECONDS.toNanos(timeoutMillis);
-            long nanosRemaining = c.awaitNanos(nanosTimeout);
+            long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
+            long nanosRemaining = c.awaitNanos(timeoutNanos);
             assertTrue(nanosRemaining > 0);
             break;
         case awaitUntil:
@@ -283,8 +283,8 @@ public class AbstractQueuedSynchronizerTest extends JSR166TestCase {
                 break;
             case awaitNanos:
                 startTime = System.nanoTime();
-                long nanosTimeout = MILLISECONDS.toNanos(timeoutMillis);
-                long nanosRemaining = c.awaitNanos(nanosTimeout);
+                long timeoutNanos = MILLISECONDS.toNanos(timeoutMillis);
+                long nanosRemaining = c.awaitNanos(timeoutNanos);
                 assertTrue(nanosRemaining <= 0);
                 assertTrue(nanosRemaining > -MILLISECONDS.toNanos(LONG_DELAY_MS));
                 assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
diff --git a/test/jdk/java/util/concurrent/tck/CompletableFutureTest.java b/test/jdk/java/util/concurrent/tck/CompletableFutureTest.java
index cf37f3582fe..5ff6da3ca9f 100644
--- a/test/jdk/java/util/concurrent/tck/CompletableFutureTest.java
+++ b/test/jdk/java/util/concurrent/tck/CompletableFutureTest.java
@@ -4415,7 +4415,7 @@ public class CompletableFutureTest extends JSR166TestCase {
             f.complete(null);
 
             f = new CompletableFuture<>();
-            CompletableFuture.anyOf(new CompletableFuture<?>[] { f, incomplete });
+            CompletableFuture.anyOf(f, incomplete);
             f.complete(null);
         }
 
@@ -4433,7 +4433,7 @@ public class CompletableFutureTest extends JSR166TestCase {
             f.complete(null);
 
             f = new CompletableFuture<>();
-            CompletableFuture.anyOf(new CompletableFuture<?>[] { incomplete, f });
+            CompletableFuture.anyOf(incomplete, f);
             f.complete(null);
         }
     }
diff --git a/test/jdk/java/util/concurrent/tck/ConcurrentHashMap8Test.java b/test/jdk/java/util/concurrent/tck/ConcurrentHashMap8Test.java
index f02f400a7a3..4088978c07a 100644
--- a/test/jdk/java/util/concurrent/tck/ConcurrentHashMap8Test.java
+++ b/test/jdk/java/util/concurrent/tck/ConcurrentHashMap8Test.java
@@ -200,8 +200,8 @@ public class ConcurrentHashMap8Test extends JSR166TestCase {
     static Set populatedSet(Integer[] elements) {
         Set<Integer> a = ConcurrentHashMap.<Integer>newKeySet();
         assertTrue(a.isEmpty());
-        for (int i = 0; i < elements.length; i++)
-            assertTrue(a.add(elements[i]));
+        for (Integer element : elements)
+            assertTrue(a.add(element));
         assertFalse(a.isEmpty());
         assertEquals(elements.length, a.size());
         return a;
diff --git a/test/jdk/java/util/concurrent/tck/ConcurrentLinkedDequeTest.java b/test/jdk/java/util/concurrent/tck/ConcurrentLinkedDequeTest.java
index 2f205bb9ab4..0eee93dc436 100644
--- a/test/jdk/java/util/concurrent/tck/ConcurrentLinkedDequeTest.java
+++ b/test/jdk/java/util/concurrent/tck/ConcurrentLinkedDequeTest.java
@@ -689,9 +689,11 @@ public class ConcurrentLinkedDequeTest extends JSR166TestCase {
      */
     public void testToArray() {
         ConcurrentLinkedDeque q = populatedDeque(SIZE);
-        Object[] o = q.toArray();
-        for (int i = 0; i < o.length; i++)
-            assertSame(o[i], q.poll());
+        Object[] a = q.toArray();
+        assertSame(Object[].class, a.getClass());
+        for (Object o : a)
+            assertSame(o, q.poll());
+        assertTrue(q.isEmpty());
     }
 
     /**
@@ -702,8 +704,9 @@ public class ConcurrentLinkedDequeTest extends JSR166TestCase {
         Integer[] ints = new Integer[SIZE];
         Integer[] array = q.toArray(ints);
         assertSame(ints, array);
-        for (int i = 0; i < ints.length; i++)
-            assertSame(ints[i], q.poll());
+        for (Integer o : ints)
+            assertSame(o, q.poll());
+        assertTrue(q.isEmpty());
     }
 
     /**
diff --git a/test/jdk/java/util/concurrent/tck/ConcurrentLinkedQueueTest.java b/test/jdk/java/util/concurrent/tck/ConcurrentLinkedQueueTest.java
index e42f13d0738..badf29ca2e7 100644
--- a/test/jdk/java/util/concurrent/tck/ConcurrentLinkedQueueTest.java
+++ b/test/jdk/java/util/concurrent/tck/ConcurrentLinkedQueueTest.java
@@ -416,9 +416,11 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase {
      */
     public void testToArray() {
         ConcurrentLinkedQueue q = populatedQueue(SIZE);
-        Object[] o = q.toArray();
-        for (int i = 0; i < o.length; i++)
-            assertSame(o[i], q.poll());
+        Object[] a = q.toArray();
+        assertSame(Object[].class, a.getClass());
+        for (Object o : a)
+            assertSame(o, q.poll());
+        assertTrue(q.isEmpty());
     }
 
     /**
@@ -429,8 +431,9 @@ public class ConcurrentLinkedQueueTest extends JSR166TestCase {
         Integer[] ints = new Integer[SIZE];
         Integer[] array = q.toArray(ints);
         assertSame(ints, array);
-        for (int i = 0; i < ints.length; i++)
-            assertSame(ints[i], q.poll());
+        for (Integer o : ints)
+            assertSame(o, q.poll());
+        assertTrue(q.isEmpty());
     }
 
     /**
diff --git a/test/jdk/java/util/concurrent/tck/ConcurrentSkipListSetTest.java b/test/jdk/java/util/concurrent/tck/ConcurrentSkipListSetTest.java
index ff92a2fad7d..3941b23476c 100644
--- a/test/jdk/java/util/concurrent/tck/ConcurrentSkipListSetTest.java
+++ b/test/jdk/java/util/concurrent/tck/ConcurrentSkipListSetTest.java
@@ -483,9 +483,11 @@ public class ConcurrentSkipListSetTest extends JSR166TestCase {
      */
     public void testToArray() {
         ConcurrentSkipListSet q = populatedSet(SIZE);
-        Object[] o = q.toArray();
-        for (int i = 0; i < o.length; i++)
-            assertSame(o[i], q.pollFirst());
+        Object[] a = q.toArray();
+        assertSame(Object[].class, a.getClass());
+        for (Object o : a)
+            assertSame(o, q.pollFirst());
+        assertTrue(q.isEmpty());
     }
 
     /**
@@ -495,8 +497,9 @@ public class ConcurrentSkipListSetTest extends JSR166TestCase {
         ConcurrentSkipListSet<Integer> q = populatedSet(SIZE);
         Integer[] ints = new Integer[SIZE];
         assertSame(ints, q.toArray(ints));
-        for (int i = 0; i < ints.length; i++)
-            assertSame(ints[i], q.pollFirst());
+        for (Integer o : ints)
+            assertSame(o, q.pollFirst());
+        assertTrue(q.isEmpty());
     }
 
     /**
diff --git a/test/jdk/java/util/concurrent/tck/ConcurrentSkipListSubSetTest.java b/test/jdk/java/util/concurrent/tck/ConcurrentSkipListSubSetTest.java
index 1d8aa25ac1f..6df5830333d 100644
--- a/test/jdk/java/util/concurrent/tck/ConcurrentSkipListSubSetTest.java
+++ b/test/jdk/java/util/concurrent/tck/ConcurrentSkipListSubSetTest.java
@@ -434,9 +434,11 @@ public class ConcurrentSkipListSubSetTest extends JSR166TestCase {
      */
     public void testToArray() {
         NavigableSet q = populatedSet(SIZE);
-        Object[] o = q.toArray();
-        for (int i = 0; i < o.length; i++)
-            assertSame(o[i], q.pollFirst());
+        Object[] a = q.toArray();
+        assertSame(Object[].class, a.getClass());
+        for (Object o : a)
+            assertSame(o, q.pollFirst());
+        assertTrue(q.isEmpty());
     }
 
     /**
@@ -447,8 +449,9 @@ public class ConcurrentSkipListSubSetTest extends JSR166TestCase {
         Integer[] ints = new Integer[SIZE];
         Integer[] array = q.toArray(ints);
         assertSame(ints, array);
-        for (int i = 0; i < ints.length; i++)
-            assertSame(ints[i], q.pollFirst());
+        for (Integer o : ints)
+            assertSame(o, q.pollFirst());
+        assertTrue(q.isEmpty());
     }
 
     /**
diff --git a/test/jdk/java/util/concurrent/tck/DelayQueueTest.java b/test/jdk/java/util/concurrent/tck/DelayQueueTest.java
index 9d5fe107d9f..6c2cfe0584b 100644
--- a/test/jdk/java/util/concurrent/tck/DelayQueueTest.java
+++ b/test/jdk/java/util/concurrent/tck/DelayQueueTest.java
@@ -593,10 +593,12 @@ public class DelayQueueTest extends JSR166TestCase {
      */
     public void testToArray() throws InterruptedException {
         DelayQueue q = populatedQueue(SIZE);
-        Object[] o = q.toArray();
-        Arrays.sort(o);
-        for (int i = 0; i < o.length; i++)
-            assertSame(o[i], q.take());
+        Object[] a = q.toArray();
+        assertSame(Object[].class, a.getClass());
+        Arrays.sort(a);
+        for (Object o : a)
+            assertSame(o, q.take());
+        assertTrue(q.isEmpty());
     }
 
     /**
@@ -608,8 +610,9 @@ public class DelayQueueTest extends JSR166TestCase {
         PDelay[] array = q.toArray(ints);
         assertSame(ints, array);
         Arrays.sort(ints);
-        for (int i = 0; i < ints.length; i++)
-            assertSame(ints[i], q.remove());
+        for (PDelay o : ints)
+            assertSame(o, q.remove());
+        assertTrue(q.isEmpty());
     }
 
     /**
diff --git a/test/jdk/java/util/concurrent/tck/LinkedBlockingDequeTest.java b/test/jdk/java/util/concurrent/tck/LinkedBlockingDequeTest.java
index 5388fbaa1a9..fa8b5d1db6e 100644
--- a/test/jdk/java/util/concurrent/tck/LinkedBlockingDequeTest.java
+++ b/test/jdk/java/util/concurrent/tck/LinkedBlockingDequeTest.java
@@ -1570,9 +1570,11 @@ public class LinkedBlockingDequeTest extends JSR166TestCase {
      */
     public void testToArray() throws InterruptedException {
         LinkedBlockingDeque q = populatedDeque(SIZE);
-        Object[] o = q.toArray();
-        for (int i = 0; i < o.length; i++)
-            assertSame(o[i], q.poll());
+        Object[] a = q.toArray();
+        assertSame(Object[].class, a.getClass());
+        for (Object o : a)
+            assertSame(o, q.poll());
+        assertTrue(q.isEmpty());
     }
 
     /**
@@ -1583,8 +1585,9 @@ public class LinkedBlockingDequeTest extends JSR166TestCase {
         Integer[] ints = new Integer[SIZE];
         Integer[] array = q.toArray(ints);
         assertSame(ints, array);
-        for (int i = 0; i < ints.length; i++)
-            assertSame(ints[i], q.remove());
+        for (Integer o : ints)
+            assertSame(o, q.remove());
+        assertTrue(q.isEmpty());
     }
 
     /**
diff --git a/test/jdk/java/util/concurrent/tck/LinkedBlockingQueueTest.java b/test/jdk/java/util/concurrent/tck/LinkedBlockingQueueTest.java
index a58aa5df784..6349d601923 100644
--- a/test/jdk/java/util/concurrent/tck/LinkedBlockingQueueTest.java
+++ b/test/jdk/java/util/concurrent/tck/LinkedBlockingQueueTest.java
@@ -656,9 +656,11 @@ public class LinkedBlockingQueueTest extends JSR166TestCase {
      */
     public void testToArray() {
         LinkedBlockingQueue q = populatedQueue(SIZE);
-        Object[] o = q.toArray();
-        for (int i = 0; i < o.length; i++)
-            assertSame(o[i], q.poll());
+        Object[] a = q.toArray();
+        assertSame(Object[].class, a.getClass());
+        for (Object o : a)
+            assertSame(o, q.poll());
+        assertTrue(q.isEmpty());
     }
 
     /**
@@ -669,8 +671,9 @@ public class LinkedBlockingQueueTest extends JSR166TestCase {
         Integer[] ints = new Integer[SIZE];
         Integer[] array = q.toArray(ints);
         assertSame(ints, array);
-        for (int i = 0; i < ints.length; i++)
-            assertSame(ints[i], q.poll());
+        for (Integer o : ints)
+            assertSame(o, q.poll());
+        assertTrue(q.isEmpty());
     }
 
     /**
diff --git a/test/jdk/java/util/concurrent/tck/LinkedListTest.java b/test/jdk/java/util/concurrent/tck/LinkedListTest.java
index 47c4ab6b939..d0ced2831e7 100644
--- a/test/jdk/java/util/concurrent/tck/LinkedListTest.java
+++ b/test/jdk/java/util/concurrent/tck/LinkedListTest.java
@@ -385,9 +385,11 @@ public class LinkedListTest extends JSR166TestCase {
      */
     public void testToArray() {
         LinkedList q = populatedQueue(SIZE);
-        Object[] o = q.toArray();
-        for (int i = 0; i < o.length; i++)
-            assertSame(o[i], q.poll());
+        Object[] a = q.toArray();
+        assertSame(Object[].class, a.getClass());
+        for (Object o : a)
+            assertSame(o, q.poll());
+        assertTrue(q.isEmpty());
     }
 
     /**
@@ -398,8 +400,9 @@ public class LinkedListTest extends JSR166TestCase {
         Integer[] ints = new Integer[SIZE];
         Integer[] array = q.toArray(ints);
         assertSame(ints, array);
-        for (int i = 0; i < ints.length; i++)
-            assertSame(ints[i], q.poll());
+        for (Integer o : ints)
+            assertSame(o, q.poll());
+        assertTrue(q.isEmpty());
     }
 
     /**
diff --git a/test/jdk/java/util/concurrent/tck/LinkedTransferQueueTest.java b/test/jdk/java/util/concurrent/tck/LinkedTransferQueueTest.java
index bea78963f8f..7bda06d4df2 100644
--- a/test/jdk/java/util/concurrent/tck/LinkedTransferQueueTest.java
+++ b/test/jdk/java/util/concurrent/tck/LinkedTransferQueueTest.java
@@ -502,10 +502,11 @@ public class LinkedTransferQueueTest extends JSR166TestCase {
      */
     public void testToArray() {
         LinkedTransferQueue q = populatedQueue(SIZE);
-        Object[] o = q.toArray();
-        for (int i = 0; i < o.length; i++) {
-            assertSame(o[i], q.poll());
-        }
+        Object[] a = q.toArray();
+        assertSame(Object[].class, a.getClass());
+        for (Object o : a)
+            assertSame(o, q.poll());
+        assertTrue(q.isEmpty());
     }
 
     /**
@@ -516,9 +517,9 @@ public class LinkedTransferQueueTest extends JSR166TestCase {
         Integer[] ints = new Integer[SIZE];
         Integer[] array = q.toArray(ints);
         assertSame(ints, array);
-        for (int i = 0; i < ints.length; i++) {
-            assertSame(ints[i], q.poll());
-        }
+        for (Integer o : ints)
+            assertSame(o, q.poll());
+        assertTrue(q.isEmpty());
     }
 
     /**
diff --git a/test/jdk/java/util/concurrent/tck/PriorityBlockingQueueTest.java b/test/jdk/java/util/concurrent/tck/PriorityBlockingQueueTest.java
index a00d17f20db..8a00ce81054 100644
--- a/test/jdk/java/util/concurrent/tck/PriorityBlockingQueueTest.java
+++ b/test/jdk/java/util/concurrent/tck/PriorityBlockingQueueTest.java
@@ -600,10 +600,12 @@ public class PriorityBlockingQueueTest extends JSR166TestCase {
      */
     public void testToArray() throws InterruptedException {
         PriorityBlockingQueue q = populatedQueue(SIZE);
-        Object[] o = q.toArray();
-        Arrays.sort(o);
-        for (int i = 0; i < o.length; i++)
-            assertSame(o[i], q.take());
+        Object[] a = q.toArray();
+        assertSame(Object[].class, a.getClass());
+        Arrays.sort(a);
+        for (Object o : a)
+            assertSame(o, q.take());
+        assertTrue(q.isEmpty());
     }
 
     /**
@@ -615,8 +617,9 @@ public class PriorityBlockingQueueTest extends JSR166TestCase {
         Integer[] array = q.toArray(ints);
         assertSame(ints, array);
         Arrays.sort(ints);
-        for (int i = 0; i < ints.length; i++)
-            assertSame(ints[i], q.take());
+        for (Integer o : ints)
+            assertSame(o, q.take());
+        assertTrue(q.isEmpty());
     }
 
     /**
diff --git a/test/jdk/java/util/concurrent/tck/PriorityQueueTest.java b/test/jdk/java/util/concurrent/tck/PriorityQueueTest.java
index ff600f64319..fd8783ac9d2 100644
--- a/test/jdk/java/util/concurrent/tck/PriorityQueueTest.java
+++ b/test/jdk/java/util/concurrent/tck/PriorityQueueTest.java
@@ -463,10 +463,12 @@ public class PriorityQueueTest extends JSR166TestCase {
      */
     public void testToArray() {
         PriorityQueue q = populatedQueue(SIZE);
-        Object[] o = q.toArray();
-        Arrays.sort(o);
-        for (int i = 0; i < o.length; i++)
-            assertSame(o[i], q.poll());
+        Object[] a = q.toArray();
+        assertSame(Object[].class, a.getClass());
+        Arrays.sort(a);
+        for (Object o : a)
+            assertSame(o, q.poll());
+        assertTrue(q.isEmpty());
     }
 
     /**
@@ -478,8 +480,9 @@ public class PriorityQueueTest extends JSR166TestCase {
         Integer[] array = q.toArray(ints);
         assertSame(ints, array);
         Arrays.sort(ints);
-        for (int i = 0; i < ints.length; i++)
-            assertSame(ints[i], q.poll());
+        for (Integer o : ints)
+            assertSame(o, q.poll());
+        assertTrue(q.isEmpty());
     }
 
     /**
diff --git a/test/jdk/java/util/concurrent/tck/RecursiveActionTest.java b/test/jdk/java/util/concurrent/tck/RecursiveActionTest.java
index b318cd1e913..a3d16c75bb3 100644
--- a/test/jdk/java/util/concurrent/tck/RecursiveActionTest.java
+++ b/test/jdk/java/util/concurrent/tck/RecursiveActionTest.java
@@ -364,8 +364,8 @@ public class RecursiveActionTest extends JSR166TestCase {
                 fibActions[4].cancel(true);
                 fibActions[5].completeExceptionally(new FJException());
 
-                for (int i = 0; i < fibActions.length; i++)
-                    fibActions[i].fork();
+                for (FibAction fibAction : fibActions)
+                    fibAction.fork();
 
                 sq.put(fibActions);
 
diff --git a/test/jdk/java/util/concurrent/tck/SubmissionPublisherTest.java b/test/jdk/java/util/concurrent/tck/SubmissionPublisherTest.java
index d340ddd9acc..6eb5be656aa 100644
--- a/test/jdk/java/util/concurrent/tck/SubmissionPublisherTest.java
+++ b/test/jdk/java/util/concurrent/tck/SubmissionPublisherTest.java
@@ -361,9 +361,7 @@ public class SubmissionPublisherTest extends JSR166TestCase {
         TestSubscriber s = new TestSubscriber();
         SubmissionPublisher<Integer> p = basicPublisher();
         s.throwOnCall = true;
-        try {
-            p.subscribe(s);
-        } catch (Exception ok) {}
+        p.subscribe(s);
         s.awaitError();
         assertEquals(0, s.nexts);
         assertEquals(1, s.errors);
diff --git a/test/jdk/java/util/concurrent/tck/TreeSetTest.java b/test/jdk/java/util/concurrent/tck/TreeSetTest.java
index 4d3fe24815a..4234e66ec87 100644
--- a/test/jdk/java/util/concurrent/tck/TreeSetTest.java
+++ b/test/jdk/java/util/concurrent/tck/TreeSetTest.java
@@ -481,9 +481,11 @@ public class TreeSetTest extends JSR166TestCase {
      */
     public void testToArray() {
         TreeSet q = populatedSet(SIZE);
-        Object[] o = q.toArray();
-        for (int i = 0; i < o.length; i++)
-            assertSame(o[i], q.pollFirst());
+        Object[] a = q.toArray();
+        assertSame(Object[].class, a.getClass());
+        for (Object o : a)
+            assertSame(o, q.pollFirst());
+        assertTrue(q.isEmpty());
     }
 
     /**
@@ -494,8 +496,9 @@ public class TreeSetTest extends JSR166TestCase {
         Integer[] ints = new Integer[SIZE];
         Integer[] array = q.toArray(ints);
         assertSame(ints, array);
-        for (int i = 0; i < ints.length; i++)
-            assertSame(ints[i], q.pollFirst());
+        for (Integer o : ints)
+            assertSame(o, q.pollFirst());
+        assertTrue(q.isEmpty());
     }
 
     /**
diff --git a/test/jdk/java/util/concurrent/tck/TreeSubSetTest.java b/test/jdk/java/util/concurrent/tck/TreeSubSetTest.java
index 10e37e9f7b4..d9ce1c7d214 100644
--- a/test/jdk/java/util/concurrent/tck/TreeSubSetTest.java
+++ b/test/jdk/java/util/concurrent/tck/TreeSubSetTest.java
@@ -432,9 +432,11 @@ public class TreeSubSetTest extends JSR166TestCase {
      */
     public void testToArray() {
         NavigableSet q = populatedSet(SIZE);
-        Object[] o = q.toArray();
-        for (int i = 0; i < o.length; i++)
-            assertSame(o[i], q.pollFirst());
+        Object[] a = q.toArray();
+        assertSame(Object[].class, a.getClass());
+        for (Object o : a)
+            assertSame(o, q.pollFirst());
+        assertTrue(q.isEmpty());
     }
 
     /**
@@ -445,8 +447,9 @@ public class TreeSubSetTest extends JSR166TestCase {
         Integer[] ints = new Integer[SIZE];
         Integer[] array = q.toArray(ints);
         assertSame(ints, array);
-        for (int i = 0; i < ints.length; i++)
-            assertSame(ints[i], q.pollFirst());
+        for (Integer o : ints)
+            assertSame(o, q.pollFirst());
+        assertTrue(q.isEmpty());
     }
 
     /**