ViewVC Help

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

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

Comparing jsr166/src/test/tck/CollectionTest.java (file contents):
Revision 1.4 by jsr166, Mon Oct 17 01:55:48 2016 UTC vs.
Revision 1.9 by jsr166, Mon Oct 24 22:45:50 2016 UTC

#	Line 5 | Line 5
5		* http://creativecommons.org/publicdomain/zero/1.0/
6		*/
7
8	+	import java.util.ArrayList;
9		import java.util.Collection;
10	+	import java.util.Collections;
11		import java.util.Deque;
12	+	import java.util.HashSet;
13	+	import java.util.Iterator;
14	+	import java.util.List;
15		import java.util.NoSuchElementException;
16		import java.util.Queue;
17	+	import java.util.Spliterator;
18	+	import java.util.concurrent.ThreadLocalRandom;
19	+	import java.util.concurrent.atomic.AtomicReference;
20		import java.util.function.Consumer;
21	+	import java.util.function.Predicate;
22
23		import junit.framework.Test;
24
#	Line 41 | Line 50 | public class CollectionTest extends JSR1
50		assertTrue(c.isEmpty());
51		assertEquals(0, c.size());
52		assertEquals("[]", c.toString());
53	<	assertEquals(0, c.toArray().length);
53	>	{
54	>	Object[] a = c.toArray();
55	>	assertEquals(0, a.length);
56	>	assertSame(Object[].class, a.getClass());
57	>	}
58		{
59		Object[] a = new Object[0];
60		assertSame(a, c.toArray(a));
61		}
62	+	{
63	+	Integer[] a = new Integer[0];
64	+	assertSame(a, c.toArray(a));
65	+	}
66	+	{
67	+	Integer[] a = { 1, 2, 3};
68	+	assertSame(a, c.toArray(a));
69	+	assertNull(a[0]);
70	+	assertSame(2, a[1]);
71	+	assertSame(3, a[2]);
72	+	}
73	+	assertIteratorExhausted(c.iterator());
74		Consumer alwaysThrows = (e) -> { throw new AssertionError(); };
75		c.forEach(alwaysThrows);
76		c.iterator().forEachRemaining(alwaysThrows);
#	Line 62 | Line 87 | public class CollectionTest extends JSR1
87		assertNull(d.peekLast());
88		assertNull(d.pollFirst());
89		assertNull(d.pollLast());
90	+	assertIteratorExhausted(d.descendingIterator());
91		}
92		}
93
#	Line 73 | Line 99 | public class CollectionTest extends JSR1
99		() -> c.containsAll(null),
100		() -> c.retainAll(null),
101		() -> c.removeAll(null),
102	<	() -> c.removeIf(null));
102	>	() -> c.removeIf(null),
103	>	() -> c.toArray(null));
104
105		if (!impl.permitsNulls()) {
106		assertThrows(
#	Line 121 | Line 148 | public class CollectionTest extends JSR1
148		() -> d.getLast(),
149		() -> d.removeFirst(),
150		() -> d.removeLast(),
151	<	() -> d.pop());
151	>	() -> d.pop(),
152	>	() -> d.descendingIterator().next());
153	>	}
154	>	}
155	>
156	>	public void testRemoveIf() {
157	>	Collection c = impl.emptyCollection();
158	>	ThreadLocalRandom rnd = ThreadLocalRandom.current();
159	>	int n = rnd.nextInt(6);
160	>	for (int i = 0; i < n; i++) c.add(impl.makeElement(i));
161	>	AtomicReference threwAt = new AtomicReference(null);
162	>	ArrayList survivors = new ArrayList(c);
163	>	ArrayList accepts = new ArrayList();
164	>	ArrayList rejects = new ArrayList();
165	>	Predicate randomPredicate = (e) -> {
166	>	assertNull(threwAt.get());
167	>	switch (rnd.nextInt(3)) {
168	>	case 0: accepts.add(e); return true;
169	>	case 1: rejects.add(e); return false;
170	>	case 2: threwAt.set(e); throw new ArithmeticException();
171	>	default: throw new AssertionError();
172	>	}
173	>	};
174	>	try {
175	>	boolean modified = c.removeIf(randomPredicate);
176	>	if (!modified) {
177	>	assertNull(threwAt.get());
178	>	assertEquals(n, rejects.size());
179	>	assertEquals(0, accepts.size());
180	>	}
181	>	} catch (ArithmeticException ok) {}
182	>	survivors.removeAll(accepts);
183	>	if (n - accepts.size() != c.size()) {
184	>	System.err.println(impl.klazz());
185	>	System.err.println(c);
186	>	System.err.println(accepts);
187	>	System.err.println(rejects);
188	>	System.err.println(survivors);
189	>	System.err.println(threwAt.get());
190	>	}
191	>	assertEquals(n - accepts.size(), c.size());
192	>	assertTrue(c.containsAll(survivors));
193	>	assertTrue(survivors.containsAll(rejects));
194	>	for (Object x : accepts) assertFalse(c.contains(x));
195	>	if (threwAt.get() == null)
196	>	assertEquals(accepts.size() + rejects.size(), n);
197	>	}
198	>
199	>	/**
200	>	* Various ways of traversing a collection yield same elements
201	>	*/
202	>	public void testIteratorEquivalence() {
203	>	Collection c = impl.emptyCollection();
204	>	ThreadLocalRandom rnd = ThreadLocalRandom.current();
205	>	int n = rnd.nextInt(6);
206	>	for (int i = 0; i < n; i++) c.add(impl.makeElement(i));
207	>	ArrayList iterated = new ArrayList();
208	>	ArrayList iteratedForEachRemaining = new ArrayList();
209	>	ArrayList spliterated = new ArrayList();
210	>	ArrayList foreached = new ArrayList();
211	>	for (Object x : c) iterated.add(x);
212	>	c.iterator().forEachRemaining(e -> iteratedForEachRemaining.add(e));
213	>	c.spliterator().forEachRemaining(e -> spliterated.add(e));
214	>	c.forEach(e -> foreached.add(e));
215	>	boolean ordered =
216	>	c.spliterator().hasCharacteristics(Spliterator.ORDERED);
217	>	if (c instanceof List || c instanceof Deque)
218	>	assertTrue(ordered);
219	>	if (ordered) {
220	>	assertEquals(iterated, iteratedForEachRemaining);
221	>	assertEquals(iterated, spliterated);
222	>	assertEquals(iterated, foreached);
223	>	} else {
224	>	HashSet cset = new HashSet(c);
225	>	assertEquals(cset, new HashSet(iterated));
226	>	assertEquals(cset, new HashSet(iteratedForEachRemaining));
227	>	assertEquals(cset, new HashSet(spliterated));
228	>	assertEquals(cset, new HashSet(foreached));
229	>	}
230	>	if (c instanceof Deque) {
231	>	Deque d = (Deque) c;
232	>	ArrayList descending = new ArrayList();
233	>	ArrayList descendingForEachRemaining = new ArrayList();
234	>	for (Iterator it = d.descendingIterator(); it.hasNext(); )
235	>	descending.add(it.next());
236	>	d.descendingIterator().forEachRemaining(
237	>	e -> descendingForEachRemaining.add(e));
238	>	Collections.reverse(descending);
239	>	Collections.reverse(descendingForEachRemaining);
240	>	assertEquals(iterated, descending);
241	>	assertEquals(iterated, descendingForEachRemaining);
242	>	}
243	>	}
244	>
245	>	/**
246	>	* Calling Iterator#remove() after Iterator#forEachRemaining
247	>	* should remove last element
248	>	*/
249	>	public void testRemoveAfterForEachRemaining() {
250	>	Collection c = impl.emptyCollection();
251	>	ThreadLocalRandom rnd = ThreadLocalRandom.current();
252	>	{
253	>	int n = 3 + rnd.nextInt(2);
254	>	for (int i = 0; i < n; i++) c.add(impl.makeElement(i));
255	>	Iterator it = c.iterator();
256	>	assertTrue(it.hasNext());
257	>	assertEquals(impl.makeElement(0), it.next());
258	>	assertTrue(it.hasNext());
259	>	assertEquals(impl.makeElement(1), it.next());
260	>	it.forEachRemaining((e) -> {});
261	>	it.remove();
262	>	assertEquals(n - 1, c.size());
263	>	for (int i = 0; i < n - 1; i++)
264	>	assertTrue(c.contains(impl.makeElement(i)));
265	>	assertFalse(c.contains(impl.makeElement(n - 1)));
266	>	}
267	>	if (c instanceof Deque) {
268	>	Deque d = (Deque) impl.emptyCollection();
269	>	int n = 3 + rnd.nextInt(2);
270	>	for (int i = 0; i < n; i++) d.add(impl.makeElement(i));
271	>	Iterator it = d.descendingIterator();
272	>	assertTrue(it.hasNext());
273	>	assertEquals(impl.makeElement(n - 1), it.next());
274	>	assertTrue(it.hasNext());
275	>	assertEquals(impl.makeElement(n - 2), it.next());
276	>	it.forEachRemaining((e) -> {});
277	>	it.remove();
278	>	assertEquals(n - 1, d.size());
279	>	for (int i = 1; i < n; i++)
280	>	assertTrue(d.contains(impl.makeElement(i)));
281	>	assertFalse(d.contains(impl.makeElement(0)));
282		}
283		}
284

Diff Legend

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