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.79 by jsr166, Mon Oct 17 01:54:51 2016 UTC vs.
Revision 1.86 by jsr166, Sun May 14 00:48:20 2017 UTC

# Line 52 | Line 52 | public class DelayQueueTest extends JSR1
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; }
62 <        public int compareTo(PDelay other) {
63 <            int a = this.pseudodelay;
64 <            int b = other.pseudodelay;
65 <            return (a < b) ? -1 : (a > b) ? 1 : 0;
66 <        }
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 85 | 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          }
92 –        public int compareTo(NanoDelay y) {
93 –            long i = trigger;
94 –            long j = y.trigger;
95 –            if (i < j) return -1;
96 –            if (i > j) return 1;
97 –            return 0;
98 –        }
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) {
# Line 127 | Line 115 | public class DelayQueueTest extends JSR1
115       * Returns a new queue of given size containing consecutive
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)
122              assertTrue(q.offer(new PDelay(i)));
# Line 350 | 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()));
355 –                }
343  
344                  Thread.currentThread().interrupt();
345                  try {
# Line 370 | Line 357 | public class DelayQueueTest extends JSR1
357              }});
358  
359          await(pleaseInterrupt);
360 <        assertThreadStaysAlive(t);
360 >        assertThreadBlocks(t, Thread.State.WAITING);
361          t.interrupt();
362          awaitTermination(t);
363      }
# Line 441 | Line 428 | public class DelayQueueTest extends JSR1
428                      shouldThrow();
429                  } catch (InterruptedException success) {}
430                  assertFalse(Thread.interrupted());
431 +
432                  assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
433              }});
434  
435          await(pleaseInterrupt);
436 <        assertThreadStaysAlive(t);
436 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
437          t.interrupt();
438          awaitTermination(t);
439          checkEmpty(q);
# Line 686 | Line 674 | public class DelayQueueTest extends JSR1
674       * Delayed actions do not occur until their delay elapses
675       */
676      public void testDelay() throws InterruptedException {
677 <        DelayQueue<NanoDelay> q = new DelayQueue<NanoDelay>();
677 >        DelayQueue<NanoDelay> q = new DelayQueue<>();
678          for (int i = 0; i < SIZE; ++i)
679              q.add(new NanoDelay(1000000L * (SIZE - i)));
680  
# Line 726 | Line 714 | public class DelayQueueTest extends JSR1
714      public void testTimedPollDelayed() throws InterruptedException {
715          DelayQueue q = new DelayQueue();
716          q.add(new NanoDelay(LONG_DELAY_MS * 1000000L));
717 +        long startTime = System.nanoTime();
718          assertNull(q.poll(timeoutMillis(), MILLISECONDS));
719 +        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
720      }
721  
722      /**

Diff Legend

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