ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/DelayQueueTest.java
(Generate patch)

Comparing jsr166/src/test/tck/DelayQueueTest.java (file contents):
Revision 1.73 by jsr166, Sat May 23 00:53:08 2015 UTC vs.
Revision 1.93 by jsr166, Thu Sep 5 21:11:13 2019 UTC

# Line 39 | Line 39 | public class DelayQueueTest extends JSR1
39      }
40  
41      public static Test suite() {
42 +        class Implementation implements CollectionImplementation {
43 +            public Class<?> klazz() { return DelayQueue.class; }
44 +            public Collection emptyCollection() { return new DelayQueue(); }
45 +            public Object makeElement(int i) { return new PDelay(i); }
46 +            public boolean isConcurrent() { return true; }
47 +            public boolean permitsNulls() { return false; }
48 +        }
49          return newTestSuite(DelayQueueTest.class,
50 <                            new Generic().testSuite());
50 >                            new Generic().testSuite(),
51 >                            CollectionTest.testSuite(new Implementation()));
52      }
53  
54      /**
55 <     * A delayed implementation for testing.
56 <     * Most tests use Pseudodelays, where delays are all elapsed
55 >     * A fake Delayed implementation for testing.
56 >     * Most tests use PDelays, where delays are all elapsed
57       * (so, no blocking solely for delays) but are still ordered
58       */
59      static class PDelay implements Delayed {
60 <        int pseudodelay;
61 <        PDelay(int i) { pseudodelay = i; }
54 <        public int compareTo(PDelay other) {
55 <            int a = this.pseudodelay;
56 <            int b = other.pseudodelay;
57 <            return (a < b) ? -1 : (a > b) ? 1 : 0;
58 <        }
60 >        final int pseudodelay;
61 >        PDelay(int pseudodelay) { this.pseudodelay = pseudodelay; }
62          public int compareTo(Delayed y) {
63 <            return compareTo((PDelay)y);
63 >            return Integer.compare(this.pseudodelay, ((PDelay)y).pseudodelay);
64          }
65          public boolean equals(Object other) {
66              return (other instanceof PDelay) &&
# Line 66 | Line 69 | public class DelayQueueTest extends JSR1
69          // suppress [overrides] javac warning
70          public int hashCode() { return pseudodelay; }
71          public long getDelay(TimeUnit ignore) {
72 <            return Integer.MIN_VALUE + pseudodelay;
72 >            return (long) Integer.MIN_VALUE + pseudodelay;
73          }
74          public String toString() {
75              return String.valueOf(pseudodelay);
# Line 77 | Line 80 | public class DelayQueueTest extends JSR1
80       * Delayed implementation that actually delays
81       */
82      static class NanoDelay implements Delayed {
83 <        long trigger;
83 >        final long trigger;
84          NanoDelay(long i) {
85              trigger = System.nanoTime() + i;
86          }
84 –        public int compareTo(NanoDelay y) {
85 –            long i = trigger;
86 –            long j = y.trigger;
87 –            if (i < j) return -1;
88 –            if (i > j) return 1;
89 –            return 0;
90 –        }
87  
88          public int compareTo(Delayed y) {
89 <            return compareTo((NanoDelay)y);
89 >            return Long.compare(trigger, ((NanoDelay)y).trigger);
90          }
91  
92          public boolean equals(Object other) {
93 <            return equals((NanoDelay)other);
94 <        }
99 <        public boolean equals(NanoDelay other) {
100 <            return other.trigger == trigger;
93 >            return (other instanceof NanoDelay) &&
94 >                this.trigger == ((NanoDelay)other).trigger;
95          }
96  
97          // suppress [overrides] javac warning
# Line 119 | Line 113 | public class DelayQueueTest extends JSR1
113  
114      /**
115       * Returns a new queue of given size containing consecutive
116 <     * PDelays 0 ... n.
116 >     * PDelays 0 ... n - 1.
117       */
118 <    private DelayQueue<PDelay> populatedQueue(int n) {
119 <        DelayQueue<PDelay> q = new DelayQueue<PDelay>();
118 >    private static DelayQueue<PDelay> populatedQueue(int n) {
119 >        DelayQueue<PDelay> q = new DelayQueue<>();
120          assertTrue(q.isEmpty());
121 <        for (int i = n-1; i >= 0; i -= 2)
121 >        for (int i = n - 1; i >= 0; i -= 2)
122              assertTrue(q.offer(new PDelay(i)));
123          for (int i = (n & 1); i < n; i += 2)
124              assertTrue(q.offer(new PDelay(i)));
125          assertFalse(q.isEmpty());
126          assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
127          assertEquals(n, q.size());
128 +        assertEquals(new PDelay(0), q.peek());
129          return q;
130      }
131  
# Line 239 | Line 234 | public class DelayQueueTest extends JSR1
234      }
235  
236      /**
237 <     * addAll(this) throws IAE
237 >     * addAll(this) throws IllegalArgumentException
238       */
239      public void testAddAllSelf() {
240          DelayQueue q = populatedQueue(SIZE);
# Line 310 | Line 305 | public class DelayQueueTest extends JSR1
305      }
306  
307      /**
308 <     * timed offer does not time out
308 >     * Queue is unbounded, so timed offer never times out
309       */
310      public void testTimedOffer() throws InterruptedException {
311          final DelayQueue q = new DelayQueue();
# Line 343 | Line 338 | public class DelayQueueTest extends JSR1
338          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
339          Thread t = newStartedThread(new CheckedRunnable() {
340              public void realRun() throws InterruptedException {
341 <                for (int i = 0; i < SIZE; ++i) {
341 >                for (int i = 0; i < SIZE; i++)
342                      assertEquals(new PDelay(i), ((PDelay)q.take()));
348 –                }
343  
344                  Thread.currentThread().interrupt();
345                  try {
# Line 363 | Line 357 | public class DelayQueueTest extends JSR1
357              }});
358  
359          await(pleaseInterrupt);
360 <        assertThreadStaysAlive(t);
360 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
361          t.interrupt();
362          awaitTermination(t);
363      }
# Line 412 | Line 406 | public class DelayQueueTest extends JSR1
406       */
407      public void testInterruptedTimedPoll() throws InterruptedException {
408          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
409 +        final DelayQueue q = populatedQueue(SIZE);
410          Thread t = newStartedThread(new CheckedRunnable() {
411              public void realRun() throws InterruptedException {
412 <                DelayQueue q = populatedQueue(SIZE);
413 <                for (int i = 0; i < SIZE; ++i) {
414 <                    assertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, MILLISECONDS)));
420 <                }
412 >                for (int i = 0; i < SIZE; i++)
413 >                    assertEquals(new PDelay(i),
414 >                                 ((PDelay)q.poll(LONG_DELAY_MS, MILLISECONDS)));
415  
416                  Thread.currentThread().interrupt();
417                  try {
418 <                    q.poll(LONG_DELAY_MS, MILLISECONDS);
418 >                    q.poll(randomTimeout(), randomTimeUnit());
419                      shouldThrow();
420                  } catch (InterruptedException success) {}
421                  assertFalse(Thread.interrupted());
422  
423                  pleaseInterrupt.countDown();
424                  try {
425 <                    q.poll(LONG_DELAY_MS, MILLISECONDS);
425 >                    q.poll(LONGER_DELAY_MS, MILLISECONDS);
426                      shouldThrow();
427                  } catch (InterruptedException success) {}
428                  assertFalse(Thread.interrupted());
429              }});
430  
431          await(pleaseInterrupt);
432 <        assertThreadStaysAlive(t);
432 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
433          t.interrupt();
434          awaitTermination(t);
435 +        checkEmpty(q);
436      }
437  
438      /**
# Line 568 | Line 563 | public class DelayQueueTest extends JSR1
563       */
564      public void testToArray() throws InterruptedException {
565          DelayQueue q = populatedQueue(SIZE);
566 <        Object[] o = q.toArray();
567 <        Arrays.sort(o);
568 <        for (int i = 0; i < o.length; i++)
569 <            assertSame(o[i], q.take());
566 >        Object[] a = q.toArray();
567 >        assertSame(Object[].class, a.getClass());
568 >        Arrays.sort(a);
569 >        for (Object o : a)
570 >            assertSame(o, q.take());
571 >        assertTrue(q.isEmpty());
572      }
573  
574      /**
# Line 583 | Line 580 | public class DelayQueueTest extends JSR1
580          PDelay[] array = q.toArray(ints);
581          assertSame(ints, array);
582          Arrays.sort(ints);
583 <        for (int i = 0; i < ints.length; i++)
584 <            assertSame(ints[i], q.remove());
583 >        for (PDelay o : ints)
584 >            assertSame(o, q.remove());
585 >        assertTrue(q.isEmpty());
586      }
587  
588      /**
# Line 653 | Line 651 | public class DelayQueueTest extends JSR1
651      public void testPollInExecutor() {
652          final DelayQueue q = new DelayQueue();
653          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
654 <        ExecutorService executor = Executors.newFixedThreadPool(2);
655 <        executor.execute(new CheckedRunnable() {
656 <            public void realRun() throws InterruptedException {
657 <                assertNull(q.poll());
658 <                threadsStarted.await();
659 <                assertNotNull(q.poll(LONG_DELAY_MS, MILLISECONDS));
660 <                checkEmpty(q);
661 <            }});
662 <
663 <        executor.execute(new CheckedRunnable() {
664 <            public void realRun() throws InterruptedException {
665 <                threadsStarted.await();
666 <                q.put(new PDelay(1));
667 <            }});
668 <
669 <        joinPool(executor);
654 >        final ExecutorService executor = Executors.newFixedThreadPool(2);
655 >        try (PoolCleaner cleaner = cleaner(executor)) {
656 >            executor.execute(new CheckedRunnable() {
657 >                public void realRun() throws InterruptedException {
658 >                    assertNull(q.poll());
659 >                    threadsStarted.await();
660 >                    assertNotNull(q.poll(LONG_DELAY_MS, MILLISECONDS));
661 >                    checkEmpty(q);
662 >                }});
663 >
664 >            executor.execute(new CheckedRunnable() {
665 >                public void realRun() throws InterruptedException {
666 >                    threadsStarted.await();
667 >                    q.put(new PDelay(1));
668 >                }});
669 >        }
670      }
671  
672      /**
673       * Delayed actions do not occur until their delay elapses
674       */
675      public void testDelay() throws InterruptedException {
676 <        DelayQueue<NanoDelay> q = new DelayQueue<NanoDelay>();
676 >        DelayQueue<NanoDelay> q = new DelayQueue<>();
677          for (int i = 0; i < SIZE; ++i)
678              q.add(new NanoDelay(1000000L * (SIZE - i)));
679  
# Line 715 | Line 713 | public class DelayQueueTest extends JSR1
713      public void testTimedPollDelayed() throws InterruptedException {
714          DelayQueue q = new DelayQueue();
715          q.add(new NanoDelay(LONG_DELAY_MS * 1000000L));
716 +        long startTime = System.nanoTime();
717          assertNull(q.poll(timeoutMillis(), MILLISECONDS));
718 +        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
719      }
720  
721      /**

Diff Legend

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