--- jsr166/src/test/tck/LinkedTransferQueueTest.java	2009/08/15 00:35:01	1.12
+++ jsr166/src/test/tck/LinkedTransferQueueTest.java	2009/11/21 21:00:34	1.18
@@ -13,7 +13,6 @@ import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.ConcurrentModificationException;
 import java.util.Iterator;
 import java.util.List;
 import java.util.NoSuchElementException;
@@ -45,18 +44,15 @@ public class LinkedTransferQueueTest ext
         try {
             q.element();
             shouldThrow();
-        } catch (NoSuchElementException success) {
-        }
+        } catch (NoSuchElementException success) {}
         try {
             q.iterator().next();
             shouldThrow();
-        } catch (NoSuchElementException success) {
-        }
+        } catch (NoSuchElementException success) {}
         try {
             q.remove();
             shouldThrow();
-        } catch (NoSuchElementException success) {
-        }
+        } catch (NoSuchElementException success) {}
     }
 
     /**
@@ -76,8 +72,7 @@ public class LinkedTransferQueueTest ext
         try {
             new LinkedTransferQueue(null);
             shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -89,8 +84,7 @@ public class LinkedTransferQueueTest ext
             Integer[] ints = new Integer[SIZE];
             new LinkedTransferQueue(Arrays.asList(ints));
             shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -105,8 +99,7 @@ public class LinkedTransferQueueTest ext
             }
             new LinkedTransferQueue(Arrays.asList(ints));
             shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -158,8 +151,7 @@ public class LinkedTransferQueueTest ext
             LinkedTransferQueue q = new LinkedTransferQueue();
             q.offer(null);
             shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -170,8 +162,7 @@ public class LinkedTransferQueueTest ext
             LinkedTransferQueue q = new LinkedTransferQueue();
             q.add(null);
             shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -182,8 +173,7 @@ public class LinkedTransferQueueTest ext
             LinkedTransferQueue q = new LinkedTransferQueue();
             q.addAll(null);
             shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -194,8 +184,7 @@ public class LinkedTransferQueueTest ext
             LinkedTransferQueue q = populatedQueue(SIZE);
             q.addAll(q);
             shouldThrow();
-        } catch (IllegalArgumentException success) {
-        }
+        } catch (IllegalArgumentException success) {}
     }
 
     /**
@@ -207,8 +196,7 @@ public class LinkedTransferQueueTest ext
             Integer[] ints = new Integer[SIZE];
             q.addAll(Arrays.asList(ints));
             shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -224,8 +212,7 @@ public class LinkedTransferQueueTest ext
             }
             q.addAll(Arrays.asList(ints));
             shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -355,7 +342,7 @@ public class LinkedTransferQueueTest ext
      */
     public void testInterruptedTimedPoll() throws InterruptedException {
         final LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
-        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
+        Thread t = newStartedThread(new CheckedRunnable() {
             void realRun() throws InterruptedException {
                 for (int i = 0; i < SIZE; ++i) {
                     long t0 = System.nanoTime();
@@ -364,8 +351,12 @@ public class LinkedTransferQueueTest ext
                     long millisElapsed = (System.nanoTime() - t0)/(1024 * 1024);
                     assertTrue(millisElapsed < SMALL_DELAY_MS);
                 }
-                q.poll(LONG_DELAY_MS, MILLISECONDS);
+                try {
+                    q.poll(LONG_DELAY_MS, MILLISECONDS);
+                    shouldThrow();
+                } catch (InterruptedException success) {}
             }});
+
         Thread.sleep(SMALL_DELAY_MS);
         t.interrupt();
         t.join();
@@ -378,12 +369,16 @@ public class LinkedTransferQueueTest ext
      */
     public void testTimedPollWithOffer() throws InterruptedException {
         final LinkedTransferQueue q = new LinkedTransferQueue();
-        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
+        Thread t = new Thread(new CheckedRunnable() {
             void realRun() throws InterruptedException {
-                threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
-                q.poll(LONG_DELAY_MS, MILLISECONDS);
-                q.poll(LONG_DELAY_MS, MILLISECONDS);
+                assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
+                assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
+                try {
+                    q.poll(LONG_DELAY_MS, MILLISECONDS);
+                    shouldThrow();
+                } catch (InterruptedException success) {}
             }});
+
         Thread.sleep(SMALL_DELAY_MS);
         assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
         t.interrupt();
@@ -417,8 +412,7 @@ public class LinkedTransferQueueTest ext
         try {
             q.element();
             shouldThrow();
-        } catch (NoSuchElementException success) {
-        }
+        } catch (NoSuchElementException success) {}
         checkEmpty(q);
     }
 
@@ -433,8 +427,7 @@ public class LinkedTransferQueueTest ext
         try {
             q.remove();
             shouldThrow();
-        } catch (NoSuchElementException success) {
-        }
+        } catch (NoSuchElementException success) {}
         checkEmpty(q);
     }
 
