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.44 by jsr166, Tue Mar 15 19:47:06 2011 UTC vs.
Revision 1.83 by jsr166, Thu Sep 5 21:11:13 2019 UTC

# Line 5 | Line 5
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.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;
18 < import static java.util.concurrent.TimeUnit.NANOSECONDS;
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 {
27
28      public static class Generic extends BlockingQueueTest {
29          protected BlockingQueue emptyCollection() {
30              return new LinkedTransferQueue();
# Line 32 | Line 32 | public class LinkedTransferQueueTest ext
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 +        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());
47 >                            new Generic().testSuite(),
48 >                            CollectionTest.testSuite(new Implementation()));
49      }
50  
51      /**
# Line 65 | 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];
70 <            new LinkedTransferQueue(Arrays.asList(ints));
78 >            new LinkedTransferQueue(elements);
79              shouldThrow();
80          } catch (NullPointerException success) {}
81      }
# Line 77 | 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];
82 <            for (int i = 0; i < SIZE - 1; ++i) {
83 <                ints[i] = i;
84 <            }
85 <            new LinkedTransferQueue(Arrays.asList(ints));
93 >            new LinkedTransferQueue(elements);
94              shouldThrow();
95          } catch (NullPointerException success) {}
96      }
# Line 115 | 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);
135 >            assertTrue(q.add(i));
136          }
137      }
138  
139      /**
132     * offer(null) throws NullPointerException
133     */
134    public void testOfferNull() {
135        try {
136            LinkedTransferQueue q = new LinkedTransferQueue();
137            q.offer(null);
138            shouldThrow();
139        } catch (NullPointerException success) {}
140    }
141
142    /**
143     * add(null) throws NullPointerException
144     */
145    public void testAddNull() {
146        try {
147            LinkedTransferQueue q = new LinkedTransferQueue();
148            q.add(null);
149            shouldThrow();
150        } catch (NullPointerException success) {}
151    }
152
153    /**
154     * addAll(null) throws NullPointerException
155     */
156    public void testAddAll1() {
157        try {
158            LinkedTransferQueue q = new LinkedTransferQueue();
159            q.addAll(null);
160            shouldThrow();
161        } catch (NullPointerException success) {}
162    }
163
164    /**
140       * addAll(this) throws IllegalArgumentException
141       */
142      public void testAddAllSelf() {
143 +        LinkedTransferQueue q = populatedQueue(SIZE);
144          try {
169            LinkedTransferQueue q = populatedQueue(SIZE);
145              q.addAll(q);
146              shouldThrow();
147          } catch (IllegalArgumentException success) {}
148      }
149  
150      /**
176     * addAll of a collection with null elements throws NullPointerException
177     */
178    public void testAddAll2() {
179        try {
180            LinkedTransferQueue q = new LinkedTransferQueue();
181            Integer[] ints = new Integer[SIZE];
182            q.addAll(Arrays.asList(ints));
183            shouldThrow();
184        } catch (NullPointerException success) {}
185    }
186
187    /**
151       * addAll of a collection with any null elements throws
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 {
193            LinkedTransferQueue q = new LinkedTransferQueue();
194            Integer[] ints = new Integer[SIZE];
195            for (int i = 0; i < SIZE - 1; ++i) {
196                ints[i] = i;
197            }
160              q.addAll(Arrays.asList(ints));
161              shouldThrow();
162          } catch (NullPointerException success) {}
# Line 218 | Line 180 | public class LinkedTransferQueueTest ext
180      }
181  
182      /**
221     * put(null) throws NullPointerException
222     */
223    public void testPutNull() throws InterruptedException {
224        try {
225            LinkedTransferQueue q = new LinkedTransferQueue();
226            q.put(null);
227            shouldThrow();
228        } catch (NullPointerException success) {}
229    }
230
231    /**
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 254 | Line 205 | public class LinkedTransferQueueTest ext
205       * take removes existing elements until empty, then blocks interruptibly
206       */
207      public void testBlockingTake() throws InterruptedException {
208 <        final BlockingQueue<Integer> q = populatedQueue(SIZE);
209 <        final CountDownLatch aboutToWait = new CountDownLatch(1);
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) {
213 <                    assertEquals(i, (int) q.take());
214 <                }
215 <                aboutToWait.countDown();
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  
229 <        aboutToWait.await();
230 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
229 >        await(pleaseInterrupt);
230 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
231          t.interrupt();
232 <        awaitTermination(t, MEDIUM_DELAY_MS);
275 <        checkEmpty(q);
232 >        awaitTermination(t);
233      }
234  
235      /**
# Line 304 | Line 261 | public class LinkedTransferQueueTest ext
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();
266 <            assertEquals(i, (int) q.poll(SMALL_DELAY_MS, MILLISECONDS));
267 <            assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
268 <        }
269 <        long t0 = System.nanoTime();
270 <        assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
271 <        assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
264 >        long startTime = System.nanoTime();
265 >        for (int i = 0; i < SIZE; ++i)
266 >            assertEquals(i, (int) q.poll(LONG_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 321 | Line 278 | public class LinkedTransferQueueTest ext
278       */
279      public void testInterruptedTimedPoll() throws InterruptedException {
280          final BlockingQueue<Integer> q = populatedQueue(SIZE);
281 <        final CountDownLatch aboutToWait = new CountDownLatch(1);
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) {
328 <                    long t0 = System.nanoTime();
284 >                for (int i = 0; i < SIZE; i++)
285                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
286 <                    assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
287 <                }
332 <                long t0 = System.nanoTime();
333 <                aboutToWait.countDown();
286 >
287 >                Thread.currentThread().interrupt();
288                  try {
289 <                    q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
289 >                    q.poll(randomTimeout(), randomTimeUnit());
290                      shouldThrow();
291 <                } catch (InterruptedException success) {
292 <                    assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
293 <                }
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  
302 <        aboutToWait.await();
303 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
302 >        await(pleaseInterrupt);
303 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
304          t.interrupt();
305 <        awaitTermination(t, MEDIUM_DELAY_MS);
305 >        awaitTermination(t);
306          checkEmpty(q);
307      }
308  
# Line 354 | Line 314 | public class LinkedTransferQueueTest ext
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 <                    long t0 = System.nanoTime();
360 <                    assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
361 <                    assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
362 <                }
319 >                for (int i = 0; i < SIZE; ++i)
320 >                    assertEquals(i, (int) q.poll(randomTimeout(), randomTimeUnit()));
321                  try {
322 <                    q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
322 >                    q.poll(randomTimeout(), randomTimeUnit());
323                      shouldThrow();
324                  } catch (InterruptedException success) {}
325 +                assertFalse(Thread.interrupted());
326 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
327              }});
328  
329 <        awaitTermination(t, MEDIUM_DELAY_MS);
329 >        awaitTermination(t);
330          checkEmpty(q);
331      }
332  
# Line 417 | Line 377 | public class LinkedTransferQueueTest ext
377      }
378  
379      /**
420     * remove(x) removes x and returns true if present
421     */
422    public void testRemoveElement() throws InterruptedException {
423        LinkedTransferQueue q = populatedQueue(SIZE);
424        for (int i = 1; i < SIZE; i+=2) {
425            assertTrue(q.contains(i));
426            assertTrue(q.remove(i));
427            assertFalse(q.contains(i));
428            assertTrue(q.contains(i-1));
429        }
430        for (int i = 0; i < SIZE; i+=2) {
431            assertTrue(q.contains(i));
432            assertTrue(q.remove(i));
433            assertFalse(q.contains(i));
434            assertFalse(q.remove(i+1));
435            assertFalse(q.contains(i+1));
436        }
437        checkEmpty(q);
438    }
439
440    /**
380       * An add following remove(x) succeeds
381       */
382      public void testRemoveElementAndAdd() throws InterruptedException {
# Line 483 | 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 533 | Line 472 | public class LinkedTransferQueueTest ext
472       */
473      public void testToArray() {
474          LinkedTransferQueue q = populatedQueue(SIZE);
475 <        Object[] o = q.toArray();
476 <        for (int i = 0; i < o.length; i++) {
477 <            assertSame(o[i], q.poll());
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      /**
# Line 547 | Line 487 | public class LinkedTransferQueueTest ext
487          Integer[] ints = new Integer[SIZE];
488          Integer[] array = q.toArray(ints);
489          assertSame(ints, array);
490 <        for (int i = 0; i < ints.length; i++) {
491 <            assertSame(ints[i], q.poll());
492 <        }
553 <    }
554 <
555 <    /**
556 <     * toArray(null) throws NullPointerException
557 <     */
558 <    public void testToArray_NullArg() {
559 <        LinkedTransferQueue q = populatedQueue(SIZE);
560 <        try {
561 <            q.toArray(null);
562 <            shouldThrow();
563 <        } catch (NullPointerException success) {}
490 >        for (Integer o : ints)
491 >            assertSame(o, q.poll());
492 >        assertTrue(q.isEmpty());
493      }
494  
495      /**
# Line 580 | 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++);
515 <        }
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 610 | Line 552 | public class LinkedTransferQueueTest ext
552       * iterator ordering is FIFO
553       */
554      public void testIteratorOrdering() {
555 <        final LinkedTransferQueue<Integer> q
614 <            = 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 646 | 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 655 | Line 596 | public class LinkedTransferQueueTest ext
596       */
597      public void testOfferInExecutor() {
598          final LinkedTransferQueue q = new LinkedTransferQueue();
599 <        final CountDownLatch threadsStarted = new CountDownLatch(2);
600 <        ExecutorService executor = Executors.newFixedThreadPool(2);
601 <
661 <        executor.execute(new CheckedRunnable() {
662 <            public void realRun() throws InterruptedException {
663 <                threadsStarted.countDown();
664 <                threadsStarted.await();
665 <                assertTrue(q.offer(one, MEDIUM_DELAY_MS, MILLISECONDS));
666 <            }});
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.countDown();
606 <                threadsStarted.await();
607 <                assertSame(one, q.take());
608 <                checkEmpty(q);
609 <            }});
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      /**
# Line 681 | Line 622 | public class LinkedTransferQueueTest ext
622       */
623      public void testPollInExecutor() {
624          final LinkedTransferQueue q = new LinkedTransferQueue();
625 <        final CountDownLatch threadsStarted = new CountDownLatch(2);
626 <        ExecutorService executor = Executors.newFixedThreadPool(2);
627 <
687 <        executor.execute(new CheckedRunnable() {
688 <            public void realRun() throws InterruptedException {
689 <                assertNull(q.poll());
690 <                threadsStarted.countDown();
691 <                threadsStarted.await();
692 <                assertSame(one, q.poll(SMALL_DELAY_MS, MILLISECONDS));
693 <                checkEmpty(q);
694 <            }});
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 <                threadsStarted.countDown();
632 <                threadsStarted.await();
633 <                q.put(one);
634 <            }});
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 <        joinPool(executor);
639 >            executor.execute(new CheckedRunnable() {
640 >                public void realRun() throws InterruptedException {
641 >                    threadsStarted.await();
642 >                    q.put(one);
643 >                }});
644 >        }
645      }
646  
647      /**
648 <     * A deserialized serialized queue has same elements in same order
648 >     * A deserialized/reserialized queue has same elements in same order
649       */
650      public void testSerialization() throws Exception {
651 <        LinkedTransferQueue q = populatedQueue(SIZE);
652 <
712 <        ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
713 <        ObjectOutputStream out
714 <            = new ObjectOutputStream(new BufferedOutputStream(bout));
715 <        out.writeObject(q);
716 <        out.close();
717 <
718 <        ByteArrayInputStream bin
719 <            = new ByteArrayInputStream(bout.toByteArray());
720 <        ObjectInputStream in
721 <            = new ObjectInputStream(new BufferedInputStream(bin));
722 <        LinkedTransferQueue r = (LinkedTransferQueue) in.readObject();
651 >        Queue x = populatedQueue(SIZE);
652 >        Queue y = serialClone(x);
653  
654 <        assertEquals(q.size(), r.size());
655 <        assertEquals(q.toString(), r.toString());
656 <        assertTrue(Arrays.equals(q.toArray(), r.toArray()));
657 <        while (!q.isEmpty()) {
658 <            assertEquals(q.remove(), r.remove());
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 <    }
731 <
732 <    /**
733 <     * drainTo(null) throws NullPointerException
734 <     */
735 <    public void testDrainToNull() {
736 <        LinkedTransferQueue q = populatedQueue(SIZE);
737 <        try {
738 <            q.drainTo(null);
739 <            shouldThrow();
740 <        } catch (NullPointerException success) {}
741 <    }
742 <
743 <    /**
744 <     * drainTo(this) throws IllegalArgumentException
745 <     */
746 <    public void testDrainToSelf() {
747 <        LinkedTransferQueue q = populatedQueue(SIZE);
748 <        try {
749 <            q.drainTo(q);
750 <            shouldThrow();
751 <        } catch (IllegalArgumentException success) {}
662 >        assertTrue(y.isEmpty());
663      }
664  
665      /**
# Line 758 | 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 770 | 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  
# Line 789 | Line 700 | public class LinkedTransferQueueTest ext
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 <        }
795 <        awaitTermination(t, MEDIUM_DELAY_MS);
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      /**
800     * drainTo(null, n) throws NullPointerException
801     */
802    public void testDrainToNullN() {
803        LinkedTransferQueue q = populatedQueue(SIZE);
804        try {
805            q.drainTo(null, SIZE);
806            shouldThrow();
807        } catch (NullPointerException success) {}
808    }
809
810    /**
811     * drainTo(this, n) throws IllegalArgumentException
812     */
813    public void testDrainToSelfN() {
814        LinkedTransferQueue q = populatedQueue(SIZE);
815        try {
816            q.drainTo(q, SIZE);
817            shouldThrow();
818        } catch (IllegalArgumentException success) {}
819    }
820
821    /**
710       * drainTo(c, n) empties first min(n, size) elements of queue into c
711       */
712      public void testDrainToN() {
# Line 830 | 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 <            }
838 <            while (q.poll() != null)
839 <                ;
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  
# Line 846 | Line 732 | public class LinkedTransferQueueTest ext
732       */
733      public void testWaitingConsumer() throws InterruptedException {
734          final LinkedTransferQueue q = new LinkedTransferQueue();
735 <        assertEquals(q.getWaitingConsumerCount(), 0);
735 >        assertEquals(0, q.getWaitingConsumerCount());
736          assertFalse(q.hasWaitingConsumer());
737          final CountDownLatch threadStarted = new CountDownLatch(1);
738  
739          Thread t = newStartedThread(new CheckedRunnable() {
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(q.getWaitingConsumerCount(), 0);
744 >                assertEquals(0, q.getWaitingConsumerCount());
745                  assertFalse(q.hasWaitingConsumer());
746 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
747              }});
748  
749          threadStarted.await();
750 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
751 <        assertEquals(q.getWaitingConsumerCount(), 1);
752 <        assertTrue(q.hasWaitingConsumer());
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(q.getWaitingConsumerCount(), 0);
757 >        assertEquals(0, q.getWaitingConsumerCount());
758          assertFalse(q.hasWaitingConsumer());
759  
760 <        awaitTermination(t, MEDIUM_DELAY_MS);
760 >        awaitTermination(t);
761      }
762  
763      /**
# Line 882 | Line 772 | public class LinkedTransferQueueTest ext
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
890 <            = new LinkedTransferQueue<Integer>();
779 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
780          final CountDownLatch threadStarted = new CountDownLatch(1);
781  
782          Thread t = newStartedThread(new CheckedRunnable() {
# Line 898 | Line 787 | public class LinkedTransferQueueTest ext
787              }});
788  
789          threadStarted.await();
790 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
791 <        assertEquals(1, q.size());
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, MEDIUM_DELAY_MS);
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
913 <            = new LinkedTransferQueue<Integer>();
804 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
805  
806          Thread first = newStartedThread(new CheckedRunnable() {
807              public void realRun() throws InterruptedException {
808                  q.transfer(four);
809 <                assertTrue(!q.contains(four));
809 >                assertFalse(q.contains(four));
810                  assertEquals(1, q.size());
811              }});
812  
# Line 958 | Line 849 | public class LinkedTransferQueueTest ext
849          assertEquals(1, q.size());
850          assertTrue(q.offer(three));
851          assertSame(four, q.poll());
852 <        awaitTermination(t, MEDIUM_DELAY_MS);
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
970 <            = new LinkedTransferQueue<Integer>();
860 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
861  
862          Thread t = newStartedThread(new CheckedRunnable() {
863              public void realRun() throws InterruptedException {
# Line 981 | Line 871 | public class LinkedTransferQueueTest ext
871          assertEquals(1, q.size());
872          assertSame(four, q.take());
873          checkEmpty(q);
874 <        awaitTermination(t, MEDIUM_DELAY_MS);
874 >        awaitTermination(t);
875      }
876  
877      /**
878       * tryTransfer(null) throws NullPointerException
879       */
880      public void testTryTransfer1() {
881 +        final LinkedTransferQueue q = new LinkedTransferQueue();
882          try {
992            final LinkedTransferQueue q = new LinkedTransferQueue();
883              q.tryTransfer(null);
884              shouldThrow();
885          } catch (NullPointerException success) {}
# Line 1023 | Line 913 | public class LinkedTransferQueueTest ext
913                  assertTrue(q.tryTransfer(hotPotato));
914              }});
915  
916 <        assertSame(hotPotato, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
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 <        awaitTermination(t, MEDIUM_DELAY_MS);
920 >        awaitTermination(t);
921      }
922  
923      /**
# Line 1047 | Line 939 | public class LinkedTransferQueueTest ext
939  
940          assertSame(q.take(), hotPotato);
941          checkEmpty(q);
942 <        awaitTermination(t, MEDIUM_DELAY_MS);
942 >        awaitTermination(t);
943      }
944  
945      /**
946 <     * tryTransfer waits the amount given, and throws
1055 <     * InterruptedException when interrupted.
946 >     * tryTransfer blocks interruptibly if no takers
947       */
948      public void testTryTransfer5() throws InterruptedException {
949          final LinkedTransferQueue q = new LinkedTransferQueue();
950 <        final CountDownLatch threadStarted = new CountDownLatch(1);
950 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
951          assertTrue(q.isEmpty());
952  
953          Thread t = newStartedThread(new CheckedRunnable() {
954              public void realRun() throws InterruptedException {
955 <                long t0 = System.nanoTime();
956 <                threadStarted.countDown();
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 <                assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
969 <                assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
968 >                assertFalse(Thread.interrupted());
969 >
970 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
971              }});
972  
973 <        threadStarted.await();
974 <        while (q.isEmpty())
1076 <            Thread.yield();
1077 <        Thread.sleep(SHORT_DELAY_MS);
973 >        await(pleaseInterrupt);
974 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
975          t.interrupt();
976 <        awaitTermination(t, MEDIUM_DELAY_MS);
976 >        awaitTermination(t);
977          checkEmpty(q);
978      }
979  
# Line 1088 | Line 985 | public class LinkedTransferQueueTest ext
985  
986          Thread t = newStartedThread(new CheckedRunnable() {
987              public void realRun() throws InterruptedException {
988 <                long t0 = System.nanoTime();
988 >                long startTime = System.nanoTime();
989                  assertFalse(q.tryTransfer(new Object(),
990 <                                          SHORT_DELAY_MS, MILLISECONDS));
991 <                assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
990 >                                          timeoutMillis(), MILLISECONDS));
991 >                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
992                  checkEmpty(q);
993              }});
994  
995 <        awaitTermination(t, MEDIUM_DELAY_MS);
995 >        awaitTermination(t);
996          checkEmpty(q);
997      }
998  
# Line 1109 | Line 1006 | public class LinkedTransferQueueTest ext
1006  
1007          Thread t = newStartedThread(new CheckedRunnable() {
1008              public void realRun() throws InterruptedException {
1009 <                assertTrue(q.tryTransfer(five, MEDIUM_DELAY_MS, MILLISECONDS));
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  
# Line 1119 | Line 1018 | public class LinkedTransferQueueTest ext
1018          assertSame(four, q.poll());
1019          assertSame(five, q.poll());
1020          checkEmpty(q);
1021 <        awaitTermination(t, MEDIUM_DELAY_MS);
1021 >        awaitTermination(t);
1022      }
1023  
1024      /**
# Line 1130 | Line 1029 | public class LinkedTransferQueueTest ext
1029          final LinkedTransferQueue q = new LinkedTransferQueue();
1030          assertTrue(q.offer(four));
1031          assertEquals(1, q.size());
1032 <        long t0 = System.nanoTime();
1033 <        assertFalse(q.tryTransfer(five, SHORT_DELAY_MS, MILLISECONDS));
1034 <        assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
1032 >        long startTime = System.nanoTime();
1033 >        assertFalse(q.tryTransfer(five, timeoutMillis(), MILLISECONDS));
1034 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
1035          assertEquals(1, q.size());
1036          assertSame(four, q.poll());
1037          assertNull(q.poll());
# Line 1140 | Line 1039 | public class LinkedTransferQueueTest ext
1039      }
1040  
1041      private LinkedTransferQueue<Integer> populatedQueue(int n) {
1042 <        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
1042 >        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
1043          checkEmpty(q);
1044          for (int i = 0; i < n; i++) {
1045              assertEquals(i, q.size());
# Line 1150 | Line 1049 | public class LinkedTransferQueueTest ext
1049          assertFalse(q.isEmpty());
1050          return q;
1051      }
1052 +
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