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.67 by jsr166, Fri Jan 2 03:52:53 2015 UTC vs.
Revision 1.92 by jsr166, Thu Sep 5 20:54:24 2019 UTC

# Line 35 | Line 35 | public class DelayQueueTest extends JSR1
35      }
36  
37      public static void main(String[] args) {
38 <        junit.textui.TestRunner.run(suite());
38 >        main(suite(), args);
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  
46 –    private static final int NOCAP = Integer.MAX_VALUE;
47 –
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; }
56 <        public int compareTo(PDelay other) {
57 <            int a = this.pseudodelay;
58 <            int b = other.pseudodelay;
59 <            return (a < b) ? -1 : (a > b) ? 1 : 0;
60 <        }
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 68 | 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 79 | 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          }
86 –        public int compareTo(NanoDelay y) {
87 –            long i = trigger;
88 –            long j = y.trigger;
89 –            if (i < j) return -1;
90 –            if (i > j) return 1;
91 –            return 0;
92 –        }
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 <        }
101 <        public boolean equals(NanoDelay other) {
102 <            return other.trigger == trigger;
93 >            return (other instanceof NanoDelay) &&
94 >                this.trigger == ((NanoDelay)other).trigger;
95          }
96  
97          // suppress [overrides] javac warning
# Line 121 | 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(NOCAP, q.remainingCapacity());
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 140 | Line 133 | public class DelayQueueTest extends JSR1
133       * A new queue has unbounded capacity
134       */
135      public void testConstructor1() {
136 <        assertEquals(NOCAP, new DelayQueue().remainingCapacity());
136 >        assertEquals(Integer.MAX_VALUE, new DelayQueue().remainingCapacity());
137      }
138  
139      /**
# Line 148 | Line 141 | public class DelayQueueTest extends JSR1
141       */
142      public void testConstructor3() {
143          try {
144 <            DelayQueue q = new DelayQueue(null);
144 >            new DelayQueue(null);
145              shouldThrow();
146          } catch (NullPointerException success) {}
147      }
# Line 158 | Line 151 | public class DelayQueueTest extends JSR1
151       */
152      public void testConstructor4() {
153          try {
154 <            PDelay[] ints = new PDelay[SIZE];
162 <            DelayQueue q = new DelayQueue(Arrays.asList(ints));
154 >            new DelayQueue(Arrays.asList(new PDelay[SIZE]));
155              shouldThrow();
156          } catch (NullPointerException success) {}
157      }
# Line 168 | Line 160 | public class DelayQueueTest extends JSR1
160       * Initializing from Collection with some null elements throws NPE
161       */
162      public void testConstructor5() {
163 +        PDelay[] a = new PDelay[SIZE];
164 +        for (int i = 0; i < SIZE - 1; ++i)
165 +            a[i] = new PDelay(i);
166          try {
167 <            PDelay[] ints = new PDelay[SIZE];
173 <            for (int i = 0; i < SIZE-1; ++i)
174 <                ints[i] = new PDelay(i);
175 <            DelayQueue q = new DelayQueue(Arrays.asList(ints));
167 >            new DelayQueue(Arrays.asList(a));
168              shouldThrow();
169          } catch (NullPointerException success) {}
170      }
# Line 195 | Line 187 | public class DelayQueueTest extends JSR1
187      public void testEmpty() {
188          DelayQueue q = new DelayQueue();
189          assertTrue(q.isEmpty());
190 <        assertEquals(NOCAP, q.remainingCapacity());
190 >        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
191          q.add(new PDelay(1));
192          assertFalse(q.isEmpty());
193          q.add(new PDelay(2));
# Line 205 | Line 197 | public class DelayQueueTest extends JSR1
197      }
198  
199      /**
200 <     * remainingCapacity does not change when elements added or removed,
209 <     * but size does
200 >     * remainingCapacity() always returns Integer.MAX_VALUE
201       */
202      public void testRemainingCapacity() {
203 <        DelayQueue q = populatedQueue(SIZE);
203 >        BlockingQueue q = populatedQueue(SIZE);
204          for (int i = 0; i < SIZE; ++i) {
205 <            assertEquals(NOCAP, q.remainingCapacity());
206 <            assertEquals(SIZE-i, q.size());
207 <            q.remove();
205 >            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
206 >            assertEquals(SIZE - i, q.size());
207 >            assertTrue(q.remove() instanceof PDelay);
208          }
209          for (int i = 0; i < SIZE; ++i) {
210 <            assertEquals(NOCAP, q.remainingCapacity());
210 >            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
211              assertEquals(i, q.size());
212 <            q.add(new PDelay(i));
212 >            assertTrue(q.add(new PDelay(i)));
213          }
214      }
215  
# Line 243 | 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);
241          try {
250 –            DelayQueue q = populatedQueue(SIZE);
242              q.addAll(q);
243              shouldThrow();
244          } catch (IllegalArgumentException success) {}
# Line 258 | Line 249 | public class DelayQueueTest extends JSR1
249       * possibly adding some elements
250       */
251      public void testAddAll3() {
252 +        DelayQueue q = new DelayQueue();
253 +        PDelay[] a = new PDelay[SIZE];
254 +        for (int i = 0; i < SIZE - 1; ++i)
255 +            a[i] = new PDelay(i);
256          try {
257 <            DelayQueue q = new DelayQueue();
263 <            PDelay[] ints = new PDelay[SIZE];
264 <            for (int i = 0; i < SIZE-1; ++i)
265 <                ints[i] = new PDelay(i);
266 <            q.addAll(Arrays.asList(ints));
257 >            q.addAll(Arrays.asList(a));
258              shouldThrow();
259          } catch (NullPointerException success) {}
260      }
# Line 274 | Line 265 | public class DelayQueueTest extends JSR1
265      public void testAddAll5() {
266          PDelay[] empty = new PDelay[0];
267          PDelay[] ints = new PDelay[SIZE];
268 <        for (int i = SIZE-1; i >= 0; --i)
268 >        for (int i = SIZE - 1; i >= 0; --i)
269              ints[i] = new PDelay(i);
270          DelayQueue q = new DelayQueue();
271          assertFalse(q.addAll(Arrays.asList(empty)));
# Line 314 | 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 347 | 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()));
352 –                }
343  
344                  Thread.currentThread().interrupt();
345                  try {
# Line 367 | 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 416 | 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)));
415 <                }
412 >                long startTime = System.nanoTime();
413 >                for (int i = 0; i < SIZE; i++)
414 >                    assertEquals(new PDelay(i),
415 >                                 ((PDelay)q.poll(LONG_DELAY_MS, MILLISECONDS)));
416  
417                  Thread.currentThread().interrupt();
418                  try {
419 <                    q.poll(LONG_DELAY_MS, MILLISECONDS);
419 >                    q.poll(randomTimeout(), randomTimeUnit());
420                      shouldThrow();
421                  } catch (InterruptedException success) {}
422                  assertFalse(Thread.interrupted());
# Line 436 | Line 427 | public class DelayQueueTest extends JSR1
427                      shouldThrow();
428                  } catch (InterruptedException success) {}
429                  assertFalse(Thread.interrupted());
430 +
431 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
432              }});
433  
434          await(pleaseInterrupt);
435 <        assertThreadStaysAlive(t);
435 >        if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
436          t.interrupt();
437          awaitTermination(t);
438 +        checkEmpty(q);
439      }
440  
441      /**
# Line 509 | Line 503 | public class DelayQueueTest extends JSR1
503          q.clear();
504          assertTrue(q.isEmpty());
505          assertEquals(0, q.size());
506 <        assertEquals(NOCAP, q.remainingCapacity());
506 >        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
507          PDelay x = new PDelay(1);
508          q.add(x);
509          assertFalse(q.isEmpty());
# Line 546 | Line 540 | public class DelayQueueTest extends JSR1
540                  assertTrue(changed);
541  
542              assertTrue(q.containsAll(p));
543 <            assertEquals(SIZE-i, q.size());
543 >            assertEquals(SIZE - i, q.size());
544              p.remove();
545          }
546      }
# Line 559 | Line 553 | public class DelayQueueTest extends JSR1
553              DelayQueue q = populatedQueue(SIZE);
554              DelayQueue p = populatedQueue(i);
555              assertTrue(q.removeAll(p));
556 <            assertEquals(SIZE-i, q.size());
556 >            assertEquals(SIZE - i, q.size());
557              for (int j = 0; j < i; ++j) {
558                  PDelay x = (PDelay)(p.remove());
559                  assertFalse(q.contains(x));
# Line 572 | Line 566 | public class DelayQueueTest extends JSR1
566       */
567      public void testToArray() throws InterruptedException {
568          DelayQueue q = populatedQueue(SIZE);
569 <        Object[] o = q.toArray();
570 <        Arrays.sort(o);
571 <        for (int i = 0; i < o.length; i++)
572 <            assertSame(o[i], q.take());
569 >        Object[] a = q.toArray();
570 >        assertSame(Object[].class, a.getClass());
571 >        Arrays.sort(a);
572 >        for (Object o : a)
573 >            assertSame(o, q.take());
574 >        assertTrue(q.isEmpty());
575      }
576  
577      /**
# Line 587 | Line 583 | public class DelayQueueTest extends JSR1
583          PDelay[] array = q.toArray(ints);
584          assertSame(ints, array);
585          Arrays.sort(ints);
586 <        for (int i = 0; i < ints.length; i++)
587 <            assertSame(ints[i], q.remove());
586 >        for (PDelay o : ints)
587 >            assertSame(o, q.remove());
588 >        assertTrue(q.isEmpty());
589      }
590  
591      /**
# Line 614 | Line 611 | public class DelayQueueTest extends JSR1
611              ++i;
612          }
613          assertEquals(i, SIZE);
614 +        assertIteratorExhausted(it);
615 +    }
616 +
617 +    /**
618 +     * iterator of empty collection has no elements
619 +     */
620 +    public void testEmptyIterator() {
621 +        assertIteratorExhausted(new DelayQueue().iterator());
622      }
623  
624      /**
# Line 649 | Line 654 | public class DelayQueueTest extends JSR1
654      public void testPollInExecutor() {
655          final DelayQueue q = new DelayQueue();
656          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
657 <        ExecutorService executor = Executors.newFixedThreadPool(2);
658 <        executor.execute(new CheckedRunnable() {
659 <            public void realRun() throws InterruptedException {
660 <                assertNull(q.poll());
661 <                threadsStarted.await();
662 <                assertNotNull(q.poll(LONG_DELAY_MS, MILLISECONDS));
663 <                checkEmpty(q);
664 <            }});
665 <
666 <        executor.execute(new CheckedRunnable() {
667 <            public void realRun() throws InterruptedException {
668 <                threadsStarted.await();
669 <                q.put(new PDelay(1));
670 <            }});
671 <
672 <        joinPool(executor);
657 >        final ExecutorService executor = Executors.newFixedThreadPool(2);
658 >        try (PoolCleaner cleaner = cleaner(executor)) {
659 >            executor.execute(new CheckedRunnable() {
660 >                public void realRun() throws InterruptedException {
661 >                    assertNull(q.poll());
662 >                    threadsStarted.await();
663 >                    assertNotNull(q.poll(LONG_DELAY_MS, MILLISECONDS));
664 >                    checkEmpty(q);
665 >                }});
666 >
667 >            executor.execute(new CheckedRunnable() {
668 >                public void realRun() throws InterruptedException {
669 >                    threadsStarted.await();
670 >                    q.put(new PDelay(1));
671 >                }});
672 >        }
673      }
674  
675      /**
676       * Delayed actions do not occur until their delay elapses
677       */
678      public void testDelay() throws InterruptedException {
679 <        DelayQueue<NanoDelay> q = new DelayQueue<NanoDelay>();
679 >        DelayQueue<NanoDelay> q = new DelayQueue<>();
680          for (int i = 0; i < SIZE; ++i)
681              q.add(new NanoDelay(1000000L * (SIZE - i)));
682  
# Line 711 | Line 716 | public class DelayQueueTest extends JSR1
716      public void testTimedPollDelayed() throws InterruptedException {
717          DelayQueue q = new DelayQueue();
718          q.add(new NanoDelay(LONG_DELAY_MS * 1000000L));
719 +        long startTime = System.nanoTime();
720          assertNull(q.poll(timeoutMillis(), MILLISECONDS));
721 +        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
722      }
723  
724      /**
# Line 749 | Line 756 | public class DelayQueueTest extends JSR1
756          final DelayQueue q = populatedQueue(SIZE);
757          Thread t = new Thread(new CheckedRunnable() {
758              public void realRun() {
759 <                q.put(new PDelay(SIZE+1));
759 >                q.put(new PDelay(SIZE + 1));
760              }});
761  
762          t.start();
# Line 769 | Line 776 | public class DelayQueueTest extends JSR1
776              ArrayList l = new ArrayList();
777              q.drainTo(l, i);
778              int k = (i < SIZE) ? i : SIZE;
779 <            assertEquals(SIZE-k, q.size());
779 >            assertEquals(SIZE - k, q.size());
780              assertEquals(k, l.size());
781          }
782      }

Diff Legend

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