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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.30 - (view) (download)

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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8