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

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