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.61 by jsr166, Sun Oct 4 18:49:02 2015 UTC vs.
Revision 1.72 by jsr166, Sat May 13 22:17:12 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 751 | Line 759 | public class LinkedBlockingDequeTest ext
759          final CountDownLatch aboutToWait = 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                  }
759 –                long t0 = System.nanoTime();
766                  aboutToWait.countDown();
767                  try {
768 <                    q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
768 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
769                      shouldThrow();
770                  } catch (InterruptedException success) {
771 <                    assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
771 >                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
772                  }
773              }});
774  
775 <        aboutToWait.await();
776 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
775 >        await(aboutToWait);
776 >        waitForThreadToEnterWaitState(t);
777          t.interrupt();
778 <        awaitTermination(t, MEDIUM_DELAY_MS);
778 >        awaitTermination(t);
779          checkEmpty(q);
780      }
781  
# Line 826 | Line 832 | public class LinkedBlockingDequeTest ext
832              }});
833  
834          await(pleaseInterrupt);
835 <        assertThreadStaysAlive(t);
835 >        assertThreadBlocks(t, Thread.State.WAITING);
836          t.interrupt();
837          awaitTermination(t);
838          assertEquals(SIZE, q.size());
# Line 861 | Line 867 | public class LinkedBlockingDequeTest ext
867          assertEquals(capacity - 1, q.take());
868  
869          await(pleaseInterrupt);
870 <        assertThreadStaysAlive(t);
870 >        assertThreadBlocks(t, Thread.State.WAITING);
871          t.interrupt();
872          awaitTermination(t);
873          assertEquals(0, q.remainingCapacity());
# Line 888 | Line 894 | public class LinkedBlockingDequeTest ext
894              }});
895  
896          await(pleaseInterrupt);
897 <        assertThreadStaysAlive(t);
897 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
898          t.interrupt();
899          awaitTermination(t);
900      }
# Line 920 | Line 926 | public class LinkedBlockingDequeTest ext
926              }});
927  
928          await(threadStarted);
929 <        assertThreadStaysAlive(t);
929 >        assertThreadBlocks(t, Thread.State.WAITING);
930          t.interrupt();
931          awaitTermination(t);
932      }
# Line 961 | Line 967 | public class LinkedBlockingDequeTest ext
967              }});
968  
969          await(threadStarted);
970 <        assertThreadStaysAlive(t);
970 >        assertThreadBlocks(t, Thread.State.WAITING);
971          t.interrupt();
972          awaitTermination(t);
973      }
# Line 993 | Line 999 | public class LinkedBlockingDequeTest ext
999          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1000          Thread t = newStartedThread(new CheckedRunnable() {
1001              public void realRun() throws InterruptedException {
1002 <                for (int i = 0; i < SIZE; ++i) {
997 <                    assertEquals(i, q.takeFirst());
998 <                }
1002 >                for (int i = 0; i < SIZE; i++) assertEquals(i, q.takeFirst());
1003  
1004                  Thread.currentThread().interrupt();
1005                  try {
# Line 1013 | Line 1017 | public class LinkedBlockingDequeTest ext
1017              }});
1018  
1019          await(pleaseInterrupt);
1020 <        assertThreadStaysAlive(t);
1020 >        assertThreadBlocks(t, Thread.State.WAITING);
1021          t.interrupt();
1022          awaitTermination(t);
1023      }
# Line 1050 | Line 1054 | public class LinkedBlockingDequeTest ext
1054       * returning timeout status
1055       */
1056      public void testInterruptedTimedPollFirst() throws InterruptedException {
1057 +        final LinkedBlockingDeque q = populatedDeque(SIZE);
1058          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1059          Thread t = newStartedThread(new CheckedRunnable() {
1060              public void realRun() throws InterruptedException {
1061 <                LinkedBlockingDeque q = populatedDeque(SIZE);
1061 >                long startTime = System.nanoTime();
1062                  for (int i = 0; i < SIZE; ++i) {
1063                      assertEquals(i, q.pollFirst(LONG_DELAY_MS, MILLISECONDS));
1064                  }
1065  
1066                  Thread.currentThread().interrupt();
1067                  try {
1068 <                    q.pollFirst(SMALL_DELAY_MS, MILLISECONDS);
1068 >                    q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1069                      shouldThrow();
1070                  } catch (InterruptedException success) {}
1071                  assertFalse(Thread.interrupted());
# Line 1071 | Line 1076 | public class LinkedBlockingDequeTest ext
1076                      shouldThrow();
1077                  } catch (InterruptedException success) {}
1078                  assertFalse(Thread.interrupted());
1079 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1080              }});
1081  
1082          await(pleaseInterrupt);
# Line 1173 | Line 1179 | public class LinkedBlockingDequeTest ext
1179              }});
1180  
1181          await(pleaseInterrupt);
1182 <        assertThreadStaysAlive(t);
1182 >        assertThreadBlocks(t, Thread.State.WAITING);
1183          t.interrupt();
1184          awaitTermination(t);
1185          assertEquals(SIZE, q.size());
# Line 1208 | Line 1214 | public class LinkedBlockingDequeTest ext
1214          assertEquals(0, q.take());
1215  
1216          await(pleaseInterrupt);
1217 <        assertThreadStaysAlive(t);
1217 >        assertThreadBlocks(t, Thread.State.WAITING);
1218          t.interrupt();
1219          awaitTermination(t);
1220          assertEquals(0, q.remainingCapacity());
# Line 1235 | Line 1241 | public class LinkedBlockingDequeTest ext
1241              }});
1242  
1243          await(pleaseInterrupt);
1244 <        assertThreadStaysAlive(t);
1244 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1245          t.interrupt();
1246          awaitTermination(t);
1247      }
# Line 1258 | Line 1264 | public class LinkedBlockingDequeTest ext
1264          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1265          Thread t = newStartedThread(new CheckedRunnable() {
1266              public void realRun() throws InterruptedException {
1267 <                for (int i = 0; i < SIZE; ++i) {
1267 >                for (int i = 0; i < SIZE; i++)
1268                      assertEquals(SIZE - i - 1, q.takeLast());
1263 –                }
1269  
1270                  Thread.currentThread().interrupt();
1271                  try {
# Line 1278 | Line 1283 | public class LinkedBlockingDequeTest ext
1283              }});
1284  
1285          await(pleaseInterrupt);
1286 <        assertThreadStaysAlive(t);
1286 >        assertThreadBlocks(t, Thread.State.WAITING);
1287          t.interrupt();
1288          awaitTermination(t);
1289      }
# Line 1315 | Line 1320 | public class LinkedBlockingDequeTest ext
1320       * returning timeout status
1321       */
1322      public void testInterruptedTimedPollLast() throws InterruptedException {
1323 +        final LinkedBlockingDeque q = populatedDeque(SIZE);
1324          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1325          Thread t = newStartedThread(new CheckedRunnable() {
1326              public void realRun() throws InterruptedException {
1327 <                LinkedBlockingDeque q = populatedDeque(SIZE);
1327 >                long startTime = System.nanoTime();
1328                  for (int i = 0; i < SIZE; ++i) {
1329                      assertEquals(SIZE - i - 1,
1330                                   q.pollLast(LONG_DELAY_MS, MILLISECONDS));
# Line 1337 | Line 1343 | public class LinkedBlockingDequeTest ext
1343                      shouldThrow();
1344                  } catch (InterruptedException success) {}
1345                  assertFalse(Thread.interrupted());
1346 +
1347 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1348              }});
1349  
1350          await(pleaseInterrupt);
1351          assertThreadStaysAlive(t);
1352          t.interrupt();
1353          awaitTermination(t);
1354 +        checkEmpty(q);
1355      }
1356  
1357      /**
# Line 1375 | Line 1384 | public class LinkedBlockingDequeTest ext
1384                      shouldThrow();
1385                  } catch (InterruptedException success) {}
1386                  assertFalse(Thread.interrupted());
1387 +
1388 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1389              }});
1390  
1391          barrier.await();

Diff Legend

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