test/extra166y/ParallelArrayAsListTest.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 * Other contributors include Andrew Wright, Jeffrey Hayes,
 * Pat Fisher, Mike Judd.
 */

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

public class ParallelArrayAsListTest extends JSR166TestCase {

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

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

    static List populatedArray(int n) {
        List a = ParallelArray.createEmpty(n, Object.class, ParallelArray.defaultExecutor()).asList();
        assertTrue(a.isEmpty());
        for (int i = 0; i < n; ++i)
            a.add(new Integer(i));
        assertFalse(a.isEmpty());
        assertEquals(n, a.size());
        return a;
    }


    static List emptyArray() {
        List a = ParallelArray.createEmpty(1, Object.class, ParallelArray.defaultExecutor()).asList();
        return a;
    }


    /**
     * a new list is empty
     */
    public void testConstructor() {
        List a = ParallelArray.createEmpty(1, Object.class, ParallelArray.defaultExecutor()).asList();
        assertTrue(a.isEmpty());
    }

    /**
     * new list contains all elements of initializing array
     */
    public void testConstructor2() {
        Integer[] ints = new Integer[SIZE];
        for (int i = 0; i < SIZE-1; ++i)
            ints[i] = new Integer(i);
        List a = ParallelArray.createUsingHandoff(ints, ParallelArray.defaultExecutor()).asList();
        for (int i = 0; i < SIZE; ++i)
            assertEquals(ints[i], a.get(i));
    }


    /**
     * addAll adds each element from the given collection
     */
    public void testAddAll() {
        List full = populatedArray(3);
        Vector v = new Vector();
        v.add(three);
        v.add(four);
        v.add(five);
        full.addAll(v);
        assertEquals(6, full.size());
    }

    /**
     * clear removes all elements from the list
     */
    public void testClear() {
        List full = populatedArray(SIZE);
        full.clear();
        assertEquals(0, full.size());
    }


    /**
     * contains is true for added elements
     */
    public void testContains() {
        List full = populatedArray(3);
        assertTrue(full.contains(one));
        assertFalse(full.contains(five));
    }

    /**
     * adding at an index places it in the indicated index
     */
    public void testAddIndex() {
        List full = populatedArray(3);
        full.add(0, m1);
        assertEquals(4, full.size());
        assertEquals(m1, full.get(0));
        assertEquals(zero, full.get(1));

        full.add(2, m2);
        assertEquals(5, full.size());
        assertEquals(m2, full.get(2));
        assertEquals(two, full.get(4));
    }

    /**
     * lists with same elements are equal and have same hashCode
     */
    public void testEquals() {
        List a = populatedArray(3);
        List b = populatedArray(3);
        assertTrue(a.equals(b));
        assertTrue(b.equals(a));
        assertEquals(a.hashCode(), b.hashCode());
        a.add(m1);
        assertFalse(a.equals(b));
        assertFalse(b.equals(a));
        b.add(m1);
        assertTrue(a.equals(b));
        assertTrue(b.equals(a));
        assertEquals(a.hashCode(), b.hashCode());
    }


    /**
     * containsAll returns true for collection with subset of elements
     */
    public void testContainsAll() {
        List full = populatedArray(3);
        Vector v = new Vector();
        v.add(one);
        v.add(two);
        assertTrue(full.containsAll(v));
        v.add(six);
        assertFalse(full.containsAll(v));
    }

    /**
     * get returns the value at the given index
     */
    public void testGet() {
        List full = populatedArray(3);
        assertEquals(0, ((Integer)full.get(0)).intValue());
    }

    /**
     * indexOf gives the index for the given object
     */
    public void testIndexOf() {
        List full = populatedArray(3);
        assertEquals(1, full.indexOf(one));
        assertEquals(-1, full.indexOf("puppies"));
    }

    /**
     * isEmpty returns true when empty, else false
     */
    public void testIsEmpty() {
        List empty = emptyArray();
        List full = populatedArray(SIZE);
        assertTrue(empty.isEmpty());
        assertFalse(full.isEmpty());
    }

