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.17 by jsr166, Sat Nov 21 19:45:16 2009 UTC vs.
Revision 1.33 by jsr166, Fri Oct 29 06:22:12 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) < SHORT_DELAY_MS);
358                  }
359 +                aboutToWait.countDown();
360                  try {
361 <                    q.poll(LONG_DELAY_MS, MILLISECONDS);
361 >                    q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
362                      shouldThrow();
363                  } catch (InterruptedException success) {}
364              }});
365  
366 <        Thread.sleep(SMALL_DELAY_MS);
366 >        aboutToWait.await();
367 >        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
368          t.interrupt();
369 <        t.join();
369 >        awaitTermination(t, MEDIUM_DELAY_MS);
370          checkEmpty(q);
371      }
372  
373      /**
374 <     * timed poll before a delayed offer fails; after offer succeeds;
375 <     * on interruption throws
374 >     * timed poll after thread interrupted throws InterruptedException
375 >     * instead of returning timeout status
376       */
377 <    public void testTimedPollWithOffer() throws InterruptedException {
378 <        final LinkedTransferQueue q = new LinkedTransferQueue();
379 <        Thread t = newStartedThread(new CheckedInterruptedRunnable() {
380 <            void realRun() throws InterruptedException {
381 <                threadAssertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
382 <                q.poll(LONG_DELAY_MS, MILLISECONDS);
383 <                q.poll(LONG_DELAY_MS, MILLISECONDS);
377 >    public void testTimedPollAfterInterrupt() throws InterruptedException {
378 >        final BlockingQueue<Integer> q = populatedQueue(SIZE);
379 >        Thread t = newStartedThread(new CheckedRunnable() {
380 >            public void realRun() throws InterruptedException {
381 >                Thread.currentThread().interrupt();
382 >                for (int i = 0; i < SIZE; ++i) {
383 >                    long t0 = System.nanoTime();
384 >                    assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
385 >                    assertTrue(millisElapsedSince(t0) < SHORT_DELAY_MS);
386 >                }
387 >                try {
388 >                    q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
389 >                    shouldThrow();
390 >                } catch (InterruptedException success) {}
391              }});
392 <        Thread.sleep(SMALL_DELAY_MS);
393 <        assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
394 <        t.interrupt();
381 <        t.join();
392 >
393 >        awaitTermination(t, MEDIUM_DELAY_MS);
394 >        checkEmpty(q);
395      }
396  
397      /**
# Line 452 | Line 465 | public class LinkedTransferQueueTest ext
465          assertTrue(q.remove(one));
466          assertTrue(q.remove(two));
467          assertTrue(q.add(three));
468 <        assertTrue(q.take() == three);
468 >        assertSame(q.take(), three);
469      }
470  
471      /**
# Line 560 | Line 573 | public class LinkedTransferQueueTest ext
573       * toArray(null) throws NullPointerException
574       */
575      public void testToArray_BadArg() {
576 +        LinkedTransferQueue q = populatedQueue(SIZE);
577          try {
564 –            LinkedTransferQueue q = populatedQueue(SIZE);
578              Object o[] = q.toArray(null);
579              shouldThrow();
580          } catch (NullPointerException success) {}
# Line 571 | Line 584 | public class LinkedTransferQueueTest ext
584       * toArray(incompatible array type) throws CCE
585       */
586      public void testToArray1_BadArg() {
587 +        LinkedTransferQueue q = populatedQueue(SIZE);
588          try {
575 –            LinkedTransferQueue q = populatedQueue(SIZE);
589              Object o[] = q.toArray(new String[10]);
590              shouldThrow();
591          } catch (ArrayStoreException success) {}
# Line 605 | Line 618 | public class LinkedTransferQueueTest ext
618          it.remove();
619  
620          it = q.iterator();
621 <        assertEquals(it.next(), one);
622 <        assertEquals(it.next(), three);
621 >        assertSame(it.next(), one);
622 >        assertSame(it.next(), three);
623          assertFalse(it.hasNext());
624      }
625  
# Line 659 | Line 672 | public class LinkedTransferQueueTest ext
672       */
673      public void testOfferInExecutor() {
674          final LinkedTransferQueue q = new LinkedTransferQueue();
675 <        q.add(one);
663 <        q.add(two);
675 >        final CountDownLatch threadsStarted = new CountDownLatch(2);
676          ExecutorService executor = Executors.newFixedThreadPool(2);
677  
678          executor.execute(new CheckedRunnable() {
679 <            void realRun() {
680 <                threadAssertTrue(q.offer(three, MEDIUM_DELAY_MS,
681 <                                         MILLISECONDS));
679 >            public void realRun() throws InterruptedException {
680 >                threadsStarted.countDown();
681 >                threadsStarted.await();
682 >                assertTrue(q.offer(one, MEDIUM_DELAY_MS, MILLISECONDS));
683              }});
684  
685          executor.execute(new CheckedRunnable() {
686 <            void realRun() throws InterruptedException {
687 <                Thread.sleep(SMALL_DELAY_MS);
688 <                threadAssertEquals(one, q.take());
686 >            public void realRun() throws InterruptedException {
687 >                threadsStarted.countDown();
688 >                threadsStarted.await();
689 >                assertSame(one, q.take());
690 >                checkEmpty(q);
691              }});
692  
693          joinPool(executor);
# Line 683 | Line 698 | public class LinkedTransferQueueTest ext
698       */
699      public void testPollInExecutor() {
700          final LinkedTransferQueue q = new LinkedTransferQueue();
701 +        final CountDownLatch threadsStarted = new CountDownLatch(2);
702          ExecutorService executor = Executors.newFixedThreadPool(2);
703  
704          executor.execute(new CheckedRunnable() {
705 <            void realRun() throws InterruptedException {
706 <                threadAssertNull(q.poll());
707 <                threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS,
708 <                                                MILLISECONDS));
709 <                threadAssertTrue(q.isEmpty());
705 >            public void realRun() throws InterruptedException {
706 >                assertNull(q.poll());
707 >                threadsStarted.countDown();
708 >                threadsStarted.await();
709 >                assertSame(one, q.poll(SMALL_DELAY_MS, MILLISECONDS));
710 >                checkEmpty(q);
711              }});
712  
713          executor.execute(new CheckedRunnable() {
714 <            void realRun() throws InterruptedException {
715 <                Thread.sleep(SMALL_DELAY_MS);
714 >            public void realRun() throws InterruptedException {
715 >                threadsStarted.countDown();
716 >                threadsStarted.await();
717                  q.put(one);
718              }});
719  
# Line 721 | Line 739 | public class LinkedTransferQueueTest ext
739          LinkedTransferQueue r = (LinkedTransferQueue) in.readObject();
740  
741          assertEquals(q.size(), r.size());
742 +        assertEquals(q.toString(), r.toString());
743 +        assertTrue(Arrays.equals(q.toArray(), r.toArray()));
744          while (!q.isEmpty()) {
745              assertEquals(q.remove(), r.remove());
746          }
# Line 780 | Line 800 | public class LinkedTransferQueueTest ext
800      public void testDrainToWithActivePut() throws InterruptedException {
801          final LinkedTransferQueue q = populatedQueue(SIZE);
802          Thread t = newStartedThread(new CheckedRunnable() {
803 <            void realRun() {
803 >            public void realRun() {
804                  q.put(SIZE + 1);
805              }});
806          ArrayList l = new ArrayList();
# Line 789 | Line 809 | public class LinkedTransferQueueTest ext
809          for (int i = 0; i < SIZE; ++i) {
810              assertEquals(l.get(i), i);
811          }
812 <        t.join();
812 >        awaitTermination(t, MEDIUM_DELAY_MS);
813          assertTrue(q.size() + l.size() >= SIZE);
814      }
815  
# Line 816 | Line 836 | public class LinkedTransferQueueTest ext
836      }
837  
838      /**
839 <     * drainTo(c, n) empties first max {n, size} elements of queue into c
839 >     * drainTo(c, n) empties first min(n, size) elements of queue into c
840       */
841      public void testDrainToN() {
842          LinkedTransferQueue q = new LinkedTransferQueue();
# Line 845 | Line 865 | public class LinkedTransferQueueTest ext
865          final LinkedTransferQueue q = new LinkedTransferQueue();
866          assertEquals(q.getWaitingConsumerCount(), 0);
867          assertFalse(q.hasWaitingConsumer());
868 +        final CountDownLatch threadStarted = new CountDownLatch(1);
869  
870          Thread t = newStartedThread(new CheckedRunnable() {
871 <            void realRun() throws InterruptedException {
872 <                Thread.sleep(SMALL_DELAY_MS);
873 <                threadAssertTrue(q.hasWaitingConsumer());
874 <                threadAssertEquals(q.getWaitingConsumerCount(), 1);
875 <                threadAssertTrue(q.offer(new Object()));
855 <                threadAssertFalse(q.hasWaitingConsumer());
856 <                threadAssertEquals(q.getWaitingConsumerCount(), 0);
871 >            public void realRun() throws InterruptedException {
872 >                threadStarted.countDown();
873 >                assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
874 >                assertEquals(q.getWaitingConsumerCount(), 0);
875 >                assertFalse(q.hasWaitingConsumer());
876              }});
877  
878 <        assertTrue(q.poll(LONG_DELAY_MS, MILLISECONDS) != null);
878 >        threadStarted.await();
879 >        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
880 >        assertEquals(q.getWaitingConsumerCount(), 1);
881 >        assertTrue(q.hasWaitingConsumer());
882 >
883 >        assertTrue(q.offer(one));
884          assertEquals(q.getWaitingConsumerCount(), 0);
885          assertFalse(q.hasWaitingConsumer());
886 <        t.join();
886 >
887 >        awaitTermination(t, MEDIUM_DELAY_MS);
888      }
889  
890      /**
# Line 880 | Line 905 | public class LinkedTransferQueueTest ext
905      public void testTransfer2() throws InterruptedException {
906          final LinkedTransferQueue<Integer> q
907              = new LinkedTransferQueue<Integer>();
908 +        final CountDownLatch threadStarted = new CountDownLatch(1);
909  
910          Thread t = newStartedThread(new CheckedRunnable() {
911 <            void realRun() throws InterruptedException {
911 >            public void realRun() throws InterruptedException {
912 >                threadStarted.countDown();
913                  q.transfer(SIZE);
914 <                threadAssertTrue(q.isEmpty());
914 >                checkEmpty(q);
915              }});
916  
917 <        Thread.sleep(SHORT_DELAY_MS);
917 >        threadStarted.await();
918 >        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
919 >        assertTrue(t.isAlive());
920          assertEquals(1, q.size());
921          assertEquals(SIZE, (int) q.poll());
922 <        assertTrue(q.isEmpty());
923 <        t.join();
922 >        checkEmpty(q);
923 >        awaitTermination(t, MEDIUM_DELAY_MS);
924      }
925  
926      /**
# Line 902 | Line 931 | public class LinkedTransferQueueTest ext
931              = new LinkedTransferQueue<Integer>();
932  
933          Thread first = newStartedThread(new CheckedRunnable() {
934 <            void realRun() throws InterruptedException {
935 <                Integer i = SIZE + 1;
936 <                q.transfer(i);
937 <                threadAssertTrue(!q.contains(i));
909 <                threadAssertEquals(1, q.size());
934 >            public void realRun() throws InterruptedException {
935 >                q.transfer(four);
936 >                assertTrue(!q.contains(four));
937 >                assertEquals(1, q.size());
938              }});
939  
940          Thread interruptedThread = newStartedThread(
941              new CheckedInterruptedRunnable() {
942 <                void realRun() throws InterruptedException {
943 <                    while (q.size() == 0)
942 >                public void realRun() throws InterruptedException {
943 >                    while (q.isEmpty())
944                          Thread.yield();
945 <                    q.transfer(SIZE);
945 >                    q.transfer(five);
946                  }});
947  
948          while (q.size() < 2)
949              Thread.yield();
950          assertEquals(2, q.size());
951 <        assertEquals(SIZE + 1, (int) q.poll());
951 >        assertSame(four, q.poll());
952          first.join();
953          assertEquals(1, q.size());
954          interruptedThread.interrupt();
955          interruptedThread.join();
956 <        assertEquals(0, q.size());
929 <        assertTrue(q.isEmpty());
956 >        checkEmpty(q);
957      }
958  
959      /**
# Line 937 | Line 964 | public class LinkedTransferQueueTest ext
964          final LinkedTransferQueue q = new LinkedTransferQueue();
965  
966          Thread t = newStartedThread(new CheckedRunnable() {
967 <            void realRun() throws InterruptedException {
967 >            public void realRun() throws InterruptedException {
968                  q.transfer(four);
969 <                threadAssertFalse(q.contains(four));
970 <                threadAssertEquals(three, q.poll());
969 >                assertFalse(q.contains(four));
970 >                assertSame(three, q.poll());
971              }});
972  
973 <        Thread.sleep(SHORT_DELAY_MS);
973 >        while (q.isEmpty())
974 >            Thread.yield();
975 >        assertFalse(q.isEmpty());
976 >        assertEquals(1, q.size());
977          assertTrue(q.offer(three));
978 <        assertEquals(four, q.poll());
979 <        t.join();
978 >        assertSame(four, q.poll());
979 >        awaitTermination(t, MEDIUM_DELAY_MS);
980      }
981  
982      /**
# Line 958 | Line 988 | public class LinkedTransferQueueTest ext
988              = new LinkedTransferQueue<Integer>();
989  
990          Thread t = newStartedThread(new CheckedRunnable() {
991 <            void realRun() throws InterruptedException {
992 <                q.transfer(SIZE);
991 >            public void realRun() throws InterruptedException {
992 >                q.transfer(four);
993                  checkEmpty(q);
994              }});
995  
996 <        Thread.sleep(SHORT_DELAY_MS);
997 <        assertEquals(SIZE, (int) q.take());
996 >        while (q.isEmpty())
997 >            Thread.yield();
998 >        assertFalse(q.isEmpty());
999 >        assertEquals(1, q.size());
1000 >        assertSame(four, q.take());
1001          checkEmpty(q);
1002 <        t.join();
1002 >        awaitTermination(t, MEDIUM_DELAY_MS);
1003      }
1004  
1005      /**
# Line 1000 | Line 1033 | public class LinkedTransferQueueTest ext
1033          final LinkedTransferQueue q = new LinkedTransferQueue();
1034  
1035          Thread t = newStartedThread(new CheckedRunnable() {
1036 <            void realRun() {
1036 >            public void realRun() {
1037                  while (! q.hasWaitingConsumer())
1038                      Thread.yield();
1039 <                threadAssertTrue(q.hasWaitingConsumer());
1040 <                threadAssertTrue(q.isEmpty());
1041 <                threadAssertTrue(q.size() == 0);
1009 <                threadAssertTrue(q.tryTransfer(hotPotato));
1039 >                assertTrue(q.hasWaitingConsumer());
1040 >                checkEmpty(q);
1041 >                assertTrue(q.tryTransfer(hotPotato));
1042              }});
1043  
1044 <        assertTrue(q.poll(MEDIUM_DELAY_MS, MILLISECONDS) == hotPotato);
1044 >        assertSame(hotPotato, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
1045          checkEmpty(q);
1046 <        t.join();
1046 >        awaitTermination(t, MEDIUM_DELAY_MS);
1047      }
1048  
1049      /**
# Line 1023 | Line 1055 | public class LinkedTransferQueueTest ext
1055          final LinkedTransferQueue q = new LinkedTransferQueue();
1056  
1057          Thread t = newStartedThread(new CheckedRunnable() {
1058 <            void realRun() {
1058 >            public void realRun() {
1059                  while (! q.hasWaitingConsumer())
1060                      Thread.yield();
1061 <                threadAssertTrue(q.hasWaitingConsumer());
1062 <                threadAssertTrue(q.isEmpty());
1063 <                threadAssertTrue(q.size() == 0);
1032 <                threadAssertTrue(q.tryTransfer(hotPotato));
1061 >                assertTrue(q.hasWaitingConsumer());
1062 >                checkEmpty(q);
1063 >                assertTrue(q.tryTransfer(hotPotato));
1064              }});
1065  
1066 <        assertTrue(q.take() == hotPotato);
1066 >        assertSame(q.take(), hotPotato);
1067          checkEmpty(q);
1068 <        t.join();
1068 >        awaitTermination(t, MEDIUM_DELAY_MS);
1069      }
1070  
1071      /**
# Line 1043 | Line 1074 | public class LinkedTransferQueueTest ext
1074       */
1075      public void testTryTransfer5() throws InterruptedException {
1076          final LinkedTransferQueue q = new LinkedTransferQueue();
1077 +        final CountDownLatch threadStarted = new CountDownLatch(1);
1078  
1079 <        Thread toInterrupt = newStartedThread(new CheckedInterruptedRunnable() {
1080 <            void realRun() throws InterruptedException {
1081 <                q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
1079 >        Thread t = newStartedThread(new CheckedRunnable() {
1080 >            public void realRun() throws InterruptedException {
1081 >                long t0 = System.nanoTime();
1082 >                threadStarted.countDown();
1083 >                try {
1084 >                    q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
1085 >                    shouldThrow();
1086 >                } catch (InterruptedException success) {}
1087 >                assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
1088              }});
1089  
1090 <        Thread.sleep(SMALL_DELAY_MS);
1091 <        toInterrupt.interrupt();
1092 <        toInterrupt.join();
1090 >        threadStarted.await();
1091 >        Thread.sleep(SHORT_DELAY_MS);
1092 >        t.interrupt();
1093 >        awaitTermination(t, MEDIUM_DELAY_MS);
1094 >        checkEmpty(q);
1095      }
1096  
1097      /**
1098 <     * tryTransfer gives up after the timeout and return false
1098 >     * tryTransfer gives up after the timeout and returns false
1099       */
1100      public void testTryTransfer6() throws InterruptedException {
1101          final LinkedTransferQueue q = new LinkedTransferQueue();
1102  
1103          Thread t = newStartedThread(new CheckedRunnable() {
1104 <            void realRun() throws InterruptedException {
1105 <                threadAssertFalse
1106 <                    (q.tryTransfer(new Object(),
1107 <                                   SHORT_DELAY_MS, MILLISECONDS));
1104 >            public void realRun() throws InterruptedException {
1105 >                long t0 = System.nanoTime();
1106 >                assertFalse(q.tryTransfer(new Object(),
1107 >                                          SHORT_DELAY_MS, MILLISECONDS));
1108 >                assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
1109 >                checkEmpty(q);
1110              }});
1111  
1112 <        Thread.sleep(SMALL_DELAY_MS);
1112 >        awaitTermination(t, MEDIUM_DELAY_MS);
1113          checkEmpty(q);
1072 –        t.join();
1114      }
1115  
1116      /**
# Line 1081 | Line 1122 | public class LinkedTransferQueueTest ext
1122          assertTrue(q.offer(four));
1123  
1124          Thread t = newStartedThread(new CheckedRunnable() {
1125 <            void realRun() throws InterruptedException {
1126 <                threadAssertTrue(q.tryTransfer(five,
1127 <                                               MEDIUM_DELAY_MS, MILLISECONDS));
1087 <                threadAssertTrue(q.isEmpty());
1125 >            public void realRun() throws InterruptedException {
1126 >                assertTrue(q.tryTransfer(five, MEDIUM_DELAY_MS, MILLISECONDS));
1127 >                checkEmpty(q);
1128              }});
1129  
1130 <        Thread.sleep(SHORT_DELAY_MS);
1130 >        while (q.size() != 2)
1131 >            Thread.yield();
1132          assertEquals(2, q.size());
1133 <        assertEquals(four, q.poll());
1134 <        assertEquals(five, q.poll());
1133 >        assertSame(four, q.poll());
1134 >        assertSame(five, q.poll());
1135          checkEmpty(q);
1136 <        t.join();
1136 >        awaitTermination(t, MEDIUM_DELAY_MS);
1137      }
1138  
1139      /**
# Line 1103 | Line 1144 | public class LinkedTransferQueueTest ext
1144          final LinkedTransferQueue q = new LinkedTransferQueue();
1145          assertTrue(q.offer(four));
1146          assertEquals(1, q.size());
1147 +        long t0 = System.nanoTime();
1148          assertFalse(q.tryTransfer(five, SHORT_DELAY_MS, MILLISECONDS));
1149 +        assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
1150          assertEquals(1, q.size());
1151 <        assertEquals(four, q.poll());
1151 >        assertSame(four, q.poll());
1152          assertNull(q.poll());
1153          checkEmpty(q);
1154      }
1155  
1156      private LinkedTransferQueue<Integer> populatedQueue(int n) {
1157          LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
1158 <        assertTrue(q.isEmpty());
1158 >        checkEmpty(q);
1159          for (int i = 0; i < n; i++) {
1160              assertEquals(i, q.size());
1161              assertTrue(q.offer(i));

Diff Legend

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