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.85 by dl, Tue Jan 26 13:33:06 2021 UTC vs.
Revision 1.87 by jsr166, Wed Jan 27 02:55:18 2021 UTC

# Line 88 | Line 88 | public class PriorityBlockingQueueTest e
88       * Items 0 ... n - 1.
89       */
90      private static PriorityBlockingQueue<Item> populatedQueue(int n) {
91 <        PriorityBlockingQueue<Item> q =
92 <            new PriorityBlockingQueue<Item>(n);
91 >        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<>(n);
92          assertTrue(q.isEmpty());
93          for (int i = n - 1; i >= 0; i -= 2)
94              mustOffer(q, i);
# Line 158 | Line 157 | public class PriorityBlockingQueueTest e
157       */
158      public void testConstructor6() {
159          Item[] items = defaultItems;
160 <        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(Arrays.asList(items));
160 >        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<>(Arrays.asList(items));
161          for (int i = 0; i < SIZE; ++i)
162              mustEqual(items[i], q.poll());
163      }
# Line 169 | Line 168 | public class PriorityBlockingQueueTest e
168      public void testConstructor7() {
169          MyReverseComparator cmp = new MyReverseComparator();
170          @SuppressWarnings("unchecked")
171 <        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(SIZE, cmp);
171 >        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<>(SIZE, cmp);
172          mustEqual(cmp, q.comparator());
173          Item[] items = defaultItems;
174          q.addAll(Arrays.asList(items));
# Line 181 | Line 180 | public class PriorityBlockingQueueTest e
180       * isEmpty is true before add, false after
181       */
182      public void testEmpty() {
183 <        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(2);
183 >        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<>(2);
184          assertTrue(q.isEmpty());
185          mustEqual(Integer.MAX_VALUE, q.remainingCapacity());
186          q.add(one);
# Line 213 | Line 212 | public class PriorityBlockingQueueTest e
212       * Offer of comparable element succeeds
213       */
214      public void testOffer() {
215 <        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(1);
215 >        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<>(1);
216          assertTrue(q.offer(zero));
217          assertTrue(q.offer(one));
218      }
# Line 222 | Line 221 | public class PriorityBlockingQueueTest e
221       * Offer of non-Comparable throws CCE
222       */
223      public void testOfferNonComparable() {
224 <        PriorityBlockingQueue<Object> q = new PriorityBlockingQueue<Object>(1);
224 >        PriorityBlockingQueue<Object> q = new PriorityBlockingQueue<>(1);
225          try {
226              q.offer(new Object());
227              shouldThrow();
# Line 237 | Line 236 | public class PriorityBlockingQueueTest e
236       * add of comparable succeeds
237       */
238      public void testAdd() {
239 <        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(SIZE);
239 >        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<>(SIZE);
240          for (int i = 0; i < SIZE; ++i) {
241              mustEqual(i, q.size());
242              mustAdd(q, i);
# Line 260 | Line 259 | public class PriorityBlockingQueueTest e
259       * possibly adding some elements
260       */
261      public void testAddAll3() {
262 <        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(SIZE);
262 >        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<>(SIZE);
263          Item[] items = new Item[2];
264          items[0] = zero;
265          try {
# Line 275 | Line 274 | public class PriorityBlockingQueueTest e
274      public void testAddAll5() {
275          Item[] empty = new Item[0];
276          Item[] items = defaultItems;
277 <        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(SIZE);
277 >        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<>(SIZE);
278          assertFalse(q.addAll(Arrays.asList(empty)));
279          assertTrue(q.addAll(Arrays.asList(items)));
280          for (int i = 0; i < SIZE; ++i)
# Line 286 | Line 285 | public class PriorityBlockingQueueTest e
285       * all elements successfully put are contained
286       */
287      public void testPut() {
288 <        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(SIZE);
288 >        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<>(SIZE);
289          for (int i = 0; i < SIZE; ++i) {
290              Item x = itemFor(i);
291              q.put(x);
# Line 299 | Line 298 | public class PriorityBlockingQueueTest e
298       * put doesn't block waiting for take
299       */
300      public void testPutWithTake() throws InterruptedException {
301 <        final PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(2);
301 >        final PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<>(2);
302          final int size = 4;
303          Thread t = newStartedThread(new CheckedRunnable() {
304              public void realRun() {
# Line 316 | Line 315 | public class PriorityBlockingQueueTest e
315       * Queue is unbounded, so timed offer never times out
316       */
317      public void testTimedOffer() {
318 <        final PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(2);
318 >        final PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<>(2);
319          Thread t = newStartedThread(new CheckedRunnable() {
320              public void realRun() {
321                  q.put(one);
# Line 515 | Line 514 | public class PriorityBlockingQueueTest e
514       */
515      public void testContainsAll() {
516          PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
517 <        PriorityBlockingQueue<Item> p = new PriorityBlockingQueue<Item>(SIZE);
517 >        PriorityBlockingQueue<Item> p = new PriorityBlockingQueue<>(SIZE);
518          for (int i = 0; i < SIZE; ++i) {
519              assertTrue(q.containsAll(p));
520              assertFalse(p.containsAll(q));
# Line 589 | Line 588 | public class PriorityBlockingQueueTest e
588      /**
589       * toArray(incompatible array type) throws ArrayStoreException
590       */
591 <    public void testToArray1_BadArg() {
591 >    @SuppressWarnings("CollectionToArraySafeParameter")
592 >    public void testToArray_incompatibleArrayType() {
593          PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
594          try {
595              q.toArray(new String[10]);
# Line 614 | Line 614 | public class PriorityBlockingQueueTest e
614       * iterator of empty collection has no elements
615       */
616      public void testEmptyIterator() {
617 <        assertIteratorExhausted(new PriorityBlockingQueue<Item>().iterator());
617 >        assertIteratorExhausted(new PriorityBlockingQueue<>().iterator());
618      }
619  
620      /**
621       * iterator.remove removes current element
622       */
623      public void testIteratorRemove() {
624 <        final PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(3);
624 >        final PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<>(3);
625          q.add(two);
626          q.add(one);
627          q.add(three);
# Line 651 | Line 651 | public class PriorityBlockingQueueTest e
651       * timed poll transfers elements across Executor tasks
652       */
653      public void testPollInExecutor() {
654 <        final PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(2);
654 >        final PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<>(2);
655          final CheckedBarrier threadsStarted = new CheckedBarrier(2);
656          final ExecutorService executor = Executors.newFixedThreadPool(2);
657          try (PoolCleaner cleaner = cleaner(executor)) {
# Line 692 | Line 692 | public class PriorityBlockingQueueTest e
692       */
693      public void testDrainTo() {
694          PriorityBlockingQueue<Item> q = populatedQueue(SIZE);
695 <        ArrayList<Item> l = new ArrayList<Item>();
695 >        ArrayList<Item> l = new ArrayList<>();
696          q.drainTo(l);
697          mustEqual(0, q.size());
698          mustEqual(SIZE, l.size());
# Line 721 | Line 721 | public class PriorityBlockingQueueTest e
721              }});
722  
723          t.start();
724 <        ArrayList<Item> l = new ArrayList<Item>();
724 >        ArrayList<Item> l = new ArrayList<>();
725          q.drainTo(l);
726          assertTrue(l.size() >= SIZE);
727          for (int i = 0; i < SIZE; ++i)
# Line 734 | Line 734 | public class PriorityBlockingQueueTest e
734       * drainTo(c, n) empties first min(n, size) elements of queue into c
735       */
736      public void testDrainToN() {
737 <        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<Item>(SIZE * 2);
737 >        PriorityBlockingQueue<Item> q = new PriorityBlockingQueue<>(SIZE * 2);
738          for (int i = 0; i < SIZE + 2; ++i) {
739              for (int j = 0; j < SIZE; j++)
740                  mustOffer(q, j);
741 <            ArrayList<Item> l = new ArrayList<Item>();
741 >            ArrayList<Item> l = new ArrayList<>();
742              q.drainTo(l, i);
743              int k = (i < SIZE) ? i : SIZE;
744              mustEqual(k, l.size());
# Line 754 | Line 754 | public class PriorityBlockingQueueTest e
754       */
755      public void testNeverContainsNull() {
756          Collection<?>[] qs = {
757 <            new PriorityBlockingQueue<Object>(),
757 >            new PriorityBlockingQueue<>(),
758              populatedQueue(2),
759          };
760  

Diff Legend

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