test/tck/ConcurrentLinkedQueueTest.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 ConcurrentLinkedQueueTest extends JSR166TestCase {

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

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

    /**
     * Create a queue of given size containing consecutive
     * Integers 0 ... n.
     */
    private ConcurrentLinkedQueue populatedQueue(int n) {
        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
        assertTrue(q.isEmpty());
        for(int i = 0; i < n; ++i)
            assertTrue(q.offer(new Integer(i)));
        assertFalse(q.isEmpty());
        assertEquals(n, q.size());
        return q;
    }
 
    public void testConstructor1(){
        assertEquals(0, new ConcurrentLinkedQueue().size());
    }

    public void testConstructor3() {
        try {
            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue((Collection)null);
            fail("Cannot make from null collection");
        }
        catch (NullPointerException success) {}
    }

    public void testConstructor4(){
        try {
            Integer[] ints = new Integer[SIZE];
            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
            fail("Cannot make with null elements");
        }
        catch (NullPointerException success) {}
    }

    public void testConstructor5(){
        try {
            Integer[] ints = new Integer[SIZE];
            for (int i = 0; i < SIZE-1; ++i)
                ints[i] = new Integer(i);
            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
            fail("Cannot make with null elements");
        }
        catch (NullPointerException success) {}
    }

    public void testConstructor6(){
        try {
            Integer[] ints = new Integer[SIZE];
            for (int i = 0; i < SIZE; ++i)
                ints[i] = new Integer(i);
            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
            for (int i = 0; i < SIZE; ++i)
                assertEquals(ints[i], q.poll());
        }
        finally {}
    }

    public void testEmpty() {
        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
        assertTrue(q.isEmpty());
        q.add(one);
        assertFalse(q.isEmpty());
        q.add(two);
        q.remove();
        q.remove();
        assertTrue(q.isEmpty());
    }

    public void testSize() {
        ConcurrentLinkedQueue q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            assertEquals(SIZE-i, q.size());
            q.remove();
        }
        for (int i = 0; i < SIZE; ++i) {
            assertEquals(i, q.size());
            q.add(new Integer(i));
        }
    }

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

    public void testOffer() {
        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
        assertTrue(q.offer(zero));
        assertTrue(q.offer(one));
    }

    public void testAdd(){
        ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
        for (int i = 0; i < SIZE; ++i) {
            assertEquals(i, q.size());
            assertTrue(q.add(new Integer(i)));
        }
    }

    public void testAddAll1(){
        try {
            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
            q.addAll(null);
            fail("Cannot add null collection");
        }
        catch (NullPointerException success) {}
    }
    public void testAddAll2(){
        try {
            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
            Integer[] ints = new Integer[SIZE];
            q.addAll(Arrays.asList(ints));
            fail("Cannot add null elements");
        }
        catch (NullPointerException success) {}
    }
    public void testAddAll3(){
        try {
            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
            Integer[] ints = new Integer[SIZE];
            for (int i = 0; i < SIZE-1; ++i)
                ints[i] = new Integer(i);
            q.addAll(Arrays.asList(ints));
            fail("Cannot add null elements");
        }
        catch (NullPointerException success) {}
    }

    public void testAddAll5(){
        try {
            Integer[] empty = new Integer[0];
            Integer[] ints = new Integer[SIZE];
            for (int i = 0; i < SIZE; ++i)
                ints[i] = new Integer(i);
            ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
            assertFalse(q.addAll(Arrays.asList(empty)));
            assertTrue(q.addAll(Arrays.asList(ints)));
            for (int i = 0; i < SIZE; ++i)
                assertEquals(ints[i], q.poll());
        }
        finally {}
    }

    public void testPoll(){
        ConcurrentLinkedQueue q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            assertEquals(i, ((Integer)q.poll()).intValue());
        }
        assertNull(q.poll());
    }

    public void testPeek(){
        ConcurrentLinkedQueue q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            assertEquals(i, ((Integer)q.peek()).intValue());
            q.poll();
            assertTrue(q.peek() == null ||
                       i != ((Integer)q.peek()).intValue());
        }
        assertNull(q.peek());
    }

    public void testElement(){
        ConcurrentLinkedQueue q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            assertEquals(i, ((Integer)q.element()).intValue());
            q.poll();
        }
        try {
            q.element();
            fail("no such element");
        }
        catch (NoSuchElementException success) {}
    }

    public void testRemove(){
        ConcurrentLinkedQueue q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            assertEquals(i, ((Integer)q.remove()).intValue());
        }
        try {
            q.remove();
            fail("remove should throw");
        } catch (NoSuchElementException success){
        }   
    }

    public void testRemoveElement(){
        ConcurrentLinkedQueue q = populatedQueue(SIZE);
        for (int i = 1; i < SIZE; i+=2) {
            assertTrue(q.remove(new Integer(i)));
        }
        for (int i = 0; i < SIZE; i+=2) {
            assertTrue(q.remove(new Integer(i)));
            assertFalse(q.remove(new Integer(i+1)));
        }
        assertTrue(q.isEmpty());
    }
        
    public void testContains(){
        ConcurrentLinkedQueue q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            assertTrue(q.contains(new Integer(i)));
            q.poll();
            assertFalse(q.contains(new Integer(i)));
        }
    }

    public void testClear(){
        ConcurrentLinkedQueue q = populatedQueue(SIZE);
        q.clear();
        assertTrue(q.isEmpty());
        assertEquals(0, q.size());
        q.add(one);
        assertFalse(q.isEmpty());
        q.clear();
        assertTrue(q.isEmpty());
    }

    public void testContainsAll(){
        ConcurrentLinkedQueue q = populatedQueue(SIZE);
        ConcurrentLinkedQueue p = new ConcurrentLinkedQueue();
        for (int i = 0; i < SIZE; ++i) {
            assertTrue(q.containsAll(p));
            assertFalse(p.containsAll(q));
            p.add(new Integer(i));
        }
        assertTrue(p.containsAll(q));
    }

    public void testRetainAll(){
        ConcurrentLinkedQueue q = populatedQueue(SIZE);
        ConcurrentLinkedQueue p = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            boolean changed = q.retainAll(p);
            if (i == 0)
                assertFalse(changed);
            else
                assertTrue(changed);

            assertTrue(q.containsAll(p));
            assertEquals(SIZE-i, q.size());
            p.remove();
        }
    }

    public void testRemoveAll(){
        for (int i = 1; i < SIZE; ++i) {
            ConcurrentLinkedQueue q = populatedQueue(SIZE);
            ConcurrentLinkedQueue p = populatedQueue(i);
            assertTrue(q.removeAll(p));
            assertEquals(SIZE-i, q.size());
            for (int j = 0; j < i; ++j) {
                Integer I = (Integer)(p.remove());
                assertFalse(q.contains(I));
            }
        }
    }

    public void testToArray(){
        ConcurrentLinkedQueue q = populatedQueue(SIZE);
        Object[] o = q.toArray();
        Arrays.sort(o);
        for(int i = 0; i < o.length; i++)
            assertEquals(o[i], q.poll());
    }

    public void testToArray2(){
        ConcurrentLinkedQueue q = populatedQueue(SIZE);
        Integer[] ints = new Integer[SIZE];
        ints = (Integer[])q.toArray(ints);
        Arrays.sort(ints);
        for(int i = 0; i < ints.length; i++)
            assertEquals(ints[i], q.poll());
    }
    
    public void testIterator(){
        ConcurrentLinkedQueue q = populatedQueue(SIZE);
        int i = 0;
        Iterator it = q.iterator();
        while(it.hasNext()) {
            assertTrue(q.contains(it.next()));
            ++i;
        }
        assertEquals(i, SIZE);
    }

    public void testIteratorOrdering() {
        final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
        q.add(one);
        q.add(two);
        q.add(three);

        int k = 0;
        for (Iterator it = q.iterator(); it.hasNext();) {
            int i = ((Integer)(it.next())).intValue();
            assertEquals("items should come out in order", ++k, i);
        }

        assertEquals("should go through 3 elements", 3, k);
    }

    public void testWeaklyConsistentIteration () {
        final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
        q.add(one);
        q.add(two);
        q.add(three);

        try {
            for (Iterator it = q.iterator(); it.hasNext();) {
                q.remove();
                it.next();
            }
        }
        catch (ConcurrentModificationException e) {
            fail("weakly consistent iterator; should not get CME");
        }

        assertEquals("queue should be empty again", 0, q.size());
    }

    public void testIteratorRemove () {
        final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
        q.add(one);
        q.add(two);
        q.add(three);
        Iterator it = q.iterator();
        it.next();
        it.remove();
        it = q.iterator();
        assertEquals(it.next(), two);
        assertEquals(it.next(), three);
        assertFalse(it.hasNext());
    }


    public void testToString(){
        ConcurrentLinkedQueue q = populatedQueue(SIZE);
        String s = q.toString();
        for (int i = 0; i < SIZE; ++i) {
            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
        }
    }        

    public void testSerialization() {
        ConcurrentLinkedQueue q = populatedQueue(SIZE);
        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));
            ConcurrentLinkedQueue r = (ConcurrentLinkedQueue)in.readObject();
            assertEquals(q.size(), r.size());
            while (!q.isEmpty()) 
                assertEquals(q.remove(), r.remove());
        } catch(Exception e){
            e.printStackTrace();
            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:	+67 -79 lines
Log Message:	New base class JSR166TestCase
#	Content
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	import java.io.*;
12
13	public class ConcurrentLinkedQueueTest extends JSR166TestCase {
14
15	public static void main(String[] args) {
16	junit.textui.TestRunner.run (suite());
17	}
18
19	public static Test suite() {
20	return new TestSuite(ConcurrentLinkedQueueTest.class);
21	}
22
23	/**
24	* Create a queue of given size containing consecutive
25	* Integers 0 ... n.
26	*/
27	private ConcurrentLinkedQueue populatedQueue(int n) {
28	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
29	assertTrue(q.isEmpty());
30	for(int i = 0; i < n; ++i)
31	assertTrue(q.offer(new Integer(i)));
32	assertFalse(q.isEmpty());
33	assertEquals(n, q.size());
34	return q;
35	}
36
37	public void testConstructor1(){
38	assertEquals(0, new ConcurrentLinkedQueue().size());
39	}
40
41	public void testConstructor3() {
42	try {
43	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue((Collection)null);
44	fail("Cannot make from null collection");
45	}
46	catch (NullPointerException success) {}
47	}
48
49	public void testConstructor4(){
50	try {
51	Integer[] ints = new Integer[SIZE];
52	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
53	fail("Cannot make with null elements");
54	}
55	catch (NullPointerException success) {}
56	}
57
58	public void testConstructor5(){
59	try {
60	Integer[] ints = new Integer[SIZE];
61	for (int i = 0; i < SIZE-1; ++i)
62	ints[i] = new Integer(i);
63	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
64	fail("Cannot make with null elements");
65	}
66	catch (NullPointerException success) {}
67	}
68
69	public void testConstructor6(){
70	try {
71	Integer[] ints = new Integer[SIZE];
72	for (int i = 0; i < SIZE; ++i)
73	ints[i] = new Integer(i);
74	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue(Arrays.asList(ints));
75	for (int i = 0; i < SIZE; ++i)
76	assertEquals(ints[i], q.poll());
77	}
78	finally {}
79	}
80
81	public void testEmpty() {
82	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
83	assertTrue(q.isEmpty());
84	q.add(one);
85	assertFalse(q.isEmpty());
86	q.add(two);
87	q.remove();
88	q.remove();
89	assertTrue(q.isEmpty());
90	}
91
92	public void testSize() {
93	ConcurrentLinkedQueue q = populatedQueue(SIZE);
94	for (int i = 0; i < SIZE; ++i) {
95	assertEquals(SIZE-i, q.size());
96	q.remove();
97	}
98	for (int i = 0; i < SIZE; ++i) {
99	assertEquals(i, q.size());
100	q.add(new Integer(i));
101	}
102	}
103
104	public void testOfferNull(){
105	try {
106	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
107	q.offer(null);
108	fail("should throw NPE");
109	} catch (NullPointerException success) { }
110	}
111
112	public void testOffer() {
113	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
114	assertTrue(q.offer(zero));
115	assertTrue(q.offer(one));
116	}
117
118	public void testAdd(){
119	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
120	for (int i = 0; i < SIZE; ++i) {
121	assertEquals(i, q.size());
122	assertTrue(q.add(new Integer(i)));
123	}
124	}
125
126	public void testAddAll1(){
127	try {
128	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
129	q.addAll(null);
130	fail("Cannot add null collection");
131	}
132	catch (NullPointerException success) {}
133	}
134	public void testAddAll2(){
135	try {
136	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
137	Integer[] ints = new Integer[SIZE];
138	q.addAll(Arrays.asList(ints));
139	fail("Cannot add null elements");
140	}
141	catch (NullPointerException success) {}
142	}
143	public void testAddAll3(){
144	try {
145	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
146	Integer[] ints = new Integer[SIZE];
147	for (int i = 0; i < SIZE-1; ++i)
148	ints[i] = new Integer(i);
149	q.addAll(Arrays.asList(ints));
150	fail("Cannot add null elements");
151	}
152	catch (NullPointerException success) {}
153	}
154
155	public void testAddAll5(){
156	try {
157	Integer[] empty = new Integer[0];
158	Integer[] ints = new Integer[SIZE];
159	for (int i = 0; i < SIZE; ++i)
160	ints[i] = new Integer(i);
161	ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
162	assertFalse(q.addAll(Arrays.asList(empty)));
163	assertTrue(q.addAll(Arrays.asList(ints)));
164	for (int i = 0; i < SIZE; ++i)
165	assertEquals(ints[i], q.poll());
166	}
167	finally {}
168	}
169
170	public void testPoll(){
171	ConcurrentLinkedQueue q = populatedQueue(SIZE);
172	for (int i = 0; i < SIZE; ++i) {
173	assertEquals(i, ((Integer)q.poll()).intValue());
174	}
175	assertNull(q.poll());
176	}
177
178	public void testPeek(){
179	ConcurrentLinkedQueue q = populatedQueue(SIZE);
180	for (int i = 0; i < SIZE; ++i) {
181	assertEquals(i, ((Integer)q.peek()).intValue());
182	q.poll();
183	assertTrue(q.peek() == null \|\|
184	i != ((Integer)q.peek()).intValue());
185	}
186	assertNull(q.peek());
187	}
188
189	public void testElement(){
190	ConcurrentLinkedQueue q = populatedQueue(SIZE);
191	for (int i = 0; i < SIZE; ++i) {
192	assertEquals(i, ((Integer)q.element()).intValue());
193	q.poll();
194	}
195	try {
196	q.element();
197	fail("no such element");
198	}
199	catch (NoSuchElementException success) {}
200	}
201
202	public void testRemove(){
203	ConcurrentLinkedQueue q = populatedQueue(SIZE);
204	for (int i = 0; i < SIZE; ++i) {
205	assertEquals(i, ((Integer)q.remove()).intValue());
206	}
207	try {
208	q.remove();
209	fail("remove should throw");
210	} catch (NoSuchElementException success){
211	}
212	}
213
214	public void testRemoveElement(){
215	ConcurrentLinkedQueue q = populatedQueue(SIZE);
216	for (int i = 1; i < SIZE; i+=2) {
217	assertTrue(q.remove(new Integer(i)));
218	}
219	for (int i = 0; i < SIZE; i+=2) {
220	assertTrue(q.remove(new Integer(i)));
221	assertFalse(q.remove(new Integer(i+1)));
222	}
223	assertTrue(q.isEmpty());
224	}
225
226	public void testContains(){
227	ConcurrentLinkedQueue q = populatedQueue(SIZE);
228	for (int i = 0; i < SIZE; ++i) {
229	assertTrue(q.contains(new Integer(i)));
230	q.poll();
231	assertFalse(q.contains(new Integer(i)));
232	}
233	}
234
235	public void testClear(){
236	ConcurrentLinkedQueue q = populatedQueue(SIZE);
237	q.clear();
238	assertTrue(q.isEmpty());
239	assertEquals(0, q.size());
240	q.add(one);
241	assertFalse(q.isEmpty());
242	q.clear();
243	assertTrue(q.isEmpty());
244	}
245
246	public void testContainsAll(){
247	ConcurrentLinkedQueue q = populatedQueue(SIZE);
248	ConcurrentLinkedQueue p = new ConcurrentLinkedQueue();
249	for (int i = 0; i < SIZE; ++i) {
250	assertTrue(q.containsAll(p));
251	assertFalse(p.containsAll(q));
252	p.add(new Integer(i));
253	}
254	assertTrue(p.containsAll(q));
255	}
256
257	public void testRetainAll(){
258	ConcurrentLinkedQueue q = populatedQueue(SIZE);
259	ConcurrentLinkedQueue p = populatedQueue(SIZE);
260	for (int i = 0; i < SIZE; ++i) {
261	boolean changed = q.retainAll(p);
262	if (i == 0)
263	assertFalse(changed);
264	else
265	assertTrue(changed);
266
267	assertTrue(q.containsAll(p));
268	assertEquals(SIZE-i, q.size());
269	p.remove();
270	}
271	}
272
273	public void testRemoveAll(){
274	for (int i = 1; i < SIZE; ++i) {
275	ConcurrentLinkedQueue q = populatedQueue(SIZE);
276	ConcurrentLinkedQueue p = populatedQueue(i);
277	assertTrue(q.removeAll(p));
278	assertEquals(SIZE-i, q.size());
279	for (int j = 0; j < i; ++j) {
280	Integer I = (Integer)(p.remove());
281	assertFalse(q.contains(I));
282	}
283	}
284	}
285
286	public void testToArray(){
287	ConcurrentLinkedQueue q = populatedQueue(SIZE);
288	Object[] o = q.toArray();
289	Arrays.sort(o);
290	for(int i = 0; i < o.length; i++)
291	assertEquals(o[i], q.poll());
292	}
293
294	public void testToArray2(){
295	ConcurrentLinkedQueue q = populatedQueue(SIZE);
296	Integer[] ints = new Integer[SIZE];
297	ints = (Integer[])q.toArray(ints);
298	Arrays.sort(ints);
299	for(int i = 0; i < ints.length; i++)
300	assertEquals(ints[i], q.poll());
301	}
302
303	public void testIterator(){
304	ConcurrentLinkedQueue q = populatedQueue(SIZE);
305	int i = 0;
306	Iterator it = q.iterator();
307	while(it.hasNext()) {
308	assertTrue(q.contains(it.next()));
309	++i;
310	}
311	assertEquals(i, SIZE);
312	}
313
314	public void testIteratorOrdering() {
315	final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
316	q.add(one);
317	q.add(two);
318	q.add(three);
319
320	int k = 0;
321	for (Iterator it = q.iterator(); it.hasNext();) {
322	int i = ((Integer)(it.next())).intValue();
323	assertEquals("items should come out in order", ++k, i);
324	}
325
326	assertEquals("should go through 3 elements", 3, k);
327	}
328
329	public void testWeaklyConsistentIteration () {
330	final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
331	q.add(one);
332	q.add(two);
333	q.add(three);
334
335	try {
336	for (Iterator it = q.iterator(); it.hasNext();) {
337	q.remove();
338	it.next();
339	}
340	}
341	catch (ConcurrentModificationException e) {
342	fail("weakly consistent iterator; should not get CME");
343	}
344
345	assertEquals("queue should be empty again", 0, q.size());
346	}
347
348	public void testIteratorRemove () {
349	final ConcurrentLinkedQueue q = new ConcurrentLinkedQueue();
350	q.add(one);
351	q.add(two);
352	q.add(three);
353	Iterator it = q.iterator();
354	it.next();
355	it.remove();
356	it = q.iterator();
357	assertEquals(it.next(), two);
358	assertEquals(it.next(), three);
359	assertFalse(it.hasNext());
360	}
361
362
363	public void testToString(){
364	ConcurrentLinkedQueue q = populatedQueue(SIZE);
365	String s = q.toString();
366	for (int i = 0; i < SIZE; ++i) {
367	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
368	}
369	}
370
371	public void testSerialization() {
372	ConcurrentLinkedQueue q = populatedQueue(SIZE);
373	try {
374	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
375	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
376	out.writeObject(q);
377	out.close();
378
379	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
380	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
381	ConcurrentLinkedQueue r = (ConcurrentLinkedQueue)in.readObject();
382	assertEquals(q.size(), r.size());
383	while (!q.isEmpty())
384	assertEquals(q.remove(), r.remove());
385	} catch(Exception e){
386	e.printStackTrace();
387	fail("unexpected exception");
388	}
389	}
390
391	}