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.71 by jsr166, Sat May 13 21:52:59 2017 UTC vs.
Revision 1.77 by jsr166, Sun May 14 00:56:43 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 663 | Line 663 | public class LinkedBlockingDequeTest ext
663                      q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
664                      shouldThrow();
665                  } catch (InterruptedException success) {}
666 +                assertFalse(Thread.interrupted());
667              }});
668  
669          await(pleaseInterrupt);
670 <        assertThreadStaysAlive(t);
670 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
671          t.interrupt();
672          awaitTermination(t);
673      }
# Line 756 | Line 757 | public class LinkedBlockingDequeTest ext
757       */
758      public void testInterruptedTimedPoll() throws InterruptedException {
759          final BlockingQueue<Integer> q = populatedDeque(SIZE);
760 <        final CountDownLatch aboutToWait = new CountDownLatch(1);
760 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
761          Thread t = newStartedThread(new CheckedRunnable() {
762              public void realRun() throws InterruptedException {
763                  long startTime = System.nanoTime();
764                  for (int i = 0; i < SIZE; ++i) {
765                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
766                  }
767 <                aboutToWait.countDown();
767 >
768 >                pleaseInterrupt.countDown();
769                  try {
770                      q.poll(LONG_DELAY_MS, MILLISECONDS);
771                      shouldThrow();
772 <                } catch (InterruptedException success) {
773 <                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
774 <                }
772 >                } catch (InterruptedException success) {}
773 >                assertFalse(Thread.interrupted());
774 >
775 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
776              }});
777  
778 <        await(aboutToWait);
779 <        waitForThreadToEnterWaitState(t);
778 >        await(pleaseInterrupt);
779 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
780          t.interrupt();
781          awaitTermination(t);
782          checkEmpty(q);
# Line 832 | Line 835 | public class LinkedBlockingDequeTest ext
835              }});
836  
837          await(pleaseInterrupt);
838 <        assertThreadStaysAlive(t);
838 >        assertThreadBlocks(t, Thread.State.WAITING);
839          t.interrupt();
840          awaitTermination(t);
841          assertEquals(SIZE, q.size());
# Line 867 | Line 870 | public class LinkedBlockingDequeTest ext
870          assertEquals(capacity - 1, q.take());
871  
872          await(pleaseInterrupt);
873 <        assertThreadStaysAlive(t);
873 >        assertThreadBlocks(t, Thread.State.WAITING);
874          t.interrupt();
875          awaitTermination(t);
876          assertEquals(0, q.remainingCapacity());
# Line 891 | Line 894 | public class LinkedBlockingDequeTest ext
894                      q.offerFirst(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
895                      shouldThrow();
896                  } catch (InterruptedException success) {}
897 +                assertFalse(Thread.interrupted());
898              }});
899  
900          await(pleaseInterrupt);
901 <        assertThreadStaysAlive(t);
901 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
902          t.interrupt();
903          awaitTermination(t);
904      }
# Line 1076 | Line 1080 | public class LinkedBlockingDequeTest ext
1080                      shouldThrow();
1081                  } catch (InterruptedException success) {}
1082                  assertFalse(Thread.interrupted());
1083 +
1084                  assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1085              }});
1086  
1087          await(pleaseInterrupt);
1088 <        assertThreadStaysAlive(t);
1088 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1089          t.interrupt();
1090          awaitTermination(t);
1091      }
# Line 1113 | Line 1118 | public class LinkedBlockingDequeTest ext
1118                      q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1119                      shouldThrow();
1120                  } catch (InterruptedException success) {}
1121 +                assertFalse(Thread.interrupted());
1122                  assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1123              }});
1124  
# Line 1121 | Line 1127 | public class LinkedBlockingDequeTest ext
1127          assertTrue(q.offerFirst(zero, LONG_DELAY_MS, MILLISECONDS));
1128          assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1129          barrier.await();
1130 <        assertThreadStaysAlive(t);
1130 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1131          t.interrupt();
1132          awaitTermination(t);
1133      }
# Line 1179 | Line 1185 | public class LinkedBlockingDequeTest ext
1185              }});
1186  
1187          await(pleaseInterrupt);
1188 <        assertThreadStaysAlive(t);
1188 >        assertThreadBlocks(t, Thread.State.WAITING);
1189          t.interrupt();
1190          awaitTermination(t);
1191          assertEquals(SIZE, q.size());
# Line 1214 | Line 1220 | public class LinkedBlockingDequeTest ext
1220          assertEquals(0, q.take());
1221  
1222          await(pleaseInterrupt);
1223 <        assertThreadStaysAlive(t);
1223 >        assertThreadBlocks(t, Thread.State.WAITING);
1224          t.interrupt();
1225          awaitTermination(t);
1226          assertEquals(0, q.remainingCapacity());
# Line 1241 | Line 1247 | public class LinkedBlockingDequeTest ext
1247              }});
1248  
1249          await(pleaseInterrupt);
1250 <        assertThreadStaysAlive(t);
1250 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1251          t.interrupt();
1252          awaitTermination(t);
1253      }
# Line 1348 | Line 1354 | public class LinkedBlockingDequeTest ext
1354              }});
1355  
1356          await(pleaseInterrupt);
1357 <        assertThreadStaysAlive(t);
1357 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1358          t.interrupt();
1359          awaitTermination(t);
1360          checkEmpty(q);
# Line 1394 | Line 1400 | public class LinkedBlockingDequeTest ext
1400          assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1401  
1402          barrier.await();
1403 <        assertThreadStaysAlive(t);
1403 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1404          t.interrupt();
1405          awaitTermination(t);
1406      }

Diff Legend

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