--- jsr166/src/test/tck/SynchronousQueueTest.java	2019/12/16 22:55:54	1.67
+++ jsr166/src/test/tck/SynchronousQueueTest.java	2021/01/26 13:33:06	1.68
@@ -51,10 +51,10 @@ public class SynchronousQueueTest extend
     public void testEmptyFull()      { testEmptyFull(false); }
     public void testEmptyFull_fair() { testEmptyFull(true); }
     public void testEmptyFull(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         assertTrue(q.isEmpty());
-        assertEquals(0, q.size());
-        assertEquals(0, q.remainingCapacity());
+        mustEqual(0, q.size());
+        mustEqual(0, q.remainingCapacity());
         assertFalse(q.offer(zero));
     }
 
@@ -64,7 +64,7 @@ public class SynchronousQueueTest extend
     public void testOffer()      { testOffer(false); }
     public void testOffer_fair() { testOffer(true); }
     public void testOffer(boolean fair) {
-        SynchronousQueue q = new SynchronousQueue(fair);
+        SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         assertFalse(q.offer(one));
     }
 
@@ -74,8 +74,8 @@ public class SynchronousQueueTest extend
     public void testAdd()      { testAdd(false); }
     public void testAdd_fair() { testAdd(true); }
     public void testAdd(boolean fair) {
-        SynchronousQueue q = new SynchronousQueue(fair);
-        assertEquals(0, q.remainingCapacity());
+        SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
+        mustEqual(0, q.remainingCapacity());
         try {
             q.add(one);
             shouldThrow();
@@ -88,24 +88,22 @@ public class SynchronousQueueTest extend
     public void testAddAll_self()      { testAddAll_self(false); }
     public void testAddAll_self_fair() { testAddAll_self(true); }
     public void testAddAll_self(boolean fair) {
-        SynchronousQueue q = new SynchronousQueue(fair);
+        SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         try {
             q.addAll(q);
             shouldThrow();
         } catch (IllegalArgumentException success) {}
     }
 
-    /**
+    /**S
      * addAll throws IllegalStateException if no active taker
      */
     public void testAddAll_ISE()      { testAddAll_ISE(false); }
     public void testAddAll_ISE_fair() { testAddAll_ISE(true); }
     public void testAddAll_ISE(boolean fair) {
-        SynchronousQueue q = new SynchronousQueue(fair);
-        Integer[] ints = new Integer[1];
-        for (int i = 0; i < ints.length; i++)
-            ints[i] = i;
-        Collection<Integer> coll = Arrays.asList(ints);
+        SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
+        Item[] items = seqItems(1);
+        Collection<Item> coll = Arrays.asList(items);
         try {
             q.addAll(coll);
             shouldThrow();
@@ -118,20 +116,20 @@ public class SynchronousQueueTest extend
     public void testBlockingPut()      { testBlockingPut(false); }
     public void testBlockingPut_fair() { testBlockingPut(true); }
     public void testBlockingPut(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
         Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 Thread.currentThread().interrupt();
                 try {
-                    q.put(99);
+                    q.put(ninetynine);
                     shouldThrow();
                 } catch (InterruptedException success) {}
                 assertFalse(Thread.interrupted());
 
                 pleaseInterrupt.countDown();
                 try {
-                    q.put(99);
+                    q.put(ninetynine);
                     shouldThrow();
                 } catch (InterruptedException success) {}
                 assertFalse(Thread.interrupted());
@@ -141,7 +139,7 @@ public class SynchronousQueueTest extend
         if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
         t.interrupt();
         awaitTermination(t);
-        assertEquals(0, q.remainingCapacity());
+        mustEqual(0, q.remainingCapacity());
     }
 
     /**
@@ -150,7 +148,7 @@ public class SynchronousQueueTest extend
     public void testPutWithTake()      { testPutWithTake(false); }
     public void testPutWithTake_fair() { testPutWithTake(true); }
     public void testPutWithTake(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         final CountDownLatch pleaseTake = new CountDownLatch(1);
         final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
         Thread t = newStartedThread(new CheckedRunnable() {
@@ -160,21 +158,21 @@ public class SynchronousQueueTest extend
 
                 Thread.currentThread().interrupt();
                 try {
-                    q.put(99);
+                    q.put(ninetynine);
                     shouldThrow();
                 } catch (InterruptedException success) {}
                 assertFalse(Thread.interrupted());
 
                 pleaseInterrupt.countDown();
                 try {
-                    q.put(99);
+                    q.put(ninetynine);
                     shouldThrow();
                 } catch (InterruptedException success) {}
                 assertFalse(Thread.interrupted());
             }});
 
         await(pleaseTake);
-        assertEquals(0, q.remainingCapacity());
+        mustEqual(0, q.remainingCapacity());
         try { assertSame(one, q.take()); }
         catch (InterruptedException e) { threadUnexpectedException(e); }
 
@@ -182,7 +180,7 @@ public class SynchronousQueueTest extend
         if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
         t.interrupt();
         awaitTermination(t);
-        assertEquals(0, q.remainingCapacity());
+        mustEqual(0, q.remainingCapacity());
     }
 
     /**
@@ -190,25 +188,25 @@ public class SynchronousQueueTest extend
      */
     public void testTimedOffer() {
         final boolean fair = randomBoolean();
-        final SynchronousQueue q = new SynchronousQueue(fair);
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
         Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 long startTime = System.nanoTime();
 
-                assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
+                assertFalse(q.offer(zero, timeoutMillis(), MILLISECONDS));
                 assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
 
                 Thread.currentThread().interrupt();
                 try {
-                    q.offer(new Object(), randomTimeout(), randomTimeUnit());
+                    q.offer(one, randomTimeout(), randomTimeUnit());
                     shouldThrow();
                 } catch (InterruptedException success) {}
                 assertFalse(Thread.interrupted());
 
                 pleaseInterrupt.countDown();
                 try {
-                    q.offer(new Object(), LONGER_DELAY_MS, MILLISECONDS);
+                    q.offer(two, LONGER_DELAY_MS, MILLISECONDS);
                     shouldThrow();
                 } catch (InterruptedException success) {}
                 assertFalse(Thread.interrupted());
@@ -226,7 +224,7 @@ public class SynchronousQueueTest extend
     public void testPoll()      { testPoll(false); }
     public void testPoll_fair() { testPoll(true); }
     public void testPoll(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         assertNull(q.poll());
     }
 
@@ -236,7 +234,7 @@ public class SynchronousQueueTest extend
     public void testTimedPoll0()      { testTimedPoll0(false); }
     public void testTimedPoll0_fair() { testTimedPoll0(true); }
     public void testTimedPoll0(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         try { assertNull(q.poll(0, MILLISECONDS)); }
         catch (InterruptedException e) { threadUnexpectedException(e); }
     }
@@ -246,7 +244,7 @@ public class SynchronousQueueTest extend
      */
     public void testTimedPoll() {
         final boolean fair = randomBoolean();
-        final SynchronousQueue q = new SynchronousQueue(fair);
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         final long startTime = System.nanoTime();
         try { assertNull(q.poll(timeoutMillis(), MILLISECONDS)); }
         catch (InterruptedException e) { threadUnexpectedException(e); }
@@ -259,7 +257,7 @@ public class SynchronousQueueTest extend
      */
     public void testTimedPollWithOffer() {
         final boolean fair = randomBoolean();
-        final SynchronousQueue q = new SynchronousQueue(fair);
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         final CountDownLatch pleaseOffer = new CountDownLatch(1);
         final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
         Thread t = newStartedThread(new CheckedRunnable() {
@@ -307,7 +305,7 @@ public class SynchronousQueueTest extend
     public void testPeek()      { testPeek(false); }
     public void testPeek_fair() { testPeek(true); }
     public void testPeek(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         assertNull(q.peek());
     }
 
@@ -317,7 +315,7 @@ public class SynchronousQueueTest extend
     public void testElement()      { testElement(false); }
     public void testElement_fair() { testElement(true); }
     public void testElement(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         try {
             q.element();
             shouldThrow();
@@ -330,7 +328,7 @@ public class SynchronousQueueTest extend
     public void testRemove()      { testRemove(false); }
     public void testRemove_fair() { testRemove(true); }
     public void testRemove(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         try {
             q.remove();
             shouldThrow();
@@ -343,7 +341,7 @@ public class SynchronousQueueTest extend
     public void testContains()      { testContains(false); }
     public void testContains_fair() { testContains(true); }
     public void testContains(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         assertFalse(q.contains(zero));
     }
 
@@ -353,7 +351,7 @@ public class SynchronousQueueTest extend
     public void testClear()      { testClear(false); }
     public void testClear_fair() { testClear(true); }
     public void testClear(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         q.clear();
         assertTrue(q.isEmpty());
     }
@@ -364,11 +362,11 @@ public class SynchronousQueueTest extend
     public void testContainsAll()      { testContainsAll(false); }
     public void testContainsAll_fair() { testContainsAll(true); }
     public void testContainsAll(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
-        Integer[] empty = new Integer[0];
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
+        Item[] empty = new Item[0];
         assertTrue(q.containsAll(Arrays.asList(empty)));
-        Integer[] ints = new Integer[1]; ints[0] = zero;
-        assertFalse(q.containsAll(Arrays.asList(ints)));
+        Item[] items = new Item[1]; items[0] = zero;
+        assertFalse(q.containsAll(Arrays.asList(items)));
     }
 
     /**
@@ -377,11 +375,11 @@ public class SynchronousQueueTest extend
     public void testRetainAll()      { testRetainAll(false); }
     public void testRetainAll_fair() { testRetainAll(true); }
     public void testRetainAll(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
-        Integer[] empty = new Integer[0];
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
+        Item[] empty = new Item[0];
         assertFalse(q.retainAll(Arrays.asList(empty)));
-        Integer[] ints = new Integer[1]; ints[0] = zero;
-        assertFalse(q.retainAll(Arrays.asList(ints)));
+        Item[] items = new Item[1]; items[0] = zero;
+        assertFalse(q.retainAll(Arrays.asList(items)));
     }
 
     /**
@@ -390,11 +388,11 @@ public class SynchronousQueueTest extend
     public void testRemoveAll()      { testRemoveAll(false); }
     public void testRemoveAll_fair() { testRemoveAll(true); }
     public void testRemoveAll(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
-        Integer[] empty = new Integer[0];
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
+        Item[] empty = new Item[0];
         assertFalse(q.removeAll(Arrays.asList(empty)));
-        Integer[] ints = new Integer[1]; ints[0] = zero;
-        assertFalse(q.containsAll(Arrays.asList(ints)));
+        Item[] items = new Item[1]; items[0] = zero;
+        assertFalse(q.containsAll(Arrays.asList(items)));
     }
 
     /**
@@ -403,30 +401,30 @@ public class SynchronousQueueTest extend
     public void testToArray()      { testToArray(false); }
     public void testToArray_fair() { testToArray(true); }
     public void testToArray(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         Object[] o = q.toArray();
-        assertEquals(0, o.length);
+        mustEqual(0, o.length);
     }
 
     /**
-     * toArray(Integer array) returns its argument with the first
+     * toArray(Item array) returns its argument with the first
      * element (if present) nulled out
      */
     public void testToArray2()      { testToArray2(false); }
     public void testToArray2_fair() { testToArray2(true); }
     public void testToArray2(boolean fair) {
-        final SynchronousQueue<Integer> q = new SynchronousQueue<>(fair);
-        Integer[] a;
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
+        Item[] a;
 
-        a = new Integer[0];
+        a = new Item[0];
         assertSame(a, q.toArray(a));
 
-        a = new Integer[3];
-        Arrays.fill(a, 42);
+        a = new Item[3];
+        Arrays.fill(a, fortytwo);
         assertSame(a, q.toArray(a));
         assertNull(a[0]);
         for (int i = 1; i < a.length; i++)
-            assertEquals(42, (int) a[i]);
+            mustEqual(42, a[i]);
     }
 
     /**
@@ -435,7 +433,7 @@ public class SynchronousQueueTest extend
     public void testToArray_null()      { testToArray_null(false); }
     public void testToArray_null_fair() { testToArray_null(true); }
     public void testToArray_null(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         try {
             Object[] unused = q.toArray((Object[])null);
             shouldThrow();
@@ -448,7 +446,7 @@ public class SynchronousQueueTest extend
     public void testIterator()      { testIterator(false); }
     public void testIterator_fair() { testIterator(true); }
     public void testIterator(boolean fair) {
-        assertIteratorExhausted(new SynchronousQueue(fair).iterator());
+        assertIteratorExhausted(new SynchronousQueue<Item>(fair).iterator());
     }
 
     /**
@@ -457,8 +455,8 @@ public class SynchronousQueueTest extend
     public void testIteratorRemove()      { testIteratorRemove(false); }
     public void testIteratorRemove_fair() { testIteratorRemove(true); }
     public void testIteratorRemove(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
-        Iterator it = q.iterator();
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
+        Iterator<? extends Item> it = q.iterator();
         try {
             it.remove();
             shouldThrow();
@@ -471,7 +469,7 @@ public class SynchronousQueueTest extend
     public void testToString()      { testToString(false); }
     public void testToString_fair() { testToString(true); }
     public void testToString(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         String s = q.toString();
         assertNotNull(s);
     }
@@ -482,7 +480,7 @@ public class SynchronousQueueTest extend
     public void testOfferInExecutor()      { testOfferInExecutor(false); }
     public void testOfferInExecutor_fair() { testOfferInExecutor(true); }
     public void testOfferInExecutor(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         final CheckedBarrier threadsStarted = new CheckedBarrier(2);
         final ExecutorService executor = Executors.newFixedThreadPool(2);
         try (PoolCleaner cleaner = cleaner(executor)) {
@@ -492,7 +490,7 @@ public class SynchronousQueueTest extend
                     assertFalse(q.offer(one));
                     threadsStarted.await();
                     assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
-                    assertEquals(0, q.remainingCapacity());
+                    mustEqual(0, q.remainingCapacity());
                 }});
 
             executor.execute(new CheckedRunnable() {
@@ -509,7 +507,7 @@ public class SynchronousQueueTest extend
     public void testPollInExecutor()      { testPollInExecutor(false); }
     public void testPollInExecutor_fair() { testPollInExecutor(true); }
     public void testPollInExecutor(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         final CheckedBarrier threadsStarted = new CheckedBarrier(2);
         final ExecutorService executor = Executors.newFixedThreadPool(2);
         try (PoolCleaner cleaner = cleaner(executor)) {
@@ -533,19 +531,21 @@ public class SynchronousQueueTest extend
      * a deserialized/reserialized queue is usable
      */
     public void testSerialization() {
-        final SynchronousQueue x = new SynchronousQueue();
-        final SynchronousQueue y = new SynchronousQueue(false);
-        final SynchronousQueue z = new SynchronousQueue(true);
+        final SynchronousQueue<Item> x = new SynchronousQueue<Item>();
+        final SynchronousQueue<Item> y = new SynchronousQueue<Item>(false);
+        final SynchronousQueue<Item> z = new SynchronousQueue<Item>(true);
         assertSerialEquals(x, y);
         assertNotSerialEquals(x, z);
-        SynchronousQueue[] qs = { x, y, z };
-        for (SynchronousQueue q : qs) {
-            SynchronousQueue clone = serialClone(q);
+        SynchronousQueue[] rqs = { x, y, z };
+        @SuppressWarnings("unchecked")
+        SynchronousQueue<Item>[] qs = (SynchronousQueue<Item>[])rqs;
+        for (SynchronousQueue<Item> q : qs) {
+            SynchronousQueue<Item> clone = serialClone(q);
             assertNotSame(q, clone);
             assertSerialEquals(q, clone);
             assertTrue(clone.isEmpty());
-            assertEquals(0, clone.size());
-            assertEquals(0, clone.remainingCapacity());
+            mustEqual(0, clone.size());
+            mustEqual(0, clone.remainingCapacity());
             assertFalse(clone.offer(zero));
         }
     }
@@ -556,11 +556,11 @@ public class SynchronousQueueTest extend
     public void testDrainTo()      { testDrainTo(false); }
     public void testDrainTo_fair() { testDrainTo(true); }
     public void testDrainTo(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
-        ArrayList l = new ArrayList();
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
+        ArrayList<Item> l = new ArrayList<Item>();
         q.drainTo(l);
-        assertEquals(0, q.size());
-        assertEquals(0, l.size());
+        mustEqual(0, q.size());
+        mustEqual(0, l.size());
     }
 
     /**
@@ -569,13 +569,13 @@ public class SynchronousQueueTest extend
     public void testDrainToWithActivePut()      { testDrainToWithActivePut(false); }
     public void testDrainToWithActivePut_fair() { testDrainToWithActivePut(true); }
     public void testDrainToWithActivePut(boolean fair) {
-        final SynchronousQueue q = new SynchronousQueue(fair);
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>(fair);
         Thread t = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 q.put(one);
             }});
 
-        ArrayList l = new ArrayList();
+        ArrayList<Item> l = new ArrayList<Item>();
         long startTime = System.nanoTime();
         while (l.isEmpty()) {
             q.drainTo(l);
@@ -583,7 +583,7 @@ public class SynchronousQueueTest extend
                 fail("timed out");
             Thread.yield();
         }
-        assertEquals(1, l.size());
+        mustEqual(1, l.size());
         assertSame(one, l.get(0));
         awaitTermination(t);
     }
@@ -592,7 +592,7 @@ public class SynchronousQueueTest extend
      * drainTo(c, n) empties up to n elements of queue into c
      */
     public void testDrainToN() throws InterruptedException {
-        final SynchronousQueue q = new SynchronousQueue();
+        final SynchronousQueue<Item> q = new SynchronousQueue<Item>();
         Thread t1 = newStartedThread(new CheckedRunnable() {
             public void realRun() throws InterruptedException {
                 q.put(one);
@@ -603,14 +603,14 @@ public class SynchronousQueueTest extend
                 q.put(two);
             }});
 
-        ArrayList l = new ArrayList();
+        ArrayList<Item> l = new ArrayList<Item>();
         int drained;
         while ((drained = q.drainTo(l, 1)) == 0) Thread.yield();
-        assertEquals(1, drained);
-        assertEquals(1, l.size());
+        mustEqual(1, drained);
+        mustEqual(1, l.size());
         while ((drained = q.drainTo(l, 1)) == 0) Thread.yield();
-        assertEquals(1, drained);
-        assertEquals(2, l.size());
+        mustEqual(1, drained);
+        mustEqual(2, l.size());
         assertTrue(l.contains(one));
         assertTrue(l.contains(two));
         awaitTermination(t1);
@@ -621,7 +621,7 @@ public class SynchronousQueueTest extend
      * remove(null), contains(null) always return false
      */
     public void testNeverContainsNull() {
-        Collection<?> q = new SynchronousQueue();
+        Collection<?> q = new SynchronousQueue<Item>();
         assertFalse(q.contains(null));
         assertFalse(q.remove(null));
     }