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
#	Content
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	* http://creativecommons.org/publicdomain/zero/1.0/
5	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	* Pat Fisher, Mike Judd.
7	*/
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	public class ParallelArrayAsListTest extends JSR166TestCase {
17
18	public static void main(String[] args) {
19	junit.textui.TestRunner.run(suite());
20	}
21
22	public static Test suite() {
23	return new TestSuite(ParallelArrayAsListTest.class);
24	}
25
26	static List populatedArray(int n) {
27	List a = ParallelArray.createEmpty(n, Object.class, ParallelArray.defaultExecutor()).asList();
28	assertTrue(a.isEmpty());
29	for (int i = 0; i < n; ++i)
30	a.add(new Integer(i));
31	assertFalse(a.isEmpty());
32	assertEquals(n, a.size());
33	return a;
34	}
35
36
37	static List emptyArray() {
38	List a = ParallelArray.createEmpty(1, Object.class, ParallelArray.defaultExecutor()).asList();
39	return a;
40	}
41
42
43	/**
44	* a new list is empty
45	*/
46	public void testConstructor() {
47	List a = ParallelArray.createEmpty(1, Object.class, ParallelArray.defaultExecutor()).asList();
48	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	List a = ParallelArray.createUsingHandoff(ints, ParallelArray.defaultExecutor()).asList();
59	for (int i = 0; i < SIZE; ++i)
60	assertEquals(ints[i], a.get(i));
61	}
62
63
64	/**
65	* addAll adds each element from the given collection
66	*/
67	public void testAddAll() {
68	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	}
76
77	/**
78	* clear removes all elements from the list
79	*/
80	public void testClear() {
81	List full = populatedArray(SIZE);
82	full.clear();
83	assertEquals(0, full.size());
84	}
85
86
87
88	/**
89	* contains is true for added elements
90	*/
91	public void testContains() {
92	List full = populatedArray(3);
93	assertTrue(full.contains(one));
94	assertFalse(full.contains(five));
95	}
96
97	/**
98	* adding at an index places it in the indicated index
99	*/
100	public void testAddIndex() {
101	List full = populatedArray(3);
102	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	List a = populatedArray(3);
118	List b = populatedArray(3);
119	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
132	/**
133	* containsAll returns true for collection with subset of elements
134	*/
135	public void testContainsAll() {
136	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	}
144
145	/**
146	* get returns the value at the given index
147	*/
148	public void testGet() {
149	List full = populatedArray(3);
150	assertEquals(0, ((Integer)full.get(0)).intValue());
151	}
152
153	/**
154	* indexOf gives the index for the given object
155	*/
156	public void testIndexOf() {
157	List full = populatedArray(3);
158	assertEquals(1, full.indexOf(one));
159	assertEquals(-1, full.indexOf("puppies"));
160	}
161
162	/**
163	* isEmpty returns true when empty, else false
164	*/
165	public void testIsEmpty() {
166	List empty = emptyArray();
167	List full = populatedArray(SIZE);
168	assertTrue(empty.isEmpty());
169	assertFalse(full.isEmpty());
170	}
171
172	/**
173	* iterator() returns an iterator containing the elements of the list
174	*/
175	public void testIterator() {
176	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	}
183
184	/**
185	* iterator.remove removes element
186	*/
187	public void testIteratorRemove() {
188	List full = populatedArray(SIZE);
189	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	List full = populatedArray(3);
201	String s = full.toString();
202	for (int i = 0; i < 3; ++i) {
203	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
204	}
205	}
206
207	/**
208	* lastIndexOf returns the index for the given object
209	*/
210	public void testLastIndexOf1() {
211	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	}
217
218	/**
219	* listIterator traverses all elements
220	*/
221	public void testListIterator1() {
222	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	}
229
230	/**
231	* listIterator only returns those elements after the given index
232	*/
233	public void testListIterator2() {
234	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	}
241
242	/**
243	* remove removes and returns the object at the given index
244	*/
245	public void testRemove() {
246	List full = populatedArray(3);
247	assertEquals(two, full.remove(2));
248	assertEquals(2, full.size());
249	}
250
251	/**
252	* removeAll removes all elements from the given collection
253	*/
254	public void testRemoveAll() {
255	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	}
262
263	/**
264	* set changes the element at the given index
265	*/
266	public void testSet() {
267	List full = populatedArray(3);
268	assertEquals(two, full.set(2, four));
269	assertEquals(4, ((Integer)full.get(2)).intValue());
270	}
271
272	/**
273	* size returns the number of elements
274	*/
275	public void testSize() {
276	List empty = emptyArray();
277	List full = populatedArray(SIZE);
278	assertEquals(SIZE, full.size());
279	assertEquals(0, empty.size());
280	}
281
282	/**
283	* toArray returns an Object array containing all elements from the list
284	*/
285	public void testToArray() {
286	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	}
293
294	/**
295	* toArray returns an Integer array containing all elements from
296	* the list
297	*/
298	public void testToArray2() {
299	List full = populatedArray(3);
300	Integer[] i = new Integer[3];
301	assertSame(i, full.toArray(i));
302	assertEquals(0, i[0].intValue());
303	assertEquals(1, i[1].intValue());
304	assertEquals(2, i[2].intValue());
305	}
306
307
308	/**
309	* sublists contains elements at indexes offset from their base
310	*/
311	public void testSubList() {
312	List a = populatedArray(10);
313	assertTrue(a.subList(1,1).isEmpty());
314	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
323	List s = a.subList(2, 5);
324	assertEquals(3, s.size());
325	s.set(2, m1);
326	assertEquals(a.get(4), m1);
327	s.clear();
328	assertEquals(7, a.size());
329	}
330
331	// Exception tests
332
333	/**
334	* toArray throws an ArrayStoreException when the given array
335	* can not store the objects inside the list
336	*/
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	shouldThrow();
344	} catch (ArrayStoreException e) {}
345	}
346
347	/**
348	* get throws an IndexOutOfBoundsException on a negative index
349	*/
350	public void testGet1_IndexOutOfBoundsException() {
351	try {
352	List c = emptyArray();
353	c.get(-1);
354	shouldThrow();
355	} catch (IndexOutOfBoundsException e) {}
356	}
357
358	/**
359	* get throws an IndexOutOfBoundsException on a too high index
360	*/
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	} catch (IndexOutOfBoundsException e) {}
369	}
370
371	/**
372	* set throws an IndexOutOfBoundsException on a negative index
373	*/
374	public void testSet1_IndexOutOfBoundsException() {
375	try {
376	List c = emptyArray();
377	c.set(-1,"qwerty");
378	shouldThrow();
379	} catch (IndexOutOfBoundsException e) {}
380	}
381
382	/**
383	* set throws an IndexOutOfBoundsException on a too high index
384	*/
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	} catch (IndexOutOfBoundsException e) {}
393	}
394
395	/**
396	* add throws an IndexOutOfBoundsException on a negative index
397	*/
398	public void testAdd1_IndexOutOfBoundsException() {
399	try {
400	List c = emptyArray();
401	c.add(-1,"qwerty");
402	shouldThrow();
403	} catch (IndexOutOfBoundsException e) {}
404	}
405
406	/**
407	* add throws an IndexOutOfBoundsException on a too high index
408	*/
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	} catch (IndexOutOfBoundsException e) {}
417	}
418
419	/**
420	* remove throws an IndexOutOfBoundsException on a negative index
421	*/
422	public void testRemove1_IndexOutOfBounds() {
423	try {
424	List c = emptyArray();
425	c.remove(-1);
426	shouldThrow();
427	} catch (IndexOutOfBoundsException e) {}
428	}
429
430	/**
431	* remove throws an IndexOutOfBoundsException on a too high index
432	*/
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	} catch (IndexOutOfBoundsException e) {}
441	}
442
443	/**
444	* addAll throws an IndexOutOfBoundsException on a negative index
445	*/
446	public void testAddAll1_IndexOutOfBoundsException() {
447	try {
448	List c = emptyArray();
449	c.addAll(-1,new LinkedList());
450	shouldThrow();
451	} catch (IndexOutOfBoundsException e) {}
452	}
453
454	/**
455	* addAll throws an IndexOutOfBoundsException on a too high index
456	*/
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	} catch (IndexOutOfBoundsException e) {}
465	}
466
467	/**
468	* listIterator throws an IndexOutOfBoundsException on a negative index
469	*/
470	public void testListIterator1_IndexOutOfBoundsException() {
471	try {
472	List c = emptyArray();
473	c.listIterator(-1);
474	shouldThrow();
475	} catch (IndexOutOfBoundsException e) {}
476	}
477
478	/**
479	* listIterator throws an IndexOutOfBoundsException on a too high index
480	*/
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	} catch (IndexOutOfBoundsException e) {}
489	}
490
491	/**
492	* subList throws an IndexOutOfBoundsException on a negative index
493	*/
494	public void testSubList1_IndexOutOfBoundsException() {
495	try {
496	List c = emptyArray();
497	c.subList(-1,100);
498
499	shouldThrow();
500	} catch (IndexOutOfBoundsException e) {}
501	}
502
503	/**
504	* subList throws an IndexOutOfBoundsException on a too high index
505	*/
506	public void testSubList2_IndexOutOfBoundsException() {
507	try {
508	List c = emptyArray();
509	c.add("asdasd");
510	c.subList(1,100);
511	shouldThrow();
512	} catch (IndexOutOfBoundsException e) {}
513	}
514
515	/**
516	* subList throws IndexOutOfBoundsException when the second index
517	* is lower then the first
518	*/
519	public void testSubList3_IndexOutOfBoundsException() {
520	try {
521	List c = emptyArray();
522	c.subList(3,1);
523
524	shouldThrow();
525	} catch (IndexOutOfBoundsException e) {}
526	}
527
528
529	}