ViewVC Help

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

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

Comparing jsr166/src/test/tck/Collection8Test.java (file contents):
Revision 1.9 by jsr166, Thu Nov 3 16:53:13 2016 UTC vs.
Revision 1.21 by jsr166, Mon Nov 7 00:37:53 2016 UTC

#	Line 5 | Line 5
5		* http://creativecommons.org/publicdomain/zero/1.0/
6		*/
7
8	+	import static java.util.concurrent.TimeUnit.HOURS;
9		import static java.util.concurrent.TimeUnit.MILLISECONDS;
10
11		import java.util.ArrayList;
12	+	import java.util.Arrays;
13		import java.util.Collection;
14		import java.util.Collections;
15		import java.util.Deque;
#	Line 17 | Line 19 | import java.util.List;
19		import java.util.NoSuchElementException;
20		import java.util.Queue;
21		import java.util.Spliterator;
22	+	import java.util.concurrent.BlockingDeque;
23	+	import java.util.concurrent.BlockingQueue;
24		import java.util.concurrent.CountDownLatch;
25		import java.util.concurrent.Executors;
26		import java.util.concurrent.ExecutorService;
#	Line 49 | Line 53 | public class Collection8Test extends JSR
53		impl);
54		}
55
56	+	Object bomb() {
57	+	return new Object() {
58	+	public boolean equals(Object x) { throw new AssertionError(); }
59	+	public int hashCode() { throw new AssertionError(); }
60	+	};
61	+	}
62	+
63		/** Checks properties of empty collections. */
64	<	public void testEmptyMeansEmpty() {
64	>	public void testEmptyMeansEmpty() throws InterruptedException {
65		Collection c = impl.emptyCollection();
66	+	emptyMeansEmpty(c);
67	+
68	+	if (c instanceof java.io.Serializable)
69	+	emptyMeansEmpty(serialClone(c));
70	+
71	+	Collection clone = cloneableClone(c);
72	+	if (clone != null)
73	+	emptyMeansEmpty(clone);
74	+	}
75	+
76	+	void emptyMeansEmpty(Collection c) throws InterruptedException {
77		assertTrue(c.isEmpty());
78		assertEquals(0, c.size());
79		assertEquals("[]", c.toString());
#	Line 76 | Line 98 | public class Collection8Test extends JSR
98		assertSame(3, a[2]);
99		}
100		assertIteratorExhausted(c.iterator());
101	<	Consumer alwaysThrows = (e) -> { throw new AssertionError(); };
101	>	Consumer alwaysThrows = e -> { throw new AssertionError(); };
102		c.forEach(alwaysThrows);
103		c.iterator().forEachRemaining(alwaysThrows);
104		c.spliterator().forEachRemaining(alwaysThrows);
105		assertFalse(c.spliterator().tryAdvance(alwaysThrows));
106		if (c.spliterator().hasCharacteristics(Spliterator.SIZED))
107		assertEquals(0, c.spliterator().estimateSize());
108	<	if (Queue.class.isAssignableFrom(impl.klazz())) {
108	>	assertFalse(c.contains(bomb()));
109	>	assertFalse(c.remove(bomb()));
110	>	if (c instanceof Queue) {
111		Queue q = (Queue) c;
112		assertNull(q.peek());
113		assertNull(q.poll());
114		}
115	<	if (Deque.class.isAssignableFrom(impl.klazz())) {
115	>	if (c instanceof Deque) {
116		Deque d = (Deque) c;
117		assertNull(d.peekFirst());
118		assertNull(d.peekLast());
#	Line 96 | Line 120 | public class Collection8Test extends JSR
120		assertNull(d.pollLast());
121		assertIteratorExhausted(d.descendingIterator());
122		d.descendingIterator().forEachRemaining(alwaysThrows);
123	+	assertFalse(d.removeFirstOccurrence(bomb()));
124	+	assertFalse(d.removeLastOccurrence(bomb()));
125	+	}
126	+	if (c instanceof BlockingQueue) {
127	+	BlockingQueue q = (BlockingQueue) c;
128	+	assertNull(q.poll(0L, MILLISECONDS));
129	+	}
130	+	if (c instanceof BlockingDeque) {
131	+	BlockingDeque q = (BlockingDeque) c;
132	+	assertNull(q.pollFirst(0L, MILLISECONDS));
133	+	assertNull(q.pollLast(0L, MILLISECONDS));
134		}
135		}
136
137	<	public void testNullPointerExceptions() {
137	>	public void testNullPointerExceptions() throws InterruptedException {
138		Collection c = impl.emptyCollection();
139		assertThrows(
140		NullPointerException.class,
#	Line 119 | Line 154 | public class Collection8Test extends JSR
154		NullPointerException.class,
155		() -> c.add(null));
156		}
157	<	if (!impl.permitsNulls()
123	<	&& Queue.class.isAssignableFrom(impl.klazz())) {
157	>	if (!impl.permitsNulls() && c instanceof Queue) {
158		Queue q = (Queue) c;
159		assertThrows(
160		NullPointerException.class,
161		() -> q.offer(null));
162		}
163	<	if (!impl.permitsNulls()
130	<	&& Deque.class.isAssignableFrom(impl.klazz())) {
163	>	if (!impl.permitsNulls() && c instanceof Deque) {
164		Deque d = (Deque) c;
165		assertThrows(
166		NullPointerException.class,
#	Line 138 | Line 171 | public class Collection8Test extends JSR
171		() -> d.push(null),
172		() -> d.descendingIterator().forEachRemaining(null));
173		}
174	+	if (c instanceof BlockingQueue) {
175	+	BlockingQueue q = (BlockingQueue) c;
176	+	assertThrows(
177	+	NullPointerException.class,
178	+	() -> {
179	+	try { q.offer(null, 1L, HOURS); }
180	+	catch (InterruptedException ex) {
181	+	throw new AssertionError(ex);
182	+	}},
183	+	() -> {
184	+	try { q.put(null); }
185	+	catch (InterruptedException ex) {
186	+	throw new AssertionError(ex);
187	+	}});
188	+	}
189	+	if (c instanceof BlockingDeque) {
190	+	BlockingDeque q = (BlockingDeque) c;
191	+	assertThrows(
192	+	NullPointerException.class,
193	+	() -> {
194	+	try { q.offerFirst(null, 1L, HOURS); }
195	+	catch (InterruptedException ex) {
196	+	throw new AssertionError(ex);
197	+	}},
198	+	() -> {
199	+	try { q.offerLast(null, 1L, HOURS); }
200	+	catch (InterruptedException ex) {
201	+	throw new AssertionError(ex);
202	+	}},
203	+	() -> {
204	+	try { q.putFirst(null); }
205	+	catch (InterruptedException ex) {
206	+	throw new AssertionError(ex);
207	+	}},
208	+	() -> {
209	+	try { q.putLast(null); }
210	+	catch (InterruptedException ex) {
211	+	throw new AssertionError(ex);
212	+	}});
213	+	}
214		}
215
216		public void testNoSuchElementExceptions() {
#	Line 146 | Line 219 | public class Collection8Test extends JSR
219		NoSuchElementException.class,
220		() -> c.iterator().next());
221
222	<	if (Queue.class.isAssignableFrom(impl.klazz())) {
222	>	if (c instanceof Queue) {
223		Queue q = (Queue) c;
224		assertThrows(
225		NoSuchElementException.class,
226		() -> q.element(),
227		() -> q.remove());
228		}
229	<	if (Deque.class.isAssignableFrom(impl.klazz())) {
229	>	if (c instanceof Deque) {
230		Deque d = (Deque) c;
231		assertThrows(
232		NoSuchElementException.class,
#	Line 172 | Line 245 | public class Collection8Test extends JSR
245		int n = rnd.nextInt(6);
246		for (int i = 0; i < n; i++) c.add(impl.makeElement(i));
247		AtomicReference threwAt = new AtomicReference(null);
248	<	ArrayList survivors = new ArrayList(c);
248	>	List orig = rnd.nextBoolean()
249	>	? new ArrayList(c)
250	>	: Arrays.asList(c.toArray());
251	>
252	>	// Merely creating an iterator can change ArrayBlockingQueue behavior
253	>	Iterator it = rnd.nextBoolean() ? c.iterator() : null;
254	>
255	>	ArrayList survivors = new ArrayList();
256		ArrayList accepts = new ArrayList();
257		ArrayList rejects = new ArrayList();
258	<	Predicate randomPredicate = (e) -> {
258	>
259	>	Predicate randomPredicate = e -> {
260		assertNull(threwAt.get());
261		switch (rnd.nextInt(3)) {
262		case 0: accepts.add(e); return true;
#	Line 185 | Line 266 | public class Collection8Test extends JSR
266		}
267		};
268		try {
188	–	assertFalse(survivors.contains(null));
269		try {
270		boolean modified = c.removeIf(randomPredicate);
271	<	if (!modified) {
272	<	assertNull(threwAt.get());
273	<	assertEquals(n, rejects.size());
274	<	assertEquals(0, accepts.size());
275	<	}
276	<	} catch (ArithmeticException ok) {}
277	<	survivors.removeAll(accepts);
278	<	assertEquals(n - accepts.size(), c.size());
271	>	assertNull(threwAt.get());
272	>	assertEquals(modified, accepts.size() > 0);
273	>	assertEquals(modified, rejects.size() != n);
274	>	assertEquals(accepts.size() + rejects.size(), n);
275	>	assertEquals(rejects, Arrays.asList(c.toArray()));
276	>	} catch (ArithmeticException ok) {
277	>	assertNotNull(threwAt.get());
278	>	assertTrue(c.contains(threwAt.get()));
279	>	}
280	>	if (it != null && impl.isConcurrent())
281	>	// check for weakly consistent iterator
282	>	while (it.hasNext()) assertTrue(orig.contains(it.next()));
283	>	switch (rnd.nextInt(4)) {
284	>	case 0: survivors.addAll(c); break;
285	>	case 1: survivors.addAll(Arrays.asList(c.toArray())); break;
286	>	case 2: c.forEach(e -> survivors.add(e)); break;
287	>	case 3: for (Object e : c) survivors.add(e); break;
288	>	}
289	>	assertTrue(orig.containsAll(accepts));
290	>	assertTrue(orig.containsAll(rejects));
291	>	assertTrue(orig.containsAll(survivors));
292	>	assertTrue(orig.containsAll(c));
293	>	assertTrue(c.containsAll(rejects));
294		assertTrue(c.containsAll(survivors));
295		assertTrue(survivors.containsAll(rejects));
296	+	assertEquals(n - accepts.size(), c.size());
297		for (Object x : accepts) assertFalse(c.contains(x));
202	–	if (threwAt.get() == null)
203	–	assertEquals(accepts.size() + rejects.size(), n);
298		} catch (Throwable ex) {
299		System.err.println(impl.klazz());
300		System.err.printf("c=%s%n", c);
301		System.err.printf("n=%d%n", n);
302	+	System.err.printf("orig=%s%n", orig);
303		System.err.printf("accepts=%s%n", accepts);
304		System.err.printf("rejects=%s%n", rejects);
305		System.err.printf("survivors=%s%n", survivors);
306	<	System.err.printf("threw=%s%n", threwAt.get());
306	>	System.err.printf("threwAt=%s%n", threwAt.get());
307		throw ex;
308		}
309		}
#	Line 223 | Line 318 | public class Collection8Test extends JSR
318		for (int i = 0; i < n; i++) c.add(impl.makeElement(i));
319		ArrayList iterated = new ArrayList();
320		ArrayList iteratedForEachRemaining = new ArrayList();
321	+	ArrayList tryAdvanced = new ArrayList();
322		ArrayList spliterated = new ArrayList();
323	<	ArrayList foreached = new ArrayList();
323	>	ArrayList forEached = new ArrayList();
324	>	ArrayList removeIfed = new ArrayList();
325		for (Object x : c) iterated.add(x);
326		c.iterator().forEachRemaining(e -> iteratedForEachRemaining.add(e));
327	+	for (Spliterator s = c.spliterator();
328	+	s.tryAdvance(e -> tryAdvanced.add(e)); ) {}
329		c.spliterator().forEachRemaining(e -> spliterated.add(e));
330	<	c.forEach(e -> foreached.add(e));
330	>	c.forEach(e -> forEached.add(e));
331	>	c.removeIf(e -> { removeIfed.add(e); return false; });
332		boolean ordered =
333		c.spliterator().hasCharacteristics(Spliterator.ORDERED);
334		if (c instanceof List || c instanceof Deque)
335		assertTrue(ordered);
336		if (ordered) {
337		assertEquals(iterated, iteratedForEachRemaining);
338	+	assertEquals(iterated, tryAdvanced);
339		assertEquals(iterated, spliterated);
340	<	assertEquals(iterated, foreached);
340	>	assertEquals(iterated, forEached);
341	>	assertEquals(iterated, removeIfed);
342		} else {
343		HashSet cset = new HashSet(c);
344		assertEquals(cset, new HashSet(iterated));
345		assertEquals(cset, new HashSet(iteratedForEachRemaining));
346	+	assertEquals(cset, new HashSet(tryAdvanced));
347		assertEquals(cset, new HashSet(spliterated));
348	<	assertEquals(cset, new HashSet(foreached));
348	>	assertEquals(cset, new HashSet(forEached));
349	>	assertEquals(cset, new HashSet(removeIfed));
350		}
351		if (c instanceof Deque) {
352		Deque d = (Deque) c;
#	Line 261 | Line 365 | public class Collection8Test extends JSR
365
366		/**
367		* Calling Iterator#remove() after Iterator#forEachRemaining
368	<	* should remove last element
368	>	* should (maybe) remove last element
369		*/
370		public void testRemoveAfterForEachRemaining() {
371		Collection c = impl.emptyCollection();
#	Line 274 | Line 378 | public class Collection8Test extends JSR
378		assertEquals(impl.makeElement(0), it.next());
379		assertTrue(it.hasNext());
380		assertEquals(impl.makeElement(1), it.next());
381	<	it.forEachRemaining((e) -> {});
382	<	it.remove();
383	<	assertEquals(n - 1, c.size());
384	<	for (int i = 0; i < n - 1; i++)
385	<	assertTrue(c.contains(impl.makeElement(i)));
386	<	assertFalse(c.contains(impl.makeElement(n - 1)));
381	>	it.forEachRemaining(e -> assertTrue(c.contains(e)));
382	>	if (testImplementationDetails) {
383	>	if (c instanceof java.util.concurrent.ArrayBlockingQueue) {
384	>	assertIteratorExhausted(it);
385	>	} else {
386	>	it.remove();
387	>	assertEquals(n - 1, c.size());
388	>	for (int i = 0; i < n - 1; i++)
389	>	assertTrue(c.contains(impl.makeElement(i)));
390	>	assertFalse(c.contains(impl.makeElement(n - 1)));
391	>	}
392	>	}
393		}
394		if (c instanceof Deque) {
395		Deque d = (Deque) impl.emptyCollection();
#	Line 290 | Line 400 | public class Collection8Test extends JSR
400		assertEquals(impl.makeElement(n - 1), it.next());
401		assertTrue(it.hasNext());
402		assertEquals(impl.makeElement(n - 2), it.next());
403	<	it.forEachRemaining((e) -> {});
404	<	it.remove();
405	<	assertEquals(n - 1, d.size());
406	<	for (int i = 1; i < n; i++)
407	<	assertTrue(d.contains(impl.makeElement(i)));
408	<	assertFalse(d.contains(impl.makeElement(0)));
403	>	it.forEachRemaining(e -> assertTrue(c.contains(e)));
404	>	if (testImplementationDetails) {
405	>	it.remove();
406	>	assertEquals(n - 1, d.size());
407	>	for (int i = 1; i < n; i++)
408	>	assertTrue(d.contains(impl.makeElement(i)));
409	>	assertFalse(d.contains(impl.makeElement(0)));
410	>	}
411		}
412		}
413
#	Line 308 | Line 420 | public class Collection8Test extends JSR
420		final Object x = impl.makeElement(1);
421		final Object y = impl.makeElement(2);
422		final ArrayList found = new ArrayList();
423	<	Consumer<Object> spy = (o) -> { found.add(o); };
423	>	Consumer<Object> spy = o -> found.add(o);
424		c.stream().forEach(spy);
425		assertTrue(found.isEmpty());
426
#	Line 342 | Line 454 | public class Collection8Test extends JSR
454		Runnable checkElt = () -> {
455		threadsStarted.countDown();
456		while (!done.get())
457	<	c.stream().forEach((x) -> { assertSame(x, elt); }); };
457	>	c.stream().forEach(x -> assertSame(x, elt)); };
458		Runnable addRemove = () -> {
459		threadsStarted.countDown();
460		while (!done.get()) {
#	Line 366 | Line 478 | public class Collection8Test extends JSR
478		final Object x = impl.makeElement(1);
479		final Object y = impl.makeElement(2);
480		final ArrayList found = new ArrayList();
481	<	Consumer<Object> spy = (o) -> { found.add(o); };
481	>	Consumer<Object> spy = o -> found.add(o);
482		c.forEach(spy);
483		assertTrue(found.isEmpty());
484
#	Line 400 | Line 512 | public class Collection8Test extends JSR
512		Runnable checkElt = () -> {
513		threadsStarted.countDown();
514		while (!done.get())
515	<	c.forEach((x) -> { assertSame(x, elt); }); };
515	>	c.forEach(x -> assertSame(x, elt)); };
516		Runnable addRemove = () -> {
517		threadsStarted.countDown();
518		while (!done.get()) {

Diff Legend

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