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.79 by jsr166, Sun May 14 04:02:06 2017 UTC vs.
Revision 1.85 by jsr166, Thu Sep 5 20:54:24 2019 UTC

# Line 442 | Line 442 | public class LinkedBlockingDequeTest ext
442      }
443  
444      /**
445 <     * push succeeds if not full; throws ISE if full
445 >     * push succeeds if not full; throws IllegalStateException if full
446       */
447      public void testPush() {
448          LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
# Line 492 | Line 492 | public class LinkedBlockingDequeTest ext
492      }
493  
494      /**
495 <     * add succeeds if not full; throws ISE if full
495 >     * add succeeds if not full; throws IllegalStateException if full
496       */
497      public void testAdd() {
498          LinkedBlockingDeque q = new LinkedBlockingDeque(SIZE);
# Line 506 | Line 506 | public class LinkedBlockingDequeTest ext
506      }
507  
508      /**
509 <     * addAll(this) throws IAE
509 >     * addAll(this) throws IllegalArgumentException
510       */
511      public void testAddAllSelf() {
512          LinkedBlockingDeque q = populatedDeque(SIZE);
# 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 655 | 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 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(), 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 715 | 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 773 | 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 789 | 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 848 | 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 883 | 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 892 | Line 901 | public class LinkedBlockingDequeTest ext
901      /**
902       * timed offerFirst times out if full and elements not taken
903       */
904 <    public void testTimedOfferFirst() throws InterruptedException {
904 >    public void testTimedOfferFirst() {
905          final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
906          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
907          Thread t = newStartedThread(new CheckedRunnable() {
# Line 900 | 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(), 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 943 | 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 984 | 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 1034 | 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 1081 | 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 1097 | 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 1121 | 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 1131 | 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 1139 | 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 1197 | 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 1219 | Line 1240 | public class LinkedBlockingDequeTest ext
1240                  pleaseTake.countDown();
1241                  q.putLast(86);
1242  
1243 +                Thread.currentThread().interrupt();
1244 +                try {
1245 +                    q.putLast(99);
1246 +                    shouldThrow();
1247 +                } catch (InterruptedException success) {}
1248 +                assertFalse(Thread.interrupted());
1249 +
1250                  pleaseInterrupt.countDown();
1251                  try {
1252                      q.putLast(99);
# Line 1232 | 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 1241 | Line 1269 | public class LinkedBlockingDequeTest ext
1269      /**
1270       * timed offerLast times out if full and elements not taken
1271       */
1272 <    public void testTimedOfferLast() throws InterruptedException {
1272 >    public void testTimedOfferLast() {
1273          final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
1274          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1275          Thread t = newStartedThread(new CheckedRunnable() {
# Line 1249 | 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(), 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 1301 | 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 1349 | 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 1365 | 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 1390 | 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 1411 | 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      }
# Line 1513 | Line 1551 | public class LinkedBlockingDequeTest ext
1551       */
1552      public void testToArray() throws InterruptedException {
1553          LinkedBlockingDeque q = populatedDeque(SIZE);
1554 <        Object[] o = q.toArray();
1555 <        for (int i = 0; i < o.length; i++)
1556 <            assertSame(o[i], q.poll());
1554 >        Object[] a = q.toArray();
1555 >        assertSame(Object[].class, a.getClass());
1556 >        for (Object o : a)
1557 >            assertSame(o, q.poll());
1558 >        assertTrue(q.isEmpty());
1559      }
1560  
1561      /**
# Line 1526 | Line 1566 | public class LinkedBlockingDequeTest ext
1566          Integer[] ints = new Integer[SIZE];
1567          Integer[] array = q.toArray(ints);
1568          assertSame(ints, array);
1569 <        for (int i = 0; i < ints.length; i++)
1570 <            assertSame(ints[i], q.remove());
1569 >        for (Integer o : ints)
1570 >            assertSame(o, q.remove());
1571 >        assertTrue(q.isEmpty());
1572      }
1573  
1574      /**
# Line 1743 | Line 1784 | public class LinkedBlockingDequeTest ext
1784      }
1785  
1786      /**
1787 <     * A deserialized serialized deque has same elements in same order
1787 >     * A deserialized/reserialized deque has same elements in same order
1788       */
1789      public void testSerialization() throws Exception {
1790          Queue x = populatedDeque(SIZE);

Diff Legend

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