/[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.57 - (show annotations)
Sun Nov 23 22:27:06 2014 UTC (4 years, 8 months ago) by jsr166
Branch: MAIN
Changes since 1.56: +14 -0 lines
add tests for contains(null), remove(null)

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

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