test/tck/VectorTest.java

/*
 * Written by Doug Lea and Martin Buchholz 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/
 */

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Vector;
import java.util.concurrent.ThreadLocalRandom;

import junit.framework.Test;

public class VectorTest extends JSR166TestCase {
    public static void main(String[] args) {
        main(suite(), args);
    }

    public static Test suite() {
        class Implementation implements CollectionImplementation {
            public Class<?> klazz() { return Vector.class; }
            public List emptyCollection() { return new Vector(); }
            public Object makeElement(int i) { return i; }
            public boolean isConcurrent() { return false; }
            public boolean permitsNulls() { return true; }
        }
        class SubListImplementation extends Implementation {
            public List emptyCollection() {
                return super.emptyCollection().subList(0, 0);
            }
        }
        return newTestSuite(
                VectorTest.class,
                CollectionTest.testSuite(new Implementation()),
                CollectionTest.testSuite(new SubListImplementation()));
    }

    static Vector<Integer> populatedList(int n) {
        Vector<Integer> list = new Vector<>();
        assertTrue(list.isEmpty());
        for (int i = 0; i < n; i++)
            list.add(i);
        assertEquals(n <= 0, list.isEmpty());
        assertEquals(n, list.size());
        return list;
    }

    /**
     * addAll adds each element from the given collection, including duplicates
     */
    public void testAddAll() {
        List list = populatedList(3);
        assertTrue(list.addAll(Arrays.asList(three, four, five)));
        assertEquals(6, list.size());
        assertTrue(list.addAll(Arrays.asList(three, four, five)));
        assertEquals(9, list.size());
    }

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

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

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

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

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

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

