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.53 by jsr166, Mon May 30 22:43:20 2011 UTC vs.
Revision 1.71 by jsr166, Sat Apr 25 04:55:30 2015 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 < import junit.framework.*;
10 < import java.util.Arrays;
9 > import static java.util.concurrent.TimeUnit.MILLISECONDS;
10 >
11   import java.util.ArrayList;
12 + import java.util.Arrays;
13   import java.util.Collection;
14   import java.util.Iterator;
15   import java.util.NoSuchElementException;
# Line 19 | Line 20 | import java.util.concurrent.DelayQueue;
20   import java.util.concurrent.Executors;
21   import java.util.concurrent.ExecutorService;
22   import java.util.concurrent.TimeUnit;
23 < import static java.util.concurrent.TimeUnit.MILLISECONDS;
23 >
24 > import junit.framework.Test;
25  
26   public class DelayQueueTest extends JSR166TestCase {
27  
# Line 33 | 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() {
# Line 41 | Line 43 | public class DelayQueueTest extends JSR1
43                              new Generic().testSuite());
44      }
45  
44 –    private static final int NOCAP = Integer.MAX_VALUE;
45 –
46      /**
47       * A delayed implementation for testing.
48       * Most tests use Pseudodelays, where delays are all elapsed
# Line 50 | Line 50 | public class DelayQueueTest extends JSR1
50       */
51      static class PDelay implements Delayed {
52          int pseudodelay;
53 <        PDelay(int i) { pseudodelay = Integer.MIN_VALUE + i; }
54 <        public int compareTo(PDelay y) {
55 <            int i = pseudodelay;
56 <            int j = y.pseudodelay;
57 <            if (i < j) return -1;
58 <            if (i > j) return 1;
59 <            return 0;
53 >        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          }
61 –
59          public int compareTo(Delayed y) {
60              return compareTo((PDelay)y);
61          }
65 –
62          public boolean equals(Object other) {
63 <            return equals((PDelay)other);
64 <        }
69 <        public boolean equals(PDelay other) {
70 <            return other.pseudodelay == pseudodelay;
63 >            return (other instanceof PDelay) &&
64 >                this.pseudodelay == ((PDelay)other).pseudodelay;
65          }
66 <
66 >        // suppress [overrides] javac warning
67 >        public int hashCode() { return pseudodelay; }
68          public long getDelay(TimeUnit ignore) {
69 <            return pseudodelay;
75 <        }
76 <        public int intValue() {
77 <            return pseudodelay;
69 >            return Integer.MIN_VALUE + pseudodelay;
70          }
79 –
71          public String toString() {
72              return String.valueOf(pseudodelay);
73          }
# Line 109 | Line 100 | public class DelayQueueTest extends JSR1
100              return other.trigger == trigger;
101          }
102  
103 +        // suppress [overrides] javac warning
104 +        public int hashCode() { return (int) trigger; }
105 +
106          public long getDelay(TimeUnit unit) {
107              long n = trigger - System.nanoTime();
108              return unit.convert(n, TimeUnit.NANOSECONDS);
# Line 124 | Line 118 | public class DelayQueueTest extends JSR1
118      }
119  
120      /**
121 <     * Create a queue of given size containing consecutive
121 >     * Returns a new queue of given size containing consecutive
122       * PDelays 0 ... n.
123       */
124      private DelayQueue<PDelay> populatedQueue(int n) {
125          DelayQueue<PDelay> q = new DelayQueue<PDelay>();
126          assertTrue(q.isEmpty());
127 <        for (int i = n-1; i >= 0; i-=2)
127 >        for (int i = n-1; i >= 0; i -= 2)
128              assertTrue(q.offer(new PDelay(i)));
129 <        for (int i = (n & 1); i < n; i+=2)
129 >        for (int i = (n & 1); i < n; i += 2)
130              assertTrue(q.offer(new PDelay(i)));
131          assertFalse(q.isEmpty());
132 <        assertEquals(NOCAP, q.remainingCapacity());
132 >        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
133          assertEquals(n, q.size());
134          return q;
135      }
# Line 144 | Line 138 | public class DelayQueueTest extends JSR1
138       * A new queue has unbounded capacity
139       */
140      public void testConstructor1() {
141 <        assertEquals(NOCAP, new DelayQueue().remainingCapacity());
141 >        assertEquals(Integer.MAX_VALUE, new DelayQueue().remainingCapacity());
142      }
143  
144      /**
# Line 152 | Line 146 | public class DelayQueueTest extends JSR1
146       */
147      public void testConstructor3() {
148          try {
149 <            DelayQueue q = new DelayQueue(null);
149 >            new DelayQueue(null);
150              shouldThrow();
151          } catch (NullPointerException success) {}
152      }
# Line 163 | Line 157 | public class DelayQueueTest extends JSR1
157      public void testConstructor4() {
158          try {
159              PDelay[] ints = new PDelay[SIZE];
160 <            DelayQueue q = new DelayQueue(Arrays.asList(ints));
160 >            new DelayQueue(Arrays.asList(ints));
161              shouldThrow();
162          } catch (NullPointerException success) {}
163      }
# Line 176 | Line 170 | public class DelayQueueTest extends JSR1
170              PDelay[] ints = new PDelay[SIZE];
171              for (int i = 0; i < SIZE-1; ++i)
172                  ints[i] = new PDelay(i);
173 <            DelayQueue q = new DelayQueue(Arrays.asList(ints));
173 >            new DelayQueue(Arrays.asList(ints));
174              shouldThrow();
175          } catch (NullPointerException success) {}
176      }
# Line 199 | Line 193 | public class DelayQueueTest extends JSR1
193      public void testEmpty() {
194          DelayQueue q = new DelayQueue();
195          assertTrue(q.isEmpty());
196 <        assertEquals(NOCAP, q.remainingCapacity());
196 >        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
197          q.add(new PDelay(1));
198          assertFalse(q.isEmpty());
199          q.add(new PDelay(2));
# Line 209 | Line 203 | public class DelayQueueTest extends JSR1
203      }
204  
205      /**
206 <     * remainingCapacity does not change when elements added or removed,
213 <     * but size does
206 >     * remainingCapacity() always returns Integer.MAX_VALUE
207       */
208      public void testRemainingCapacity() {
209 <        DelayQueue q = populatedQueue(SIZE);
209 >        BlockingQueue q = populatedQueue(SIZE);
210          for (int i = 0; i < SIZE; ++i) {
211 <            assertEquals(NOCAP, q.remainingCapacity());
211 >            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
212              assertEquals(SIZE-i, q.size());
213 <            q.remove();
213 >            assertTrue(q.remove() instanceof PDelay);
214          }
215          for (int i = 0; i < SIZE; ++i) {
216 <            assertEquals(NOCAP, q.remainingCapacity());
216 >            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
217              assertEquals(i, q.size());
218 <            q.add(new PDelay(i));
218 >            assertTrue(q.add(new PDelay(i)));
219          }
220      }
221  
# Line 293 | Line 286 | public class DelayQueueTest extends JSR1
286      public void testPut() {
287          DelayQueue q = new DelayQueue();
288          for (int i = 0; i < SIZE; ++i) {
289 <            PDelay I = new PDelay(i);
290 <            q.put(I);
291 <            assertTrue(q.contains(I));
289 >            PDelay x = new PDelay(i);
290 >            q.put(x);
291 >            assertTrue(q.contains(x));
292          }
293          assertEquals(SIZE, q.size());
294      }
# Line 339 | Line 332 | public class DelayQueueTest extends JSR1
332      public void testTake() throws InterruptedException {
333          DelayQueue q = populatedQueue(SIZE);
334          for (int i = 0; i < SIZE; ++i) {
335 <            assertEquals(new PDelay(i), ((PDelay)q.take()));
335 >            assertEquals(new PDelay(i), q.take());
336          }
337      }
338  
# Line 382 | Line 375 | public class DelayQueueTest extends JSR1
375      public void testPoll() {
376          DelayQueue q = populatedQueue(SIZE);
377          for (int i = 0; i < SIZE; ++i) {
378 <            assertEquals(new PDelay(i), ((PDelay)q.poll()));
378 >            assertEquals(new PDelay(i), q.poll());
379          }
380          assertNull(q.poll());
381      }
# Line 393 | Line 386 | public class DelayQueueTest extends JSR1
386      public void testTimedPoll0() throws InterruptedException {
387          DelayQueue q = populatedQueue(SIZE);
388          for (int i = 0; i < SIZE; ++i) {
389 <            assertEquals(new PDelay(i), ((PDelay)q.poll(0, MILLISECONDS)));
389 >            assertEquals(new PDelay(i), q.poll(0, MILLISECONDS));
390          }
391          assertNull(q.poll(0, MILLISECONDS));
392      }
# Line 405 | Line 398 | public class DelayQueueTest extends JSR1
398          DelayQueue q = populatedQueue(SIZE);
399          for (int i = 0; i < SIZE; ++i) {
400              long startTime = System.nanoTime();
401 <            assertEquals(new PDelay(i), ((PDelay)q.poll(LONG_DELAY_MS, MILLISECONDS)));
401 >            assertEquals(new PDelay(i), q.poll(LONG_DELAY_MS, MILLISECONDS));
402              assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
403          }
404          long startTime = System.nanoTime();
# Line 454 | Line 447 | public class DelayQueueTest extends JSR1
447      public void testPeek() {
448          DelayQueue q = populatedQueue(SIZE);
449          for (int i = 0; i < SIZE; ++i) {
450 <            assertEquals(new PDelay(i), ((PDelay)q.peek()));
451 <            assertEquals(new PDelay(i), ((PDelay)q.poll()));
450 >            assertEquals(new PDelay(i), q.peek());
451 >            assertEquals(new PDelay(i), q.poll());
452              if (q.isEmpty())
453                  assertNull(q.peek());
454              else
# Line 470 | Line 463 | public class DelayQueueTest extends JSR1
463      public void testElement() {
464          DelayQueue q = populatedQueue(SIZE);
465          for (int i = 0; i < SIZE; ++i) {
466 <            assertEquals(new PDelay(i), ((PDelay)q.element()));
466 >            assertEquals(new PDelay(i), q.element());
467              q.poll();
468          }
469          try {
# Line 485 | Line 478 | public class DelayQueueTest extends JSR1
478      public void testRemove() {
479          DelayQueue q = populatedQueue(SIZE);
480          for (int i = 0; i < SIZE; ++i) {
481 <            assertEquals(new PDelay(i), ((PDelay)q.remove()));
481 >            assertEquals(new PDelay(i), q.remove());
482          }
483          try {
484              q.remove();
# Line 494 | Line 487 | public class DelayQueueTest extends JSR1
487      }
488  
489      /**
497 –     * remove(x) removes x and returns true if present
498 –     */
499 –    public void testRemoveElement() {
500 –        DelayQueue q = populatedQueue(SIZE);
501 –        for (int i = 1; i < SIZE; i+=2) {
502 –            assertTrue(q.remove(new PDelay(i)));
503 –        }
504 –        for (int i = 0; i < SIZE; i+=2) {
505 –            assertTrue(q.remove(new PDelay(i)));
506 –            assertFalse(q.remove(new PDelay(i+1)));
507 –        }
508 –        assertTrue(q.isEmpty());
509 –    }
510 –
511 –    /**
490       * contains(x) reports true when elements added but not yet removed
491       */
492      public void testContains() {
# Line 528 | Line 506 | public class DelayQueueTest extends JSR1
506          q.clear();
507          assertTrue(q.isEmpty());
508          assertEquals(0, q.size());
509 <        assertEquals(NOCAP, q.remainingCapacity());
509 >        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
510          PDelay x = new PDelay(1);
511          q.add(x);
512          assertFalse(q.isEmpty());
# Line 580 | Line 558 | public class DelayQueueTest extends JSR1
558              assertTrue(q.removeAll(p));
559              assertEquals(SIZE-i, q.size());
560              for (int j = 0; j < i; ++j) {
561 <                PDelay I = (PDelay)(p.remove());
562 <                assertFalse(q.contains(I));
561 >                PDelay x = (PDelay)(p.remove());
562 >                assertFalse(q.contains(x));
563              }
564          }
565      }
# Line 633 | 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 647 | Line 633 | public class DelayQueueTest extends JSR1
633          it.next();
634          it.remove();
635          it = q.iterator();
636 <        assertEquals(it.next(), new PDelay(2));
637 <        assertEquals(it.next(), new PDelay(3));
636 >        assertEquals(new PDelay(2), it.next());
637 >        assertEquals(new PDelay(3), it.next());
638          assertFalse(it.hasNext());
639      }
640  
# Line 658 | Line 644 | public class DelayQueueTest extends JSR1
644      public void testToString() {
645          DelayQueue q = populatedQueue(SIZE);
646          String s = q.toString();
647 <        for (int i = 0; i < SIZE; ++i) {
648 <            assertTrue(s.contains(String.valueOf(Integer.MIN_VALUE+i)));
663 <        }
647 >        for (Object e : q)
648 >            assertTrue(s.contains(e.toString()));
649      }
650  
651      /**
# Line 674 | Line 659 | public class DelayQueueTest extends JSR1
659              public void realRun() throws InterruptedException {
660                  assertNull(q.poll());
661                  threadsStarted.await();
662 <                assertTrue(null != q.poll(LONG_DELAY_MS, MILLISECONDS));
662 >                assertNotNull(q.poll(LONG_DELAY_MS, MILLISECONDS));
663                  checkEmpty(q);
664              }});
665  
# Line 746 | Line 731 | public class DelayQueueTest extends JSR1
731          }
732          ArrayList l = new ArrayList();
733          q.drainTo(l);
734 <        assertEquals(q.size(), 0);
734 >        assertEquals(0, q.size());
735          for (int i = 0; i < SIZE; ++i)
736 <            assertEquals(l.get(i), elems[i]);
736 >            assertEquals(elems[i], l.get(i));
737          q.add(elems[0]);
738          q.add(elems[1]);
739          assertFalse(q.isEmpty());
# Line 756 | Line 741 | public class DelayQueueTest extends JSR1
741          assertTrue(q.contains(elems[1]));
742          l.clear();
743          q.drainTo(l);
744 <        assertEquals(q.size(), 0);
745 <        assertEquals(l.size(), 2);
744 >        assertEquals(0, q.size());
745 >        assertEquals(2, l.size());
746          for (int i = 0; i < 2; ++i)
747 <            assertEquals(l.get(i), elems[i]);
747 >            assertEquals(elems[i], l.get(i));
748      }
749  
750      /**
# Line 789 | Line 774 | public class DelayQueueTest extends JSR1
774              ArrayList l = new ArrayList();
775              q.drainTo(l, i);
776              int k = (i < SIZE) ? i : SIZE;
777 <            assertEquals(q.size(), SIZE-k);
778 <            assertEquals(l.size(), k);
777 >            assertEquals(SIZE-k, q.size());
778 >            assertEquals(k, l.size());
779          }
780      }
781  
782 +    /**
783 +     * remove(null), contains(null) always return false
784 +     */
785 +    public void testNeverContainsNull() {
786 +        Collection<?> q = populatedQueue(SIZE);
787 +        assertFalse(q.contains(null));
788 +        assertFalse(q.remove(null));
789 +    }
790   }

Diff Legend

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