ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/LinkedTransferQueueTest.java
(Generate patch)

Comparing jsr166/src/test/tck/LinkedTransferQueueTest.java (file contents):
Revision 1.6 by dl, Sun Aug 2 12:31:24 2009 UTC vs.
Revision 1.69 by jsr166, Sat Feb 18 01:17:06 2017 UTC

# Line 1 | Line 1
1   /*
2   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at
4 < * http://creativecommons.org/licenses/publicdomain
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5   * Other contributors include John Vint
6   */
7  
8 < import java.io.BufferedInputStream;
9 < import java.io.BufferedOutputStream;
10 < import java.io.ByteArrayInputStream;
11 < import java.io.ByteArrayOutputStream;
12 < import java.io.ObjectInputStream;
13 < import java.io.ObjectOutputStream;
8 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
9 >
10   import java.util.ArrayList;
11   import java.util.Arrays;
12 < import java.util.ConcurrentModificationException;
12 > import java.util.Collection;
13   import java.util.Iterator;
14 + import java.util.List;
15   import java.util.NoSuchElementException;
16 < import java.util.concurrent.*;
16 > import java.util.Queue;
17 > import java.util.concurrent.BlockingQueue;
18 > import java.util.concurrent.CountDownLatch;
19 > import java.util.concurrent.Executors;
20 > import java.util.concurrent.ExecutorService;
21 > import java.util.concurrent.LinkedTransferQueue;
22 >
23   import junit.framework.Test;
21 import junit.framework.TestSuite;
24  
25 + @SuppressWarnings({"unchecked", "rawtypes"})
26   public class LinkedTransferQueueTest extends JSR166TestCase {
27 +    public static class Generic extends BlockingQueueTest {
28 +        protected BlockingQueue emptyCollection() {
29 +            return new LinkedTransferQueue();
30 +        }
31 +    }
32  
33      public static void main(String[] args) {
34 <        junit.textui.TestRunner.run(suite());
34 >        main(suite(), args);
35      }
36  
37      public static Test suite() {
38 <        return new TestSuite(LinkedTransferQueueTest.class);
38 >        class Implementation implements CollectionImplementation {
39 >            public Class<?> klazz() { return LinkedTransferQueue.class; }
40 >            public Collection emptyCollection() { return new LinkedTransferQueue(); }
41 >            public Object makeElement(int i) { return i; }
42 >            public boolean isConcurrent() { return true; }
43 >            public boolean permitsNulls() { return false; }
44 >        }
45 >        return newTestSuite(LinkedTransferQueueTest.class,
46 >                            new Generic().testSuite(),
47 >                            CollectionTest.testSuite(new Implementation()));
48      }
49  
50      /**
51 <     * Constructor builds new queue with size being zero and empty being true
51 >     * Constructor builds new queue with size being zero and empty
52 >     * being true
53       */
54      public void testConstructor1() {
55          assertEquals(0, new LinkedTransferQueue().size());
# Line 39 | Line 57 | public class LinkedTransferQueueTest ext
57      }
58  
59      /**
60 <     * Initializing constructor with null collection throws NullPointerException
60 >     * Initializing constructor with null collection throws
61 >     * NullPointerException
62       */
63      public void testConstructor2() {
64          try {
65              new LinkedTransferQueue(null);
66              shouldThrow();
67 <        } catch (NullPointerException success) {
49 <        }
67 >        } catch (NullPointerException success) {}
68      }
69  
70      /**
71 <     * Initializing from Collection of null elements throws NullPointerException
71 >     * Initializing from Collection of null elements throws
72 >     * NullPointerException
73       */
74      public void testConstructor3() {
75 +        Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
76          try {
77 <            Integer[] ints = new Integer[SIZE];
58 <            LinkedTransferQueue q = new LinkedTransferQueue(Arrays.asList(ints));
77 >            new LinkedTransferQueue(elements);
78              shouldThrow();
79 <        } catch (NullPointerException success) {
61 <        }
79 >        } catch (NullPointerException success) {}
80      }
81  
82      /**
# Line 66 | Line 84 | public class LinkedTransferQueueTest ext
84       * throws NullPointerException
85       */
86      public void testConstructor4() {
87 +        Integer[] ints = new Integer[SIZE];
88 +        for (int i = 0; i < SIZE - 1; ++i)
89 +            ints[i] = i;
90 +        Collection<Integer> elements = Arrays.asList(ints);
91          try {
92 <            Integer[] ints = new Integer[SIZE];
71 <            for (int i = 0; i < SIZE - 1; ++i) {
72 <                ints[i] = i;
73 <            }
74 <            LinkedTransferQueue q = new LinkedTransferQueue(Arrays.asList(ints));
92 >            new LinkedTransferQueue(elements);
93              shouldThrow();
94 <        } catch (NullPointerException success) {
77 <        }
94 >        } catch (NullPointerException success) {}
95      }
96  
97      /**
98       * Queue contains all elements of the collection it is initialized by
99       */
100      public void testConstructor5() {
101 <        try {
102 <            Integer[] ints = new Integer[SIZE];
103 <            for (int i = 0; i < SIZE; ++i) {
104 <                ints[i] = i;
105 <            }
106 <            LinkedTransferQueue q = new LinkedTransferQueue(Arrays.asList(ints));
107 <            for (int i = 0; i < SIZE; ++i) {
108 <                assertEquals(ints[i], q.poll());
109 <            }
110 <        } finally {
101 >        Integer[] ints = new Integer[SIZE];
102 >        for (int i = 0; i < SIZE; ++i) {
103 >            ints[i] = i;
104 >        }
105 >        List intList = Arrays.asList(ints);
106 >        LinkedTransferQueue q
107 >            = new LinkedTransferQueue(intList);
108 >        assertEquals(q.size(), intList.size());
109 >        assertEquals(q.toString(), intList.toString());
110 >        assertTrue(Arrays.equals(q.toArray(),
111 >                                     intList.toArray()));
112 >        assertTrue(Arrays.equals(q.toArray(new Object[0]),
113 >                                 intList.toArray(new Object[0])));
114 >        assertTrue(Arrays.equals(q.toArray(new Object[SIZE]),
115 >                                 intList.toArray(new Object[SIZE])));
116 >        for (int i = 0; i < SIZE; ++i) {
117 >            assertEquals(ints[i], q.poll());
118          }
119      }
120  
121      /**
122 <     * Remaining capacity never decrease nor increase on add or remove
122 >     * remainingCapacity() always returns Integer.MAX_VALUE
123       */
124      public void testRemainingCapacity() {
125 <        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
125 >        BlockingQueue q = populatedQueue(SIZE);
126          for (int i = 0; i < SIZE; ++i) {
127              assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
128              assertEquals(SIZE - i, q.size());
129 <            q.remove();
129 >            assertEquals(i, q.remove());
130          }
131          for (int i = 0; i < SIZE; ++i) {
132              assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
133              assertEquals(i, q.size());
134 <            q.add(i);
111 <        }
112 <    }
113 <
114 <    /**
115 <     * offer(null) throws NullPointerException
116 <     */
117 <    public void testOfferNull() {
118 <        try {
119 <            LinkedTransferQueue q = new LinkedTransferQueue();
120 <            q.offer(null);
121 <            shouldThrow();
122 <        } catch (NullPointerException success) {
123 <        }
124 <    }
125 <
126 <    /**
127 <     * add(null) throws NullPointerException
128 <     */
129 <    public void testAddNull() {
130 <        try {
131 <            LinkedTransferQueue q = new LinkedTransferQueue();
132 <            q.add(null);
133 <            shouldThrow();
134 <        } catch (NullPointerException success) {
135 <        }
136 <    }
137 <
138 <    /**
139 <     * addAll(null) throws NullPointerException
140 <     */
141 <    public void testAddAll1() {
142 <        try {
143 <            LinkedTransferQueue q = new LinkedTransferQueue();
144 <            q.addAll(null);
145 <            shouldThrow();
146 <        } catch (NullPointerException success) {
134 >            assertTrue(q.add(i));
135          }
136      }
137  
# Line 151 | Line 139 | public class LinkedTransferQueueTest ext
139       * addAll(this) throws IllegalArgumentException
140       */
141      public void testAddAllSelf() {
142 +        LinkedTransferQueue q = populatedQueue(SIZE);
143          try {
155            LinkedTransferQueue q = populatedQueue(SIZE);
144              q.addAll(q);
145              shouldThrow();
146 <        } catch (IllegalArgumentException success) {
159 <        }
146 >        } catch (IllegalArgumentException success) {}
147      }
148  
149      /**
150 <     * addAll of a collection with null elements throws NullPointerException
151 <     */
165 <    public void testAddAll2() {
166 <        try {
167 <            LinkedTransferQueue q = new LinkedTransferQueue();
168 <            Integer[] ints = new Integer[SIZE];
169 <            q.addAll(Arrays.asList(ints));
170 <            shouldThrow();
171 <        } catch (NullPointerException success) {
172 <        }
173 <    }
174 <
175 <    /**
176 <     * addAll of a collection with any null elements throws NullPointerException after
177 <     * possibly adding some elements
150 >     * addAll of a collection with any null elements throws
151 >     * NullPointerException after possibly adding some elements
152       */
153      public void testAddAll3() {
154 +        LinkedTransferQueue q = new LinkedTransferQueue();
155 +        Integer[] ints = new Integer[SIZE];
156 +        for (int i = 0; i < SIZE - 1; ++i)
157 +            ints[i] = i;
158          try {
181            LinkedTransferQueue q = new LinkedTransferQueue();
182            Integer[] ints = new Integer[SIZE];
183            for (int i = 0; i < SIZE - 1; ++i) {
184                ints[i] = i;
185            }
159              q.addAll(Arrays.asList(ints));
160              shouldThrow();
161 <        } catch (NullPointerException success) {
189 <        }
161 >        } catch (NullPointerException success) {}
162      }
163  
164      /**
# Line 207 | Line 179 | public class LinkedTransferQueueTest ext
179      }
180  
181      /**
210     * put(null) throws NullPointerException
211     */
212    public void testPutNull() throws InterruptedException {
213        try {
214            LinkedTransferQueue q = new LinkedTransferQueue();
215            q.put(null);
216            shouldThrow();
217        } catch (NullPointerException success) {}
218    }
219
220    /**
182       * all elements successfully put are contained
183       */
184      public void testPut() {
185 <        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
185 >        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
186          for (int i = 0; i < SIZE; ++i) {
187 +            assertEquals(i, q.size());
188              q.put(i);
189              assertTrue(q.contains(i));
190          }
229        assertEquals(q.size(), SIZE);
191      }
192  
193      /**
# Line 240 | Line 201 | public class LinkedTransferQueueTest ext
201      }
202  
203      /**
204 <     * take blocks interruptibly when empty
204 >     * take removes existing elements until empty, then blocks interruptibly
205       */
206 <    public void testTakeFromEmpty() throws InterruptedException {
207 <        final LinkedTransferQueue q = new LinkedTransferQueue();
208 <        Thread t = new Thread(new Runnable() {
209 <            public void run() {
206 >    public void testBlockingTake() throws InterruptedException {
207 >        final BlockingQueue q = populatedQueue(SIZE);
208 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
209 >        Thread t = newStartedThread(new CheckedRunnable() {
210 >            public void realRun() throws InterruptedException {
211 >                for (int i = 0; i < SIZE; ++i) {
212 >                    assertEquals(i, q.take());
213 >                }
214 >
215 >                Thread.currentThread().interrupt();
216                  try {
217                      q.take();
218 <                    threadShouldThrow();
219 <                } catch (InterruptedException success) {
220 <                } catch (Throwable ex) {
254 <                    threadUnexpectedException(ex);
255 <                }
256 <            }});
257 <        t.start();
258 <        Thread.sleep(SHORT_DELAY_MS);
259 <        t.interrupt();
260 <        t.join();
261 <    }
218 >                    shouldThrow();
219 >                } catch (InterruptedException success) {}
220 >                assertFalse(Thread.interrupted());
221  
222 <    /**
264 <     * Take removes existing elements until empty, then blocks interruptibly
265 <     */
266 <    public void testBlockingTake() throws InterruptedException {
267 <        Thread t = new Thread(new Runnable() {
268 <            public void run() {
222 >                pleaseInterrupt.countDown();
223                  try {
270                    LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
271                    for (int i = 0; i < SIZE; ++i) {
272                        threadAssertEquals(i, (int) q.take());
273                    }
224                      q.take();
225 <                    threadShouldThrow();
226 <                } catch (InterruptedException success) {
227 <                } catch (Throwable ex) {
278 <                    threadUnexpectedException(ex);
279 <                }
225 >                    shouldThrow();
226 >                } catch (InterruptedException success) {}
227 >                assertFalse(Thread.interrupted());
228              }});
229 <        t.start();
230 <        Thread.sleep(SHORT_DELAY_MS);
229 >
230 >        await(pleaseInterrupt);
231 >        assertThreadStaysAlive(t);
232          t.interrupt();
233 <        t.join();
233 >        awaitTermination(t);
234      }
235  
236      /**
237       * poll succeeds unless empty
238       */
239 <    public void testPoll() {
239 >    public void testPoll() throws InterruptedException {
240          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
241          for (int i = 0; i < SIZE; ++i) {
242              assertEquals(i, (int) q.poll());
243          }
244          assertNull(q.poll());
245 +        checkEmpty(q);
246      }
247  
248      /**
249 <     * timed pool with zero timeout succeeds when non-empty, else times out
249 >     * timed poll with zero timeout succeeds when non-empty, else times out
250       */
251      public void testTimedPoll0() throws InterruptedException {
252          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
253          for (int i = 0; i < SIZE; ++i) {
254 <            assertEquals(i, (int) q.poll(0, TimeUnit.MILLISECONDS));
254 >            assertEquals(i, (int) q.poll(0, MILLISECONDS));
255          }
256 <        assertNull(q.poll(0, TimeUnit.MILLISECONDS));
256 >        assertNull(q.poll(0, MILLISECONDS));
257 >        checkEmpty(q);
258      }
259  
260      /**
261 <     * timed pool with nonzero timeout succeeds when non-empty, else times out
261 >     * timed poll with nonzero timeout succeeds when non-empty, else times out
262       */
263      public void testTimedPoll() throws InterruptedException {
264          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
265 <        for (int i = 0; i < SIZE; ++i) {
266 <            assertEquals(i, (int) q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
267 <        }
268 <        assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
265 >        long startTime = System.nanoTime();
266 >        for (int i = 0; i < SIZE; ++i)
267 >            assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
268 >        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
269 >
270 >        startTime = System.nanoTime();
271 >        assertNull(q.poll(timeoutMillis(), MILLISECONDS));
272 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
273 >        checkEmpty(q);
274      }
275  
276      /**
# Line 322 | Line 278 | public class LinkedTransferQueueTest ext
278       * returning timeout status
279       */
280      public void testInterruptedTimedPoll() throws InterruptedException {
281 <        Thread t = new Thread(new Runnable() {
282 <            public void run() {
281 >        final BlockingQueue<Integer> q = populatedQueue(SIZE);
282 >        final CountDownLatch aboutToWait = new CountDownLatch(1);
283 >        Thread t = newStartedThread(new CheckedRunnable() {
284 >            public void realRun() throws InterruptedException {
285 >                long startTime = System.nanoTime();
286 >                for (int i = 0; i < SIZE; ++i)
287 >                    assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
288 >                aboutToWait.countDown();
289                  try {
290 <                    LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
291 <                    for (int i = 0; i < SIZE; ++i) {
292 <                        threadAssertEquals(i, (int) q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
293 <                    }
332 <                    threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
333 <                } catch (InterruptedException success) {
334 <                } catch (Throwable ex) {
335 <                    threadUnexpectedException(ex);
336 <                }
290 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
291 >                    shouldThrow();
292 >                } catch (InterruptedException success) {}
293 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
294              }});
295 <        t.start();
296 <        Thread.sleep(SHORT_DELAY_MS);
295 >
296 >        aboutToWait.await();
297 >        waitForThreadToEnterWaitState(t);
298          t.interrupt();
299 <        t.join();
299 >        awaitTermination(t);
300 >        checkEmpty(q);
301      }
302  
303      /**
304 <     * timed poll before a delayed offer fails; after offer succeeds;
305 <     * on interruption throws
304 >     * timed poll after thread interrupted throws InterruptedException
305 >     * instead of returning timeout status
306       */
307 <    public void testTimedPollWithOffer() throws InterruptedException {
308 <        final LinkedTransferQueue q = new LinkedTransferQueue();
309 <        Thread t = new Thread(new Runnable() {
310 <            public void run() {
307 >    public void testTimedPollAfterInterrupt() throws InterruptedException {
308 >        final BlockingQueue<Integer> q = populatedQueue(SIZE);
309 >        Thread t = newStartedThread(new CheckedRunnable() {
310 >            public void realRun() throws InterruptedException {
311 >                long startTime = System.nanoTime();
312 >                Thread.currentThread().interrupt();
313 >                for (int i = 0; i < SIZE; ++i)
314 >                    assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
315                  try {
316 <                    threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
317 <                    q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
318 <                    q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
319 <                    threadShouldThrow();
357 <                } catch (InterruptedException success) {
358 <                } catch (Throwable ex) {
359 <                    threadUnexpectedException(ex);
360 <                }
316 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
317 >                    shouldThrow();
318 >                } catch (InterruptedException success) {}
319 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
320              }});
321 <        t.start();
322 <        Thread.sleep(SMALL_DELAY_MS);
323 <        assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
365 <        t.interrupt();
366 <        t.join();
321 >
322 >        awaitTermination(t);
323 >        checkEmpty(q);
324      }
325  
326      /**
327       * peek returns next element, or null if empty
328       */
329 <    public void testPeek() {
329 >    public void testPeek() throws InterruptedException {
330          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
331          for (int i = 0; i < SIZE; ++i) {
332              assertEquals(i, (int) q.peek());
# Line 378 | Line 335 | public class LinkedTransferQueueTest ext
335                         i != (int) q.peek());
336          }
337          assertNull(q.peek());
338 +        checkEmpty(q);
339      }
340  
341      /**
342       * element returns next element, or throws NoSuchElementException if empty
343       */
344 <    public void testElement() {
344 >    public void testElement() throws InterruptedException {
345          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
346          for (int i = 0; i < SIZE; ++i) {
347              assertEquals(i, (int) q.element());
# Line 392 | Line 350 | public class LinkedTransferQueueTest ext
350          try {
351              q.element();
352              shouldThrow();
353 <        } catch (NoSuchElementException success) {
354 <        }
353 >        } catch (NoSuchElementException success) {}
354 >        checkEmpty(q);
355      }
356  
357      /**
358       * remove removes next element, or throws NoSuchElementException if empty
359       */
360 <    public void testRemove() {
360 >    public void testRemove() throws InterruptedException {
361          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
362          for (int i = 0; i < SIZE; ++i) {
363              assertEquals(i, (int) q.remove());
# Line 407 | Line 365 | public class LinkedTransferQueueTest ext
365          try {
366              q.remove();
367              shouldThrow();
368 <        } catch (NoSuchElementException success) {
369 <        }
412 <    }
413 <
414 <    /**
415 <     * remove(x) removes x and returns true if present
416 <     */
417 <    public void testRemoveElement() {
418 <        LinkedTransferQueue q = populatedQueue(SIZE);
419 <        for (int i = 1; i < SIZE; i += 2) {
420 <            assertTrue(q.remove(i));
421 <        }
422 <        for (int i = 0; i < SIZE; i += 2) {
423 <            assertTrue(q.remove(i));
424 <            assertFalse(q.remove(i + 1));
425 <        }
426 <        assertTrue(q.isEmpty());
368 >        } catch (NoSuchElementException success) {}
369 >        checkEmpty(q);
370      }
371  
372      /**
# Line 436 | Line 379 | public class LinkedTransferQueueTest ext
379          assertTrue(q.remove(one));
380          assertTrue(q.remove(two));
381          assertTrue(q.add(three));
382 <        assertTrue(q.take() != null);
382 >        assertSame(q.take(), three);
383      }
384  
385      /**
# Line 454 | Line 397 | public class LinkedTransferQueueTest ext
397      /**
398       * clear removes all elements
399       */
400 <    public void testClear() {
400 >    public void testClear() throws InterruptedException {
401          LinkedTransferQueue q = populatedQueue(SIZE);
402          q.clear();
403 <        assertTrue(q.isEmpty());
461 <        assertEquals(0, q.size());
403 >        checkEmpty(q);
404          assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
405          q.add(one);
406          assertFalse(q.isEmpty());
407 +        assertEquals(1, q.size());
408          assertTrue(q.contains(one));
409          q.clear();
410 <        assertTrue(q.isEmpty());
410 >        checkEmpty(q);
411      }
412  
413      /**
# Line 472 | Line 415 | public class LinkedTransferQueueTest ext
415       */
416      public void testContainsAll() {
417          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
418 <        LinkedTransferQueue<Integer> p = new LinkedTransferQueue<Integer>();
418 >        LinkedTransferQueue<Integer> p = new LinkedTransferQueue<>();
419          for (int i = 0; i < SIZE; ++i) {
420              assertTrue(q.containsAll(p));
421              assertFalse(p.containsAll(q));
# Line 482 | Line 425 | public class LinkedTransferQueueTest ext
425      }
426  
427      /**
428 <     * retainAll(c) retains only those elements of c and reports true if changed
428 >     * retainAll(c) retains only those elements of c and reports true
429 >     * if changed
430       */
431      public void testRetainAll() {
432          LinkedTransferQueue q = populatedQueue(SIZE);
# Line 501 | Line 445 | public class LinkedTransferQueueTest ext
445      }
446  
447      /**
448 <     * removeAll(c) removes only those elements of c and reports true if changed
448 >     * removeAll(c) removes only those elements of c and reports true
449 >     * if changed
450       */
451      public void testRemoveAll() {
452          for (int i = 1; i < SIZE; ++i) {
# Line 516 | Line 461 | public class LinkedTransferQueueTest ext
461      }
462  
463      /**
464 <     * toArray contains all elements
464 >     * toArray() contains all elements in FIFO order
465       */
466 <    public void testToArray() throws InterruptedException {
466 >    public void testToArray() {
467          LinkedTransferQueue q = populatedQueue(SIZE);
468          Object[] o = q.toArray();
469          for (int i = 0; i < o.length; i++) {
470 <            assertEquals(o[i], q.take());
470 >            assertSame(o[i], q.poll());
471          }
472      }
473  
474      /**
475 <     * toArray(a) contains all elements
475 >     * toArray(a) contains all elements in FIFO order
476       */
477 <    public void testToArray2() throws InterruptedException {
477 >    public void testToArray2() {
478          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
479          Integer[] ints = new Integer[SIZE];
480 <        ints = q.toArray(ints);
480 >        Integer[] array = q.toArray(ints);
481 >        assertSame(ints, array);
482          for (int i = 0; i < ints.length; i++) {
483 <            assertEquals(ints[i], q.take());
483 >            assertSame(ints[i], q.poll());
484          }
485      }
486  
487      /**
488 <     * toArray(null) throws NullPointerException
543 <     */
544 <    public void testToArray_BadArg() {
545 <        try {
546 <            LinkedTransferQueue q = populatedQueue(SIZE);
547 <            Object o[] = q.toArray(null);
548 <            shouldThrow();
549 <        } catch (NullPointerException success) {
550 <        }
551 <    }
552 <
553 <    /**
554 <     * toArray with incompatible array type throws CCE
488 >     * toArray(incompatible array type) throws ArrayStoreException
489       */
490      public void testToArray1_BadArg() {
491 +        LinkedTransferQueue q = populatedQueue(SIZE);
492          try {
493 <            LinkedTransferQueue q = populatedQueue(SIZE);
559 <            Object o[] = q.toArray(new String[10]);
493 >            q.toArray(new String[10]);
494              shouldThrow();
495 <        } catch (ArrayStoreException success) {
562 <        }
495 >        } catch (ArrayStoreException success) {}
496      }
497  
498      /**
# Line 568 | Line 501 | public class LinkedTransferQueueTest ext
501      public void testIterator() throws InterruptedException {
502          LinkedTransferQueue q = populatedQueue(SIZE);
503          Iterator it = q.iterator();
504 <        while (it.hasNext()) {
504 >        int i;
505 >        for (i = 0; it.hasNext(); i++)
506 >            assertTrue(q.contains(it.next()));
507 >        assertEquals(i, SIZE);
508 >        assertIteratorExhausted(it);
509 >
510 >        it = q.iterator();
511 >        for (i = 0; it.hasNext(); i++)
512              assertEquals(it.next(), q.take());
513 <        }
513 >        assertEquals(i, SIZE);
514 >        assertIteratorExhausted(it);
515      }
516  
517      /**
518 <     * iterator.remove removes current element
518 >     * iterator of empty collection has no elements
519 >     */
520 >    public void testEmptyIterator() {
521 >        assertIteratorExhausted(new LinkedTransferQueue().iterator());
522 >    }
523 >
524 >    /**
525 >     * iterator.remove() removes current element
526       */
527      public void testIteratorRemove() {
528          final LinkedTransferQueue q = new LinkedTransferQueue();
# Line 587 | Line 535 | public class LinkedTransferQueueTest ext
535          it.remove();
536  
537          it = q.iterator();
538 <        assertEquals(it.next(), one);
539 <        assertEquals(it.next(), three);
538 >        assertSame(it.next(), one);
539 >        assertSame(it.next(), three);
540          assertFalse(it.hasNext());
541      }
542  
# Line 596 | Line 544 | public class LinkedTransferQueueTest ext
544       * iterator ordering is FIFO
545       */
546      public void testIteratorOrdering() {
547 <        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
547 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
548          assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
549          q.add(one);
550          q.add(two);
# Line 631 | Line 579 | public class LinkedTransferQueueTest ext
579          LinkedTransferQueue q = populatedQueue(SIZE);
580          String s = q.toString();
581          for (int i = 0; i < SIZE; ++i) {
582 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
582 >            assertTrue(s.contains(String.valueOf(i)));
583          }
584      }
585  
# Line 640 | Line 588 | public class LinkedTransferQueueTest ext
588       */
589      public void testOfferInExecutor() {
590          final LinkedTransferQueue q = new LinkedTransferQueue();
591 <        q.add(one);
592 <        q.add(two);
593 <        ExecutorService executor = Executors.newFixedThreadPool(2);
594 <        executor.execute(new Runnable() {
595 <            public void run() {
596 <                try {
597 <                    threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
598 <                } catch (Throwable ex) {
599 <                    threadUnexpectedException(ex);
600 <                }
601 <            }});
654 <
655 <        executor.execute(new Runnable() {
656 <            public void run() {
657 <                try {
658 <                    Thread.sleep(SMALL_DELAY_MS);
659 <                    threadAssertEquals(one, q.take());
660 <                } catch (Throwable ex) {
661 <                    threadUnexpectedException(ex);
662 <                }
663 <            }});
591 >        final CheckedBarrier threadsStarted = new CheckedBarrier(2);
592 >        final ExecutorService executor = Executors.newFixedThreadPool(2);
593 >        try (PoolCleaner cleaner = cleaner(executor)) {
594 >
595 >            executor.execute(new CheckedRunnable() {
596 >                public void realRun() throws InterruptedException {
597 >                    threadsStarted.await();
598 >                    long startTime = System.nanoTime();
599 >                    assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
600 >                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
601 >                }});
602  
603 <        joinPool(executor);
603 >            executor.execute(new CheckedRunnable() {
604 >                public void realRun() throws InterruptedException {
605 >                    threadsStarted.await();
606 >                    assertSame(one, q.take());
607 >                    checkEmpty(q);
608 >                }});
609 >        }
610      }
611  
612      /**
613 <     * poll retrieves elements across Executor threads
613 >     * timed poll retrieves elements across Executor threads
614       */
615      public void testPollInExecutor() {
616          final LinkedTransferQueue q = new LinkedTransferQueue();
617 <        ExecutorService executor = Executors.newFixedThreadPool(2);
618 <        executor.execute(new Runnable() {
619 <            public void run() {
620 <                try {
621 <                    threadAssertNull(q.poll());
622 <                    threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
623 <                    threadAssertTrue(q.isEmpty());
624 <                } catch (Throwable  ex) {
625 <                    threadUnexpectedException(ex);
626 <                }
627 <            }});
617 >        final CheckedBarrier threadsStarted = new CheckedBarrier(2);
618 >        final ExecutorService executor = Executors.newFixedThreadPool(2);
619 >        try (PoolCleaner cleaner = cleaner(executor)) {
620 >
621 >            executor.execute(new CheckedRunnable() {
622 >                public void realRun() throws InterruptedException {
623 >                    assertNull(q.poll());
624 >                    threadsStarted.await();
625 >                    long startTime = System.nanoTime();
626 >                    assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
627 >                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
628 >                    checkEmpty(q);
629 >                }});
630  
631 <        executor.execute(new Runnable() {
632 <            public void run() {
633 <                try {
688 <                    Thread.sleep(SMALL_DELAY_MS);
631 >            executor.execute(new CheckedRunnable() {
632 >                public void realRun() throws InterruptedException {
633 >                    threadsStarted.await();
634                      q.put(one);
635 <                } catch (Throwable ex) {
636 <                    threadUnexpectedException(ex);
692 <                }
693 <            }});
694 <
695 <        joinPool(executor);
635 >                }});
636 >        }
637      }
638  
639      /**
640       * A deserialized serialized queue has same elements in same order
641       */
642      public void testSerialization() throws Exception {
643 <        LinkedTransferQueue q = populatedQueue(SIZE);
643 >        Queue x = populatedQueue(SIZE);
644 >        Queue y = serialClone(x);
645  
646 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
647 <        ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
648 <        out.writeObject(q);
649 <        out.close();
650 <
651 <        ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
652 <        ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
711 <        LinkedTransferQueue r = (LinkedTransferQueue) in.readObject();
712 <
713 <        assertEquals(q.size(), r.size());
714 <        while (!q.isEmpty()) {
715 <            assertEquals(q.remove(), r.remove());
716 <        }
717 <    }
718 <
719 <    /**
720 <     * drainTo(null) throws NullPointerException
721 <     */
722 <    public void testDrainToNull() {
723 <        LinkedTransferQueue q = populatedQueue(SIZE);
724 <        try {
725 <            q.drainTo(null);
726 <            shouldThrow();
727 <        } catch (NullPointerException success) {
728 <        }
729 <    }
730 <
731 <    /**
732 <     * drainTo(this) throws IllegalArgumentException
733 <     */
734 <    public void testDrainToSelf() {
735 <        LinkedTransferQueue q = populatedQueue(SIZE);
736 <        try {
737 <            q.drainTo(q);
738 <            shouldThrow();
739 <        } catch (IllegalArgumentException success) {
646 >        assertNotSame(y, x);
647 >        assertEquals(x.size(), y.size());
648 >        assertEquals(x.toString(), y.toString());
649 >        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
650 >        while (!x.isEmpty()) {
651 >            assertFalse(y.isEmpty());
652 >            assertEquals(x.remove(), y.remove());
653          }
654 +        assertTrue(y.isEmpty());
655      }
656  
657      /**
# Line 747 | Line 661 | public class LinkedTransferQueueTest ext
661          LinkedTransferQueue q = populatedQueue(SIZE);
662          ArrayList l = new ArrayList();
663          q.drainTo(l);
664 <        assertEquals(q.size(), 0);
665 <        assertEquals(l.size(), SIZE);
664 >        assertEquals(0, q.size());
665 >        assertEquals(SIZE, l.size());
666          for (int i = 0; i < SIZE; ++i) {
667 <            assertEquals(l.get(i), i);
667 >            assertEquals(i, l.get(i));
668          }
669          q.add(zero);
670          q.add(one);
# Line 759 | Line 673 | public class LinkedTransferQueueTest ext
673          assertTrue(q.contains(one));
674          l.clear();
675          q.drainTo(l);
676 <        assertEquals(q.size(), 0);
677 <        assertEquals(l.size(), 2);
676 >        assertEquals(0, q.size());
677 >        assertEquals(2, l.size());
678          for (int i = 0; i < 2; ++i) {
679 <            assertEquals(l.get(i), i);
679 >            assertEquals(i, l.get(i));
680          }
681      }
682  
683      /**
684 <     * drainTo empties full queue, unblocking a waiting put.
684 >     * drainTo(c) empties full queue, unblocking a waiting put.
685       */
686      public void testDrainToWithActivePut() throws InterruptedException {
687          final LinkedTransferQueue q = populatedQueue(SIZE);
688 <        Thread t = new Thread(new Runnable() {
689 <            public void run() {
690 <                try {
777 <                    q.put(SIZE + 1);
778 <                } catch (Throwable ex) {
779 <                    threadUnexpectedException(ex);
780 <                }
688 >        Thread t = newStartedThread(new CheckedRunnable() {
689 >            public void realRun() {
690 >                q.put(SIZE + 1);
691              }});
782        t.start();
692          ArrayList l = new ArrayList();
693          q.drainTo(l);
694          assertTrue(l.size() >= SIZE);
695 <        for (int i = 0; i < SIZE; ++i) {
696 <            assertEquals(l.get(i), i);
697 <        }
789 <        t.join();
695 >        for (int i = 0; i < SIZE; ++i)
696 >            assertEquals(i, l.get(i));
697 >        awaitTermination(t);
698          assertTrue(q.size() + l.size() >= SIZE);
699      }
700  
701      /**
702 <     * drainTo(null, n) throws NullPointerException
795 <     */
796 <    public void testDrainToNullN() {
797 <        LinkedTransferQueue q = populatedQueue(SIZE);
798 <        try {
799 <            q.drainTo(null, 0);
800 <            shouldThrow();
801 <        } catch (NullPointerException success) {
802 <        }
803 <    }
804 <
805 <    /**
806 <     * drainTo(this, n) throws IllegalArgumentException
807 <     */
808 <    public void testDrainToSelfN() {
809 <        LinkedTransferQueue q = populatedQueue(SIZE);
810 <        try {
811 <            q.drainTo(q, 0);
812 <            shouldThrow();
813 <        } catch (IllegalArgumentException success) {
814 <        }
815 <    }
816 <
817 <    /**
818 <     * drainTo(c, n) empties first max {n, size} elements of queue into c
702 >     * drainTo(c, n) empties first min(n, size) elements of queue into c
703       */
704      public void testDrainToN() {
705          LinkedTransferQueue q = new LinkedTransferQueue();
# Line 826 | Line 710 | public class LinkedTransferQueueTest ext
710              ArrayList l = new ArrayList();
711              q.drainTo(l, i);
712              int k = (i < SIZE) ? i : SIZE;
713 <            assertEquals(l.size(), k);
714 <            assertEquals(q.size(), SIZE - k);
715 <            for (int j = 0; j < k; ++j) {
716 <                assertEquals(l.get(j), j);
717 <            }
834 <            while (q.poll() != null)
835 <                ;
713 >            assertEquals(k, l.size());
714 >            assertEquals(SIZE - k, q.size());
715 >            for (int j = 0; j < k; ++j)
716 >                assertEquals(j, l.get(j));
717 >            do {} while (q.poll() != null);
718          }
719      }
720  
721      /**
722 <     * poll and take decrement the waiting consumer count
722 >     * timed poll() or take() increments the waiting consumer count;
723 >     * offer(e) decrements the waiting consumer count
724       */
725      public void testWaitingConsumer() throws InterruptedException {
726          final LinkedTransferQueue q = new LinkedTransferQueue();
727 <        final ConsumerObserver waiting = new ConsumerObserver();
728 <        new Thread(new Runnable() {
729 <            public void run() {
730 <                try {
731 <                    threadAssertTrue(q.hasWaitingConsumer());
732 <                    waiting.setWaitingConsumer(q.getWaitingConsumerCount());
733 <                    threadAssertTrue(q.offer(new Object()));
734 <                } catch (Throwable ex) {
735 <                    threadUnexpectedException(ex);
736 <                }
737 <            }}).start();
738 <        assertTrue(q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS) != null);
739 <        assertTrue(q.getWaitingConsumerCount() < waiting.getWaitingConsumers());
727 >        assertEquals(0, q.getWaitingConsumerCount());
728 >        assertFalse(q.hasWaitingConsumer());
729 >        final CountDownLatch threadStarted = new CountDownLatch(1);
730 >
731 >        Thread t = newStartedThread(new CheckedRunnable() {
732 >            public void realRun() throws InterruptedException {
733 >                threadStarted.countDown();
734 >                long startTime = System.nanoTime();
735 >                assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
736 >                assertEquals(0, q.getWaitingConsumerCount());
737 >                assertFalse(q.hasWaitingConsumer());
738 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
739 >            }});
740 >
741 >        threadStarted.await();
742 >        waitForThreadToEnterWaitState(t);
743 >        assertEquals(1, q.getWaitingConsumerCount());
744 >        assertTrue(q.hasWaitingConsumer());
745 >
746 >        assertTrue(q.offer(one));
747 >        assertEquals(0, q.getWaitingConsumerCount());
748 >        assertFalse(q.hasWaitingConsumer());
749 >
750 >        awaitTermination(t);
751      }
752  
753      /**
# Line 864 | Line 758 | public class LinkedTransferQueueTest ext
758              LinkedTransferQueue q = new LinkedTransferQueue();
759              q.transfer(null);
760              shouldThrow();
761 <        } catch (NullPointerException ex) {
868 <        }
761 >        } catch (NullPointerException success) {}
762      }
763  
764      /**
765       * transfer waits until a poll occurs. The transfered element
766 <     * is returned by this associated poll.
766 >     * is returned by the associated poll.
767       */
768      public void testTransfer2() throws InterruptedException {
769 <        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
769 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
770 >        final CountDownLatch threadStarted = new CountDownLatch(1);
771  
772 <        new Thread(new Runnable() {
773 <            public void run() {
774 <                try {
775 <                    q.transfer(SIZE);
776 <                    threadAssertTrue(q.isEmpty());
777 <                } catch (Throwable ex) {
884 <                    threadUnexpectedException(ex);
885 <                }
886 <            }}).start();
772 >        Thread t = newStartedThread(new CheckedRunnable() {
773 >            public void realRun() throws InterruptedException {
774 >                threadStarted.countDown();
775 >                q.transfer(five);
776 >                checkEmpty(q);
777 >            }});
778  
779 <        Thread.sleep(SHORT_DELAY_MS);
779 >        threadStarted.await();
780 >        waitForThreadToEnterWaitState(t);
781          assertEquals(1, q.size());
782 <        assertEquals(SIZE, (int) q.poll());
783 <        assertTrue(q.isEmpty());
782 >        assertSame(five, q.poll());
783 >        checkEmpty(q);
784 >        awaitTermination(t);
785      }
786  
787      /**
788       * transfer waits until a poll occurs, and then transfers in fifo order
789       */
790      public void testTransfer3() throws InterruptedException {
791 <        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
791 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
792  
793 <        Thread first =
794 <            new Thread(new Runnable() {
795 <                public void run() {
796 <                    try {
797 <                        Integer i = SIZE + 1;
798 <                        q.transfer(i);
906 <                        threadAssertTrue(!q.contains(i));
907 <                        threadAssertEquals(1, q.size());
908 <                    } catch (Throwable ex) {
909 <                        threadUnexpectedException(ex);
910 <                    }
911 <                }});
912 <        first.start();
793 >        Thread first = newStartedThread(new CheckedRunnable() {
794 >            public void realRun() throws InterruptedException {
795 >                q.transfer(four);
796 >                assertTrue(!q.contains(four));
797 >                assertEquals(1, q.size());
798 >            }});
799  
800 <        Thread interruptedThread =
801 <            new Thread(new Runnable() {
802 <                public void run() {
803 <                    try {
804 <                        while (q.size() == 0)
805 <                            Thread.yield();
920 <                        q.transfer(SIZE);
921 <                        threadShouldThrow();
922 <                    } catch (InterruptedException success) {
923 <                    } catch (Throwable ex) {
924 <                        threadUnexpectedException(ex);
925 <                    }
800 >        Thread interruptedThread = newStartedThread(
801 >            new CheckedInterruptedRunnable() {
802 >                public void realRun() throws InterruptedException {
803 >                    while (q.isEmpty())
804 >                        Thread.yield();
805 >                    q.transfer(five);
806                  }});
927        interruptedThread.start();
807  
808          while (q.size() < 2)
809              Thread.yield();
810          assertEquals(2, q.size());
811 <        assertEquals(SIZE + 1, (int) q.poll());
811 >        assertSame(four, q.poll());
812          first.join();
813          assertEquals(1, q.size());
814          interruptedThread.interrupt();
815          interruptedThread.join();
816 <        assertEquals(0, q.size());
938 <        assertTrue(q.isEmpty());
816 >        checkEmpty(q);
817      }
818  
819      /**
# Line 944 | Line 822 | public class LinkedTransferQueueTest ext
822       */
823      public void testTransfer4() throws InterruptedException {
824          final LinkedTransferQueue q = new LinkedTransferQueue();
825 <        new Thread(new Runnable() {
826 <            public void run() {
827 <                try {
828 <                    q.transfer(four);
829 <                    threadAssertFalse(q.contains(four));
830 <                    threadAssertEquals(three, q.poll());
831 <                } catch (Throwable ex) {
832 <                    threadUnexpectedException(ex);
833 <                }
834 <            }}).start();
835 <        Thread.sleep(MEDIUM_DELAY_MS);
825 >
826 >        Thread t = newStartedThread(new CheckedRunnable() {
827 >            public void realRun() throws InterruptedException {
828 >                q.transfer(four);
829 >                assertFalse(q.contains(four));
830 >                assertSame(three, q.poll());
831 >            }});
832 >
833 >        while (q.isEmpty())
834 >            Thread.yield();
835 >        assertFalse(q.isEmpty());
836 >        assertEquals(1, q.size());
837          assertTrue(q.offer(three));
838 <        assertEquals(four, q.poll());
838 >        assertSame(four, q.poll());
839 >        awaitTermination(t);
840      }
841  
842      /**
843       * transfer waits until a take occurs. The transfered element
844 <     * is returned by this associated take.
844 >     * is returned by the associated take.
845       */
846      public void testTransfer5() throws InterruptedException {
847 <        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
847 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
848  
849 <        new Thread(new Runnable() {
850 <            public void run() {
851 <                try {
852 <                    q.transfer(SIZE);
853 <                    threadAssertTrue(q.isEmpty());
974 <                } catch (Throwable ex) {
975 <                    threadUnexpectedException(ex);
976 <                }
977 <            }}).start();
849 >        Thread t = newStartedThread(new CheckedRunnable() {
850 >            public void realRun() throws InterruptedException {
851 >                q.transfer(four);
852 >                checkEmpty(q);
853 >            }});
854  
855 <        Thread.sleep(SHORT_DELAY_MS);
856 <        assertEquals(SIZE, (int) q.take());
857 <        assertTrue(q.isEmpty());
855 >        while (q.isEmpty())
856 >            Thread.yield();
857 >        assertFalse(q.isEmpty());
858 >        assertEquals(1, q.size());
859 >        assertSame(four, q.take());
860 >        checkEmpty(q);
861 >        awaitTermination(t);
862      }
863  
864      /**
865       * tryTransfer(null) throws NullPointerException
866       */
867      public void testTryTransfer1() {
868 +        final LinkedTransferQueue q = new LinkedTransferQueue();
869          try {
989            final LinkedTransferQueue q = new LinkedTransferQueue();
870              q.tryTransfer(null);
871 <            this.shouldThrow();
872 <        } catch (NullPointerException ex) {
993 <        }
871 >            shouldThrow();
872 >        } catch (NullPointerException success) {}
873      }
874  
875      /**
876       * tryTransfer returns false and does not enqueue if there are no
877       * consumers waiting to poll or take.
878       */
879 <    public void testTryTransfer2() {
879 >    public void testTryTransfer2() throws InterruptedException {
880          final LinkedTransferQueue q = new LinkedTransferQueue();
881          assertFalse(q.tryTransfer(new Object()));
882          assertFalse(q.hasWaitingConsumer());
883 <        assertTrue(q.isEmpty());
1005 <        assertEquals(0, q.size());
883 >        checkEmpty(q);
884      }
885  
886      /**
# Line 1012 | Line 890 | public class LinkedTransferQueueTest ext
890      public void testTryTransfer3() throws InterruptedException {
891          final Object hotPotato = new Object();
892          final LinkedTransferQueue q = new LinkedTransferQueue();
893 <        new Thread(new Runnable() {
894 <            public void run() {
895 <                try {
896 <                    while (! q.hasWaitingConsumer())
897 <                        Thread.yield();
898 <                    threadAssertTrue(q.hasWaitingConsumer());
899 <                    threadAssertTrue(q.isEmpty());
900 <                    threadAssertTrue(q.size() == 0);
901 <                    threadAssertTrue(q.tryTransfer(hotPotato));
902 <                } catch (Throwable ex) {
903 <                    threadUnexpectedException(ex);
904 <                }
905 <            }}).start();
906 <        assertTrue(q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS) == hotPotato);
907 <        assertTrue(q.isEmpty());
893 >
894 >        Thread t = newStartedThread(new CheckedRunnable() {
895 >            public void realRun() {
896 >                while (! q.hasWaitingConsumer())
897 >                    Thread.yield();
898 >                assertTrue(q.hasWaitingConsumer());
899 >                checkEmpty(q);
900 >                assertTrue(q.tryTransfer(hotPotato));
901 >            }});
902 >
903 >        long startTime = System.nanoTime();
904 >        assertSame(hotPotato, q.poll(LONG_DELAY_MS, MILLISECONDS));
905 >        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
906 >        checkEmpty(q);
907 >        awaitTermination(t);
908      }
909  
910      /**
# Line 1036 | Line 914 | public class LinkedTransferQueueTest ext
914      public void testTryTransfer4() throws InterruptedException {
915          final Object hotPotato = new Object();
916          final LinkedTransferQueue q = new LinkedTransferQueue();
917 <        new Thread(new Runnable() {
918 <            public void run() {
919 <                try {
920 <                    while (! q.hasWaitingConsumer())
921 <                        Thread.yield();
922 <                    threadAssertTrue(q.hasWaitingConsumer());
923 <                    threadAssertTrue(q.isEmpty());
924 <                    threadAssertTrue(q.size() == 0);
925 <                    threadAssertTrue(q.tryTransfer(hotPotato));
926 <                } catch (Throwable ex) {
927 <                    threadUnexpectedException(ex);
928 <                }
929 <            }}).start();
1052 <        assertTrue(q.take() == hotPotato);
1053 <        assertTrue(q.isEmpty());
917 >
918 >        Thread t = newStartedThread(new CheckedRunnable() {
919 >            public void realRun() {
920 >                while (! q.hasWaitingConsumer())
921 >                    Thread.yield();
922 >                assertTrue(q.hasWaitingConsumer());
923 >                checkEmpty(q);
924 >                assertTrue(q.tryTransfer(hotPotato));
925 >            }});
926 >
927 >        assertSame(q.take(), hotPotato);
928 >        checkEmpty(q);
929 >        awaitTermination(t);
930      }
931  
932      /**
933 <     * tryTransfer waits the amount given if interrupted, and
1058 <     * throws interrupted exception
933 >     * tryTransfer blocks interruptibly if no takers
934       */
935      public void testTryTransfer5() throws InterruptedException {
936          final LinkedTransferQueue q = new LinkedTransferQueue();
937 <        Thread toInterrupt = new Thread(new Runnable() {
938 <            public void run() {
937 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
938 >        assertTrue(q.isEmpty());
939 >
940 >        Thread t = newStartedThread(new CheckedRunnable() {
941 >            public void realRun() throws InterruptedException {
942 >                long startTime = System.nanoTime();
943 >                Thread.currentThread().interrupt();
944                  try {
945 <                    q.tryTransfer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
946 <                    threadShouldThrow();
947 <                } catch (InterruptedException success) {
948 <                } catch (Throwable ex) {
949 <                    threadUnexpectedException(ex);
950 <                }
945 >                    q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
946 >                    shouldThrow();
947 >                } catch (InterruptedException success) {}
948 >                assertFalse(Thread.interrupted());
949 >
950 >                pleaseInterrupt.countDown();
951 >                try {
952 >                    q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
953 >                    shouldThrow();
954 >                } catch (InterruptedException success) {}
955 >                assertFalse(Thread.interrupted());
956 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
957              }});
958 <        toInterrupt.start();
959 <        Thread.sleep(SMALL_DELAY_MS);
960 <        toInterrupt.interrupt();
958 >
959 >        await(pleaseInterrupt);
960 >        assertThreadStaysAlive(t);
961 >        t.interrupt();
962 >        awaitTermination(t);
963 >        checkEmpty(q);
964      }
965  
966      /**
967 <     * tryTransfer gives up after the timeout and return false
967 >     * tryTransfer gives up after the timeout and returns false
968       */
969      public void testTryTransfer6() throws InterruptedException {
970          final LinkedTransferQueue q = new LinkedTransferQueue();
971 <        new Thread(new Runnable() {
972 <            public void run() {
973 <                try {
974 <                    threadAssertFalse(q.tryTransfer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
975 <                } catch (Throwable ex) {
976 <                    threadUnexpectedException(ex);
977 <                }
978 <            }}).start();
979 <        Thread.sleep(LONG_DELAY_MS);
980 <        assertTrue(q.isEmpty());
971 >
972 >        Thread t = newStartedThread(new CheckedRunnable() {
973 >            public void realRun() throws InterruptedException {
974 >                long startTime = System.nanoTime();
975 >                assertFalse(q.tryTransfer(new Object(),
976 >                                          timeoutMillis(), MILLISECONDS));
977 >                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
978 >                checkEmpty(q);
979 >            }});
980 >
981 >        awaitTermination(t);
982 >        checkEmpty(q);
983      }
984  
985      /**
# Line 1098 | Line 989 | public class LinkedTransferQueueTest ext
989      public void testTryTransfer7() throws InterruptedException {
990          final LinkedTransferQueue q = new LinkedTransferQueue();
991          assertTrue(q.offer(four));
992 <        new Thread(new Runnable() {
993 <            public void run() {
994 <                try {
995 <                    threadAssertTrue(q.tryTransfer(five, LONG_DELAY_MS, TimeUnit.MILLISECONDS));
996 <                    threadAssertTrue(q.isEmpty());
997 <                } catch (Throwable ex) {
998 <                    threadUnexpectedException(ex);
999 <                }
1000 <            }}).start();
1001 <        Thread.sleep(SHORT_DELAY_MS);
992 >
993 >        Thread t = newStartedThread(new CheckedRunnable() {
994 >            public void realRun() throws InterruptedException {
995 >                long startTime = System.nanoTime();
996 >                assertTrue(q.tryTransfer(five, LONG_DELAY_MS, MILLISECONDS));
997 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
998 >                checkEmpty(q);
999 >            }});
1000 >
1001 >        while (q.size() != 2)
1002 >            Thread.yield();
1003          assertEquals(2, q.size());
1004 <        assertEquals(four, q.poll());
1005 <        assertEquals(five, q.poll());
1006 <        assertTrue(q.isEmpty());
1004 >        assertSame(four, q.poll());
1005 >        assertSame(five, q.poll());
1006 >        checkEmpty(q);
1007 >        awaitTermination(t);
1008      }
1009  
1010      /**
1011 <     * tryTransfer attempts to enqueue into the q and fails returning
1012 <     * false not enqueueing and the successive poll is null
1011 >     * tryTransfer attempts to enqueue into the queue and fails
1012 >     * returning false not enqueueing and the successive poll is null
1013       */
1014      public void testTryTransfer8() throws InterruptedException {
1015          final LinkedTransferQueue q = new LinkedTransferQueue();
1016          assertTrue(q.offer(four));
1017          assertEquals(1, q.size());
1018 <        assertFalse(q.tryTransfer(five, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
1018 >        long startTime = System.nanoTime();
1019 >        assertFalse(q.tryTransfer(five, timeoutMillis(), MILLISECONDS));
1020 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
1021          assertEquals(1, q.size());
1022 <        assertEquals(four, q.poll());
1128 <        threadAssertTrue(q.isEmpty());
1022 >        assertSame(four, q.poll());
1023          assertNull(q.poll());
1024 +        checkEmpty(q);
1025      }
1026  
1027      private LinkedTransferQueue<Integer> populatedQueue(int n) {
1028 <        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
1029 <        assertTrue(q.isEmpty());
1028 >        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
1029 >        checkEmpty(q);
1030          for (int i = 0; i < n; i++) {
1031              assertEquals(i, q.size());
1032              assertTrue(q.offer(i));
# Line 1141 | Line 1036 | public class LinkedTransferQueueTest ext
1036          return q;
1037      }
1038  
1039 <    private static class ConsumerObserver {
1040 <
1041 <        private int waitingConsumers;
1042 <
1043 <        private ConsumerObserver() {
1044 <        }
1045 <
1046 <        private void setWaitingConsumer(int i) {
1047 <            this.waitingConsumers = i;
1048 <        }
1049 <
1050 <        private int getWaitingConsumers() {
1156 <            return waitingConsumers;
1039 >    /**
1040 >     * remove(null), contains(null) always return false
1041 >     */
1042 >    public void testNeverContainsNull() {
1043 >        Collection<?>[] qs = {
1044 >            new LinkedTransferQueue<Object>(),
1045 >            populatedQueue(2),
1046 >        };
1047 >
1048 >        for (Collection<?> q : qs) {
1049 >            assertFalse(q.contains(null));
1050 >            assertFalse(q.remove(null));
1051          }
1052      }
1053   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines