test/tck/SynchronousQueueTest.java

/*
 * Written by members of JCP JSR-166 Expert Group and released to the
 * public domain. Use, modify, and redistribute this code in any way
 * without acknowledgement. Other contributors include Andrew Wright,
 * Jeffrey Hayes, Pat Fischer, Mike Judd.
 */

import junit.framework.*;
import java.util.*;
import java.util.concurrent.*;
import java.io.*;

public class SynchronousQueueTest extends JSR166TestCase {

    public static void main(String[] args) {
        junit.textui.TestRunner.run (suite());  
    }

    public static Test suite() {
        return new TestSuite(SynchronousQueueTest.class);
    }

    public void testEmptyFull() {
        SynchronousQueue q = new SynchronousQueue();
        assertTrue(q.isEmpty());
        assertEquals(0, q.size());
        assertEquals(0, q.remainingCapacity());
        assertFalse(q.offer(new Integer(3)));
    }

    public void testOfferNull(){
        try {
            SynchronousQueue q = new SynchronousQueue();
            q.offer(null);
            fail("should throw NPE");
        } catch (NullPointerException success) { }   
    }

    public void testOffer(){
        SynchronousQueue q = new SynchronousQueue();
        assertFalse(q.offer(new Integer(1)));
    }

    public void testAdd(){
        try {
            SynchronousQueue q = new SynchronousQueue();
            assertEquals(0, q.remainingCapacity());
            q.add(new Integer(0));
        } catch (IllegalStateException success){
        }   
    }

    public void testAddAll1(){
        try {
            SynchronousQueue q = new SynchronousQueue();
            q.addAll(null);
            fail("Cannot add null collection");
        }
        catch (NullPointerException success) {}
    }
    public void testAddAll2(){
        try {
            SynchronousQueue q = new SynchronousQueue();
            Integer[] ints = new Integer[1];
            q.addAll(Arrays.asList(ints));
            fail("Cannot add null elements");
        }
        catch (NullPointerException success) {}
    }
    public void testAddAll4(){
        try {
            SynchronousQueue q = new SynchronousQueue();
            Integer[] ints = new Integer[1];
            for (int i = 0; i < 1; ++i)
                ints[i] = new Integer(i);
            q.addAll(Arrays.asList(ints));
            fail("Cannot add with insufficient capacity");
        }
        catch (IllegalStateException success) {}
    }

    public void testPutNull() {
        try {
            SynchronousQueue q = new SynchronousQueue();
            q.put(null);
            fail("put should throw NPE");
        } 
        catch (NullPointerException success){
        }   
        catch (InterruptedException ie) {
            fail("Unexpected exception");
        }
     }

    public void testBlockingPut(){
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        SynchronousQueue q = new SynchronousQueue();
                        q.put(new Integer(0));
                        threadFail("put should block");
                    } catch (InterruptedException ie){
                    }   
                }});
        t.start();
        try { 
           Thread.sleep(SHORT_DELAY_MS); 
           t.interrupt();
           t.join();
        }
        catch (InterruptedException ie) {
            fail("Unexpected exception");
        }
    }

    public void testPutWithTake() {
        final SynchronousQueue q = new SynchronousQueue();
        Thread t = new Thread(new Runnable() {
                public void run(){
                    int added = 0;
                    try {
                        q.put(new Object());
                        ++added;
                        q.put(new Object());
                        ++added;
                        q.put(new Object());
                        ++added;
                        q.put(new Object());
                        ++added;
                        threadFail("Should block");
                    } catch (InterruptedException e){
                        assertTrue(added >= 1);
                    }
                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            q.take();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch (Exception e){
            fail("Unexpected exception");
        }
    }

    public void testTimedOffer() {
        final SynchronousQueue q = new SynchronousQueue();
        Thread t = new Thread(new Runnable() {
                public void run(){
                    try {

                        threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
                        q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadFail("Should block");
                    } catch (InterruptedException success){}
                }
            });
        
        try {
            t.start();
            Thread.sleep(SMALL_DELAY_MS);
            t.interrupt();
            t.join();
        } catch (Exception e){
            fail("Unexpected exception");
        }
    }


    public void testTakeFromEmpty() {
        final SynchronousQueue q = new SynchronousQueue();
        Thread t = new Thread(new Runnable() {
                public void run(){
                    try {
                        q.take();
                        threadFail("Should block");
                    } catch (InterruptedException success){ }                
                }
            });
        try {
            t.start();
            Thread.sleep(SHORT_DELAY_MS);
            t.interrupt();
            t.join();
        } catch (Exception e){
            fail("Unexpected exception");
        }
    }

    public void testPoll(){
        SynchronousQueue q = new SynchronousQueue();
        assertNull(q.poll());
    }

    public void testTimedPoll0() {
        try {
            SynchronousQueue q = new SynchronousQueue();
            assertNull(q.poll(0, TimeUnit.MILLISECONDS));
        } catch (InterruptedException e){
            fail("Unexpected exception");
        }   
    }

    public void testTimedPoll() {
        try {
            SynchronousQueue q = new SynchronousQueue();
            assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
        } catch (InterruptedException e){
            fail("Unexpected exception");
        }   
    }

    public void testInterruptedTimedPoll(){
        Thread t = new Thread(new Runnable() {
                public void run() {
                    try {
                        SynchronousQueue q = new SynchronousQueue();
                        assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
                    } catch (InterruptedException success){
                    }   
                }});
        t.start();
        try { 
           Thread.sleep(SHORT_DELAY_MS); 
           t.interrupt();
           t.join();
        }
        catch (InterruptedException ie) {
            fail("Unexpected exception");
        }
    }

    public void testTimedPollWithOffer(){
        final SynchronousQueue q = new SynchronousQueue();
        Thread t = new Thread(new Runnable() {
                public void run(){
                    try {
                        threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
                        q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
                        q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
                        threadFail("Should block");
                    } catch (InterruptedException success) { }                
                }
            });
        try {
            t.start();
            Thread.sleep(SMALL_DELAY_MS);
            assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
            t.interrupt();
            t.join();
        } catch (Exception e){
            fail("Unexpected exception");
        }
    }  


    public void testPeek(){
        SynchronousQueue q = new SynchronousQueue();
        assertNull(q.peek());
    }

    public void testElement(){
        SynchronousQueue q = new SynchronousQueue();
        try {
            q.element();
            fail("no such element");
        }
        catch (NoSuchElementException success) {}
    }

    public void testRemove(){
        SynchronousQueue q = new SynchronousQueue();
        try {
            q.remove();
            fail("remove should throw");
        } catch (NoSuchElementException success){
        }   
    }

    public void testRemoveElement(){
        SynchronousQueue q = new SynchronousQueue();
        assertFalse(q.remove(new Integer(0)));
        assertTrue(q.isEmpty());
    }
        
    public void testContains(){
        SynchronousQueue q = new SynchronousQueue();
        assertFalse(q.contains(new Integer(0)));
    }

    public void testClear(){
        SynchronousQueue q = new SynchronousQueue();
        q.clear();
        assertTrue(q.isEmpty());
    }

    public void testContainsAll(){
        SynchronousQueue q = new SynchronousQueue();
        Integer[] empty = new Integer[0];
        Integer[] ints = new Integer[1]; ints[0] = new Integer(0);
        //        assertTrue(q.containsAll(Arrays.asList(empty)));
        assertFalse(q.containsAll(Arrays.asList(ints)));
    }

    public void testRetainAll(){
        SynchronousQueue q = new SynchronousQueue();
        Integer[] empty = new Integer[0];
        Integer[] ints = new Integer[1]; ints[0] = new Integer(0);
        q.retainAll(Arrays.asList(ints));
        //        assertTrue(q.containsAll(Arrays.asList(empty)));
        assertFalse(q.containsAll(Arrays.asList(ints)));
    }

    public void testRemoveAll(){
        SynchronousQueue q = new SynchronousQueue();
        Integer[] empty = new Integer[0];
        Integer[] ints = new Integer[1]; ints[0] = new Integer(0);
        q.removeAll(Arrays.asList(ints));
        //        assertTrue(q.containsAll(Arrays.asList(empty)));
        assertFalse(q.containsAll(Arrays.asList(ints)));
    }


    public void testToArray(){
        SynchronousQueue q = new SynchronousQueue();
        Object[] o = q.toArray();
        assertEquals(o.length, 0);
    }

    public void testToArray2(){
        SynchronousQueue q = new SynchronousQueue();
        Integer[] ints = new Integer[1];
        assertNull(ints[0]);
    }
    
    public void testIterator(){
        SynchronousQueue q = new SynchronousQueue();
        Iterator it = q.iterator();
        assertFalse(it.hasNext());
        try {
            Object x = it.next();
            fail("should throw");
        }
        catch (NoSuchElementException success) {}
    }

    public void testIteratorRemove(){
        SynchronousQueue q = new SynchronousQueue();
        Iterator it = q.iterator();
        try {
            it.remove();
            fail("should throw");
        }
        catch (IllegalStateException success) {}
    }

    public void testToString(){
        SynchronousQueue q = new SynchronousQueue();
        String s = q.toString();
        assertTrue(s != null);
    }        


    public void testOfferInExecutor() {
        final SynchronousQueue q = new SynchronousQueue();
        ExecutorService executor = Executors.newFixedThreadPool(2);
        final Integer one = new Integer(1);

        executor.execute(new Runnable() {
            public void run() {
                threadAssertFalse(q.offer(one));
                try {
                    threadAssertTrue(q.offer(one, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
                    threadAssertEquals(0, q.remainingCapacity());
                }
                catch (InterruptedException e) {
                    threadFail("should not be interrupted");
                }
            }
        });

        executor.execute(new Runnable() {
            public void run() {
                try {
                    Thread.sleep(SMALL_DELAY_MS);
                    threadAssertEquals(one, q.take());
                }
                catch (InterruptedException e) {
                    fail("should not be interrupted");
                }
            }
        });
        
        joinPool(executor);

    }

    public void testPollInExecutor() {

        final SynchronousQueue q = new SynchronousQueue();

        ExecutorService executor = Executors.newFixedThreadPool(2);

        executor.execute(new Runnable() {
            public void run() {
                threadAssertNull(q.poll());
                try {
                    threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
                    threadAssertTrue(q.isEmpty());
                }
                catch (InterruptedException e) {
                    threadFail("should not be interrupted");
                }
            }
        });

        executor.execute(new Runnable() {
            public void run() {
                try {
                    Thread.sleep(SMALL_DELAY_MS);
                    q.put(new Integer(1));
                }
                catch (InterruptedException e) {
                    threadFail("should not be interrupted");
                }
            }
        });
        
        joinPool(executor);

    }

    public void testSerialization() {
        SynchronousQueue q = new SynchronousQueue();
        try {
            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
            out.writeObject(q);
            out.close();

            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
            SynchronousQueue r = (SynchronousQueue)in.readObject();
            assertEquals(q.size(), r.size());
            while (!q.isEmpty()) 
                assertEquals(q.remove(), r.remove());
        } catch(Exception e){
            fail("unexpected exception");
        }
    }

}
Revision:	1.3
Committed:	Sun Sep 14 20:42:40 2003 UTC (20 years, 8 months ago) by dl
Branch:	MAIN
Changes since 1.2:	+29 -38 lines
Log Message:	New base class JSR166TestCase
#	User	Rev	Content
1	dl	1.1	/*
2			* Written by members of JCP JSR-166 Expert Group and released to the
3			* public domain. Use, modify, and redistribute this code in any way
4			* without acknowledgement. Other contributors include Andrew Wright,
5			* Jeffrey Hayes, Pat Fischer, Mike Judd.
6			*/
7
8			import junit.framework.*;
9			import java.util.*;
10			import java.util.concurrent.*;
11	dl	1.2	import java.io.*;
12	dl	1.1
13	dl	1.3	public class SynchronousQueueTest extends JSR166TestCase {
14	dl	1.1
15			public static void main(String[] args) {
16			junit.textui.TestRunner.run (suite());
17			}
18
19			public static Test suite() {
20			return new TestSuite(SynchronousQueueTest.class);
21			}
22
23			public void testEmptyFull() {
24			SynchronousQueue q = new SynchronousQueue();
25			assertTrue(q.isEmpty());
26			assertEquals(0, q.size());
27			assertEquals(0, q.remainingCapacity());
28			assertFalse(q.offer(new Integer(3)));
29			}
30
31			public void testOfferNull(){
32			try {
33			SynchronousQueue q = new SynchronousQueue();
34			q.offer(null);
35			fail("should throw NPE");
36			} catch (NullPointerException success) { }
37			}
38
39			public void testOffer(){
40			SynchronousQueue q = new SynchronousQueue();
41			assertFalse(q.offer(new Integer(1)));
42			}
43
44			public void testAdd(){
45			try {
46			SynchronousQueue q = new SynchronousQueue();
47			assertEquals(0, q.remainingCapacity());
48			q.add(new Integer(0));
49			} catch (IllegalStateException success){
50			}
51			}
52
53			public void testAddAll1(){
54			try {
55			SynchronousQueue q = new SynchronousQueue();
56			q.addAll(null);
57			fail("Cannot add null collection");
58			}
59			catch (NullPointerException success) {}
60			}
61			public void testAddAll2(){
62			try {
63			SynchronousQueue q = new SynchronousQueue();
64	dl	1.3	Integer[] ints = new Integer[1];
65	dl	1.1	q.addAll(Arrays.asList(ints));
66			fail("Cannot add null elements");
67			}
68			catch (NullPointerException success) {}
69			}
70			public void testAddAll4(){
71			try {
72			SynchronousQueue q = new SynchronousQueue();
73	dl	1.3	Integer[] ints = new Integer[1];
74			for (int i = 0; i < 1; ++i)
75	dl	1.1	ints[i] = new Integer(i);
76			q.addAll(Arrays.asList(ints));
77			fail("Cannot add with insufficient capacity");
78			}
79			catch (IllegalStateException success) {}
80			}
81
82			public void testPutNull() {
83			try {
84			SynchronousQueue q = new SynchronousQueue();
85			q.put(null);
86			fail("put should throw NPE");
87			}
88			catch (NullPointerException success){
89			}
90			catch (InterruptedException ie) {
91			fail("Unexpected exception");
92			}
93			}
94
95			public void testBlockingPut(){
96			Thread t = new Thread(new Runnable() {
97			public void run() {
98			try {
99			SynchronousQueue q = new SynchronousQueue();
100			q.put(new Integer(0));
101	dl	1.3	threadFail("put should block");
102	dl	1.1	} catch (InterruptedException ie){
103			}
104			}});
105			t.start();
106			try {
107			Thread.sleep(SHORT_DELAY_MS);
108			t.interrupt();
109			t.join();
110			}
111			catch (InterruptedException ie) {
112			fail("Unexpected exception");
113			}
114			}
115
116			public void testPutWithTake() {
117			final SynchronousQueue q = new SynchronousQueue();
118			Thread t = new Thread(new Runnable() {
119			public void run(){
120			int added = 0;
121			try {
122			q.put(new Object());
123			++added;
124			q.put(new Object());
125			++added;
126			q.put(new Object());
127			++added;
128			q.put(new Object());
129			++added;
130	dl	1.3	threadFail("Should block");
131	dl	1.1	} catch (InterruptedException e){
132			assertTrue(added >= 1);
133			}
134			}
135			});
136			try {
137			t.start();
138			Thread.sleep(SHORT_DELAY_MS);
139			q.take();
140			Thread.sleep(SHORT_DELAY_MS);
141			t.interrupt();
142			t.join();
143			} catch (Exception e){
144			fail("Unexpected exception");
145			}
146			}
147
148			public void testTimedOffer() {
149			final SynchronousQueue q = new SynchronousQueue();
150			Thread t = new Thread(new Runnable() {
151			public void run(){
152			try {
153
154	dl	1.3	threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
155	dl	1.1	q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
156	dl	1.3	threadFail("Should block");
157	dl	1.1	} catch (InterruptedException success){}
158			}
159			});
160
161			try {
162			t.start();
163	dl	1.3	Thread.sleep(SMALL_DELAY_MS);
164	dl	1.1	t.interrupt();
165			t.join();
166			} catch (Exception e){
167			fail("Unexpected exception");
168			}
169			}
170
171
172			public void testTakeFromEmpty() {
173			final SynchronousQueue q = new SynchronousQueue();
174			Thread t = new Thread(new Runnable() {
175			public void run(){
176			try {
177			q.take();
178	dl	1.3	threadFail("Should block");
179	dl	1.1	} catch (InterruptedException success){ }
180			}
181			});
182			try {
183			t.start();
184			Thread.sleep(SHORT_DELAY_MS);
185			t.interrupt();
186			t.join();
187			} catch (Exception e){
188			fail("Unexpected exception");
189			}
190			}
191
192			public void testPoll(){
193			SynchronousQueue q = new SynchronousQueue();
194			assertNull(q.poll());
195			}
196
197			public void testTimedPoll0() {
198			try {
199			SynchronousQueue q = new SynchronousQueue();
200			assertNull(q.poll(0, TimeUnit.MILLISECONDS));
201			} catch (InterruptedException e){
202			fail("Unexpected exception");
203			}
204			}
205
206			public void testTimedPoll() {
207			try {
208			SynchronousQueue q = new SynchronousQueue();
209			assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
210			} catch (InterruptedException e){
211			fail("Unexpected exception");
212			}
213			}
214
215			public void testInterruptedTimedPoll(){
216			Thread t = new Thread(new Runnable() {
217			public void run() {
218			try {
219			SynchronousQueue q = new SynchronousQueue();
220			assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
221			} catch (InterruptedException success){
222			}
223			}});
224			t.start();
225			try {
226			Thread.sleep(SHORT_DELAY_MS);
227			t.interrupt();
228			t.join();
229			}
230			catch (InterruptedException ie) {
231			fail("Unexpected exception");
232			}
233			}
234
235			public void testTimedPollWithOffer(){
236			final SynchronousQueue q = new SynchronousQueue();
237			Thread t = new Thread(new Runnable() {
238			public void run(){
239			try {
240	dl	1.3	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
241	dl	1.1	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
242			q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
243	dl	1.3	threadFail("Should block");
244	dl	1.1	} catch (InterruptedException success) { }
245			}
246			});
247			try {
248			t.start();
249	dl	1.3	Thread.sleep(SMALL_DELAY_MS);
250	dl	1.1	assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
251			t.interrupt();
252			t.join();
253			} catch (Exception e){
254			fail("Unexpected exception");
255			}
256			}
257
258
259			public void testPeek(){
260			SynchronousQueue q = new SynchronousQueue();
261			assertNull(q.peek());
262			}
263
264			public void testElement(){
265			SynchronousQueue q = new SynchronousQueue();
266			try {
267			q.element();
268			fail("no such element");
269			}
270			catch (NoSuchElementException success) {}
271			}
272
273			public void testRemove(){
274			SynchronousQueue q = new SynchronousQueue();
275			try {
276			q.remove();
277			fail("remove should throw");
278			} catch (NoSuchElementException success){
279			}
280			}
281
282			public void testRemoveElement(){
283			SynchronousQueue q = new SynchronousQueue();
284	dl	1.3	assertFalse(q.remove(new Integer(0)));
285	dl	1.2	assertTrue(q.isEmpty());
286	dl	1.1	}
287
288			public void testContains(){
289			SynchronousQueue q = new SynchronousQueue();
290	dl	1.3	assertFalse(q.contains(new Integer(0)));
291	dl	1.1	}
292
293			public void testClear(){
294			SynchronousQueue q = new SynchronousQueue();
295			q.clear();
296			assertTrue(q.isEmpty());
297			}
298
299			public void testContainsAll(){
300			SynchronousQueue q = new SynchronousQueue();
301			Integer[] empty = new Integer[0];
302			Integer[] ints = new Integer[1]; ints[0] = new Integer(0);
303			// assertTrue(q.containsAll(Arrays.asList(empty)));
304			assertFalse(q.containsAll(Arrays.asList(ints)));
305			}
306
307			public void testRetainAll(){
308			SynchronousQueue q = new SynchronousQueue();
309			Integer[] empty = new Integer[0];
310			Integer[] ints = new Integer[1]; ints[0] = new Integer(0);
311			q.retainAll(Arrays.asList(ints));
312			// assertTrue(q.containsAll(Arrays.asList(empty)));
313			assertFalse(q.containsAll(Arrays.asList(ints)));
314			}
315
316			public void testRemoveAll(){
317			SynchronousQueue q = new SynchronousQueue();
318			Integer[] empty = new Integer[0];
319			Integer[] ints = new Integer[1]; ints[0] = new Integer(0);
320			q.removeAll(Arrays.asList(ints));
321			// assertTrue(q.containsAll(Arrays.asList(empty)));
322			assertFalse(q.containsAll(Arrays.asList(ints)));
323			}
324
325
326			public void testToArray(){
327			SynchronousQueue q = new SynchronousQueue();
328			Object[] o = q.toArray();
329			assertEquals(o.length, 0);
330			}
331
332			public void testToArray2(){
333			SynchronousQueue q = new SynchronousQueue();
334			Integer[] ints = new Integer[1];
335			assertNull(ints[0]);
336			}
337
338			public void testIterator(){
339			SynchronousQueue q = new SynchronousQueue();
340			Iterator it = q.iterator();
341			assertFalse(it.hasNext());
342			try {
343			Object x = it.next();
344			fail("should throw");
345			}
346			catch (NoSuchElementException success) {}
347			}
348
349			public void testIteratorRemove(){
350			SynchronousQueue q = new SynchronousQueue();
351			Iterator it = q.iterator();
352			try {
353			it.remove();
354			fail("should throw");
355			}
356			catch (IllegalStateException success) {}
357			}
358
359			public void testToString(){
360			SynchronousQueue q = new SynchronousQueue();
361			String s = q.toString();
362			assertTrue(s != null);
363			}
364
365
366			public void testOfferInExecutor() {
367			final SynchronousQueue q = new SynchronousQueue();
368			ExecutorService executor = Executors.newFixedThreadPool(2);
369			final Integer one = new Integer(1);
370
371			executor.execute(new Runnable() {
372			public void run() {
373	dl	1.3	threadAssertFalse(q.offer(one));
374	dl	1.1	try {
375	dl	1.3	threadAssertTrue(q.offer(one, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
376			threadAssertEquals(0, q.remainingCapacity());
377	dl	1.1	}
378			catch (InterruptedException e) {
379	dl	1.3	threadFail("should not be interrupted");
380	dl	1.1	}
381			}
382			});
383
384			executor.execute(new Runnable() {
385			public void run() {
386			try {
387	dl	1.3	Thread.sleep(SMALL_DELAY_MS);
388			threadAssertEquals(one, q.take());
389	dl	1.1	}
390			catch (InterruptedException e) {
391			fail("should not be interrupted");
392			}
393			}
394			});
395
396	dl	1.3	joinPool(executor);
397	dl	1.1
398			}
399
400			public void testPollInExecutor() {
401
402			final SynchronousQueue q = new SynchronousQueue();
403
404			ExecutorService executor = Executors.newFixedThreadPool(2);
405
406			executor.execute(new Runnable() {
407			public void run() {
408	dl	1.3	threadAssertNull(q.poll());
409	dl	1.1	try {
410	dl	1.3	threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
411			threadAssertTrue(q.isEmpty());
412	dl	1.1	}
413			catch (InterruptedException e) {
414	dl	1.3	threadFail("should not be interrupted");
415	dl	1.1	}
416			}
417			});
418
419			executor.execute(new Runnable() {
420			public void run() {
421			try {
422	dl	1.3	Thread.sleep(SMALL_DELAY_MS);
423	dl	1.1	q.put(new Integer(1));
424			}
425			catch (InterruptedException e) {
426	dl	1.3	threadFail("should not be interrupted");
427	dl	1.1	}
428			}
429			});
430
431	dl	1.3	joinPool(executor);
432	dl	1.1
433	dl	1.2	}
434
435			public void testSerialization() {
436			SynchronousQueue q = new SynchronousQueue();
437			try {
438			ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
439			ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
440			out.writeObject(q);
441			out.close();
442
443			ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
444			ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
445			SynchronousQueue r = (SynchronousQueue)in.readObject();
446			assertEquals(q.size(), r.size());
447			while (!q.isEmpty())
448			assertEquals(q.remove(), r.remove());
449			} catch(Exception e){
450			fail("unexpected exception");
451			}
452	dl	1.1	}
453
454			}