test/tck/LinkedListTest.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.*;

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

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

    /**
     * Create a queue of given size containing consecutive
     * Integers 0 ... n.
     */
    private LinkedList populatedQueue(int n) {
        LinkedList q = new LinkedList();
        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 LinkedList().size());
    }

    /**
     *
     */
    public void testConstructor3() {
        try {
            LinkedList q = new LinkedList((Collection)null);
            shouldThrow();
        }
        catch (NullPointerException success) {}
    }

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

    /**
     *
     */
    public void testEmpty() {
        LinkedList q = new LinkedList();
        assertTrue(q.isEmpty());
        q.add(new Integer(1));
        assertFalse(q.isEmpty());
        q.add(new Integer(2));
        q.remove();
        q.remove();
        assertTrue(q.isEmpty());
    }

    /**
     *
     */
    public void testSize() {
        LinkedList 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 {
            LinkedList q = new LinkedList();
            q.offer(null);
        } catch (NullPointerException ie) { 
            unexpectedException();
        }   
    }

    /**
     *
     */
    public void testOffer() {
        LinkedList q = new LinkedList();
        assertTrue(q.offer(new Integer(0)));
        assertTrue(q.offer(new Integer(1)));
    }

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

    /**
     *
     */
    public void testAddAll1() {
        try {
            LinkedList q = new LinkedList();
            q.addAll(null);
            shouldThrow();
        }
        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);
            LinkedList q = new LinkedList();
            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() {
        LinkedList q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            assertEquals(i, ((Integer)q.poll()).intValue());
        }
        assertNull(q.poll());
    }

    /**
     *
     */
    public void testPeek() {
        LinkedList 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() {
        LinkedList q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            assertEquals(i, ((Integer)q.element()).intValue());
            q.poll();
        }
        try {
            q.element();
            shouldThrow();
        }
        catch (NoSuchElementException success) {}
    }

    /**
     *
     */
    public void testRemove() {
        LinkedList q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            assertEquals(i, ((Integer)q.remove()).intValue());
        }
        try {
            q.remove();
            shouldThrow();
        } catch (NoSuchElementException success){
        }   
    }

    /**
     *
     */
    public void testRemoveElement() {
        LinkedList 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() {
        LinkedList 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() {
        LinkedList q = populatedQueue(SIZE);
        q.clear();
        assertTrue(q.isEmpty());
        assertEquals(0, q.size());
        q.add(new Integer(1));
        assertFalse(q.isEmpty());
        q.clear();
        assertTrue(q.isEmpty());
    }

    /**
     *
     */
    public void testContainsAll() {
        LinkedList q = populatedQueue(SIZE);
        LinkedList p = new LinkedList();
        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() {
        LinkedList q = populatedQueue(SIZE);
        LinkedList 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) {
            LinkedList q = populatedQueue(SIZE);
            LinkedList 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() {
        LinkedList 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() {
        LinkedList 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() {
        LinkedList 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 LinkedList q = new LinkedList();

        q.add(new Integer(1));
        q.add(new Integer(2));
        q.add(new Integer(3));

        int k = 0;
        for (Iterator it = q.iterator(); it.hasNext();) {
            int i = ((Integer)(it.next())).intValue();
            assertEquals(++k, i);
        }

        assertEquals(3, k);
    }

    /**
     *
     */
    public void testIteratorRemove () {
        final LinkedList q = new LinkedList();

        q.add(new Integer(1));
        q.add(new Integer(2));
        q.add(new Integer(3));

        Iterator it = q.iterator();
        it.next();
        it.remove();

        it = q.iterator();
        assertEquals(it.next(), new Integer(2));
        assertEquals(it.next(), new Integer(3));
        assertFalse(it.hasNext());
    }


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

    /**
     *
     */
    public void testAddFirst() {
        LinkedList q = populatedQueue(3);
        q.addFirst(new Integer(4));
        assertEquals(new Integer(4),q.get(0));
    }   

    /**
     *
     */
    public void testAddLast() {
        LinkedList q = populatedQueue(3);
        q.addLast(new Integer(3));
        assertEquals(new Integer(3),q.get(3));
    }
    
    /**
     *
     */
    public void testGetFirst() {
        LinkedList q = populatedQueue(3);
        assertEquals(new Integer(0),q.getFirst());
    }   
    
    /**
     *
     */
    public void testGetLast() {
        LinkedList q = populatedQueue(3);
        assertEquals(new Integer(2),q.getLast());
    }
    
    /**
     *
     */
    public void testIndexOf() {
        LinkedList q = populatedQueue(3);
        assertEquals(0,q.indexOf(new Integer(0)));
        assertEquals(1,q.indexOf(new Integer(1)));
        assertEquals(2,q.indexOf(new Integer(2)));
        assertEquals(-1, q.indexOf("not there")); 
    }

    /**
     *
     */
    public void testLastIndexOf() {
        LinkedList q = populatedQueue(3);
        q.add(new Integer(2));
        assertEquals(3,q.lastIndexOf(new Integer(2)));
        assertEquals(-1, q.lastIndexOf("not there"));
    }
    
    /**
     *
     */
    public void testSet() {
        LinkedList q = populatedQueue(3);
        q.set(0,(new Integer(1)));
        assertFalse(q.contains(new Integer(0)));
        assertEquals(new Integer(1), q.get(0));
    }
    

    /**
     *
     */
    public void testGetFirst_NoSuchElementException() {
        try {
            LinkedList l = new LinkedList();
            l.getFirst();
            shouldThrow();
        }
        catch(NoSuchElementException success) {}
    }
    
    /**
     *
     */
    public void testRemoveFirst() {
        try {
            LinkedList l = new LinkedList();
            l.removeFirst();
            shouldThrow();
        }
        catch(NoSuchElementException success) {}
    }
    
    /**
     *
     */
    public void testRemoveLast() {
        try {
            LinkedList l = new LinkedList();
            l.removeLast();
            shouldThrow();
        }
        catch(NoSuchElementException success) {}
    }
    
    /**
     *
     */
    public void testGetLast_NoSuchElementException() {
        try {
            LinkedList l = new LinkedList();
            l.getLast();
            shouldThrow();
        }
        catch(NoSuchElementException success) {}
    }


    /**
     *
     */
    public void testAddAll_NullPointerException() {
        try {
            LinkedList l = new LinkedList(); 
            l.addAll((Collection)null);
            shouldThrow();
        }
        catch(NullPointerException success){}
    }
    
    
    /**
     *
     */
    public void testAddAll1_OutOfBounds() {
        try {
            LinkedList l = new LinkedList(); 
            l.addAll(4,new LinkedList());
            shouldThrow();
        }
        catch(IndexOutOfBoundsException  success) {}
    }
    
    
    /**
     *
     */
    public void testAddAll2_IndexOutOfBoundsException() {
        try {
            LinkedList l = new LinkedList();
            l.add(new Object());
            LinkedList m = new LinkedList();
            m.add(new Object());
            l.addAll(4,m);
            shouldThrow();
        } catch(IndexOutOfBoundsException  success) {}
    }

    /**
     *
     */
    public void testAddAll4_BadIndex() {
        try {
            LinkedList l = new LinkedList();
            l.add(new Object());
            LinkedList m = new LinkedList();
            m.add(new Object());
            l.addAll(-1,m);
            shouldThrow();
        } catch(IndexOutOfBoundsException  success){}
    }

    /**
     *
     */
    public void testget1() {
        try {
            LinkedList l = new LinkedList();
            l.add(new Object());
            l.get(-1);
            shouldThrow();
        } catch(IndexOutOfBoundsException  success) {}  
    }

    /**
     *
     */
    public void testget2() {
        try {
            LinkedList l = new LinkedList();
            l.add(new Object());
            l.get(5);
            shouldThrow();
        } catch(IndexOutOfBoundsException  success){}   
    }

    /**
     *
     */
    public void testset1() {
        try {
            LinkedList l = new LinkedList();
            l.add(new Object());
            l.set(-1,new Object());
            shouldThrow();
        } catch(IndexOutOfBoundsException  success){}   
    }

    /**
     *
     */
    public void testset2() {
        try {
            LinkedList l = new LinkedList();
            l.add(new Object());
            l.set(5,new Object());
            shouldThrow();
        } catch(IndexOutOfBoundsException  success){}   
    }

    /**
     *
     */
    public void testadd1() {
        try {
            LinkedList l = new LinkedList();
            l.add(new Object());
            l.add(-1,new Object());
            shouldThrow();
        } catch(IndexOutOfBoundsException  success){}   
    }

    public void add2() {
        try {
            LinkedList l = new LinkedList();
            l.add(new Object());
            l.add(5,new Object());
            shouldThrow();
        } catch(IndexOutOfBoundsException  success) {}  
    }

    /**
     *
     */
    public void testremove() {
        try {
            LinkedList l = new LinkedList();
            l.add(new Object());
            l.remove(-1);
            shouldThrow();
        } catch(IndexOutOfBoundsException  success){}
    }
    
    /**
     *
     */
    public void testremove1() {
        try {
            LinkedList l = new LinkedList();
            l.add(new Object());
            l.remove(5);
            shouldThrow();
        } catch(IndexOutOfBoundsException  success){}
    }

     
    /**
     *
     */
    public void testremove2() {
        try {
            LinkedList l = new LinkedList();
            l.remove();
            shouldThrow();
        } catch(NoSuchElementException e){}     
    }

    /**
     *
     */
    public void testlistIt1() {
        try {
            LinkedList l = new LinkedList();
            l.add(new Object());
            l.listIterator(5);
            shouldThrow();
        } catch(IndexOutOfBoundsException  success){}
    }
    
    /**
     *
     */
    public void testlistIt2() {
        try {
            LinkedList l = new LinkedList();
            l.add(new Object());
            l.listIterator(-1);
            shouldThrow();
        } catch(IndexOutOfBoundsException  success){}
    }
    
    /**
     *
     */
    public void testlistIt3() {
        try {
            LinkedList l = new LinkedList();
            l.add(new Object());
            ListIterator a = l.listIterator(0);
            l.removeFirst();
            a.next();
            shouldThrow();
        } catch(ConcurrentModificationException success){}
    }

    /**
     *
     */
    public void testToArray_BadArg() {
        try {
            LinkedList l = new LinkedList();
            l.add(new Object());
            Object o[] = l.toArray(null);
            shouldThrow();
        } catch(NullPointerException success){}
    }

    /**
     *
     */
    public void testToArray1_BadArg() {
        try {
            LinkedList l = new LinkedList();
            l.add(new Integer(5));
            Object o[] = l.toArray(new String[10] );
            shouldThrow();
        } catch(ArrayStoreException  success){}
    }

}
Revision:	1.4
Committed:	Sat Sep 20 18:20:08 2003 UTC (20 years, 8 months ago) by dl
Branch:	MAIN
Changes since 1.3:	+240 -78 lines
Log Message:	Documentation scaffolding
#	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
12	public class LinkedListTest extends JSR166TestCase {
13	public static void main(String[] args) {
14	junit.textui.TestRunner.run (suite());
15	}
16
17	public static Test suite() {
18	return new TestSuite(LinkedListTest.class);
19	}
20
21	/**
22	* Create a queue of given size containing consecutive
23	* Integers 0 ... n.
24	*/
25	private LinkedList populatedQueue(int n) {
26	LinkedList q = new LinkedList();
27	assertTrue(q.isEmpty());
28	for(int i = 0; i < n; ++i)
29	assertTrue(q.offer(new Integer(i)));
30	assertFalse(q.isEmpty());
31	assertEquals(n, q.size());
32	return q;
33	}
34
35	/**
36	*
37	*/
38	public void testConstructor1() {
39	assertEquals(0, new LinkedList().size());
40	}
41
42	/**
43	*
44	*/
45	public void testConstructor3() {
46	try {
47	LinkedList q = new LinkedList((Collection)null);
48	shouldThrow();
49	}
50	catch (NullPointerException success) {}
51	}
52
53	/**
54	*
55	*/
56	public void testConstructor6() {
57	try {
58	Integer[] ints = new Integer[SIZE];
59	for (int i = 0; i < SIZE; ++i)
60	ints[i] = new Integer(i);
61	LinkedList q = new LinkedList(Arrays.asList(ints));
62	for (int i = 0; i < SIZE; ++i)
63	assertEquals(ints[i], q.poll());
64	}
65	finally {}
66	}
67
68	/**
69	*
70	*/
71	public void testEmpty() {
72	LinkedList q = new LinkedList();
73	assertTrue(q.isEmpty());
74	q.add(new Integer(1));
75	assertFalse(q.isEmpty());
76	q.add(new Integer(2));
77	q.remove();
78	q.remove();
79	assertTrue(q.isEmpty());
80	}
81
82	/**
83	*
84	*/
85	public void testSize() {
86	LinkedList q = populatedQueue(SIZE);
87	for (int i = 0; i < SIZE; ++i) {
88	assertEquals(SIZE-i, q.size());
89	q.remove();
90	}
91	for (int i = 0; i < SIZE; ++i) {
92	assertEquals(i, q.size());
93	q.add(new Integer(i));
94	}
95	}
96
97	/**
98	*
99	*/
100	public void testOfferNull() {
101	try {
102	LinkedList q = new LinkedList();
103	q.offer(null);
104	} catch (NullPointerException ie) {
105	unexpectedException();
106	}
107	}
108
109	/**
110	*
111	*/
112	public void testOffer() {
113	LinkedList q = new LinkedList();
114	assertTrue(q.offer(new Integer(0)));
115	assertTrue(q.offer(new Integer(1)));
116	}
117
118	/**
119	*
120	*/
121	public void testAdd() {
122	LinkedList q = new LinkedList();
123	for (int i = 0; i < SIZE; ++i) {
124	assertEquals(i, q.size());
125	assertTrue(q.add(new Integer(i)));
126	}
127	}
128
129	/**
130	*
131	*/
132	public void testAddAll1() {
133	try {
134	LinkedList q = new LinkedList();
135	q.addAll(null);
136	shouldThrow();
137	}
138	catch (NullPointerException success) {}
139	}
140
141	/**
142	*
143	*/
144	public void testAddAll5() {
145	try {
146	Integer[] empty = new Integer[0];
147	Integer[] ints = new Integer[SIZE];
148	for (int i = 0; i < SIZE; ++i)
149	ints[i] = new Integer(i);
150	LinkedList q = new LinkedList();
151	assertFalse(q.addAll(Arrays.asList(empty)));
152	assertTrue(q.addAll(Arrays.asList(ints)));
153	for (int i = 0; i < SIZE; ++i)
154	assertEquals(ints[i], q.poll());
155	}
156	finally {}
157	}
158
159	/**
160	*
161	*/
162	public void testPoll() {
163	LinkedList q = populatedQueue(SIZE);
164	for (int i = 0; i < SIZE; ++i) {
165	assertEquals(i, ((Integer)q.poll()).intValue());
166	}
167	assertNull(q.poll());
168	}
169
170	/**
171	*
172	*/
173	public void testPeek() {
174	LinkedList q = populatedQueue(SIZE);
175	for (int i = 0; i < SIZE; ++i) {
176	assertEquals(i, ((Integer)q.peek()).intValue());
177	q.poll();
178	assertTrue(q.peek() == null \|\|
179	i != ((Integer)q.peek()).intValue());
180	}
181	assertNull(q.peek());
182	}
183
184	/**
185	*
186	*/
187	public void testElement() {
188	LinkedList q = populatedQueue(SIZE);
189	for (int i = 0; i < SIZE; ++i) {
190	assertEquals(i, ((Integer)q.element()).intValue());
191	q.poll();
192	}
193	try {
194	q.element();
195	shouldThrow();
196	}
197	catch (NoSuchElementException success) {}
198	}
199
200	/**
201	*
202	*/
203	public void testRemove() {
204	LinkedList q = populatedQueue(SIZE);
205	for (int i = 0; i < SIZE; ++i) {
206	assertEquals(i, ((Integer)q.remove()).intValue());
207	}
208	try {
209	q.remove();
210	shouldThrow();
211	} catch (NoSuchElementException success){
212	}
213	}
214
215	/**
216	*
217	*/
218	public void testRemoveElement() {
219	LinkedList q = populatedQueue(SIZE);
220	for (int i = 1; i < SIZE; i+=2) {
221	assertTrue(q.remove(new Integer(i)));
222	}
223	for (int i = 0; i < SIZE; i+=2) {
224	assertTrue(q.remove(new Integer(i)));
225	assertFalse(q.remove(new Integer(i+1)));
226	}
227	assertTrue(q.isEmpty());
228	}
229
230	/**
231	*
232	*/
233	public void testContains() {
234	LinkedList q = populatedQueue(SIZE);
235	for (int i = 0; i < SIZE; ++i) {
236	assertTrue(q.contains(new Integer(i)));
237	q.poll();
238	assertFalse(q.contains(new Integer(i)));
239	}
240	}
241
242	/**
243	*
244	*/
245	public void testClear() {
246	LinkedList q = populatedQueue(SIZE);
247	q.clear();
248	assertTrue(q.isEmpty());
249	assertEquals(0, q.size());
250	q.add(new Integer(1));
251	assertFalse(q.isEmpty());
252	q.clear();
253	assertTrue(q.isEmpty());
254	}
255
256	/**
257	*
258	*/
259	public void testContainsAll() {
260	LinkedList q = populatedQueue(SIZE);
261	LinkedList p = new LinkedList();
262	for (int i = 0; i < SIZE; ++i) {
263	assertTrue(q.containsAll(p));
264	assertFalse(p.containsAll(q));
265	p.add(new Integer(i));
266	}
267	assertTrue(p.containsAll(q));
268	}
269
270	/**
271	*
272	*/
273	public void testRetainAll() {
274	LinkedList q = populatedQueue(SIZE);
275	LinkedList p = populatedQueue(SIZE);
276	for (int i = 0; i < SIZE; ++i) {
277	boolean changed = q.retainAll(p);
278	if (i == 0)
279	assertFalse(changed);
280	else
281	assertTrue(changed);
282
283	assertTrue(q.containsAll(p));
284	assertEquals(SIZE-i, q.size());
285	p.remove();
286	}
287	}
288
289	/**
290	*
291	*/
292	public void testRemoveAll() {
293	for (int i = 1; i < SIZE; ++i) {
294	LinkedList q = populatedQueue(SIZE);
295	LinkedList p = populatedQueue(i);
296	assertTrue(q.removeAll(p));
297	assertEquals(SIZE-i, q.size());
298	for (int j = 0; j < i; ++j) {
299	Integer I = (Integer)(p.remove());
300	assertFalse(q.contains(I));
301	}
302	}
303	}
304
305	/**
306	*
307	*/
308	public void testToArray() {
309	LinkedList q = populatedQueue(SIZE);
310	Object[] o = q.toArray();
311	Arrays.sort(o);
312	for(int i = 0; i < o.length; i++)
313	assertEquals(o[i], q.poll());
314	}
315
316	/**
317	*
318	*/
319	public void testToArray2() {
320	LinkedList q = populatedQueue(SIZE);
321	Integer[] ints = new Integer[SIZE];
322	ints = (Integer[])q.toArray(ints);
323	Arrays.sort(ints);
324	for(int i = 0; i < ints.length; i++)
325	assertEquals(ints[i], q.poll());
326	}
327
328	/**
329	*
330	*/
331	public void testIterator() {
332	LinkedList q = populatedQueue(SIZE);
333	int i = 0;
334	Iterator it = q.iterator();
335	while(it.hasNext()) {
336	assertTrue(q.contains(it.next()));
337	++i;
338	}
339	assertEquals(i, SIZE);
340	}
341
342	/**
343	*
344	*/
345	public void testIteratorOrdering() {
346
347	final LinkedList q = new LinkedList();
348
349	q.add(new Integer(1));
350	q.add(new Integer(2));
351	q.add(new Integer(3));
352
353	int k = 0;
354	for (Iterator it = q.iterator(); it.hasNext();) {
355	int i = ((Integer)(it.next())).intValue();
356	assertEquals(++k, i);
357	}
358
359	assertEquals(3, k);
360	}
361
362	/**
363	*
364	*/
365	public void testIteratorRemove () {
366	final LinkedList q = new LinkedList();
367
368	q.add(new Integer(1));
369	q.add(new Integer(2));
370	q.add(new Integer(3));
371
372	Iterator it = q.iterator();
373	it.next();
374	it.remove();
375
376	it = q.iterator();
377	assertEquals(it.next(), new Integer(2));
378	assertEquals(it.next(), new Integer(3));
379	assertFalse(it.hasNext());
380	}
381
382
383	/**
384	*
385	*/
386	public void testToString() {
387	LinkedList q = populatedQueue(SIZE);
388	String s = q.toString();
389	for (int i = 0; i < SIZE; ++i) {
390	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
391	}
392	}
393
394	/**
395	*
396	*/
397	public void testAddFirst() {
398	LinkedList q = populatedQueue(3);
399	q.addFirst(new Integer(4));
400	assertEquals(new Integer(4),q.get(0));
401	}
402
403	/**
404	*
405	*/
406	public void testAddLast() {
407	LinkedList q = populatedQueue(3);
408	q.addLast(new Integer(3));
409	assertEquals(new Integer(3),q.get(3));
410	}
411
412	/**
413	*
414	*/
415	public void testGetFirst() {
416	LinkedList q = populatedQueue(3);
417	assertEquals(new Integer(0),q.getFirst());
418	}
419
420	/**
421	*
422	*/
423	public void testGetLast() {
424	LinkedList q = populatedQueue(3);
425	assertEquals(new Integer(2),q.getLast());
426	}
427
428	/**
429	*
430	*/
431	public void testIndexOf() {
432	LinkedList q = populatedQueue(3);
433	assertEquals(0,q.indexOf(new Integer(0)));
434	assertEquals(1,q.indexOf(new Integer(1)));
435	assertEquals(2,q.indexOf(new Integer(2)));
436	assertEquals(-1, q.indexOf("not there"));
437	}
438
439	/**
440	*
441	*/
442	public void testLastIndexOf() {
443	LinkedList q = populatedQueue(3);
444	q.add(new Integer(2));
445	assertEquals(3,q.lastIndexOf(new Integer(2)));
446	assertEquals(-1, q.lastIndexOf("not there"));
447	}
448
449	/**
450	*
451	*/
452	public void testSet() {
453	LinkedList q = populatedQueue(3);
454	q.set(0,(new Integer(1)));
455	assertFalse(q.contains(new Integer(0)));
456	assertEquals(new Integer(1), q.get(0));
457	}
458
459
460	/**
461	*
462	*/
463	public void testGetFirst_NoSuchElementException() {
464	try {
465	LinkedList l = new LinkedList();
466	l.getFirst();
467	shouldThrow();
468	}
469	catch(NoSuchElementException success) {}
470	}
471
472	/**
473	*
474	*/
475	public void testRemoveFirst() {
476	try {
477	LinkedList l = new LinkedList();
478	l.removeFirst();
479	shouldThrow();
480	}
481	catch(NoSuchElementException success) {}
482	}
483
484	/**
485	*
486	*/
487	public void testRemoveLast() {
488	try {
489	LinkedList l = new LinkedList();
490	l.removeLast();
491	shouldThrow();
492	}
493	catch(NoSuchElementException success) {}
494	}
495
496	/**
497	*
498	*/
499	public void testGetLast_NoSuchElementException() {
500	try {
501	LinkedList l = new LinkedList();
502	l.getLast();
503	shouldThrow();
504	}
505	catch(NoSuchElementException success) {}
506	}
507
508
509	/**
510	*
511	*/
512	public void testAddAll_NullPointerException() {
513	try {
514	LinkedList l = new LinkedList();
515	l.addAll((Collection)null);
516	shouldThrow();
517	}
518	catch(NullPointerException success){}
519	}
520
521
522	/**
523	*
524	*/
525	public void testAddAll1_OutOfBounds() {
526	try {
527	LinkedList l = new LinkedList();
528	l.addAll(4,new LinkedList());
529	shouldThrow();
530	}
531	catch(IndexOutOfBoundsException success) {}
532	}
533
534
535	/**
536	*
537	*/
538	public void testAddAll2_IndexOutOfBoundsException() {
539	try {
540	LinkedList l = new LinkedList();
541	l.add(new Object());
542	LinkedList m = new LinkedList();
543	m.add(new Object());
544	l.addAll(4,m);
545	shouldThrow();
546	} catch(IndexOutOfBoundsException success) {}
547	}
548
549	/**
550	*
551	*/
552	public void testAddAll4_BadIndex() {
553	try {
554	LinkedList l = new LinkedList();
555	l.add(new Object());
556	LinkedList m = new LinkedList();
557	m.add(new Object());
558	l.addAll(-1,m);
559	shouldThrow();
560	} catch(IndexOutOfBoundsException success){}
561	}
562
563	/**
564	*
565	*/
566	public void testget1() {
567	try {
568	LinkedList l = new LinkedList();
569	l.add(new Object());
570	l.get(-1);
571	shouldThrow();
572	} catch(IndexOutOfBoundsException success) {}
573	}
574
575	/**
576	*
577	*/
578	public void testget2() {
579	try {
580	LinkedList l = new LinkedList();
581	l.add(new Object());
582	l.get(5);
583	shouldThrow();
584	} catch(IndexOutOfBoundsException success){}
585	}
586
587	/**
588	*
589	*/
590	public void testset1() {
591	try {
592	LinkedList l = new LinkedList();
593	l.add(new Object());
594	l.set(-1,new Object());
595	shouldThrow();
596	} catch(IndexOutOfBoundsException success){}
597	}
598
599	/**
600	*
601	*/
602	public void testset2() {
603	try {
604	LinkedList l = new LinkedList();
605	l.add(new Object());
606	l.set(5,new Object());
607	shouldThrow();
608	} catch(IndexOutOfBoundsException success){}
609	}
610
611	/**
612	*
613	*/
614	public void testadd1() {
615	try {
616	LinkedList l = new LinkedList();
617	l.add(new Object());
618	l.add(-1,new Object());
619	shouldThrow();
620	} catch(IndexOutOfBoundsException success){}
621	}
622
623	public void add2() {
624	try {
625	LinkedList l = new LinkedList();
626	l.add(new Object());
627	l.add(5,new Object());
628	shouldThrow();
629	} catch(IndexOutOfBoundsException success) {}
630	}
631
632	/**
633	*
634	*/
635	public void testremove() {
636	try {
637	LinkedList l = new LinkedList();
638	l.add(new Object());
639	l.remove(-1);
640	shouldThrow();
641	} catch(IndexOutOfBoundsException success){}
642	}
643
644	/**
645	*
646	*/
647	public void testremove1() {
648	try {
649	LinkedList l = new LinkedList();
650	l.add(new Object());
651	l.remove(5);
652	shouldThrow();
653	} catch(IndexOutOfBoundsException success){}
654	}
655
656
657	/**
658	*
659	*/
660	public void testremove2() {
661	try {
662	LinkedList l = new LinkedList();
663	l.remove();
664	shouldThrow();
665	} catch(NoSuchElementException e){}
666	}
667
668	/**
669	*
670	*/
671	public void testlistIt1() {
672	try {
673	LinkedList l = new LinkedList();
674	l.add(new Object());
675	l.listIterator(5);
676	shouldThrow();
677	} catch(IndexOutOfBoundsException success){}
678	}
679
680	/**
681	*
682	*/
683	public void testlistIt2() {
684	try {
685	LinkedList l = new LinkedList();
686	l.add(new Object());
687	l.listIterator(-1);
688	shouldThrow();
689	} catch(IndexOutOfBoundsException success){}
690	}
691
692	/**
693	*
694	*/
695	public void testlistIt3() {
696	try {
697	LinkedList l = new LinkedList();
698	l.add(new Object());
699	ListIterator a = l.listIterator(0);
700	l.removeFirst();
701	a.next();
702	shouldThrow();
703	} catch(ConcurrentModificationException success){}
704	}
705
706	/**
707	*
708	*/
709	public void testToArray_BadArg() {
710	try {
711	LinkedList l = new LinkedList();
712	l.add(new Object());
713	Object o[] = l.toArray(null);
714	shouldThrow();
715	} catch(NullPointerException success){}
716	}
717
718	/**
719	*
720	*/
721	public void testToArray1_BadArg() {
722	try {
723	LinkedList l = new LinkedList();
724	l.add(new Integer(5));
725	Object o[] = l.toArray(new String[10] );
726	shouldThrow();
727	} catch(ArrayStoreException success){}
728	}
729
730	}