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
#	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			*
37			*/
38			public void testConstructor1() {
39	dl	1.1	assertEquals(0, new LinkedList().size());
40			}
41
42	dl	1.4	/**
43			*
44			*/
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			*
55			*/
56			public void testConstructor6() {
57	dl	1.1	try {
58	dl	1.3	Integer[] ints = new Integer[SIZE];
59			for (int i = 0; i < SIZE; ++i)
60	dl	1.1	ints[i] = new Integer(i);
61			LinkedList q = new LinkedList(Arrays.asList(ints));
62	dl	1.3	for (int i = 0; i < SIZE; ++i)
63	dl	1.1	assertEquals(ints[i], q.poll());
64			}
65			finally {}
66			}
67
68	dl	1.4	/**
69			*
70			*/
71	dl	1.1	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	dl	1.4	/**
83			*
84			*/
85	dl	1.1	public void testSize() {
86	dl	1.3	LinkedList q = populatedQueue(SIZE);
87			for (int i = 0; i < SIZE; ++i) {
88			assertEquals(SIZE-i, q.size());
89	dl	1.1	q.remove();
90			}
91	dl	1.3	for (int i = 0; i < SIZE; ++i) {
92	dl	1.1	assertEquals(i, q.size());
93			q.add(new Integer(i));
94			}
95			}
96
97	dl	1.4	/**
98			*
99			*/
100			public void testOfferNull() {
101	dl	1.1	try {
102			LinkedList q = new LinkedList();
103			q.offer(null);
104			} catch (NullPointerException ie) {
105	dl	1.4	unexpectedException();
106	dl	1.1	}
107			}
108
109	dl	1.4	/**
110			*
111			*/
112	dl	1.1	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	dl	1.4	/**
119			*
120			*/
121			public void testAdd() {
122	dl	1.1	LinkedList q = new LinkedList();
123	dl	1.3	for (int i = 0; i < SIZE; ++i) {
124	dl	1.1	assertEquals(i, q.size());
125			assertTrue(q.add(new Integer(i)));
126			}
127			}
128
129	dl	1.4	/**
130			*
131			*/
132			public void testAddAll1() {
133	dl	1.1	try {
134			LinkedList q = new LinkedList();
135			q.addAll(null);
136	dl	1.4	shouldThrow();
137	dl	1.1	}
138			catch (NullPointerException success) {}
139			}
140
141	dl	1.4	/**
142			*
143			*/
144			public void testAddAll5() {
145	dl	1.1	try {
146			Integer[] empty = new Integer[0];
147	dl	1.3	Integer[] ints = new Integer[SIZE];
148			for (int i = 0; i < SIZE; ++i)
149	dl	1.1	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	dl	1.3	for (int i = 0; i < SIZE; ++i)
154	dl	1.1	assertEquals(ints[i], q.poll());
155			}
156			finally {}
157			}
158
159	dl	1.4	/**
160			*
161			*/
162			public void testPoll() {
163	dl	1.3	LinkedList q = populatedQueue(SIZE);
164			for (int i = 0; i < SIZE; ++i) {
165	dl	1.1	assertEquals(i, ((Integer)q.poll()).intValue());
166			}
167			assertNull(q.poll());
168			}
169
170	dl	1.4	/**
171			*
172			*/
173			public void testPeek() {
174	dl	1.3	LinkedList q = populatedQueue(SIZE);
175			for (int i = 0; i < SIZE; ++i) {
176	dl	1.1	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	dl	1.4	/**
185			*
186			*/
187			public void testElement() {
188	dl	1.3	LinkedList q = populatedQueue(SIZE);
189			for (int i = 0; i < SIZE; ++i) {
190	dl	1.1	assertEquals(i, ((Integer)q.element()).intValue());
191			q.poll();
192			}
193			try {
194			q.element();
195	dl	1.4	shouldThrow();
196	dl	1.1	}
197			catch (NoSuchElementException success) {}
198			}
199
200	dl	1.4	/**
201			*
202			*/
203			public void testRemove() {
204	dl	1.3	LinkedList q = populatedQueue(SIZE);
205			for (int i = 0; i < SIZE; ++i) {
206	dl	1.1	assertEquals(i, ((Integer)q.remove()).intValue());
207			}
208			try {
209			q.remove();
210	dl	1.4	shouldThrow();
211	dl	1.1	} catch (NoSuchElementException success){
212			}
213			}
214
215	dl	1.4	/**
216			*
217			*/
218			public void testRemoveElement() {
219	dl	1.3	LinkedList q = populatedQueue(SIZE);
220			for (int i = 1; i < SIZE; i+=2) {
221	dl	1.1	assertTrue(q.remove(new Integer(i)));
222			}
223	dl	1.3	for (int i = 0; i < SIZE; i+=2) {
224	dl	1.1	assertTrue(q.remove(new Integer(i)));
225			assertFalse(q.remove(new Integer(i+1)));
226			}
227	dl	1.2	assertTrue(q.isEmpty());
228	dl	1.1	}
229
230	dl	1.4	/**
231			*
232			*/
233			public void testContains() {
234	dl	1.3	LinkedList q = populatedQueue(SIZE);
235			for (int i = 0; i < SIZE; ++i) {
236	dl	1.1	assertTrue(q.contains(new Integer(i)));
237			q.poll();
238			assertFalse(q.contains(new Integer(i)));
239			}
240			}
241
242	dl	1.4	/**
243			*
244			*/
245			public void testClear() {
246	dl	1.3	LinkedList q = populatedQueue(SIZE);
247	dl	1.1	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	dl	1.4	/**
257			*
258			*/
259			public void testContainsAll() {
260	dl	1.3	LinkedList q = populatedQueue(SIZE);
261	dl	1.1	LinkedList p = new LinkedList();
262	dl	1.3	for (int i = 0; i < SIZE; ++i) {
263	dl	1.1	assertTrue(q.containsAll(p));
264			assertFalse(p.containsAll(q));
265			p.add(new Integer(i));
266			}
267			assertTrue(p.containsAll(q));
268			}
269
270	dl	1.4	/**
271			*
272			*/
273			public void testRetainAll() {
274	dl	1.3	LinkedList q = populatedQueue(SIZE);
275			LinkedList p = populatedQueue(SIZE);
276			for (int i = 0; i < SIZE; ++i) {
277	dl	1.1	boolean changed = q.retainAll(p);
278			if (i == 0)
279			assertFalse(changed);
280			else
281			assertTrue(changed);
282
283			assertTrue(q.containsAll(p));
284	dl	1.3	assertEquals(SIZE-i, q.size());
285	dl	1.1	p.remove();
286			}
287			}
288
289	dl	1.4	/**
290			*
291			*/
292			public void testRemoveAll() {
293	dl	1.3	for (int i = 1; i < SIZE; ++i) {
294			LinkedList q = populatedQueue(SIZE);
295			LinkedList p = populatedQueue(i);
296	dl	1.1	assertTrue(q.removeAll(p));
297	dl	1.3	assertEquals(SIZE-i, q.size());
298	dl	1.1	for (int j = 0; j < i; ++j) {
299			Integer I = (Integer)(p.remove());
300			assertFalse(q.contains(I));
301			}
302			}
303			}
304
305	dl	1.4	/**
306			*
307			*/
308			public void testToArray() {
309	dl	1.3	LinkedList q = populatedQueue(SIZE);
310	dl	1.1	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	dl	1.4	/**
317			*
318			*/
319			public void testToArray2() {
320	dl	1.3	LinkedList q = populatedQueue(SIZE);
321			Integer[] ints = new Integer[SIZE];
322	dl	1.1	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	dl	1.4	/**
329			*
330			*/
331			public void testIterator() {
332	dl	1.3	LinkedList q = populatedQueue(SIZE);
333	dl	1.1	int i = 0;
334			Iterator it = q.iterator();
335			while(it.hasNext()) {
336			assertTrue(q.contains(it.next()));
337			++i;
338			}
339	dl	1.3	assertEquals(i, SIZE);
340	dl	1.1	}
341
342	dl	1.4	/**
343			*
344			*/
345	dl	1.1	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	dl	1.4	assertEquals(++k, i);
357	dl	1.1	}
358
359	dl	1.4	assertEquals(3, k);
360	dl	1.1	}
361
362	dl	1.4	/**
363			*
364			*/
365	dl	1.1	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	dl	1.4	/**
384			*
385			*/
386			public void testToString() {
387	dl	1.3	LinkedList q = populatedQueue(SIZE);
388	dl	1.1	String s = q.toString();
389	dl	1.3	for (int i = 0; i < SIZE; ++i) {
390	dl	1.1	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
391			}
392			}
393
394	dl	1.4	/**
395			*
396			*/
397			public void testAddFirst() {
398	dl	1.3	LinkedList q = populatedQueue(3);
399	dl	1.1	q.addFirst(new Integer(4));
400			assertEquals(new Integer(4),q.get(0));
401			}
402
403	dl	1.4	/**
404			*
405			*/
406			public void testAddLast() {
407	dl	1.3	LinkedList q = populatedQueue(3);
408	dl	1.1	q.addLast(new Integer(3));
409			assertEquals(new Integer(3),q.get(3));
410			}
411
412	dl	1.4	/**
413			*
414			*/
415	dl	1.1	public void testGetFirst() {
416	dl	1.3	LinkedList q = populatedQueue(3);
417	dl	1.1	assertEquals(new Integer(0),q.getFirst());
418			}
419
420	dl	1.4	/**
421			*
422			*/
423	dl	1.1	public void testGetLast() {
424	dl	1.3	LinkedList q = populatedQueue(3);
425	dl	1.1	assertEquals(new Integer(2),q.getLast());
426			}
427
428	dl	1.4	/**
429			*
430			*/
431			public void testIndexOf() {
432	dl	1.3	LinkedList q = populatedQueue(3);
433	dl	1.1	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	dl	1.4	/**
440			*
441			*/
442			public void testLastIndexOf() {
443	dl	1.3	LinkedList q = populatedQueue(3);
444	dl	1.1	q.add(new Integer(2));
445			assertEquals(3,q.lastIndexOf(new Integer(2)));
446			assertEquals(-1, q.lastIndexOf("not there"));
447			}
448
449	dl	1.4	/**
450			*
451			*/
452			public void testSet() {
453	dl	1.3	LinkedList q = populatedQueue(3);
454	dl	1.1	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	dl	1.4	/**
461			*
462			*/
463			public void testGetFirst_NoSuchElementException() {
464	dl	1.1	try {
465			LinkedList l = new LinkedList();
466			l.getFirst();
467	dl	1.4	shouldThrow();
468	dl	1.1	}
469			catch(NoSuchElementException success) {}
470			}
471
472	dl	1.4	/**
473			*
474			*/
475	dl	1.1	public void testRemoveFirst() {
476			try {
477			LinkedList l = new LinkedList();
478			l.removeFirst();
479	dl	1.4	shouldThrow();
480	dl	1.1	}
481			catch(NoSuchElementException success) {}
482			}
483
484	dl	1.4	/**
485			*
486			*/
487	dl	1.1	public void testRemoveLast() {
488			try {
489			LinkedList l = new LinkedList();
490			l.removeLast();
491	dl	1.4	shouldThrow();
492	dl	1.1	}
493			catch(NoSuchElementException success) {}
494			}
495
496	dl	1.4	/**
497			*
498			*/
499			public void testGetLast_NoSuchElementException() {
500	dl	1.1	try {
501			LinkedList l = new LinkedList();
502			l.getLast();
503	dl	1.4	shouldThrow();
504	dl	1.1	}
505			catch(NoSuchElementException success) {}
506			}
507
508
509	dl	1.4	/**
510			*
511			*/
512			public void testAddAll_NullPointerException() {
513	dl	1.1	try {
514			LinkedList l = new LinkedList();
515			l.addAll((Collection)null);
516	dl	1.4	shouldThrow();
517	dl	1.1	}
518			catch(NullPointerException success){}
519			}
520
521
522	dl	1.4	/**
523			*
524			*/
525	dl	1.1	public void testAddAll1_OutOfBounds() {
526			try {
527			LinkedList l = new LinkedList();
528			l.addAll(4,new LinkedList());
529	dl	1.4	shouldThrow();
530	dl	1.1	}
531			catch(IndexOutOfBoundsException success) {}
532			}
533
534
535	dl	1.4	/**
536			*
537			*/
538	dl	1.1	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	dl	1.4	shouldThrow();
546			} catch(IndexOutOfBoundsException success) {}
547	dl	1.1	}
548
549	dl	1.4	/**
550			*
551			*/
552	dl	1.1	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	dl	1.4	shouldThrow();
560			} catch(IndexOutOfBoundsException success){}
561	dl	1.1	}
562
563	dl	1.4	/**
564			*
565			*/
566	dl	1.1	public void testget1() {
567			try {
568			LinkedList l = new LinkedList();
569			l.add(new Object());
570			l.get(-1);
571	dl	1.4	shouldThrow();
572			} catch(IndexOutOfBoundsException success) {}
573	dl	1.1	}
574
575	dl	1.4	/**
576			*
577			*/
578	dl	1.1	public void testget2() {
579			try {
580			LinkedList l = new LinkedList();
581			l.add(new Object());
582			l.get(5);
583	dl	1.4	shouldThrow();
584			} catch(IndexOutOfBoundsException success){}
585	dl	1.1	}
586
587	dl	1.4	/**
588			*
589			*/
590	dl	1.1	public void testset1() {
591			try {
592			LinkedList l = new LinkedList();
593			l.add(new Object());
594			l.set(-1,new Object());
595	dl	1.4	shouldThrow();
596			} catch(IndexOutOfBoundsException success){}
597	dl	1.1	}
598
599	dl	1.4	/**
600			*
601			*/
602	dl	1.1	public void testset2() {
603			try {
604			LinkedList l = new LinkedList();
605			l.add(new Object());
606			l.set(5,new Object());
607	dl	1.4	shouldThrow();
608			} catch(IndexOutOfBoundsException success){}
609	dl	1.1	}
610
611	dl	1.4	/**
612			*
613			*/
614	dl	1.1	public void testadd1() {
615			try {
616			LinkedList l = new LinkedList();
617			l.add(new Object());
618			l.add(-1,new Object());
619	dl	1.4	shouldThrow();
620			} catch(IndexOutOfBoundsException success){}
621	dl	1.1	}
622
623	dl	1.4	public void add2() {
624	dl	1.1	try {
625			LinkedList l = new LinkedList();
626			l.add(new Object());
627			l.add(5,new Object());
628	dl	1.4	shouldThrow();
629			} catch(IndexOutOfBoundsException success) {}
630	dl	1.1	}
631
632	dl	1.4	/**
633			*
634			*/
635			public void testremove() {
636	dl	1.1	try {
637			LinkedList l = new LinkedList();
638			l.add(new Object());
639			l.remove(-1);
640	dl	1.4	shouldThrow();
641			} catch(IndexOutOfBoundsException success){}
642	dl	1.1	}
643
644	dl	1.4	/**
645			*
646			*/
647			public void testremove1() {
648	dl	1.1	try {
649			LinkedList l = new LinkedList();
650			l.add(new Object());
651			l.remove(5);
652	dl	1.4	shouldThrow();
653			} catch(IndexOutOfBoundsException success){}
654	dl	1.1	}
655
656
657	dl	1.4	/**
658			*
659			*/
660			public void testremove2() {
661			try {
662	dl	1.1	LinkedList l = new LinkedList();
663			l.remove();
664	dl	1.4	shouldThrow();
665			} catch(NoSuchElementException e){}
666	dl	1.1	}
667
668	dl	1.4	/**
669			*
670			*/
671	dl	1.1	public void testlistIt1() {
672			try {
673			LinkedList l = new LinkedList();
674			l.add(new Object());
675			l.listIterator(5);
676	dl	1.4	shouldThrow();
677			} catch(IndexOutOfBoundsException success){}
678	dl	1.1	}
679
680	dl	1.4	/**
681			*
682			*/
683	dl	1.1	public void testlistIt2() {
684			try {
685			LinkedList l = new LinkedList();
686			l.add(new Object());
687			l.listIterator(-1);
688	dl	1.4	shouldThrow();
689			} catch(IndexOutOfBoundsException success){}
690	dl	1.1	}
691
692	dl	1.4	/**
693			*
694			*/
695	dl	1.1	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	dl	1.4	shouldThrow();
703			} catch(ConcurrentModificationException success){}
704	dl	1.1	}
705
706	dl	1.4	/**
707			*
708			*/
709	dl	1.1	public void testToArray_BadArg() {
710			try {
711			LinkedList l = new LinkedList();
712			l.add(new Object());
713			Object o[] = l.toArray(null);
714	dl	1.4	shouldThrow();
715			} catch(NullPointerException success){}
716	dl	1.1	}
717
718	dl	1.4	/**
719			*
720			*/
721	dl	1.1	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	dl	1.4	shouldThrow();
727			} catch(ArrayStoreException success){}
728	dl	1.1	}
729
730			}