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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8