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.68 by jsr166, Sat Jan 17 22:55:06 2015 UTC vs.
Revision 1.76 by jsr166, Tue Oct 6 00:03:55 2015 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() {
# Line 43 | Line 43 | public class DelayQueueTest extends JSR1
43                              new Generic().testSuite());
44      }
45  
46 –    private static final int NOCAP = Integer.MAX_VALUE;
47 –
46      /**
47       * A delayed implementation for testing.
48       * Most tests use Pseudodelays, where delays are all elapsed
# Line 126 | Line 124 | public class DelayQueueTest extends JSR1
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)
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 140 | 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 148 | 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 158 | Line 156 | public class DelayQueueTest extends JSR1
156       */
157      public void testConstructor4() {
158          try {
159 <            PDelay[] ints = new PDelay[SIZE];
162 <            DelayQueue q = new DelayQueue(Arrays.asList(ints));
159 >            new DelayQueue(Arrays.asList(new PDelay[SIZE]));
160              shouldThrow();
161          } catch (NullPointerException success) {}
162      }
# Line 168 | 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];
173 <            for (int i = 0; i < SIZE-1; ++i)
174 <                ints[i] = new PDelay(i);
175 <            DelayQueue q = new DelayQueue(Arrays.asList(ints));
172 >            new DelayQueue(Arrays.asList(a));
173              shouldThrow();
174          } catch (NullPointerException success) {}
175      }
# Line 195 | 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 205 | Line 202 | public class DelayQueueTest extends JSR1
202      }
203  
204      /**
205 <     * remainingCapacity does not change when elements added or removed,
209 <     * 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());
211 <            assertEquals(SIZE-i, q.size());
212 <            q.remove();
210 >            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
211 >            assertEquals(SIZE - i, q.size());
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 246 | Line 242 | public class DelayQueueTest extends JSR1
242       * addAll(this) throws IAE
243       */
244      public void testAddAllSelf() {
245 +        DelayQueue q = populatedQueue(SIZE);
246          try {
250 –            DelayQueue q = populatedQueue(SIZE);
247              q.addAll(q);
248              shouldThrow();
249          } catch (IllegalArgumentException success) {}
# Line 258 | 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();
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));
262 >            q.addAll(Arrays.asList(a));
263              shouldThrow();
264          } catch (NullPointerException success) {}
265      }
# Line 274 | Line 270 | public class DelayQueueTest extends JSR1
270      public void testAddAll5() {
271          PDelay[] empty = new PDelay[0];
272          PDelay[] ints = new PDelay[SIZE];
273 <        for (int i = SIZE-1; i >= 0; --i)
273 >        for (int i = SIZE - 1; i >= 0; --i)
274              ints[i] = new PDelay(i);
275          DelayQueue q = new DelayQueue();
276          assertFalse(q.addAll(Arrays.asList(empty)));
# Line 416 | Line 412 | public class DelayQueueTest extends JSR1
412       */
413      public void testInterruptedTimedPoll() throws InterruptedException {
414          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
415 +        final DelayQueue q = populatedQueue(SIZE);
416          Thread t = newStartedThread(new CheckedRunnable() {
417              public void realRun() throws InterruptedException {
418 <                DelayQueue q = populatedQueue(SIZE);
418 >                long startTime = System.nanoTime();
419                  for (int i = 0; i < SIZE; ++i) {
420 <                    assertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, MILLISECONDS)));
420 >                    assertEquals(new PDelay(i),
421 >                                 ((PDelay)q.poll(LONG_DELAY_MS, MILLISECONDS)));
422                  }
423  
424                  Thread.currentThread().interrupt();
# Line 436 | Line 434 | public class DelayQueueTest extends JSR1
434                      shouldThrow();
435                  } catch (InterruptedException success) {}
436                  assertFalse(Thread.interrupted());
437 +                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
438              }});
439  
440          await(pleaseInterrupt);
441          assertThreadStaysAlive(t);
442          t.interrupt();
443          awaitTermination(t);
444 +        checkEmpty(q);
445      }
446  
447      /**
# Line 509 | Line 509 | public class DelayQueueTest extends JSR1
509          q.clear();
510          assertTrue(q.isEmpty());
511          assertEquals(0, q.size());
512 <        assertEquals(NOCAP, q.remainingCapacity());
512 >        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
513          PDelay x = new PDelay(1);
514          q.add(x);
515          assertFalse(q.isEmpty());
# Line 546 | Line 546 | public class DelayQueueTest extends JSR1
546                  assertTrue(changed);
547  
548              assertTrue(q.containsAll(p));
549 <            assertEquals(SIZE-i, q.size());
549 >            assertEquals(SIZE - i, q.size());
550              p.remove();
551          }
552      }
# Line 559 | Line 559 | public class DelayQueueTest extends JSR1
559              DelayQueue q = populatedQueue(SIZE);
560              DelayQueue p = populatedQueue(i);
561              assertTrue(q.removeAll(p));
562 <            assertEquals(SIZE-i, q.size());
562 >            assertEquals(SIZE - i, q.size());
563              for (int j = 0; j < i; ++j) {
564                  PDelay x = (PDelay)(p.remove());
565                  assertFalse(q.contains(x));
# Line 657 | Line 657 | public class DelayQueueTest extends JSR1
657      public void testPollInExecutor() {
658          final DelayQueue q = new DelayQueue();
659          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
660 <        ExecutorService executor = Executors.newFixedThreadPool(2);
661 <        executor.execute(new CheckedRunnable() {
662 <            public void realRun() throws InterruptedException {
663 <                assertNull(q.poll());
664 <                threadsStarted.await();
665 <                assertNotNull(q.poll(LONG_DELAY_MS, MILLISECONDS));
666 <                checkEmpty(q);
667 <            }});
668 <
669 <        executor.execute(new CheckedRunnable() {
670 <            public void realRun() throws InterruptedException {
671 <                threadsStarted.await();
672 <                q.put(new PDelay(1));
673 <            }});
674 <
675 <        joinPool(executor);
660 >        final ExecutorService executor = Executors.newFixedThreadPool(2);
661 >        try (PoolCleaner cleaner = cleaner(executor)) {
662 >            executor.execute(new CheckedRunnable() {
663 >                public void realRun() throws InterruptedException {
664 >                    assertNull(q.poll());
665 >                    threadsStarted.await();
666 >                    assertNotNull(q.poll(LONG_DELAY_MS, MILLISECONDS));
667 >                    checkEmpty(q);
668 >                }});
669 >
670 >            executor.execute(new CheckedRunnable() {
671 >                public void realRun() throws InterruptedException {
672 >                    threadsStarted.await();
673 >                    q.put(new PDelay(1));
674 >                }});
675 >        }
676      }
677  
678      /**
# Line 757 | Line 757 | public class DelayQueueTest extends JSR1
757          final DelayQueue q = populatedQueue(SIZE);
758          Thread t = new Thread(new CheckedRunnable() {
759              public void realRun() {
760 <                q.put(new PDelay(SIZE+1));
760 >                q.put(new PDelay(SIZE + 1));
761              }});
762  
763          t.start();
# Line 777 | Line 777 | public class DelayQueueTest extends JSR1
777              ArrayList l = new ArrayList();
778              q.drainTo(l, i);
779              int k = (i < SIZE) ? i : SIZE;
780 <            assertEquals(SIZE-k, q.size());
780 >            assertEquals(SIZE - k, q.size());
781              assertEquals(k, l.size());
782          }
783      }

Diff Legend

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