    /**
     * iterator() returns an iterator containing the elements of the list
     */
    public void testIterator() {
        List full = populatedArray(SIZE);
        Iterator i = full.iterator();
        int j;
        for (j = 0; i.hasNext(); j++)
            assertEquals(j, ((Integer)i.next()).intValue());
        assertEquals(SIZE, j);
    }

    /**
     * iterator.remove removes element
     */
    public void testIteratorRemove() {
        List full = populatedArray(SIZE);
        Iterator it = full.iterator();
        Object first = full.get(0);
        it.next();
        it.remove();
        assertFalse(full.contains(first));
    }

    /**
     * toString contains toString of elements
     */
    public void testToString() {
        List full = populatedArray(3);
        String s = full.toString();
        for (int i = 0; i < 3; ++i) {
            assertTrue(s.indexOf(String.valueOf(i)) >= 0);
        }
    }

    /**
     * lastIndexOf returns the index for the given object
     */
    public void testLastIndexOf1() {
        List full = populatedArray(3);
        full.add(one);
        full.add(three);
        assertEquals(3, full.lastIndexOf(one));
        assertEquals(-1, full.lastIndexOf(six));
    }

    /**
     * listIterator traverses all elements
     */
    public void testListIterator1() {
        List full = populatedArray(SIZE);
        ListIterator i = full.listIterator();
        int j;
        for (j = 0; i.hasNext(); j++)
            assertEquals(j, ((Integer)i.next()).intValue());
        assertEquals(SIZE, j);
    }

    /**
     * listIterator only returns those elements after the given index
     */
    public void testListIterator2() {
        List full = populatedArray(3);
        ListIterator i = full.listIterator(1);
        int j;
        for (j = 0; i.hasNext(); j++)
            assertEquals(j+1, ((Integer)i.next()).intValue());
        assertEquals(2, j);
    }

    /**
     * remove removes and returns the object at the given index
     */
    public void testRemove() {
        List full = populatedArray(3);
        assertEquals(two, full.remove(2));
        assertEquals(2, full.size());
    }

    /**
     * removeAll removes all elements from the given collection
     */
    public void testRemoveAll() {
        List full = populatedArray(3);
        Vector v = new Vector();
        v.add(one);
        v.add(two);
        full.removeAll(v);
        assertEquals(1, full.size());
    }

    /**
     * set changes the element at the given index
     */
    public void testSet() {
        List full = populatedArray(3);
        assertEquals(two, full.set(2, four));
        assertEquals(4, ((Integer)full.get(2)).intValue());
    }

    /**
     * size returns the number of elements
     */
    public void testSize() {
        List empty = emptyArray();
        List full = populatedArray(SIZE);
        assertEquals(SIZE, full.size());
        assertEquals(0, empty.size());
    }

    /**
     * toArray returns an Object array containing all elements from the list
     */
    public void testToArray() {
        List full = populatedArray(3);
        Object[] o = full.toArray();
        assertEquals(3, o.length);
        assertEquals(0, ((Integer)o[0]).intValue());
        assertEquals(1, ((Integer)o[1]).intValue());
        assertEquals(2, ((Integer)o[2]).intValue());
    }

    /**
     * toArray returns an Integer array containing all elements from
     * the list
     */
    public void testToArray2() {
        List full = populatedArray(3);
        Integer[] i = new Integer[3];
        assertSame(i, full.toArray(i));
        assertEquals(0, i[0].intValue());
        assertEquals(1, i[1].intValue());
        assertEquals(2, i[2].intValue());
    }


    /**
     * sublists contains elements at indexes offset from their base
     */
    public void testSubList() {
        List a = populatedArray(10);
        assertTrue(a.subList(1,1).isEmpty());
        for (int j = 0; j < 9; ++j) {
            for (int i = j ; i < 10; ++i) {
                List b = a.subList(j,i);
                for (int k = j; k < i; ++k) {
                    assertEquals(new Integer(k), b.get(k-j));
                }
            }
        }

        List s = a.subList(2, 5);
        assertEquals(3, s.size());
        s.set(2, m1);
        assertEquals(a.get(4), m1);
        s.clear();
        assertEquals(7, a.size());
    }

    // Exception tests

