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