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.70 by jsr166, Sat May 13 21:47:12 2017 UTC vs.
Revision 1.76 by jsr166, Sun May 14 00:48:20 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 639 | 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 666 | 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 756 | 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) {
764                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
765                  }
766 <                aboutToWait.countDown();
766 >
767 >                pleaseInterrupt.countDown();
768                  try {
769                      q.poll(LONG_DELAY_MS, MILLISECONDS);
770                      shouldThrow();
771 <                } catch (InterruptedException success) {
772 <                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
773 <                }
771 >                } catch (InterruptedException success) {}
772 >                assertFalse(Thread.interrupted());
773 >
774 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
775              }});
776  
777 <        await(aboutToWait);
778 <        waitForThreadToEnterWaitState(t);
777 >        await(pleaseInterrupt);
778 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
779          t.interrupt();
780          awaitTermination(t);
781          checkEmpty(q);
# Line 832 | 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 867 | 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 894 | 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 1076 | 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 1121 | 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 1179 | 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 1214 | 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 1241 | 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 1348 | Line 1351 | public class LinkedBlockingDequeTest ext
1351              }});
1352  
1353          await(pleaseInterrupt);
1354 <        assertThreadStaysAlive(t);
1354 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1355          t.interrupt();
1356          awaitTermination(t);
1357          checkEmpty(q);
# Line 1394 | 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      }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines