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.58 by jsr166, Sat Nov 26 05:42:14 2011 UTC vs.
Revision 1.70 by jsr166, Sat Feb 28 19:59:23 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;
16   import java.util.concurrent.BlockingQueue;
# Line 18 | 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 40 | Line 43 | public class DelayQueueTest extends JSR1
43                              new Generic().testSuite());
44      }
45  
43 –    private static final int NOCAP = Integer.MAX_VALUE;
44 –
46      /**
47       * A delayed implementation for testing.
48       * Most tests use Pseudodelays, where delays are all elapsed
# Line 62 | Line 63 | public class DelayQueueTest extends JSR1
63              return (other instanceof PDelay) &&
64                  this.pseudodelay == ((PDelay)other).pseudodelay;
65          }
66 +        // suppress [overrides] javac warning
67 +        public int hashCode() { return pseudodelay; }
68          public long getDelay(TimeUnit ignore) {
69              return Integer.MIN_VALUE + pseudodelay;
70          }
# Line 97 | 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 112 | 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 132 | 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 140 | 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 151 | 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 164 | 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 187 | 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 197 | Line 203 | public class DelayQueueTest extends JSR1
203      }
204  
205      /**
206 <     * remainingCapacity does not change when elements added or removed,
201 <     * 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 281 | 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 327 | 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 370 | 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 381 | 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 393 | 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 442 | 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 458 | 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 473 | 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 501 | 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 553 | 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 606 | 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 646 | 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 766 | Line 779 | public class DelayQueueTest extends JSR1
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