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.61 by jsr166, Sun Oct 4 18:49:02 2015 UTC vs.
Revision 1.67 by jsr166, Sat Mar 11 18:20:47 2017 UTC

# Line 41 | Line 41 | public class LinkedBlockingDequeTest ext
41      }
42  
43      public static Test suite() {
44 +        class Implementation implements CollectionImplementation {
45 +            public Class<?> klazz() { return LinkedBlockingDeque.class; }
46 +            public Collection emptyCollection() { return new LinkedBlockingDeque(); }
47 +            public Object makeElement(int i) { return i; }
48 +            public boolean isConcurrent() { return true; }
49 +            public boolean permitsNulls() { return false; }
50 +        }
51          return newTestSuite(LinkedBlockingDequeTest.class,
52                              new Unbounded().testSuite(),
53 <                            new Bounded().testSuite());
53 >                            new Bounded().testSuite(),
54 >                            CollectionTest.testSuite(new Implementation()));
55      }
56  
57      /**
58       * Returns a new deque of given size containing consecutive
59 <     * Integers 0 ... n.
59 >     * Integers 0 ... n - 1.
60       */
61 <    private LinkedBlockingDeque<Integer> populatedDeque(int n) {
61 >    private static LinkedBlockingDeque<Integer> populatedDeque(int n) {
62          LinkedBlockingDeque<Integer> q =
63              new LinkedBlockingDeque<Integer>(n);
64          assertTrue(q.isEmpty());
# Line 59 | Line 67 | public class LinkedBlockingDequeTest ext
67          assertFalse(q.isEmpty());
68          assertEquals(0, q.remainingCapacity());
69          assertEquals(n, q.size());
70 +        assertEquals((Integer) 0, q.peekFirst());
71 +        assertEquals((Integer) (n - 1), q.peekLast());
72          return q;
73      }
74  
# Line 751 | Line 761 | public class LinkedBlockingDequeTest ext
761          final CountDownLatch aboutToWait = new CountDownLatch(1);
762          Thread t = newStartedThread(new CheckedRunnable() {
763              public void realRun() throws InterruptedException {
764 +                long startTime = System.nanoTime();
765                  for (int i = 0; i < SIZE; ++i) {
755 –                    long t0 = System.nanoTime();
766                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
757 –                    assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
767                  }
759 –                long t0 = System.nanoTime();
768                  aboutToWait.countDown();
769                  try {
770 <                    q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
770 >                    q.poll(LONG_DELAY_MS, MILLISECONDS);
771                      shouldThrow();
772                  } catch (InterruptedException success) {
773 <                    assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
773 >                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
774                  }
775              }});
776  
777          aboutToWait.await();
778 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
778 >        waitForThreadToEnterWaitState(t);
779          t.interrupt();
780 <        awaitTermination(t, MEDIUM_DELAY_MS);
780 >        awaitTermination(t);
781          checkEmpty(q);
782      }
783  
# Line 1050 | Line 1058 | public class LinkedBlockingDequeTest ext
1058       * returning timeout status
1059       */
1060      public void testInterruptedTimedPollFirst() throws InterruptedException {
1061 +        final LinkedBlockingDeque q = populatedDeque(SIZE);
1062          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1063          Thread t = newStartedThread(new CheckedRunnable() {
1064              public void realRun() throws InterruptedException {
1065 <                LinkedBlockingDeque q = populatedDeque(SIZE);
1065 >                long startTime = System.nanoTime();
1066                  for (int i = 0; i < SIZE; ++i) {
1067                      assertEquals(i, q.pollFirst(LONG_DELAY_MS, MILLISECONDS));
1068                  }
1069  
1070                  Thread.currentThread().interrupt();
1071                  try {
1072 <                    q.pollFirst(SMALL_DELAY_MS, MILLISECONDS);
1072 >                    q.pollFirst(LONG_DELAY_MS, MILLISECONDS);
1073                      shouldThrow();
1074                  } catch (InterruptedException success) {}
1075                  assertFalse(Thread.interrupted());
# Line 1071 | Line 1080 | public class LinkedBlockingDequeTest ext
1080                      shouldThrow();
1081                  } catch (InterruptedException success) {}
1082                  assertFalse(Thread.interrupted());
1083 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1084              }});
1085  
1086          await(pleaseInterrupt);
# Line 1315 | Line 1325 | public class LinkedBlockingDequeTest ext
1325       * returning timeout status
1326       */
1327      public void testInterruptedTimedPollLast() throws InterruptedException {
1328 +        final LinkedBlockingDeque q = populatedDeque(SIZE);
1329          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
1330          Thread t = newStartedThread(new CheckedRunnable() {
1331              public void realRun() throws InterruptedException {
1332 <                LinkedBlockingDeque q = populatedDeque(SIZE);
1332 >                long startTime = System.nanoTime();
1333                  for (int i = 0; i < SIZE; ++i) {
1334                      assertEquals(SIZE - i - 1,
1335                                   q.pollLast(LONG_DELAY_MS, MILLISECONDS));
# Line 1337 | Line 1348 | public class LinkedBlockingDequeTest ext
1348                      shouldThrow();
1349                  } catch (InterruptedException success) {}
1350                  assertFalse(Thread.interrupted());
1351 +
1352 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1353              }});
1354  
1355          await(pleaseInterrupt);
1356          assertThreadStaysAlive(t);
1357          t.interrupt();
1358          awaitTermination(t);
1359 +        checkEmpty(q);
1360      }
1361  
1362      /**
# Line 1375 | Line 1389 | public class LinkedBlockingDequeTest ext
1389                      shouldThrow();
1390                  } catch (InterruptedException success) {}
1391                  assertFalse(Thread.interrupted());
1392 +
1393 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
1394              }});
1395  
1396          barrier.await();

Diff Legend

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