ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/LinkedBlockingDequeTest.java
(Generate patch)

Comparing jsr166/src/test/tck/LinkedBlockingDequeTest.java (file contents):
Revision 1.60 by jsr166, Sun May 24 01:42:14 2015 UTC vs.
Revision 1.76 by jsr166, Sun May 14 00:48:20 2017 UTC

# Line 41 | Line 41 | public class LinkedBlockingDequeTest ext
41      }
42  
43      public static Test suite() {
44 +        class Implementation implements CollectionImplementation {
45 +            public Class<?> klazz() { return LinkedBlockingDeque.class; }
46 +            public Collection emptyCollection() { return new LinkedBlockingDeque(); }
47 +            public Object makeElement(int i) { return i; }
48 +            public boolean isConcurrent() { return true; }
49 +            public boolean permitsNulls() { return false; }
50 +        }
51          return newTestSuite(LinkedBlockingDequeTest.class,
52                              new Unbounded().testSuite(),
53 <                            new Bounded().testSuite());
53 >                            new Bounded().testSuite(),
54 >                            CollectionTest.testSuite(new Implementation()));
55      }
56  
57      /**
58       * Returns a new deque of given size containing consecutive
59 <     * Integers 0 ... n.
59 >     * Integers 0 ... n - 1.
60       */
61 <    private LinkedBlockingDeque<Integer> populatedDeque(int n) {
61 >    private static LinkedBlockingDeque<Integer> populatedDeque(int n) {
62          LinkedBlockingDeque<Integer> q =
63              new LinkedBlockingDeque<Integer>(n);
64          assertTrue(q.isEmpty());
# Line 59 | Line 67 | public class LinkedBlockingDequeTest ext
67          assertFalse(q.isEmpty());
68          assertEquals(0, q.remainingCapacity());
69          assertEquals(n, q.size());
70 +        assertEquals((Integer) 0, q.peekFirst());
71 +        assertEquals((Integer) (n - 1), q.peekLast());
72          return q;
73      }
74  
# Line 594 | Line 604 | public class LinkedBlockingDequeTest ext
604              }});
605  
606          await(pleaseInterrupt);
607 <        assertThreadStaysAlive(t);
607 >        assertThreadBlocks(t, Thread.State.WAITING);
608          t.interrupt();
609          awaitTermination(t);
610          assertEquals(SIZE, q.size());
# Line 629 | Line 639 | public class LinkedBlockingDequeTest ext
639          assertEquals(0, q.take());
640  
641          await(pleaseInterrupt);
642 <        assertThreadStaysAlive(t);
642 >        assertThreadBlocks(t, Thread.State.WAITING);
643          t.interrupt();
644          awaitTermination(t);
645          assertEquals(0, q.remainingCapacity());
# Line 656 | Line 666 | public class LinkedBlockingDequeTest ext
666              }});
667  
668          await(pleaseInterrupt);
669 <        assertThreadStaysAlive(t);
669 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
670          t.interrupt();
671          awaitTermination(t);
672      }
# Line 679 | Line 689 | public class LinkedBlockingDequeTest ext
689          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
690          Thread t = newStartedThread(new CheckedRunnable() {
691              public void realRun() throws InterruptedException {
692 <                for (int i = 0; i < SIZE; ++i) {
683 <                    assertEquals(i, q.take());
684 <                }
692 >                for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
693  
694                  Thread.currentThread().interrupt();
695                  try {
# Line 699 | Line 707 | public class LinkedBlockingDequeTest ext
707              }});
708  
709          await(pleaseInterrupt);
710 <        assertThreadStaysAlive(t);
710 >        assertThreadBlocks(t, Thread.State.WAITING);
711          t.interrupt();
712          awaitTermination(t);
713      }
# Line 748 | Line 756 | public class LinkedBlockingDequeTest ext
756       */
757      public void testInterruptedTimedPoll() throws InterruptedException {
758          final BlockingQueue<Integer> q = populatedDeque(SIZE);
759 <        final CountDownLatch aboutToWait = new CountDownLatch(1);
759 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
760          Thread t = newStartedThread(new CheckedRunnable() {
761              public void realRun() throws InterruptedException {
762 +                long startTime = System.nanoTime();
763                  for (int i = 0; i < SIZE; ++i) {
755 –                    long t0 = System.nanoTime();
764                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
757 –                    assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
765                  }
766 <                long t0 = System.nanoTime();
767 <                aboutToWait.countDown();
766 >
767 >                pleaseInterrupt.countDown();
768                  try {
769 <                    q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
769 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
770                      shouldThrow();
771 <                } catch (InterruptedException success) {
772 <                    assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
773 <                }
771 >                } catch (InterruptedException success) {}
772 >                assertFalse(Thread.interrupted());
773 >
774 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
775              }});
776  
777 <        aboutToWait.await();
778 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
777 >        await(pleaseInterrupt);
778 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
779          t.interrupt();
780 <        awaitTermination(t, MEDIUM_DELAY_MS);
780 >        awaitTermination(t);
781          checkEmpty(q);
782      }
783  
# Line 826 | Line 834 | public class LinkedBlockingDequeTest ext
834              }});
835  
836          await(pleaseInterrupt);
837 <        assertThreadStaysAlive(t);
837 >        assertThreadBlocks(t, Thread.State.WAITING);
838          t.interrupt();
839          awaitTermination(t);
840          assertEquals(SIZE, q.size());
# Line 861 | Line 869 | public class LinkedBlockingDequeTest ext
869          assertEquals(capacity - 1, q.take());
870  
871          await(pleaseInterrupt);
872 <        assertThreadStaysAlive(t);
872 >        assertThreadBlocks(t, Thread.State.WAITING);
873          t.interrupt();
874          awaitTermination(t);
875          assertEquals(0, q.remainingCapacity());
# Line 888 | Line 896 | public class LinkedBlockingDequeTest ext
896              }});
897  
898          await(pleaseInterrupt);
899 <        assertThreadStaysAlive(t);
899 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
900          t.interrupt();
901          awaitTermination(t);
902      }
# Line 920 | Line 928 | public class LinkedBlockingDequeTest ext
928              }});
929  
930          await(threadStarted);
931 <        assertThreadStaysAlive(t);
931 >        assertThreadBlocks(t, Thread.State.WAITING);
932          t.interrupt();
933          awaitTermination(t);
934      }
# Line 961 | Line 969 | public class LinkedBlockingDequeTest ext
969              }});
970  
971          await(threadStarted);
972 <        assertThreadStaysAlive(t);
972 >        assertThreadBlocks(t, Thread.State.WAITING);
973          t.interrupt();
974          awaitTermination(t);
975      }
# Line 993 | Line 1001 | public class LinkedBlockingDequeTest ext
1001          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1002          Thread t = newStartedThread(new CheckedRunnable() {
1003              public void realRun() throws InterruptedException {
1004 <                for (int i = 0; i < SIZE; ++i) {
997 <                    assertEquals(i, q.takeFirst());
998 <                }
1004 >                for (int i = 0; i < SIZE; i++) assertEquals(i, q.takeFirst());
1005  
1006                  Thread.currentThread().interrupt();
1007                  try {
# Line 1013 | Line 1019 | public class LinkedBlockingDequeTest ext
1019              }});
1020  
1021          await(pleaseInterrupt);
1022 <        assertThreadStaysAlive(t);
1022 >        assertThreadBlocks(t, Thread.State.WAITING);
1023          t.interrupt();
1024          awaitTermination(t);
1025      }
# Line 1050 | Line 1056 | public class LinkedBlockingDequeTest ext
1056       * returning timeout status
1057       */
1058      public void testInterruptedTimedPollFirst() throws InterruptedException {
1059 +        final LinkedBlockingDeque q = populatedDeque(SIZE);
1060          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1061          Thread t = newStartedThread(new CheckedRunnable() {
1062              public void realRun() throws InterruptedException {
1063 <                LinkedBlockingDeque q = populatedDeque(SIZE);
1063 >                long startTime = System.nanoTime();
1064                  for (int i = 0; i < SIZE; ++i) {
1065                      assertEquals(i, q.pollFirst(LONG_DELAY_MS, MILLISECONDS));
1066                  }
1067  
1068                  Thread.currentThread().interrupt();
1069                  try {
1070 <                    q.pollFirst(SMALL_DELAY_MS, MILLISECONDS);
1070 >                    q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1071                      shouldThrow();
1072                  } catch (InterruptedException success) {}
1073                  assertFalse(Thread.interrupted());
# Line 1071 | Line 1078 | public class LinkedBlockingDequeTest ext
1078                      shouldThrow();
1079                  } catch (InterruptedException success) {}
1080                  assertFalse(Thread.interrupted());
1081 +
1082 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1083              }});
1084  
1085          await(pleaseInterrupt);
1086 <        assertThreadStaysAlive(t);
1086 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1087          t.interrupt();
1088          awaitTermination(t);
1089      }
# Line 1115 | Line 1124 | public class LinkedBlockingDequeTest ext
1124          assertTrue(q.offerFirst(zero, LONG_DELAY_MS, MILLISECONDS));
1125          assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1126          barrier.await();
1127 <        assertThreadStaysAlive(t);
1127 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1128          t.interrupt();
1129          awaitTermination(t);
1130      }
# Line 1173 | Line 1182 | public class LinkedBlockingDequeTest ext
1182              }});
1183  
1184          await(pleaseInterrupt);
1185 <        assertThreadStaysAlive(t);
1185 >        assertThreadBlocks(t, Thread.State.WAITING);
1186          t.interrupt();
1187          awaitTermination(t);
1188          assertEquals(SIZE, q.size());
# Line 1208 | Line 1217 | public class LinkedBlockingDequeTest ext
1217          assertEquals(0, q.take());
1218  
1219          await(pleaseInterrupt);
1220 <        assertThreadStaysAlive(t);
1220 >        assertThreadBlocks(t, Thread.State.WAITING);
1221          t.interrupt();
1222          awaitTermination(t);
1223          assertEquals(0, q.remainingCapacity());
# Line 1235 | Line 1244 | public class LinkedBlockingDequeTest ext
1244              }});
1245  
1246          await(pleaseInterrupt);
1247 <        assertThreadStaysAlive(t);
1247 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1248          t.interrupt();
1249          awaitTermination(t);
1250      }
# Line 1258 | Line 1267 | public class LinkedBlockingDequeTest ext
1267          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1268          Thread t = newStartedThread(new CheckedRunnable() {
1269              public void realRun() throws InterruptedException {
1270 <                for (int i = 0; i < SIZE; ++i) {
1270 >                for (int i = 0; i < SIZE; i++)
1271                      assertEquals(SIZE - i - 1, q.takeLast());
1263 –                }
1272  
1273                  Thread.currentThread().interrupt();
1274                  try {
# Line 1278 | Line 1286 | public class LinkedBlockingDequeTest ext
1286              }});
1287  
1288          await(pleaseInterrupt);
1289 <        assertThreadStaysAlive(t);
1289 >        assertThreadBlocks(t, Thread.State.WAITING);
1290          t.interrupt();
1291          awaitTermination(t);
1292      }
# Line 1315 | Line 1323 | public class LinkedBlockingDequeTest ext
1323       * returning timeout status
1324       */
1325      public void testInterruptedTimedPollLast() throws InterruptedException {
1326 +        final LinkedBlockingDeque q = populatedDeque(SIZE);
1327          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1328          Thread t = newStartedThread(new CheckedRunnable() {
1329              public void realRun() throws InterruptedException {
1330 <                LinkedBlockingDeque q = populatedDeque(SIZE);
1330 >                long startTime = System.nanoTime();
1331                  for (int i = 0; i < SIZE; ++i) {
1332                      assertEquals(SIZE - i - 1,
1333                                   q.pollLast(LONG_DELAY_MS, MILLISECONDS));
# Line 1337 | Line 1346 | public class LinkedBlockingDequeTest ext
1346                      shouldThrow();
1347                  } catch (InterruptedException success) {}
1348                  assertFalse(Thread.interrupted());
1349 +
1350 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1351              }});
1352  
1353          await(pleaseInterrupt);
1354 <        assertThreadStaysAlive(t);
1354 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1355          t.interrupt();
1356          awaitTermination(t);
1357 +        checkEmpty(q);
1358      }
1359  
1360      /**
# Line 1375 | Line 1387 | public class LinkedBlockingDequeTest ext
1387                      shouldThrow();
1388                  } catch (InterruptedException success) {}
1389                  assertFalse(Thread.interrupted());
1390 +
1391 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1392              }});
1393  
1394          barrier.await();
# Line 1383 | Line 1397 | public class LinkedBlockingDequeTest ext
1397          assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1398  
1399          barrier.await();
1400 <        assertThreadStaysAlive(t);
1400 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1401          t.interrupt();
1402          awaitTermination(t);
1403      }
# Line 1671 | Line 1685 | public class LinkedBlockingDequeTest ext
1685          final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
1686          q.add(one);
1687          q.add(two);
1674 –        ExecutorService executor = Executors.newFixedThreadPool(2);
1688          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
1689 <        executor.execute(new CheckedRunnable() {
1690 <            public void realRun() throws InterruptedException {
1691 <                assertFalse(q.offer(three));
1692 <                threadsStarted.await();
1693 <                assertTrue(q.offer(three, LONG_DELAY_MS, MILLISECONDS));
1694 <                assertEquals(0, q.remainingCapacity());
1695 <            }});
1696 <
1697 <        executor.execute(new CheckedRunnable() {
1698 <            public void realRun() throws InterruptedException {
1699 <                threadsStarted.await();
1700 <                assertSame(one, q.take());
1701 <            }});
1702 <
1703 <        joinPool(executor);
1689 >        final ExecutorService executor = Executors.newFixedThreadPool(2);
1690 >        try (PoolCleaner cleaner = cleaner(executor)) {
1691 >            executor.execute(new CheckedRunnable() {
1692 >                public void realRun() throws InterruptedException {
1693 >                    assertFalse(q.offer(three));
1694 >                    threadsStarted.await();
1695 >                    assertTrue(q.offer(three, LONG_DELAY_MS, MILLISECONDS));
1696 >                    assertEquals(0, q.remainingCapacity());
1697 >                }});
1698 >
1699 >            executor.execute(new CheckedRunnable() {
1700 >                public void realRun() throws InterruptedException {
1701 >                    threadsStarted.await();
1702 >                    assertSame(one, q.take());
1703 >                }});
1704 >        }
1705      }
1706  
1707      /**
# Line 1696 | Line 1710 | public class LinkedBlockingDequeTest ext
1710      public void testPollInExecutor() {
1711          final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
1712          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
1713 <        ExecutorService executor = Executors.newFixedThreadPool(2);
1714 <        executor.execute(new CheckedRunnable() {
1715 <            public void realRun() throws InterruptedException {
1716 <                assertNull(q.poll());
1717 <                threadsStarted.await();
1718 <                assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
1719 <                checkEmpty(q);
1720 <            }});
1721 <
1722 <        executor.execute(new CheckedRunnable() {
1723 <            public void realRun() throws InterruptedException {
1724 <                threadsStarted.await();
1725 <                q.put(one);
1726 <            }});
1727 <
1728 <        joinPool(executor);
1713 >        final ExecutorService executor = Executors.newFixedThreadPool(2);
1714 >        try (PoolCleaner cleaner = cleaner(executor)) {
1715 >            executor.execute(new CheckedRunnable() {
1716 >                public void realRun() throws InterruptedException {
1717 >                    assertNull(q.poll());
1718 >                    threadsStarted.await();
1719 >                    assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
1720 >                    checkEmpty(q);
1721 >                }});
1722 >
1723 >            executor.execute(new CheckedRunnable() {
1724 >                public void realRun() throws InterruptedException {
1725 >                    threadsStarted.await();
1726 >                    q.put(one);
1727 >                }});
1728 >        }
1729      }
1730  
1731      /**

Diff Legend

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