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.64 by jsr166, Tue Oct 6 00:03:55 2015 UTC vs.
Revision 1.68 by jsr166, Wed Jan 4 06:09:58 2017 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 183 | Line 182 | public class LinkedTransferQueueTest ext
182       * all elements successfully put are contained
183       */
184      public void testPut() {
185 <        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
185 >        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
186          for (int i = 0; i < SIZE; ++i) {
187              assertEquals(i, q.size());
188              q.put(i);
# 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 t0 = System.nanoTime();
313 >                for (int i = 0; i < SIZE; ++i)
314                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
318 –                    assertTrue(millisElapsedSince(t0) < 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 419 | Line 415 | public class LinkedTransferQueueTest ext
415       */
416      public void testContainsAll() {
417          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
418 <        LinkedTransferQueue<Integer> p = new LinkedTransferQueue<Integer>();
418 >        LinkedTransferQueue<Integer> p = new LinkedTransferQueue<>();
419          for (int i = 0; i < SIZE; ++i) {
420              assertTrue(q.containsAll(p));
421              assertFalse(p.containsAll(q));
# Line 548 | Line 544 | public class LinkedTransferQueueTest ext
544       * iterator ordering is FIFO
545       */
546      public void testIteratorOrdering() {
547 <        final LinkedTransferQueue<Integer> q
552 <            = new LinkedTransferQueue<Integer>();
547 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
548          assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
549          q.add(one);
550          q.add(two);
# Line 600 | Line 595 | public class LinkedTransferQueueTest ext
595              executor.execute(new CheckedRunnable() {
596                  public void realRun() throws InterruptedException {
597                      threadsStarted.await();
598 +                    long startTime = System.nanoTime();
599                      assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
600 +                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
601                  }});
602  
603              executor.execute(new CheckedRunnable() {
# Line 625 | Line 622 | public class LinkedTransferQueueTest ext
622                  public void realRun() throws InterruptedException {
623                      assertNull(q.poll());
624                      threadsStarted.await();
625 +                    long startTime = System.nanoTime();
626                      assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
627 +                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
628                      checkEmpty(q);
629                  }});
630  
# Line 695 | Line 694 | public class LinkedTransferQueueTest ext
694          assertTrue(l.size() >= SIZE);
695          for (int i = 0; i < SIZE; ++i)
696              assertEquals(i, l.get(i));
697 <        awaitTermination(t, MEDIUM_DELAY_MS);
697 >        awaitTermination(t);
698          assertTrue(q.size() + l.size() >= SIZE);
699      }
700  
# Line 732 | Line 731 | public class LinkedTransferQueueTest ext
731          Thread t = newStartedThread(new CheckedRunnable() {
732              public void realRun() throws InterruptedException {
733                  threadStarted.countDown();
734 +                long startTime = System.nanoTime();
735                  assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
736                  assertEquals(0, q.getWaitingConsumerCount());
737                  assertFalse(q.hasWaitingConsumer());
738 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
739              }});
740  
741          threadStarted.await();
742 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
742 >        waitForThreadToEnterWaitState(t);
743          assertEquals(1, q.getWaitingConsumerCount());
744          assertTrue(q.hasWaitingConsumer());
745  
# Line 746 | Line 747 | public class LinkedTransferQueueTest ext
747          assertEquals(0, q.getWaitingConsumerCount());
748          assertFalse(q.hasWaitingConsumer());
749  
750 <        awaitTermination(t, MEDIUM_DELAY_MS);
750 >        awaitTermination(t);
751      }
752  
753      /**
# Line 765 | Line 766 | public class LinkedTransferQueueTest ext
766       * is returned by this associated poll.
767       */
768      public void testTransfer2() throws InterruptedException {
769 <        final LinkedTransferQueue<Integer> q
769 <            = new LinkedTransferQueue<Integer>();
769 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
770          final CountDownLatch threadStarted = new CountDownLatch(1);
771  
772          Thread t = newStartedThread(new CheckedRunnable() {
# Line 777 | Line 777 | public class LinkedTransferQueueTest ext
777              }});
778  
779          threadStarted.await();
780 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
780 >        waitForThreadToEnterWaitState(t);
781          assertEquals(1, q.size());
782          assertSame(five, q.poll());
783          checkEmpty(q);
784 <        awaitTermination(t, MEDIUM_DELAY_MS);
784 >        awaitTermination(t);
785      }
786  
787      /**
788       * transfer waits until a poll occurs, and then transfers in fifo order
789       */
790      public void testTransfer3() throws InterruptedException {
791 <        final LinkedTransferQueue<Integer> q
792 <            = new LinkedTransferQueue<Integer>();
791 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
792  
793          Thread first = newStartedThread(new CheckedRunnable() {
794              public void realRun() throws InterruptedException {
# Line 837 | Line 836 | public class LinkedTransferQueueTest ext
836          assertEquals(1, q.size());
837          assertTrue(q.offer(three));
838          assertSame(four, q.poll());
839 <        awaitTermination(t, MEDIUM_DELAY_MS);
839 >        awaitTermination(t);
840      }
841  
842      /**
# Line 845 | Line 844 | public class LinkedTransferQueueTest ext
844       * is returned by this associated take.
845       */
846      public void testTransfer5() throws InterruptedException {
847 <        final LinkedTransferQueue<Integer> q
849 <            = new LinkedTransferQueue<Integer>();
847 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
848  
849          Thread t = newStartedThread(new CheckedRunnable() {
850              public void realRun() throws InterruptedException {
# Line 860 | Line 858 | public class LinkedTransferQueueTest ext
858          assertEquals(1, q.size());
859          assertSame(four, q.take());
860          checkEmpty(q);
861 <        awaitTermination(t, MEDIUM_DELAY_MS);
861 >        awaitTermination(t);
862      }
863  
864      /**
# Line 902 | Line 900 | public class LinkedTransferQueueTest ext
900                  assertTrue(q.tryTransfer(hotPotato));
901              }});
902  
903 <        assertSame(hotPotato, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
903 >        long startTime = System.nanoTime();
904 >        assertSame(hotPotato, q.poll(LONG_DELAY_MS, MILLISECONDS));
905 >        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
906          checkEmpty(q);
907 <        awaitTermination(t, MEDIUM_DELAY_MS);
907 >        awaitTermination(t);
908      }
909  
910      /**
# Line 926 | Line 926 | public class LinkedTransferQueueTest ext
926  
927          assertSame(q.take(), hotPotato);
928          checkEmpty(q);
929 <        awaitTermination(t, MEDIUM_DELAY_MS);
929 >        awaitTermination(t);
930      }
931  
932      /**
# Line 939 | Line 939 | public class LinkedTransferQueueTest ext
939  
940          Thread t = newStartedThread(new CheckedRunnable() {
941              public void realRun() throws InterruptedException {
942 +                long startTime = System.nanoTime();
943                  Thread.currentThread().interrupt();
944                  try {
945                      q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
# Line 952 | Line 953 | public class LinkedTransferQueueTest ext
953                      shouldThrow();
954                  } catch (InterruptedException success) {}
955                  assertFalse(Thread.interrupted());
956 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
957              }});
958  
959          await(pleaseInterrupt);
# Line 969 | Line 971 | public class LinkedTransferQueueTest ext
971  
972          Thread t = newStartedThread(new CheckedRunnable() {
973              public void realRun() throws InterruptedException {
974 <                long t0 = System.nanoTime();
974 >                long startTime = System.nanoTime();
975                  assertFalse(q.tryTransfer(new Object(),
976                                            timeoutMillis(), MILLISECONDS));
977 <                assertTrue(millisElapsedSince(t0) >= timeoutMillis());
977 >                assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
978                  checkEmpty(q);
979              }});
980  
# Line 990 | Line 992 | public class LinkedTransferQueueTest ext
992  
993          Thread t = newStartedThread(new CheckedRunnable() {
994              public void realRun() throws InterruptedException {
995 <                assertTrue(q.tryTransfer(five, MEDIUM_DELAY_MS, MILLISECONDS));
995 >                long startTime = System.nanoTime();
996 >                assertTrue(q.tryTransfer(five, LONG_DELAY_MS, MILLISECONDS));
997 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
998                  checkEmpty(q);
999              }});
1000  
# Line 1000 | Line 1004 | public class LinkedTransferQueueTest ext
1004          assertSame(four, q.poll());
1005          assertSame(five, q.poll());
1006          checkEmpty(q);
1007 <        awaitTermination(t, MEDIUM_DELAY_MS);
1007 >        awaitTermination(t);
1008      }
1009  
1010      /**
# Line 1011 | Line 1015 | public class LinkedTransferQueueTest ext
1015          final LinkedTransferQueue q = new LinkedTransferQueue();
1016          assertTrue(q.offer(four));
1017          assertEquals(1, q.size());
1018 <        long t0 = System.nanoTime();
1018 >        long startTime = System.nanoTime();
1019          assertFalse(q.tryTransfer(five, timeoutMillis(), MILLISECONDS));
1020 <        assertTrue(millisElapsedSince(t0) >= timeoutMillis());
1020 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
1021          assertEquals(1, q.size());
1022          assertSame(four, q.poll());
1023          assertNull(q.poll());
# Line 1021 | Line 1025 | public class LinkedTransferQueueTest ext
1025      }
1026  
1027      private LinkedTransferQueue<Integer> populatedQueue(int n) {
1028 <        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
1028 >        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
1029          checkEmpty(q);
1030          for (int i = 0; i < n; i++) {
1031              assertEquals(i, q.size());

Diff Legend

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