    /**
     * toArray throws an ArrayStoreException when the given array
     * can not store the objects inside the list
     */
    public void testToArray_ArrayStoreException() {
        try {
            List c = emptyArray();
            c.add("zfasdfsdf");
            c.add("asdadasd");
            c.toArray(new Long[5]);
            shouldThrow();
        } catch (ArrayStoreException e) {}
    }

    /**
     * get throws an IndexOutOfBoundsException on a negative index
     */
    public void testGet1_IndexOutOfBoundsException() {
        try {
            List c = emptyArray();
            c.get(-1);
            shouldThrow();
        } catch (IndexOutOfBoundsException e) {}
    }

    /**
     * get throws an IndexOutOfBoundsException on a too high index
     */
    public void testGet2_IndexOutOfBoundsException() {
        try {
            List c = emptyArray();
            c.add("asdasd");
            c.add("asdad");
            c.get(100);
            shouldThrow();
        } catch (IndexOutOfBoundsException e) {}
    }

    /**
     * set throws an IndexOutOfBoundsException on a negative index
     */
    public void testSet1_IndexOutOfBoundsException() {
        try {
            List c = emptyArray();
            c.set(-1,"qwerty");
            shouldThrow();
        } catch (IndexOutOfBoundsException e) {}
    }

    /**
     * set throws an IndexOutOfBoundsException on a too high index
     */
    public void testSet2() {
        try {
            List c = emptyArray();
            c.add("asdasd");
            c.add("asdad");
            c.set(100, "qwerty");
            shouldThrow();
        } catch (IndexOutOfBoundsException e) {}
    }

    /**
     * add throws an IndexOutOfBoundsException on a negative index
     */
    public void testAdd1_IndexOutOfBoundsException() {
        try {
            List c = emptyArray();
            c.add(-1,"qwerty");
            shouldThrow();
        } catch (IndexOutOfBoundsException e) {}
    }

    /**
     * add throws an IndexOutOfBoundsException on a too high index
     */
    public void testAdd2_IndexOutOfBoundsException() {
        try {
            List c = emptyArray();
            c.add("asdasd");
            c.add("asdasdasd");
            c.add(100, "qwerty");
            shouldThrow();
        } catch (IndexOutOfBoundsException e) {}
    }

    /**
     * remove throws an IndexOutOfBoundsException on a negative index
     */
    public void testRemove1_IndexOutOfBounds() {
        try {
            List c = emptyArray();
            c.remove(-1);
            shouldThrow();
        } catch (IndexOutOfBoundsException e) {}
    }

    /**
     * remove throws an IndexOutOfBoundsException on a too high index
     */
    public void testRemove2_IndexOutOfBounds() {
        try {
            List c = emptyArray();
            c.add("asdasd");
            c.add("adasdasd");
            c.remove(100);
            shouldThrow();
        } catch (IndexOutOfBoundsException e) {}
    }

    /**
     * addAll throws an IndexOutOfBoundsException on a negative index
     */
    public void testAddAll1_IndexOutOfBoundsException() {
        try {
            List c = emptyArray();
            c.addAll(-1,new LinkedList());
            shouldThrow();
        } catch (IndexOutOfBoundsException e) {}
    }

    /**
     * addAll throws an IndexOutOfBoundsException on a too high index
     */
    public void testAddAll2_IndexOutOfBoundsException() {
        try {
            List c = emptyArray();
            c.add("asdasd");
            c.add("asdasdasd");
            c.addAll(100, new LinkedList());
            shouldThrow();
        } catch (IndexOutOfBoundsException e) {}
    }

    /**
     * listIterator throws an IndexOutOfBoundsException on a negative index
     */
    public void testListIterator1_IndexOutOfBoundsException() {
        try {
            List c = emptyArray();
            c.listIterator(-1);
            shouldThrow();
        } catch (IndexOutOfBoundsException e) {}
    }

    /**
     * listIterator throws an IndexOutOfBoundsException on a too high index
     */
    public void testListIterator2_IndexOutOfBoundsException() {
        try {
            List c = emptyArray();
            c.add("adasd");
            c.add("asdasdas");
            c.listIterator(100);
            shouldThrow();
        } catch (IndexOutOfBoundsException e) {}
    }

