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.83 by jsr166, Mon May 28 21:19:50 2018 UTC vs.
Revision 1.85 by jsr166, Thu Sep 5 20:54:24 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 781 | Line 782 | public class LinkedBlockingDequeTest ext
782  
783                  Thread.currentThread().interrupt();
784                  try {
785 <                    q.poll(LONG_DELAY_MS, MILLISECONDS);
785 >                    q.poll(randomTimeout(), randomTimeUnit());
786                      shouldThrow();
787                  } catch (InterruptedException success) {}
788                  assertFalse(Thread.interrupted());
# Line 797 | Line 798 | public class LinkedBlockingDequeTest ext
798              }});
799  
800          await(pleaseInterrupt);
801 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
801 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
802          t.interrupt();
803          awaitTermination(t);
804          checkEmpty(q);
# Line 856 | Line 857 | public class LinkedBlockingDequeTest ext
857              }});
858  
859          await(pleaseInterrupt);
860 <        assertThreadBlocks(t, Thread.State.WAITING);
860 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
861          t.interrupt();
862          awaitTermination(t);
863          assertEquals(SIZE, q.size());
# Line 891 | Line 892 | public class LinkedBlockingDequeTest ext
892          assertEquals(capacity - 1, q.take());
893  
894          await(pleaseInterrupt);
895 <        assertThreadBlocks(t, Thread.State.WAITING);
895 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
896          t.interrupt();
897          awaitTermination(t);
898          assertEquals(0, q.remainingCapacity());
# Line 908 | Line 909 | public class LinkedBlockingDequeTest ext
909                  q.putFirst(new Object());
910                  q.putFirst(new Object());
911                  long startTime = System.nanoTime();
912 +
913                  assertFalse(q.offerFirst(new Object(), timeoutMillis(), MILLISECONDS));
914                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
915  
916                  Thread.currentThread().interrupt();
917                  try {
918 <                    q.offerFirst(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
918 >                    q.offerFirst(new Object(), randomTimeout(), randomTimeUnit());
919                      shouldThrow();
920                  } catch (InterruptedException success) {}
921                  assertFalse(Thread.interrupted());
922  
923                  pleaseInterrupt.countDown();
924                  try {
925 <                    q.offerFirst(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
925 >                    q.offerFirst(new Object(), LONG_DELAY_MS, MILLISECONDS);
926                      shouldThrow();
927                  } catch (InterruptedException success) {}
928                  assertFalse(Thread.interrupted());
929 +
930 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
931              }});
932  
933          await(pleaseInterrupt);
934 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
934 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
935          t.interrupt();
936          awaitTermination(t);
937      }
# Line 959 | Line 963 | public class LinkedBlockingDequeTest ext
963              }});
964  
965          await(threadStarted);
966 <        assertThreadBlocks(t, Thread.State.WAITING);
966 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
967          t.interrupt();
968          awaitTermination(t);
969      }
# Line 1000 | Line 1004 | public class LinkedBlockingDequeTest ext
1004              }});
1005  
1006          await(threadStarted);
1007 <        assertThreadBlocks(t, Thread.State.WAITING);
1007 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1008          t.interrupt();
1009          awaitTermination(t);
1010      }
# Line 1050 | Line 1054 | public class LinkedBlockingDequeTest ext
1054              }});
1055  
1056          await(pleaseInterrupt);
1057 <        assertThreadBlocks(t, Thread.State.WAITING);
1057 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1058          t.interrupt();
1059          awaitTermination(t);
1060      }
# Line 1097 | Line 1101 | public class LinkedBlockingDequeTest ext
1101  
1102                  Thread.currentThread().interrupt();
1103                  try {
1104 <                    q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1104 >                    q.pollFirst(randomTimeout(), randomTimeUnit());
1105                      shouldThrow();
1106                  } catch (InterruptedException success) {}
1107                  assertFalse(Thread.interrupted());
# Line 1113 | Line 1117 | public class LinkedBlockingDequeTest ext
1117              }});
1118  
1119          await(pleaseInterrupt);
1120 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1120 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1121          t.interrupt();
1122          awaitTermination(t);
1123      }
# Line 1137 | Line 1141 | public class LinkedBlockingDequeTest ext
1141  
1142                  Thread.currentThread().interrupt();
1143                  try {
1144 <                    q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1144 >                    q.pollFirst(randomTimeout(), randomTimeUnit());
1145                      shouldThrow();
1146                  } catch (InterruptedException success) {}
1147  
# Line 1147 | Line 1151 | public class LinkedBlockingDequeTest ext
1151                      shouldThrow();
1152                  } catch (InterruptedException success) {}
1153                  assertFalse(Thread.interrupted());
1154 +
1155                  assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1156              }});
1157  
# Line 1155 | Line 1160 | public class LinkedBlockingDequeTest ext
1160          assertTrue(q.offerFirst(zero, LONG_DELAY_MS, MILLISECONDS));
1161          assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1162          barrier.await();
1163 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1163 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1164          t.interrupt();
1165          awaitTermination(t);
1166      }
# Line 1213 | Line 1218 | public class LinkedBlockingDequeTest ext
1218              }});
1219  
1220          await(pleaseInterrupt);
1221 <        assertThreadBlocks(t, Thread.State.WAITING);
1221 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1222          t.interrupt();
1223          awaitTermination(t);
1224          assertEquals(SIZE, q.size());
# Line 1255 | Line 1260 | public class LinkedBlockingDequeTest ext
1260          assertEquals(0, q.take());
1261  
1262          await(pleaseInterrupt);
1263 <        assertThreadBlocks(t, Thread.State.WAITING);
1263 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1264          t.interrupt();
1265          awaitTermination(t);
1266          assertEquals(0, q.remainingCapacity());
# Line 1272 | Line 1277 | public class LinkedBlockingDequeTest ext
1277                  q.putLast(new Object());
1278                  q.putLast(new Object());
1279                  long startTime = System.nanoTime();
1280 +
1281                  assertFalse(q.offerLast(new Object(), timeoutMillis(), MILLISECONDS));
1282                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
1283  
1284                  Thread.currentThread().interrupt();
1285                  try {
1286 <                    q.offerLast(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
1286 >                    q.offerLast(new Object(), randomTimeout(), randomTimeUnit());
1287                      shouldThrow();
1288                  } catch (InterruptedException success) {}
1289  
1290                  pleaseInterrupt.countDown();
1291                  try {
1292 <                    q.offerLast(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
1292 >                    q.offerLast(new Object(), LONG_DELAY_MS, MILLISECONDS);
1293                      shouldThrow();
1294                  } catch (InterruptedException success) {}
1295 +
1296 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1297              }});
1298  
1299          await(pleaseInterrupt);
1300 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1300 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1301          t.interrupt();
1302          awaitTermination(t);
1303      }
# Line 1331 | Line 1339 | public class LinkedBlockingDequeTest ext
1339              }});
1340  
1341          await(pleaseInterrupt);
1342 <        assertThreadBlocks(t, Thread.State.WAITING);
1342 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1343          t.interrupt();
1344          awaitTermination(t);
1345      }
# Line 1379 | Line 1387 | public class LinkedBlockingDequeTest ext
1387  
1388                  Thread.currentThread().interrupt();
1389                  try {
1390 <                    q.pollLast(LONG_DELAY_MS, MILLISECONDS);
1390 >                    q.pollLast(randomTimeout(), randomTimeUnit());
1391                      shouldThrow();
1392                  } catch (InterruptedException success) {}
1393                  assertFalse(Thread.interrupted());
# Line 1395 | Line 1403 | public class LinkedBlockingDequeTest ext
1403              }});
1404  
1405          await(pleaseInterrupt);
1406 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1406 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1407          t.interrupt();
1408          awaitTermination(t);
1409          checkEmpty(q);
# Line 1420 | Line 1428 | public class LinkedBlockingDequeTest ext
1428  
1429                  Thread.currentThread().interrupt();
1430                  try {
1431 <                    q.poll(LONG_DELAY_MS, MILLISECONDS);
1431 >                    q.poll(randomTimeout(), randomTimeUnit());
1432                      shouldThrow();
1433                  } catch (InterruptedException success) {}
1434                  assertFalse(Thread.interrupted());
# Line 1441 | Line 1449 | public class LinkedBlockingDequeTest ext
1449          assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1450  
1451          barrier.await();
1452 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1452 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1453          t.interrupt();
1454          awaitTermination(t);
1455      }

Diff Legend

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