/[cvs]/jsr166/src/test/tck/ArrayBlockingQueueTest.java
ViewVC logotype

Contents of /jsr166/src/test/tck/ArrayBlockingQueueTest.java

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.89 - (show annotations)
Sun May 14 04:02:06 2017 UTC (2 years, 3 months ago) by jsr166
Branch: MAIN
Changes since 1.88: +7 -0 lines
improve testPutWithTake

1 /*
2 * Written by Doug Lea with assistance from members of JCP JSR-166
3 * Expert Group and released to the public domain, as explained at
4 * http://creativecommons.org/publicdomain/zero/1.0/
5 * Other contributors include Andrew Wright, Jeffrey Hayes,
6 * Pat Fisher, Mike Judd.
7 */
8
9 import static java.util.concurrent.TimeUnit.MILLISECONDS;
10
11 import java.util.ArrayList;
12 import java.util.Arrays;
13 import java.util.Collection;
14 import java.util.Collections;
15 import java.util.Iterator;
16 import java.util.NoSuchElementException;
17 import java.util.Queue;
18 import java.util.concurrent.ArrayBlockingQueue;
19 import java.util.concurrent.BlockingQueue;
20 import java.util.concurrent.CountDownLatch;
21 import java.util.concurrent.Executors;
22 import java.util.concurrent.ExecutorService;
23 import java.util.concurrent.ThreadLocalRandom;
24
25 import junit.framework.Test;
26
27 public class ArrayBlockingQueueTest extends JSR166TestCase {
28
29 public static void main(String[] args) {
30 main(suite(), args);
31 }
32
33 public static Test suite() {
34 class Implementation implements CollectionImplementation {
35 public Class<?> klazz() { return ArrayBlockingQueue.class; }
36 public Collection emptyCollection() {
37 boolean fair = ThreadLocalRandom.current().nextBoolean();
38 return populatedQueue(0, SIZE, 2 * SIZE, fair);
39 }
40 public Object makeElement(int i) { return i; }
41 public boolean isConcurrent() { return true; }
42 public boolean permitsNulls() { return false; }
43 }
44
45 return newTestSuite(
46 ArrayBlockingQueueTest.class,
47 new Fair().testSuite(),
48 new NonFair().testSuite(),
49 CollectionTest.testSuite(new Implementation()));
50 }
51
52 public static class Fair extends BlockingQueueTest {
53 protected BlockingQueue emptyCollection() {
54 return populatedQueue(0, SIZE, 2 * SIZE, true);
55 }
56 }
57
58 public static class NonFair extends BlockingQueueTest {
59 protected BlockingQueue emptyCollection() {
60 return populatedQueue(0, SIZE, 2 * SIZE, false);
61 }
62 }
63
64 /**
65 * Returns a new queue of given size containing consecutive
66 * Integers 0 ... n - 1.
67 */
68 static ArrayBlockingQueue<Integer> populatedQueue(int n) {
69 return populatedQueue(n, n, n, false);
70 }
71
72 /**
73 * Returns a new queue of given size containing consecutive
74 * Integers 0 ... n - 1, with given capacity range and fairness.
75 */
76 static ArrayBlockingQueue<Integer> populatedQueue(
77 int size, int minCapacity, int maxCapacity, boolean fair) {
78 ThreadLocalRandom rnd = ThreadLocalRandom.current();
79 int capacity = rnd.nextInt(minCapacity, maxCapacity + 1);
80 ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<>(capacity);
81 assertTrue(q.isEmpty());
82 // shuffle circular array elements so they wrap
83 {
84 int n = rnd.nextInt(capacity);
85 for (int i = 0; i < n; i++) q.add(42);
86 for (int i = 0; i < n; i++) q.remove();
87 }
88 for (int i = 0; i < size; i++)
89 assertTrue(q.offer((Integer) i));
90 assertEquals(size == 0, q.isEmpty());
91 assertEquals(capacity - size, q.remainingCapacity());
92 assertEquals(size, q.size());
93 if (size > 0)
94 assertEquals((Integer) 0, q.peek());
95 return q;
96 }
97
98 /**
99 * A new queue has the indicated capacity
100 */
101 public void testConstructor1() {
102 assertEquals(SIZE, new ArrayBlockingQueue(SIZE).remainingCapacity());
103 }
104
105 /**
106 * Constructor throws IAE if capacity argument nonpositive
107 */
108 public void testConstructor_nonPositiveCapacity() {
109 for (int i : new int[] { 0, -1, Integer.MIN_VALUE }) {
110 try {
111 new ArrayBlockingQueue(i);
112 shouldThrow();
113 } catch (IllegalArgumentException success) {}
114 for (boolean fair : new boolean[] { true, false }) {
115 try {
116 new ArrayBlockingQueue(i, fair);
117 shouldThrow();
118 } catch (IllegalArgumentException success) {}
119 }
120 }
121 }
122
123 /**
124 * Initializing from null Collection throws NPE
125 */
126 public void testConstructor_nullCollection() {
127 try {
128 new ArrayBlockingQueue(1, true, null);
129 shouldThrow();
130 } catch (NullPointerException success) {}
131 }
132
133 /**
134 * Initializing from Collection of null elements throws NPE
135 */
136 public void testConstructor4() {
137 Collection<Integer> elements = Arrays.asList(new Integer[SIZE]);
138 try {
139 new ArrayBlockingQueue(SIZE, false, elements);
140 shouldThrow();
141 } catch (NullPointerException success) {}
142 }
143
144 /**
145 * Initializing from Collection with some null elements throws NPE
146 */
147 public void testConstructor5() {
148 Integer[] ints = new Integer[SIZE];
149 for (int i = 0; i < SIZE - 1; ++i)
150 ints[i] = i;
151 Collection<Integer> elements = Arrays.asList(ints);
152 try {
153 new ArrayBlockingQueue(SIZE, false, elements);
154 shouldThrow();
155 } catch (NullPointerException success) {}
156 }
157
158 /**
159 * Initializing from too large collection throws IAE
160 */
161 public void testConstructor_collectionTooLarge() {
162 // just barely fits - succeeds
163 new ArrayBlockingQueue(SIZE, false,
164 Collections.nCopies(SIZE, ""));
165 try {
166 new ArrayBlockingQueue(SIZE - 1, false,
167 Collections.nCopies(SIZE, ""));
168 shouldThrow();
169 } catch (IllegalArgumentException success) {}
170 }
171
172 /**
173 * Queue contains all elements of collection used to initialize
174 */
175 public void testConstructor7() {
176 Integer[] ints = new Integer[SIZE];
177 for (int i = 0; i < SIZE; ++i)
178 ints[i] = i;
179 Collection<Integer> elements = Arrays.asList(ints);
180 ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE, true, elements);
181 for (int i = 0; i < SIZE; ++i)
182 assertEquals(ints[i], q.poll());
183 }
184
185 /**
186 * Queue transitions from empty to full when elements added
187 */
188 public void testEmptyFull() {
189 BlockingQueue q = populatedQueue(0, 2, 2, false);
190 assertTrue(q.isEmpty());
191 assertEquals(2, q.remainingCapacity());
192 q.add(one);
193 assertFalse(q.isEmpty());
194 assertTrue(q.offer(two));
195 assertFalse(q.isEmpty());
196 assertEquals(0, q.remainingCapacity());
197 assertFalse(q.offer(three));
198 }
199
200 /**
201 * remainingCapacity decreases on add, increases on remove
202 */
203 public void testRemainingCapacity() {
204 int size = ThreadLocalRandom.current().nextInt(1, SIZE);
205 BlockingQueue q = populatedQueue(size, size, 2 * size, false);
206 int spare = q.remainingCapacity();
207 int capacity = spare + size;
208 for (int i = 0; i < size; i++) {
209 assertEquals(spare + i, q.remainingCapacity());
210 assertEquals(capacity, q.size() + q.remainingCapacity());
211 assertEquals(i, q.remove());
212 }
213 for (int i = 0; i < size; i++) {
214 assertEquals(capacity - i, q.remainingCapacity());
215 assertEquals(capacity, q.size() + q.remainingCapacity());
216 assertTrue(q.add(i));
217 }
218 }
219
220 /**
221 * Offer succeeds if not full; fails if full
222 */
223 public void testOffer() {
224 ArrayBlockingQueue q = new ArrayBlockingQueue(1);
225 assertTrue(q.offer(zero));
226 assertFalse(q.offer(one));
227 }
228
229 /**
230 * add succeeds if not full; throws ISE if full
231 */
232 public void testAdd() {
233 ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
234 for (int i = 0; i < SIZE; i++) assertTrue(q.add((Integer) i));
235 assertEquals(0, q.remainingCapacity());
236 try {
237 q.add((Integer) SIZE);
238 shouldThrow();
239 } catch (IllegalStateException success) {}
240 }
241
242 /**
243 * addAll(this) throws IAE
244 */
245 public void testAddAllSelf() {
246 ArrayBlockingQueue q = populatedQueue(SIZE);
247 try {
248 q.addAll(q);
249 shouldThrow();
250 } catch (IllegalArgumentException success) {}
251 }
252
253 /**
254 * addAll of a collection with any null elements throws NPE after
255 * possibly adding some elements
256 */
257 public void testAddAll3() {
258 ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
259 Integer[] ints = new Integer[SIZE];
260 for (int i = 0; i < SIZE - 1; ++i)
261 ints[i] = new Integer(i);
262 try {
263 q.addAll(Arrays.asList(ints));
264 shouldThrow();
265 } catch (NullPointerException success) {}
266 }
267
268 /**
269 * addAll throws ISE if not enough room
270 */
271 public void testAddAll_insufficientSpace() {
272 int size = ThreadLocalRandom.current().nextInt(1, SIZE);
273 ArrayBlockingQueue q = populatedQueue(0, size, size, false);
274 // Just fits:
275 q.addAll(populatedQueue(size, size, 2 * size, false));
276 assertEquals(0, q.remainingCapacity());
277 assertEquals(size, q.size());
278 assertEquals(0, q.peek());
279 try {
280 q = populatedQueue(0, size, size, false);
281 q.addAll(Collections.nCopies(size + 1, 42));
282 shouldThrow();
283 } catch (IllegalStateException success) {}
284 }
285
286 /**
287 * Queue contains all elements, in traversal order, of successful addAll
288 */
289 public void testAddAll5() {
290 Integer[] empty = new Integer[0];
291 Integer[] ints = new Integer[SIZE];
292 for (int i = 0; i < SIZE; ++i)
293 ints[i] = new Integer(i);
294 ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
295 assertFalse(q.addAll(Arrays.asList(empty)));
296 assertTrue(q.addAll(Arrays.asList(ints)));
297 for (int i = 0; i < SIZE; ++i)
298 assertEquals(ints[i], q.poll());
299 }
300
301 /**
302 * all elements successfully put are contained
303 */
304 public void testPut() throws InterruptedException {
305 ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
306 for (int i = 0; i < SIZE; ++i) {
307 Integer x = new Integer(i);
308 q.put(x);
309 assertTrue(q.contains(x));
310 }
311 assertEquals(0, q.remainingCapacity());
312 }
313
314 /**
315 * put blocks interruptibly if full
316 */
317 public void testBlockingPut() throws InterruptedException {
318 final ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
319 final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
320 Thread t = newStartedThread(new CheckedRunnable() {
321 public void realRun() throws InterruptedException {
322 for (int i = 0; i < SIZE; ++i)
323 q.put(i);
324 assertEquals(SIZE, q.size());
325 assertEquals(0, q.remainingCapacity());
326
327 Thread.currentThread().interrupt();
328 try {
329 q.put(99);
330 shouldThrow();
331 } catch (InterruptedException success) {}
332 assertFalse(Thread.interrupted());
333
334 pleaseInterrupt.countDown();
335 try {
336 q.put(99);
337 shouldThrow();
338 } catch (InterruptedException success) {}
339 assertFalse(Thread.interrupted());
340 }});
341
342 await(pleaseInterrupt);
343 assertThreadBlocks(t, Thread.State.WAITING);
344 t.interrupt();
345 awaitTermination(t);
346 assertEquals(SIZE, q.size());
347 assertEquals(0, q.remainingCapacity());
348 }
349
350 /**
351 * put blocks interruptibly waiting for take when full
352 */
353 public void testPutWithTake() throws InterruptedException {
354 final int capacity = 2;
355 final ArrayBlockingQueue q = new ArrayBlockingQueue(capacity);
356 final CountDownLatch pleaseTake = new CountDownLatch(1);
357 final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
358 Thread t = newStartedThread(new CheckedRunnable() {
359 public void realRun() throws InterruptedException {
360 for (int i = 0; i < capacity; i++)
361 q.put(i);
362 pleaseTake.countDown();
363 q.put(86);
364
365 Thread.currentThread().interrupt();
366 try {
367 q.put(99);
368 shouldThrow();
369 } catch (InterruptedException success) {}
370 assertFalse(Thread.interrupted());
371
372 pleaseInterrupt.countDown();
373 try {
374 q.put(99);
375 shouldThrow();
376 } catch (InterruptedException success) {}
377 assertFalse(Thread.interrupted());
378 }});
379
380 await(pleaseTake);
381 assertEquals(0, q.remainingCapacity());
382 assertEquals(0, q.take());
383
384 await(pleaseInterrupt);
385 assertThreadBlocks(t, Thread.State.WAITING);
386 t.interrupt();
387 awaitTermination(t);
388 assertEquals(0, q.remainingCapacity());
389 }
390
391 /**
392 * timed offer times out if full and elements not taken
393 */
394 public void testTimedOffer() throws InterruptedException {
395 final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
396 final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
397 Thread t = newStartedThread(new CheckedRunnable() {
398 public void realRun() throws InterruptedException {
399 q.put(new Object());
400 q.put(new Object());
401 long startTime = System.nanoTime();
402 assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
403 assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
404 pleaseInterrupt.countDown();
405 try {
406 q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
407 shouldThrow();
408 } catch (InterruptedException success) {}
409 assertFalse(Thread.interrupted());
410 }});
411
412 await(pleaseInterrupt);
413 assertThreadBlocks(t, Thread.State.TIMED_WAITING);
414 t.interrupt();
415 awaitTermination(t);
416 }
417
418 /**
419 * take retrieves elements in FIFO order
420 */
421 public void testTake() throws InterruptedException {
422 ArrayBlockingQueue q = populatedQueue(SIZE);
423 for (int i = 0; i < SIZE; ++i) {
424 assertEquals(i, q.take());
425 }
426 }
427
428 /**
429 * Take removes existing elements until empty, then blocks interruptibly
430 */
431 public void testBlockingTake() throws InterruptedException {
432 final ArrayBlockingQueue q = populatedQueue(SIZE);
433 final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
434 Thread t = newStartedThread(new CheckedRunnable() {
435 public void realRun() throws InterruptedException {
436 for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
437
438 Thread.currentThread().interrupt();
439 try {
440 q.take();
441 shouldThrow();
442 } catch (InterruptedException success) {}
443 assertFalse(Thread.interrupted());
444
445 pleaseInterrupt.countDown();
446 try {
447 q.take();
448 shouldThrow();
449 } catch (InterruptedException success) {}
450 assertFalse(Thread.interrupted());
451 }});
452
453 await(pleaseInterrupt);
454 assertThreadBlocks(t, Thread.State.WAITING);
455 t.interrupt();
456 awaitTermination(t);
457 }
458
459 /**
460 * poll succeeds unless empty
461 */
462 public void testPoll() {
463 ArrayBlockingQueue q = populatedQueue(SIZE);
464 for (int i = 0; i < SIZE; ++i) {
465 assertEquals(i, q.poll());
466 }
467 assertNull(q.poll());
468 }
469
470 /**
471 * timed poll with zero timeout succeeds when non-empty, else times out
472 */
473 public void testTimedPoll0() throws InterruptedException {
474 ArrayBlockingQueue q = populatedQueue(SIZE);
475 for (int i = 0; i < SIZE; ++i) {
476 assertEquals(i, q.poll(0, MILLISECONDS));
477 }
478 assertNull(q.poll(0, MILLISECONDS));
479 checkEmpty(q);
480 }
481
482 /**
483 * timed poll with nonzero timeout succeeds when non-empty, else times out
484 */
485 public void testTimedPoll() throws InterruptedException {
486 ArrayBlockingQueue q = populatedQueue(SIZE);
487 for (int i = 0; i < SIZE; ++i) {
488 long startTime = System.nanoTime();
489 assertEquals(i, q.poll(LONG_DELAY_MS, MILLISECONDS));
490 assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
491 }
492 long startTime = System.nanoTime();
493 assertNull(q.poll(timeoutMillis(), MILLISECONDS));
494 assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
495 checkEmpty(q);
496 }
497
498 /**
499 * Interrupted timed poll throws InterruptedException instead of
500 * returning timeout status
501 */
502 public void testInterruptedTimedPoll() throws InterruptedException {
503 final BlockingQueue<Integer> q = populatedQueue(SIZE);
504 final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
505 Thread t = newStartedThread(new CheckedRunnable() {
506 public void realRun() throws InterruptedException {
507 long startTime = System.nanoTime();
508 for (int i = 0; i < SIZE; i++)
509 assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
510
511 Thread.currentThread().interrupt();
512 try {
513 q.poll(LONG_DELAY_MS, MILLISECONDS);
514 shouldThrow();
515 } catch (InterruptedException success) {}
516 assertFalse(Thread.interrupted());
517
518 pleaseInterrupt.countDown();
519 try {
520 q.poll(LONG_DELAY_MS, MILLISECONDS);
521 shouldThrow();
522 } catch (InterruptedException success) {}
523 assertFalse(Thread.interrupted());
524
525 assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
526 }});
527
528 await(pleaseInterrupt);
529 assertThreadBlocks(t, Thread.State.TIMED_WAITING);
530 t.interrupt();
531 awaitTermination(t);
532 checkEmpty(q);
533 }
534
535 /**
536 * peek returns next element, or null if empty
537 */
538 public void testPeek() {
539 ArrayBlockingQueue q = populatedQueue(SIZE);
540 for (int i = 0; i < SIZE; ++i) {
541 assertEquals(i, q.peek());
542 assertEquals(i, q.poll());
543 assertTrue(q.peek() == null ||
544 !q.peek().equals(i));
545 }
546 assertNull(q.peek());
547 }
548
549 /**
550 * element returns next element, or throws NSEE if empty
551 */
552 public void testElement() {
553 ArrayBlockingQueue q = populatedQueue(SIZE);
554 for (int i = 0; i < SIZE; ++i) {
555 assertEquals(i, q.element());
556 assertEquals(i, q.poll());
557 }
558 try {
559 q.element();
560 shouldThrow();
561 } catch (NoSuchElementException success) {}
562 }
563
564 /**
565 * remove removes next element, or throws NSEE if empty
566 */
567 public void testRemove() {
568 ArrayBlockingQueue q = populatedQueue(SIZE);
569 for (int i = 0; i < SIZE; ++i) {
570 assertEquals(i, q.remove());
571 }
572 try {
573 q.remove();
574 shouldThrow();
575 } catch (NoSuchElementException success) {}
576 }
577
578 /**
579 * contains(x) reports true when elements added but not yet removed
580 */
581 public void testContains() {
582 int size = ThreadLocalRandom.current().nextInt(1, SIZE);
583 ArrayBlockingQueue q = populatedQueue(size, size, 2 * size, false);
584 assertFalse(q.contains(null));
585 for (int i = 0; i < size; ++i) {
586 assertTrue(q.contains(new Integer(i)));
587 assertEquals(i, q.poll());
588 assertFalse(q.contains(new Integer(i)));
589 }
590 }
591
592 /**
593 * clear removes all elements
594 */
595 public void testClear() {
596 int size = ThreadLocalRandom.current().nextInt(1, 5);
597 ArrayBlockingQueue q = populatedQueue(size, size, 2 * size, false);
598 int capacity = size + q.remainingCapacity();
599 q.clear();
600 assertTrue(q.isEmpty());
601 assertEquals(0, q.size());
602 assertEquals(capacity, q.remainingCapacity());
603 q.add(one);
604 assertFalse(q.isEmpty());
605 assertTrue(q.contains(one));
606 q.clear();
607 assertTrue(q.isEmpty());
608 }
609
610 /**
611 * containsAll(c) is true when c contains a subset of elements
612 */
613 public void testContainsAll() {
614 ArrayBlockingQueue q = populatedQueue(SIZE);
615 ArrayBlockingQueue p = new ArrayBlockingQueue(SIZE);
616 for (int i = 0; i < SIZE; ++i) {
617 assertTrue(q.containsAll(p));
618 assertFalse(p.containsAll(q));
619 p.add(new Integer(i));
620 }
621 assertTrue(p.containsAll(q));
622 }
623
624 /**
625 * retainAll(c) retains only those elements of c and reports true if changed
626 */
627 public void testRetainAll() {
628 ArrayBlockingQueue q = populatedQueue(SIZE);
629 ArrayBlockingQueue p = populatedQueue(SIZE);
630 for (int i = 0; i < SIZE; ++i) {
631 boolean changed = q.retainAll(p);
632 if (i == 0)
633 assertFalse(changed);
634 else
635 assertTrue(changed);
636
637 assertTrue(q.containsAll(p));
638 assertEquals(SIZE - i, q.size());
639 p.remove();
640 }
641 }
642
643 /**
644 * removeAll(c) removes only those elements of c and reports true if changed
645 */
646 public void testRemoveAll() {
647 for (int i = 1; i < SIZE; ++i) {
648 ArrayBlockingQueue q = populatedQueue(SIZE);
649 ArrayBlockingQueue p = populatedQueue(i);
650 assertTrue(q.removeAll(p));
651 assertEquals(SIZE - i, q.size());
652 for (int j = 0; j < i; ++j) {
653 Integer x = (Integer)(p.remove());
654 assertFalse(q.contains(x));
655 }
656 }
657 }
658
659 void checkToArray(ArrayBlockingQueue<Integer> q) {
660 int size = q.size();
661 Object[] a1 = q.toArray();
662 assertEquals(size, a1.length);
663 Integer[] a2 = q.toArray(new Integer[0]);
664 assertEquals(size, a2.length);
665 Integer[] a3 = q.toArray(new Integer[Math.max(0, size - 1)]);
666 assertEquals(size, a3.length);
667 Integer[] a4 = new Integer[size];
668 assertSame(a4, q.toArray(a4));
669 Integer[] a5 = new Integer[size + 1];
670 Arrays.fill(a5, 42);
671 assertSame(a5, q.toArray(a5));
672 Integer[] a6 = new Integer[size + 2];
673 Arrays.fill(a6, 42);
674 assertSame(a6, q.toArray(a6));
675 Object[][] as = { a1, a2, a3, a4, a5, a6 };
676 for (Object[] a : as) {
677 if (a.length > size) assertNull(a[size]);
678 if (a.length > size + 1) assertEquals(42, a[size + 1]);
679 }
680 Iterator it = q.iterator();
681 Integer s = q.peek();
682 for (int i = 0; i < size; i++) {
683 Integer x = (Integer) it.next();
684 assertEquals(s + i, (int) x);
685 for (Object[] a : as)
686 assertSame(a1[i], x);
687 }
688 }
689
690 /**
691 * toArray() and toArray(a) contain all elements in FIFO order
692 */
693 public void testToArray() {
694 final ThreadLocalRandom rnd = ThreadLocalRandom.current();
695 final int size = rnd.nextInt(6);
696 final int capacity = Math.max(1, size + rnd.nextInt(size + 1));
697 ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<>(capacity);
698 for (int i = 0; i < size; i++) {
699 checkToArray(q);
700 q.add(i);
701 }
702 // Provoke wraparound
703 int added = size * 2;
704 for (int i = 0; i < added; i++) {
705 checkToArray(q);
706 assertEquals((Integer) i, q.poll());
707 q.add(size + i);
708 }
709 for (int i = 0; i < size; i++) {
710 checkToArray(q);
711 assertEquals((Integer) (added + i), q.poll());
712 }
713 }
714
715 /**
716 * toArray(incompatible array type) throws ArrayStoreException
717 */
718 public void testToArray_incompatibleArrayType() {
719 ArrayBlockingQueue q = populatedQueue(SIZE);
720 try {
721 q.toArray(new String[10]);
722 shouldThrow();
723 } catch (ArrayStoreException success) {}
724 try {
725 q.toArray(new String[0]);
726 shouldThrow();
727 } catch (ArrayStoreException success) {}
728 }
729
730 /**
731 * iterator iterates through all elements
732 */
733 public void testIterator() throws InterruptedException {
734 ArrayBlockingQueue q = populatedQueue(SIZE);
735 Iterator it = q.iterator();
736 int i;
737 for (i = 0; it.hasNext(); i++)
738 assertTrue(q.contains(it.next()));
739 assertEquals(i, SIZE);
740 assertIteratorExhausted(it);
741
742 it = q.iterator();
743 for (i = 0; it.hasNext(); i++)
744 assertEquals(it.next(), q.take());
745 assertEquals(i, SIZE);
746 assertIteratorExhausted(it);
747 }
748
749 /**
750 * iterator of empty collection has no elements
751 */
752 public void testEmptyIterator() {
753 assertIteratorExhausted(new ArrayBlockingQueue(SIZE).iterator());
754 }
755
756 /**
757 * iterator.remove removes current element
758 */
759 public void testIteratorRemove() {
760 final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
761 q.add(two);
762 q.add(one);
763 q.add(three);
764
765 Iterator it = q.iterator();
766 it.next();
767 it.remove();
768
769 it = q.iterator();
770 assertSame(it.next(), one);
771 assertSame(it.next(), three);
772 assertFalse(it.hasNext());
773 }
774
775 /**
776 * iterator ordering is FIFO
777 */
778 public void testIteratorOrdering() {
779 final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
780 q.add(one);
781 q.add(two);
782 q.add(three);
783
784 assertEquals("queue should be full", 0, q.remainingCapacity());
785
786 int k = 0;
787 for (Iterator it = q.iterator(); it.hasNext();) {
788 assertEquals(++k, it.next());
789 }
790 assertEquals(3, k);
791 }
792
793 /**
794 * Modifications do not cause iterators to fail
795 */
796 public void testWeaklyConsistentIteration() {
797 final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
798 q.add(one);
799 q.add(two);
800 q.add(three);
801 for (Iterator it = q.iterator(); it.hasNext();) {
802 q.remove();
803 it.next();
804 }
805 assertEquals(0, q.size());
806 }
807
808 /**
809 * toString contains toStrings of elements
810 */
811 public void testToString() {
812 ArrayBlockingQueue q = populatedQueue(SIZE);
813 String s = q.toString();
814 for (int i = 0; i < SIZE; ++i) {
815 assertTrue(s.contains(String.valueOf(i)));
816 }
817 }
818
819 /**
820 * offer transfers elements across Executor tasks
821 */
822 public void testOfferInExecutor() {
823 final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
824 q.add(one);
825 q.add(two);
826 final CheckedBarrier threadsStarted = new CheckedBarrier(2);
827 final ExecutorService executor = Executors.newFixedThreadPool(2);
828 try (PoolCleaner cleaner = cleaner(executor)) {
829 executor.execute(new CheckedRunnable() {
830 public void realRun() throws InterruptedException {
831 assertFalse(q.offer(three));
832 threadsStarted.await();
833 assertTrue(q.offer(three, LONG_DELAY_MS, MILLISECONDS));
834 assertEquals(0, q.remainingCapacity());
835 }});
836
837 executor.execute(new CheckedRunnable() {
838 public void realRun() throws InterruptedException {
839 threadsStarted.await();
840 assertEquals(0, q.remainingCapacity());
841 assertSame(one, q.take());
842 }});
843 }
844 }
845
846 /**
847 * timed poll retrieves elements across Executor threads
848 */
849 public void testPollInExecutor() {
850 final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
851 final CheckedBarrier threadsStarted = new CheckedBarrier(2);
852 final ExecutorService executor = Executors.newFixedThreadPool(2);
853 try (PoolCleaner cleaner = cleaner(executor)) {
854 executor.execute(new CheckedRunnable() {
855 public void realRun() throws InterruptedException {
856 assertNull(q.poll());
857 threadsStarted.await();
858 assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
859 checkEmpty(q);
860 }});
861
862 executor.execute(new CheckedRunnable() {
863 public void realRun() throws InterruptedException {
864 threadsStarted.await();
865 q.put(one);
866 }});
867 }
868 }
869
870 /**
871 * A deserialized serialized queue has same elements in same order
872 */
873 public void testSerialization() throws Exception {
874 Queue x = populatedQueue(SIZE);
875 Queue y = serialClone(x);
876
877 assertNotSame(x, y);
878 assertEquals(x.size(), y.size());
879 assertEquals(x.toString(), y.toString());
880 assertTrue(Arrays.equals(x.toArray(), y.toArray()));
881 while (!x.isEmpty()) {
882 assertFalse(y.isEmpty());
883 assertEquals(x.remove(), y.remove());
884 }
885 assertTrue(y.isEmpty());
886 }
887
888 /**
889 * drainTo(c) empties queue into another collection c
890 */
891 public void testDrainTo() {
892 ArrayBlockingQueue q = populatedQueue(SIZE);
893 ArrayList l = new ArrayList();
894 q.drainTo(l);
895 assertEquals(0, q.size());
896 assertEquals(SIZE, l.size());
897 for (int i = 0; i < SIZE; ++i)
898 assertEquals(l.get(i), new Integer(i));
899 q.add(zero);
900 q.add(one);
901 assertFalse(q.isEmpty());
902 assertTrue(q.contains(zero));
903 assertTrue(q.contains(one));
904 l.clear();
905 q.drainTo(l);
906 assertEquals(0, q.size());
907 assertEquals(2, l.size());
908 for (int i = 0; i < 2; ++i)
909 assertEquals(l.get(i), new Integer(i));
910 }
911
912 /**
913 * drainTo empties full queue, unblocking a waiting put.
914 */
915 public void testDrainToWithActivePut() throws InterruptedException {
916 final ArrayBlockingQueue q = populatedQueue(SIZE);
917 Thread t = new Thread(new CheckedRunnable() {
918 public void realRun() throws InterruptedException {
919 q.put(new Integer(SIZE + 1));
920 }});
921
922 t.start();
923 ArrayList l = new ArrayList();
924 q.drainTo(l);
925 assertTrue(l.size() >= SIZE);
926 for (int i = 0; i < SIZE; ++i)
927 assertEquals(l.get(i), new Integer(i));
928 t.join();
929 assertTrue(q.size() + l.size() >= SIZE);
930 }
931
932 /**
933 * drainTo(c, n) empties first min(n, size) elements of queue into c
934 */
935 public void testDrainToN() {
936 ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE * 2);
937 for (int i = 0; i < SIZE + 2; ++i) {
938 for (int j = 0; j < SIZE; j++)
939 assertTrue(q.offer(new Integer(j)));
940 ArrayList l = new ArrayList();
941 q.drainTo(l, i);
942 int k = (i < SIZE) ? i : SIZE;
943 assertEquals(k, l.size());
944 assertEquals(SIZE - k, q.size());
945 for (int j = 0; j < k; ++j)
946 assertEquals(l.get(j), new Integer(j));
947 do {} while (q.poll() != null);
948 }
949 }
950
951 /**
952 * remove(null), contains(null) always return false
953 */
954 public void testNeverContainsNull() {
955 Collection<?>[] qs = {
956 populatedQueue(0, 1, 10, false),
957 populatedQueue(2, 2, 10, true),
958 };
959
960 for (Collection<?> q : qs) {
961 assertFalse(q.contains(null));
962 assertFalse(q.remove(null));
963 }
964 }
965 }

dl@cs.oswego.edu
ViewVC Help
Powered by ViewVC 1.1.27