    /**
     * subList throws an IndexOutOfBoundsException on a negative index
     */
    public void testSubList1_IndexOutOfBoundsException() {
        try {
            List c = emptyArray();
            c.subList(-1,100);

            shouldThrow();
        } catch (IndexOutOfBoundsException e) {}
    }

    /**
     * subList throws an IndexOutOfBoundsException on a too high index
     */
    public void testSubList2_IndexOutOfBoundsException() {
        try {
            List c = emptyArray();
            c.add("asdasd");
            c.subList(1,100);
            shouldThrow();
        } catch (IndexOutOfBoundsException e) {}
    }

    /**
     * subList throws IndexOutOfBoundsException when the second index
     * is lower then the first
     */
    public void testSubList3_IndexOutOfBoundsException() {
        try {
            List c = emptyArray();
            c.subList(3,1);

            shouldThrow();
        } catch (IndexOutOfBoundsException e) {}
    }


}
Revision:	1.11
Committed:	Mon Feb 18 03:15:10 2013 UTC (11 years, 2 months ago) by jsr166
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.10:	+1 -1 lines
Log Message:	whitespace
#	User	Rev	Content
1	dl	1.1	/*
2			* Written by Doug Lea with assistance from members of JCP JSR-166
3			* Expert Group and released to the public domain, as explained at
4	jsr166	1.7	* http://creativecommons.org/publicdomain/zero/1.0/
5	jsr166	1.2	* Other contributors include Andrew Wright, Jeffrey Hayes,
6			* Pat Fisher, Mike Judd.
7	dl	1.1	*/
8
9			import junit.framework.*;
10			import java.util.*;
11			import java.util.concurrent.*;
12			import jsr166y.*;
13			import extra166y.*;
14			import java.io.*;
15
16	jsr166	1.8	public class ParallelArrayAsListTest extends JSR166TestCase {
17	jsr166	1.2
18	dl	1.1	public static void main(String[] args) {
19	jsr166	1.5	junit.textui.TestRunner.run(suite());
20	dl	1.1	}
21
22			public static Test suite() {
23	jsr166	1.4	return new TestSuite(ParallelArrayAsListTest.class);
24	dl	1.1	}
25
26	jsr166	1.6	static List populatedArray(int n) {
27	jsr166	1.4	List a = ParallelArray.createEmpty(n, Object.class, ParallelArray.defaultExecutor()).asList();
28	dl	1.1	assertTrue(a.isEmpty());
29	jsr166	1.2	for (int i = 0; i < n; ++i)
30	dl	1.1	a.add(new Integer(i));
31			assertFalse(a.isEmpty());
32			assertEquals(n, a.size());
33			return a;
34			}
35
36
37	jsr166	1.6	static List emptyArray() {
38	jsr166	1.4	List a = ParallelArray.createEmpty(1, Object.class, ParallelArray.defaultExecutor()).asList();
39	dl	1.1	return a;
40			}
41
42
43			/**
44			* a new list is empty
45			*/
46			public void testConstructor() {
47	jsr166	1.4	List a = ParallelArray.createEmpty(1, Object.class, ParallelArray.defaultExecutor()).asList();
48	dl	1.1	assertTrue(a.isEmpty());
49			}
50
51			/**
52			* new list contains all elements of initializing array
53			*/
54			public void testConstructor2() {
55			Integer[] ints = new Integer[SIZE];
56			for (int i = 0; i < SIZE-1; ++i)
57			ints[i] = new Integer(i);
58	jsr166	1.4	List a = ParallelArray.createUsingHandoff(ints, ParallelArray.defaultExecutor()).asList();
59	jsr166	1.2	for (int i = 0; i < SIZE; ++i)
60	dl	1.1	assertEquals(ints[i], a.get(i));
61			}
62	jsr166	1.2
63	dl	1.1
64			/**
65	jsr166	1.6	* addAll adds each element from the given collection
66	dl	1.1	*/
67			public void testAddAll() {
68	jsr166	1.4	List full = populatedArray(3);
69			Vector v = new Vector();
70			v.add(three);
71			v.add(four);
72			v.add(five);
73			full.addAll(v);
74			assertEquals(6, full.size());
75	dl	1.1	}
76
77			/**
78	jsr166	1.6	* clear removes all elements from the list
79	dl	1.1	*/
80			public void testClear() {
81	jsr166	1.4	List full = populatedArray(SIZE);
82			full.clear();
83			assertEquals(0, full.size());
84	dl	1.1	}
85
86
87
88			/**
89	jsr166	1.6	* contains is true for added elements
90	dl	1.1	*/
91			public void testContains() {
92	jsr166	1.4	List full = populatedArray(3);
93			assertTrue(full.contains(one));
94			assertFalse(full.contains(five));
95	dl	1.1	}
96
97			/**
98			* adding at an index places it in the indicated index
99			*/
100			public void testAddIndex() {
101	jsr166	1.4	List full = populatedArray(3);
102	dl	1.1	full.add(0, m1);
103			assertEquals(4, full.size());
104			assertEquals(m1, full.get(0));
105			assertEquals(zero, full.get(1));
106
107			full.add(2, m2);
108			assertEquals(5, full.size());
109			assertEquals(m2, full.get(2));
110			assertEquals(two, full.get(4));
111			}
112
113			/**
114			* lists with same elements are equal and have same hashCode
115			*/
116			public void testEquals() {
117	jsr166	1.4	List a = populatedArray(3);
118			List b = populatedArray(3);
119	dl	1.1	assertTrue(a.equals(b));
120			assertTrue(b.equals(a));
121			assertEquals(a.hashCode(), b.hashCode());
122			a.add(m1);
123			assertFalse(a.equals(b));
124			assertFalse(b.equals(a));
125			b.add(m1);
126			assertTrue(a.equals(b));
127			assertTrue(b.equals(a));
128			assertEquals(a.hashCode(), b.hashCode());
129			}
130
131	jsr166	1.2
132	dl	1.1	/**
133	jsr166	1.6	* containsAll returns true for collection with subset of elements
134	dl	1.1	*/
135			public void testContainsAll() {
136	jsr166	1.4	List full = populatedArray(3);
137			Vector v = new Vector();
138			v.add(one);
139			v.add(two);
140			assertTrue(full.containsAll(v));
141			v.add(six);
142			assertFalse(full.containsAll(v));
143	dl	1.1	}
144
145			/**
146	jsr166	1.11	* get returns the value at the given index
147	dl	1.1	*/
148			public void testGet() {
149	jsr166	1.4	List full = populatedArray(3);
150			assertEquals(0, ((Integer)full.get(0)).intValue());
151	dl	1.1	}
152
153			/**
154	jsr166	1.6	* indexOf gives the index for the given object
155	dl	1.1	*/
156			public void testIndexOf() {
157	jsr166	1.4	List full = populatedArray(3);
158			assertEquals(1, full.indexOf(one));
159			assertEquals(-1, full.indexOf("puppies"));
160	dl	1.1	}
161
162			/**
163	jsr166	1.6	* isEmpty returns true when empty, else false
164	dl	1.1	*/
165			public void testIsEmpty() {
166	jsr166	1.4	List empty = emptyArray();
167			List full = populatedArray(SIZE);
168			assertTrue(empty.isEmpty());
169			assertFalse(full.isEmpty());
170	dl	1.1	}
171
172			/**
173	jsr166	1.6	* iterator() returns an iterator containing the elements of the list
174	dl	1.1	*/
175			public void testIterator() {
176	jsr166	1.4	List full = populatedArray(SIZE);
177			Iterator i = full.iterator();
178			int j;
179			for (j = 0; i.hasNext(); j++)
180			assertEquals(j, ((Integer)i.next()).intValue());
181			assertEquals(SIZE, j);
182	dl	1.1	}
183
184			/**
185			* iterator.remove removes element
186			*/
187	jsr166	1.5	public void testIteratorRemove() {
188	jsr166	1.4	List full = populatedArray(SIZE);
189	dl	1.1	Iterator it = full.iterator();
190			Object first = full.get(0);
191			it.next();
192			it.remove();
193			assertFalse(full.contains(first));
194			}
195
196			/**
197			* toString contains toString of elements
198			*/
199			public void testToString() {
200	jsr166	1.4	List full = populatedArray(3);
201	dl	1.1	String s = full.toString();
202			for (int i = 0; i < 3; ++i) {
203			assertTrue(s.indexOf(String.valueOf(i)) >= 0);
204			}
205	jsr166	1.2	}
206	dl	1.1
207			/**
208	jsr166	1.6	* lastIndexOf returns the index for the given object
209	dl	1.1	*/
210			public void testLastIndexOf1() {
211	jsr166	1.4	List full = populatedArray(3);
212			full.add(one);
213			full.add(three);
214			assertEquals(3, full.lastIndexOf(one));
215			assertEquals(-1, full.lastIndexOf(six));
216	dl	1.1	}
217
218			/**
219	jsr166	1.6	* listIterator traverses all elements
220	dl	1.1	*/
221			public void testListIterator1() {
222	jsr166	1.4	List full = populatedArray(SIZE);
223			ListIterator i = full.listIterator();
224			int j;
225			for (j = 0; i.hasNext(); j++)
226			assertEquals(j, ((Integer)i.next()).intValue());
227			assertEquals(SIZE, j);
228	dl	1.1	}
229
230			/**
231	jsr166	1.6	* listIterator only returns those elements after the given index
232	dl	1.1	*/
233			public void testListIterator2() {
234	jsr166	1.4	List full = populatedArray(3);
235			ListIterator i = full.listIterator(1);
236			int j;
237			for (j = 0; i.hasNext(); j++)
238			assertEquals(j+1, ((Integer)i.next()).intValue());
239			assertEquals(2, j);
240	dl	1.1	}
241
242			/**
243	jsr166	1.6	* remove removes and returns the object at the given index
244	dl	1.1	*/
245			public void testRemove() {
246	jsr166	1.4	List full = populatedArray(3);
247			assertEquals(two, full.remove(2));
248			assertEquals(2, full.size());
249	dl	1.1	}
250
251			/**
252	jsr166	1.6	* removeAll removes all elements from the given collection
253	dl	1.1	*/
254			public void testRemoveAll() {
255	jsr166	1.4	List full = populatedArray(3);
256			Vector v = new Vector();
257			v.add(one);
258			v.add(two);
259			full.removeAll(v);
260			assertEquals(1, full.size());
261	dl	1.1	}
262
263			/**
264	jsr166	1.6	* set changes the element at the given index
265	dl	1.1	*/
266			public void testSet() {
267	jsr166	1.4	List full = populatedArray(3);
268			assertEquals(two, full.set(2, four));
269			assertEquals(4, ((Integer)full.get(2)).intValue());
270	dl	1.1	}
271
272			/**
273	jsr166	1.6	* size returns the number of elements
274	dl	1.1	*/
275			public void testSize() {
276	jsr166	1.4	List empty = emptyArray();
277			List full = populatedArray(SIZE);
278			assertEquals(SIZE, full.size());
279			assertEquals(0, empty.size());
280	dl	1.1	}
281
282			/**
283	jsr166	1.6	* toArray returns an Object array containing all elements from the list
284	dl	1.1	*/
285			public void testToArray() {
286	jsr166	1.4	List full = populatedArray(3);
287			Object[] o = full.toArray();
288			assertEquals(3, o.length);
289			assertEquals(0, ((Integer)o[0]).intValue());
290			assertEquals(1, ((Integer)o[1]).intValue());
291			assertEquals(2, ((Integer)o[2]).intValue());
292	dl	1.1	}
293
294			/**
295	jsr166	1.6	* toArray returns an Integer array containing all elements from
296			* the list
297	dl	1.1	*/
298			public void testToArray2() {
299	jsr166	1.4	List full = populatedArray(3);
300			Integer[] i = new Integer[3];
301	jsr166	1.10	assertSame(i, full.toArray(i));
302	jsr166	1.4	assertEquals(0, i[0].intValue());
303			assertEquals(1, i[1].intValue());
304			assertEquals(2, i[2].intValue());
305	dl	1.1	}
306
307
308			/**
309			* sublists contains elements at indexes offset from their base
310			*/
311			public void testSubList() {
312	jsr166	1.4	List a = populatedArray(10);
313	dl	1.1	assertTrue(a.subList(1,1).isEmpty());
314	jsr166	1.4	for (int j = 0; j < 9; ++j) {
315			for (int i = j ; i < 10; ++i) {
316			List b = a.subList(j,i);
317			for (int k = j; k < i; ++k) {
318			assertEquals(new Integer(k), b.get(k-j));
319			}
320			}
321			}
322	dl	1.1
323	jsr166	1.4	List s = a.subList(2, 5);
324	jsr166	1.9	assertEquals(3, s.size());
325	dl	1.1	s.set(2, m1);
326			assertEquals(a.get(4), m1);
327	jsr166	1.4	s.clear();
328	jsr166	1.9	assertEquals(7, a.size());
329	dl	1.1	}
330
331			// Exception tests
332
333			/**
334	jsr166	1.6	* toArray throws an ArrayStoreException when the given array
335			* can not store the objects inside the list
336	dl	1.1	*/
337			public void testToArray_ArrayStoreException() {
338			try {
339			List c = emptyArray();
340			c.add("zfasdfsdf");
341			c.add("asdadasd");
342			c.toArray(new Long[5]);
343	jsr166	1.4	shouldThrow();
344	jsr166	1.6	} catch (ArrayStoreException e) {}
345	dl	1.1	}
346
347			/**
348	jsr166	1.6	* get throws an IndexOutOfBoundsException on a negative index
349	dl	1.1	*/
350			public void testGet1_IndexOutOfBoundsException() {
351			try {
352			List c = emptyArray();
353			c.get(-1);
354			shouldThrow();
355	jsr166	1.6	} catch (IndexOutOfBoundsException e) {}
356	dl	1.1	}
357	jsr166	1.2
358	dl	1.1	/**
359	jsr166	1.6	* get throws an IndexOutOfBoundsException on a too high index
360	dl	1.1	*/
361			public void testGet2_IndexOutOfBoundsException() {
362			try {
363			List c = emptyArray();
364			c.add("asdasd");
365			c.add("asdad");
366			c.get(100);
367			shouldThrow();
368	jsr166	1.6	} catch (IndexOutOfBoundsException e) {}
369	dl	1.1	}
370
371			/**
372	jsr166	1.6	* set throws an IndexOutOfBoundsException on a negative index
373	dl	1.1	*/
374			public void testSet1_IndexOutOfBoundsException() {
375			try {
376			List c = emptyArray();
377			c.set(-1,"qwerty");
378			shouldThrow();
379	jsr166	1.6	} catch (IndexOutOfBoundsException e) {}
380	dl	1.1	}
381	jsr166	1.2
382	dl	1.1	/**
383	jsr166	1.6	* set throws an IndexOutOfBoundsException on a too high index
384	dl	1.1	*/
385			public void testSet2() {
386			try {
387			List c = emptyArray();
388			c.add("asdasd");
389			c.add("asdad");
390			c.set(100, "qwerty");
391			shouldThrow();
392	jsr166	1.6	} catch (IndexOutOfBoundsException e) {}
393	dl	1.1	}
394
395			/**
396	jsr166	1.6	* add throws an IndexOutOfBoundsException on a negative index
397	dl	1.1	*/
398			public void testAdd1_IndexOutOfBoundsException() {
399			try {
400			List c = emptyArray();
401			c.add(-1,"qwerty");
402			shouldThrow();
403	jsr166	1.6	} catch (IndexOutOfBoundsException e) {}
404	dl	1.1	}
405	jsr166	1.2
406	dl	1.1	/**
407	jsr166	1.6	* add throws an IndexOutOfBoundsException on a too high index
408	dl	1.1	*/
409			public void testAdd2_IndexOutOfBoundsException() {
410			try {
411			List c = emptyArray();
412			c.add("asdasd");
413			c.add("asdasdasd");
414			c.add(100, "qwerty");
415			shouldThrow();
416	jsr166	1.6	} catch (IndexOutOfBoundsException e) {}
417	dl	1.1	}
418
419			/**
420	jsr166	1.6	* remove throws an IndexOutOfBoundsException on a negative index
421	dl	1.1	*/
422			public void testRemove1_IndexOutOfBounds() {
423			try {
424			List c = emptyArray();
425			c.remove(-1);
426			shouldThrow();
427	jsr166	1.6	} catch (IndexOutOfBoundsException e) {}
428	dl	1.1	}
429
430			/**
431	jsr166	1.6	* remove throws an IndexOutOfBoundsException on a too high index
432	dl	1.1	*/
433			public void testRemove2_IndexOutOfBounds() {
434			try {
435			List c = emptyArray();
436			c.add("asdasd");
437			c.add("adasdasd");
438			c.remove(100);
439			shouldThrow();
440	jsr166	1.6	} catch (IndexOutOfBoundsException e) {}
441	dl	1.1	}
442	jsr166	1.2
443	dl	1.1	/**
444	jsr166	1.6	* addAll throws an IndexOutOfBoundsException on a negative index
445	dl	1.1	*/
446			public void testAddAll1_IndexOutOfBoundsException() {
447			try {
448			List c = emptyArray();
449			c.addAll(-1,new LinkedList());
450			shouldThrow();
451	jsr166	1.6	} catch (IndexOutOfBoundsException e) {}
452	dl	1.1	}
453	jsr166	1.2
454	dl	1.1	/**
455	jsr166	1.6	* addAll throws an IndexOutOfBoundsException on a too high index
456	dl	1.1	*/
457			public void testAddAll2_IndexOutOfBoundsException() {
458			try {
459			List c = emptyArray();
460			c.add("asdasd");
461			c.add("asdasdasd");
462			c.addAll(100, new LinkedList());
463			shouldThrow();
464	jsr166	1.6	} catch (IndexOutOfBoundsException e) {}
465	dl	1.1	}
466
467			/**
468	jsr166	1.6	* listIterator throws an IndexOutOfBoundsException on a negative index
469	dl	1.1	*/
470			public void testListIterator1_IndexOutOfBoundsException() {
471			try {
472			List c = emptyArray();
473			c.listIterator(-1);
474			shouldThrow();
475	jsr166	1.6	} catch (IndexOutOfBoundsException e) {}
476	dl	1.1	}
477
478			/**
479	jsr166	1.6	* listIterator throws an IndexOutOfBoundsException on a too high index
480	dl	1.1	*/
481			public void testListIterator2_IndexOutOfBoundsException() {
482			try {
483			List c = emptyArray();
484			c.add("adasd");
485			c.add("asdasdas");
486			c.listIterator(100);
487			shouldThrow();
488	jsr166	1.6	} catch (IndexOutOfBoundsException e) {}
489	dl	1.1	}
490
491			/**
492	jsr166	1.6	* subList throws an IndexOutOfBoundsException on a negative index
493	dl	1.1	*/
494			public void testSubList1_IndexOutOfBoundsException() {
495			try {
496			List c = emptyArray();
497			c.subList(-1,100);
498
499			shouldThrow();
500	jsr166	1.6	} catch (IndexOutOfBoundsException e) {}
501	dl	1.1	}
502
503			/**
504	jsr166	1.6	* subList throws an IndexOutOfBoundsException on a too high index
505	dl	1.1	*/
506			public void testSubList2_IndexOutOfBoundsException() {
507			try {
508			List c = emptyArray();
509			c.add("asdasd");
510			c.subList(1,100);
511			shouldThrow();
512	jsr166	1.6	} catch (IndexOutOfBoundsException e) {}
513	dl	1.1	}
514
515			/**
516	jsr166	1.6	* subList throws IndexOutOfBoundsException when the second index
517			* is lower then the first
518	dl	1.1	*/
519			public void testSubList3_IndexOutOfBoundsException() {
520			try {
521			List c = emptyArray();
522			c.subList(3,1);
523
524			shouldThrow();
525	jsr166	1.6	} catch (IndexOutOfBoundsException e) {}
526	dl	1.1	}
527
528	jsr166	1.2
529	dl	1.1	}