test/tck/CopyOnWriteArrayListTest.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.*;
import java.io.*;

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

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

    static CopyOnWriteArrayList populatedArray(int n){
        CopyOnWriteArrayList a = new CopyOnWriteArrayList();
        assertTrue(a.isEmpty());
        for (int i = 0; i < n; ++i) 
            a.add(new Integer(i));
        assertFalse(a.isEmpty());
        assertEquals(n, a.size());
        return a;
    }


    /**
     *
     */
    public void testConstructor() {
        CopyOnWriteArrayList a = new CopyOnWriteArrayList();
        assertTrue(a.isEmpty());
    }

    /**
     *
     */
    public void testConstructor2() {
        Integer[] ints = new Integer[SIZE];
        for (int i = 0; i < SIZE-1; ++i)
            ints[i] = new Integer(i);
        CopyOnWriteArrayList a = new CopyOnWriteArrayList(ints);
        for (int i = 0; i < SIZE; ++i) 
            assertEquals(ints[i], a.get(i));
    }

    /**
     *
     */
    public void testConstructor3() {
        Integer[] ints = new Integer[SIZE];
        for (int i = 0; i < SIZE-1; ++i)
            ints[i] = new Integer(i);
        CopyOnWriteArrayList a = new CopyOnWriteArrayList(Arrays.asList(ints));
        for (int i = 0; i < SIZE; ++i) 
            assertEquals(ints[i], a.get(i));
    }
        

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

    /**
     *   addAllAbsent adds each element from the given collection that did not
     *  already exist in the List
     */
    public void testAddAllAbsent() {
        CopyOnWriteArrayList full = populatedArray(3);
        Vector v = new Vector();
        v.add(three);
        v.add(four);
        v.add(one); // will not add this element
        full.addAllAbsent(v);
        assertEquals(5, full.size());
    }

    /**
     *   addIfAbsent will not add the element if it already exists in the list
     */
    public void testAddIfAbsent() {
        CopyOnWriteArrayList full = populatedArray(SIZE);
        full.addIfAbsent(one);
        assertEquals(SIZE, full.size());
    }

    /**
     *   addIfAbsent correctly adds the element when it does not exist in the list
     */
    public void testAddIfAbsent2() {
        CopyOnWriteArrayList full = populatedArray(SIZE);
        full.addIfAbsent(three);
        assertTrue(full.contains(three));
    }

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


    /**
     *  Cloned list is equal
     */
    public void testClone() {
        CopyOnWriteArrayList l1 = populatedArray(SIZE);
        CopyOnWriteArrayList l2 = (CopyOnWriteArrayList)(l1.clone());
        assertEquals(l1, l2);
        l1.clear();
        assertFalse(l1.equals(l2));
    }

    /**
     *   contains returns the correct values 
     */
    public void testContains() {
        CopyOnWriteArrayList full = populatedArray(3);
        assertTrue(full.contains(one));
        assertFalse(full.contains(five));
    }

    /**
     *
     */
    public void testAddIndex() {
        CopyOnWriteArrayList 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));
    }

    /**
     *
     */
    public void testEquals() {
        CopyOnWriteArrayList a = populatedArray(3);
        CopyOnWriteArrayList 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 the correct values
     */
    public void testContainsAll() {
        CopyOnWriteArrayList 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 correct value for the given index
     */
    public void testGet() {
        CopyOnWriteArrayList full = populatedArray(3);
        assertEquals(0, ((Integer)full.get(0)).intValue());
    }

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

    /**
     *   indexOf gives the correct index based on the given index
     *  at which to start searching
     */
    public void testIndexOf2() {
        CopyOnWriteArrayList full = populatedArray(3);
        assertEquals(1, full.indexOf(one, 0));
        assertEquals(-1, full.indexOf(one, 2));
    }

    /**
     *   isEmpty returns the correct values
     */
    public void testIsEmpty() {
        CopyOnWriteArrayList empty = new CopyOnWriteArrayList();
        CopyOnWriteArrayList full = populatedArray(SIZE);
        assertTrue(empty.isEmpty());
        assertFalse(full.isEmpty());
    }

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

    /**
     *
     */
    public void testIteratorRemove () {
        CopyOnWriteArrayList full = populatedArray(SIZE);
        Iterator it = full.iterator();
        it.next();
        try {
            it.remove();
            shouldThrow();
        }
        catch (UnsupportedOperationException success) {}
    }

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

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

    /**
     *   lastIndexOf returns the correct index from the given starting point
     */
    public void testlastIndexOf2() {
        CopyOnWriteArrayList full = populatedArray(3);
        full.add(one);
        full.add(three);
        assertEquals(3, full.lastIndexOf(one, 4));
        assertEquals(-1, full.lastIndexOf(three, 3));
    }

    /**
     *  Identical to testIterator, except ListInterator has more functionality
     */
    public void testListIterator1() {
        CopyOnWriteArrayList 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() {
        CopyOnWriteArrayList 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 correctly removes and returns the object at the given index
     */
    public void testRemove() {
        CopyOnWriteArrayList full = populatedArray(3);
        assertEquals(two, full.remove(2));
        assertEquals(2, full.size());
    }

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

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

    /**
     *   size returns the correct values
     */
    public void testSize() {
        CopyOnWriteArrayList empty = new CopyOnWriteArrayList();
        CopyOnWriteArrayList 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() {
        CopyOnWriteArrayList 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() {
        CopyOnWriteArrayList 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());
    }


    /**
     *
     */
    public void testSubList() {
        CopyOnWriteArrayList 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 {
            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
            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 {
            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
            c.get(-1);
            shouldThrow();
        } catch(IndexOutOfBoundsException e){}
    }
    
    /**
     *   get throws an IndexOutOfBoundsException on a too high index
     */
    public void testGet2_IndexOutOfBoundsException() {
        try {
            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
            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 {
            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
            c.set(-1,"qwerty");
            shouldThrow();
        } catch(IndexOutOfBoundsException e){}
    }
    
    /**
     *   set throws an IndexOutOfBoundsException on a too high index
     */
    public void testSet2() {
        try {
            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
            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 {
            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
            c.add(-1,"qwerty");
            shouldThrow();
        } catch(IndexOutOfBoundsException e){}
    }
    
    /**
     *   add throws an IndexOutOfBoundsException on a too high index
     */
    public void testAdd2_IndexOutOfBoundsException() {
        try {
            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
            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 {
            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
            c.remove(-1);
            shouldThrow();
        } catch(IndexOutOfBoundsException e){}
    }

    /**
     *   remove throws an IndexOutOfBoundsException on a too high index
     */
    public void testRemove2_IndexOutOfBounds() {
        try {
            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
            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 {
            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
            c.addAll(-1,new LinkedList());
            shouldThrow();
        } catch(IndexOutOfBoundsException e){}
    }
    
    /**
     *   addAll throws an IndexOutOfBoundsException on a too high index
     */
    public void testAddAll2_IndexOutOfBoundsException() {
        try {
            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
            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 {
            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
            c.listIterator(-1);
            shouldThrow();
        } catch(IndexOutOfBoundsException e){}
    }

    /**
     *   listIterator throws an IndexOutOfBoundsException on a too high index
     */
    public void testListIterator2_IndexOutOfBoundsException() {
        try {
            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
            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 {
            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
            c.subList(-1,100);

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

    /**
     *   subList throws an IndexOutOfBoundsException on a too high index
     */
    public void testSubList2_IndexOutOfBoundsException() {
        try {
            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
            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 {
            CopyOnWriteArrayList c = new CopyOnWriteArrayList();
            c.subList(3,1);

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

    /**
     *
     */
    public void testSerialization() {
        CopyOnWriteArrayList q = populatedArray(SIZE);

        try {
            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
            out.writeObject(q);
            out.close();

            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
            CopyOnWriteArrayList r = (CopyOnWriteArrayList)in.readObject();
            assertEquals(q.size(), r.size());
            assertTrue(q.equals(r));
            assertTrue(r.equals(q));
        } catch(Exception e){
            unexpectedException();
        }
    }
    
}
Revision:	1.4
Committed:	Sat Sep 20 18:20:07 2003 UTC (20 years, 7 months ago) by dl
Branch:	MAIN
Changes since 1.3:	+143 -105 lines
Log Message:	Documentation scaffolding
#	Content
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	import java.io.*;
12
13	public class CopyOnWriteArrayListTest extends JSR166TestCase{
14
15	public static void main(String[] args) {
16	junit.textui.TestRunner.run (suite());
17	}
18
19	public static Test suite() {
20	return new TestSuite(CopyOnWriteArrayListTest.class);
21	}
22
23	static CopyOnWriteArrayList populatedArray(int n){
24	CopyOnWriteArrayList a = new CopyOnWriteArrayList();
25	assertTrue(a.isEmpty());
26	for (int i = 0; i < n; ++i)
27	a.add(new Integer(i));
28	assertFalse(a.isEmpty());
29	assertEquals(n, a.size());
30	return a;
31	}
32
33
34	/**
35	*
36	*/
37	public void testConstructor() {
38	CopyOnWriteArrayList a = new CopyOnWriteArrayList();
39	assertTrue(a.isEmpty());
40	}
41
42	/**
43	*
44	*/
45	public void testConstructor2() {
46	Integer[] ints = new Integer[SIZE];
47	for (int i = 0; i < SIZE-1; ++i)
48	ints[i] = new Integer(i);
49	CopyOnWriteArrayList a = new CopyOnWriteArrayList(ints);
50	for (int i = 0; i < SIZE; ++i)
51	assertEquals(ints[i], a.get(i));
52	}
53
54	/**
55	*
56	*/
57	public void testConstructor3() {
58	Integer[] ints = new Integer[SIZE];
59	for (int i = 0; i < SIZE-1; ++i)
60	ints[i] = new Integer(i);
61	CopyOnWriteArrayList a = new CopyOnWriteArrayList(Arrays.asList(ints));
62	for (int i = 0; i < SIZE; ++i)
63	assertEquals(ints[i], a.get(i));
64	}
65
66
67	/**
68	* addAll correctly adds each element from the given collection
69	*/
70	public void testAddAll() {
71	CopyOnWriteArrayList full = populatedArray(3);
72	Vector v = new Vector();
73	v.add(three);
74	v.add(four);
75	v.add(five);
76	full.addAll(v);
77	assertEquals(6, full.size());
78	}
79
80	/**
81	* addAllAbsent adds each element from the given collection that did not
82	* already exist in the List
83	*/
84	public void testAddAllAbsent() {
85	CopyOnWriteArrayList full = populatedArray(3);
86	Vector v = new Vector();
87	v.add(three);
88	v.add(four);
89	v.add(one); // will not add this element
90	full.addAllAbsent(v);
91	assertEquals(5, full.size());
92	}
93
94	/**
95	* addIfAbsent will not add the element if it already exists in the list
96	*/
97	public void testAddIfAbsent() {
98	CopyOnWriteArrayList full = populatedArray(SIZE);
99	full.addIfAbsent(one);
100	assertEquals(SIZE, full.size());
101	}
102
103	/**
104	* addIfAbsent correctly adds the element when it does not exist in the list
105	*/
106	public void testAddIfAbsent2() {
107	CopyOnWriteArrayList full = populatedArray(SIZE);
108	full.addIfAbsent(three);
109	assertTrue(full.contains(three));
110	}
111
112	/**
113	* clear correctly removes all elements from the list
114	*/
115	public void testClear() {
116	CopyOnWriteArrayList full = populatedArray(SIZE);
117	full.clear();
118	assertEquals(0, full.size());
119	}
120
121
122	/**
123	* Cloned list is equal
124	*/
125	public void testClone() {
126	CopyOnWriteArrayList l1 = populatedArray(SIZE);
127	CopyOnWriteArrayList l2 = (CopyOnWriteArrayList)(l1.clone());
128	assertEquals(l1, l2);
129	l1.clear();
130	assertFalse(l1.equals(l2));
131	}
132
133	/**
134	* contains returns the correct values
135	*/
136	public void testContains() {
137	CopyOnWriteArrayList full = populatedArray(3);
138	assertTrue(full.contains(one));
139	assertFalse(full.contains(five));
140	}
141
142	/**
143	*
144	*/
145	public void testAddIndex() {
146	CopyOnWriteArrayList full = populatedArray(3);
147	full.add(0, m1);
148	assertEquals(4, full.size());
149	assertEquals(m1, full.get(0));
150	assertEquals(zero, full.get(1));
151
152	full.add(2, m2);
153	assertEquals(5, full.size());
154	assertEquals(m2, full.get(2));
155	assertEquals(two, full.get(4));
156	}
157
158	/**
159	*
160	*/
161	public void testEquals() {
162	CopyOnWriteArrayList a = populatedArray(3);
163	CopyOnWriteArrayList b = populatedArray(3);
164	assertTrue(a.equals(b));
165	assertTrue(b.equals(a));
166	assertEquals(a.hashCode(), b.hashCode());
167	a.add(m1);
168	assertFalse(a.equals(b));
169	assertFalse(b.equals(a));
170	b.add(m1);
171	assertTrue(a.equals(b));
172	assertTrue(b.equals(a));
173	assertEquals(a.hashCode(), b.hashCode());
174	}
175
176
177	/**
178	* containsAll returns the correct values
179	*/
180	public void testContainsAll() {
181	CopyOnWriteArrayList full = populatedArray(3);
182	Vector v = new Vector();
183	v.add(one);
184	v.add(two);
185	assertTrue(full.containsAll(v));
186	v.add(six);
187	assertFalse(full.containsAll(v));
188	}
189
190	/**
191	* get returns the correct value for the given index
192	*/
193	public void testGet() {
194	CopyOnWriteArrayList full = populatedArray(3);
195	assertEquals(0, ((Integer)full.get(0)).intValue());
196	}
197
198	/**
199	* indexOf gives the correct index for the given object
200	*/
201	public void testIndexOf() {
202	CopyOnWriteArrayList full = populatedArray(3);
203	assertEquals(1, full.indexOf(one));
204	assertEquals(-1, full.indexOf("puppies"));
205	}
206
207	/**
208	* indexOf gives the correct index based on the given index
209	* at which to start searching
210	*/
211	public void testIndexOf2() {
212	CopyOnWriteArrayList full = populatedArray(3);
213	assertEquals(1, full.indexOf(one, 0));
214	assertEquals(-1, full.indexOf(one, 2));
215	}
216
217	/**
218	* isEmpty returns the correct values
219	*/
220	public void testIsEmpty() {
221	CopyOnWriteArrayList empty = new CopyOnWriteArrayList();
222	CopyOnWriteArrayList full = populatedArray(SIZE);
223	assertTrue(empty.isEmpty());
224	assertFalse(full.isEmpty());
225	}
226
227	/**
228	* iterator() returns an iterator containing the elements of the list
229	*/
230	public void testIterator() {
231	CopyOnWriteArrayList full = populatedArray(SIZE);
232	Iterator i = full.iterator();
233	int j;
234	for(j = 0; i.hasNext(); j++)
235	assertEquals(j, ((Integer)i.next()).intValue());
236	assertEquals(SIZE, j);
237	}
238
239	/**
240	*
241	*/
242	public void testIteratorRemove () {
243	CopyOnWriteArrayList full = populatedArray(SIZE);
244	Iterator it = full.iterator();
245	it.next();
246	try {
247	it.remove();
248	shouldThrow();
249	}
250	catch (UnsupportedOperationException success) {}
251	}
252
253	/**
254	*
255	*/
256	public void testToString() {
257	CopyOnWriteArrayList full = populatedArray(3);
258	String s = full.toString();
259	for (int i = 0; i < 3; ++i) {
260	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
261	}
262	}
263
264	/**
265	* lastIndexOf returns the correct index for the given object
266	*/
267	public void testLastIndexOf1() {
268	CopyOnWriteArrayList full = populatedArray(3);
269	full.add(one);
270	full.add(three);
271	assertEquals(3, full.lastIndexOf(one));
272	assertEquals(-1, full.lastIndexOf(six));
273	}
274
275	/**
276	* lastIndexOf returns the correct index from the given starting point
277	*/
278	public void testlastIndexOf2() {
279	CopyOnWriteArrayList full = populatedArray(3);
280	full.add(one);
281	full.add(three);
282	assertEquals(3, full.lastIndexOf(one, 4));
283	assertEquals(-1, full.lastIndexOf(three, 3));
284	}
285
286	/**
287	* Identical to testIterator, except ListInterator has more functionality
288	*/
289	public void testListIterator1() {
290	CopyOnWriteArrayList full = populatedArray(SIZE);
291	ListIterator i = full.listIterator();
292	int j;
293	for(j = 0; i.hasNext(); j++)
294	assertEquals(j, ((Integer)i.next()).intValue());
295	assertEquals(SIZE, j);
296	}
297
298	/**
299	* listIterator only returns those elements after the given index
300	*/
301	public void testListIterator2() {
302	CopyOnWriteArrayList full = populatedArray(3);
303	ListIterator i = full.listIterator(1);
304	int j;
305	for(j = 0; i.hasNext(); j++)
306	assertEquals(j+1, ((Integer)i.next()).intValue());
307	assertEquals(2, j);
308	}
309
310	/**
311	* remove correctly removes and returns the object at the given index
312	*/
313	public void testRemove() {
314	CopyOnWriteArrayList full = populatedArray(3);
315	assertEquals(two, full.remove(2));
316	assertEquals(2, full.size());
317	}
318
319	/**
320	* removeAll correctly removes all elements from the given collection
321	*/
322	public void testRemoveAll() {
323	CopyOnWriteArrayList full = populatedArray(3);
324	Vector v = new Vector();
325	v.add(one);
326	v.add(two);
327	full.removeAll(v);
328	assertEquals(1, full.size());
329	}
330
331	/**
332	* set correctly changes the element at the given index
333	*/
334	public void testSet() {
335	CopyOnWriteArrayList full = populatedArray(3);
336	assertEquals(two, full.set(2, four));
337	assertEquals(4, ((Integer)full.get(2)).intValue());
338	}
339
340	/**
341	* size returns the correct values
342	*/
343	public void testSize() {
344	CopyOnWriteArrayList empty = new CopyOnWriteArrayList();
345	CopyOnWriteArrayList full = populatedArray(SIZE);
346	assertEquals(SIZE, full.size());
347	assertEquals(0, empty.size());
348	}
349
350	/**
351	* toArray returns an Object array containing all elements from the list
352	*/
353	public void testToArray() {
354	CopyOnWriteArrayList full = populatedArray(3);
355	Object[] o = full.toArray();
356	assertEquals(3, o.length);
357	assertEquals(0, ((Integer)o[0]).intValue());
358	assertEquals(1, ((Integer)o[1]).intValue());
359	assertEquals(2, ((Integer)o[2]).intValue());
360	}
361
362	/**
363	* toArray returns an Integer array containing all elements from
364	* the list
365	*/
366	public void testToArray2() {
367	CopyOnWriteArrayList full = populatedArray(3);
368	Integer[] i = new Integer[3];
369	i = (Integer[])full.toArray(i);
370	assertEquals(3, i.length);
371	assertEquals(0, i[0].intValue());
372	assertEquals(1, i[1].intValue());
373	assertEquals(2, i[2].intValue());
374	}
375
376
377	/**
378	*
379	*/
380	public void testSubList() {
381	CopyOnWriteArrayList a = populatedArray(10);
382	assertTrue(a.subList(1,1).isEmpty());
383	for(int j = 0; j < 9; ++j) {
384	for(int i = j ; i < 10; ++i) {
385	List b = a.subList(j,i);
386	for(int k = j; k < i; ++k) {
387	assertEquals(new Integer(k), b.get(k-j));
388	}
389	}
390	}
391
392	List s = a.subList(2, 5);
393	assertEquals(s.size(), 3);
394	s.set(2, m1);
395	assertEquals(a.get(4), m1);
396	s.clear();
397	assertEquals(a.size(), 7);
398	}
399
400	// Exception tests
401
402	/**
403	* toArray throws an ArrayStoreException when the given array
404	* can not store the objects inside the list
405	*/
406	public void testToArray_ArrayStoreException() {
407	try {
408	CopyOnWriteArrayList c = new CopyOnWriteArrayList();
409	c.add("zfasdfsdf");
410	c.add("asdadasd");
411	c.toArray(new Long[5]);
412	shouldThrow();
413	} catch(ArrayStoreException e){}
414	}
415
416	/**
417	* get throws an IndexOutOfBoundsException on a negative index
418	*/
419	public void testGet1_IndexOutOfBoundsException() {
420	try {
421	CopyOnWriteArrayList c = new CopyOnWriteArrayList();
422	c.get(-1);
423	shouldThrow();
424	} catch(IndexOutOfBoundsException e){}
425	}
426
427	/**
428	* get throws an IndexOutOfBoundsException on a too high index
429	*/
430	public void testGet2_IndexOutOfBoundsException() {
431	try {
432	CopyOnWriteArrayList c = new CopyOnWriteArrayList();
433	c.add("asdasd");
434	c.add("asdad");
435	c.get(100);
436	shouldThrow();
437	} catch(IndexOutOfBoundsException e){}
438	}
439
440	/**
441	* set throws an IndexOutOfBoundsException on a negative index
442	*/
443	public void testSet1_IndexOutOfBoundsException() {
444	try {
445	CopyOnWriteArrayList c = new CopyOnWriteArrayList();
446	c.set(-1,"qwerty");
447	shouldThrow();
448	} catch(IndexOutOfBoundsException e){}
449	}
450
451	/**
452	* set throws an IndexOutOfBoundsException on a too high index
453	*/
454	public void testSet2() {
455	try {
456	CopyOnWriteArrayList c = new CopyOnWriteArrayList();
457	c.add("asdasd");
458	c.add("asdad");
459	c.set(100, "qwerty");
460	shouldThrow();
461	} catch(IndexOutOfBoundsException e){}
462	}
463
464	/**
465	* add throws an IndexOutOfBoundsException on a negative index
466	*/
467	public void testAdd1_IndexOutOfBoundsException() {
468	try {
469	CopyOnWriteArrayList c = new CopyOnWriteArrayList();
470	c.add(-1,"qwerty");
471	shouldThrow();
472	} catch(IndexOutOfBoundsException e){}
473	}
474
475	/**
476	* add throws an IndexOutOfBoundsException on a too high index
477	*/
478	public void testAdd2_IndexOutOfBoundsException() {
479	try {
480	CopyOnWriteArrayList c = new CopyOnWriteArrayList();
481	c.add("asdasd");
482	c.add("asdasdasd");
483	c.add(100, "qwerty");
484	shouldThrow();
485	} catch(IndexOutOfBoundsException e){}
486	}
487
488	/**
489	* remove throws an IndexOutOfBoundsException on a negative index
490	*/
491	public void testRemove1_IndexOutOfBounds() {
492	try {
493	CopyOnWriteArrayList c = new CopyOnWriteArrayList();
494	c.remove(-1);
495	shouldThrow();
496	} catch(IndexOutOfBoundsException e){}
497	}
498
499	/**
500	* remove throws an IndexOutOfBoundsException on a too high index
501	*/
502	public void testRemove2_IndexOutOfBounds() {
503	try {
504	CopyOnWriteArrayList c = new CopyOnWriteArrayList();
505	c.add("asdasd");
506	c.add("adasdasd");
507	c.remove(100);
508	shouldThrow();
509	} catch(IndexOutOfBoundsException e){}
510	}
511
512	/**
513	* addAll throws an IndexOutOfBoundsException on a negative index
514	*/
515	public void testAddAll1_IndexOutOfBoundsException() {
516	try {
517	CopyOnWriteArrayList c = new CopyOnWriteArrayList();
518	c.addAll(-1,new LinkedList());
519	shouldThrow();
520	} catch(IndexOutOfBoundsException e){}
521	}
522
523	/**
524	* addAll throws an IndexOutOfBoundsException on a too high index
525	*/
526	public void testAddAll2_IndexOutOfBoundsException() {
527	try {
528	CopyOnWriteArrayList c = new CopyOnWriteArrayList();
529	c.add("asdasd");
530	c.add("asdasdasd");
531	c.addAll(100, new LinkedList());
532	shouldThrow();
533	} catch(IndexOutOfBoundsException e){}
534	}
535
536	/**
537	* listIterator throws an IndexOutOfBoundsException on a negative index
538	*/
539	public void testListIterator1_IndexOutOfBoundsException() {
540	try {
541	CopyOnWriteArrayList c = new CopyOnWriteArrayList();
542	c.listIterator(-1);
543	shouldThrow();
544	} catch(IndexOutOfBoundsException e){}
545	}
546
547	/**
548	* listIterator throws an IndexOutOfBoundsException on a too high index
549	*/
550	public void testListIterator2_IndexOutOfBoundsException() {
551	try {
552	CopyOnWriteArrayList c = new CopyOnWriteArrayList();
553	c.add("adasd");
554	c.add("asdasdas");
555	c.listIterator(100);
556	shouldThrow();
557	} catch(IndexOutOfBoundsException e){}
558	}
559
560	/**
561	* subList throws an IndexOutOfBoundsException on a negative index
562	*/
563	public void testSubList1_IndexOutOfBoundsException() {
564	try {
565	CopyOnWriteArrayList c = new CopyOnWriteArrayList();
566	c.subList(-1,100);
567
568	shouldThrow();
569	} catch(IndexOutOfBoundsException e){}
570	}
571
572	/**
573	* subList throws an IndexOutOfBoundsException on a too high index
574	*/
575	public void testSubList2_IndexOutOfBoundsException() {
576	try {
577	CopyOnWriteArrayList c = new CopyOnWriteArrayList();
578	c.add("asdasd");
579	c.subList(1,100);
580	shouldThrow();
581	} catch(IndexOutOfBoundsException e){}
582	}
583
584	/**
585	* subList throws IndexOutOfBoundsException when the second index
586	* is lower then the first
587	*/
588	public void testSubList3_IndexOutOfBoundsException() {
589	try {
590	CopyOnWriteArrayList c = new CopyOnWriteArrayList();
591	c.subList(3,1);
592
593	shouldThrow();
594	} catch(IndexOutOfBoundsException e){}
595	}
596
597	/**
598	*
599	*/
600	public void testSerialization() {
601	CopyOnWriteArrayList q = populatedArray(SIZE);
602
603	try {
604	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
605	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
606	out.writeObject(q);
607	out.close();
608
609	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
610	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
611	CopyOnWriteArrayList r = (CopyOnWriteArrayList)in.readObject();
612	assertEquals(q.size(), r.size());
613	assertTrue(q.equals(r));
614	assertTrue(r.equals(q));
615	} catch(Exception e){
616	unexpectedException();
617	}
618	}
619
620	}