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.72 by jsr166, Sat Mar 25 21:41:10 2017 UTC

# Line 15 | Line 15 | import java.util.List;
15   import java.util.NoSuchElementException;
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;
# Line 24 | Line 25 | import junit.framework.Test;
25  
26   @SuppressWarnings({"unchecked", "rawtypes"})
27   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 –
28      public static class Generic extends BlockingQueueTest {
29          protected BlockingQueue emptyCollection() {
30              return new LinkedTransferQueue();
# Line 43 | Line 36 | public class LinkedTransferQueueTest ext
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(),
48                              CollectionTest.testSuite(new Implementation()));
# Line 183 | Line 183 | public class LinkedTransferQueueTest ext
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(i, q.size());
189              q.put(i);
# Line 263 | Line 263 | public class LinkedTransferQueueTest ext
263       */
264      public void testTimedPoll() throws InterruptedException {
265          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 –        }
266          long startTime = System.nanoTime();
267 +        for (int i = 0; i < SIZE; ++i)
268 +            assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
269 +        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
270 +
271 +        startTime = System.nanoTime();
272          assertNull(q.poll(timeoutMillis(), MILLISECONDS));
273          assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
274          checkEmpty(q);
# Line 284 | Line 284 | public class LinkedTransferQueueTest ext
284          Thread t = newStartedThread(new CheckedRunnable() {
285              public void realRun() throws InterruptedException {
286                  long startTime = System.nanoTime();
287 <                for (int i = 0; i < SIZE; ++i) {
287 >                for (int i = 0; i < SIZE; ++i)
288                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
289 –                }
289                  aboutToWait.countDown();
290                  try {
291                      q.poll(LONG_DELAY_MS, MILLISECONDS);
292                      shouldThrow();
293 <                } catch (InterruptedException success) {
294 <                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
296 <                }
293 >                } catch (InterruptedException success) {}
294 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
295              }});
296  
297 <        aboutToWait.await();
298 <        waitForThreadToEnterWaitState(t, LONG_DELAY_MS);
297 >        await(aboutToWait);
298 >        waitForThreadToEnterWaitState(t);
299          t.interrupt();
300          awaitTermination(t);
301          checkEmpty(q);
# Line 311 | Line 309 | public class LinkedTransferQueueTest ext
309          final BlockingQueue<Integer> q = populatedQueue(SIZE);
310          Thread t = newStartedThread(new CheckedRunnable() {
311              public void realRun() throws InterruptedException {
312 +                long startTime = System.nanoTime();
313                  Thread.currentThread().interrupt();
314 <                for (int i = 0; i < SIZE; ++i) {
316 <                    long startTime = System.nanoTime();
314 >                for (int i = 0; i < SIZE; ++i)
315                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
318 –                    assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
319 –                }
316                  try {
317 <                    q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
317 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
318                      shouldThrow();
319                  } catch (InterruptedException success) {}
320 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
321              }});
322  
323 <        awaitTermination(t, MEDIUM_DELAY_MS);
323 >        awaitTermination(t);
324          checkEmpty(q);
325      }
326  
# Line 419 | Line 416 | public class LinkedTransferQueueTest ext
416       */
417      public void testContainsAll() {
418          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
419 <        LinkedTransferQueue<Integer> p = new LinkedTransferQueue<Integer>();
419 >        LinkedTransferQueue<Integer> p = new LinkedTransferQueue<>();
420          for (int i = 0; i < SIZE; ++i) {
421              assertTrue(q.containsAll(p));
422              assertFalse(p.containsAll(q));
# Line 548 | Line 545 | public class LinkedTransferQueueTest ext
545       * iterator ordering is FIFO
546       */
547      public void testIteratorOrdering() {
548 <        final LinkedTransferQueue<Integer> q
552 <            = new LinkedTransferQueue<Integer>();
548 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
549          assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
550          q.add(one);
551          q.add(two);
# 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);
744 <        assertEquals(1, q.getWaitingConsumerCount());
745 <        assertTrue(q.hasWaitingConsumer());
743 >        Callable<Boolean> oneConsumer
744 >            = new Callable<Boolean>() { public Boolean call() {
745 >                return q.hasWaitingConsumer()
746 >                && q.getWaitingConsumerCount() == 1; }};
747 >        waitForThreadToEnterWaitState(t, oneConsumer);
748  
749          assertTrue(q.offer(one));
750          assertEquals(0, q.getWaitingConsumerCount());
751          assertFalse(q.hasWaitingConsumer());
752  
753 <        awaitTermination(t, MEDIUM_DELAY_MS);
753 >        awaitTermination(t);
754      }
755  
756      /**
# Line 762 | Line 766 | public class LinkedTransferQueueTest ext
766  
767      /**
768       * transfer waits until a poll occurs. The transfered element
769 <     * is returned by this associated poll.
769 >     * is returned by the associated poll.
770       */
771      public void testTransfer2() throws InterruptedException {
772 <        final LinkedTransferQueue<Integer> q
769 <            = new LinkedTransferQueue<Integer>();
772 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
773          final CountDownLatch threadStarted = new CountDownLatch(1);
774  
775          Thread t = newStartedThread(new CheckedRunnable() {
# Line 777 | Line 780 | public class LinkedTransferQueueTest ext
780              }});
781  
782          threadStarted.await();
783 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
784 <        assertEquals(1, q.size());
783 >        Callable<Boolean> oneElement
784 >            = new Callable<Boolean>() { public Boolean call() {
785 >                return !q.isEmpty() && q.size() == 1; }};
786 >        waitForThreadToEnterWaitState(t, oneElement);
787 >
788          assertSame(five, q.poll());
789          checkEmpty(q);
790 <        awaitTermination(t, MEDIUM_DELAY_MS);
790 >        awaitTermination(t);
791      }
792  
793      /**
794       * transfer waits until a poll occurs, and then transfers in fifo order
795       */
796      public void testTransfer3() throws InterruptedException {
797 <        final LinkedTransferQueue<Integer> q
792 <            = new LinkedTransferQueue<Integer>();
797 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
798  
799          Thread first = newStartedThread(new CheckedRunnable() {
800              public void realRun() throws InterruptedException {
801                  q.transfer(four);
802 <                assertTrue(!q.contains(four));
802 >                assertFalse(q.contains(four));
803                  assertEquals(1, q.size());
804              }});
805  
# Line 837 | Line 842 | public class LinkedTransferQueueTest ext
842          assertEquals(1, q.size());
843          assertTrue(q.offer(three));
844          assertSame(four, q.poll());
845 <        awaitTermination(t, MEDIUM_DELAY_MS);
845 >        awaitTermination(t);
846      }
847  
848      /**
849       * transfer waits until a take occurs. The transfered element
850 <     * is returned by this associated take.
850 >     * is returned by the associated take.
851       */
852      public void testTransfer5() throws InterruptedException {
853 <        final LinkedTransferQueue<Integer> q
849 <            = new LinkedTransferQueue<Integer>();
853 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
854  
855          Thread t = newStartedThread(new CheckedRunnable() {
856              public void realRun() throws InterruptedException {
# Line 860 | Line 864 | public class LinkedTransferQueueTest ext
864          assertEquals(1, q.size());
865          assertSame(four, q.take());
866          checkEmpty(q);
867 <        awaitTermination(t, MEDIUM_DELAY_MS);
867 >        awaitTermination(t);
868      }
869  
870      /**
# Line 902 | Line 906 | public class LinkedTransferQueueTest ext
906                  assertTrue(q.tryTransfer(hotPotato));
907              }});
908  
909 <        assertSame(hotPotato, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
909 >        long startTime = System.nanoTime();
910 >        assertSame(hotPotato, q.poll(LONG_DELAY_MS, MILLISECONDS));
911 >        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
912          checkEmpty(q);
913 <        awaitTermination(t, MEDIUM_DELAY_MS);
913 >        awaitTermination(t);
914      }
915  
916      /**
# Line 926 | Line 932 | public class LinkedTransferQueueTest ext
932  
933          assertSame(q.take(), hotPotato);
934          checkEmpty(q);
935 <        awaitTermination(t, MEDIUM_DELAY_MS);
935 >        awaitTermination(t);
936      }
937  
938      /**
# Line 939 | Line 945 | public class LinkedTransferQueueTest ext
945  
946          Thread t = newStartedThread(new CheckedRunnable() {
947              public void realRun() throws InterruptedException {
948 +                long startTime = System.nanoTime();
949                  Thread.currentThread().interrupt();
950                  try {
951                      q.tryTransfer(new Object(), LONG_DELAY_MS, MILLISECONDS);
# Line 952 | Line 959 | public class LinkedTransferQueueTest ext
959                      shouldThrow();
960                  } catch (InterruptedException success) {}
961                  assertFalse(Thread.interrupted());
962 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
963              }});
964  
965          await(pleaseInterrupt);
# Line 990 | Line 998 | public class LinkedTransferQueueTest ext
998  
999          Thread t = newStartedThread(new CheckedRunnable() {
1000              public void realRun() throws InterruptedException {
1001 <                assertTrue(q.tryTransfer(five, MEDIUM_DELAY_MS, MILLISECONDS));
1001 >                long startTime = System.nanoTime();
1002 >                assertTrue(q.tryTransfer(five, LONG_DELAY_MS, MILLISECONDS));
1003 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1004                  checkEmpty(q);
1005              }});
1006  
# Line 1000 | Line 1010 | public class LinkedTransferQueueTest ext
1010          assertSame(four, q.poll());
1011          assertSame(five, q.poll());
1012          checkEmpty(q);
1013 <        awaitTermination(t, MEDIUM_DELAY_MS);
1013 >        awaitTermination(t);
1014      }
1015  
1016      /**
# Line 1021 | Line 1031 | public class LinkedTransferQueueTest ext
1031      }
1032  
1033      private LinkedTransferQueue<Integer> populatedQueue(int n) {
1034 <        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
1034 >        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
1035          checkEmpty(q);
1036          for (int i = 0; i < n; i++) {
1037              assertEquals(i, q.size());

Diff Legend

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