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.68 by jsr166, Sat Mar 25 21:41:10 2017 UTC vs.
Revision 1.80 by jsr166, Sun May 14 04:14:09 2017 UTC

# Line 604 | 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 626 | Line 626 | public class LinkedBlockingDequeTest ext
626                  pleaseTake.countDown();
627                  q.put(86);
628  
629 +                Thread.currentThread().interrupt();
630 +                try {
631 +                    q.put(99);
632 +                    shouldThrow();
633 +                } catch (InterruptedException success) {}
634 +                assertFalse(Thread.interrupted());
635 +
636                  pleaseInterrupt.countDown();
637                  try {
638                      q.put(99);
# Line 639 | Line 646 | public class LinkedBlockingDequeTest ext
646          assertEquals(0, q.take());
647  
648          await(pleaseInterrupt);
649 <        assertThreadStaysAlive(t);
649 >        assertThreadBlocks(t, Thread.State.WAITING);
650          t.interrupt();
651          awaitTermination(t);
652          assertEquals(0, q.remainingCapacity());
# Line 648 | Line 655 | public class LinkedBlockingDequeTest ext
655      /**
656       * timed offer times out if full and elements not taken
657       */
658 <    public void testTimedOffer() throws InterruptedException {
658 >    public void testTimedOffer() {
659          final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
660          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
661          Thread t = newStartedThread(new CheckedRunnable() {
# Line 658 | Line 665 | public class LinkedBlockingDequeTest ext
665                  long startTime = System.nanoTime();
666                  assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
667                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
668 +
669 +                Thread.currentThread().interrupt();
670 +                try {
671 +                    q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
672 +                    shouldThrow();
673 +                } catch (InterruptedException success) {}
674 +                assertFalse(Thread.interrupted());
675 +
676                  pleaseInterrupt.countDown();
677                  try {
678                      q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
679                      shouldThrow();
680                  } catch (InterruptedException success) {}
681 +                assertFalse(Thread.interrupted());
682              }});
683  
684          await(pleaseInterrupt);
685 <        assertThreadStaysAlive(t);
685 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
686          t.interrupt();
687          awaitTermination(t);
688      }
# Line 689 | Line 705 | public class LinkedBlockingDequeTest ext
705          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
706          Thread t = newStartedThread(new CheckedRunnable() {
707              public void realRun() throws InterruptedException {
708 <                for (int i = 0; i < SIZE; ++i) {
693 <                    assertEquals(i, q.take());
694 <                }
708 >                for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
709  
710                  Thread.currentThread().interrupt();
711                  try {
# Line 709 | Line 723 | public class LinkedBlockingDequeTest ext
723              }});
724  
725          await(pleaseInterrupt);
726 <        assertThreadStaysAlive(t);
726 >        assertThreadBlocks(t, Thread.State.WAITING);
727          t.interrupt();
728          awaitTermination(t);
729      }
# Line 758 | Line 772 | public class LinkedBlockingDequeTest ext
772       */
773      public void testInterruptedTimedPoll() throws InterruptedException {
774          final BlockingQueue<Integer> q = populatedDeque(SIZE);
775 <        final CountDownLatch aboutToWait = new CountDownLatch(1);
775 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
776          Thread t = newStartedThread(new CheckedRunnable() {
777              public void realRun() throws InterruptedException {
778                  long startTime = System.nanoTime();
779 <                for (int i = 0; i < SIZE; ++i) {
779 >                for (int i = 0; i < SIZE; i++)
780                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
781 <                }
782 <                aboutToWait.countDown();
781 >
782 >                Thread.currentThread().interrupt();
783 >                try {
784 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
785 >                    shouldThrow();
786 >                } catch (InterruptedException success) {}
787 >                assertFalse(Thread.interrupted());
788 >
789 >                pleaseInterrupt.countDown();
790                  try {
791                      q.poll(LONG_DELAY_MS, MILLISECONDS);
792                      shouldThrow();
793 <                } catch (InterruptedException success) {
794 <                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
795 <                }
793 >                } catch (InterruptedException success) {}
794 >                assertFalse(Thread.interrupted());
795 >
796 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
797              }});
798  
799 <        await(aboutToWait);
800 <        waitForThreadToEnterWaitState(t);
799 >        await(pleaseInterrupt);
800 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
801          t.interrupt();
802          awaitTermination(t);
803          checkEmpty(q);
# Line 834 | Line 856 | public class LinkedBlockingDequeTest ext
856              }});
857  
858          await(pleaseInterrupt);
859 <        assertThreadStaysAlive(t);
859 >        assertThreadBlocks(t, Thread.State.WAITING);
860          t.interrupt();
861          awaitTermination(t);
862          assertEquals(SIZE, q.size());
# Line 869 | Line 891 | public class LinkedBlockingDequeTest ext
891          assertEquals(capacity - 1, q.take());
892  
893          await(pleaseInterrupt);
894 <        assertThreadStaysAlive(t);
894 >        assertThreadBlocks(t, Thread.State.WAITING);
895          t.interrupt();
896          awaitTermination(t);
897          assertEquals(0, q.remainingCapacity());
# Line 878 | Line 900 | public class LinkedBlockingDequeTest ext
900      /**
901       * timed offerFirst times out if full and elements not taken
902       */
903 <    public void testTimedOfferFirst() throws InterruptedException {
903 >    public void testTimedOfferFirst() {
904          final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
905          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
906          Thread t = newStartedThread(new CheckedRunnable() {
# Line 888 | Line 910 | public class LinkedBlockingDequeTest ext
910                  long startTime = System.nanoTime();
911                  assertFalse(q.offerFirst(new Object(), timeoutMillis(), MILLISECONDS));
912                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
913 +
914 +                Thread.currentThread().interrupt();
915 +                try {
916 +                    q.offerFirst(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
917 +                    shouldThrow();
918 +                } catch (InterruptedException success) {}
919 +                assertFalse(Thread.interrupted());
920 +
921                  pleaseInterrupt.countDown();
922                  try {
923                      q.offerFirst(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
924                      shouldThrow();
925                  } catch (InterruptedException success) {}
926 +                assertFalse(Thread.interrupted());
927              }});
928  
929          await(pleaseInterrupt);
930 <        assertThreadStaysAlive(t);
930 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
931          t.interrupt();
932          awaitTermination(t);
933      }
# Line 928 | Line 959 | public class LinkedBlockingDequeTest ext
959              }});
960  
961          await(threadStarted);
962 <        assertThreadStaysAlive(t);
962 >        assertThreadBlocks(t, Thread.State.WAITING);
963          t.interrupt();
964          awaitTermination(t);
965      }
# Line 969 | Line 1000 | public class LinkedBlockingDequeTest ext
1000              }});
1001  
1002          await(threadStarted);
1003 <        assertThreadStaysAlive(t);
1003 >        assertThreadBlocks(t, Thread.State.WAITING);
1004          t.interrupt();
1005          awaitTermination(t);
1006      }
# Line 1001 | Line 1032 | public class LinkedBlockingDequeTest ext
1032          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1033          Thread t = newStartedThread(new CheckedRunnable() {
1034              public void realRun() throws InterruptedException {
1035 <                for (int i = 0; i < SIZE; ++i) {
1005 <                    assertEquals(i, q.takeFirst());
1006 <                }
1035 >                for (int i = 0; i < SIZE; i++) assertEquals(i, q.takeFirst());
1036  
1037                  Thread.currentThread().interrupt();
1038                  try {
# Line 1021 | Line 1050 | public class LinkedBlockingDequeTest ext
1050              }});
1051  
1052          await(pleaseInterrupt);
1053 <        assertThreadStaysAlive(t);
1053 >        assertThreadBlocks(t, Thread.State.WAITING);
1054          t.interrupt();
1055          awaitTermination(t);
1056      }
# Line 1063 | Line 1092 | public class LinkedBlockingDequeTest ext
1092          Thread t = newStartedThread(new CheckedRunnable() {
1093              public void realRun() throws InterruptedException {
1094                  long startTime = System.nanoTime();
1095 <                for (int i = 0; i < SIZE; ++i) {
1095 >                for (int i = 0; i < SIZE; i++)
1096                      assertEquals(i, q.pollFirst(LONG_DELAY_MS, MILLISECONDS));
1068 –                }
1097  
1098                  Thread.currentThread().interrupt();
1099                  try {
# Line 1080 | Line 1108 | public class LinkedBlockingDequeTest ext
1108                      shouldThrow();
1109                  } catch (InterruptedException success) {}
1110                  assertFalse(Thread.interrupted());
1111 +
1112                  assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1113              }});
1114  
1115          await(pleaseInterrupt);
1116 <        assertThreadStaysAlive(t);
1116 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1117          t.interrupt();
1118          awaitTermination(t);
1119      }
# Line 1117 | Line 1146 | public class LinkedBlockingDequeTest ext
1146                      q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1147                      shouldThrow();
1148                  } catch (InterruptedException success) {}
1149 +                assertFalse(Thread.interrupted());
1150                  assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1151              }});
1152  
# Line 1125 | Line 1155 | public class LinkedBlockingDequeTest ext
1155          assertTrue(q.offerFirst(zero, LONG_DELAY_MS, MILLISECONDS));
1156          assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1157          barrier.await();
1158 <        assertThreadStaysAlive(t);
1158 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1159          t.interrupt();
1160          awaitTermination(t);
1161      }
# Line 1183 | Line 1213 | public class LinkedBlockingDequeTest ext
1213              }});
1214  
1215          await(pleaseInterrupt);
1216 <        assertThreadStaysAlive(t);
1216 >        assertThreadBlocks(t, Thread.State.WAITING);
1217          t.interrupt();
1218          awaitTermination(t);
1219          assertEquals(SIZE, q.size());
# Line 1205 | Line 1235 | public class LinkedBlockingDequeTest ext
1235                  pleaseTake.countDown();
1236                  q.putLast(86);
1237  
1238 +                Thread.currentThread().interrupt();
1239 +                try {
1240 +                    q.putLast(99);
1241 +                    shouldThrow();
1242 +                } catch (InterruptedException success) {}
1243 +                assertFalse(Thread.interrupted());
1244 +
1245                  pleaseInterrupt.countDown();
1246                  try {
1247                      q.putLast(99);
# Line 1218 | Line 1255 | public class LinkedBlockingDequeTest ext
1255          assertEquals(0, q.take());
1256  
1257          await(pleaseInterrupt);
1258 <        assertThreadStaysAlive(t);
1258 >        assertThreadBlocks(t, Thread.State.WAITING);
1259          t.interrupt();
1260          awaitTermination(t);
1261          assertEquals(0, q.remainingCapacity());
# Line 1227 | Line 1264 | public class LinkedBlockingDequeTest ext
1264      /**
1265       * timed offerLast times out if full and elements not taken
1266       */
1267 <    public void testTimedOfferLast() throws InterruptedException {
1267 >    public void testTimedOfferLast() {
1268          final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
1269          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1270          Thread t = newStartedThread(new CheckedRunnable() {
# Line 1237 | Line 1274 | public class LinkedBlockingDequeTest ext
1274                  long startTime = System.nanoTime();
1275                  assertFalse(q.offerLast(new Object(), timeoutMillis(), MILLISECONDS));
1276                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
1277 +
1278 +                Thread.currentThread().interrupt();
1279 +                try {
1280 +                    q.offerLast(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
1281 +                    shouldThrow();
1282 +                } catch (InterruptedException success) {}
1283 +
1284                  pleaseInterrupt.countDown();
1285                  try {
1286                      q.offerLast(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
# Line 1245 | Line 1289 | public class LinkedBlockingDequeTest ext
1289              }});
1290  
1291          await(pleaseInterrupt);
1292 <        assertThreadStaysAlive(t);
1292 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1293          t.interrupt();
1294          awaitTermination(t);
1295      }
# Line 1268 | Line 1312 | public class LinkedBlockingDequeTest ext
1312          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1313          Thread t = newStartedThread(new CheckedRunnable() {
1314              public void realRun() throws InterruptedException {
1315 <                for (int i = 0; i < SIZE; ++i) {
1315 >                for (int i = 0; i < SIZE; i++)
1316                      assertEquals(SIZE - i - 1, q.takeLast());
1273 –                }
1317  
1318                  Thread.currentThread().interrupt();
1319                  try {
# Line 1288 | Line 1331 | public class LinkedBlockingDequeTest ext
1331              }});
1332  
1333          await(pleaseInterrupt);
1334 <        assertThreadStaysAlive(t);
1334 >        assertThreadBlocks(t, Thread.State.WAITING);
1335          t.interrupt();
1336          awaitTermination(t);
1337      }
# Line 1330 | Line 1373 | public class LinkedBlockingDequeTest ext
1373          Thread t = newStartedThread(new CheckedRunnable() {
1374              public void realRun() throws InterruptedException {
1375                  long startTime = System.nanoTime();
1376 <                for (int i = 0; i < SIZE; ++i) {
1376 >                for (int i = 0; i < SIZE; i++)
1377                      assertEquals(SIZE - i - 1,
1378                                   q.pollLast(LONG_DELAY_MS, MILLISECONDS));
1336 –                }
1379  
1380                  Thread.currentThread().interrupt();
1381                  try {
# Line 1353 | Line 1395 | public class LinkedBlockingDequeTest ext
1395              }});
1396  
1397          await(pleaseInterrupt);
1398 <        assertThreadStaysAlive(t);
1398 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1399          t.interrupt();
1400          awaitTermination(t);
1401          checkEmpty(q);
# Line 1399 | Line 1441 | public class LinkedBlockingDequeTest ext
1441          assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1442  
1443          barrier.await();
1444 <        assertThreadStaysAlive(t);
1444 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1445          t.interrupt();
1446          awaitTermination(t);
1447      }

Diff Legend

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