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.69 by jsr166, Sun Oct 16 20:44:18 2016 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() {
# Line 47 | Line 47 | public class PriorityBlockingQueueTest e
47                              new InitialCapacity().testSuite());
48      }
49  
50 –    private static final int NOCAP = Integer.MAX_VALUE;
51 –
50      /** Sample Comparator */
51      static class MyReverseComparator implements Comparator {
52          public int compare(Object x, Object y) {
# Line 58 | Line 56 | public class PriorityBlockingQueueTest e
56  
57      /**
58       * Returns a new queue of given size containing consecutive
59 <     * Integers 0 ... n.
59 >     * Integers 0 ... n - 1.
60       */
61      private PriorityBlockingQueue<Integer> populatedQueue(int n) {
62          PriorityBlockingQueue<Integer> q =
63              new PriorityBlockingQueue<Integer>(n);
64          assertTrue(q.isEmpty());
65 <        for (int i = n-1; i >= 0; i-=2)
65 >        for (int i = n - 1; i >= 0; i -= 2)
66              assertTrue(q.offer(new Integer(i)));
67 <        for (int i = (n & 1); i < n; i+=2)
67 >        for (int i = (n & 1); i < n; i += 2)
68              assertTrue(q.offer(new Integer(i)));
69          assertFalse(q.isEmpty());
70 <        assertEquals(NOCAP, q.remainingCapacity());
70 >        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
71          assertEquals(n, q.size());
72 +        assertEquals((Integer) 0, q.peek());
73          return q;
74      }
75  
# Line 78 | Line 77 | public class PriorityBlockingQueueTest e
77       * A new queue has unbounded capacity
78       */
79      public void testConstructor1() {
80 <        assertEquals(NOCAP, new PriorityBlockingQueue(SIZE).remainingCapacity());
80 >        assertEquals(Integer.MAX_VALUE,
81 >                     new PriorityBlockingQueue(SIZE).remainingCapacity());
82      }
83  
84      /**
# Line 117 | Line 117 | public class PriorityBlockingQueueTest e
117       */
118      public void testConstructor5() {
119          Integer[] ints = new Integer[SIZE];
120 <        for (int i = 0; i < SIZE-1; ++i)
120 >        for (int i = 0; i < SIZE - 1; ++i)
121              ints[i] = i;
122          Collection<Integer> elements = Arrays.asList(ints);
123          try {
# Line 149 | Line 149 | public class PriorityBlockingQueueTest e
149          for (int i = 0; i < SIZE; ++i)
150              ints[i] = new Integer(i);
151          q.addAll(Arrays.asList(ints));
152 <        for (int i = SIZE-1; i >= 0; --i)
152 >        for (int i = SIZE - 1; i >= 0; --i)
153              assertEquals(ints[i], q.poll());
154      }
155  
# Line 159 | Line 159 | public class PriorityBlockingQueueTest e
159      public void testEmpty() {
160          PriorityBlockingQueue q = new PriorityBlockingQueue(2);
161          assertTrue(q.isEmpty());
162 <        assertEquals(NOCAP, q.remainingCapacity());
162 >        assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
163          q.add(one);
164          assertFalse(q.isEmpty());
165          q.add(two);
# Line 169 | Line 169 | public class PriorityBlockingQueueTest e
169      }
170  
171      /**
172 <     * remainingCapacity does not change when elements added or removed,
173 <     * but size does
172 >     * remainingCapacity() always returns Integer.MAX_VALUE
173       */
174      public void testRemainingCapacity() {
175 <        PriorityBlockingQueue q = populatedQueue(SIZE);
175 >        BlockingQueue q = populatedQueue(SIZE);
176          for (int i = 0; i < SIZE; ++i) {
177 <            assertEquals(NOCAP, q.remainingCapacity());
178 <            assertEquals(SIZE-i, q.size());
179 <            q.remove();
177 >            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
178 >            assertEquals(SIZE - i, q.size());
179 >            assertEquals(i, q.remove());
180          }
181          for (int i = 0; i < SIZE; ++i) {
182 <            assertEquals(NOCAP, q.remainingCapacity());
182 >            assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
183              assertEquals(i, q.size());
184 <            q.add(new Integer(i));
184 >            assertTrue(q.add(i));
185          }
186      }
187  
# Line 199 | Line 198 | public class PriorityBlockingQueueTest e
198       * Offer of non-Comparable throws CCE
199       */
200      public void testOfferNonComparable() {
201 +        PriorityBlockingQueue q = new PriorityBlockingQueue(1);
202          try {
203 –            PriorityBlockingQueue q = new PriorityBlockingQueue(1);
204 –            q.offer(new Object());
205 –            q.offer(new Object());
203              q.offer(new Object());
204              shouldThrow();
205 <        } catch (ClassCastException success) {}
205 >        } catch (ClassCastException success) {
206 >            assertTrue(q.isEmpty());
207 >            assertEquals(0, q.size());
208 >            assertNull(q.poll());
209 >        }
210      }
211  
212      /**
# Line 223 | Line 224 | public class PriorityBlockingQueueTest e
224       * addAll(this) throws IAE
225       */
226      public void testAddAllSelf() {
227 +        PriorityBlockingQueue q = populatedQueue(SIZE);
228          try {
227 –            PriorityBlockingQueue q = populatedQueue(SIZE);
229              q.addAll(q);
230              shouldThrow();
231          } catch (IllegalArgumentException success) {}
# Line 235 | Line 236 | public class PriorityBlockingQueueTest e
236       * possibly adding some elements
237       */
238      public void testAddAll3() {
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);
243          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);
244              q.addAll(Arrays.asList(ints));
245              shouldThrow();
246          } catch (NullPointerException success) {}
# Line 251 | Line 252 | public class PriorityBlockingQueueTest e
252      public void testAddAll5() {
253          Integer[] empty = new Integer[0];
254          Integer[] ints = new Integer[SIZE];
255 <        for (int i = SIZE-1; i >= 0; --i)
255 >        for (int i = SIZE - 1; i >= 0; --i)
256              ints[i] = new Integer(i);
257          PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
258          assertFalse(q.addAll(Arrays.asList(empty)));
# Line 266 | Line 267 | public class PriorityBlockingQueueTest e
267      public void testPut() {
268          PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
269          for (int i = 0; i < SIZE; ++i) {
270 <            Integer I = new Integer(i);
271 <            q.put(I);
272 <            assertTrue(q.contains(I));
270 >            Integer x = new Integer(i);
271 >            q.put(x);
272 >            assertTrue(q.contains(x));
273          }
274          assertEquals(SIZE, q.size());
275      }
# Line 396 | Line 397 | public class PriorityBlockingQueueTest e
397          final CountDownLatch aboutToWait = new CountDownLatch(1);
398          Thread t = newStartedThread(new CheckedRunnable() {
399              public void realRun() throws InterruptedException {
400 +                long startTime = System.nanoTime();
401                  for (int i = 0; i < SIZE; ++i) {
400 –                    long t0 = System.nanoTime();
402                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
402 –                    assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
403                  }
404 –                long t0 = System.nanoTime();
404                  aboutToWait.countDown();
405                  try {
406                      q.poll(LONG_DELAY_MS, MILLISECONDS);
407                      shouldThrow();
408                  } catch (InterruptedException success) {
409 <                    assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
409 >                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
410                  }
411              }});
412  
413          aboutToWait.await();
414 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
414 >        waitForThreadToEnterWaitState(t);
415          t.interrupt();
416 <        awaitTermination(t, MEDIUM_DELAY_MS);
416 >        awaitTermination(t);
417      }
418  
419      /**
# Line 515 | Line 514 | public class PriorityBlockingQueueTest e
514                  assertTrue(changed);
515  
516              assertTrue(q.containsAll(p));
517 <            assertEquals(SIZE-i, q.size());
517 >            assertEquals(SIZE - i, q.size());
518              p.remove();
519          }
520      }
# Line 528 | Line 527 | public class PriorityBlockingQueueTest e
527              PriorityBlockingQueue q = populatedQueue(SIZE);
528              PriorityBlockingQueue p = populatedQueue(i);
529              assertTrue(q.removeAll(p));
530 <            assertEquals(SIZE-i, q.size());
530 >            assertEquals(SIZE - i, q.size());
531              for (int j = 0; j < i; ++j) {
532 <                Integer I = (Integer)(p.remove());
533 <                assertFalse(q.contains(I));
532 >                Integer x = (Integer)(p.remove());
533 >                assertFalse(q.contains(x));
534              }
535          }
536      }
# Line 576 | Line 575 | public class PriorityBlockingQueueTest e
575       */
576      public void testIterator() {
577          PriorityBlockingQueue q = populatedQueue(SIZE);
579 –        int i = 0;
578          Iterator it = q.iterator();
579 <        while (it.hasNext()) {
579 >        int i;
580 >        for (i = 0; it.hasNext(); i++)
581              assertTrue(q.contains(it.next()));
583 –            ++i;
584 –        }
582          assertEquals(i, SIZE);
583 +        assertIteratorExhausted(it);
584 +    }
585 +
586 +    /**
587 +     * iterator of empty collection has no elements
588 +     */
589 +    public void testEmptyIterator() {
590 +        assertIteratorExhausted(new PriorityBlockingQueue().iterator());
591      }
592  
593      /**
# Line 621 | Line 626 | public class PriorityBlockingQueueTest e
626      public void testPollInExecutor() {
627          final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
628          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
629 <        ExecutorService executor = Executors.newFixedThreadPool(2);
630 <        executor.execute(new CheckedRunnable() {
631 <            public void realRun() throws InterruptedException {
632 <                assertNull(q.poll());
633 <                threadsStarted.await();
634 <                assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
635 <                checkEmpty(q);
636 <            }});
637 <
638 <        executor.execute(new CheckedRunnable() {
639 <            public void realRun() throws InterruptedException {
640 <                threadsStarted.await();
641 <                q.put(one);
642 <            }});
643 <
644 <        joinPool(executor);
629 >        final ExecutorService executor = Executors.newFixedThreadPool(2);
630 >        try (PoolCleaner cleaner = cleaner(executor)) {
631 >            executor.execute(new CheckedRunnable() {
632 >                public void realRun() throws InterruptedException {
633 >                    assertNull(q.poll());
634 >                    threadsStarted.await();
635 >                    assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
636 >                    checkEmpty(q);
637 >                }});
638 >
639 >            executor.execute(new CheckedRunnable() {
640 >                public void realRun() throws InterruptedException {
641 >                    threadsStarted.await();
642 >                    q.put(one);
643 >                }});
644 >        }
645      }
646  
647      /**
# Line 686 | Line 691 | public class PriorityBlockingQueueTest e
691          final PriorityBlockingQueue q = populatedQueue(SIZE);
692          Thread t = new Thread(new CheckedRunnable() {
693              public void realRun() {
694 <                q.put(new Integer(SIZE+1));
694 >                q.put(new Integer(SIZE + 1));
695              }});
696  
697          t.start();
# Line 703 | Line 708 | public class PriorityBlockingQueueTest e
708       * drainTo(c, n) empties first min(n, size) elements of queue into c
709       */
710      public void testDrainToN() {
711 <        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE*2);
711 >        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE * 2);
712          for (int i = 0; i < SIZE + 2; ++i) {
713              for (int j = 0; j < SIZE; j++)
714                  assertTrue(q.offer(new Integer(j)));
# Line 711 | Line 716 | public class PriorityBlockingQueueTest e
716              q.drainTo(l, i);
717              int k = (i < SIZE) ? i : SIZE;
718              assertEquals(k, l.size());
719 <            assertEquals(SIZE-k, q.size());
719 >            assertEquals(SIZE - k, q.size());
720              for (int j = 0; j < k; ++j)
721                  assertEquals(l.get(j), new Integer(j));
722 <            while (q.poll() != null) ;
722 >            do {} while (q.poll() != null);
723          }
724      }
725  

Diff Legend

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