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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8