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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8