@@ -545,7 +538,7 @@ public class LinkedTransferQueueTest ext
     }
 
     /**
-     * toArray contains all elements
+     * toArray() contains all elements
      */
     public void testToArray() throws InterruptedException {
         LinkedTransferQueue q = populatedQueue(SIZE);
@@ -575,20 +568,18 @@ public class LinkedTransferQueueTest ext
             LinkedTransferQueue q = populatedQueue(SIZE);
             Object o[] = q.toArray(null);
             shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
-     * toArray with incompatible array type throws CCE
+     * toArray(incompatible array type) throws CCE
      */
     public void testToArray1_BadArg() {
         try {
             LinkedTransferQueue q = populatedQueue(SIZE);
             Object o[] = q.toArray(new String[10]);
             shouldThrow();
-        } catch (ArrayStoreException success) {
-        }
+        } catch (ArrayStoreException success) {}
     }
 
     /**
@@ -692,7 +683,7 @@ public class LinkedTransferQueueTest ext
     }
 
     /**
-     * poll retrieves elements across Executor threads
+     * timed poll retrieves elements across Executor threads
      */
     public void testPollInExecutor() {
         final LinkedTransferQueue q = new LinkedTransferQueue();
@@ -747,8 +738,7 @@ public class LinkedTransferQueueTest ext
         try {
             q.drainTo(null);
             shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -759,8 +749,7 @@ public class LinkedTransferQueueTest ext
         try {
             q.drainTo(q);
             shouldThrow();
-        } catch (IllegalArgumentException success) {
-        }
+        } catch (IllegalArgumentException success) {}
     }
 
     /**
@@ -790,7 +779,7 @@ public class LinkedTransferQueueTest ext
     }
 
     /**
-     * drainTo empties full queue, unblocking a waiting put.
+     * drainTo(c) empties full queue, unblocking a waiting put.
      */
     public void testDrainToWithActivePut() throws InterruptedException {
         final LinkedTransferQueue q = populatedQueue(SIZE);
@@ -816,8 +805,7 @@ public class LinkedTransferQueueTest ext
         try {
             q.drainTo(null, SIZE);
             shouldThrow();
-        } catch (NullPointerException success) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -828,8 +816,7 @@ public class LinkedTransferQueueTest ext
         try {
             q.drainTo(q, SIZE);
             shouldThrow();
-        } catch (IllegalArgumentException success) {
-        }
+        } catch (IllegalArgumentException success) {}
     }
 
     /**
@@ -855,23 +842,27 @@ public class LinkedTransferQueueTest ext
     }
 
     /**
-     * poll and take decrement the waiting consumer count
+     * timed poll() or take() increments the waiting consumer count;
+     * offer(e) decrements the waiting consumer count
      */
     public void testWaitingConsumer() throws InterruptedException {
         final LinkedTransferQueue q = new LinkedTransferQueue();
-        final ConsumerObserver waiting = new ConsumerObserver();
+        assertEquals(q.getWaitingConsumerCount(), 0);
+        assertFalse(q.hasWaitingConsumer());
 
         Thread t = newStartedThread(new CheckedRunnable() {
             void realRun() throws InterruptedException {
                 Thread.sleep(SMALL_DELAY_MS);
                 threadAssertTrue(q.hasWaitingConsumer());
-                waiting.setWaitingConsumer(q.getWaitingConsumerCount());
+                threadAssertEquals(q.getWaitingConsumerCount(), 1);
                 threadAssertTrue(q.offer(new Object()));
+                threadAssertFalse(q.hasWaitingConsumer());
+                threadAssertEquals(q.getWaitingConsumerCount(), 0);
             }});
 
         assertTrue(q.poll(LONG_DELAY_MS, MILLISECONDS) != null);
-        assertTrue(q.getWaitingConsumerCount()
-                   < waiting.getWaitingConsumers());
+        assertEquals(q.getWaitingConsumerCount(), 0);
+        assertFalse(q.hasWaitingConsumer());
         t.join();
     }
 
@@ -883,8 +874,7 @@ public class LinkedTransferQueueTest ext
             LinkedTransferQueue q = new LinkedTransferQueue();
             q.transfer(null);
             shouldThrow();
-        } catch (NullPointerException ex) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -991,8 +981,7 @@ public class LinkedTransferQueueTest ext
             final LinkedTransferQueue q = new LinkedTransferQueue();
             q.tryTransfer(null);
             shouldThrow();
-        } catch (NullPointerException ex) {
-        }
+        } catch (NullPointerException success) {}
     }
 
     /**
@@ -1121,8 +1110,8 @@ public class LinkedTransferQueueTest ext
         assertFalse(q.tryTransfer(five, SHORT_DELAY_MS, MILLISECONDS));
         assertEquals(1, q.size());
         assertEquals(four, q.poll());
-        checkEmpty(q);
         assertNull(q.poll());
+        checkEmpty(q);
     }
 
     private LinkedTransferQueue<Integer> populatedQueue(int n) {
@@ -1136,20 +1125,4 @@ public class LinkedTransferQueueTest ext
         assertFalse(q.isEmpty());
         return q;
     }
-
-    private static class ConsumerObserver {
-
-        private int waitingConsumers;
-
-        private ConsumerObserver() {
-        }
-
-        private void setWaitingConsumer(int i) {
-            this.waitingConsumers = i;
-        }
-
-        private int getWaitingConsumers() {
-            return waitingConsumers;
-        }
-    }
 }