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

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8