ViewVC Help

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

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

Comparing jsr166/src/test/tck/BlockingQueueTest.java (file contents):
Revision 1.7 by jsr166, Fri May 27 19:32:04 2011 UTC vs.
Revision 1.25 by dl, Tue Jan 26 13:33:05 2021 UTC

#	Line 7 | Line 7
7		* Pat Fisher, Mike Judd.
8		*/
9
10	–	import junit.framework.*;
11	–	import java.util.*;
12	–	import java.util.concurrent.*;
10		import static java.util.concurrent.TimeUnit.MILLISECONDS;
11
12	+	import java.util.ArrayList;
13	+	import java.util.Arrays;
14	+	import java.util.Collection;
15	+	import java.util.Queue;
16	+	import java.util.concurrent.BlockingQueue;
17	+	import java.util.concurrent.CountDownLatch;
18	+
19	+	import junit.framework.Test;
20	+	import junit.framework.TestSuite;
21	+
22		/**
23	<	* Contains tests generally applicable to BlockingQueue implementations.
23	>	* Contains "contract" tests applicable to all BlockingQueue implementations.
24		*/
25		public abstract class BlockingQueueTest extends JSR166TestCase {
26		/*
#	Line 33 | Line 40 | public abstract class BlockingQueueTest
40		return new TestSuite(this.getClass());
41		}
42
43	+	//----------------------------------------------------------------
44	+	// Configuration methods
45	+	//----------------------------------------------------------------
46	+
47		/** Returns an empty instance of the implementation class. */
48		protected abstract BlockingQueue emptyCollection();
49
50		/**
51	+	* Returns an element suitable for insertion in the collection.
52	+	* Override for collections with unusual element types.
53	+	*/
54	+	protected Object makeElement(int i) {
55	+	return JSR166TestCase.itemFor(i);
56	+	}
57	+
58	+	//----------------------------------------------------------------
59	+	// Tests
60	+	//----------------------------------------------------------------
61	+
62	+	/**
63	+	* offer(null) throws NullPointerException
64	+	*/
65	+	public void testOfferNull() {
66	+	final Queue q = emptyCollection();
67	+	try {
68	+	q.offer(null);
69	+	shouldThrow();
70	+	} catch (NullPointerException success) {}
71	+	}
72	+
73	+	/**
74	+	* add(null) throws NullPointerException
75	+	*/
76	+	public void testAddNull() {
77	+	final Collection q = emptyCollection();
78	+	try {
79	+	q.add(null);
80	+	shouldThrow();
81	+	} catch (NullPointerException success) {}
82	+	}
83	+
84	+	/**
85	+	* timed offer(null) throws NullPointerException
86	+	*/
87	+	public void testTimedOfferNull() throws InterruptedException {
88	+	final BlockingQueue q = emptyCollection();
89	+	long startTime = System.nanoTime();
90	+	try {
91	+	q.offer(null, LONG_DELAY_MS, MILLISECONDS);
92	+	shouldThrow();
93	+	} catch (NullPointerException success) {}
94	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
95	+	}
96	+
97	+	/**
98	+	* put(null) throws NullPointerException
99	+	*/
100	+	public void testPutNull() throws InterruptedException {
101	+	final BlockingQueue q = emptyCollection();
102	+	try {
103	+	q.put(null);
104	+	shouldThrow();
105	+	} catch (NullPointerException success) {}
106	+	}
107	+
108	+	/**
109	+	* addAll(null) throws NullPointerException
110	+	*/
111	+	public void testAddAllNull() throws InterruptedException {
112	+	final Collection q = emptyCollection();
113	+	try {
114	+	q.addAll(null);
115	+	shouldThrow();
116	+	} catch (NullPointerException success) {}
117	+	}
118	+
119	+	/**
120	+	* addAll of a collection with null elements throws NullPointerException
121	+	*/
122	+	public void testAddAllNullElements() {
123	+	final Collection q = emptyCollection();
124	+	final Collection elements = Arrays.asList(new Item[SIZE]);
125	+	try {
126	+	q.addAll(elements);
127	+	shouldThrow();
128	+	} catch (NullPointerException success) {}
129	+	}
130	+
131	+	/**
132	+	* toArray(null) throws NullPointerException
133	+	*/
134	+	public void testToArray_NullArray() {
135	+	final Collection q = emptyCollection();
136	+	try {
137	+	q.toArray((Object[])null);
138	+	shouldThrow();
139	+	} catch (NullPointerException success) {}
140	+	}
141	+
142	+	/**
143	+	* drainTo(null) throws NullPointerException
144	+	*/
145	+	public void testDrainToNull() {
146	+	final BlockingQueue q = emptyCollection();
147	+	try {
148	+	q.drainTo(null);
149	+	shouldThrow();
150	+	} catch (NullPointerException success) {}
151	+	}
152	+
153	+	/**
154	+	* drainTo(this) throws IllegalArgumentException
155	+	*/
156	+	public void testDrainToSelf() {
157	+	final BlockingQueue q = emptyCollection();
158	+	try {
159	+	q.drainTo(q);
160	+	shouldThrow();
161	+	} catch (IllegalArgumentException success) {}
162	+	}
163	+
164	+	/**
165	+	* drainTo(null, n) throws NullPointerException
166	+	*/
167	+	public void testDrainToNullN() {
168	+	final BlockingQueue q = emptyCollection();
169	+	try {
170	+	q.drainTo(null, 0);
171	+	shouldThrow();
172	+	} catch (NullPointerException success) {}
173	+	}
174	+
175	+	/**
176	+	* drainTo(this, n) throws IllegalArgumentException
177	+	*/
178	+	public void testDrainToSelfN() {
179	+	final BlockingQueue q = emptyCollection();
180	+	try {
181	+	q.drainTo(q, 0);
182	+	shouldThrow();
183	+	} catch (IllegalArgumentException success) {}
184	+	}
185	+
186	+	/**
187	+	* drainTo(c, n) returns 0 and does nothing when n <= 0
188	+	*/
189	+	public void testDrainToNonPositiveMaxElements() {
190	+	final BlockingQueue q = emptyCollection();
191	+	final int[] ns = { 0, -1, -42, Integer.MIN_VALUE };
192	+	final ArrayList sink = new ArrayList();
193	+	for (int n : ns) {
194	+	assertEquals(0, q.drainTo(sink, n));
195	+	assertTrue(sink.isEmpty());
196	+	}
197	+	if (q.remainingCapacity() > 0) {
198	+	// Not SynchronousQueue, that is
199	+	Object e = makeElement(1);
200	+	if (q.add(e)) {
201	+	for (int n : ns)
202	+	assertEquals(0, q.drainTo(sink, n));
203	+	assertEquals(1, q.size());
204	+	assertEquals(e, q.poll());
205	+	assertTrue(sink.isEmpty());
206	+	}
207	+	}
208	+	}
209	+
210	+	/**
211		* timed poll before a delayed offer times out; after offer succeeds;
212		* on interruption throws
213		*/
214		public void testTimedPollWithOffer() throws InterruptedException {
215		final BlockingQueue q = emptyCollection();
216		final CheckedBarrier barrier = new CheckedBarrier(2);
217	+	final Object zero = makeElement(0);
218		Thread t = newStartedThread(new CheckedRunnable() {
219		public void realRun() throws InterruptedException {
220		long startTime = System.nanoTime();
#	Line 55 | Line 227 | public abstract class BlockingQueueTest
227
228		Thread.currentThread().interrupt();
229		try {
230	<	q.poll(LONG_DELAY_MS, MILLISECONDS);
230	>	q.poll(randomTimeout(), randomTimeUnit());
231		shouldThrow();
232		} catch (InterruptedException success) {}
233		assertFalse(Thread.interrupted());
#	Line 66 | Line 238 | public abstract class BlockingQueueTest
238		shouldThrow();
239		} catch (InterruptedException success) {}
240		assertFalse(Thread.interrupted());
241	+
242	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
243		}});
244
245		barrier.await();
#	Line 74 | Line 248 | public abstract class BlockingQueueTest
248		assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
249
250		barrier.await();
251	<	assertThreadStaysAlive(t);
251	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
252		t.interrupt();
253		awaitTermination(t);
254		}
#	Line 96 | Line 270 | public abstract class BlockingQueueTest
270		}});
271
272		await(threadStarted);
273	<	assertThreadStaysAlive(t);
273	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
274		t.interrupt();
275		awaitTermination(t);
276		}
#	Line 125 | Line 299 | public abstract class BlockingQueueTest
299		*/
300		public void testTimedPollFromEmptyBlocksInterruptibly() {
301		final BlockingQueue q = emptyCollection();
302	<	final CountDownLatch threadStarted = new CountDownLatch(1);
302	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
303		Thread t = newStartedThread(new CheckedRunnable() {
304		public void realRun() {
305	<	threadStarted.countDown();
305	>	pleaseInterrupt.countDown();
306		try {
307	<	q.poll(2 * LONG_DELAY_MS, MILLISECONDS);
307	>	q.poll(LONGER_DELAY_MS, MILLISECONDS);
308		shouldThrow();
309		} catch (InterruptedException success) {}
310		assertFalse(Thread.interrupted());
311		}});
312
313	<	await(threadStarted);
314	<	assertThreadStaysAlive(t);
313	>	await(pleaseInterrupt);
314	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
315		t.interrupt();
316		awaitTermination(t);
317		}
#	Line 152 | Line 326 | public abstract class BlockingQueueTest
326		public void realRun() {
327		Thread.currentThread().interrupt();
328		try {
329	<	q.poll(2 * LONG_DELAY_MS, MILLISECONDS);
329	>	q.poll(LONGER_DELAY_MS, MILLISECONDS);
330		shouldThrow();
331		} catch (InterruptedException success) {}
332		assertFalse(Thread.interrupted());
#	Line 161 | Line 335 | public abstract class BlockingQueueTest
335		awaitTermination(t);
336		}
337
338	+	/**
339	+	* remove(x) removes x and returns true if present
340	+	* TODO: move to superclass CollectionTest.java
341	+	*/
342	+	public void testRemoveElement() {
343	+	final BlockingQueue q = emptyCollection();
344	+	final int size = Math.min(q.remainingCapacity(), SIZE);
345	+	final Object[] elts = new Object[size];
346	+	assertFalse(q.contains(makeElement(99)));
347	+	assertFalse(q.remove(makeElement(99)));
348	+	checkEmpty(q);
349	+	for (int i = 0; i < size; i++)
350	+	q.add(elts[i] = makeElement(i));
351	+	for (int i = 1; i < size; i += 2) {
352	+	for (int pass = 0; pass < 2; pass++) {
353	+	mustEqual((pass == 0), q.contains(elts[i]));
354	+	mustEqual((pass == 0), q.remove(elts[i]));
355	+	assertFalse(q.contains(elts[i]));
356	+	assertTrue(q.contains(elts[i - 1]));
357	+	if (i < size - 1)
358	+	assertTrue(q.contains(elts[i + 1]));
359	+	}
360	+	}
361	+	if (size > 0)
362	+	assertTrue(q.contains(elts[0]));
363	+	for (int i = size - 2; i >= 0; i -= 2) {
364	+	assertTrue(q.contains(elts[i]));
365	+	assertFalse(q.contains(elts[i + 1]));
366	+	assertTrue(q.remove(elts[i]));
367	+	assertFalse(q.contains(elts[i]));
368	+	assertFalse(q.remove(elts[i + 1]));
369	+	assertFalse(q.contains(elts[i + 1]));
370	+	}
371	+	checkEmpty(q);
372	+	}
373	+
374		/** For debugging. */
375		public void XXXXtestFails() {
376		fail(emptyCollection().getClass().toString());

Diff Legend

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