--- jsr166/src/test/tck/LinkedTransferQueueTest.java	2011/11/26 05:42:14	1.51
+++ jsr166/src/test/tck/LinkedTransferQueueTest.java	2015/04/25 04:55:31	1.59
@@ -5,9 +5,10 @@
  * Other contributors include John Vint
  */
 
-import junit.framework.*;
-import java.util.Arrays;
+import static java.util.concurrent.TimeUnit.MILLISECONDS;
+
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
@@ -18,8 +19,8 @@ import java.util.concurrent.CountDownLat
 import java.util.concurrent.Executors;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.LinkedTransferQueue;
-import static java.util.concurrent.TimeUnit.MILLISECONDS;
-import static java.util.concurrent.TimeUnit.NANOSECONDS;
+
+import junit.framework.Test;
 
 @SuppressWarnings({"unchecked", "rawtypes"})
 public class LinkedTransferQueueTest extends JSR166TestCase {
@@ -31,7 +32,7 @@ public class LinkedTransferQueueTest ext
     }
 
     public static void main(String[] args) {
-        junit.textui.TestRunner.run(suite());
+        main(suite(), args);
     }
 
     public static Test suite() {
@@ -114,16 +115,16 @@ public class LinkedTransferQueueTest ext
      * remainingCapacity() always returns Integer.MAX_VALUE
      */
     public void testRemainingCapacity() {
-        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
+        BlockingQueue q = populatedQueue(SIZE);
         for (int i = 0; i < SIZE; ++i) {
             assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
             assertEquals(SIZE - i, q.size());
-            q.remove();
+            assertEquals(i, q.remove());
         }
         for (int i = 0; i < SIZE; ++i) {
             assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
             assertEquals(i, q.size());
-            q.add(i);
+            assertTrue(q.add(i));
         }
     }
 
@@ -499,11 +500,24 @@ public class LinkedTransferQueueTest ext
     public void testIterator() throws InterruptedException {
         LinkedTransferQueue q = populatedQueue(SIZE);
         Iterator it = q.iterator();
-        int i = 0;
-        while (it.hasNext()) {
-            assertEquals(it.next(), i++);
-        }
+        int i;
+        for (i = 0; it.hasNext(); i++)
+            assertTrue(q.contains(it.next()));
         assertEquals(i, SIZE);
+        assertIteratorExhausted(it);
+
+        it = q.iterator();
+        for (i = 0; it.hasNext(); i++)
+            assertEquals(it.next(), q.take());
+        assertEquals(i, SIZE);
+        assertIteratorExhausted(it);
+    }
+
+    /**
+     * iterator of empty collection has no elements
+     */
+    public void testEmptyIterator() {
+        assertIteratorExhausted(new LinkedTransferQueue().iterator());
     }
 
     /**
@@ -625,7 +639,7 @@ public class LinkedTransferQueueTest ext
         Queue x = populatedQueue(SIZE);
         Queue y = serialClone(x);
 
-        assertTrue(x != y);
+        assertNotSame(y, x);
         assertEquals(x.size(), y.size());
         assertEquals(x.toString(), y.toString());
         assertTrue(Arrays.equals(x.toArray(), y.toArray()));
@@ -696,8 +710,7 @@ public class LinkedTransferQueueTest ext
             assertEquals(SIZE - k, q.size());
             for (int j = 0; j < k; ++j)
                 assertEquals(j, l.get(j));
-            while (q.poll() != null)
-                ;
+            do {} while (q.poll() != null);
         }
     }
 
@@ -1013,4 +1026,19 @@ public class LinkedTransferQueueTest ext
         assertFalse(q.isEmpty());
         return q;
     }
+
+    /**
+     * remove(null), contains(null) always return false
+     */
+    public void testNeverContainsNull() {
+        Collection<?>[] qs = {
+            new LinkedTransferQueue<Object>(),
+            populatedQueue(2),
+        };
+
+        for (Collection<?> q : qs) {
+            assertFalse(q.contains(null));
+            assertFalse(q.remove(null));
+        }
+    }
 }