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.82 by jsr166, Fri Aug 4 03:30:21 2017 UTC vs.
Revision 1.87 by jsr166, Thu Sep 5 21:39:57 2019 UTC

# Line 604 | Line 604 | public class LinkedBlockingDequeTest ext
604              }});
605  
606          await(pleaseInterrupt);
607 <        assertThreadBlocks(t, Thread.State.WAITING);
607 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
608          t.interrupt();
609          awaitTermination(t);
610          assertEquals(SIZE, q.size());
# Line 646 | Line 646 | public class LinkedBlockingDequeTest ext
646          assertEquals(0, q.take());
647  
648          await(pleaseInterrupt);
649 <        assertThreadBlocks(t, Thread.State.WAITING);
649 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
650          t.interrupt();
651          awaitTermination(t);
652          assertEquals(0, q.remainingCapacity());
# Line 663 | Line 663 | public class LinkedBlockingDequeTest ext
663                  q.put(new Object());
664                  q.put(new Object());
665                  long startTime = System.nanoTime();
666 +
667                  assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
668                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
669  
670                  Thread.currentThread().interrupt();
671                  try {
672 <                    q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
672 >                    q.offer(new Object(), randomTimeout(), randomTimeUnit());
673                      shouldThrow();
674                  } catch (InterruptedException success) {}
675                  assertFalse(Thread.interrupted());
676  
677                  pleaseInterrupt.countDown();
678                  try {
679 <                    q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
679 >                    q.offer(new Object(), LONGER_DELAY_MS, MILLISECONDS);
680                      shouldThrow();
681                  } catch (InterruptedException success) {}
682                  assertFalse(Thread.interrupted());
683              }});
684  
685          await(pleaseInterrupt);
686 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
686 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
687          t.interrupt();
688          awaitTermination(t);
689      }
# Line 723 | Line 724 | public class LinkedBlockingDequeTest ext
724              }});
725  
726          await(pleaseInterrupt);
727 <        assertThreadBlocks(t, Thread.State.WAITING);
727 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
728          t.interrupt();
729          awaitTermination(t);
730      }
# Line 775 | Line 776 | public class LinkedBlockingDequeTest ext
776          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
777          Thread t = newStartedThread(new CheckedRunnable() {
778              public void realRun() throws InterruptedException {
778 –                long startTime = System.nanoTime();
779                  for (int i = 0; i < SIZE; i++)
780                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
781  
782                  Thread.currentThread().interrupt();
783                  try {
784 <                    q.poll(LONG_DELAY_MS, MILLISECONDS);
784 >                    q.poll(randomTimeout(), randomTimeUnit());
785                      shouldThrow();
786                  } catch (InterruptedException success) {}
787                  assertFalse(Thread.interrupted());
788  
789                  pleaseInterrupt.countDown();
790                  try {
791 <                    q.poll(LONG_DELAY_MS, MILLISECONDS);
791 >                    q.poll(LONGER_DELAY_MS, MILLISECONDS);
792                      shouldThrow();
793                  } catch (InterruptedException success) {}
794                  assertFalse(Thread.interrupted());
795 –
796 –                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
795              }});
796  
797          await(pleaseInterrupt);
798 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
798 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
799          t.interrupt();
800          awaitTermination(t);
801          checkEmpty(q);
# Line 856 | Line 854 | public class LinkedBlockingDequeTest ext
854              }});
855  
856          await(pleaseInterrupt);
857 <        assertThreadBlocks(t, Thread.State.WAITING);
857 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
858          t.interrupt();
859          awaitTermination(t);
860          assertEquals(SIZE, q.size());
# Line 891 | Line 889 | public class LinkedBlockingDequeTest ext
889          assertEquals(capacity - 1, q.take());
890  
891          await(pleaseInterrupt);
892 <        assertThreadBlocks(t, Thread.State.WAITING);
892 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
893          t.interrupt();
894          awaitTermination(t);
895          assertEquals(0, q.remainingCapacity());
# Line 908 | Line 906 | public class LinkedBlockingDequeTest ext
906                  q.putFirst(new Object());
907                  q.putFirst(new Object());
908                  long startTime = System.nanoTime();
909 +
910                  assertFalse(q.offerFirst(new Object(), timeoutMillis(), MILLISECONDS));
911                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
912  
913                  Thread.currentThread().interrupt();
914                  try {
915 <                    q.offerFirst(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
915 >                    q.offerFirst(new Object(), randomTimeout(), randomTimeUnit());
916                      shouldThrow();
917                  } catch (InterruptedException success) {}
918                  assertFalse(Thread.interrupted());
919  
920                  pleaseInterrupt.countDown();
921                  try {
922 <                    q.offerFirst(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
922 >                    q.offerFirst(new Object(), LONGER_DELAY_MS, MILLISECONDS);
923                      shouldThrow();
924                  } catch (InterruptedException success) {}
925                  assertFalse(Thread.interrupted());
926              }});
927  
928          await(pleaseInterrupt);
929 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
929 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
930          t.interrupt();
931          awaitTermination(t);
932      }
# Line 959 | Line 958 | public class LinkedBlockingDequeTest ext
958              }});
959  
960          await(threadStarted);
961 <        assertThreadBlocks(t, Thread.State.WAITING);
961 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
962          t.interrupt();
963          awaitTermination(t);
964      }
# Line 1000 | Line 999 | public class LinkedBlockingDequeTest ext
999              }});
1000  
1001          await(threadStarted);
1002 <        assertThreadBlocks(t, Thread.State.WAITING);
1002 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1003          t.interrupt();
1004          awaitTermination(t);
1005      }
# Line 1050 | Line 1049 | public class LinkedBlockingDequeTest ext
1049              }});
1050  
1051          await(pleaseInterrupt);
1052 <        assertThreadBlocks(t, Thread.State.WAITING);
1052 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1053          t.interrupt();
1054          awaitTermination(t);
1055      }
# Line 1091 | Line 1090 | public class LinkedBlockingDequeTest ext
1090          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1091          Thread t = newStartedThread(new CheckedRunnable() {
1092              public void realRun() throws InterruptedException {
1094 –                long startTime = System.nanoTime();
1093                  for (int i = 0; i < SIZE; i++)
1094                      assertEquals(i, q.pollFirst(LONG_DELAY_MS, MILLISECONDS));
1095  
1096                  Thread.currentThread().interrupt();
1097                  try {
1098 <                    q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1098 >                    q.pollFirst(randomTimeout(), randomTimeUnit());
1099                      shouldThrow();
1100                  } catch (InterruptedException success) {}
1101                  assertFalse(Thread.interrupted());
1102  
1103                  pleaseInterrupt.countDown();
1104                  try {
1105 <                    q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1105 >                    q.pollFirst(LONGER_DELAY_MS, MILLISECONDS);
1106                      shouldThrow();
1107                  } catch (InterruptedException success) {}
1108                  assertFalse(Thread.interrupted());
1111 –
1112 –                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1109              }});
1110  
1111          await(pleaseInterrupt);
1112 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1112 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1113          t.interrupt();
1114          awaitTermination(t);
1115      }
# Line 1137 | Line 1133 | public class LinkedBlockingDequeTest ext
1133  
1134                  Thread.currentThread().interrupt();
1135                  try {
1136 <                    q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1136 >                    q.pollFirst(randomTimeout(), randomTimeUnit());
1137                      shouldThrow();
1138                  } catch (InterruptedException success) {}
1139  
# Line 1147 | Line 1143 | public class LinkedBlockingDequeTest ext
1143                      shouldThrow();
1144                  } catch (InterruptedException success) {}
1145                  assertFalse(Thread.interrupted());
1146 +
1147                  assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1148              }});
1149  
# Line 1155 | Line 1152 | public class LinkedBlockingDequeTest ext
1152          assertTrue(q.offerFirst(zero, LONG_DELAY_MS, MILLISECONDS));
1153          assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1154          barrier.await();
1155 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1155 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1156          t.interrupt();
1157          awaitTermination(t);
1158      }
# Line 1213 | Line 1210 | public class LinkedBlockingDequeTest ext
1210              }});
1211  
1212          await(pleaseInterrupt);
1213 <        assertThreadBlocks(t, Thread.State.WAITING);
1213 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1214          t.interrupt();
1215          awaitTermination(t);
1216          assertEquals(SIZE, q.size());
# Line 1255 | Line 1252 | public class LinkedBlockingDequeTest ext
1252          assertEquals(0, q.take());
1253  
1254          await(pleaseInterrupt);
1255 <        assertThreadBlocks(t, Thread.State.WAITING);
1255 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1256          t.interrupt();
1257          awaitTermination(t);
1258          assertEquals(0, q.remainingCapacity());
# Line 1272 | Line 1269 | public class LinkedBlockingDequeTest ext
1269                  q.putLast(new Object());
1270                  q.putLast(new Object());
1271                  long startTime = System.nanoTime();
1272 +
1273                  assertFalse(q.offerLast(new Object(), timeoutMillis(), MILLISECONDS));
1274                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
1275  
1276                  Thread.currentThread().interrupt();
1277                  try {
1278 <                    q.offerLast(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
1278 >                    q.offerLast(new Object(), randomTimeout(), randomTimeUnit());
1279                      shouldThrow();
1280                  } catch (InterruptedException success) {}
1281  
1282                  pleaseInterrupt.countDown();
1283                  try {
1284 <                    q.offerLast(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
1284 >                    q.offerLast(new Object(), LONGER_DELAY_MS, MILLISECONDS);
1285                      shouldThrow();
1286                  } catch (InterruptedException success) {}
1287              }});
1288  
1289          await(pleaseInterrupt);
1290 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1290 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1291          t.interrupt();
1292          awaitTermination(t);
1293      }
# Line 1331 | Line 1329 | public class LinkedBlockingDequeTest ext
1329              }});
1330  
1331          await(pleaseInterrupt);
1332 <        assertThreadBlocks(t, Thread.State.WAITING);
1332 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1333          t.interrupt();
1334          awaitTermination(t);
1335      }
# Line 1372 | Line 1370 | public class LinkedBlockingDequeTest ext
1370          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1371          Thread t = newStartedThread(new CheckedRunnable() {
1372              public void realRun() throws InterruptedException {
1375 –                long startTime = System.nanoTime();
1373                  for (int i = 0; i < SIZE; i++)
1374                      assertEquals(SIZE - i - 1,
1375                                   q.pollLast(LONG_DELAY_MS, MILLISECONDS));
1376  
1377                  Thread.currentThread().interrupt();
1378                  try {
1379 <                    q.pollLast(LONG_DELAY_MS, MILLISECONDS);
1379 >                    q.pollLast(randomTimeout(), randomTimeUnit());
1380                      shouldThrow();
1381                  } catch (InterruptedException success) {}
1382                  assertFalse(Thread.interrupted());
1383  
1384                  pleaseInterrupt.countDown();
1385                  try {
1386 <                    q.pollLast(LONG_DELAY_MS, MILLISECONDS);
1386 >                    q.pollLast(LONGER_DELAY_MS, MILLISECONDS);
1387                      shouldThrow();
1388                  } catch (InterruptedException success) {}
1389                  assertFalse(Thread.interrupted());
1393 –
1394 –                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1390              }});
1391  
1392          await(pleaseInterrupt);
1393 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1393 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1394          t.interrupt();
1395          awaitTermination(t);
1396          checkEmpty(q);
# Line 1420 | Line 1415 | public class LinkedBlockingDequeTest ext
1415  
1416                  Thread.currentThread().interrupt();
1417                  try {
1418 <                    q.poll(LONG_DELAY_MS, MILLISECONDS);
1418 >                    q.poll(randomTimeout(), randomTimeUnit());
1419                      shouldThrow();
1420                  } catch (InterruptedException success) {}
1421                  assertFalse(Thread.interrupted());
# Line 1441 | Line 1436 | public class LinkedBlockingDequeTest ext
1436          assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1437  
1438          barrier.await();
1439 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1439 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1440          t.interrupt();
1441          awaitTermination(t);
1442      }
# Line 1543 | Line 1538 | public class LinkedBlockingDequeTest ext
1538       */
1539      public void testToArray() throws InterruptedException {
1540          LinkedBlockingDeque q = populatedDeque(SIZE);
1541 <        Object[] o = q.toArray();
1542 <        for (int i = 0; i < o.length; i++)
1543 <            assertSame(o[i], q.poll());
1541 >        Object[] a = q.toArray();
1542 >        assertSame(Object[].class, a.getClass());
1543 >        for (Object o : a)
1544 >            assertSame(o, q.poll());
1545 >        assertTrue(q.isEmpty());
1546      }
1547  
1548      /**
# Line 1556 | Line 1553 | public class LinkedBlockingDequeTest ext
1553          Integer[] ints = new Integer[SIZE];
1554          Integer[] array = q.toArray(ints);
1555          assertSame(ints, array);
1556 <        for (int i = 0; i < ints.length; i++)
1557 <            assertSame(ints[i], q.remove());
1556 >        for (Integer o : ints)
1557 >            assertSame(o, q.remove());
1558 >        assertTrue(q.isEmpty());
1559      }
1560  
1561      /**

Diff Legend

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