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.18 by jsr166, Sat Nov 21 21:00:34 2009 UTC vs.
Revision 1.36 by jsr166, Wed Nov 3 07:54:52 2010 UTC

# Line 18 | Line 18 | import java.util.List;
18   import java.util.NoSuchElementException;
19   import java.util.concurrent.*;
20   import static java.util.concurrent.TimeUnit.MILLISECONDS;
21 + import static java.util.concurrent.TimeUnit.NANOSECONDS;
22   import junit.framework.Test;
23   import junit.framework.TestSuite;
24  
25   @SuppressWarnings({"unchecked", "rawtypes"})
26   public class LinkedTransferQueueTest extends JSR166TestCase {
27  
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());
36      }
37  
38      public static Test suite() {
39 <        return new TestSuite(LinkedTransferQueueTest.class);
39 >        return newTestSuite(LinkedTransferQueueTest.class,
40 >                            new Generic().testSuite());
41      }
42  
43 <    void checkEmpty(LinkedTransferQueue q) throws InterruptedException {
36 <        assertTrue(q.isEmpty());
37 <        assertEquals(0, q.size());
38 <        assertNull(q.peek());
39 <        assertNull(q.poll());
40 <        assertNull(q.poll(0, MILLISECONDS));
41 <        assertEquals(q.toString(), "[]");
42 <        assertTrue(Arrays.equals(q.toArray(), new Object[0]));
43 <        assertFalse(q.iterator().hasNext());
44 <        try {
45 <            q.element();
46 <            shouldThrow();
47 <        } catch (NoSuchElementException success) {}
43 >    void checkEmpty(BlockingQueue q) {
44          try {
45 <            q.iterator().next();
46 <            shouldThrow();
47 <        } catch (NoSuchElementException success) {}
48 <        try {
49 <            q.remove();
50 <            shouldThrow();
51 <        } catch (NoSuchElementException success) {}
45 >            assertTrue(q.isEmpty());
46 >            assertEquals(0, q.size());
47 >            assertNull(q.peek());
48 >            assertNull(q.poll());
49 >            assertNull(q.poll(0, MILLISECONDS));
50 >            assertEquals(q.toString(), "[]");
51 >            assertTrue(Arrays.equals(q.toArray(), new Object[0]));
52 >            assertFalse(q.iterator().hasNext());
53 >            try {
54 >                q.element();
55 >                shouldThrow();
56 >            } catch (NoSuchElementException success) {}
57 >            try {
58 >                q.iterator().next();
59 >                shouldThrow();
60 >            } catch (NoSuchElementException success) {}
61 >            try {
62 >                q.remove();
63 >                shouldThrow();
64 >            } catch (NoSuchElementException success) {}
65 >        } catch (InterruptedException ie) {
66 >            threadUnexpectedException(ie);
67 >        }
68      }
69  
70      /**
# Line 266 | Line 278 | public class LinkedTransferQueueTest ext
278      }
279  
280      /**
281 <     * take blocks interruptibly when empty
270 <     */
271 <    public void testTakeFromEmpty() throws InterruptedException {
272 <        final LinkedTransferQueue q = new LinkedTransferQueue();
273 <        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
274 <            void realRun() throws InterruptedException {
275 <                q.take();
276 <            }});
277 <        Thread.sleep(SHORT_DELAY_MS);
278 <        t.interrupt();
279 <        t.join();
280 <    }
281 <
282 <    /**
283 <     * Take removes existing elements until empty, then blocks interruptibly
281 >     * take removes existing elements until empty, then blocks interruptibly
282       */
283      public void testBlockingTake() throws InterruptedException {
284 <        final LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
285 <        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
286 <            void realRun() throws InterruptedException {
284 >        final BlockingQueue<Integer> q = populatedQueue(SIZE);
285 >        final CountDownLatch aboutToWait = new CountDownLatch(1);
286 >        Thread t = newStartedThread(new CheckedRunnable() {
287 >            public void realRun() throws InterruptedException {
288                  for (int i = 0; i < SIZE; ++i) {
289 <                    threadAssertEquals(i, (int) q.take());
289 >                    assertEquals(i, (int) q.take());
290                  }
291 <                q.take();
291 >                aboutToWait.countDown();
292 >                try {
293 >                    q.take();
294 >                    shouldThrow();
295 >                } catch (InterruptedException success) {}
296              }});
297 <        Thread.sleep(SMALL_DELAY_MS);
297 >
298 >        aboutToWait.await();
299 >        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
300          t.interrupt();
301 <        t.join();
301 >        awaitTermination(t, MEDIUM_DELAY_MS);
302          checkEmpty(q);
303      }
304  
# Line 310 | Line 315 | public class LinkedTransferQueueTest ext
315      }
316  
317      /**
318 <     * timed pool with zero timeout succeeds when non-empty, else times out
318 >     * timed poll with zero timeout succeeds when non-empty, else times out
319       */
320      public void testTimedPoll0() throws InterruptedException {
321          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
# Line 322 | Line 327 | public class LinkedTransferQueueTest ext
327      }
328  
329      /**
330 <     * timed pool with nonzero timeout succeeds when non-empty, else times out
330 >     * timed poll with nonzero timeout succeeds when non-empty, else times out
331       */
332      public void testTimedPoll() throws InterruptedException {
333          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
334          for (int i = 0; i < SIZE; ++i) {
335              long t0 = System.nanoTime();
336 <            assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
337 <            long millisElapsed = (System.nanoTime() - t0)/(1024 * 1024);
333 <            assertTrue(millisElapsed < SMALL_DELAY_MS);
336 >            assertEquals(i, (int) q.poll(SMALL_DELAY_MS, MILLISECONDS));
337 >            assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
338          }
339 +        long t0 = System.nanoTime();
340          assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
341 +        assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
342          checkEmpty(q);
343      }
344  
# Line 341 | Line 347 | public class LinkedTransferQueueTest ext
347       * returning timeout status
348       */
349      public void testInterruptedTimedPoll() throws InterruptedException {
350 <        final LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
350 >        final BlockingQueue<Integer> q = populatedQueue(SIZE);
351 >        final CountDownLatch aboutToWait = new CountDownLatch(1);
352          Thread t = newStartedThread(new CheckedRunnable() {
353 <            void realRun() throws InterruptedException {
353 >            public void realRun() throws InterruptedException {
354                  for (int i = 0; i < SIZE; ++i) {
355                      long t0 = System.nanoTime();
356 <                    threadAssertEquals(i, (int) q.poll(LONG_DELAY_MS,
357 <                                                       MILLISECONDS));
351 <                    long millisElapsed = (System.nanoTime() - t0)/(1024 * 1024);
352 <                    assertTrue(millisElapsed < SMALL_DELAY_MS);
356 >                    assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
357 >                    assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
358                  }
359 +                long t0 = System.nanoTime();
360 +                aboutToWait.countDown();
361                  try {
362 <                    q.poll(LONG_DELAY_MS, MILLISECONDS);
362 >                    q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
363                      shouldThrow();
364 <                } catch (InterruptedException success) {}
364 >                } catch (InterruptedException success) {
365 >                    assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
366 >                }
367              }});
368  
369 <        Thread.sleep(SMALL_DELAY_MS);
369 >        aboutToWait.await();
370 >        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
371          t.interrupt();
372 <        t.join();
372 >        awaitTermination(t, MEDIUM_DELAY_MS);
373          checkEmpty(q);
374      }
375  
376      /**
377 <     * timed poll before a delayed offer fails; after offer succeeds;
378 <     * on interruption throws
377 >     * timed poll after thread interrupted throws InterruptedException
378 >     * instead of returning timeout status
379       */
380 <    public void testTimedPollWithOffer() throws InterruptedException {
381 <        final LinkedTransferQueue q = new LinkedTransferQueue();
382 <        Thread t = new Thread(new CheckedRunnable() {
383 <            void realRun() throws InterruptedException {
384 <                assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
385 <                assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
380 >    public void testTimedPollAfterInterrupt() throws InterruptedException {
381 >        final BlockingQueue<Integer> q = populatedQueue(SIZE);
382 >        Thread t = newStartedThread(new CheckedRunnable() {
383 >            public void realRun() throws InterruptedException {
384 >                Thread.currentThread().interrupt();
385 >                for (int i = 0; i < SIZE; ++i) {
386 >                    long t0 = System.nanoTime();
387 >                    assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
388 >                    assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
389 >                }
390                  try {
391 <                    q.poll(LONG_DELAY_MS, MILLISECONDS);
391 >                    q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
392                      shouldThrow();
393                  } catch (InterruptedException success) {}
394              }});
395  
396 <        Thread.sleep(SMALL_DELAY_MS);
397 <        assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
384 <        t.interrupt();
385 <        t.join();
396 >        awaitTermination(t, MEDIUM_DELAY_MS);
397 >        checkEmpty(q);
398      }
399  
400      /**
# Line 456 | Line 468 | public class LinkedTransferQueueTest ext
468          assertTrue(q.remove(one));
469          assertTrue(q.remove(two));
470          assertTrue(q.add(three));
471 <        assertTrue(q.take() == three);
471 >        assertSame(q.take(), three);
472      }
473  
474      /**
# Line 564 | Line 576 | public class LinkedTransferQueueTest ext
576       * toArray(null) throws NullPointerException
577       */
578      public void testToArray_BadArg() {
579 +        LinkedTransferQueue q = populatedQueue(SIZE);
580          try {
568 –            LinkedTransferQueue q = populatedQueue(SIZE);
581              Object o[] = q.toArray(null);
582              shouldThrow();
583          } catch (NullPointerException success) {}
584      }
585  
586      /**
587 <     * toArray(incompatible array type) throws CCE
587 >     * toArray(incompatible array type) throws ArrayStoreException
588       */
589      public void testToArray1_BadArg() {
590 +        LinkedTransferQueue q = populatedQueue(SIZE);
591          try {
592 <            LinkedTransferQueue q = populatedQueue(SIZE);
580 <            Object o[] = q.toArray(new String[10]);
592 >            q.toArray(new String[10]);
593              shouldThrow();
594          } catch (ArrayStoreException success) {}
595      }
# Line 609 | Line 621 | public class LinkedTransferQueueTest ext
621          it.remove();
622  
623          it = q.iterator();
624 <        assertEquals(it.next(), one);
625 <        assertEquals(it.next(), three);
624 >        assertSame(it.next(), one);
625 >        assertSame(it.next(), three);
626          assertFalse(it.hasNext());
627      }
628  
# Line 663 | Line 675 | public class LinkedTransferQueueTest ext
675       */
676      public void testOfferInExecutor() {
677          final LinkedTransferQueue q = new LinkedTransferQueue();
678 <        q.add(one);
667 <        q.add(two);
678 >        final CountDownLatch threadsStarted = new CountDownLatch(2);
679          ExecutorService executor = Executors.newFixedThreadPool(2);
680  
681          executor.execute(new CheckedRunnable() {
682 <            void realRun() {
683 <                threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS,
684 <                                         MILLISECONDS));
682 >            public void realRun() throws InterruptedException {
683 >                threadsStarted.countDown();
684 >                threadsStarted.await();
685 >                assertTrue(q.offer(one, MEDIUM_DELAY_MS, MILLISECONDS));
686              }});
687  
688          executor.execute(new CheckedRunnable() {
689 <            void realRun() throws InterruptedException {
690 <                Thread.sleep(SMALL_DELAY_MS);
691 <                threadAssertEquals(one, q.take());
689 >            public void realRun() throws InterruptedException {
690 >                threadsStarted.countDown();
691 >                threadsStarted.await();
692 >                assertSame(one, q.take());
693 >                checkEmpty(q);
694              }});
695  
696          joinPool(executor);
# Line 687 | Line 701 | public class LinkedTransferQueueTest ext
701       */
702      public void testPollInExecutor() {
703          final LinkedTransferQueue q = new LinkedTransferQueue();
704 +        final CountDownLatch threadsStarted = new CountDownLatch(2);
705          ExecutorService executor = Executors.newFixedThreadPool(2);
706  
707          executor.execute(new CheckedRunnable() {
708 <            void realRun() throws InterruptedException {
709 <                threadAssertNull(q.poll());
710 <                threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS,
711 <                                                MILLISECONDS));
712 <                threadAssertTrue(q.isEmpty());
708 >            public void realRun() throws InterruptedException {
709 >                assertNull(q.poll());
710 >                threadsStarted.countDown();
711 >                threadsStarted.await();
712 >                assertSame(one, q.poll(SMALL_DELAY_MS, MILLISECONDS));
713 >                checkEmpty(q);
714              }});
715  
716          executor.execute(new CheckedRunnable() {
717 <            void realRun() throws InterruptedException {
718 <                Thread.sleep(SMALL_DELAY_MS);
717 >            public void realRun() throws InterruptedException {
718 >                threadsStarted.countDown();
719 >                threadsStarted.await();
720                  q.put(one);
721              }});
722  
# Line 725 | Line 742 | public class LinkedTransferQueueTest ext
742          LinkedTransferQueue r = (LinkedTransferQueue) in.readObject();
743  
744          assertEquals(q.size(), r.size());
745 +        assertEquals(q.toString(), r.toString());
746 +        assertTrue(Arrays.equals(q.toArray(), r.toArray()));
747          while (!q.isEmpty()) {
748              assertEquals(q.remove(), r.remove());
749          }
# Line 784 | Line 803 | public class LinkedTransferQueueTest ext
803      public void testDrainToWithActivePut() throws InterruptedException {
804          final LinkedTransferQueue q = populatedQueue(SIZE);
805          Thread t = newStartedThread(new CheckedRunnable() {
806 <            void realRun() {
806 >            public void realRun() {
807                  q.put(SIZE + 1);
808              }});
809          ArrayList l = new ArrayList();
# Line 793 | Line 812 | public class LinkedTransferQueueTest ext
812          for (int i = 0; i < SIZE; ++i) {
813              assertEquals(l.get(i), i);
814          }
815 <        t.join();
815 >        awaitTermination(t, MEDIUM_DELAY_MS);
816          assertTrue(q.size() + l.size() >= SIZE);
817      }
818  
# Line 820 | Line 839 | public class LinkedTransferQueueTest ext
839      }
840  
841      /**
842 <     * drainTo(c, n) empties first max {n, size} elements of queue into c
842 >     * drainTo(c, n) empties first min(n, size) elements of queue into c
843       */
844      public void testDrainToN() {
845          LinkedTransferQueue q = new LinkedTransferQueue();
# Line 849 | Line 868 | public class LinkedTransferQueueTest ext
868          final LinkedTransferQueue q = new LinkedTransferQueue();
869          assertEquals(q.getWaitingConsumerCount(), 0);
870          assertFalse(q.hasWaitingConsumer());
871 +        final CountDownLatch threadStarted = new CountDownLatch(1);
872  
873          Thread t = newStartedThread(new CheckedRunnable() {
874 <            void realRun() throws InterruptedException {
875 <                Thread.sleep(SMALL_DELAY_MS);
876 <                threadAssertTrue(q.hasWaitingConsumer());
877 <                threadAssertEquals(q.getWaitingConsumerCount(), 1);
878 <                threadAssertTrue(q.offer(new Object()));
859 <                threadAssertFalse(q.hasWaitingConsumer());
860 <                threadAssertEquals(q.getWaitingConsumerCount(), 0);
874 >            public void realRun() throws InterruptedException {
875 >                threadStarted.countDown();
876 >                assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
877 >                assertEquals(q.getWaitingConsumerCount(), 0);
878 >                assertFalse(q.hasWaitingConsumer());
879              }});
880  
881 <        assertTrue(q.poll(LONG_DELAY_MS, MILLISECONDS) != null);
881 >        threadStarted.await();
882 >        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
883 >        assertEquals(q.getWaitingConsumerCount(), 1);
884 >        assertTrue(q.hasWaitingConsumer());
885 >
886 >        assertTrue(q.offer(one));
887          assertEquals(q.getWaitingConsumerCount(), 0);
888          assertFalse(q.hasWaitingConsumer());
889 <        t.join();
889 >
890 >        awaitTermination(t, MEDIUM_DELAY_MS);
891      }
892  
893      /**
# Line 884 | Line 908 | public class LinkedTransferQueueTest ext
908      public void testTransfer2() throws InterruptedException {
909          final LinkedTransferQueue<Integer> q
910              = new LinkedTransferQueue<Integer>();
911 +        final CountDownLatch threadStarted = new CountDownLatch(1);
912  
913          Thread t = newStartedThread(new CheckedRunnable() {
914 <            void realRun() throws InterruptedException {
915 <                q.transfer(SIZE);
916 <                threadAssertTrue(q.isEmpty());
914 >            public void realRun() throws InterruptedException {
915 >                threadStarted.countDown();
916 >                q.transfer(five);
917 >                checkEmpty(q);
918              }});
919  
920 <        Thread.sleep(SHORT_DELAY_MS);
920 >        threadStarted.await();
921 >        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
922          assertEquals(1, q.size());
923 <        assertEquals(SIZE, (int) q.poll());
924 <        assertTrue(q.isEmpty());
925 <        t.join();
923 >        assertSame(five, q.poll());
924 >        checkEmpty(q);
925 >        awaitTermination(t, MEDIUM_DELAY_MS);
926      }
927  
928      /**
# Line 906 | Line 933 | public class LinkedTransferQueueTest ext
933              = new LinkedTransferQueue<Integer>();
934  
935          Thread first = newStartedThread(new CheckedRunnable() {
936 <            void realRun() throws InterruptedException {
937 <                Integer i = SIZE + 1;
938 <                q.transfer(i);
939 <                threadAssertTrue(!q.contains(i));
913 <                threadAssertEquals(1, q.size());
936 >            public void realRun() throws InterruptedException {
937 >                q.transfer(four);
938 >                assertTrue(!q.contains(four));
939 >                assertEquals(1, q.size());
940              }});
941  
942          Thread interruptedThread = newStartedThread(
943              new CheckedInterruptedRunnable() {
944 <                void realRun() throws InterruptedException {
945 <                    while (q.size() == 0)
944 >                public void realRun() throws InterruptedException {
945 >                    while (q.isEmpty())
946                          Thread.yield();
947 <                    q.transfer(SIZE);
947 >                    q.transfer(five);
948                  }});
949  
950          while (q.size() < 2)
951              Thread.yield();
952          assertEquals(2, q.size());
953 <        assertEquals(SIZE + 1, (int) q.poll());
953 >        assertSame(four, q.poll());
954          first.join();
955          assertEquals(1, q.size());
956          interruptedThread.interrupt();
957          interruptedThread.join();
958 <        assertEquals(0, q.size());
933 <        assertTrue(q.isEmpty());
958 >        checkEmpty(q);
959      }
960  
961      /**
# Line 941 | Line 966 | public class LinkedTransferQueueTest ext
966          final LinkedTransferQueue q = new LinkedTransferQueue();
967  
968          Thread t = newStartedThread(new CheckedRunnable() {
969 <            void realRun() throws InterruptedException {
969 >            public void realRun() throws InterruptedException {
970                  q.transfer(four);
971 <                threadAssertFalse(q.contains(four));
972 <                threadAssertEquals(three, q.poll());
971 >                assertFalse(q.contains(four));
972 >                assertSame(three, q.poll());
973              }});
974  
975 <        Thread.sleep(SHORT_DELAY_MS);
975 >        while (q.isEmpty())
976 >            Thread.yield();
977 >        assertFalse(q.isEmpty());
978 >        assertEquals(1, q.size());
979          assertTrue(q.offer(three));
980 <        assertEquals(four, q.poll());
981 <        t.join();
980 >        assertSame(four, q.poll());
981 >        awaitTermination(t, MEDIUM_DELAY_MS);
982      }
983  
984      /**
# Line 962 | Line 990 | public class LinkedTransferQueueTest ext
990              = new LinkedTransferQueue<Integer>();
991  
992          Thread t = newStartedThread(new CheckedRunnable() {
993 <            void realRun() throws InterruptedException {
994 <                q.transfer(SIZE);
993 >            public void realRun() throws InterruptedException {
994 >                q.transfer(four);
995                  checkEmpty(q);
996              }});
997  
998 <        Thread.sleep(SHORT_DELAY_MS);
999 <        assertEquals(SIZE, (int) q.take());
998 >        while (q.isEmpty())
999 >            Thread.yield();
1000 >        assertFalse(q.isEmpty());
1001 >        assertEquals(1, q.size());
1002 >        assertSame(four, q.take());
1003          checkEmpty(q);
1004 <        t.join();
1004 >        awaitTermination(t, MEDIUM_DELAY_MS);
1005      }
1006  
1007      /**
# Line 1004 | Line 1035 | public class LinkedTransferQueueTest ext
1035          final LinkedTransferQueue q = new LinkedTransferQueue();
1036  
1037          Thread t = newStartedThread(new CheckedRunnable() {
1038 <            void realRun() {
1038 >            public void realRun() {
1039                  while (! q.hasWaitingConsumer())
1040                      Thread.yield();
1041 <                threadAssertTrue(q.hasWaitingConsumer());
1042 <                threadAssertTrue(q.isEmpty());
1043 <                threadAssertTrue(q.size() == 0);
1013 <                threadAssertTrue(q.tryTransfer(hotPotato));
1041 >                assertTrue(q.hasWaitingConsumer());
1042 >                checkEmpty(q);
1043 >                assertTrue(q.tryTransfer(hotPotato));
1044              }});
1045  
1046 <        assertTrue(q.poll(MEDIUM_DELAY_MS, MILLISECONDS) == hotPotato);
1046 >        assertSame(hotPotato, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
1047          checkEmpty(q);
1048 <        t.join();
1048 >        awaitTermination(t, MEDIUM_DELAY_MS);
1049      }
1050  
1051      /**
# Line 1027 | Line 1057 | public class LinkedTransferQueueTest ext
1057          final LinkedTransferQueue q = new LinkedTransferQueue();
1058  
1059          Thread t = newStartedThread(new CheckedRunnable() {
1060 <            void realRun() {
1060 >            public void realRun() {
1061                  while (! q.hasWaitingConsumer())
1062                      Thread.yield();
1063 <                threadAssertTrue(q.hasWaitingConsumer());
1064 <                threadAssertTrue(q.isEmpty());
1065 <                threadAssertTrue(q.size() == 0);
1036 <                threadAssertTrue(q.tryTransfer(hotPotato));
1063 >                assertTrue(q.hasWaitingConsumer());
1064 >                checkEmpty(q);
1065 >                assertTrue(q.tryTransfer(hotPotato));
1066              }});
1067  
1068 <        assertTrue(q.take() == hotPotato);
1068 >        assertSame(q.take(), hotPotato);
1069          checkEmpty(q);
1070 <        t.join();
1070 >        awaitTermination(t, MEDIUM_DELAY_MS);
1071      }
1072  
1073      /**
# Line 1047 | Line 1076 | public class LinkedTransferQueueTest ext
1076       */
1077      public void testTryTransfer5() throws InterruptedException {
1078          final LinkedTransferQueue q = new LinkedTransferQueue();
1079 +        final CountDownLatch threadStarted = new CountDownLatch(1);
1080  
1081 <        Thread toInterrupt = newStartedThread(new CheckedInterruptedRunnable() {
1082 <            void realRun() throws InterruptedException {
1083 <                q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
1081 >        Thread t = newStartedThread(new CheckedRunnable() {
1082 >            public void realRun() throws InterruptedException {
1083 >                long t0 = System.nanoTime();
1084 >                threadStarted.countDown();
1085 >                try {
1086 >                    q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
1087 >                    shouldThrow();
1088 >                } catch (InterruptedException success) {}
1089 >                assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
1090              }});
1091  
1092 <        Thread.sleep(SMALL_DELAY_MS);
1093 <        toInterrupt.interrupt();
1094 <        toInterrupt.join();
1092 >        threadStarted.await();
1093 >        Thread.sleep(SHORT_DELAY_MS);
1094 >        t.interrupt();
1095 >        awaitTermination(t, MEDIUM_DELAY_MS);
1096 >        checkEmpty(q);
1097      }
1098  
1099      /**
1100 <     * tryTransfer gives up after the timeout and return false
1100 >     * tryTransfer gives up after the timeout and returns false
1101       */
1102      public void testTryTransfer6() throws InterruptedException {
1103          final LinkedTransferQueue q = new LinkedTransferQueue();
1104  
1105          Thread t = newStartedThread(new CheckedRunnable() {
1106 <            void realRun() throws InterruptedException {
1107 <                threadAssertFalse
1108 <                    (q.tryTransfer(new Object(),
1109 <                                   SHORT_DELAY_MS, MILLISECONDS));
1106 >            public void realRun() throws InterruptedException {
1107 >                long t0 = System.nanoTime();
1108 >                assertFalse(q.tryTransfer(new Object(),
1109 >                                          SHORT_DELAY_MS, MILLISECONDS));
1110 >                assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
1111 >                checkEmpty(q);
1112              }});
1113  
1114 <        Thread.sleep(SMALL_DELAY_MS);
1114 >        awaitTermination(t, MEDIUM_DELAY_MS);
1115          checkEmpty(q);
1076 –        t.join();
1116      }
1117  
1118      /**
# Line 1085 | Line 1124 | public class LinkedTransferQueueTest ext
1124          assertTrue(q.offer(four));
1125  
1126          Thread t = newStartedThread(new CheckedRunnable() {
1127 <            void realRun() throws InterruptedException {
1128 <                threadAssertTrue(q.tryTransfer(five,
1129 <                                               MEDIUM_DELAY_MS, MILLISECONDS));
1091 <                threadAssertTrue(q.isEmpty());
1127 >            public void realRun() throws InterruptedException {
1128 >                assertTrue(q.tryTransfer(five, MEDIUM_DELAY_MS, MILLISECONDS));
1129 >                checkEmpty(q);
1130              }});
1131  
1132 <        Thread.sleep(SHORT_DELAY_MS);
1132 >        while (q.size() != 2)
1133 >            Thread.yield();
1134          assertEquals(2, q.size());
1135 <        assertEquals(four, q.poll());
1136 <        assertEquals(five, q.poll());
1135 >        assertSame(four, q.poll());
1136 >        assertSame(five, q.poll());
1137          checkEmpty(q);
1138 <        t.join();
1138 >        awaitTermination(t, MEDIUM_DELAY_MS);
1139      }
1140  
1141      /**
# Line 1107 | Line 1146 | public class LinkedTransferQueueTest ext
1146          final LinkedTransferQueue q = new LinkedTransferQueue();
1147          assertTrue(q.offer(four));
1148          assertEquals(1, q.size());
1149 +        long t0 = System.nanoTime();
1150          assertFalse(q.tryTransfer(five, SHORT_DELAY_MS, MILLISECONDS));
1151 +        assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
1152          assertEquals(1, q.size());
1153 <        assertEquals(four, q.poll());
1153 >        assertSame(four, q.poll());
1154          assertNull(q.poll());
1155          checkEmpty(q);
1156      }
1157  
1158      private LinkedTransferQueue<Integer> populatedQueue(int n) {
1159          LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
1160 <        assertTrue(q.isEmpty());
1160 >        checkEmpty(q);
1161          for (int i = 0; i < n; i++) {
1162              assertEquals(i, q.size());
1163              assertTrue(q.offer(i));

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines