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/licenses/publicdomain
 * 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];
        i = (Integer[])full.toArray(i);
        assertEquals(3, i.length);
        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(s.size(), 3);
        s.set(2, m1);
        assertEquals(a.get(4), m1);
        s.clear();
        assertEquals(a.size(), 7);
    }

    // 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.2
Committed:	Mon Nov 16 04:16:43 2009 UTC (14 years, 5 months ago) by jsr166
Branch:	MAIN
Changes since 1.1:	+17 -17 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			* http://creativecommons.org/licenses/publicdomain
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			public class ParallelArrayAsListTest extends JSR166TestCase{
17	jsr166	1.2
18	dl	1.1	public static void main(String[] args) {
19	jsr166	1.2	junit.textui.TestRunner.run (suite());
20	dl	1.1	}
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	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			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	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			* 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	jsr166	1.2
132	dl	1.1	/**
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	jsr166	1.2	* iterator() returns an iterator containing the elements of the list
174	dl	1.1	*/
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	jsr166	1.2	}
206	dl	1.1
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			i = (Integer[])full.toArray(i);
302			assertEquals(3, i.length);
303			assertEquals(0, i[0].intValue());
304			assertEquals(1, i[1].intValue());
305			assertEquals(2, i[2].intValue());
306			}
307
308
309			/**
310			* sublists contains elements at indexes offset from their base
311			*/
312			public void testSubList() {
313			List a = populatedArray(10);
314			assertTrue(a.subList(1,1).isEmpty());
315			for(int j = 0; j < 9; ++j) {
316			for(int i = j ; i < 10; ++i) {
317			List b = a.subList(j,i);
318			for(int k = j; k < i; ++k) {
319			assertEquals(new Integer(k), b.get(k-j));
320			}
321			}
322			}
323
324			List s = a.subList(2, 5);
325			assertEquals(s.size(), 3);
326			s.set(2, m1);
327			assertEquals(a.get(4), m1);
328			s.clear();
329			assertEquals(a.size(), 7);
330			}
331
332			// Exception tests
333
334			/**
335			* toArray throws an ArrayStoreException when the given array
336			* can not store the objects inside the list
337			*/
338			public void testToArray_ArrayStoreException() {
339			try {
340			List c = emptyArray();
341			c.add("zfasdfsdf");
342			c.add("asdadasd");
343			c.toArray(new Long[5]);
344			shouldThrow();
345			} catch(ArrayStoreException e){}
346			}
347
348			/**
349			* get throws an IndexOutOfBoundsException on a negative index
350			*/
351			public void testGet1_IndexOutOfBoundsException() {
352			try {
353			List c = emptyArray();
354			c.get(-1);
355			shouldThrow();
356			} catch(IndexOutOfBoundsException e){}
357			}
358	jsr166	1.2
359	dl	1.1	/**
360			* get throws an IndexOutOfBoundsException on a too high index
361			*/
362			public void testGet2_IndexOutOfBoundsException() {
363			try {
364			List c = emptyArray();
365			c.add("asdasd");
366			c.add("asdad");
367			c.get(100);
368			shouldThrow();
369			} catch(IndexOutOfBoundsException e){}
370			}
371
372			/**
373			* set throws an IndexOutOfBoundsException on a negative index
374			*/
375			public void testSet1_IndexOutOfBoundsException() {
376			try {
377			List c = emptyArray();
378			c.set(-1,"qwerty");
379			shouldThrow();
380			} catch(IndexOutOfBoundsException e){}
381			}
382	jsr166	1.2
383	dl	1.1	/**
384			* set throws an IndexOutOfBoundsException on a too high index
385			*/
386			public void testSet2() {
387			try {
388			List c = emptyArray();
389			c.add("asdasd");
390			c.add("asdad");
391			c.set(100, "qwerty");
392			shouldThrow();
393			} catch(IndexOutOfBoundsException e){}
394			}
395
396			/**
397			* add throws an IndexOutOfBoundsException on a negative index
398			*/
399			public void testAdd1_IndexOutOfBoundsException() {
400			try {
401			List c = emptyArray();
402			c.add(-1,"qwerty");
403			shouldThrow();
404			} catch(IndexOutOfBoundsException e){}
405			}
406	jsr166	1.2
407	dl	1.1	/**
408			* add throws an IndexOutOfBoundsException on a too high index
409			*/
410			public void testAdd2_IndexOutOfBoundsException() {
411			try {
412			List c = emptyArray();
413			c.add("asdasd");
414			c.add("asdasdasd");
415			c.add(100, "qwerty");
416			shouldThrow();
417			} catch(IndexOutOfBoundsException e){}
418			}
419
420			/**
421			* remove throws an IndexOutOfBoundsException on a negative index
422			*/
423			public void testRemove1_IndexOutOfBounds() {
424			try {
425			List c = emptyArray();
426			c.remove(-1);
427			shouldThrow();
428			} catch(IndexOutOfBoundsException e){}
429			}
430
431			/**
432			* remove throws an IndexOutOfBoundsException on a too high index
433			*/
434			public void testRemove2_IndexOutOfBounds() {
435			try {
436			List c = emptyArray();
437			c.add("asdasd");
438			c.add("adasdasd");
439			c.remove(100);
440			shouldThrow();
441			} catch(IndexOutOfBoundsException e){}
442			}
443	jsr166	1.2
444	dl	1.1	/**
445			* addAll throws an IndexOutOfBoundsException on a negative index
446			*/
447			public void testAddAll1_IndexOutOfBoundsException() {
448			try {
449			List c = emptyArray();
450			c.addAll(-1,new LinkedList());
451			shouldThrow();
452			} catch(IndexOutOfBoundsException e){}
453			}
454	jsr166	1.2
455	dl	1.1	/**
456			* addAll throws an IndexOutOfBoundsException on a too high index
457			*/
458			public void testAddAll2_IndexOutOfBoundsException() {
459			try {
460			List c = emptyArray();
461			c.add("asdasd");
462			c.add("asdasdasd");
463			c.addAll(100, new LinkedList());
464			shouldThrow();
465			} catch(IndexOutOfBoundsException e){}
466			}
467
468			/**
469			* listIterator throws an IndexOutOfBoundsException on a negative index
470			*/
471			public void testListIterator1_IndexOutOfBoundsException() {
472			try {
473			List c = emptyArray();
474			c.listIterator(-1);
475			shouldThrow();
476			} catch(IndexOutOfBoundsException e){}
477			}
478
479			/**
480			* listIterator throws an IndexOutOfBoundsException on a too high index
481			*/
482			public void testListIterator2_IndexOutOfBoundsException() {
483			try {
484			List c = emptyArray();
485			c.add("adasd");
486			c.add("asdasdas");
487			c.listIterator(100);
488			shouldThrow();
489			} catch(IndexOutOfBoundsException e){}
490			}
491
492			/**
493			* subList throws an IndexOutOfBoundsException on a negative index
494			*/
495			public void testSubList1_IndexOutOfBoundsException() {
496			try {
497			List c = emptyArray();
498			c.subList(-1,100);
499
500			shouldThrow();
501			} catch(IndexOutOfBoundsException e){}
502			}
503
504			/**
505			* subList throws an IndexOutOfBoundsException on a too high index
506			*/
507			public void testSubList2_IndexOutOfBoundsException() {
508			try {
509			List c = emptyArray();
510			c.add("asdasd");
511			c.subList(1,100);
512			shouldThrow();
513			} catch(IndexOutOfBoundsException e){}
514			}
515
516			/**
517			* subList throws IndexOutOfBoundsException when the second index
518	jsr166	1.2	* is lower then the first
519	dl	1.1	*/
520			public void testSubList3_IndexOutOfBoundsException() {
521			try {
522			List c = emptyArray();
523			c.subList(3,1);
524
525			shouldThrow();
526			} catch(IndexOutOfBoundsException e){}
527			}
528
529	jsr166	1.2
530	dl	1.1	}