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.11 by dl, Tue Jan 26 13:33:06 2021 UTC

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

Diff Legend

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