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.72 by jsr166, Sat May 13 22:17:12 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 626 | Line 626 | public class LinkedBlockingDequeTest ext
626                  pleaseTake.countDown();
627                  q.put(86);
628  
629 +                Thread.currentThread().interrupt();
630 +                try {
631 +                    q.put(99);
632 +                    shouldThrow();
633 +                } catch (InterruptedException success) {}
634 +                assertFalse(Thread.interrupted());
635 +
636                  pleaseInterrupt.countDown();
637                  try {
638                      q.put(99);
# Line 639 | 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 648 | 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 656 | 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 707 | 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 756 | Line 773 | public class LinkedBlockingDequeTest ext
773       */
774      public void testInterruptedTimedPoll() throws InterruptedException {
775          final BlockingQueue<Integer> q = populatedDeque(SIZE);
776 <        final CountDownLatch aboutToWait = new CountDownLatch(1);
776 >        final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
777          Thread t = newStartedThread(new CheckedRunnable() {
778              public void realRun() throws InterruptedException {
779                  long startTime = System.nanoTime();
780 <                for (int i = 0; i < SIZE; ++i) {
780 >                for (int i = 0; i < SIZE; i++)
781                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
782 <                }
783 <                aboutToWait.countDown();
782 >
783 >                Thread.currentThread().interrupt();
784 >                try {
785 >                    q.poll(randomTimeout(), randomTimeUnit());
786 >                    shouldThrow();
787 >                } catch (InterruptedException success) {}
788 >                assertFalse(Thread.interrupted());
789 >
790 >                pleaseInterrupt.countDown();
791                  try {
792                      q.poll(LONG_DELAY_MS, MILLISECONDS);
793                      shouldThrow();
794 <                } catch (InterruptedException success) {
795 <                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
796 <                }
794 >                } catch (InterruptedException success) {}
795 >                assertFalse(Thread.interrupted());
796 >
797 >                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
798              }});
799  
800 <        await(aboutToWait);
801 <        waitForThreadToEnterWaitState(t);
800 >        await(pleaseInterrupt);
801 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
802          t.interrupt();
803          awaitTermination(t);
804          checkEmpty(q);
# Line 832 | 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 867 | 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 876 | 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 884 | 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 926 | 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 967 | 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 1017 | 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 1059 | Line 1096 | public class LinkedBlockingDequeTest ext
1096          Thread t = newStartedThread(new CheckedRunnable() {
1097              public void realRun() throws InterruptedException {
1098                  long startTime = System.nanoTime();
1099 <                for (int i = 0; i < SIZE; ++i) {
1099 >                for (int i = 0; i < SIZE; i++)
1100                      assertEquals(i, q.pollFirst(LONG_DELAY_MS, MILLISECONDS));
1064 –                }
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 1076 | Line 1112 | public class LinkedBlockingDequeTest ext
1112                      shouldThrow();
1113                  } catch (InterruptedException success) {}
1114                  assertFalse(Thread.interrupted());
1115 +
1116                  assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1117              }});
1118  
1119          await(pleaseInterrupt);
1120 <        assertThreadStaysAlive(t);
1120 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1121          t.interrupt();
1122          awaitTermination(t);
1123      }
# Line 1104 | 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 1113 | Line 1150 | public class LinkedBlockingDequeTest ext
1150                      q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1151                      shouldThrow();
1152                  } catch (InterruptedException success) {}
1153 +                assertFalse(Thread.interrupted());
1154 +
1155                  assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1156              }});
1157  
# Line 1121 | 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 <        assertThreadStaysAlive(t);
1163 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1164          t.interrupt();
1165          awaitTermination(t);
1166      }
# Line 1179 | 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 1201 | 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 1214 | 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 1223 | 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 1231 | 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 1283 | 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 1325 | Line 1381 | public class LinkedBlockingDequeTest ext
1381          Thread t = newStartedThread(new CheckedRunnable() {
1382              public void realRun() throws InterruptedException {
1383                  long startTime = System.nanoTime();
1384 <                for (int i = 0; i < SIZE; ++i) {
1384 >                for (int i = 0; i < SIZE; i++)
1385                      assertEquals(SIZE - i - 1,
1386                                   q.pollLast(LONG_DELAY_MS, MILLISECONDS));
1331 –                }
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 1348 | Line 1403 | public class LinkedBlockingDequeTest ext
1403              }});
1404  
1405          await(pleaseInterrupt);
1406 <        assertThreadStaysAlive(t);
1406 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1407          t.interrupt();
1408          awaitTermination(t);
1409          checkEmpty(q);
# Line 1373 | 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 1394 | Line 1449 | public class LinkedBlockingDequeTest ext
1449          assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1450  
1451          barrier.await();
1452 <        assertThreadStaysAlive(t);
1452 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1453          t.interrupt();
1454          awaitTermination(t);
1455      }
# Line 1496 | 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 1509 | 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 1726 | 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