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.62 by jsr166, Fri May 15 18:21:19 2015 UTC vs.
Revision 1.66 by jsr166, Tue Oct 6 00:03:55 2015 UTC

# Line 62 | Line 62 | public class PriorityBlockingQueueTest e
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)
68              assertTrue(q.offer(new Integer(i)));
# Line 116 | Line 116 | public class PriorityBlockingQueueTest e
116       */
117      public void testConstructor5() {
118          Integer[] ints = new Integer[SIZE];
119 <        for (int i = 0; i < SIZE-1; ++i)
119 >        for (int i = 0; i < SIZE - 1; ++i)
120              ints[i] = i;
121          Collection<Integer> elements = Arrays.asList(ints);
122          try {
# Line 148 | Line 148 | public class PriorityBlockingQueueTest e
148          for (int i = 0; i < SIZE; ++i)
149              ints[i] = new Integer(i);
150          q.addAll(Arrays.asList(ints));
151 <        for (int i = SIZE-1; i >= 0; --i)
151 >        for (int i = SIZE - 1; i >= 0; --i)
152              assertEquals(ints[i], q.poll());
153      }
154  
# Line 234 | Line 234 | public class PriorityBlockingQueueTest e
234      public void testAddAll3() {
235          PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
236          Integer[] ints = new Integer[SIZE];
237 <        for (int i = 0; i < SIZE-1; ++i)
237 >        for (int i = 0; i < SIZE - 1; ++i)
238              ints[i] = new Integer(i);
239          try {
240              q.addAll(Arrays.asList(ints));
# Line 248 | Line 248 | public class PriorityBlockingQueueTest e
248      public void testAddAll5() {
249          Integer[] empty = new Integer[0];
250          Integer[] ints = new Integer[SIZE];
251 <        for (int i = SIZE-1; i >= 0; --i)
251 >        for (int i = SIZE - 1; i >= 0; --i)
252              ints[i] = new Integer(i);
253          PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
254          assertFalse(q.addAll(Arrays.asList(empty)));
# Line 393 | Line 393 | public class PriorityBlockingQueueTest e
393          final CountDownLatch aboutToWait = new CountDownLatch(1);
394          Thread t = newStartedThread(new CheckedRunnable() {
395              public void realRun() throws InterruptedException {
396 +                long startTime = System.nanoTime();
397                  for (int i = 0; i < SIZE; ++i) {
397 –                    long t0 = System.nanoTime();
398                      assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
399 –                    assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
399                  }
401 –                long t0 = System.nanoTime();
400                  aboutToWait.countDown();
401                  try {
402                      q.poll(LONG_DELAY_MS, MILLISECONDS);
403                      shouldThrow();
404                  } catch (InterruptedException success) {
405 <                    assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
405 >                    assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
406                  }
407              }});
408  
409          aboutToWait.await();
410 <        waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
410 >        waitForThreadToEnterWaitState(t, LONG_DELAY_MS);
411          t.interrupt();
412 <        awaitTermination(t, MEDIUM_DELAY_MS);
412 >        awaitTermination(t);
413      }
414  
415      /**
# Line 512 | Line 510 | public class PriorityBlockingQueueTest e
510                  assertTrue(changed);
511  
512              assertTrue(q.containsAll(p));
513 <            assertEquals(SIZE-i, q.size());
513 >            assertEquals(SIZE - i, q.size());
514              p.remove();
515          }
516      }
# Line 525 | Line 523 | public class PriorityBlockingQueueTest e
523              PriorityBlockingQueue q = populatedQueue(SIZE);
524              PriorityBlockingQueue p = populatedQueue(i);
525              assertTrue(q.removeAll(p));
526 <            assertEquals(SIZE-i, q.size());
526 >            assertEquals(SIZE - i, q.size());
527              for (int j = 0; j < i; ++j) {
528                  Integer x = (Integer)(p.remove());
529                  assertFalse(q.contains(x));
# Line 624 | Line 622 | public class PriorityBlockingQueueTest e
622      public void testPollInExecutor() {
623          final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
624          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
625 <        ExecutorService executor = Executors.newFixedThreadPool(2);
626 <        executor.execute(new CheckedRunnable() {
627 <            public void realRun() throws InterruptedException {
628 <                assertNull(q.poll());
629 <                threadsStarted.await();
630 <                assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
631 <                checkEmpty(q);
632 <            }});
633 <
634 <        executor.execute(new CheckedRunnable() {
635 <            public void realRun() throws InterruptedException {
636 <                threadsStarted.await();
637 <                q.put(one);
638 <            }});
639 <
640 <        joinPool(executor);
625 >        final ExecutorService executor = Executors.newFixedThreadPool(2);
626 >        try (PoolCleaner cleaner = cleaner(executor)) {
627 >            executor.execute(new CheckedRunnable() {
628 >                public void realRun() throws InterruptedException {
629 >                    assertNull(q.poll());
630 >                    threadsStarted.await();
631 >                    assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
632 >                    checkEmpty(q);
633 >                }});
634 >
635 >            executor.execute(new CheckedRunnable() {
636 >                public void realRun() throws InterruptedException {
637 >                    threadsStarted.await();
638 >                    q.put(one);
639 >                }});
640 >        }
641      }
642  
643      /**
# Line 689 | Line 687 | public class PriorityBlockingQueueTest e
687          final PriorityBlockingQueue q = populatedQueue(SIZE);
688          Thread t = new Thread(new CheckedRunnable() {
689              public void realRun() {
690 <                q.put(new Integer(SIZE+1));
690 >                q.put(new Integer(SIZE + 1));
691              }});
692  
693          t.start();
# Line 706 | Line 704 | public class PriorityBlockingQueueTest e
704       * drainTo(c, n) empties first min(n, size) elements of queue into c
705       */
706      public void testDrainToN() {
707 <        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE*2);
707 >        PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE * 2);
708          for (int i = 0; i < SIZE + 2; ++i) {
709              for (int j = 0; j < SIZE; j++)
710                  assertTrue(q.offer(new Integer(j)));
# Line 714 | Line 712 | public class PriorityBlockingQueueTest e
712              q.drainTo(l, i);
713              int k = (i < SIZE) ? i : SIZE;
714              assertEquals(k, l.size());
715 <            assertEquals(SIZE-k, q.size());
715 >            assertEquals(SIZE - k, q.size());
716              for (int j = 0; j < k; ++j)
717                  assertEquals(l.get(j), new Integer(j));
718              do {} while (q.poll() != null);

Diff Legend

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