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.76 by jsr166, Sun May 14 00:48:20 2017 UTC vs.
Revision 1.86 by jsr166, Thu Sep 5 21:11:13 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 759 | 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 {
779 <                long startTime = System.nanoTime();
763 <                for (int i = 0; i < SIZE; ++i) {
779 >                for (int i = 0; i < SIZE; i++)
780                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
765 –                }
781  
782 <                pleaseInterrupt.countDown();
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 <                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
789 >                pleaseInterrupt.countDown();
790 >                try {
791 >                    q.poll(LONGER_DELAY_MS, MILLISECONDS);
792 >                    shouldThrow();
793 >                } catch (InterruptedException success) {}
794 >                assertFalse(Thread.interrupted());
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 834 | 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 869 | 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 878 | Line 898 | public class LinkedBlockingDequeTest ext
898      /**
899       * timed offerFirst times out if full and elements not taken
900       */
901 <    public void testTimedOfferFirst() throws InterruptedException {
901 >    public void testTimedOfferFirst() {
902          final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
903          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
904          Thread t = newStartedThread(new CheckedRunnable() {
# Line 886 | 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(), 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(), LONG_DELAY_MS, MILLISECONDS);
923                      shouldThrow();
924                  } catch (InterruptedException success) {}
925 +                assertFalse(Thread.interrupted());
926 +
927 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
928              }});
929  
930          await(pleaseInterrupt);
931 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
931 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
932          t.interrupt();
933          awaitTermination(t);
934      }
# Line 928 | Line 960 | public class LinkedBlockingDequeTest ext
960              }});
961  
962          await(threadStarted);
963 <        assertThreadBlocks(t, Thread.State.WAITING);
963 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
964          t.interrupt();
965          awaitTermination(t);
966      }
# Line 969 | Line 1001 | public class LinkedBlockingDequeTest ext
1001              }});
1002  
1003          await(threadStarted);
1004 <        assertThreadBlocks(t, Thread.State.WAITING);
1004 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1005          t.interrupt();
1006          awaitTermination(t);
1007      }
# Line 1019 | Line 1051 | public class LinkedBlockingDequeTest ext
1051              }});
1052  
1053          await(pleaseInterrupt);
1054 <        assertThreadBlocks(t, Thread.State.WAITING);
1054 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1055          t.interrupt();
1056          awaitTermination(t);
1057      }
# Line 1060 | Line 1092 | public class LinkedBlockingDequeTest ext
1092          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1093          Thread t = newStartedThread(new CheckedRunnable() {
1094              public void realRun() throws InterruptedException {
1095 <                long startTime = System.nanoTime();
1064 <                for (int i = 0; i < SIZE; ++i) {
1095 >                for (int i = 0; i < SIZE; i++)
1096                      assertEquals(i, q.pollFirst(LONG_DELAY_MS, MILLISECONDS));
1066 –                }
1097  
1098                  Thread.currentThread().interrupt();
1099                  try {
1100 <                    q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1100 >                    q.pollFirst(randomTimeout(), randomTimeUnit());
1101                      shouldThrow();
1102                  } catch (InterruptedException success) {}
1103                  assertFalse(Thread.interrupted());
1104  
1105                  pleaseInterrupt.countDown();
1106                  try {
1107 <                    q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1107 >                    q.pollFirst(LONGER_DELAY_MS, MILLISECONDS);
1108                      shouldThrow();
1109                  } catch (InterruptedException success) {}
1110                  assertFalse(Thread.interrupted());
1081 –
1082 –                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1111              }});
1112  
1113          await(pleaseInterrupt);
1114 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1114 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1115          t.interrupt();
1116          awaitTermination(t);
1117      }
# Line 1107 | Line 1135 | public class LinkedBlockingDequeTest ext
1135  
1136                  Thread.currentThread().interrupt();
1137                  try {
1138 <                    q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1138 >                    q.pollFirst(randomTimeout(), randomTimeUnit());
1139                      shouldThrow();
1140                  } catch (InterruptedException success) {}
1141  
# Line 1116 | Line 1144 | public class LinkedBlockingDequeTest ext
1144                      q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1145                      shouldThrow();
1146                  } catch (InterruptedException success) {}
1147 +                assertFalse(Thread.interrupted());
1148 +
1149                  assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1150              }});
1151  
# Line 1124 | Line 1154 | public class LinkedBlockingDequeTest ext
1154          assertTrue(q.offerFirst(zero, LONG_DELAY_MS, MILLISECONDS));
1155          assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1156          barrier.await();
1157 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1157 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1158          t.interrupt();
1159          awaitTermination(t);
1160      }
# Line 1182 | Line 1212 | public class LinkedBlockingDequeTest ext
1212              }});
1213  
1214          await(pleaseInterrupt);
1215 <        assertThreadBlocks(t, Thread.State.WAITING);
1215 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1216          t.interrupt();
1217          awaitTermination(t);
1218          assertEquals(SIZE, q.size());
# Line 1204 | Line 1234 | public class LinkedBlockingDequeTest ext
1234                  pleaseTake.countDown();
1235                  q.putLast(86);
1236  
1237 +                Thread.currentThread().interrupt();
1238 +                try {
1239 +                    q.putLast(99);
1240 +                    shouldThrow();
1241 +                } catch (InterruptedException success) {}
1242 +                assertFalse(Thread.interrupted());
1243 +
1244                  pleaseInterrupt.countDown();
1245                  try {
1246                      q.putLast(99);
# Line 1217 | Line 1254 | public class LinkedBlockingDequeTest ext
1254          assertEquals(0, q.take());
1255  
1256          await(pleaseInterrupt);
1257 <        assertThreadBlocks(t, Thread.State.WAITING);
1257 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1258          t.interrupt();
1259          awaitTermination(t);
1260          assertEquals(0, q.remainingCapacity());
# Line 1226 | Line 1263 | public class LinkedBlockingDequeTest ext
1263      /**
1264       * timed offerLast times out if full and elements not taken
1265       */
1266 <    public void testTimedOfferLast() throws InterruptedException {
1266 >    public void testTimedOfferLast() {
1267          final LinkedBlockingDeque q = new LinkedBlockingDeque(2);
1268          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1269          Thread t = newStartedThread(new CheckedRunnable() {
# Line 1234 | Line 1271 | public class LinkedBlockingDequeTest ext
1271                  q.putLast(new Object());
1272                  q.putLast(new Object());
1273                  long startTime = System.nanoTime();
1274 +
1275                  assertFalse(q.offerLast(new Object(), timeoutMillis(), MILLISECONDS));
1276                  assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
1277 +
1278 +                Thread.currentThread().interrupt();
1279 +                try {
1280 +                    q.offerLast(new Object(), randomTimeout(), randomTimeUnit());
1281 +                    shouldThrow();
1282 +                } catch (InterruptedException success) {}
1283 +
1284                  pleaseInterrupt.countDown();
1285                  try {
1286 <                    q.offerLast(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
1286 >                    q.offerLast(new Object(), LONG_DELAY_MS, MILLISECONDS);
1287                      shouldThrow();
1288                  } catch (InterruptedException success) {}
1289 +
1290 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1291              }});
1292  
1293          await(pleaseInterrupt);
1294 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1294 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1295          t.interrupt();
1296          awaitTermination(t);
1297      }
# Line 1286 | Line 1333 | public class LinkedBlockingDequeTest ext
1333              }});
1334  
1335          await(pleaseInterrupt);
1336 <        assertThreadBlocks(t, Thread.State.WAITING);
1336 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
1337          t.interrupt();
1338          awaitTermination(t);
1339      }
# Line 1327 | Line 1374 | public class LinkedBlockingDequeTest ext
1374          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1375          Thread t = newStartedThread(new CheckedRunnable() {
1376              public void realRun() throws InterruptedException {
1377 <                long startTime = System.nanoTime();
1331 <                for (int i = 0; i < SIZE; ++i) {
1377 >                for (int i = 0; i < SIZE; i++)
1378                      assertEquals(SIZE - i - 1,
1379                                   q.pollLast(LONG_DELAY_MS, MILLISECONDS));
1334 –                }
1380  
1381                  Thread.currentThread().interrupt();
1382                  try {
1383 <                    q.pollLast(LONG_DELAY_MS, MILLISECONDS);
1383 >                    q.pollLast(randomTimeout(), randomTimeUnit());
1384                      shouldThrow();
1385                  } catch (InterruptedException success) {}
1386                  assertFalse(Thread.interrupted());
1387  
1388                  pleaseInterrupt.countDown();
1389                  try {
1390 <                    q.pollLast(LONG_DELAY_MS, MILLISECONDS);
1390 >                    q.pollLast(LONGER_DELAY_MS, MILLISECONDS);
1391                      shouldThrow();
1392                  } catch (InterruptedException success) {}
1393                  assertFalse(Thread.interrupted());
1349 –
1350 –                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1394              }});
1395  
1396          await(pleaseInterrupt);
1397 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1397 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1398          t.interrupt();
1399          awaitTermination(t);
1400          checkEmpty(q);
# Line 1376 | Line 1419 | public class LinkedBlockingDequeTest ext
1419  
1420                  Thread.currentThread().interrupt();
1421                  try {
1422 <                    q.poll(LONG_DELAY_MS, MILLISECONDS);
1422 >                    q.poll(randomTimeout(), randomTimeUnit());
1423                      shouldThrow();
1424                  } catch (InterruptedException success) {}
1425                  assertFalse(Thread.interrupted());
# Line 1397 | Line 1440 | public class LinkedBlockingDequeTest ext
1440          assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1441  
1442          barrier.await();
1443 <        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1443 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
1444          t.interrupt();
1445          awaitTermination(t);
1446      }
# Line 1499 | Line 1542 | public class LinkedBlockingDequeTest ext
1542       */
1543      public void testToArray() throws InterruptedException {
1544          LinkedBlockingDeque q = populatedDeque(SIZE);
1545 <        Object[] o = q.toArray();
1546 <        for (int i = 0; i < o.length; i++)
1547 <            assertSame(o[i], q.poll());
1545 >        Object[] a = q.toArray();
1546 >        assertSame(Object[].class, a.getClass());
1547 >        for (Object o : a)
1548 >            assertSame(o, q.poll());
1549 >        assertTrue(q.isEmpty());
1550      }
1551  
1552      /**
# Line 1512 | Line 1557 | public class LinkedBlockingDequeTest ext
1557          Integer[] ints = new Integer[SIZE];
1558          Integer[] array = q.toArray(ints);
1559          assertSame(ints, array);
1560 <        for (int i = 0; i < ints.length; i++)
1561 <            assertSame(ints[i], q.remove());
1560 >        for (Integer o : ints)
1561 >            assertSame(o, q.remove());
1562 >        assertTrue(q.isEmpty());
1563      }
1564  
1565      /**
# Line 1729 | Line 1775 | public class LinkedBlockingDequeTest ext
1775      }
1776  
1777      /**
1778 <     * A deserialized serialized deque has same elements in same order
1778 >     * A deserialized/reserialized deque has same elements in same order
1779       */
1780      public void testSerialization() throws Exception {
1781          Queue x = populatedDeque(SIZE);

Diff Legend

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