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.65 by jsr166, Tue Oct 6 00:36:55 2015 UTC vs.
Revision 1.67 by jsr166, Sun Oct 16 20:16:36 2016 UTC

# Line 24 | Line 24 | import junit.framework.Test;
24  
25   @SuppressWarnings({"unchecked", "rawtypes"})
26   public class LinkedTransferQueueTest extends JSR166TestCase {
27 –    static class Implementation implements CollectionImplementation {
28 –        public Class<?> klazz() { return LinkedTransferQueue.class; }
29 –        public Collection emptyCollection() { return new LinkedTransferQueue(); }
30 –        public Object makeElement(int i) { return i; }
31 –        public boolean isConcurrent() { return true; }
32 –        public boolean permitsNulls() { return false; }
33 –    }
34 –
27      public static class Generic extends BlockingQueueTest {
28          protected BlockingQueue emptyCollection() {
29              return new LinkedTransferQueue();
# Line 43 | Line 35 | public class LinkedTransferQueueTest ext
35      }
36  
37      public static Test suite() {
38 +        class Implementation implements CollectionImplementation {
39 +            public Class<?> klazz() { return LinkedTransferQueue.class; }
40 +            public Collection emptyCollection() { return new LinkedTransferQueue(); }
41 +            public Object makeElement(int i) { return i; }
42 +            public boolean isConcurrent() { return true; }
43 +            public boolean permitsNulls() { return false; }
44 +        }
45          return newTestSuite(LinkedTransferQueueTest.class,
46                              new Generic().testSuite(),
47                              CollectionTest.testSuite(new Implementation()));
# Line 263 | Line 262 | public class LinkedTransferQueueTest ext
262       */
263      public void testTimedPoll() throws InterruptedException {
264          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
266 –        for (int i = 0; i < SIZE; ++i) {
267 –            long startTime = System.nanoTime();
268 –            assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
269 –            assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
270 –        }
265          long startTime = System.nanoTime();
266 +        for (int i = 0; i < SIZE; ++i)
267 +            assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
268 +        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
269 +
270 +        startTime = System.nanoTime();
271          assertNull(q.poll(timeoutMillis(), MILLISECONDS));
272          assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
273          checkEmpty(q);
# Line 284 | Line 283 | public class LinkedTransferQueueTest ext
283          Thread t = newStartedThread(new CheckedRunnable() {
284              public void realRun() throws InterruptedException {
285                  long startTime = System.nanoTime();
286 <                for (int i = 0; i < SIZE; ++i) {
286 >                for (int i = 0; i < SIZE; ++i)
287                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
289 –                }
288                  aboutToWait.countDown();
289                  try {
290                      q.poll(LONG_DELAY_MS, MILLISECONDS);
291                      shouldThrow();
292 <                } catch (InterruptedException success) {
293 <                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
296 <                }
292 >                } catch (InterruptedException success) {}
293 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
294              }});
295  
296          aboutToWait.await();
297 <        waitForThreadToEnterWaitState(t, LONG_DELAY_MS);
297 >        waitForThreadToEnterWaitState(t);
298          t.interrupt();
299          awaitTermination(t);
300          checkEmpty(q);
# Line 311 | Line 308 | public class LinkedTransferQueueTest ext
308          final BlockingQueue<Integer> q = populatedQueue(SIZE);
309          Thread t = newStartedThread(new CheckedRunnable() {
310              public void realRun() throws InterruptedException {
311 +                long startTime = System.nanoTime();
312                  Thread.currentThread().interrupt();
313 <                for (int i = 0; i < SIZE; ++i) {
316 <                    long startTime = System.nanoTime();
313 >                for (int i = 0; i < SIZE; ++i)
314                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
318 –                    assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
319 –                }
315                  try {
316 <                    q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
316 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
317                      shouldThrow();
318                  } catch (InterruptedException success) {}
319 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
320              }});
321  
322 <        awaitTermination(t, MEDIUM_DELAY_MS);
322 >        awaitTermination(t);
323          checkEmpty(q);
324      }
325  
# Line 600 | Line 596 | public class LinkedTransferQueueTest ext
596              executor.execute(new CheckedRunnable() {
597                  public void realRun() throws InterruptedException {
598                      threadsStarted.await();
599 +                    long startTime = System.nanoTime();
600                      assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
601 +                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
602                  }});
603  
604              executor.execute(new CheckedRunnable() {
# Line 625 | Line 623 | public class LinkedTransferQueueTest ext
623                  public void realRun() throws InterruptedException {
624                      assertNull(q.poll());
625                      threadsStarted.await();
626 +                    long startTime = System.nanoTime();
627                      assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
628 +                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
629                      checkEmpty(q);
630                  }});
631  
# Line 695 | Line 695 | public class LinkedTransferQueueTest ext
695          assertTrue(l.size() >= SIZE);
696          for (int i = 0; i < SIZE; ++i)
697              assertEquals(i, l.get(i));
698 <        awaitTermination(t, MEDIUM_DELAY_MS);
698 >        awaitTermination(t);
699          assertTrue(q.size() + l.size() >= SIZE);
700      }
701  
# Line 732 | Line 732 | public class LinkedTransferQueueTest ext
732          Thread t = newStartedThread(new CheckedRunnable() {
733              public void realRun() throws InterruptedException {
734                  threadStarted.countDown();
735 +                long startTime = System.nanoTime();
736                  assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
737                  assertEquals(0, q.getWaitingConsumerCount());
738                  assertFalse(q.hasWaitingConsumer());
739 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
740              }});
741  
742          threadStarted.await();
743 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
743 >        waitForThreadToEnterWaitState(t);
744          assertEquals(1, q.getWaitingConsumerCount());
745          assertTrue(q.hasWaitingConsumer());
746  
# Line 746 | Line 748 | public class LinkedTransferQueueTest ext
748          assertEquals(0, q.getWaitingConsumerCount());
749          assertFalse(q.hasWaitingConsumer());
750  
751 <        awaitTermination(t, MEDIUM_DELAY_MS);
751 >        awaitTermination(t);
752      }
753  
754      /**
# Line 777 | Line 779 | public class LinkedTransferQueueTest ext
779              }});
780  
781          threadStarted.await();
782 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
782 >        waitForThreadToEnterWaitState(t);
783          assertEquals(1, q.size());
784          assertSame(five, q.poll());
785          checkEmpty(q);
786 <        awaitTermination(t, MEDIUM_DELAY_MS);
786 >        awaitTermination(t);
787      }
788  
789      /**
# Line 837 | Line 839 | public class LinkedTransferQueueTest ext
839          assertEquals(1, q.size());
840          assertTrue(q.offer(three));
841          assertSame(four, q.poll());
842 <        awaitTermination(t, MEDIUM_DELAY_MS);
842 >        awaitTermination(t);
843      }
844  
845      /**
# Line 860 | Line 862 | public class LinkedTransferQueueTest ext
862          assertEquals(1, q.size());
863          assertSame(four, q.take());
864          checkEmpty(q);
865 <        awaitTermination(t, MEDIUM_DELAY_MS);
865 >        awaitTermination(t);
866      }
867  
868      /**
# Line 902 | Line 904 | public class LinkedTransferQueueTest ext
904                  assertTrue(q.tryTransfer(hotPotato));
905              }});
906  
907 <        assertSame(hotPotato, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
907 >        long startTime = System.nanoTime();
908 >        assertSame(hotPotato, q.poll(LONG_DELAY_MS, MILLISECONDS));
909 >        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
910          checkEmpty(q);
911 <        awaitTermination(t, MEDIUM_DELAY_MS);
911 >        awaitTermination(t);
912      }
913  
914      /**
# Line 926 | Line 930 | public class LinkedTransferQueueTest ext
930  
931          assertSame(q.take(), hotPotato);
932          checkEmpty(q);
933 <        awaitTermination(t, MEDIUM_DELAY_MS);
933 >        awaitTermination(t);
934      }
935  
936      /**
# Line 939 | Line 943 | public class LinkedTransferQueueTest ext
943  
944          Thread t = newStartedThread(new CheckedRunnable() {
945              public void realRun() throws InterruptedException {
946 +                long startTime = System.nanoTime();
947                  Thread.currentThread().interrupt();
948                  try {
949                      q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
# Line 952 | Line 957 | public class LinkedTransferQueueTest ext
957                      shouldThrow();
958                  } catch (InterruptedException success) {}
959                  assertFalse(Thread.interrupted());
960 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
961              }});
962  
963          await(pleaseInterrupt);
# Line 990 | Line 996 | public class LinkedTransferQueueTest ext
996  
997          Thread t = newStartedThread(new CheckedRunnable() {
998              public void realRun() throws InterruptedException {
999 <                assertTrue(q.tryTransfer(five, MEDIUM_DELAY_MS, MILLISECONDS));
999 >                long startTime = System.nanoTime();
1000 >                assertTrue(q.tryTransfer(five, LONG_DELAY_MS, MILLISECONDS));
1001 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1002                  checkEmpty(q);
1003              }});
1004  
# Line 1000 | Line 1008 | public class LinkedTransferQueueTest ext
1008          assertSame(four, q.poll());
1009          assertSame(five, q.poll());
1010          checkEmpty(q);
1011 <        awaitTermination(t, MEDIUM_DELAY_MS);
1011 >        awaitTermination(t);
1012      }
1013  
1014      /**

Diff Legend

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