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.74 by jsr166, Sat May 13 22:49:01 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 209 | Line 209 | public class LinkedTransferQueueTest ext
209          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
210          Thread t = newStartedThread(new CheckedRunnable() {
211              public void realRun() throws InterruptedException {
212 <                for (int i = 0; i < SIZE; ++i) {
213 <                    assertEquals(i, q.take());
214 <                }
212 >                for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
213  
214                  Thread.currentThread().interrupt();
215                  try {
# Line 229 | Line 227 | public class LinkedTransferQueueTest ext
227              }});
228  
229          await(pleaseInterrupt);
230 <        assertThreadStaysAlive(t);
230 >        assertThreadBlocks(t, Thread.State.WAITING);
231          t.interrupt();
232          awaitTermination(t);
233      }
# Line 263 | Line 261 | public class LinkedTransferQueueTest ext
261       */
262      public void testTimedPoll() throws InterruptedException {
263          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 –        }
264          long startTime = System.nanoTime();
265 +        for (int i = 0; i < SIZE; ++i)
266 +            assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
267 +        assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
268 +
269 +        startTime = System.nanoTime();
270          assertNull(q.poll(timeoutMillis(), MILLISECONDS));
271          assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
272          checkEmpty(q);
# Line 284 | Line 282 | public class LinkedTransferQueueTest ext
282          Thread t = newStartedThread(new CheckedRunnable() {
283              public void realRun() throws InterruptedException {
284                  long startTime = System.nanoTime();
285 <                for (int i = 0; i < SIZE; ++i) {
285 >                for (int i = 0; i < SIZE; ++i)
286                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
289 –                }
287                  aboutToWait.countDown();
288                  try {
289                      q.poll(LONG_DELAY_MS, MILLISECONDS);
290                      shouldThrow();
291 <                } catch (InterruptedException success) {
292 <                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
296 <                }
291 >                } catch (InterruptedException success) {}
292 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
293              }});
294  
295 <        aboutToWait.await();
296 <        waitForThreadToEnterWaitState(t, LONG_DELAY_MS);
295 >        await(aboutToWait);
296 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
297          t.interrupt();
298          awaitTermination(t);
299          checkEmpty(q);
# Line 311 | Line 307 | public class LinkedTransferQueueTest ext
307          final BlockingQueue<Integer> q = populatedQueue(SIZE);
308          Thread t = newStartedThread(new CheckedRunnable() {
309              public void realRun() throws InterruptedException {
310 +                long startTime = System.nanoTime();
311                  Thread.currentThread().interrupt();
312 <                for (int i = 0; i < SIZE; ++i) {
316 <                    long startTime = System.nanoTime();
312 >                for (int i = 0; i < SIZE; ++i)
313                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
318 –                    assertTrue(millisElapsedSince(startTime) < SMALL_DELAY_MS);
319 –                }
314                  try {
315 <                    q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
315 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
316                      shouldThrow();
317                  } catch (InterruptedException success) {}
318 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
319              }});
320  
321 <        awaitTermination(t, MEDIUM_DELAY_MS);
321 >        awaitTermination(t);
322          checkEmpty(q);
323      }
324  
# Line 419 | Line 414 | public class LinkedTransferQueueTest ext
414       */
415      public void testContainsAll() {
416          LinkedTransferQueue<Integer> q = populatedQueue(SIZE);
417 <        LinkedTransferQueue<Integer> p = new LinkedTransferQueue<Integer>();
417 >        LinkedTransferQueue<Integer> p = new LinkedTransferQueue<>();
418          for (int i = 0; i < SIZE; ++i) {
419              assertTrue(q.containsAll(p));
420              assertFalse(p.containsAll(q));
# Line 548 | Line 543 | public class LinkedTransferQueueTest ext
543       * iterator ordering is FIFO
544       */
545      public void testIteratorOrdering() {
546 <        final LinkedTransferQueue<Integer> q
552 <            = new LinkedTransferQueue<Integer>();
546 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
547          assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
548          q.add(one);
549          q.add(two);
# Line 600 | Line 594 | public class LinkedTransferQueueTest ext
594              executor.execute(new CheckedRunnable() {
595                  public void realRun() throws InterruptedException {
596                      threadsStarted.await();
597 +                    long startTime = System.nanoTime();
598                      assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
599 +                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
600                  }});
601  
602              executor.execute(new CheckedRunnable() {
# Line 625 | Line 621 | public class LinkedTransferQueueTest ext
621                  public void realRun() throws InterruptedException {
622                      assertNull(q.poll());
623                      threadsStarted.await();
624 +                    long startTime = System.nanoTime();
625                      assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
626 +                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
627                      checkEmpty(q);
628                  }});
629  
# Line 695 | Line 693 | public class LinkedTransferQueueTest ext
693          assertTrue(l.size() >= SIZE);
694          for (int i = 0; i < SIZE; ++i)
695              assertEquals(i, l.get(i));
696 <        awaitTermination(t, MEDIUM_DELAY_MS);
696 >        awaitTermination(t);
697          assertTrue(q.size() + l.size() >= SIZE);
698      }
699  
# Line 732 | Line 730 | public class LinkedTransferQueueTest ext
730          Thread t = newStartedThread(new CheckedRunnable() {
731              public void realRun() throws InterruptedException {
732                  threadStarted.countDown();
733 +                long startTime = System.nanoTime();
734                  assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
735                  assertEquals(0, q.getWaitingConsumerCount());
736                  assertFalse(q.hasWaitingConsumer());
737 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
738              }});
739  
740          threadStarted.await();
741 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
742 <        assertEquals(1, q.getWaitingConsumerCount());
743 <        assertTrue(q.hasWaitingConsumer());
741 >        Callable<Boolean> oneConsumer
742 >            = new Callable<Boolean>() { public Boolean call() {
743 >                return q.hasWaitingConsumer()
744 >                && q.getWaitingConsumerCount() == 1; }};
745 >        waitForThreadToEnterWaitState(t, oneConsumer);
746  
747          assertTrue(q.offer(one));
748          assertEquals(0, q.getWaitingConsumerCount());
749          assertFalse(q.hasWaitingConsumer());
750  
751 <        awaitTermination(t, MEDIUM_DELAY_MS);
751 >        awaitTermination(t);
752      }
753  
754      /**
# Line 762 | Line 764 | public class LinkedTransferQueueTest ext
764  
765      /**
766       * transfer waits until a poll occurs. The transfered element
767 <     * is returned by this associated poll.
767 >     * is returned by the associated poll.
768       */
769      public void testTransfer2() throws InterruptedException {
770 <        final LinkedTransferQueue<Integer> q
769 <            = new LinkedTransferQueue<Integer>();
770 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
771          final CountDownLatch threadStarted = new CountDownLatch(1);
772  
773          Thread t = newStartedThread(new CheckedRunnable() {
# Line 777 | Line 778 | public class LinkedTransferQueueTest ext
778              }});
779  
780          threadStarted.await();
781 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
782 <        assertEquals(1, q.size());
781 >        Callable<Boolean> oneElement
782 >            = new Callable<Boolean>() { public Boolean call() {
783 >                return !q.isEmpty() && q.size() == 1; }};
784 >        waitForThreadToEnterWaitState(t, oneElement);
785 >
786          assertSame(five, q.poll());
787          checkEmpty(q);
788 <        awaitTermination(t, MEDIUM_DELAY_MS);
788 >        awaitTermination(t);
789      }
790  
791      /**
792       * transfer waits until a poll occurs, and then transfers in fifo order
793       */
794      public void testTransfer3() throws InterruptedException {
795 <        final LinkedTransferQueue<Integer> q
792 <            = new LinkedTransferQueue<Integer>();
795 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
796  
797          Thread first = newStartedThread(new CheckedRunnable() {
798              public void realRun() throws InterruptedException {
799                  q.transfer(four);
800 <                assertTrue(!q.contains(four));
800 >                assertFalse(q.contains(four));
801                  assertEquals(1, q.size());
802              }});
803  
# Line 837 | Line 840 | public class LinkedTransferQueueTest ext
840          assertEquals(1, q.size());
841          assertTrue(q.offer(three));
842          assertSame(four, q.poll());
843 <        awaitTermination(t, MEDIUM_DELAY_MS);
843 >        awaitTermination(t);
844      }
845  
846      /**
847       * transfer waits until a take occurs. The transfered element
848 <     * is returned by this associated take.
848 >     * is returned by the associated take.
849       */
850      public void testTransfer5() throws InterruptedException {
851 <        final LinkedTransferQueue<Integer> q
849 <            = new LinkedTransferQueue<Integer>();
851 >        final LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
852  
853          Thread t = newStartedThread(new CheckedRunnable() {
854              public void realRun() throws InterruptedException {
# 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      /**
# Line 1021 | Line 1029 | public class LinkedTransferQueueTest ext
1029      }
1030  
1031      private LinkedTransferQueue<Integer> populatedQueue(int n) {
1032 <        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<Integer>();
1032 >        LinkedTransferQueue<Integer> q = new LinkedTransferQueue<>();
1033          checkEmpty(q);
1034          for (int i = 0; i < n; i++) {
1035              assertEquals(i, q.size());

Diff Legend

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