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.12 by jsr166, Sat Aug 15 00:35:01 2009 UTC vs.
Revision 1.83 by jsr166, Thu Sep 5 21:11:13 2019 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.*;
17 < import static java.util.concurrent.TimeUnit.MILLISECONDS;
16 > import java.util.Queue;
17 > import java.util.concurrent.BlockingQueue;
18 > import java.util.concurrent.Callable;
19 > import java.util.concurrent.CountDownLatch;
20 > import java.util.concurrent.Executors;
21 > import java.util.concurrent.ExecutorService;
22 > import java.util.concurrent.LinkedTransferQueue;
23 >
24   import junit.framework.Test;
23 import junit.framework.TestSuite;
25  
26   @SuppressWarnings({"unchecked", "rawtypes"})
27   public class LinkedTransferQueueTest extends JSR166TestCase {
28 +    public static class Generic extends BlockingQueueTest {
29 +        protected BlockingQueue emptyCollection() {
30 +            return new LinkedTransferQueue();
31 +        }
32 +    }
33  
34      public static void main(String[] args) {
35 <        junit.textui.TestRunner.run(suite());
35 >        main(suite(), args);
36      }
37  
38      public static Test suite() {
39 <        return new TestSuite(LinkedTransferQueueTest.class);
40 <    }
41 <
42 <    void checkEmpty(LinkedTransferQueue q) throws InterruptedException {
43 <        assertTrue(q.isEmpty());
44 <        assertEquals(0, q.size());
45 <        assertNull(q.peek());
46 <        assertNull(q.poll());
47 <        assertNull(q.poll(0, MILLISECONDS));
48 <        assertEquals(q.toString(), "[]");
43 <        assertTrue(Arrays.equals(q.toArray(), new Object[0]));
44 <        assertFalse(q.iterator().hasNext());
45 <        try {
46 <            q.element();
47 <            shouldThrow();
48 <        } catch (NoSuchElementException success) {
49 <        }
50 <        try {
51 <            q.iterator().next();
52 <            shouldThrow();
53 <        } catch (NoSuchElementException success) {
54 <        }
55 <        try {
56 <            q.remove();
57 <            shouldThrow();
58 <        } catch (NoSuchElementException success) {
59 <        }
39 >        class Implementation implements CollectionImplementation {
40 >            public Class<?> klazz() { return LinkedTransferQueue.class; }
41 >            public Collection emptyCollection() { return new LinkedTransferQueue(); }
42 >            public Object makeElement(int i) { return i; }
43 >            public boolean isConcurrent() { return true; }
44 >            public boolean permitsNulls() { return false; }
45 >        }
46 >        return newTestSuite(LinkedTransferQueueTest.class,
47 >                            new Generic().testSuite(),
48 >                            CollectionTest.testSuite(new Implementation()));
49      }
50  
51      /**
# Line 76 | Line 65 | public class LinkedTransferQueueTest ext
65          try {
66              new LinkedTransferQueue(null);
67              shouldThrow();
68 <        } catch (NullPointerException success) {
80 <        }
68 >        } catch (NullPointerException success) {}
69      }
70  
71      /**
# Line 85 | Line 73 | public class LinkedTransferQueueTest ext
73       * NullPointerException
74       */
75      public void testConstructor3() {
76 +        Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
77          try {
78 <            Integer[] ints = new Integer[SIZE];
90 <            new LinkedTransferQueue(Arrays.asList(ints));
78 >            new LinkedTransferQueue(elements);
79              shouldThrow();
80 <        } catch (NullPointerException success) {
93 <        }
80 >        } catch (NullPointerException success) {}
81      }
82  
83      /**
# Line 98 | Line 85 | public class LinkedTransferQueueTest ext
85       * throws NullPointerException
86       */
87      public void testConstructor4() {
88 +        Integer[] ints = new Integer[SIZE];
89 +        for (int i = 0; i < SIZE - 1; ++i)
90 +            ints[i] = i;
91 +        Collection<Integer> elements = Arrays.asList(ints);
92          try {
93 <            Integer[] ints = new Integer[SIZE];
103 <            for (int i = 0; i < SIZE - 1; ++i) {
104 <                ints[i] = i;
105 <            }
106 <            new LinkedTransferQueue(Arrays.asList(ints));
93 >            new LinkedTransferQueue(elements);
94              shouldThrow();
95 <        } catch (NullPointerException success) {
109 <        }
95 >        } catch (NullPointerException success) {}
96      }
97  
98      /**
# Line 137 | Line 123 | public class LinkedTransferQueueTest ext
123       * remainingCapacity() always returns Integer.MAX_VALUE
124       */
125      public void testRemainingCapacity() {
126 <        LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
126 >        BlockingQueue q = populatedQueue(SIZE);
127          for (int i = 0; i < SIZE; ++i) {
128              assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
129              assertEquals(SIZE - i, q.size());
130 <            q.remove();
130 >            assertEquals(i, q.remove());
131          }
132          for (int i = 0; i < SIZE; ++i) {
133              assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
134              assertEquals(i, q.size());
135 <            q.add(i);
150 <        }
151 <    }
152 <
153 <    /**
154 <     * offer(null) throws NullPointerException
155 <     */
156 <    public void testOfferNull() {
157 <        try {
158 <            LinkedTransferQueue q = new LinkedTransferQueue();
159 <            q.offer(null);
160 <            shouldThrow();
161 <        } catch (NullPointerException success) {
162 <        }
163 <    }
164 <
165 <    /**
166 <     * add(null) throws NullPointerException
167 <     */
168 <    public void testAddNull() {
169 <        try {
170 <            LinkedTransferQueue q = new LinkedTransferQueue();
171 <            q.add(null);
172 <            shouldThrow();
173 <        } catch (NullPointerException success) {
174 <        }
175 <    }
176 <
177 <    /**
178 <     * addAll(null) throws NullPointerException
179 <     */
180 <    public void testAddAll1() {
181 <        try {
182 <            LinkedTransferQueue q = new LinkedTransferQueue();
183 <            q.addAll(null);
184 <            shouldThrow();
185 <        } catch (NullPointerException success) {
135 >            assertTrue(q.add(i));
136          }
137      }
138  
# Line 190 | Line 140 | public class LinkedTransferQueueTest ext
140       * addAll(this) throws IllegalArgumentException
141       */
142      public void testAddAllSelf() {
143 +        LinkedTransferQueue q = populatedQueue(SIZE);
144          try {
194            LinkedTransferQueue q = populatedQueue(SIZE);
145              q.addAll(q);
146              shouldThrow();
147 <        } catch (IllegalArgumentException success) {
198 <        }
199 <    }
200 <
201 <    /**
202 <     * addAll of a collection with null elements throws NullPointerException
203 <     */
204 <    public void testAddAll2() {
205 <        try {
206 <            LinkedTransferQueue q = new LinkedTransferQueue();
207 <            Integer[] ints = new Integer[SIZE];
208 <            q.addAll(Arrays.asList(ints));
209 <            shouldThrow();
210 <        } catch (NullPointerException success) {
211 <        }
147 >        } catch (IllegalArgumentException success) {}
148      }
149  
150      /**
# Line 216 | Line 152 | public class LinkedTransferQueueTest ext
152       * NullPointerException after possibly adding some elements
153       */
154      public void testAddAll3() {
155 +        LinkedTransferQueue q = new LinkedTransferQueue();
156 +        Integer[] ints = new Integer[SIZE];
157 +        for (int i = 0; i < SIZE - 1; ++i)
158 +            ints[i] = i;
159          try {
220            LinkedTransferQueue q = new LinkedTransferQueue();
221            Integer[] ints = new Integer[SIZE];
222            for (int i = 0; i < SIZE - 1; ++i) {
223                ints[i] = i;
224            }
160              q.addAll(Arrays.asList(ints));
161              shouldThrow();
162 <        } catch (NullPointerException success) {
228 <        }
162 >        } catch (NullPointerException success) {}
163      }
164  
165      /**
# Line 246 | Line 180 | public class LinkedTransferQueueTest ext
180      }
181  
182      /**
249     * put(null) throws NullPointerException
250     */
251    public void testPutNull() throws InterruptedException {
252        try {
253            LinkedTransferQueue q = new LinkedTransferQueue();
254            q.put(null);
255            shouldThrow();
256        } catch (NullPointerException success) {}
257    }
258
259    /**
183       * all elements successfully put are contained
184       */
185      public void testPut() {
186 <        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
186 >        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
187          for (int i = 0; i < SIZE; ++i) {
188 <            assertEquals(q.size(), i);
188 >            assertEquals(i, q.size());
189              q.put(i);
190              assertTrue(q.contains(i));
191          }
# Line 279 | Line 202 | public class LinkedTransferQueueTest ext
202      }
203  
204      /**
205 <     * take blocks interruptibly when empty
283 <     */
284 <    public void testTakeFromEmpty() throws InterruptedException {
285 <        final LinkedTransferQueue q = new LinkedTransferQueue();
286 <        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
287 <            void realRun() throws InterruptedException {
288 <                q.take();
289 <            }});
290 <        Thread.sleep(SHORT_DELAY_MS);
291 <        t.interrupt();
292 <        t.join();
293 <    }
294 <
295 <    /**
296 <     * Take removes existing elements until empty, then blocks interruptibly
205 >     * take removes existing elements until empty, then blocks interruptibly
206       */
207      public void testBlockingTake() throws InterruptedException {
208 <        final LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
209 <        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
210 <            void realRun() throws InterruptedException {
211 <                for (int i = 0; i < SIZE; ++i) {
212 <                    threadAssertEquals(i, (int) q.take());
213 <                }
214 <                q.take();
208 >        final BlockingQueue q = populatedQueue(SIZE);
209 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
210 >        Thread t = newStartedThread(new CheckedRunnable() {
211 >            public void realRun() throws InterruptedException {
212 >                for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
213 >
214 >                Thread.currentThread().interrupt();
215 >                try {
216 >                    q.take();
217 >                    shouldThrow();
218 >                } catch (InterruptedException success) {}
219 >                assertFalse(Thread.interrupted());
220 >
221 >                pleaseInterrupt.countDown();
222 >                try {
223 >                    q.take();
224 >                    shouldThrow();
225 >                } catch (InterruptedException success) {}
226 >                assertFalse(Thread.interrupted());
227              }});
228 <        Thread.sleep(SMALL_DELAY_MS);
228 >
229 >        await(pleaseInterrupt);
230 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
231          t.interrupt();
232 <        t.join();
310 <        checkEmpty(q);
232 >        awaitTermination(t);
233      }
234  
235      /**
# Line 323 | Line 245 | public class LinkedTransferQueueTest ext
245      }
246  
247      /**
248 <     * timed pool with zero timeout succeeds when non-empty, else times out
248 >     * timed poll with zero timeout succeeds when non-empty, else times out
249       */
250      public void testTimedPoll0() throws InterruptedException {
251          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
# Line 335 | Line 257 | public class LinkedTransferQueueTest ext
257      }
258  
259      /**
260 <     * timed pool with nonzero timeout succeeds when non-empty, else times out
260 >     * timed poll with nonzero timeout succeeds when non-empty, else times out
261       */
262      public void testTimedPoll() throws InterruptedException {
263          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
264 <        for (int i = 0; i < SIZE; ++i) {
265 <            long t0 = System.nanoTime();
264 >        long startTime = System.nanoTime();
265 >        for (int i = 0; i < SIZE; ++i)
266              assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
267 <            long millisElapsed = (System.nanoTime() - t0)/(1024 * 1024);
268 <            assertTrue(millisElapsed < SMALL_DELAY_MS);
269 <        }
270 <        assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
267 >        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
268 >
269 >        startTime = System.nanoTime();
270 >        assertNull(q.poll(timeoutMillis(), MILLISECONDS));
271 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
272          checkEmpty(q);
273      }
274  
# Line 354 | Line 277 | public class LinkedTransferQueueTest ext
277       * returning timeout status
278       */
279      public void testInterruptedTimedPoll() throws InterruptedException {
280 <        final LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
281 <        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
282 <            void realRun() throws InterruptedException {
283 <                for (int i = 0; i < SIZE; ++i) {
284 <                    long t0 = System.nanoTime();
285 <                    threadAssertEquals(i, (int) q.poll(LONG_DELAY_MS,
286 <                                                       MILLISECONDS));
287 <                    long millisElapsed = (System.nanoTime() - t0)/(1024 * 1024);
288 <                    assertTrue(millisElapsed < SMALL_DELAY_MS);
289 <                }
290 <                q.poll(LONG_DELAY_MS, MILLISECONDS);
280 >        final BlockingQueue<Integer> q = populatedQueue(SIZE);
281 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
282 >        Thread t = newStartedThread(new CheckedRunnable() {
283 >            public void realRun() throws InterruptedException {
284 >                for (int i = 0; i < SIZE; i++)
285 >                    assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
286 >
287 >                Thread.currentThread().interrupt();
288 >                try {
289 >                    q.poll(randomTimeout(), randomTimeUnit());
290 >                    shouldThrow();
291 >                } catch (InterruptedException success) {}
292 >                assertFalse(Thread.interrupted());
293 >
294 >                pleaseInterrupt.countDown();
295 >                try {
296 >                    q.poll(LONGER_DELAY_MS, MILLISECONDS);
297 >                    shouldThrow();
298 >                } catch (InterruptedException success) {}
299 >                assertFalse(Thread.interrupted());
300              }});
301 <        Thread.sleep(SMALL_DELAY_MS);
301 >
302 >        await(pleaseInterrupt);
303 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
304          t.interrupt();
305 <        t.join();
305 >        awaitTermination(t);
306          checkEmpty(q);
307      }
308  
309      /**
310 <     * timed poll before a delayed offer fails; after offer succeeds;
311 <     * on interruption throws
310 >     * timed poll after thread interrupted throws InterruptedException
311 >     * instead of returning timeout status
312       */
313 <    public void testTimedPollWithOffer() throws InterruptedException {
314 <        final LinkedTransferQueue q = new LinkedTransferQueue();
315 <        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
316 <            void realRun() throws InterruptedException {
317 <                threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
318 <                q.poll(LONG_DELAY_MS, MILLISECONDS);
319 <                q.poll(LONG_DELAY_MS, MILLISECONDS);
313 >    public void testTimedPollAfterInterrupt() throws InterruptedException {
314 >        final BlockingQueue<Integer> q = populatedQueue(SIZE);
315 >        Thread t = newStartedThread(new CheckedRunnable() {
316 >            public void realRun() throws InterruptedException {
317 >                long startTime = System.nanoTime();
318 >                Thread.currentThread().interrupt();
319 >                for (int i = 0; i < SIZE; ++i)
320 >                    assertEquals(i, (int) q.poll(randomTimeout(), randomTimeUnit()));
321 >                try {
322 >                    q.poll(randomTimeout(), randomTimeUnit());
323 >                    shouldThrow();
324 >                } catch (InterruptedException success) {}
325 >                assertFalse(Thread.interrupted());
326 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
327              }});
328 <        Thread.sleep(SMALL_DELAY_MS);
329 <        assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
330 <        t.interrupt();
390 <        t.join();
328 >
329 >        awaitTermination(t);
330 >        checkEmpty(q);
331      }
332  
333      /**
# Line 417 | Line 357 | public class LinkedTransferQueueTest ext
357          try {
358              q.element();
359              shouldThrow();
360 <        } catch (NoSuchElementException success) {
421 <        }
360 >        } catch (NoSuchElementException success) {}
361          checkEmpty(q);
362      }
363  
# Line 433 | Line 372 | public class LinkedTransferQueueTest ext
372          try {
373              q.remove();
374              shouldThrow();
375 <        } catch (NoSuchElementException success) {
437 <        }
438 <        checkEmpty(q);
439 <    }
440 <
441 <    /**
442 <     * remove(x) removes x and returns true if present
443 <     */
444 <    public void testRemoveElement() throws InterruptedException {
445 <        LinkedTransferQueue q = populatedQueue(SIZE);
446 <        for (int i = 1; i < SIZE; i += 2) {
447 <            assertTrue(q.remove(i));
448 <        }
449 <        for (int i = 0; i < SIZE; i += 2) {
450 <            assertTrue(q.remove(i));
451 <            assertFalse(q.remove(i + 1));
452 <        }
375 >        } catch (NoSuchElementException success) {}
376          checkEmpty(q);
377      }
378  
# Line 463 | Line 386 | public class LinkedTransferQueueTest ext
386          assertTrue(q.remove(one));
387          assertTrue(q.remove(two));
388          assertTrue(q.add(three));
389 <        assertTrue(q.take() == three);
389 >        assertSame(q.take(), three);
390      }
391  
392      /**
# Line 499 | Line 422 | public class LinkedTransferQueueTest ext
422       */
423      public void testContainsAll() {
424          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
425 <        LinkedTransferQueue<Integer> p = new LinkedTransferQueue<Integer>();
425 >        LinkedTransferQueue<Integer> p = new LinkedTransferQueue<>();
426          for (int i = 0; i < SIZE; ++i) {
427              assertTrue(q.containsAll(p));
428              assertFalse(p.containsAll(q));
# Line 545 | Line 468 | public class LinkedTransferQueueTest ext
468      }
469  
470      /**
471 <     * toArray contains all elements
471 >     * toArray() contains all elements in FIFO order
472       */
473 <    public void testToArray() throws InterruptedException {
473 >    public void testToArray() {
474          LinkedTransferQueue q = populatedQueue(SIZE);
475 <        Object[] o = q.toArray();
476 <        for (int i = 0; i < o.length; i++) {
477 <            assertEquals(o[i], q.take());
478 <        }
475 >        Object[] a = q.toArray();
476 >        assertSame(Object[].class, a.getClass());
477 >        for (Object o : a)
478 >            assertSame(o, q.poll());
479 >        assertTrue(q.isEmpty());
480      }
481  
482      /**
483 <     * toArray(a) contains all elements
483 >     * toArray(a) contains all elements in FIFO order
484       */
485 <    public void testToArray2() throws InterruptedException {
485 >    public void testToArray2() {
486          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
487          Integer[] ints = new Integer[SIZE];
488 <        ints = q.toArray(ints);
489 <        for (int i = 0; i < ints.length; i++) {
490 <            assertEquals(ints[i], q.take());
491 <        }
492 <    }
569 <
570 <    /**
571 <     * toArray(null) throws NullPointerException
572 <     */
573 <    public void testToArray_BadArg() {
574 <        try {
575 <            LinkedTransferQueue q = populatedQueue(SIZE);
576 <            Object o[] = q.toArray(null);
577 <            shouldThrow();
578 <        } catch (NullPointerException success) {
579 <        }
488 >        Integer[] array = q.toArray(ints);
489 >        assertSame(ints, array);
490 >        for (Integer o : ints)
491 >            assertSame(o, q.poll());
492 >        assertTrue(q.isEmpty());
493      }
494  
495      /**
496 <     * toArray with incompatible array type throws CCE
496 >     * toArray(incompatible array type) throws ArrayStoreException
497       */
498      public void testToArray1_BadArg() {
499 +        LinkedTransferQueue q = populatedQueue(SIZE);
500          try {
501 <            LinkedTransferQueue q = populatedQueue(SIZE);
588 <            Object o[] = q.toArray(new String[10]);
501 >            q.toArray(new String[10]);
502              shouldThrow();
503 <        } catch (ArrayStoreException success) {
591 <        }
503 >        } catch (ArrayStoreException success) {}
504      }
505  
506      /**
# Line 597 | Line 509 | public class LinkedTransferQueueTest ext
509      public void testIterator() throws InterruptedException {
510          LinkedTransferQueue q = populatedQueue(SIZE);
511          Iterator it = q.iterator();
512 <        int i = 0;
513 <        while (it.hasNext()) {
514 <            assertEquals(it.next(), i++);
603 <        }
512 >        int i;
513 >        for (i = 0; it.hasNext(); i++)
514 >            assertTrue(q.contains(it.next()));
515          assertEquals(i, SIZE);
516 +        assertIteratorExhausted(it);
517 +
518 +        it = q.iterator();
519 +        for (i = 0; it.hasNext(); i++)
520 +            assertEquals(it.next(), q.take());
521 +        assertEquals(i, SIZE);
522 +        assertIteratorExhausted(it);
523 +    }
524 +
525 +    /**
526 +     * iterator of empty collection has no elements
527 +     */
528 +    public void testEmptyIterator() {
529 +        assertIteratorExhausted(new LinkedTransferQueue().iterator());
530      }
531  
532      /**
# Line 618 | Line 543 | public class LinkedTransferQueueTest ext
543          it.remove();
544  
545          it = q.iterator();
546 <        assertEquals(it.next(), one);
547 <        assertEquals(it.next(), three);
546 >        assertSame(it.next(), one);
547 >        assertSame(it.next(), three);
548          assertFalse(it.hasNext());
549      }
550  
# Line 627 | Line 552 | public class LinkedTransferQueueTest ext
552       * iterator ordering is FIFO
553       */
554      public void testIteratorOrdering() {
555 <        final LinkedTransferQueue<Integer> q
631 <            = new LinkedTransferQueue<Integer>();
555 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
556          assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
557          q.add(one);
558          q.add(two);
# Line 663 | Line 587 | public class LinkedTransferQueueTest ext
587          LinkedTransferQueue q = populatedQueue(SIZE);
588          String s = q.toString();
589          for (int i = 0; i < SIZE; ++i) {
590 <            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
590 >            assertTrue(s.contains(String.valueOf(i)));
591          }
592      }
593  
# Line 672 | Line 596 | public class LinkedTransferQueueTest ext
596       */
597      public void testOfferInExecutor() {
598          final LinkedTransferQueue q = new LinkedTransferQueue();
599 <        q.add(one);
600 <        q.add(two);
601 <        ExecutorService executor = Executors.newFixedThreadPool(2);
602 <
603 <        executor.execute(new CheckedRunnable() {
604 <            void realRun() {
605 <                threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS,
606 <                                         MILLISECONDS));
607 <            }});
608 <
609 <        executor.execute(new CheckedRunnable() {
686 <            void realRun() throws InterruptedException {
687 <                Thread.sleep(SMALL_DELAY_MS);
688 <                threadAssertEquals(one, q.take());
689 <            }});
599 >        final CheckedBarrier threadsStarted = new CheckedBarrier(2);
600 >        final ExecutorService executor = Executors.newFixedThreadPool(2);
601 >        try (PoolCleaner cleaner = cleaner(executor)) {
602 >
603 >            executor.execute(new CheckedRunnable() {
604 >                public void realRun() throws InterruptedException {
605 >                    threadsStarted.await();
606 >                    long startTime = System.nanoTime();
607 >                    assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
608 >                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
609 >                }});
610  
611 <        joinPool(executor);
611 >            executor.execute(new CheckedRunnable() {
612 >                public void realRun() throws InterruptedException {
613 >                    threadsStarted.await();
614 >                    assertSame(one, q.take());
615 >                    checkEmpty(q);
616 >                }});
617 >        }
618      }
619  
620      /**
621 <     * poll retrieves elements across Executor threads
621 >     * timed poll retrieves elements across Executor threads
622       */
623      public void testPollInExecutor() {
624          final LinkedTransferQueue q = new LinkedTransferQueue();
625 <        ExecutorService executor = Executors.newFixedThreadPool(2);
626 <
627 <        executor.execute(new CheckedRunnable() {
628 <            void realRun() throws InterruptedException {
629 <                threadAssertNull(q.poll());
630 <                threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS,
631 <                                                MILLISECONDS));
632 <                threadAssertTrue(q.isEmpty());
633 <            }});
634 <
635 <        executor.execute(new CheckedRunnable() {
636 <            void realRun() throws InterruptedException {
637 <                Thread.sleep(SMALL_DELAY_MS);
712 <                q.put(one);
713 <            }});
714 <
715 <        joinPool(executor);
716 <    }
717 <
718 <    /**
719 <     * A deserialized serialized queue has same elements in same order
720 <     */
721 <    public void testSerialization() throws Exception {
722 <        LinkedTransferQueue q = populatedQueue(SIZE);
723 <
724 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
725 <        ObjectOutputStream out
726 <            = new ObjectOutputStream(new BufferedOutputStream(bout));
727 <        out.writeObject(q);
728 <        out.close();
729 <
730 <        ByteArrayInputStream bin
731 <            = new ByteArrayInputStream(bout.toByteArray());
732 <        ObjectInputStream in
733 <            = new ObjectInputStream(new BufferedInputStream(bin));
734 <        LinkedTransferQueue r = (LinkedTransferQueue) in.readObject();
625 >        final CheckedBarrier threadsStarted = new CheckedBarrier(2);
626 >        final ExecutorService executor = Executors.newFixedThreadPool(2);
627 >        try (PoolCleaner cleaner = cleaner(executor)) {
628 >
629 >            executor.execute(new CheckedRunnable() {
630 >                public void realRun() throws InterruptedException {
631 >                    assertNull(q.poll());
632 >                    threadsStarted.await();
633 >                    long startTime = System.nanoTime();
634 >                    assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
635 >                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
636 >                    checkEmpty(q);
637 >                }});
638  
639 <        assertEquals(q.size(), r.size());
640 <        while (!q.isEmpty()) {
641 <            assertEquals(q.remove(), r.remove());
639 >            executor.execute(new CheckedRunnable() {
640 >                public void realRun() throws InterruptedException {
641 >                    threadsStarted.await();
642 >                    q.put(one);
643 >                }});
644          }
645      }
646  
647      /**
648 <     * drainTo(null) throws NullPointerException
648 >     * A deserialized/reserialized queue has same elements in same order
649       */
650 <    public void testDrainToNull() {
651 <        LinkedTransferQueue q = populatedQueue(SIZE);
652 <        try {
748 <            q.drainTo(null);
749 <            shouldThrow();
750 <        } catch (NullPointerException success) {
751 <        }
752 <    }
650 >    public void testSerialization() throws Exception {
651 >        Queue x = populatedQueue(SIZE);
652 >        Queue y = serialClone(x);
653  
654 <    /**
655 <     * drainTo(this) throws IllegalArgumentException
656 <     */
657 <    public void testDrainToSelf() {
658 <        LinkedTransferQueue q = populatedQueue(SIZE);
659 <        try {
660 <            q.drainTo(q);
761 <            shouldThrow();
762 <        } catch (IllegalArgumentException success) {
654 >        assertNotSame(y, x);
655 >        assertEquals(x.size(), y.size());
656 >        assertEquals(x.toString(), y.toString());
657 >        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
658 >        while (!x.isEmpty()) {
659 >            assertFalse(y.isEmpty());
660 >            assertEquals(x.remove(), y.remove());
661          }
662 +        assertTrue(y.isEmpty());
663      }
664  
665      /**
# Line 770 | Line 669 | public class LinkedTransferQueueTest ext
669          LinkedTransferQueue q = populatedQueue(SIZE);
670          ArrayList l = new ArrayList();
671          q.drainTo(l);
672 <        assertEquals(q.size(), 0);
673 <        assertEquals(l.size(), SIZE);
672 >        assertEquals(0, q.size());
673 >        assertEquals(SIZE, l.size());
674          for (int i = 0; i < SIZE; ++i) {
675 <            assertEquals(l.get(i), i);
675 >            assertEquals(i, l.get(i));
676          }
677          q.add(zero);
678          q.add(one);
# Line 782 | Line 681 | public class LinkedTransferQueueTest ext
681          assertTrue(q.contains(one));
682          l.clear();
683          q.drainTo(l);
684 <        assertEquals(q.size(), 0);
685 <        assertEquals(l.size(), 2);
684 >        assertEquals(0, q.size());
685 >        assertEquals(2, l.size());
686          for (int i = 0; i < 2; ++i) {
687 <            assertEquals(l.get(i), i);
687 >            assertEquals(i, l.get(i));
688          }
689      }
690  
691      /**
692 <     * drainTo empties full queue, unblocking a waiting put.
692 >     * drainTo(c) empties full queue, unblocking a waiting put.
693       */
694      public void testDrainToWithActivePut() throws InterruptedException {
695          final LinkedTransferQueue q = populatedQueue(SIZE);
696          Thread t = newStartedThread(new CheckedRunnable() {
697 <            void realRun() {
697 >            public void realRun() {
698                  q.put(SIZE + 1);
699              }});
700          ArrayList l = new ArrayList();
701          q.drainTo(l);
702          assertTrue(l.size() >= SIZE);
703 <        for (int i = 0; i < SIZE; ++i) {
704 <            assertEquals(l.get(i), i);
705 <        }
807 <        t.join();
703 >        for (int i = 0; i < SIZE; ++i)
704 >            assertEquals(i, l.get(i));
705 >        awaitTermination(t);
706          assertTrue(q.size() + l.size() >= SIZE);
707      }
708  
709      /**
710 <     * drainTo(null, n) throws NullPointerException
813 <     */
814 <    public void testDrainToNullN() {
815 <        LinkedTransferQueue q = populatedQueue(SIZE);
816 <        try {
817 <            q.drainTo(null, SIZE);
818 <            shouldThrow();
819 <        } catch (NullPointerException success) {
820 <        }
821 <    }
822 <
823 <    /**
824 <     * drainTo(this, n) throws IllegalArgumentException
825 <     */
826 <    public void testDrainToSelfN() {
827 <        LinkedTransferQueue q = populatedQueue(SIZE);
828 <        try {
829 <            q.drainTo(q, SIZE);
830 <            shouldThrow();
831 <        } catch (IllegalArgumentException success) {
832 <        }
833 <    }
834 <
835 <    /**
836 <     * drainTo(c, n) empties first max {n, size} elements of queue into c
710 >     * drainTo(c, n) empties first min(n, size) elements of queue into c
711       */
712      public void testDrainToN() {
713          LinkedTransferQueue q = new LinkedTransferQueue();
# Line 844 | Line 718 | public class LinkedTransferQueueTest ext
718              ArrayList l = new ArrayList();
719              q.drainTo(l, i);
720              int k = (i < SIZE) ? i : SIZE;
721 <            assertEquals(l.size(), k);
722 <            assertEquals(q.size(), SIZE - k);
723 <            for (int j = 0; j < k; ++j) {
724 <                assertEquals(l.get(j), j);
725 <            }
852 <            while (q.poll() != null)
853 <                ;
721 >            assertEquals(k, l.size());
722 >            assertEquals(SIZE - k, q.size());
723 >            for (int j = 0; j < k; ++j)
724 >                assertEquals(j, l.get(j));
725 >            do {} while (q.poll() != null);
726          }
727      }
728  
729      /**
730 <     * poll and take decrement the waiting consumer count
730 >     * timed poll() or take() increments the waiting consumer count;
731 >     * offer(e) decrements the waiting consumer count
732       */
733      public void testWaitingConsumer() throws InterruptedException {
734          final LinkedTransferQueue q = new LinkedTransferQueue();
735 <        final ConsumerObserver waiting = new ConsumerObserver();
735 >        assertEquals(0, q.getWaitingConsumerCount());
736 >        assertFalse(q.hasWaitingConsumer());
737 >        final CountDownLatch threadStarted = new CountDownLatch(1);
738  
739          Thread t = newStartedThread(new CheckedRunnable() {
740 <            void realRun() throws InterruptedException {
741 <                Thread.sleep(SMALL_DELAY_MS);
742 <                threadAssertTrue(q.hasWaitingConsumer());
743 <                waiting.setWaitingConsumer(q.getWaitingConsumerCount());
744 <                threadAssertTrue(q.offer(new Object()));
740 >            public void realRun() throws InterruptedException {
741 >                threadStarted.countDown();
742 >                long startTime = System.nanoTime();
743 >                assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
744 >                assertEquals(0, q.getWaitingConsumerCount());
745 >                assertFalse(q.hasWaitingConsumer());
746 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
747              }});
748  
749 <        assertTrue(q.poll(LONG_DELAY_MS, MILLISECONDS) != null);
750 <        assertTrue(q.getWaitingConsumerCount()
751 <                   < waiting.getWaitingConsumers());
752 <        t.join();
749 >        threadStarted.await();
750 >        Callable<Boolean> oneConsumer
751 >            = new Callable<Boolean>() { public Boolean call() {
752 >                return q.hasWaitingConsumer()
753 >                && q.getWaitingConsumerCount() == 1; }};
754 >        waitForThreadToEnterWaitState(t, oneConsumer);
755 >
756 >        assertTrue(q.offer(one));
757 >        assertEquals(0, q.getWaitingConsumerCount());
758 >        assertFalse(q.hasWaitingConsumer());
759 >
760 >        awaitTermination(t);
761      }
762  
763      /**
# Line 883 | Line 768 | public class LinkedTransferQueueTest ext
768              LinkedTransferQueue q = new LinkedTransferQueue();
769              q.transfer(null);
770              shouldThrow();
771 <        } catch (NullPointerException ex) {
887 <        }
771 >        } catch (NullPointerException success) {}
772      }
773  
774      /**
775 <     * transfer waits until a poll occurs. The transfered element
776 <     * is returned by this associated poll.
775 >     * transfer waits until a poll occurs. The transferred element
776 >     * is returned by the associated poll.
777       */
778      public void testTransfer2() throws InterruptedException {
779 <        final LinkedTransferQueue<Integer> q
780 <            = new LinkedTransferQueue<Integer>();
779 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
780 >        final CountDownLatch threadStarted = new CountDownLatch(1);
781  
782          Thread t = newStartedThread(new CheckedRunnable() {
783 <            void realRun() throws InterruptedException {
784 <                q.transfer(SIZE);
785 <                threadAssertTrue(q.isEmpty());
783 >            public void realRun() throws InterruptedException {
784 >                threadStarted.countDown();
785 >                q.transfer(five);
786 >                checkEmpty(q);
787              }});
788  
789 <        Thread.sleep(SHORT_DELAY_MS);
790 <        assertEquals(1, q.size());
791 <        assertEquals(SIZE, (int) q.poll());
792 <        assertTrue(q.isEmpty());
793 <        t.join();
789 >        threadStarted.await();
790 >        Callable<Boolean> oneElement
791 >            = new Callable<Boolean>() { public Boolean call() {
792 >                return !q.isEmpty() && q.size() == 1; }};
793 >        waitForThreadToEnterWaitState(t, oneElement);
794 >
795 >        assertSame(five, q.poll());
796 >        checkEmpty(q);
797 >        awaitTermination(t);
798      }
799  
800      /**
801       * transfer waits until a poll occurs, and then transfers in fifo order
802       */
803      public void testTransfer3() throws InterruptedException {
804 <        final LinkedTransferQueue<Integer> q
916 <            = new LinkedTransferQueue<Integer>();
804 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
805  
806          Thread first = newStartedThread(new CheckedRunnable() {
807 <            void realRun() throws InterruptedException {
808 <                Integer i = SIZE + 1;
809 <                q.transfer(i);
810 <                threadAssertTrue(!q.contains(i));
923 <                threadAssertEquals(1, q.size());
807 >            public void realRun() throws InterruptedException {
808 >                q.transfer(four);
809 >                assertFalse(q.contains(four));
810 >                assertEquals(1, q.size());
811              }});
812  
813          Thread interruptedThread = newStartedThread(
814              new CheckedInterruptedRunnable() {
815 <                void realRun() throws InterruptedException {
816 <                    while (q.size() == 0)
815 >                public void realRun() throws InterruptedException {
816 >                    while (q.isEmpty())
817                          Thread.yield();
818 <                    q.transfer(SIZE);
818 >                    q.transfer(five);
819                  }});
820  
821          while (q.size() < 2)
822              Thread.yield();
823          assertEquals(2, q.size());
824 <        assertEquals(SIZE + 1, (int) q.poll());
824 >        assertSame(four, q.poll());
825          first.join();
826          assertEquals(1, q.size());
827          interruptedThread.interrupt();
828          interruptedThread.join();
829 <        assertEquals(0, q.size());
943 <        assertTrue(q.isEmpty());
829 >        checkEmpty(q);
830      }
831  
832      /**
# Line 951 | Line 837 | public class LinkedTransferQueueTest ext
837          final LinkedTransferQueue q = new LinkedTransferQueue();
838  
839          Thread t = newStartedThread(new CheckedRunnable() {
840 <            void realRun() throws InterruptedException {
840 >            public void realRun() throws InterruptedException {
841                  q.transfer(four);
842 <                threadAssertFalse(q.contains(four));
843 <                threadAssertEquals(three, q.poll());
842 >                assertFalse(q.contains(four));
843 >                assertSame(three, q.poll());
844              }});
845  
846 <        Thread.sleep(SHORT_DELAY_MS);
846 >        while (q.isEmpty())
847 >            Thread.yield();
848 >        assertFalse(q.isEmpty());
849 >        assertEquals(1, q.size());
850          assertTrue(q.offer(three));
851 <        assertEquals(four, q.poll());
852 <        t.join();
851 >        assertSame(four, q.poll());
852 >        awaitTermination(t);
853      }
854  
855      /**
856 <     * transfer waits until a take occurs. The transfered element
857 <     * is returned by this associated take.
856 >     * transfer waits until a take occurs. The transferred element
857 >     * is returned by the associated take.
858       */
859      public void testTransfer5() throws InterruptedException {
860 <        final LinkedTransferQueue<Integer> q
972 <            = new LinkedTransferQueue<Integer>();
860 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
861  
862          Thread t = newStartedThread(new CheckedRunnable() {
863 <            void realRun() throws InterruptedException {
864 <                q.transfer(SIZE);
863 >            public void realRun() throws InterruptedException {
864 >                q.transfer(four);
865                  checkEmpty(q);
866              }});
867  
868 <        Thread.sleep(SHORT_DELAY_MS);
869 <        assertEquals(SIZE, (int) q.take());
868 >        while (q.isEmpty())
869 >            Thread.yield();
870 >        assertFalse(q.isEmpty());
871 >        assertEquals(1, q.size());
872 >        assertSame(four, q.take());
873          checkEmpty(q);
874 <        t.join();
874 >        awaitTermination(t);
875      }
876  
877      /**
878       * tryTransfer(null) throws NullPointerException
879       */
880      public void testTryTransfer1() {
881 +        final LinkedTransferQueue q = new LinkedTransferQueue();
882          try {
991            final LinkedTransferQueue q = new LinkedTransferQueue();
883              q.tryTransfer(null);
884              shouldThrow();
885 <        } catch (NullPointerException ex) {
995 <        }
885 >        } catch (NullPointerException success) {}
886      }
887  
888      /**
# Line 1015 | Line 905 | public class LinkedTransferQueueTest ext
905          final LinkedTransferQueue q = new LinkedTransferQueue();
906  
907          Thread t = newStartedThread(new CheckedRunnable() {
908 <            void realRun() {
908 >            public void realRun() {
909                  while (! q.hasWaitingConsumer())
910                      Thread.yield();
911 <                threadAssertTrue(q.hasWaitingConsumer());
912 <                threadAssertTrue(q.isEmpty());
913 <                threadAssertTrue(q.size() == 0);
1024 <                threadAssertTrue(q.tryTransfer(hotPotato));
911 >                assertTrue(q.hasWaitingConsumer());
912 >                checkEmpty(q);
913 >                assertTrue(q.tryTransfer(hotPotato));
914              }});
915  
916 <        assertTrue(q.poll(MEDIUM_DELAY_MS, MILLISECONDS) == hotPotato);
916 >        long startTime = System.nanoTime();
917 >        assertSame(hotPotato, q.poll(LONG_DELAY_MS, MILLISECONDS));
918 >        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
919          checkEmpty(q);
920 <        t.join();
920 >        awaitTermination(t);
921      }
922  
923      /**
# Line 1038 | Line 929 | public class LinkedTransferQueueTest ext
929          final LinkedTransferQueue q = new LinkedTransferQueue();
930  
931          Thread t = newStartedThread(new CheckedRunnable() {
932 <            void realRun() {
932 >            public void realRun() {
933                  while (! q.hasWaitingConsumer())
934                      Thread.yield();
935 <                threadAssertTrue(q.hasWaitingConsumer());
936 <                threadAssertTrue(q.isEmpty());
937 <                threadAssertTrue(q.size() == 0);
1047 <                threadAssertTrue(q.tryTransfer(hotPotato));
935 >                assertTrue(q.hasWaitingConsumer());
936 >                checkEmpty(q);
937 >                assertTrue(q.tryTransfer(hotPotato));
938              }});
939  
940 <        assertTrue(q.take() == hotPotato);
940 >        assertSame(q.take(), hotPotato);
941          checkEmpty(q);
942 <        t.join();
942 >        awaitTermination(t);
943      }
944  
945      /**
946 <     * tryTransfer waits the amount given if interrupted, and
1057 <     * throws interrupted exception
946 >     * tryTransfer blocks interruptibly if no takers
947       */
948      public void testTryTransfer5() throws InterruptedException {
949          final LinkedTransferQueue q = new LinkedTransferQueue();
950 +        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
951 +        assertTrue(q.isEmpty());
952  
953 <        Thread toInterrupt = newStartedThread(new CheckedInterruptedRunnable() {
954 <            void realRun() throws InterruptedException {
955 <                q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
953 >        Thread t = newStartedThread(new CheckedRunnable() {
954 >            public void realRun() throws InterruptedException {
955 >                long startTime = System.nanoTime();
956 >                Thread.currentThread().interrupt();
957 >                try {
958 >                    q.tryTransfer(new Object(), randomTimeout(), randomTimeUnit());
959 >                    shouldThrow();
960 >                } catch (InterruptedException success) {}
961 >                assertFalse(Thread.interrupted());
962 >
963 >                pleaseInterrupt.countDown();
964 >                try {
965 >                    q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
966 >                    shouldThrow();
967 >                } catch (InterruptedException success) {}
968 >                assertFalse(Thread.interrupted());
969 >
970 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
971              }});
972  
973 <        Thread.sleep(SMALL_DELAY_MS);
974 <        toInterrupt.interrupt();
975 <        toInterrupt.join();
973 >        await(pleaseInterrupt);
974 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
975 >        t.interrupt();
976 >        awaitTermination(t);
977 >        checkEmpty(q);
978      }
979  
980      /**
981 <     * tryTransfer gives up after the timeout and return false
981 >     * tryTransfer gives up after the timeout and returns false
982       */
983      public void testTryTransfer6() throws InterruptedException {
984          final LinkedTransferQueue q = new LinkedTransferQueue();
985  
986          Thread t = newStartedThread(new CheckedRunnable() {
987 <            void realRun() throws InterruptedException {
988 <                threadAssertFalse
989 <                    (q.tryTransfer(new Object(),
990 <                                   SHORT_DELAY_MS, MILLISECONDS));
987 >            public void realRun() throws InterruptedException {
988 >                long startTime = System.nanoTime();
989 >                assertFalse(q.tryTransfer(new Object(),
990 >                                          timeoutMillis(), MILLISECONDS));
991 >                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
992 >                checkEmpty(q);
993              }});
994  
995 <        Thread.sleep(SMALL_DELAY_MS);
995 >        awaitTermination(t);
996          checkEmpty(q);
1087        t.join();
997      }
998  
999      /**
# Line 1096 | Line 1005 | public class LinkedTransferQueueTest ext
1005          assertTrue(q.offer(four));
1006  
1007          Thread t = newStartedThread(new CheckedRunnable() {
1008 <            void realRun() throws InterruptedException {
1009 <                threadAssertTrue(q.tryTransfer(five,
1010 <                                               MEDIUM_DELAY_MS, MILLISECONDS));
1011 <                threadAssertTrue(q.isEmpty());
1008 >            public void realRun() throws InterruptedException {
1009 >                long startTime = System.nanoTime();
1010 >                assertTrue(q.tryTransfer(five, LONG_DELAY_MS, MILLISECONDS));
1011 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1012 >                checkEmpty(q);
1013              }});
1014  
1015 <        Thread.sleep(SHORT_DELAY_MS);
1015 >        while (q.size() != 2)
1016 >            Thread.yield();
1017          assertEquals(2, q.size());
1018 <        assertEquals(four, q.poll());
1019 <        assertEquals(five, q.poll());
1018 >        assertSame(four, q.poll());
1019 >        assertSame(five, q.poll());
1020          checkEmpty(q);
1021 <        t.join();
1021 >        awaitTermination(t);
1022      }
1023  
1024      /**
1025 <     * tryTransfer attempts to enqueue into the q and fails returning
1026 <     * false not enqueueing and the successive poll is null
1025 >     * tryTransfer attempts to enqueue into the queue and fails
1026 >     * returning false not enqueueing and the successive poll is null
1027       */
1028      public void testTryTransfer8() throws InterruptedException {
1029          final LinkedTransferQueue q = new LinkedTransferQueue();
1030          assertTrue(q.offer(four));
1031          assertEquals(1, q.size());
1032 <        assertFalse(q.tryTransfer(five, SHORT_DELAY_MS, MILLISECONDS));
1032 >        long startTime = System.nanoTime();
1033 >        assertFalse(q.tryTransfer(five, timeoutMillis(), MILLISECONDS));
1034 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
1035          assertEquals(1, q.size());
1036 <        assertEquals(four, q.poll());
1124 <        checkEmpty(q);
1036 >        assertSame(four, q.poll());
1037          assertNull(q.poll());
1038 +        checkEmpty(q);
1039      }
1040  
1041      private LinkedTransferQueue<Integer> populatedQueue(int n) {
1042 <        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
1043 <        assertTrue(q.isEmpty());
1042 >        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
1043 >        checkEmpty(q);
1044          for (int i = 0; i < n; i++) {
1045              assertEquals(i, q.size());
1046              assertTrue(q.offer(i));
# Line 1137 | Line 1050 | public class LinkedTransferQueueTest ext
1050          return q;
1051      }
1052  
1053 <    private static class ConsumerObserver {
1054 <
1055 <        private int waitingConsumers;
1056 <
1057 <        private ConsumerObserver() {
1058 <        }
1059 <
1060 <        private void setWaitingConsumer(int i) {
1061 <            this.waitingConsumers = i;
1062 <        }
1063 <
1064 <        private int getWaitingConsumers() {
1152 <            return waitingConsumers;
1053 >    /**
1054 >     * remove(null), contains(null) always return false
1055 >     */
1056 >    public void testNeverContainsNull() {
1057 >        Collection<?>[] qs = {
1058 >            new LinkedTransferQueue<Object>(),
1059 >            populatedQueue(2),
1060 >        };
1061 >
1062 >        for (Collection<?> q : qs) {
1063 >            assertFalse(q.contains(null));
1064 >            assertFalse(q.remove(null));
1065          }
1066      }
1067   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines