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.72 by jsr166, Fri May 15 18:21:19 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;
69 >            return Integer.MIN_VALUE + pseudodelay;
70          }
76 –        public int intValue() {
77 –            return pseudodelay;
78 –        }
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 162 | Line 156 | public class DelayQueueTest extends JSR1
156       */
157      public void testConstructor4() {
158          try {
159 <            PDelay[] ints = new PDelay[SIZE];
166 <            DelayQueue q = new DelayQueue(Arrays.asList(ints));
159 >            new DelayQueue(Arrays.asList(new PDelay[SIZE]));
160              shouldThrow();
161          } catch (NullPointerException success) {}
162      }
# Line 172 | Line 165 | public class DelayQueueTest extends JSR1
165       * Initializing from Collection with some null elements throws NPE
166       */
167      public void testConstructor5() {
168 +        PDelay[] a = new PDelay[SIZE];
169 +        for (int i = 0; i < SIZE-1; ++i)
170 +            a[i] = new PDelay(i);
171          try {
172 <            PDelay[] ints = new PDelay[SIZE];
177 <            for (int i = 0; i < SIZE-1; ++i)
178 <                ints[i] = new PDelay(i);
179 <            DelayQueue q = new DelayQueue(Arrays.asList(ints));
172 >            new DelayQueue(Arrays.asList(a));
173              shouldThrow();
174          } catch (NullPointerException success) {}
175      }
# Line 199 | Line 192 | public class DelayQueueTest extends JSR1
192      public void testEmpty() {
193          DelayQueue q = new DelayQueue();
194          assertTrue(q.isEmpty());
195 <        assertEquals(NOCAP, q.remainingCapacity());
195 >        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
196          q.add(new PDelay(1));
197          assertFalse(q.isEmpty());
198          q.add(new PDelay(2));
# Line 209 | Line 202 | public class DelayQueueTest extends JSR1
202      }
203  
204      /**
205 <     * remainingCapacity does not change when elements added or removed,
213 <     * but size does
205 >     * remainingCapacity() always returns Integer.MAX_VALUE
206       */
207      public void testRemainingCapacity() {
208 <        DelayQueue q = populatedQueue(SIZE);
208 >        BlockingQueue q = populatedQueue(SIZE);
209          for (int i = 0; i < SIZE; ++i) {
210 <            assertEquals(NOCAP, q.remainingCapacity());
210 >            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
211              assertEquals(SIZE-i, q.size());
212 <            q.remove();
212 >            assertTrue(q.remove() instanceof PDelay);
213          }
214          for (int i = 0; i < SIZE; ++i) {
215 <            assertEquals(NOCAP, q.remainingCapacity());
215 >            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
216              assertEquals(i, q.size());
217 <            q.add(new PDelay(i));
217 >            assertTrue(q.add(new PDelay(i)));
218          }
219      }
220  
# Line 250 | Line 242 | public class DelayQueueTest extends JSR1
242       * addAll(this) throws IAE
243       */
244      public void testAddAllSelf() {
245 +        DelayQueue q = populatedQueue(SIZE);
246          try {
254 –            DelayQueue q = populatedQueue(SIZE);
247              q.addAll(q);
248              shouldThrow();
249          } catch (IllegalArgumentException success) {}
# Line 262 | Line 254 | public class DelayQueueTest extends JSR1
254       * possibly adding some elements
255       */
256      public void testAddAll3() {
257 +        DelayQueue q = new DelayQueue();
258 +        PDelay[] a = new PDelay[SIZE];
259 +        for (int i = 0; i < SIZE-1; ++i)
260 +            a[i] = new PDelay(i);
261          try {
262 <            DelayQueue q = new DelayQueue();
267 <            PDelay[] ints = new PDelay[SIZE];
268 <            for (int i = 0; i < SIZE-1; ++i)
269 <                ints[i] = new PDelay(i);
270 <            q.addAll(Arrays.asList(ints));
262 >            q.addAll(Arrays.asList(a));
263              shouldThrow();
264          } catch (NullPointerException success) {}
265      }
# Line 293 | Line 285 | public class DelayQueueTest extends JSR1
285      public void testPut() {
286          DelayQueue q = new DelayQueue();
287          for (int i = 0; i < SIZE; ++i) {
288 <            PDelay I = new PDelay(i);
289 <            q.put(I);
290 <            assertTrue(q.contains(I));
288 >            PDelay x = new PDelay(i);
289 >            q.put(x);
290 >            assertTrue(q.contains(x));
291          }
292          assertEquals(SIZE, q.size());
293      }
# Line 339 | Line 331 | public class DelayQueueTest extends JSR1
331      public void testTake() throws InterruptedException {
332          DelayQueue q = populatedQueue(SIZE);
333          for (int i = 0; i < SIZE; ++i) {
334 <            assertEquals(new PDelay(i), ((PDelay)q.take()));
334 >            assertEquals(new PDelay(i), q.take());
335          }
336      }
337  
# Line 382 | Line 374 | public class DelayQueueTest extends JSR1
374      public void testPoll() {
375          DelayQueue q = populatedQueue(SIZE);
376          for (int i = 0; i < SIZE; ++i) {
377 <            assertEquals(new PDelay(i), ((PDelay)q.poll()));
377 >            assertEquals(new PDelay(i), q.poll());
378          }
379          assertNull(q.poll());
380      }
# Line 393 | Line 385 | public class DelayQueueTest extends JSR1
385      public void testTimedPoll0() throws InterruptedException {
386          DelayQueue q = populatedQueue(SIZE);
387          for (int i = 0; i < SIZE; ++i) {
388 <            assertEquals(new PDelay(i), ((PDelay)q.poll(0, MILLISECONDS)));
388 >            assertEquals(new PDelay(i), q.poll(0, MILLISECONDS));
389          }
390          assertNull(q.poll(0, MILLISECONDS));
391      }
# Line 405 | Line 397 | public class DelayQueueTest extends JSR1
397          DelayQueue q = populatedQueue(SIZE);
398          for (int i = 0; i < SIZE; ++i) {
399              long startTime = System.nanoTime();
400 <            assertEquals(new PDelay(i), ((PDelay)q.poll(LONG_DELAY_MS, MILLISECONDS)));
400 >            assertEquals(new PDelay(i), q.poll(LONG_DELAY_MS, MILLISECONDS));
401              assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
402          }
403          long startTime = System.nanoTime();
# Line 454 | Line 446 | public class DelayQueueTest extends JSR1
446      public void testPeek() {
447          DelayQueue q = populatedQueue(SIZE);
448          for (int i = 0; i < SIZE; ++i) {
449 <            assertEquals(new PDelay(i), ((PDelay)q.peek()));
450 <            assertEquals(new PDelay(i), ((PDelay)q.poll()));
449 >            assertEquals(new PDelay(i), q.peek());
450 >            assertEquals(new PDelay(i), q.poll());
451              if (q.isEmpty())
452                  assertNull(q.peek());
453              else
# Line 470 | Line 462 | public class DelayQueueTest extends JSR1
462      public void testElement() {
463          DelayQueue q = populatedQueue(SIZE);
464          for (int i = 0; i < SIZE; ++i) {
465 <            assertEquals(new PDelay(i), ((PDelay)q.element()));
465 >            assertEquals(new PDelay(i), q.element());
466              q.poll();
467          }
468          try {
# Line 485 | Line 477 | public class DelayQueueTest extends JSR1
477      public void testRemove() {
478          DelayQueue q = populatedQueue(SIZE);
479          for (int i = 0; i < SIZE; ++i) {
480 <            assertEquals(new PDelay(i), ((PDelay)q.remove()));
480 >            assertEquals(new PDelay(i), q.remove());
481          }
482          try {
483              q.remove();
# Line 494 | Line 486 | public class DelayQueueTest extends JSR1
486      }
487  
488      /**
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 –    /**
489       * contains(x) reports true when elements added but not yet removed
490       */
491      public void testContains() {
# Line 528 | Line 505 | public class DelayQueueTest extends JSR1
505          q.clear();
506          assertTrue(q.isEmpty());
507          assertEquals(0, q.size());
508 <        assertEquals(NOCAP, q.remainingCapacity());
508 >        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
509          PDelay x = new PDelay(1);
510          q.add(x);
511          assertFalse(q.isEmpty());
# Line 580 | Line 557 | public class DelayQueueTest extends JSR1
557              assertTrue(q.removeAll(p));
558              assertEquals(SIZE-i, q.size());
559              for (int j = 0; j < i; ++j) {
560 <                PDelay I = (PDelay)(p.remove());
561 <                assertFalse(q.contains(I));
560 >                PDelay x = (PDelay)(p.remove());
561 >                assertFalse(q.contains(x));
562              }
563          }
564      }
# Line 633 | Line 610 | public class DelayQueueTest extends JSR1
610              ++i;
611          }
612          assertEquals(i, SIZE);
613 +        assertIteratorExhausted(it);
614 +    }
615 +
616 +    /**
617 +     * iterator of empty collection has no elements
618 +     */
619 +    public void testEmptyIterator() {
620 +        assertIteratorExhausted(new DelayQueue().iterator());
621      }
622  
623      /**
# Line 647 | Line 632 | public class DelayQueueTest extends JSR1
632          it.next();
633          it.remove();
634          it = q.iterator();
635 <        assertEquals(it.next(), new PDelay(2));
636 <        assertEquals(it.next(), new PDelay(3));
635 >        assertEquals(new PDelay(2), it.next());
636 >        assertEquals(new PDelay(3), it.next());
637          assertFalse(it.hasNext());
638      }
639  
# Line 658 | Line 643 | public class DelayQueueTest extends JSR1
643      public void testToString() {
644          DelayQueue q = populatedQueue(SIZE);
645          String s = q.toString();
646 <        for (int i = 0; i < SIZE; ++i) {
647 <            assertTrue(s.contains(String.valueOf(Integer.MIN_VALUE+i)));
663 <        }
646 >        for (Object e : q)
647 >            assertTrue(s.contains(e.toString()));
648      }
649  
650      /**
# Line 674 | Line 658 | public class DelayQueueTest extends JSR1
658              public void realRun() throws InterruptedException {
659                  assertNull(q.poll());
660                  threadsStarted.await();
661 <                assertTrue(null != q.poll(LONG_DELAY_MS, MILLISECONDS));
661 >                assertNotNull(q.poll(LONG_DELAY_MS, MILLISECONDS));
662                  checkEmpty(q);
663              }});
664  
# Line 746 | Line 730 | public class DelayQueueTest extends JSR1
730          }
731          ArrayList l = new ArrayList();
732          q.drainTo(l);
733 <        assertEquals(q.size(), 0);
733 >        assertEquals(0, q.size());
734          for (int i = 0; i < SIZE; ++i)
735 <            assertEquals(l.get(i), elems[i]);
735 >            assertEquals(elems[i], l.get(i));
736          q.add(elems[0]);
737          q.add(elems[1]);
738          assertFalse(q.isEmpty());
# Line 756 | Line 740 | public class DelayQueueTest extends JSR1
740          assertTrue(q.contains(elems[1]));
741          l.clear();
742          q.drainTo(l);
743 <        assertEquals(q.size(), 0);
744 <        assertEquals(l.size(), 2);
743 >        assertEquals(0, q.size());
744 >        assertEquals(2, l.size());
745          for (int i = 0; i < 2; ++i)
746 <            assertEquals(l.get(i), elems[i]);
746 >            assertEquals(elems[i], l.get(i));
747      }
748  
749      /**
# Line 789 | Line 773 | public class DelayQueueTest extends JSR1
773              ArrayList l = new ArrayList();
774              q.drainTo(l, i);
775              int k = (i < SIZE) ? i : SIZE;
776 <            assertEquals(q.size(), SIZE-k);
777 <            assertEquals(l.size(), k);
776 >            assertEquals(SIZE-k, q.size());
777 >            assertEquals(k, l.size());
778          }
779      }
780  
781 +    /**
782 +     * remove(null), contains(null) always return false
783 +     */
784 +    public void testNeverContainsNull() {
785 +        Collection<?> q = populatedQueue(SIZE);
786 +        assertFalse(q.contains(null));
787 +        assertFalse(q.remove(null));
788 +    }
789   }

Diff Legend

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