ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/PriorityBlockingQueueTest.java
(Generate patch)

Comparing jsr166/src/test/tck/PriorityBlockingQueueTest.java (file contents):
Revision 1.54 by jsr166, Wed Dec 31 19:05:43 2014 UTC vs.
Revision 1.74 by jsr166, Sat May 13 22:49:01 2017 UTC

# Line 38 | Line 38 | public class PriorityBlockingQueueTest e
38      }
39  
40      public static void main(String[] args) {
41 <        junit.textui.TestRunner.run(suite());
41 >        main(suite(), args);
42      }
43  
44      public static Test suite() {
45 +        class Implementation implements CollectionImplementation {
46 +            public Class<?> klazz() { return PriorityBlockingQueue.class; }
47 +            public Collection emptyCollection() { return new PriorityBlockingQueue(); }
48 +            public Object makeElement(int i) { return i; }
49 +            public boolean isConcurrent() { return true; }
50 +            public boolean permitsNulls() { return false; }
51 +        }
52          return newTestSuite(PriorityBlockingQueueTest.class,
53                              new Generic().testSuite(),
54 <                            new InitialCapacity().testSuite());
54 >                            new InitialCapacity().testSuite(),
55 >                            CollectionTest.testSuite(new Implementation()));
56      }
57  
50 –    private static final int NOCAP = Integer.MAX_VALUE;
51 –
58      /** Sample Comparator */
59      static class MyReverseComparator implements Comparator {
60          public int compare(Object x, Object y) {
# Line 58 | Line 64 | public class PriorityBlockingQueueTest e
64  
65      /**
66       * Returns a new queue of given size containing consecutive
67 <     * Integers 0 ... n.
67 >     * Integers 0 ... n - 1.
68       */
69 <    private PriorityBlockingQueue<Integer> populatedQueue(int n) {
69 >    private static PriorityBlockingQueue<Integer> populatedQueue(int n) {
70          PriorityBlockingQueue<Integer> q =
71              new PriorityBlockingQueue<Integer>(n);
72          assertTrue(q.isEmpty());
73 <        for (int i = n-1; i >= 0; i-=2)
73 >        for (int i = n - 1; i >= 0; i -= 2)
74              assertTrue(q.offer(new Integer(i)));
75 <        for (int i = (n & 1); i < n; i+=2)
75 >        for (int i = (n & 1); i < n; i += 2)
76              assertTrue(q.offer(new Integer(i)));
77          assertFalse(q.isEmpty());
78 <        assertEquals(NOCAP, q.remainingCapacity());
78 >        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
79          assertEquals(n, q.size());
80 +        assertEquals((Integer) 0, q.peek());
81          return q;
82      }
83  
# Line 78 | Line 85 | public class PriorityBlockingQueueTest e
85       * A new queue has unbounded capacity
86       */
87      public void testConstructor1() {
88 <        assertEquals(NOCAP, new PriorityBlockingQueue(SIZE).remainingCapacity());
88 >        assertEquals(Integer.MAX_VALUE,
89 >                     new PriorityBlockingQueue(SIZE).remainingCapacity());
90      }
91  
92      /**
# Line 117 | Line 125 | public class PriorityBlockingQueueTest e
125       */
126      public void testConstructor5() {
127          Integer[] ints = new Integer[SIZE];
128 <        for (int i = 0; i < SIZE-1; ++i)
128 >        for (int i = 0; i < SIZE - 1; ++i)
129              ints[i] = i;
130          Collection<Integer> elements = Arrays.asList(ints);
131          try {
# Line 149 | Line 157 | public class PriorityBlockingQueueTest e
157          for (int i = 0; i < SIZE; ++i)
158              ints[i] = new Integer(i);
159          q.addAll(Arrays.asList(ints));
160 <        for (int i = SIZE-1; i >= 0; --i)
160 >        for (int i = SIZE - 1; i >= 0; --i)
161              assertEquals(ints[i], q.poll());
162      }
163  
# Line 159 | Line 167 | public class PriorityBlockingQueueTest e
167      public void testEmpty() {
168          PriorityBlockingQueue q = new PriorityBlockingQueue(2);
169          assertTrue(q.isEmpty());
170 <        assertEquals(NOCAP, q.remainingCapacity());
170 >        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
171          q.add(one);
172          assertFalse(q.isEmpty());
173          q.add(two);
# Line 169 | Line 177 | public class PriorityBlockingQueueTest e
177      }
178  
179      /**
180 <     * remainingCapacity does not change when elements added or removed,
173 <     * but size does
180 >     * remainingCapacity() always returns Integer.MAX_VALUE
181       */
182      public void testRemainingCapacity() {
183 <        PriorityBlockingQueue q = populatedQueue(SIZE);
183 >        BlockingQueue q = populatedQueue(SIZE);
184          for (int i = 0; i < SIZE; ++i) {
185 <            assertEquals(NOCAP, q.remainingCapacity());
186 <            assertEquals(SIZE-i, q.size());
187 <            q.remove();
185 >            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
186 >            assertEquals(SIZE - i, q.size());
187 >            assertEquals(i, q.remove());
188          }
189          for (int i = 0; i < SIZE; ++i) {
190 <            assertEquals(NOCAP, q.remainingCapacity());
190 >            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
191              assertEquals(i, q.size());
192 <            q.add(new Integer(i));
192 >            assertTrue(q.add(i));
193          }
194      }
195  
# Line 199 | Line 206 | public class PriorityBlockingQueueTest e
206       * Offer of non-Comparable throws CCE
207       */
208      public void testOfferNonComparable() {
209 +        PriorityBlockingQueue q = new PriorityBlockingQueue(1);
210          try {
203 –            PriorityBlockingQueue q = new PriorityBlockingQueue(1);
204 –            q.offer(new Object());
205 –            q.offer(new Object());
211              q.offer(new Object());
212              shouldThrow();
213 <        } catch (ClassCastException success) {}
213 >        } catch (ClassCastException success) {
214 >            assertTrue(q.isEmpty());
215 >            assertEquals(0, q.size());
216 >            assertNull(q.poll());
217 >        }
218      }
219  
220      /**
# Line 223 | Line 232 | public class PriorityBlockingQueueTest e
232       * addAll(this) throws IAE
233       */
234      public void testAddAllSelf() {
235 +        PriorityBlockingQueue q = populatedQueue(SIZE);
236          try {
227 –            PriorityBlockingQueue q = populatedQueue(SIZE);
237              q.addAll(q);
238              shouldThrow();
239          } catch (IllegalArgumentException success) {}
# Line 235 | Line 244 | public class PriorityBlockingQueueTest e
244       * possibly adding some elements
245       */
246      public void testAddAll3() {
247 +        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
248 +        Integer[] ints = new Integer[SIZE];
249 +        for (int i = 0; i < SIZE - 1; ++i)
250 +            ints[i] = new Integer(i);
251          try {
239 –            PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
240 –            Integer[] ints = new Integer[SIZE];
241 –            for (int i = 0; i < SIZE-1; ++i)
242 –                ints[i] = new Integer(i);
252              q.addAll(Arrays.asList(ints));
253              shouldThrow();
254          } catch (NullPointerException success) {}
# Line 251 | Line 260 | public class PriorityBlockingQueueTest e
260      public void testAddAll5() {
261          Integer[] empty = new Integer[0];
262          Integer[] ints = new Integer[SIZE];
263 <        for (int i = SIZE-1; i >= 0; --i)
263 >        for (int i = SIZE - 1; i >= 0; --i)
264              ints[i] = new Integer(i);
265          PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
266          assertFalse(q.addAll(Arrays.asList(empty)));
# Line 266 | Line 275 | public class PriorityBlockingQueueTest e
275      public void testPut() {
276          PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
277          for (int i = 0; i < SIZE; ++i) {
278 <            Integer I = new Integer(i);
279 <            q.put(I);
280 <            assertTrue(q.contains(I));
278 >            Integer x = new Integer(i);
279 >            q.put(x);
280 >            assertTrue(q.contains(x));
281          }
282          assertEquals(SIZE, q.size());
283      }
# Line 324 | Line 333 | public class PriorityBlockingQueueTest e
333          final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
334          Thread t = newStartedThread(new CheckedRunnable() {
335              public void realRun() throws InterruptedException {
336 <                for (int i = 0; i < SIZE; ++i) {
328 <                    assertEquals(i, q.take());
329 <                }
336 >                for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
337  
338                  Thread.currentThread().interrupt();
339                  try {
# Line 344 | Line 351 | public class PriorityBlockingQueueTest e
351              }});
352  
353          await(pleaseInterrupt);
354 <        assertThreadStaysAlive(t);
354 >        assertThreadBlocks(t, Thread.State.WAITING);
355          t.interrupt();
356          awaitTermination(t);
357      }
# Line 396 | Line 403 | public class PriorityBlockingQueueTest e
403          final CountDownLatch aboutToWait = new CountDownLatch(1);
404          Thread t = newStartedThread(new CheckedRunnable() {
405              public void realRun() throws InterruptedException {
406 +                long startTime = System.nanoTime();
407                  for (int i = 0; i < SIZE; ++i) {
400 –                    long t0 = System.nanoTime();
408                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
402 –                    assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
409                  }
404 –                long t0 = System.nanoTime();
410                  aboutToWait.countDown();
411                  try {
412                      q.poll(LONG_DELAY_MS, MILLISECONDS);
413                      shouldThrow();
414                  } catch (InterruptedException success) {
415 <                    assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
415 >                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
416                  }
417              }});
418  
419 <        aboutToWait.await();
420 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
419 >        await(aboutToWait);
420 >        assertThreadBlocks(t, Thread.State.TIMED_WAITING);
421          t.interrupt();
422 <        awaitTermination(t, MEDIUM_DELAY_MS);
422 >        awaitTermination(t);
423      }
424  
425      /**
# Line 515 | Line 520 | public class PriorityBlockingQueueTest e
520                  assertTrue(changed);
521  
522              assertTrue(q.containsAll(p));
523 <            assertEquals(SIZE-i, q.size());
523 >            assertEquals(SIZE - i, q.size());
524              p.remove();
525          }
526      }
# Line 528 | Line 533 | public class PriorityBlockingQueueTest e
533              PriorityBlockingQueue q = populatedQueue(SIZE);
534              PriorityBlockingQueue p = populatedQueue(i);
535              assertTrue(q.removeAll(p));
536 <            assertEquals(SIZE-i, q.size());
536 >            assertEquals(SIZE - i, q.size());
537              for (int j = 0; j < i; ++j) {
538 <                Integer I = (Integer)(p.remove());
539 <                assertFalse(q.contains(I));
538 >                Integer x = (Integer)(p.remove());
539 >                assertFalse(q.contains(x));
540              }
541          }
542      }
# Line 576 | Line 581 | public class PriorityBlockingQueueTest e
581       */
582      public void testIterator() {
583          PriorityBlockingQueue q = populatedQueue(SIZE);
579 –        int i = 0;
584          Iterator it = q.iterator();
585 <        while (it.hasNext()) {
585 >        int i;
586 >        for (i = 0; it.hasNext(); i++)
587              assertTrue(q.contains(it.next()));
583 –            ++i;
584 –        }
588          assertEquals(i, SIZE);
589 +        assertIteratorExhausted(it);
590 +    }
591 +
592 +    /**
593 +     * iterator of empty collection has no elements
594 +     */
595 +    public void testEmptyIterator() {
596 +        assertIteratorExhausted(new PriorityBlockingQueue().iterator());
597      }
598  
599      /**
# Line 621 | Line 632 | public class PriorityBlockingQueueTest e
632      public void testPollInExecutor() {
633          final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
634          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
635 <        ExecutorService executor = Executors.newFixedThreadPool(2);
636 <        executor.execute(new CheckedRunnable() {
637 <            public void realRun() throws InterruptedException {
638 <                assertNull(q.poll());
639 <                threadsStarted.await();
640 <                assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
641 <                checkEmpty(q);
642 <            }});
643 <
644 <        executor.execute(new CheckedRunnable() {
645 <            public void realRun() throws InterruptedException {
646 <                threadsStarted.await();
647 <                q.put(one);
648 <            }});
649 <
650 <        joinPool(executor);
635 >        final ExecutorService executor = Executors.newFixedThreadPool(2);
636 >        try (PoolCleaner cleaner = cleaner(executor)) {
637 >            executor.execute(new CheckedRunnable() {
638 >                public void realRun() throws InterruptedException {
639 >                    assertNull(q.poll());
640 >                    threadsStarted.await();
641 >                    assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
642 >                    checkEmpty(q);
643 >                }});
644 >
645 >            executor.execute(new CheckedRunnable() {
646 >                public void realRun() throws InterruptedException {
647 >                    threadsStarted.await();
648 >                    q.put(one);
649 >                }});
650 >        }
651      }
652  
653      /**
# Line 686 | Line 697 | public class PriorityBlockingQueueTest e
697          final PriorityBlockingQueue q = populatedQueue(SIZE);
698          Thread t = new Thread(new CheckedRunnable() {
699              public void realRun() {
700 <                q.put(new Integer(SIZE+1));
700 >                q.put(new Integer(SIZE + 1));
701              }});
702  
703          t.start();
# Line 703 | Line 714 | public class PriorityBlockingQueueTest e
714       * drainTo(c, n) empties first min(n, size) elements of queue into c
715       */
716      public void testDrainToN() {
717 <        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE*2);
717 >        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE * 2);
718          for (int i = 0; i < SIZE + 2; ++i) {
719              for (int j = 0; j < SIZE; j++)
720                  assertTrue(q.offer(new Integer(j)));
# Line 711 | Line 722 | public class PriorityBlockingQueueTest e
722              q.drainTo(l, i);
723              int k = (i < SIZE) ? i : SIZE;
724              assertEquals(k, l.size());
725 <            assertEquals(SIZE-k, q.size());
725 >            assertEquals(SIZE - k, q.size());
726              for (int j = 0; j < k; ++j)
727                  assertEquals(l.get(j), new Integer(j));
728 <            while (q.poll() != null) ;
728 >            do {} while (q.poll() != null);
729          }
730      }
731  

Diff Legend

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