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.6 by dl, Fri May 6 11:22:07 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	<	* timed poll before a delayed offer fails; after offer succeeds;
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	<	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
220	>	long startTime = System.nanoTime();
221	>	assertNull(q.poll(timeoutMillis(), MILLISECONDS));
222	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
223
224		barrier.await();
225	<	assertSame(zero, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
225	>
226	>	assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
227
228		Thread.currentThread().interrupt();
229		try {
230	<	q.poll(SHORT_DELAY_MS, MILLISECONDS);
230	>	q.poll(randomTimeout(), randomTimeUnit());
231		shouldThrow();
232		} catch (InterruptedException success) {}
233	+	assertFalse(Thread.interrupted());
234
235		barrier.await();
236		try {
237	<	q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
237	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
238		shouldThrow();
239		} catch (InterruptedException success) {}
240	+	assertFalse(Thread.interrupted());
241	+
242	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
243		}});
244
245		barrier.await();
246	<	assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
246	>	long startTime = System.nanoTime();
247	>	assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS));
248	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
249	>
250		barrier.await();
251	<	sleep(SHORT_DELAY_MS);
251	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
252		t.interrupt();
253	<	awaitTermination(t, MEDIUM_DELAY_MS);
253	>	awaitTermination(t);
254		}
255
256		/**
257		* take() blocks interruptibly when empty
258		*/
259	<	public void testTakeFromEmptyBlocksInterruptibly()
78	<	throws InterruptedException {
259	>	public void testTakeFromEmptyBlocksInterruptibly() {
260		final BlockingQueue q = emptyCollection();
261		final CountDownLatch threadStarted = new CountDownLatch(1);
262		Thread t = newStartedThread(new CheckedRunnable() {
263		public void realRun() {
83	–	long t0 = System.nanoTime();
264		threadStarted.countDown();
265		try {
266		q.take();
267		shouldThrow();
268		} catch (InterruptedException success) {}
269	<	assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
269	>	assertFalse(Thread.interrupted());
270		}});
271
272	<	threadStarted.await();
273	<	delay(SHORT_DELAY_MS);
94	<	assertTrue(t.isAlive());
272	>	await(threadStarted);
273	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
274		t.interrupt();
275	<	awaitTermination(t, MEDIUM_DELAY_MS);
275	>	awaitTermination(t);
276		}
277
278		/**
279		* take() throws InterruptedException immediately if interrupted
280		* before waiting
281		*/
282	<	public void testTakeFromEmptyAfterInterrupt()
104	<	throws InterruptedException {
282	>	public void testTakeFromEmptyAfterInterrupt() {
283		final BlockingQueue q = emptyCollection();
284		Thread t = newStartedThread(new CheckedRunnable() {
285		public void realRun() {
108	–	long t0 = System.nanoTime();
286		Thread.currentThread().interrupt();
287		try {
288		q.take();
289		shouldThrow();
290		} catch (InterruptedException success) {}
291	<	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
291	>	assertFalse(Thread.interrupted());
292	>	}});
293	>
294	>	awaitTermination(t);
295	>	}
296	>
297	>	/**
298	>	* timed poll() blocks interruptibly when empty
299	>	*/
300	>	public void testTimedPollFromEmptyBlocksInterruptibly() {
301	>	final BlockingQueue q = emptyCollection();
302	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
303	>	Thread t = newStartedThread(new CheckedRunnable() {
304	>	public void realRun() {
305	>	pleaseInterrupt.countDown();
306	>	try {
307	>	q.poll(LONGER_DELAY_MS, MILLISECONDS);
308	>	shouldThrow();
309	>	} catch (InterruptedException success) {}
310	>	assertFalse(Thread.interrupted());
311	>	}});
312	>
313	>	await(pleaseInterrupt);
314	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
315	>	t.interrupt();
316	>	awaitTermination(t);
317	>	}
318	>
319	>	/**
320	>	* timed poll() throws InterruptedException immediately if
321	>	* interrupted before waiting
322	>	*/
323	>	public void testTimedPollFromEmptyAfterInterrupt() {
324	>	final BlockingQueue q = emptyCollection();
325	>	Thread t = newStartedThread(new CheckedRunnable() {
326	>	public void realRun() {
327	>	Thread.currentThread().interrupt();
328	>	try {
329	>	q.poll(LONGER_DELAY_MS, MILLISECONDS);
330	>	shouldThrow();
331	>	} catch (InterruptedException success) {}
332	>	assertFalse(Thread.interrupted());
333		}});
334
335	<	awaitTermination(t, MEDIUM_DELAY_MS);
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. */

Diff Legend

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