/[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.86 - (show annotations)
Sun May 14 00:48:20 2017 UTC (2 years, 3 months ago) by jsr166
Branch: MAIN
Changes since 1.85: +8 -6 lines
improve testInterruptedTimedPoll

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 pleaseInterrupt.countDown();
366 try {
367 q.put(99);
368 shouldThrow();
369 } catch (InterruptedException success) {}
370 assertFalse(Thread.interrupted());
371 }});
372
373 await(pleaseTake);
374 assertEquals(0, q.remainingCapacity());
375 assertEquals(0, q.take());
376
377 await(pleaseInterrupt);
378 assertThreadBlocks(t, Thread.State.WAITING);
379 t.interrupt();
380 awaitTermination(t);
381 assertEquals(0, q.remainingCapacity());
382 }
383
384 /**
385 * timed offer times out if full and elements not taken
386 */
387 public void testTimedOffer() throws InterruptedException {
388 final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
389 final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
390 Thread t = newStartedThread(new CheckedRunnable() {
391 public void realRun() throws InterruptedException {
392 q.put(new Object());
393 q.put(new Object());
394 long startTime = System.nanoTime();
395 assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
396 assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
397 pleaseInterrupt.countDown();
398 try {
399 q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
400 shouldThrow();
401 } catch (InterruptedException success) {}
402 }});
403
404 await(pleaseInterrupt);
405 assertThreadBlocks(t, Thread.State.TIMED_WAITING);
406 t.interrupt();
407 awaitTermination(t);
408 }
409
410 /**
411 * take retrieves elements in FIFO order
412 */
413 public void testTake() throws InterruptedException {
414 ArrayBlockingQueue q = populatedQueue(SIZE);
415 for (int i = 0; i < SIZE; ++i) {
416 assertEquals(i, q.take());
417 }
418 }
419
420 /**
421 * Take removes existing elements until empty, then blocks interruptibly
422 */
423 public void testBlockingTake() throws InterruptedException {
424 final ArrayBlockingQueue q = populatedQueue(SIZE);
425 final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
426 Thread t = newStartedThread(new CheckedRunnable() {
427 public void realRun() throws InterruptedException {
428 for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
429
430 Thread.currentThread().interrupt();
431 try {
432 q.take();
433 shouldThrow();
434 } catch (InterruptedException success) {}
435 assertFalse(Thread.interrupted());
436
437 pleaseInterrupt.countDown();
438 try {
439 q.take();
440 shouldThrow();
441 } catch (InterruptedException success) {}
442 assertFalse(Thread.interrupted());
443 }});
444
445 await(pleaseInterrupt);
446 assertThreadBlocks(t, Thread.State.WAITING);
447 t.interrupt();
448 awaitTermination(t);
449 }
450
451 /**
452 * poll succeeds unless empty
453 */
454 public void testPoll() {
455 ArrayBlockingQueue q = populatedQueue(SIZE);
456 for (int i = 0; i < SIZE; ++i) {
457 assertEquals(i, q.poll());
458 }
459 assertNull(q.poll());
460 }
461
462 /**
463 * timed poll with zero timeout succeeds when non-empty, else times out
464 */
465 public void testTimedPoll0() throws InterruptedException {
466 ArrayBlockingQueue q = populatedQueue(SIZE);
467 for (int i = 0; i < SIZE; ++i) {
468 assertEquals(i, q.poll(0, MILLISECONDS));
469 }
470 assertNull(q.poll(0, MILLISECONDS));
471 checkEmpty(q);
472 }
473
474 /**
475 * timed poll with nonzero timeout succeeds when non-empty, else times out
476 */
477 public void testTimedPoll() throws InterruptedException {
478 ArrayBlockingQueue q = populatedQueue(SIZE);
479 for (int i = 0; i < SIZE; ++i) {
480 long startTime = System.nanoTime();
481 assertEquals(i, q.poll(LONG_DELAY_MS, MILLISECONDS));
482 assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
483 }
484 long startTime = System.nanoTime();
485 assertNull(q.poll(timeoutMillis(), MILLISECONDS));
486 assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
487 checkEmpty(q);
488 }
489
490 /**
491 * Interrupted timed poll throws InterruptedException instead of
492 * returning timeout status
493 */
494 public void testInterruptedTimedPoll() throws InterruptedException {
495 final BlockingQueue<Integer> q = populatedQueue(SIZE);
496 final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
497 Thread t = newStartedThread(new CheckedRunnable() {
498 public void realRun() throws InterruptedException {
499 long startTime = System.nanoTime();
500 for (int i = 0; i < SIZE; ++i) {
501 assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
502 }
503
504 pleaseInterrupt.countDown();
505 try {
506 q.poll(LONG_DELAY_MS, MILLISECONDS);
507 shouldThrow();
508 } catch (InterruptedException success) {}
509 assertFalse(Thread.interrupted());
510
511 assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
512 }});
513
514 await(pleaseInterrupt);
515 assertThreadBlocks(t, Thread.State.TIMED_WAITING);
516 t.interrupt();
517 awaitTermination(t);
518 checkEmpty(q);
519 }
520
521 /**
522 * peek returns next element, or null if empty
523 */
524 public void testPeek() {
525 ArrayBlockingQueue q = populatedQueue(SIZE);
526 for (int i = 0; i < SIZE; ++i) {
527 assertEquals(i, q.peek());
528 assertEquals(i, q.poll());
529 assertTrue(q.peek() == null ||
530 !q.peek().equals(i));
531 }
532 assertNull(q.peek());
533 }
534
535 /**
536 * element returns next element, or throws NSEE if empty
537 */
538 public void testElement() {
539 ArrayBlockingQueue q = populatedQueue(SIZE);
540 for (int i = 0; i < SIZE; ++i) {
541 assertEquals(i, q.element());
542 assertEquals(i, q.poll());
543 }
544 try {
545 q.element();
546 shouldThrow();
547 } catch (NoSuchElementException success) {}
548 }
549
550 /**
551 * remove removes next element, or throws NSEE if empty
552 */
553 public void testRemove() {
554 ArrayBlockingQueue q = populatedQueue(SIZE);
555 for (int i = 0; i < SIZE; ++i) {
556 assertEquals(i, q.remove());
557 }
558 try {
559 q.remove();
560 shouldThrow();
561 } catch (NoSuchElementException success) {}
562 }
563
564 /**
565 * contains(x) reports true when elements added but not yet removed
566 */
567 public void testContains() {
568 int size = ThreadLocalRandom.current().nextInt(1, SIZE);
569 ArrayBlockingQueue q = populatedQueue(size, size, 2 * size, false);
570 assertFalse(q.contains(null));
571 for (int i = 0; i < size; ++i) {
572 assertTrue(q.contains(new Integer(i)));
573 assertEquals(i, q.poll());
574 assertFalse(q.contains(new Integer(i)));
575 }
576 }
577
578 /**
579 * clear removes all elements
580 */
581 public void testClear() {
582 int size = ThreadLocalRandom.current().nextInt(1, 5);
583 ArrayBlockingQueue q = populatedQueue(size, size, 2 * size, false);
584 int capacity = size + q.remainingCapacity();
585 q.clear();
586 assertTrue(q.isEmpty());
587 assertEquals(0, q.size());
588 assertEquals(capacity, q.remainingCapacity());
589 q.add(one);
590 assertFalse(q.isEmpty());
591 assertTrue(q.contains(one));
592 q.clear();
593 assertTrue(q.isEmpty());
594 }
595
596 /**
597 * containsAll(c) is true when c contains a subset of elements
598 */
599 public void testContainsAll() {
600 ArrayBlockingQueue q = populatedQueue(SIZE);
601 ArrayBlockingQueue p = new ArrayBlockingQueue(SIZE);
602 for (int i = 0; i < SIZE; ++i) {
603 assertTrue(q.containsAll(p));
604 assertFalse(p.containsAll(q));
605 p.add(new Integer(i));
606 }
607 assertTrue(p.containsAll(q));
608 }
609
610 /**
611 * retainAll(c) retains only those elements of c and reports true if changed
612 */
613 public void testRetainAll() {
614 ArrayBlockingQueue q = populatedQueue(SIZE);
615 ArrayBlockingQueue p = populatedQueue(SIZE);
616 for (int i = 0; i < SIZE; ++i) {
617 boolean changed = q.retainAll(p);
618 if (i == 0)
619 assertFalse(changed);
620 else
621 assertTrue(changed);
622
623 assertTrue(q.containsAll(p));
624 assertEquals(SIZE - i, q.size());
625 p.remove();
626 }
627 }
628
629 /**
630 * removeAll(c) removes only those elements of c and reports true if changed
631 */
632 public void testRemoveAll() {
633 for (int i = 1; i < SIZE; ++i) {
634 ArrayBlockingQueue q = populatedQueue(SIZE);
635 ArrayBlockingQueue p = populatedQueue(i);
636 assertTrue(q.removeAll(p));
637 assertEquals(SIZE - i, q.size());
638 for (int j = 0; j < i; ++j) {
639 Integer x = (Integer)(p.remove());
640 assertFalse(q.contains(x));
641 }
642 }
643 }
644
645 void checkToArray(ArrayBlockingQueue<Integer> q) {
646 int size = q.size();
647 Object[] a1 = q.toArray();
648 assertEquals(size, a1.length);
649 Integer[] a2 = q.toArray(new Integer[0]);
650 assertEquals(size, a2.length);
651 Integer[] a3 = q.toArray(new Integer[Math.max(0, size - 1)]);
652 assertEquals(size, a3.length);
653 Integer[] a4 = new Integer[size];
654 assertSame(a4, q.toArray(a4));
655 Integer[] a5 = new Integer[size + 1];
656 Arrays.fill(a5, 42);
657 assertSame(a5, q.toArray(a5));
658 Integer[] a6 = new Integer[size + 2];
659 Arrays.fill(a6, 42);
660 assertSame(a6, q.toArray(a6));
661 Object[][] as = { a1, a2, a3, a4, a5, a6 };
662 for (Object[] a : as) {
663 if (a.length > size) assertNull(a[size]);
664 if (a.length > size + 1) assertEquals(42, a[size + 1]);
665 }
666 Iterator it = q.iterator();
667 Integer s = q.peek();
668 for (int i = 0; i < size; i++) {
669 Integer x = (Integer) it.next();
670 assertEquals(s + i, (int) x);
671 for (Object[] a : as)
672 assertSame(a1[i], x);
673 }
674 }
675
676 /**
677 * toArray() and toArray(a) contain all elements in FIFO order
678 */
679 public void testToArray() {
680 final ThreadLocalRandom rnd = ThreadLocalRandom.current();
681 final int size = rnd.nextInt(6);
682 final int capacity = Math.max(1, size + rnd.nextInt(size + 1));
683 ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<>(capacity);
684 for (int i = 0; i < size; i++) {
685 checkToArray(q);
686 q.add(i);
687 }
688 // Provoke wraparound
689 int added = size * 2;
690 for (int i = 0; i < added; i++) {
691 checkToArray(q);
692 assertEquals((Integer) i, q.poll());
693 q.add(size + i);
694 }
695 for (int i = 0; i < size; i++) {
696 checkToArray(q);
697 assertEquals((Integer) (added + i), q.poll());
698 }
699 }
700
701 /**
702 * toArray(incompatible array type) throws ArrayStoreException
703 */
704 public void testToArray_incompatibleArrayType() {
705 ArrayBlockingQueue q = populatedQueue(SIZE);
706 try {
707 q.toArray(new String[10]);
708 shouldThrow();
709 } catch (ArrayStoreException success) {}
710 try {
711 q.toArray(new String[0]);
712 shouldThrow();
713 } catch (ArrayStoreException success) {}
714 }
715
716 /**
717 * iterator iterates through all elements
718 */
719 public void testIterator() throws InterruptedException {
720 ArrayBlockingQueue q = populatedQueue(SIZE);
721 Iterator it = q.iterator();
722 int i;
723 for (i = 0; it.hasNext(); i++)
724 assertTrue(q.contains(it.next()));
725 assertEquals(i, SIZE);
726 assertIteratorExhausted(it);
727
728 it = q.iterator();
729 for (i = 0; it.hasNext(); i++)
730 assertEquals(it.next(), q.take());
731 assertEquals(i, SIZE);
732 assertIteratorExhausted(it);
733 }
734
735 /**
736 * iterator of empty collection has no elements
737 */
738 public void testEmptyIterator() {
739 assertIteratorExhausted(new ArrayBlockingQueue(SIZE).iterator());
740 }
741
742 /**
743 * iterator.remove removes current element
744 */
745 public void testIteratorRemove() {
746 final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
747 q.add(two);
748 q.add(one);
749 q.add(three);
750
751 Iterator it = q.iterator();
752 it.next();
753 it.remove();
754
755 it = q.iterator();
756 assertSame(it.next(), one);
757 assertSame(it.next(), three);
758 assertFalse(it.hasNext());
759 }
760
761 /**
762 * iterator ordering is FIFO
763 */
764 public void testIteratorOrdering() {
765 final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
766 q.add(one);
767 q.add(two);
768 q.add(three);
769
770 assertEquals("queue should be full", 0, q.remainingCapacity());
771
772 int k = 0;
773 for (Iterator it = q.iterator(); it.hasNext();) {
774 assertEquals(++k, it.next());
775 }
776 assertEquals(3, k);
777 }
778
779 /**
780 * Modifications do not cause iterators to fail
781 */
782 public void testWeaklyConsistentIteration() {
783 final ArrayBlockingQueue q = new ArrayBlockingQueue(3);
784 q.add(one);
785 q.add(two);
786 q.add(three);
787 for (Iterator it = q.iterator(); it.hasNext();) {
788 q.remove();
789 it.next();
790 }
791 assertEquals(0, q.size());
792 }
793
794 /**
795 * toString contains toStrings of elements
796 */
797 public void testToString() {
798 ArrayBlockingQueue q = populatedQueue(SIZE);
799 String s = q.toString();
800 for (int i = 0; i < SIZE; ++i) {
801 assertTrue(s.contains(String.valueOf(i)));
802 }
803 }
804
805 /**
806 * offer transfers elements across Executor tasks
807 */
808 public void testOfferInExecutor() {
809 final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
810 q.add(one);
811 q.add(two);
812 final CheckedBarrier threadsStarted = new CheckedBarrier(2);
813 final ExecutorService executor = Executors.newFixedThreadPool(2);
814 try (PoolCleaner cleaner = cleaner(executor)) {
815 executor.execute(new CheckedRunnable() {
816 public void realRun() throws InterruptedException {
817 assertFalse(q.offer(three));
818 threadsStarted.await();
819 assertTrue(q.offer(three, LONG_DELAY_MS, MILLISECONDS));
820 assertEquals(0, q.remainingCapacity());
821 }});
822
823 executor.execute(new CheckedRunnable() {
824 public void realRun() throws InterruptedException {
825 threadsStarted.await();
826 assertEquals(0, q.remainingCapacity());
827 assertSame(one, q.take());
828 }});
829 }
830 }
831
832 /**
833 * timed poll retrieves elements across Executor threads
834 */
835 public void testPollInExecutor() {
836 final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
837 final CheckedBarrier threadsStarted = new CheckedBarrier(2);
838 final ExecutorService executor = Executors.newFixedThreadPool(2);
839 try (PoolCleaner cleaner = cleaner(executor)) {
840 executor.execute(new CheckedRunnable() {
841 public void realRun() throws InterruptedException {
842 assertNull(q.poll());
843 threadsStarted.await();
844 assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
845 checkEmpty(q);
846 }});
847
848 executor.execute(new CheckedRunnable() {
849 public void realRun() throws InterruptedException {
850 threadsStarted.await();
851 q.put(one);
852 }});
853 }
854 }
855
856 /**
857 * A deserialized serialized queue has same elements in same order
858 */
859 public void testSerialization() throws Exception {
860 Queue x = populatedQueue(SIZE);
861 Queue y = serialClone(x);
862
863 assertNotSame(x, y);
864 assertEquals(x.size(), y.size());
865 assertEquals(x.toString(), y.toString());
866 assertTrue(Arrays.equals(x.toArray(), y.toArray()));
867 while (!x.isEmpty()) {
868 assertFalse(y.isEmpty());
869 assertEquals(x.remove(), y.remove());
870 }
871 assertTrue(y.isEmpty());
872 }
873
874 /**
875 * drainTo(c) empties queue into another collection c
876 */
877 public void testDrainTo() {
878 ArrayBlockingQueue q = populatedQueue(SIZE);
879 ArrayList l = new ArrayList();
880 q.drainTo(l);
881 assertEquals(0, q.size());
882 assertEquals(SIZE, l.size());
883 for (int i = 0; i < SIZE; ++i)
884 assertEquals(l.get(i), new Integer(i));
885 q.add(zero);
886 q.add(one);
887 assertFalse(q.isEmpty());
888 assertTrue(q.contains(zero));
889 assertTrue(q.contains(one));
890 l.clear();
891 q.drainTo(l);
892 assertEquals(0, q.size());
893 assertEquals(2, l.size());
894 for (int i = 0; i < 2; ++i)
895 assertEquals(l.get(i), new Integer(i));
896 }
897
898 /**
899 * drainTo empties full queue, unblocking a waiting put.
900 */
901 public void testDrainToWithActivePut() throws InterruptedException {
902 final ArrayBlockingQueue q = populatedQueue(SIZE);
903 Thread t = new Thread(new CheckedRunnable() {
904 public void realRun() throws InterruptedException {
905 q.put(new Integer(SIZE + 1));
906 }});
907
908 t.start();
909 ArrayList l = new ArrayList();
910 q.drainTo(l);
911 assertTrue(l.size() >= SIZE);
912 for (int i = 0; i < SIZE; ++i)
913 assertEquals(l.get(i), new Integer(i));
914 t.join();
915 assertTrue(q.size() + l.size() >= SIZE);
916 }
917
918 /**
919 * drainTo(c, n) empties first min(n, size) elements of queue into c
920 */
921 public void testDrainToN() {
922 ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE * 2);
923 for (int i = 0; i < SIZE + 2; ++i) {
924 for (int j = 0; j < SIZE; j++)
925 assertTrue(q.offer(new Integer(j)));
926 ArrayList l = new ArrayList();
927 q.drainTo(l, i);
928 int k = (i < SIZE) ? i : SIZE;
929 assertEquals(k, l.size());
930 assertEquals(SIZE - k, q.size());
931 for (int j = 0; j < k; ++j)
932 assertEquals(l.get(j), new Integer(j));
933 do {} while (q.poll() != null);
934 }
935 }
936
937 /**
938 * remove(null), contains(null) always return false
939 */
940 public void testNeverContainsNull() {
941 Collection<?>[] qs = {
942 populatedQueue(0, 1, 10, false),
943 populatedQueue(2, 2, 10, true),
944 };
945
946 for (Collection<?> q : qs) {
947 assertFalse(q.contains(null));
948 assertFalse(q.remove(null));
949 }
950 }
951 }

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