        assertFalse(a.equals(null));
    }

    /**
     * containsAll returns true for collections with subset of elements
     */
    public void testContainsAll() {
        List list = populatedList(3);
        assertTrue(list.containsAll(Arrays.asList()));
        assertTrue(list.containsAll(Arrays.asList(one)));
        assertTrue(list.containsAll(Arrays.asList(one, two)));
        assertFalse(list.containsAll(Arrays.asList(one, two, six)));
        assertFalse(list.containsAll(Arrays.asList(six)));

        try {
            list.containsAll(null);
            shouldThrow();
        } catch (NullPointerException success) {}
    }

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

    /**
     * indexOf(Object) returns the index of the first occurrence of the
     * specified element in this list, or -1 if this list does not
     * contain the element
     */
    public void testIndexOf() {
        List list = populatedList(3);
        assertEquals(-1, list.indexOf(-42));
        int size = list.size();
        for (int i = 0; i < size; i++) {
            assertEquals(i, list.indexOf(i));
            assertEquals(i, list.subList(0, size).indexOf(i));
            assertEquals(i, list.subList(0, i + 1).indexOf(i));
            assertEquals(-1, list.subList(0, i).indexOf(i));
            assertEquals(0, list.subList(i, size).indexOf(i));
            assertEquals(-1, list.subList(i + 1, size).indexOf(i));
        }

        list.add(1);
        assertEquals(1, list.indexOf(1));
        assertEquals(1, list.subList(0, size + 1).indexOf(1));
        assertEquals(0, list.subList(1, size + 1).indexOf(1));
        assertEquals(size - 2, list.subList(2, size + 1).indexOf(1));
        assertEquals(0, list.subList(size, size + 1).indexOf(1));
        assertEquals(-1, list.subList(size + 1, size + 1).indexOf(1));
    }

    /**
     * indexOf(E, int) returns the index of the first occurrence of the
     * specified element in this list, searching forwards from index,
     * or returns -1 if the element is not found
     */
    public void testIndexOf2() {
        Vector list = populatedList(3);
        int size = list.size();
        assertEquals(-1, list.indexOf(-42, 0));

        // we might expect IOOBE, but spec says otherwise
        assertEquals(-1, list.indexOf(0, size));
        assertEquals(-1, list.indexOf(0, Integer.MAX_VALUE));

        assertThrows(
            IndexOutOfBoundsException.class,
            () -> list.indexOf(0, -1),
            () -> list.indexOf(0, Integer.MIN_VALUE));

        for (int i = 0; i < size; i++) {
            assertEquals(i, list.indexOf(i, 0));
            assertEquals(i, list.indexOf(i, i));
            assertEquals(-1, list.indexOf(i, i + 1));
        }

        list.add(1);
        assertEquals(1, list.indexOf(1, 0));
        assertEquals(1, list.indexOf(1, 1));
        assertEquals(size, list.indexOf(1, 2));
        assertEquals(size, list.indexOf(1, size));
    }

    /**
     * isEmpty returns true when empty, else false
     */
    public void testIsEmpty() {
        List empty = new Vector();
        assertTrue(empty.isEmpty());
        assertTrue(empty.subList(0, 0).isEmpty());

        List full = populatedList(SIZE);
        assertFalse(full.isEmpty());
        assertTrue(full.subList(0, 0).isEmpty());
        assertTrue(full.subList(SIZE, SIZE).isEmpty());
    }

    /**
     * iterator of empty collection has no elements
     */
    public void testEmptyIterator() {
        Collection c = new Vector();
        assertIteratorExhausted(c.iterator());
    }

    /**
     * lastIndexOf(Object) returns the index of the last occurrence of
     * the specified element in this list, or -1 if this list does not
     * contain the element
     */
    public void testLastIndexOf1() {
        List list = populatedList(3);
        assertEquals(-1, list.lastIndexOf(-42));
        int size = list.size();
        for (int i = 0; i < size; i++) {
            assertEquals(i, list.lastIndexOf(i));
            assertEquals(i, list.subList(0, size).lastIndexOf(i));
            assertEquals(i, list.subList(0, i + 1).lastIndexOf(i));
            assertEquals(-1, list.subList(0, i).lastIndexOf(i));
            assertEquals(0, list.subList(i, size).lastIndexOf(i));
            assertEquals(-1, list.subList(i + 1, size).lastIndexOf(i));
        }

        list.add(1);
        assertEquals(size, list.lastIndexOf(1));
        assertEquals(size, list.subList(0, size + 1).lastIndexOf(1));
        assertEquals(1, list.subList(0, size).lastIndexOf(1));
        assertEquals(0, list.subList(1, 2).lastIndexOf(1));
        assertEquals(-1, list.subList(0, 1).indexOf(1));
    }

    /**
     * lastIndexOf(E, int) returns the index of the last occurrence of the
     * specified element in this list, searching backwards from index, or
     * returns -1 if the element is not found
     */
    public void testLastIndexOf2() {
        Vector list = populatedList(3);

        // we might expect IOOBE, but spec says otherwise
        assertEquals(-1, list.lastIndexOf(0, -1));

        int size = list.size();
        assertThrows(
            IndexOutOfBoundsException.class,
            () -> list.lastIndexOf(0, size),
            () -> list.lastIndexOf(0, Integer.MAX_VALUE));

        for (int i = 0; i < size; i++) {
            assertEquals(i, list.lastIndexOf(i, i));
            assertEquals(list.indexOf(i), list.lastIndexOf(i, i));
            if (i > 0)
                assertEquals(-1, list.lastIndexOf(i, i - 1));
        }
        list.add(one);
        list.add(three);
        assertEquals(1, list.lastIndexOf(one, 1));
        assertEquals(1, list.lastIndexOf(one, 2));
        assertEquals(3, list.lastIndexOf(one, 3));
        assertEquals(3, list.lastIndexOf(one, 4));
        assertEquals(-1, list.lastIndexOf(three, 3));
    }

    /**
     * size returns the number of elements
     */
    public void testSize() {
        List empty = new Vector();
        assertEquals(0, empty.size());
        assertEquals(0, empty.subList(0, 0).size());

        List full = populatedList(SIZE);
        assertEquals(SIZE, full.size());
        assertEquals(0, full.subList(0, 0).size());
        assertEquals(0, full.subList(SIZE, SIZE).size());
    }

    /**
     * sublists contains elements at indexes offset from their base
     */
    public void testSubList() {
        List a = populatedList(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());

        assertThrows(
            IndexOutOfBoundsException.class,
            () -> s.get(0),
            () -> s.set(0, 42));
    }

    /**
     * toArray throws an ArrayStoreException when the given array
     * can not store the objects inside the list
     */
    public void testToArray_ArrayStoreException() {
        List list = new Vector();
        // Integers are not auto-converted to Longs
        list.add(86);
        list.add(99);
        assertThrows(
            ArrayStoreException.class,
            () -> list.toArray(new Long[0]),
            () -> list.toArray(new Long[5]));
    }

    void testIndexOutOfBoundsException(List list) {
        int size = list.size();
        assertThrows(
            IndexOutOfBoundsException.class,
            () -> list.get(-1),
            () -> list.get(size),
            () -> list.set(-1, "qwerty"),
            () -> list.set(size, "qwerty"),
            () -> list.add(-1, "qwerty"),
            () -> list.add(size + 1, "qwerty"),
            () -> list.remove(-1),
            () -> list.remove(size),
            () -> list.addAll(-1, Collections.emptyList()),
            () -> list.addAll(size + 1, Collections.emptyList()),
            () -> list.listIterator(-1),
            () -> list.listIterator(size + 1),
            () -> list.subList(-1, size),
            () -> list.subList(0, size + 1));

        // Conversely, operations that must not throw
        list.addAll(0, Collections.emptyList());
        list.addAll(size, Collections.emptyList());
        list.add(0, "qwerty");
        list.add(list.size(), "qwerty");
        list.get(0);
        list.get(list.size() - 1);
        list.set(0, "azerty");
        list.set(list.size() - 1, "azerty");
        list.listIterator(0);
        list.listIterator(list.size());
        list.subList(0, list.size());
        list.remove(list.size() - 1);
    }

    /**
     * IndexOutOfBoundsException is thrown when specified
     */
    public void testIndexOutOfBoundsException() {
        ThreadLocalRandom rnd = ThreadLocalRandom.current();
        List x = populatedList(rnd.nextInt(5));
        testIndexOutOfBoundsException(x);

        int start = rnd.nextInt(x.size() + 1);
        int end = rnd.nextInt(start, x.size() + 1);

        // Vector#subList spec deviates slightly from List#subList spec
        assertThrows(
            IllegalArgumentException.class,
            () -> x.subList(start, start - 1));

        List subList = x.subList(start, end);
        testIndexOutOfBoundsException(x);
    }

    /**
     * a deserialized/reserialized list equals original
     */
    public void testSerialization() throws Exception {
        List x = populatedList(SIZE);
        List y = serialClone(x);

        assertNotSame(x, y);
        assertEquals(x.size(), y.size());
        assertEquals(x.toString(), y.toString());
        assertTrue(Arrays.equals(x.toArray(), y.toArray()));
        assertEquals(x, y);
        assertEquals(y, x);
        while (!x.isEmpty()) {
            assertFalse(y.isEmpty());
            assertEquals(x.remove(0), y.remove(0));
        }
        assertTrue(y.isEmpty());
    }

    /**
     * tests for setSize()
     */
    public void testSetSize() {
        final Vector v = new Vector();
        for (int n : new int[] { 100, 5, 50 }) {
            v.setSize(n);
            assertEquals(n, v.size());
            assertNull(v.get(0));
            assertNull(v.get(n - 1));
            assertThrows(
                    ArrayIndexOutOfBoundsException.class,
                    new Runnable() { public void run() { v.setSize(-1); }});
            assertEquals(n, v.size());
            assertNull(v.get(0));
            assertNull(v.get(n - 1));
        }
    }

}
Revision:	1.7
Committed:	Tue Apr 3 00:59:22 2018 UTC (6 years, 1 month ago) by jsr166
Branch:	MAIN
Changes since 1.6:	+393 -1 lines
Log Message:	port CopyOnWriteArrayListTest tests to also test Vector
#	Content
1	/*
2	* Written by Doug Lea and Martin Buchholz with assistance from
3	* members of JCP JSR-166 Expert Group and released to the public
4	* domain, as explained at
5	* http://creativecommons.org/publicdomain/zero/1.0/
6	*/
7
8	import java.util.ArrayList;
9	import java.util.Arrays;
10	import java.util.Collection;
11	import java.util.Collections;
12	import java.util.List;
13	import java.util.Vector;
14	import java.util.concurrent.ThreadLocalRandom;
15
16	import junit.framework.Test;
17
18	public class VectorTest extends JSR166TestCase {
19	public static void main(String[] args) {
20	main(suite(), args);
21	}
22
23	public static Test suite() {
24	class Implementation implements CollectionImplementation {
25	public Class<?> klazz() { return Vector.class; }
26	public List emptyCollection() { return new Vector(); }
27	public Object makeElement(int i) { return i; }
28	public boolean isConcurrent() { return false; }
29	public boolean permitsNulls() { return true; }
30	}
31	class SubListImplementation extends Implementation {
32	public List emptyCollection() {
33	return super.emptyCollection().subList(0, 0);
34	}
35	}
36	return newTestSuite(
37	VectorTest.class,
38	CollectionTest.testSuite(new Implementation()),
39	CollectionTest.testSuite(new SubListImplementation()));
40	}
41
42	static Vector<Integer> populatedList(int n) {
43	Vector<Integer> list = new Vector<>();
44	assertTrue(list.isEmpty());
45	for (int i = 0; i < n; i++)
46	list.add(i);
47	assertEquals(n <= 0, list.isEmpty());
48	assertEquals(n, list.size());
49	return list;
50	}
51
52	/**
53	* addAll adds each element from the given collection, including duplicates
54	*/
55	public void testAddAll() {
56	List list = populatedList(3);
57	assertTrue(list.addAll(Arrays.asList(three, four, five)));
58	assertEquals(6, list.size());
59	assertTrue(list.addAll(Arrays.asList(three, four, five)));
60	assertEquals(9, list.size());
61	}
62
63	/**
64	* clear removes all elements from the list
65	*/
66	public void testClear() {
67	List list = populatedList(SIZE);
68	list.clear();
69	assertEquals(0, list.size());
70	}
71
72	/**
73	* Cloned list is equal
74	*/
75	public void testClone() {
76	Vector l1 = populatedList(SIZE);
77	Vector l2 = (Vector)(l1.clone());
78	assertEquals(l1, l2);
79	l1.clear();
80	assertFalse(l1.equals(l2));
81	}
82
83	/**
84	* contains is true for added elements
85	*/
86	public void testContains() {
87	List list = populatedList(3);
88	assertTrue(list.contains(one));
89	assertFalse(list.contains(five));
90	}
91
92	/**
93	* adding at an index places it in the indicated index
94	*/
95	public void testAddIndex() {
96	List list = populatedList(3);
97	list.add(0, m1);
98	assertEquals(4, list.size());
99	assertEquals(m1, list.get(0));
100	assertEquals(zero, list.get(1));
101
102	list.add(2, m2);
103	assertEquals(5, list.size());
104	assertEquals(m2, list.get(2));
105	assertEquals(two, list.get(4));
106	}
107
108	/**
109	* lists with same elements are equal and have same hashCode
110	*/
111	public void testEquals() {
112	List a = populatedList(3);
113	List b = populatedList(3);
114	assertTrue(a.equals(b));
115	assertTrue(b.equals(a));
116	assertTrue(a.containsAll(b));
117	assertTrue(b.containsAll(a));
118	assertEquals(a.hashCode(), b.hashCode());
119	a.add(m1);
120	assertFalse(a.equals(b));
121	assertFalse(b.equals(a));
122	assertTrue(a.containsAll(b));
123	assertFalse(b.containsAll(a));
124	b.add(m1);
125	assertTrue(a.equals(b));
126	assertTrue(b.equals(a));
127	assertTrue(a.containsAll(b));
128	assertTrue(b.containsAll(a));
129	assertEquals(a.hashCode(), b.hashCode());
130
131	assertFalse(a.equals(null));
132	}
133
134	/**
135	* containsAll returns true for collections with subset of elements
136	*/
137	public void testContainsAll() {
138	List list = populatedList(3);
139	assertTrue(list.containsAll(Arrays.asList()));
140	assertTrue(list.containsAll(Arrays.asList(one)));
141	assertTrue(list.containsAll(Arrays.asList(one, two)));
142	assertFalse(list.containsAll(Arrays.asList(one, two, six)));
143	assertFalse(list.containsAll(Arrays.asList(six)));
144
145	try {
146	list.containsAll(null);
147	shouldThrow();
148	} catch (NullPointerException success) {}
149	}
150
151	/**
152	* get returns the value at the given index
153	*/
154	public void testGet() {
155	List list = populatedList(3);
156	assertEquals(0, list.get(0));
157	}
158
159	/**
160	* indexOf(Object) returns the index of the first occurrence of the
161	* specified element in this list, or -1 if this list does not
162	* contain the element
163	*/
164	public void testIndexOf() {
165	List list = populatedList(3);
166	assertEquals(-1, list.indexOf(-42));
167	int size = list.size();
168	for (int i = 0; i < size; i++) {
169	assertEquals(i, list.indexOf(i));
170	assertEquals(i, list.subList(0, size).indexOf(i));
171	assertEquals(i, list.subList(0, i + 1).indexOf(i));
172	assertEquals(-1, list.subList(0, i).indexOf(i));
173	assertEquals(0, list.subList(i, size).indexOf(i));
174	assertEquals(-1, list.subList(i + 1, size).indexOf(i));
175	}
176
177	list.add(1);
178	assertEquals(1, list.indexOf(1));
179	assertEquals(1, list.subList(0, size + 1).indexOf(1));
180	assertEquals(0, list.subList(1, size + 1).indexOf(1));
181	assertEquals(size - 2, list.subList(2, size + 1).indexOf(1));
182	assertEquals(0, list.subList(size, size + 1).indexOf(1));
183	assertEquals(-1, list.subList(size + 1, size + 1).indexOf(1));
184	}
185
186	/**
187	* indexOf(E, int) returns the index of the first occurrence of the
188	* specified element in this list, searching forwards from index,
189	* or returns -1 if the element is not found
190	*/
191	public void testIndexOf2() {
192	Vector list = populatedList(3);
193	int size = list.size();
194	assertEquals(-1, list.indexOf(-42, 0));
195
196	// we might expect IOOBE, but spec says otherwise
197	assertEquals(-1, list.indexOf(0, size));
198	assertEquals(-1, list.indexOf(0, Integer.MAX_VALUE));
199
200	assertThrows(
201	IndexOutOfBoundsException.class,
202	() -> list.indexOf(0, -1),
203	() -> list.indexOf(0, Integer.MIN_VALUE));
204
205	for (int i = 0; i < size; i++) {
206	assertEquals(i, list.indexOf(i, 0));
207	assertEquals(i, list.indexOf(i, i));
208	assertEquals(-1, list.indexOf(i, i + 1));
209	}
210
211	list.add(1);
212	assertEquals(1, list.indexOf(1, 0));
213	assertEquals(1, list.indexOf(1, 1));
214	assertEquals(size, list.indexOf(1, 2));
215	assertEquals(size, list.indexOf(1, size));
216	}
217
218	/**
219	* isEmpty returns true when empty, else false
220	*/
221	public void testIsEmpty() {
222	List empty = new Vector();
223	assertTrue(empty.isEmpty());
224	assertTrue(empty.subList(0, 0).isEmpty());
225
226	List full = populatedList(SIZE);
227	assertFalse(full.isEmpty());
228	assertTrue(full.subList(0, 0).isEmpty());
229	assertTrue(full.subList(SIZE, SIZE).isEmpty());
230	}
231
232	/**
233	* iterator of empty collection has no elements
234	*/
235	public void testEmptyIterator() {
236	Collection c = new Vector();
237	assertIteratorExhausted(c.iterator());
238	}
239
240	/**
241	* lastIndexOf(Object) returns the index of the last occurrence of
242	* the specified element in this list, or -1 if this list does not
243	* contain the element
244	*/
245	public void testLastIndexOf1() {
246	List list = populatedList(3);
247	assertEquals(-1, list.lastIndexOf(-42));
248	int size = list.size();
249	for (int i = 0; i < size; i++) {
250	assertEquals(i, list.lastIndexOf(i));
251	assertEquals(i, list.subList(0, size).lastIndexOf(i));
252	assertEquals(i, list.subList(0, i + 1).lastIndexOf(i));
253	assertEquals(-1, list.subList(0, i).lastIndexOf(i));
254	assertEquals(0, list.subList(i, size).lastIndexOf(i));
255	assertEquals(-1, list.subList(i + 1, size).lastIndexOf(i));
256	}
257
258	list.add(1);
259	assertEquals(size, list.lastIndexOf(1));
260	assertEquals(size, list.subList(0, size + 1).lastIndexOf(1));
261	assertEquals(1, list.subList(0, size).lastIndexOf(1));
262	assertEquals(0, list.subList(1, 2).lastIndexOf(1));
263	assertEquals(-1, list.subList(0, 1).indexOf(1));
264	}
265
266	/**
267	* lastIndexOf(E, int) returns the index of the last occurrence of the
268	* specified element in this list, searching backwards from index, or
269	* returns -1 if the element is not found
270	*/
271	public void testLastIndexOf2() {
272	Vector list = populatedList(3);
273
274	// we might expect IOOBE, but spec says otherwise
275	assertEquals(-1, list.lastIndexOf(0, -1));
276
277	int size = list.size();
278	assertThrows(
279	IndexOutOfBoundsException.class,
280	() -> list.lastIndexOf(0, size),
281	() -> list.lastIndexOf(0, Integer.MAX_VALUE));
282
283	for (int i = 0; i < size; i++) {
284	assertEquals(i, list.lastIndexOf(i, i));
285	assertEquals(list.indexOf(i), list.lastIndexOf(i, i));
286	if (i > 0)
287	assertEquals(-1, list.lastIndexOf(i, i - 1));
288	}
289	list.add(one);
290	list.add(three);
291	assertEquals(1, list.lastIndexOf(one, 1));
292	assertEquals(1, list.lastIndexOf(one, 2));
293	assertEquals(3, list.lastIndexOf(one, 3));
294	assertEquals(3, list.lastIndexOf(one, 4));
295	assertEquals(-1, list.lastIndexOf(three, 3));
296	}
297
298	/**
299	* size returns the number of elements
300	*/
301	public void testSize() {
302	List empty = new Vector();
303	assertEquals(0, empty.size());
304	assertEquals(0, empty.subList(0, 0).size());
305
306	List full = populatedList(SIZE);
307	assertEquals(SIZE, full.size());
308	assertEquals(0, full.subList(0, 0).size());
309	assertEquals(0, full.subList(SIZE, SIZE).size());
310	}
311
312	/**
313	* sublists contains elements at indexes offset from their base
314	*/
315	public void testSubList() {
316	List a = populatedList(10);
317	assertTrue(a.subList(1,1).isEmpty());
318	for (int j = 0; j < 9; ++j) {
319	for (int i = j ; i < 10; ++i) {
320	List b = a.subList(j,i);
321	for (int k = j; k < i; ++k) {
322	assertEquals(new Integer(k), b.get(k-j));
323	}
324	}
325	}
326
327	List s = a.subList(2, 5);
328	assertEquals(3, s.size());
329	s.set(2, m1);
330	assertEquals(a.get(4), m1);
331	s.clear();
332	assertEquals(7, a.size());
333
334	assertThrows(
335	IndexOutOfBoundsException.class,
336	() -> s.get(0),
337	() -> s.set(0, 42));
338	}
339
340	/**
341	* toArray throws an ArrayStoreException when the given array
342	* can not store the objects inside the list
343	*/
344	public void testToArray_ArrayStoreException() {
345	List list = new Vector();
346	// Integers are not auto-converted to Longs
347	list.add(86);
348	list.add(99);
349	assertThrows(
350	ArrayStoreException.class,
351	() -> list.toArray(new Long[0]),
352	() -> list.toArray(new Long[5]));
353	}
354
355	void testIndexOutOfBoundsException(List list) {
356	int size = list.size();
357	assertThrows(
358	IndexOutOfBoundsException.class,
359	() -> list.get(-1),
360	() -> list.get(size),
361	() -> list.set(-1, "qwerty"),
362	() -> list.set(size, "qwerty"),
363	() -> list.add(-1, "qwerty"),
364	() -> list.add(size + 1, "qwerty"),
365	() -> list.remove(-1),
366	() -> list.remove(size),
367	() -> list.addAll(-1, Collections.emptyList()),
368	() -> list.addAll(size + 1, Collections.emptyList()),
369	() -> list.listIterator(-1),
370	() -> list.listIterator(size + 1),
371	() -> list.subList(-1, size),
372	() -> list.subList(0, size + 1));
373
374	// Conversely, operations that must not throw
375	list.addAll(0, Collections.emptyList());
376	list.addAll(size, Collections.emptyList());
377	list.add(0, "qwerty");
378	list.add(list.size(), "qwerty");
379	list.get(0);
380	list.get(list.size() - 1);
381	list.set(0, "azerty");
382	list.set(list.size() - 1, "azerty");
383	list.listIterator(0);
384	list.listIterator(list.size());
385	list.subList(0, list.size());
386	list.remove(list.size() - 1);
387	}
388
389	/**
390	* IndexOutOfBoundsException is thrown when specified
391	*/
392	public void testIndexOutOfBoundsException() {
393	ThreadLocalRandom rnd = ThreadLocalRandom.current();
394	List x = populatedList(rnd.nextInt(5));
395	testIndexOutOfBoundsException(x);
396
397	int start = rnd.nextInt(x.size() + 1);
398	int end = rnd.nextInt(start, x.size() + 1);
399
400	// Vector#subList spec deviates slightly from List#subList spec
401	assertThrows(
402	IllegalArgumentException.class,
403	() -> x.subList(start, start - 1));
404
405	List subList = x.subList(start, end);
406	testIndexOutOfBoundsException(x);
407	}
408
409	/**
410	* a deserialized/reserialized list equals original
411	*/
412	public void testSerialization() throws Exception {
413	List x = populatedList(SIZE);
414	List y = serialClone(x);
415
416	assertNotSame(x, y);
417	assertEquals(x.size(), y.size());
418	assertEquals(x.toString(), y.toString());
419	assertTrue(Arrays.equals(x.toArray(), y.toArray()));
420	assertEquals(x, y);
421	assertEquals(y, x);
422	while (!x.isEmpty()) {
423	assertFalse(y.isEmpty());
424	assertEquals(x.remove(0), y.remove(0));
425	}
426	assertTrue(y.isEmpty());
427	}
428
429	/**
430	* tests for setSize()
431	*/
432	public void testSetSize() {
433	final Vector v = new Vector();
434	for (int n : new int[] { 100, 5, 50 }) {
435	v.setSize(n);
436	assertEquals(n, v.size());
437	assertNull(v.get(0));
438	assertNull(v.get(n - 1));
439	assertThrows(
440	ArrayIndexOutOfBoundsException.class,
441	new Runnable() { public void run() { v.setSize(-1); }});
442	assertEquals(n, v.size());
443	assertNull(v.get(0));
444	assertNull(v.get(n - 1));
445	}
446	}
447
448	}