ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/VectorTest.java

Comparing jsr166/src/test/tck/VectorTest.java (file contents):
Revision 1.1 by jsr166, Thu Nov 3 20:41:32 2016 UTC vs.
Revision 1.7 by jsr166, Tue Apr 3 00:59:22 2018 UTC

#	Line 5 | Line 5
5		* http://creativecommons.org/publicdomain/zero/1.0/
6		*/
7
8	<	import java.util.Vector;
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;
12	–	import junit.framework.TestSuite;
17
18		public class VectorTest extends JSR166TestCase {
19		public static void main(String[] args) {
#	Line 19 | Line 23 | public class VectorTest extends JSR166Te
23		public static Test suite() {
24		class Implementation implements CollectionImplementation {
25		public Class<?> klazz() { return Vector.class; }
26	<	public Collection emptyCollection() { return new Vector(); }
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	<	return newTestSuite(// VectorTest.class,
32	<	CollectionTest.testSuite(new Implementation()));
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		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines