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;
    }
 
    /**
     * new queue is empty
     */
    public void testConstructor1() {
        assertEquals(0, new LinkedList().size());
    }

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

    /**
     * Queue contains all elements of collection used to initialize

     */
    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 {}
    }

    /**
     * isEmpty is true before add, false after
     */
    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());
    }

    /**
     * size changes when elements added and removed
     */
    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));
        }
    }

    /**
     * offer(null) succeeds
     */
    public void testOfferNull() {
        try {
            LinkedList q = new LinkedList();
            q.offer(null);
        } catch (NullPointerException ie) { 
            unexpectedException();
        }   
    }

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

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

    /**
     * addAll(null) throws NPE
     */
    public void testAddAll1() {
        try {
            LinkedList q = new LinkedList();
            q.addAll(null);
            shouldThrow();
        }
        catch (NullPointerException success) {}
    }

    /**
     * Queue contains all elements, in traversal order, of successful addAll
     */
    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 {}
    }

    /**
     * addAll with too large an index throws IOOBE
     */
    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) {}
    }

    /**
     * addAll with negative index throws IOOBE
     */
    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){}
    }

    /**
     *  poll succeeds unless empty
     */
    public void testPoll() {
        LinkedList q = populatedQueue(SIZE);
        for (int i = 0; i < SIZE; ++i) {
            assertEquals(i, ((Integer)q.poll()).intValue());
        }
        assertNull(q.poll());
    }

    /**
     *  peek returns next element, or null if empty
     */
    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) {}
    }

    /**
     * element returns next element, or throws NSEE if empty
     */
    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){
        }   
    }

    /**
     * remove(x) removes x and returns true if present
     */
    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());
    }
        
    /**
     * contains(x) reports true when elements added but not yet removed
     */
    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)));
        }
    }

    /**
     * clear removes all elements
     */
    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());
    }

    /**
     * containsAll(c) is true when c contains a subset of elements
     */
    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));
    }

    /**
     * retainAll(c) retains only those elements of c and reports true if changed
     */
    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();
        }
    }

    /**
     *  removeAll(c) removes only those elements of c and reports true if changed
     */
    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));
            }
        }
    }

    /**
     *  toArray contains all elements
     */
    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());
    }

    /**
     *  toArray(a) contains all elements
     */
    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());
    }

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

    /**
     * toArray with incompatable aray type throws CCE
     */
    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){}
    }
    
    /**
     *  iterator iterates through all elements
     */
    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);
    }

    /**
     *  iterator ordering is FIFO
     */
    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);
    }

    /**
     * iterator.remove removes current element
     */
    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());
    }


    /**
     * toString contains toStrings of elements
     */
    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);
        }
    }        

    /**
     * peek returns element inserted with addFirst
     */
    public void testAddFirst() {
        LinkedList q = populatedQueue(3);
        q.addFirst(four);
        assertEquals(four,q.peek());
    }   

}
Revision:	1.5
Committed:	Thu Sep 25 11:02:41 2003 UTC (20 years, 7 months ago) by dl
Branch:	MAIN
Changes since 1.4:	+82 -362 lines
Log Message:	improve tck javadocs; rename and add a few tests
#	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
12	dl	1.3	public class LinkedListTest extends JSR166TestCase {
13	dl	1.1	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	dl	1.3	private LinkedList populatedQueue(int n) {
26	dl	1.1	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	dl	1.4	/**
36	dl	1.5	* new queue is empty
37	dl	1.4	*/
38			public void testConstructor1() {
39	dl	1.1	assertEquals(0, new LinkedList().size());
40			}
41
42	dl	1.4	/**
43	dl	1.5	* Initializing from null Collection throws NPE
44	dl	1.4	*/
45	dl	1.1	public void testConstructor3() {
46			try {
47			LinkedList q = new LinkedList((Collection)null);
48	dl	1.4	shouldThrow();
49	dl	1.1	}
50			catch (NullPointerException success) {}
51			}
52
53	dl	1.4	/**
54	dl	1.5	* Queue contains all elements of collection used to initialize
55
56	dl	1.4	*/
57			public void testConstructor6() {
58	dl	1.1	try {
59	dl	1.3	Integer[] ints = new Integer[SIZE];
60			for (int i = 0; i < SIZE; ++i)
61	dl	1.1	ints[i] = new Integer(i);
62			LinkedList q = new LinkedList(Arrays.asList(ints));
63	dl	1.3	for (int i = 0; i < SIZE; ++i)
64	dl	1.1	assertEquals(ints[i], q.poll());
65			}
66			finally {}
67			}
68
69	dl	1.4	/**
70	dl	1.5	* isEmpty is true before add, false after
71	dl	1.4	*/
72	dl	1.1	public void testEmpty() {
73			LinkedList q = new LinkedList();
74			assertTrue(q.isEmpty());
75			q.add(new Integer(1));
76			assertFalse(q.isEmpty());
77			q.add(new Integer(2));
78			q.remove();
79			q.remove();
80			assertTrue(q.isEmpty());
81			}
82
83	dl	1.4	/**
84	dl	1.5	* size changes when elements added and removed
85	dl	1.4	*/
86	dl	1.1	public void testSize() {
87	dl	1.3	LinkedList q = populatedQueue(SIZE);
88			for (int i = 0; i < SIZE; ++i) {
89			assertEquals(SIZE-i, q.size());
90	dl	1.1	q.remove();
91			}
92	dl	1.3	for (int i = 0; i < SIZE; ++i) {
93	dl	1.1	assertEquals(i, q.size());
94			q.add(new Integer(i));
95			}
96			}
97
98	dl	1.4	/**
99	dl	1.5	* offer(null) succeeds
100	dl	1.4	*/
101			public void testOfferNull() {
102	dl	1.1	try {
103			LinkedList q = new LinkedList();
104			q.offer(null);
105			} catch (NullPointerException ie) {
106	dl	1.4	unexpectedException();
107	dl	1.1	}
108			}
109
110	dl	1.4	/**
111	dl	1.5	* Offer succeeds
112	dl	1.4	*/
113	dl	1.1	public void testOffer() {
114			LinkedList q = new LinkedList();
115			assertTrue(q.offer(new Integer(0)));
116			assertTrue(q.offer(new Integer(1)));
117			}
118
119	dl	1.4	/**
120	dl	1.5	* add succeeds
121	dl	1.4	*/
122			public void testAdd() {
123	dl	1.1	LinkedList q = new LinkedList();
124	dl	1.3	for (int i = 0; i < SIZE; ++i) {
125	dl	1.1	assertEquals(i, q.size());
126			assertTrue(q.add(new Integer(i)));
127			}
128			}
129
130	dl	1.4	/**
131	dl	1.5	* addAll(null) throws NPE
132	dl	1.4	*/
133			public void testAddAll1() {
134	dl	1.1	try {
135			LinkedList q = new LinkedList();
136			q.addAll(null);
137	dl	1.4	shouldThrow();
138	dl	1.1	}
139			catch (NullPointerException success) {}
140			}
141
142	dl	1.4	/**
143	dl	1.5	* Queue contains all elements, in traversal order, of successful addAll
144	dl	1.4	*/
145			public void testAddAll5() {
146	dl	1.1	try {
147			Integer[] empty = new Integer[0];
148	dl	1.3	Integer[] ints = new Integer[SIZE];
149			for (int i = 0; i < SIZE; ++i)
150	dl	1.1	ints[i] = new Integer(i);
151			LinkedList q = new LinkedList();
152			assertFalse(q.addAll(Arrays.asList(empty)));
153			assertTrue(q.addAll(Arrays.asList(ints)));
154	dl	1.3	for (int i = 0; i < SIZE; ++i)
155	dl	1.1	assertEquals(ints[i], q.poll());
156			}
157			finally {}
158			}
159
160	dl	1.4	/**
161	dl	1.5	* addAll with too large an index throws IOOBE
162			*/
163			public void testAddAll2_IndexOutOfBoundsException() {
164			try {
165			LinkedList l = new LinkedList();
166			l.add(new Object());
167			LinkedList m = new LinkedList();
168			m.add(new Object());
169			l.addAll(4,m);
170			shouldThrow();
171			} catch(IndexOutOfBoundsException success) {}
172			}
173
174			/**
175			* addAll with negative index throws IOOBE
176			*/
177			public void testAddAll4_BadIndex() {
178			try {
179			LinkedList l = new LinkedList();
180			l.add(new Object());
181			LinkedList m = new LinkedList();
182			m.add(new Object());
183			l.addAll(-1,m);
184			shouldThrow();
185			} catch(IndexOutOfBoundsException success){}
186			}
187
188			/**
189			* poll succeeds unless empty
190	dl	1.4	*/
191			public void testPoll() {
192	dl	1.3	LinkedList q = populatedQueue(SIZE);
193			for (int i = 0; i < SIZE; ++i) {
194	dl	1.1	assertEquals(i, ((Integer)q.poll()).intValue());
195			}
196			assertNull(q.poll());
197			}
198
199	dl	1.4	/**
200	dl	1.5	* peek returns next element, or null if empty
201	dl	1.4	*/
202			public void testPeek() {
203	dl	1.3	LinkedList q = populatedQueue(SIZE);
204			for (int i = 0; i < SIZE; ++i) {
205	dl	1.1	assertEquals(i, ((Integer)q.peek()).intValue());
206			q.poll();
207			assertTrue(q.peek() == null \|\|
208			i != ((Integer)q.peek()).intValue());
209			}
210			assertNull(q.peek());
211			}
212
213	dl	1.4	/**
214	dl	1.5	*
215	dl	1.4	*/
216			public void testElement() {
217	dl	1.3	LinkedList q = populatedQueue(SIZE);
218			for (int i = 0; i < SIZE; ++i) {
219	dl	1.1	assertEquals(i, ((Integer)q.element()).intValue());
220			q.poll();
221			}
222			try {
223			q.element();
224	dl	1.4	shouldThrow();
225	dl	1.1	}
226			catch (NoSuchElementException success) {}
227			}
228
229	dl	1.4	/**
230	dl	1.5	* element returns next element, or throws NSEE if empty
231	dl	1.4	*/
232			public void testRemove() {
233	dl	1.3	LinkedList q = populatedQueue(SIZE);
234			for (int i = 0; i < SIZE; ++i) {
235	dl	1.1	assertEquals(i, ((Integer)q.remove()).intValue());
236			}
237			try {
238			q.remove();
239	dl	1.4	shouldThrow();
240	dl	1.1	} catch (NoSuchElementException success){
241			}
242			}
243
244	dl	1.4	/**
245	dl	1.5	* remove(x) removes x and returns true if present
246	dl	1.4	*/
247			public void testRemoveElement() {
248	dl	1.3	LinkedList q = populatedQueue(SIZE);
249			for (int i = 1; i < SIZE; i+=2) {
250	dl	1.1	assertTrue(q.remove(new Integer(i)));
251			}
252	dl	1.3	for (int i = 0; i < SIZE; i+=2) {
253	dl	1.1	assertTrue(q.remove(new Integer(i)));
254			assertFalse(q.remove(new Integer(i+1)));
255			}
256	dl	1.2	assertTrue(q.isEmpty());
257	dl	1.1	}
258
259	dl	1.4	/**
260	dl	1.5	* contains(x) reports true when elements added but not yet removed
261	dl	1.4	*/
262			public void testContains() {
263	dl	1.3	LinkedList q = populatedQueue(SIZE);
264			for (int i = 0; i < SIZE; ++i) {
265	dl	1.1	assertTrue(q.contains(new Integer(i)));
266			q.poll();
267			assertFalse(q.contains(new Integer(i)));
268			}
269			}
270
271	dl	1.4	/**
272	dl	1.5	* clear removes all elements
273	dl	1.4	*/
274			public void testClear() {
275	dl	1.3	LinkedList q = populatedQueue(SIZE);
276	dl	1.1	q.clear();
277			assertTrue(q.isEmpty());
278			assertEquals(0, q.size());
279			q.add(new Integer(1));
280			assertFalse(q.isEmpty());
281			q.clear();
282			assertTrue(q.isEmpty());
283			}
284
285	dl	1.4	/**
286	dl	1.5	* containsAll(c) is true when c contains a subset of elements
287	dl	1.4	*/
288			public void testContainsAll() {
289	dl	1.3	LinkedList q = populatedQueue(SIZE);
290	dl	1.1	LinkedList p = new LinkedList();
291	dl	1.3	for (int i = 0; i < SIZE; ++i) {
292	dl	1.1	assertTrue(q.containsAll(p));
293			assertFalse(p.containsAll(q));
294			p.add(new Integer(i));
295			}
296			assertTrue(p.containsAll(q));
297			}
298
299	dl	1.4	/**
300	dl	1.5	* retainAll(c) retains only those elements of c and reports true if changed
301	dl	1.4	*/
302			public void testRetainAll() {
303	dl	1.3	LinkedList q = populatedQueue(SIZE);
304			LinkedList p = populatedQueue(SIZE);
305			for (int i = 0; i < SIZE; ++i) {
306	dl	1.1	boolean changed = q.retainAll(p);
307			if (i == 0)
308			assertFalse(changed);
309			else
310			assertTrue(changed);
311
312			assertTrue(q.containsAll(p));
313	dl	1.3	assertEquals(SIZE-i, q.size());
314	dl	1.1	p.remove();
315			}
316			}
317
318	dl	1.4	/**
319	dl	1.5	* removeAll(c) removes only those elements of c and reports true if changed
320	dl	1.4	*/
321			public void testRemoveAll() {
322	dl	1.3	for (int i = 1; i < SIZE; ++i) {
323			LinkedList q = populatedQueue(SIZE);
324			LinkedList p = populatedQueue(i);
325	dl	1.1	assertTrue(q.removeAll(p));
326	dl	1.3	assertEquals(SIZE-i, q.size());
327	dl	1.1	for (int j = 0; j < i; ++j) {
328			Integer I = (Integer)(p.remove());
329			assertFalse(q.contains(I));
330			}
331			}
332			}
333
334	dl	1.4	/**
335	dl	1.5	* toArray contains all elements
336	dl	1.4	*/
337			public void testToArray() {
338	dl	1.3	LinkedList q = populatedQueue(SIZE);
339	dl	1.1	Object[] o = q.toArray();
340			Arrays.sort(o);
341			for(int i = 0; i < o.length; i++)
342			assertEquals(o[i], q.poll());
343			}
344
345	dl	1.4	/**
346	dl	1.5	* toArray(a) contains all elements
347	dl	1.4	*/
348			public void testToArray2() {
349	dl	1.3	LinkedList q = populatedQueue(SIZE);
350			Integer[] ints = new Integer[SIZE];
351	dl	1.1	ints = (Integer[])q.toArray(ints);
352			Arrays.sort(ints);
353			for(int i = 0; i < ints.length; i++)
354			assertEquals(ints[i], q.poll());
355			}
356	dl	1.5
357			/**
358			* toArray(null) throws NPE
359			*/
360			public void testToArray_BadArg() {
361			try {
362			LinkedList l = new LinkedList();
363			l.add(new Object());
364			Object o[] = l.toArray(null);
365			shouldThrow();
366			} catch(NullPointerException success){}
367			}
368
369			/**
370			* toArray with incompatable aray type throws CCE
371			*/
372			public void testToArray1_BadArg() {
373			try {
374			LinkedList l = new LinkedList();
375			l.add(new Integer(5));
376			Object o[] = l.toArray(new String[10] );
377			shouldThrow();
378			} catch(ArrayStoreException success){}
379			}
380	dl	1.1
381	dl	1.4	/**
382	dl	1.5	* iterator iterates through all elements
383	dl	1.4	*/
384			public void testIterator() {
385	dl	1.3	LinkedList q = populatedQueue(SIZE);
386	dl	1.1	int i = 0;
387			Iterator it = q.iterator();
388			while(it.hasNext()) {
389			assertTrue(q.contains(it.next()));
390			++i;
391			}
392	dl	1.3	assertEquals(i, SIZE);
393	dl	1.1	}
394
395	dl	1.4	/**
396	dl	1.5	* iterator ordering is FIFO
397	dl	1.4	*/
398	dl	1.1	public void testIteratorOrdering() {
399			final LinkedList q = new LinkedList();
400			q.add(new Integer(1));
401			q.add(new Integer(2));
402			q.add(new Integer(3));
403			int k = 0;
404			for (Iterator it = q.iterator(); it.hasNext();) {
405			int i = ((Integer)(it.next())).intValue();
406	dl	1.4	assertEquals(++k, i);
407	dl	1.1	}
408
409	dl	1.4	assertEquals(3, k);
410	dl	1.1	}
411
412	dl	1.4	/**
413	dl	1.5	* iterator.remove removes current element
414	dl	1.4	*/
415	dl	1.1	public void testIteratorRemove () {
416			final LinkedList q = new LinkedList();
417			q.add(new Integer(1));
418			q.add(new Integer(2));
419			q.add(new Integer(3));
420			Iterator it = q.iterator();
421			it.next();
422			it.remove();
423			it = q.iterator();
424			assertEquals(it.next(), new Integer(2));
425			assertEquals(it.next(), new Integer(3));
426			assertFalse(it.hasNext());
427			}
428
429
430	dl	1.4	/**
431	dl	1.5	* toString contains toStrings of elements
432	dl	1.4	*/
433			public void testToString() {
434	dl	1.3	LinkedList q = populatedQueue(SIZE);
435	dl	1.1	String s = q.toString();
436	dl	1.3	for (int i = 0; i < SIZE; ++i) {
437	dl	1.1	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
438			}
439			}
440
441	dl	1.4	/**
442	dl	1.5	* peek returns element inserted with addFirst
443	dl	1.4	*/
444			public void testAddFirst() {
445	dl	1.3	LinkedList q = populatedQueue(3);
446	dl	1.5	q.addFirst(four);
447			assertEquals(four,q.peek());
448	dl	1.1	}
449
450			}