/[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.18 - (show annotations)
Sat Nov 21 10:25:05 2009 UTC (9 years, 9 months ago) by jsr166
Branch: MAIN
Changes since 1.17: +2 -2 lines
improve exception handling

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

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