ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/SynchronousQueueTest.java
Revision: 1.10
Committed: Mon Nov 2 20:28:32 2009 UTC (14 years, 6 months ago) by jsr166
Branch: MAIN
Changes since 1.9: +49 -49 lines
Log Message: 
whitespace

File Contents

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