ViewVC Help

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

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

Comparing jsr166/src/test/tck/SynchronousQueueTest.java (file contents):
Revision 1.11 by jsr166, Mon Nov 16 04:57:10 2009 UTC vs.
Revision 1.36 by jsr166, Sat May 28 13:40:20 2011 UTC

#	Line 1 | Line 1
1		/*
2		* Written by Doug Lea with assistance from members of JCP JSR-166
3		* Expert Group and released to the public domain, as explained at
4	<	* http://creativecommons.org/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		* Other contributors include Andrew Wright, Jeffrey Hayes,
6		* Pat Fisher, Mike Judd.
7		*/
#	Line 9 | Line 9
9		import junit.framework.*;
10		import java.util.*;
11		import java.util.concurrent.*;
12	+	import static java.util.concurrent.TimeUnit.MILLISECONDS;
13		import java.io.*;
14
15		public class SynchronousQueueTest extends JSR166TestCase {
16
17	<	public static void main(String[] args) {
18	<	junit.textui.TestRunner.run (suite());
17	>	public static class Fair extends BlockingQueueTest {
18	>	protected BlockingQueue emptyCollection() {
19	>	return new SynchronousQueue(true);
20	>	}
21		}
22
23	<	public static Test suite() {
24	<	return new TestSuite(SynchronousQueueTest.class);
23	>	public static class NonFair extends BlockingQueueTest {
24	>	protected BlockingQueue emptyCollection() {
25	>	return new SynchronousQueue(false);
26	>	}
27		}
28
29	<	/**
30	<	* A SynchronousQueue is both empty and full
31	<	*/
32	<	public void testEmptyFull() {
33	<	SynchronousQueue q = new SynchronousQueue();
34	<	assertTrue(q.isEmpty());
35	<	assertEquals(0, q.size());
36	<	assertEquals(0, q.remainingCapacity());
32	<	assertFalse(q.offer(zero));
29	>	public static void main(String[] args) {
30	>	junit.textui.TestRunner.run(suite());
31	>	}
32	>
33	>	public static Test suite() {
34	>	return newTestSuite(SynchronousQueueTest.class,
35	>	new Fair().testSuite(),
36	>	new NonFair().testSuite());
37		}
38
39		/**
40	<	* A fair SynchronousQueue is both empty and full
40	>	* Any SynchronousQueue is both empty and full
41		*/
42	<	public void testFairEmptyFull() {
43	<	SynchronousQueue q = new SynchronousQueue(true);
42	>	public void testEmptyFull()      { testEmptyFull(false); }
43	>	public void testEmptyFull_fair() { testEmptyFull(true); }
44	>	public void testEmptyFull(boolean fair) {
45	>	final SynchronousQueue q = new SynchronousQueue(fair);
46		assertTrue(q.isEmpty());
47	<	assertEquals(0, q.size());
47	>	assertEquals(0, q.size());
48		assertEquals(0, q.remainingCapacity());
49		assertFalse(q.offer(zero));
50		}
51
52		/**
53	<	* offer(null) throws NPE
53	>	* offer(null) throws NullPointerException
54		*/
55	<	public void testOfferNull() {
56	<	try {
57	<	SynchronousQueue q = new SynchronousQueue();
55	>	public void testOfferNull()      { testOfferNull(false); }
56	>	public void testOfferNull_fair() { testOfferNull(true); }
57	>	public void testOfferNull(boolean fair) {
58	>	SynchronousQueue q = new SynchronousQueue(fair);
59	>	try {
60		q.offer(null);
61		shouldThrow();
62	<	} catch (NullPointerException success) { }
62	>	} catch (NullPointerException success) {}
63		}
64
65		/**
66	<	* add(null) throws NPE
66	>	* add(null) throws NullPointerException
67		*/
68	<	public void testAddNull() {
69	<	try {
70	<	SynchronousQueue q = new SynchronousQueue();
68	>	public void testAddNull()      { testAddNull(false); }
69	>	public void testAddNull_fair() { testAddNull(true); }
70	>	public void testAddNull(boolean fair) {
71	>	SynchronousQueue q = new SynchronousQueue(fair);
72	>	try {
73		q.add(null);
74		shouldThrow();
75	<	} catch (NullPointerException success) { }
75	>	} catch (NullPointerException success) {}
76		}
77
78		/**
79		* offer fails if no active taker
80		*/
81	<	public void testOffer() {
82	<	SynchronousQueue q = new SynchronousQueue();
81	>	public void testOffer()      { testOffer(false); }
82	>	public void testOffer_fair() { testOffer(true); }
83	>	public void testOffer(boolean fair) {
84	>	SynchronousQueue q = new SynchronousQueue(fair);
85		assertFalse(q.offer(one));
86		}
87
88		/**
89	<	* add throws ISE if no active taker
89	>	* add throws IllegalStateException if no active taker
90		*/
91	<	public void testAdd() {
92	<	try {
93	<	SynchronousQueue q = new SynchronousQueue();
94	<	assertEquals(0, q.remainingCapacity());
91	>	public void testAdd()      { testAdd(false); }
92	>	public void testAdd_fair() { testAdd(true); }
93	>	public void testAdd(boolean fair) {
94	>	SynchronousQueue q = new SynchronousQueue(fair);
95	>	assertEquals(0, q.remainingCapacity());
96	>	try {
97		q.add(one);
98		shouldThrow();
99	<	} catch (IllegalStateException success){
86	<	}
99	>	} catch (IllegalStateException success) {}
100		}
101
102		/**
103	<	* addAll(null) throws NPE
103	>	* addAll(null) throws NullPointerException
104		*/
105	<	public void testAddAll1() {
105	>	public void testAddAll_null()      { testAddAll_null(false); }
106	>	public void testAddAll_null_fair() { testAddAll_null(true); }
107	>	public void testAddAll_null(boolean fair) {
108	>	SynchronousQueue q = new SynchronousQueue(fair);
109		try {
94	–	SynchronousQueue q = new SynchronousQueue();
110		q.addAll(null);
111		shouldThrow();
112	<	}
98	<	catch (NullPointerException success) {}
112	>	} catch (NullPointerException success) {}
113		}
114
115		/**
116	<	* addAll(this) throws IAE
116	>	* addAll(this) throws IllegalArgumentException
117		*/
118	<	public void testAddAllSelf() {
118	>	public void testAddAll_self()      { testAddAll_self(false); }
119	>	public void testAddAll_self_fair() { testAddAll_self(true); }
120	>	public void testAddAll_self(boolean fair) {
121	>	SynchronousQueue q = new SynchronousQueue(fair);
122		try {
106	–	SynchronousQueue q = new SynchronousQueue();
123		q.addAll(q);
124		shouldThrow();
125	<	}
110	<	catch (IllegalArgumentException success) {}
125	>	} catch (IllegalArgumentException success) {}
126		}
127
128		/**
129	<	* addAll of a collection with null elements throws NPE
129	>	* addAll of a collection with null elements throws NullPointerException
130		*/
131	<	public void testAddAll2() {
131	>	public void testAddAll_null2()      { testAddAll_null2(false); }
132	>	public void testAddAll_null2_fair() { testAddAll_null2(true); }
133	>	public void testAddAll_null2(boolean fair) {
134	>	SynchronousQueue q = new SynchronousQueue(fair);
135	>	Collection<Integer> ints = Arrays.asList(new Integer[1]);
136		try {
137	<	SynchronousQueue q = new SynchronousQueue();
119	<	Integer[] ints = new Integer[1];
120	<	q.addAll(Arrays.asList(ints));
137	>	q.addAll(ints);
138		shouldThrow();
139	<	}
123	<	catch (NullPointerException success) {}
139	>	} catch (NullPointerException success) {}
140		}
141	+
142		/**
143		* addAll throws ISE if no active taker
144		*/
145	<	public void testAddAll4() {
145	>	public void testAddAll_ISE()      { testAddAll_ISE(false); }
146	>	public void testAddAll_ISE_fair() { testAddAll_ISE(true); }
147	>	public void testAddAll_ISE(boolean fair) {
148	>	SynchronousQueue q = new SynchronousQueue(fair);
149	>	Integer[] ints = new Integer[1];
150	>	for (int i = 0; i < ints.length; i++)
151	>	ints[i] = i;
152	>	Collection<Integer> coll = Arrays.asList(ints);
153		try {
154	<	SynchronousQueue q = new SynchronousQueue();
131	<	Integer[] ints = new Integer[1];
132	<	for (int i = 0; i < 1; ++i)
133	<	ints[i] = new Integer(i);
134	<	q.addAll(Arrays.asList(ints));
154	>	q.addAll(coll);
155		shouldThrow();
156	<	}
137	<	catch (IllegalStateException success) {}
156	>	} catch (IllegalStateException success) {}
157		}
158
159		/**
160		* put(null) throws NPE
161		*/
162	<	public void testPutNull() {
163	<	try {
162	>	public void testPutNull() throws InterruptedException {
163	>	try {
164		SynchronousQueue q = new SynchronousQueue();
165		q.put(null);
166		shouldThrow();
167	<	}
168	<	catch (NullPointerException success){
150	<	}
151	<	catch (InterruptedException ie) {
152	<	unexpectedException();
153	<	}
154	<	}
167	>	} catch (NullPointerException success) {}
168	>	}
169
170		/**
171		* put blocks interruptibly if no active taker
172		*/
173	<	public void testBlockingPut() {
174	<	Thread t = new Thread(new Runnable() {
175	<	public void run() {
176	<	try {
177	<	SynchronousQueue q = new SynchronousQueue();
178	<	q.put(zero);
179	<	threadShouldThrow();
180	<	} catch (InterruptedException ie){
181	<	}
182	<	}});
183	<	t.start();
184	<	try {
185	<	Thread.sleep(SHORT_DELAY_MS);
172	<	t.interrupt();
173	<	t.join();
174	<	}
175	<	catch (InterruptedException ie) {
176	<	unexpectedException();
177	<	}
178	<	}
173	>	public void testBlockingPut()      { testBlockingPut(false); }
174	>	public void testBlockingPut_fair() { testBlockingPut(true); }
175	>	public void testBlockingPut(boolean fair) {
176	>	final SynchronousQueue q = new SynchronousQueue(fair);
177	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
178	>	Thread t = newStartedThread(new CheckedRunnable() {
179	>	public void realRun() throws InterruptedException {
180	>	Thread.currentThread().interrupt();
181	>	try {
182	>	q.put(99);
183	>	shouldThrow();
184	>	} catch (InterruptedException success) {}
185	>	assertFalse(Thread.interrupted());
186
187	<	/**
188	<	* put blocks waiting for take
189	<	*/
190	<	public void testPutWithTake() {
191	<	final SynchronousQueue q = new SynchronousQueue();
192	<	Thread t = new Thread(new Runnable() {
193	<	public void run() {
194	<	int added = 0;
195	<	try {
196	<	q.put(new Object());
197	<	++added;
198	<	q.put(new Object());
199	<	++added;
193	<	q.put(new Object());
194	<	++added;
195	<	q.put(new Object());
196	<	++added;
197	<	threadShouldThrow();
198	<	} catch (InterruptedException e){
199	<	assertTrue(added >= 1);
200	<	}
201	<	}
202	<	});
203	<	try {
204	<	t.start();
205	<	Thread.sleep(SHORT_DELAY_MS);
206	<	q.take();
207	<	Thread.sleep(SHORT_DELAY_MS);
208	<	t.interrupt();
209	<	t.join();
210	<	} catch (Exception e){
211	<	unexpectedException();
212	<	}
187	>	pleaseInterrupt.countDown();
188	>	try {
189	>	q.put(99);
190	>	shouldThrow();
191	>	} catch (InterruptedException success) {}
192	>	assertFalse(Thread.interrupted());
193	>	}});
194	>
195	>	await(pleaseInterrupt);
196	>	assertThreadStaysAlive(t);
197	>	t.interrupt();
198	>	awaitTermination(t);
199	>	assertEquals(0, q.remainingCapacity());
200		}
201
202		/**
203	<	* timed offer times out if elements not taken
203	>	* put blocks interruptibly waiting for take
204		*/
205	<	public void testTimedOffer() {
206	<	final SynchronousQueue q = new SynchronousQueue();
207	<	Thread t = new Thread(new Runnable() {
208	<	public void run() {
209	<	try {
210	<
211	<	threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
212	<	q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
213	<	threadShouldThrow();
214	<	} catch (InterruptedException success){}
228	<	}
229	<	});
230	<
231	<	try {
232	<	t.start();
233	<	Thread.sleep(SMALL_DELAY_MS);
234	<	t.interrupt();
235	<	t.join();
236	<	} catch (Exception e){
237	<	unexpectedException();
238	<	}
239	<	}
240	<
205	>	public void testPutWithTake()      { testPutWithTake(false); }
206	>	public void testPutWithTake_fair() { testPutWithTake(true); }
207	>	public void testPutWithTake(boolean fair) {
208	>	final SynchronousQueue q = new SynchronousQueue(fair);
209	>	final CountDownLatch pleaseTake = new CountDownLatch(1);
210	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
211	>	Thread t = newStartedThread(new CheckedRunnable() {
212	>	public void realRun() throws InterruptedException {
213	>	pleaseTake.countDown();
214	>	q.put(one);
215
216	<	/**
217	<	* take blocks interruptibly when empty
218	<	*/
219	<	public void testTakeFromEmpty() {
220	<	final SynchronousQueue q = new SynchronousQueue();
221	<	Thread t = new Thread(new Runnable() {
222	<	public void run() {
223	<	try {
224	<	q.take();
225	<	threadShouldThrow();
226	<	} catch (InterruptedException success){ }
227	<	}
228	<	});
229	<	try {
230	<	t.start();
231	<	Thread.sleep(SHORT_DELAY_MS);
232	<	t.interrupt();
233	<	t.join();
260	<	} catch (Exception e){
261	<	unexpectedException();
262	<	}
216	>	pleaseInterrupt.countDown();
217	>	try {
218	>	q.put(99);
219	>	shouldThrow();
220	>	} catch (InterruptedException success) {}
221	>	assertFalse(Thread.interrupted());
222	>	}});
223	>
224	>	await(pleaseTake);
225	>	assertEquals(q.remainingCapacity(), 0);
226	>	try { assertSame(one, q.take()); }
227	>	catch (InterruptedException e) { threadUnexpectedException(e); }
228	>
229	>	await(pleaseInterrupt);
230	>	assertThreadStaysAlive(t);
231	>	t.interrupt();
232	>	awaitTermination(t);
233	>	assertEquals(q.remainingCapacity(), 0);
234		}
235
265	–
236		/**
237	<	* put blocks interruptibly if no active taker
237	>	* timed offer times out if elements not taken
238		*/
239	<	public void testFairBlockingPut() {
240	<	Thread t = new Thread(new Runnable() {
241	<	public void run() {
242	<	try {
243	<	SynchronousQueue q = new SynchronousQueue(true);
244	<	q.put(zero);
245	<	threadShouldThrow();
246	<	} catch (InterruptedException ie){
247	<	}
248	<	}});
249	<	t.start();
250	<	try {
251	<	Thread.sleep(SHORT_DELAY_MS);
252	<	t.interrupt();
253	<	t.join();
254	<	}
285	<	catch (InterruptedException ie) {
286	<	unexpectedException();
287	<	}
288	<	}
239	>	public void testTimedOffer()      { testTimedOffer(false); }
240	>	public void testTimedOffer_fair() { testTimedOffer(true); }
241	>	public void testTimedOffer(boolean fair) {
242	>	final SynchronousQueue q = new SynchronousQueue(fair);
243	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
244	>	Thread t = newStartedThread(new CheckedRunnable() {
245	>	public void realRun() throws InterruptedException {
246	>	long startTime = System.nanoTime();
247	>	assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
248	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
249	>	pleaseInterrupt.countDown();
250	>	try {
251	>	q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
252	>	shouldThrow();
253	>	} catch (InterruptedException success) {}
254	>	}});
255
256	<	/**
257	<	* put blocks waiting for take
258	<	*/
259	<	public void testFairPutWithTake() {
294	<	final SynchronousQueue q = new SynchronousQueue(true);
295	<	Thread t = new Thread(new Runnable() {
296	<	public void run() {
297	<	int added = 0;
298	<	try {
299	<	q.put(new Object());
300	<	++added;
301	<	q.put(new Object());
302	<	++added;
303	<	q.put(new Object());
304	<	++added;
305	<	q.put(new Object());
306	<	++added;
307	<	threadShouldThrow();
308	<	} catch (InterruptedException e){
309	<	assertTrue(added >= 1);
310	<	}
311	<	}
312	<	});
313	<	try {
314	<	t.start();
315	<	Thread.sleep(SHORT_DELAY_MS);
316	<	q.take();
317	<	Thread.sleep(SHORT_DELAY_MS);
318	<	t.interrupt();
319	<	t.join();
320	<	} catch (Exception e){
321	<	unexpectedException();
322	<	}
256	>	await(pleaseInterrupt);
257	>	assertThreadStaysAlive(t);
258	>	t.interrupt();
259	>	awaitTermination(t);
260		}
261
262		/**
263	<	* timed offer times out if elements not taken
263	>	* poll return null if no active putter
264		*/
265	<	public void testFairTimedOffer() {
266	<	final SynchronousQueue q = new SynchronousQueue(true);
267	<	Thread t = new Thread(new Runnable() {
268	<	public void run() {
269	<	try {
333	<
334	<	threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
335	<	q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
336	<	threadShouldThrow();
337	<	} catch (InterruptedException success){}
338	<	}
339	<	});
340	<
341	<	try {
342	<	t.start();
343	<	Thread.sleep(SMALL_DELAY_MS);
344	<	t.interrupt();
345	<	t.join();
346	<	} catch (Exception e){
347	<	unexpectedException();
348	<	}
265	>	public void testPoll()      { testPoll(false); }
266	>	public void testPoll_fair() { testPoll(true); }
267	>	public void testPoll(boolean fair) {
268	>	final SynchronousQueue q = new SynchronousQueue(fair);
269	>	assertNull(q.poll());
270		}
271
351	–
272		/**
273	<	* take blocks interruptibly when empty
273	>	* timed poll with zero timeout times out if no active putter
274		*/
275	<	public void testFairTakeFromEmpty() {
276	<	final SynchronousQueue q = new SynchronousQueue(true);
277	<	Thread t = new Thread(new Runnable() {
278	<	public void run() {
279	<	try {
280	<	q.take();
361	<	threadShouldThrow();
362	<	} catch (InterruptedException success){ }
363	<	}
364	<	});
365	<	try {
366	<	t.start();
367	<	Thread.sleep(SHORT_DELAY_MS);
368	<	t.interrupt();
369	<	t.join();
370	<	} catch (Exception e){
371	<	unexpectedException();
372	<	}
275	>	public void testTimedPoll0()      { testTimedPoll0(false); }
276	>	public void testTimedPoll0_fair() { testTimedPoll0(true); }
277	>	public void testTimedPoll0(boolean fair) {
278	>	final SynchronousQueue q = new SynchronousQueue(fair);
279	>	try { assertNull(q.poll(0, MILLISECONDS)); }
280	>	catch (InterruptedException e) { threadUnexpectedException(e); }
281		}
282
283		/**
284	<	* poll fails unless active taker
284	>	* timed poll with nonzero timeout times out if no active putter
285		*/
286	<	public void testPoll() {
287	<	SynchronousQueue q = new SynchronousQueue();
288	<	assertNull(q.poll());
286	>	public void testTimedPoll()      { testTimedPoll(false); }
287	>	public void testTimedPoll_fair() { testTimedPoll(true); }
288	>	public void testTimedPoll(boolean fair) {
289	>	final SynchronousQueue q = new SynchronousQueue(fair);
290	>	long startTime = System.nanoTime();
291	>	try { assertNull(q.poll(timeoutMillis(), MILLISECONDS)); }
292	>	catch (InterruptedException e) { threadUnexpectedException(e); }
293	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
294		}
295
296		/**
297	<	* timed pool with zero timeout times out if no active taker
297	>	* timed poll before a delayed offer times out, returning null;
298	>	* after offer succeeds; on interruption throws
299		*/
300	<	public void testTimedPoll0() {
301	<	try {
302	<	SynchronousQueue q = new SynchronousQueue();
303	<	assertNull(q.poll(0, TimeUnit.MILLISECONDS));
304	<	} catch (InterruptedException e){
305	<	unexpectedException();
306	<	}
307	<	}
300	>	public void testTimedPollWithOffer()      { testTimedPollWithOffer(false); }
301	>	public void testTimedPollWithOffer_fair() { testTimedPollWithOffer(true); }
302	>	public void testTimedPollWithOffer(boolean fair) {
303	>	final SynchronousQueue q = new SynchronousQueue(fair);
304	>	final CountDownLatch pleaseOffer = new CountDownLatch(1);
305	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
306	>	Thread t = newStartedThread(new CheckedRunnable() {
307	>	public void realRun() throws InterruptedException {
308	>	long startTime = System.nanoTime();
309	>	assertNull(q.poll(timeoutMillis(), MILLISECONDS));
310	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
311
312	<	/**
313	<	* timed pool with nonzero timeout times out if no active taker
314	<	*/
315	<	public void testTimedPoll() {
399	<	try {
400	<	SynchronousQueue q = new SynchronousQueue();
401	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
402	<	} catch (InterruptedException e){
403	<	unexpectedException();
404	<	}
405	<	}
312	>	pleaseOffer.countDown();
313	>	startTime = System.nanoTime();
314	>	assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
315	>	assertTrue(millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
316
317	<	/**
318	<	* Interrupted timed poll throws InterruptedException instead of
319	<	* returning timeout status
320	<	*/
321	<	public void testInterruptedTimedPoll() {
322	<	Thread t = new Thread(new Runnable() {
413	<	public void run() {
414	<	try {
415	<	SynchronousQueue q = new SynchronousQueue();
416	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
417	<	} catch (InterruptedException success){
418	<	}
419	<	}});
420	<	t.start();
421	<	try {
422	<	Thread.sleep(SHORT_DELAY_MS);
423	<	t.interrupt();
424	<	t.join();
425	<	}
426	<	catch (InterruptedException ie) {
427	<	unexpectedException();
428	<	}
429	<	}
317	>	Thread.currentThread().interrupt();
318	>	try {
319	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
320	>	shouldThrow();
321	>	} catch (InterruptedException success) {}
322	>	assertFalse(Thread.interrupted());
323
324	<	/**
325	<	*  timed poll before a delayed offer fails; after offer succeeds;
326	<	*  on interruption throws
327	<	*/
328	<	public void testTimedPollWithOffer() {
329	<	final SynchronousQueue q = new SynchronousQueue();
330	<	Thread t = new Thread(new Runnable() {
438	<	public void run() {
439	<	try {
440	<	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
441	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
442	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
443	<	threadShouldThrow();
444	<	} catch (InterruptedException success) { }
445	<	}
446	<	});
447	<	try {
448	<	t.start();
449	<	Thread.sleep(SMALL_DELAY_MS);
450	<	assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
451	<	t.interrupt();
452	<	t.join();
453	<	} catch (Exception e){
454	<	unexpectedException();
455	<	}
456	<	}
324	>	pleaseInterrupt.countDown();
325	>	try {
326	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
327	>	shouldThrow();
328	>	} catch (InterruptedException success) {}
329	>	assertFalse(Thread.interrupted());
330	>	}});
331
332	<	/**
333	<	* Interrupted timed poll throws InterruptedException instead of
334	<	* returning timeout status
335	<	*/
336	<	public void testFairInterruptedTimedPoll() {
463	<	Thread t = new Thread(new Runnable() {
464	<	public void run() {
465	<	try {
466	<	SynchronousQueue q = new SynchronousQueue(true);
467	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
468	<	} catch (InterruptedException success){
469	<	}
470	<	}});
471	<	t.start();
472	<	try {
473	<	Thread.sleep(SHORT_DELAY_MS);
474	<	t.interrupt();
475	<	t.join();
476	<	}
477	<	catch (InterruptedException ie) {
478	<	unexpectedException();
479	<	}
480	<	}
332	>	await(pleaseOffer);
333	>	long startTime = System.nanoTime();
334	>	try { assertTrue(q.offer(zero, LONG_DELAY_MS, MILLISECONDS)); }
335	>	catch (InterruptedException e) { threadUnexpectedException(e); }
336	>	assertTrue(millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
337
338	<	/**
339	<	*  timed poll before a delayed offer fails; after offer succeeds;
340	<	*  on interruption throws
341	<	*/
486	<	public void testFairTimedPollWithOffer() {
487	<	final SynchronousQueue q = new SynchronousQueue(true);
488	<	Thread t = new Thread(new Runnable() {
489	<	public void run() {
490	<	try {
491	<	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
492	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
493	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
494	<	threadShouldThrow();
495	<	} catch (InterruptedException success) { }
496	<	}
497	<	});
498	<	try {
499	<	t.start();
500	<	Thread.sleep(SMALL_DELAY_MS);
501	<	assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
502	<	t.interrupt();
503	<	t.join();
504	<	} catch (Exception e){
505	<	unexpectedException();
506	<	}
338	>	await(pleaseInterrupt);
339	>	assertThreadStaysAlive(t);
340	>	t.interrupt();
341	>	awaitTermination(t);
342		}
343
509	–
344		/**
345	<	* peek returns null
345	>	* peek() returns null if no active putter
346		*/
347	<	public void testPeek() {
348	<	SynchronousQueue q = new SynchronousQueue();
349	<	assertNull(q.peek());
347	>	public void testPeek()      { testPeek(false); }
348	>	public void testPeek_fair() { testPeek(true); }
349	>	public void testPeek(boolean fair) {
350	>	final SynchronousQueue q = new SynchronousQueue(fair);
351	>	assertNull(q.peek());
352		}
353
354		/**
355	<	* element throws NSEE
355	>	* element() throws NoSuchElementException if no active putter
356		*/
357	<	public void testElement() {
358	<	SynchronousQueue q = new SynchronousQueue();
357	>	public void testElement()      { testElement(false); }
358	>	public void testElement_fair() { testElement(true); }
359	>	public void testElement(boolean fair) {
360	>	final SynchronousQueue q = new SynchronousQueue(fair);
361		try {
362		q.element();
363		shouldThrow();
364	<	}
527	<	catch (NoSuchElementException success) {}
364	>	} catch (NoSuchElementException success) {}
365		}
366
367		/**
368	<	* remove throws NSEE if no active taker
368	>	* remove() throws NoSuchElementException if no active putter
369		*/
370	<	public void testRemove() {
371	<	SynchronousQueue q = new SynchronousQueue();
370	>	public void testRemove()      { testRemove(false); }
371	>	public void testRemove_fair() { testRemove(true); }
372	>	public void testRemove(boolean fair) {
373	>	final SynchronousQueue q = new SynchronousQueue(fair);
374		try {
375		q.remove();
376		shouldThrow();
377	<	} catch (NoSuchElementException success){
539	<	}
377	>	} catch (NoSuchElementException success) {}
378		}
379
380		/**
381		* remove(x) returns false
382		*/
383	<	public void testRemoveElement() {
384	<	SynchronousQueue q = new SynchronousQueue();
383	>	public void testRemoveElement()      { testRemoveElement(false); }
384	>	public void testRemoveElement_fair() { testRemoveElement(true); }
385	>	public void testRemoveElement(boolean fair) {
386	>	final SynchronousQueue q = new SynchronousQueue(fair);
387		assertFalse(q.remove(zero));
388		assertTrue(q.isEmpty());
389		}
#	Line 551 | Line 391 | public class SynchronousQueueTest extend
391		/**
392		* contains returns false
393		*/
394	<	public void testContains() {
395	<	SynchronousQueue q = new SynchronousQueue();
394	>	public void testContains()      { testContains(false); }
395	>	public void testContains_fair() { testContains(true); }
396	>	public void testContains(boolean fair) {
397	>	final SynchronousQueue q = new SynchronousQueue(fair);
398		assertFalse(q.contains(zero));
399		}
400
401		/**
402		* clear ensures isEmpty
403		*/
404	<	public void testClear() {
405	<	SynchronousQueue q = new SynchronousQueue();
404	>	public void testClear()      { testClear(false); }
405	>	public void testClear_fair() { testClear(true); }
406	>	public void testClear(boolean fair) {
407	>	final SynchronousQueue q = new SynchronousQueue(fair);
408		q.clear();
409		assertTrue(q.isEmpty());
410		}
#	Line 568 | Line 412 | public class SynchronousQueueTest extend
412		/**
413		* containsAll returns false unless empty
414		*/
415	<	public void testContainsAll() {
416	<	SynchronousQueue q = new SynchronousQueue();
415	>	public void testContainsAll()      { testContainsAll(false); }
416	>	public void testContainsAll_fair() { testContainsAll(true); }
417	>	public void testContainsAll(boolean fair) {
418	>	final SynchronousQueue q = new SynchronousQueue(fair);
419		Integer[] empty = new Integer[0];
420		assertTrue(q.containsAll(Arrays.asList(empty)));
421		Integer[] ints = new Integer[1]; ints[0] = zero;
#	Line 579 | Line 425 | public class SynchronousQueueTest extend
425		/**
426		* retainAll returns false
427		*/
428	<	public void testRetainAll() {
429	<	SynchronousQueue q = new SynchronousQueue();
428	>	public void testRetainAll()      { testRetainAll(false); }
429	>	public void testRetainAll_fair() { testRetainAll(true); }
430	>	public void testRetainAll(boolean fair) {
431	>	final SynchronousQueue q = new SynchronousQueue(fair);
432		Integer[] empty = new Integer[0];
433		assertFalse(q.retainAll(Arrays.asList(empty)));
434		Integer[] ints = new Integer[1]; ints[0] = zero;
#	Line 590 | Line 438 | public class SynchronousQueueTest extend
438		/**
439		* removeAll returns false
440		*/
441	<	public void testRemoveAll() {
442	<	SynchronousQueue q = new SynchronousQueue();
441	>	public void testRemoveAll()      { testRemoveAll(false); }
442	>	public void testRemoveAll_fair() { testRemoveAll(true); }
443	>	public void testRemoveAll(boolean fair) {
444	>	final SynchronousQueue q = new SynchronousQueue(fair);
445		Integer[] empty = new Integer[0];
446		assertFalse(q.removeAll(Arrays.asList(empty)));
447		Integer[] ints = new Integer[1]; ints[0] = zero;
448		assertFalse(q.containsAll(Arrays.asList(ints)));
449		}
450
601	–
451		/**
452		* toArray is empty
453		*/
454	<	public void testToArray() {
455	<	SynchronousQueue q = new SynchronousQueue();
456	<	Object[] o = q.toArray();
454	>	public void testToArray()      { testToArray(false); }
455	>	public void testToArray_fair() { testToArray(true); }
456	>	public void testToArray(boolean fair) {
457	>	final SynchronousQueue q = new SynchronousQueue(fair);
458	>	Object[] o = q.toArray();
459		assertEquals(o.length, 0);
460		}
461
462		/**
463		* toArray(a) is nulled at position 0
464		*/
465	<	public void testToArray2() {
466	<	SynchronousQueue q = new SynchronousQueue();
467	<	Integer[] ints = new Integer[1];
465	>	public void testToArray2()      { testToArray2(false); }
466	>	public void testToArray2_fair() { testToArray2(true); }
467	>	public void testToArray2(boolean fair) {
468	>	final SynchronousQueue q = new SynchronousQueue(fair);
469	>	Integer[] ints = new Integer[1];
470		assertNull(ints[0]);
471		}
472
473		/**
474		* toArray(null) throws NPE
475		*/
476	<	public void testToArray_BadArg() {
477	<	try {
478	<	SynchronousQueue q = new SynchronousQueue();
479	<	Object o[] = q.toArray(null);
480	<	shouldThrow();
481	<	} catch (NullPointerException success){}
476	>	public void testToArray_null()      { testToArray_null(false); }
477	>	public void testToArray_null_fair() { testToArray_null(true); }
478	>	public void testToArray_null(boolean fair) {
479	>	final SynchronousQueue q = new SynchronousQueue(fair);
480	>	try {
481	>	Object o[] = q.toArray(null);
482	>	shouldThrow();
483	>	} catch (NullPointerException success) {}
484		}
485
631	–
486		/**
487		* iterator does not traverse any elements
488		*/
489	<	public void testIterator() {
490	<	SynchronousQueue q = new SynchronousQueue();
491	<	Iterator it = q.iterator();
489	>	public void testIterator()      { testIterator(false); }
490	>	public void testIterator_fair() { testIterator(true); }
491	>	public void testIterator(boolean fair) {
492	>	final SynchronousQueue q = new SynchronousQueue(fair);
493	>	Iterator it = q.iterator();
494		assertFalse(it.hasNext());
495		try {
496		Object x = it.next();
497		shouldThrow();
498	<	}
643	<	catch (NoSuchElementException success) {}
498	>	} catch (NoSuchElementException success) {}
499		}
500
501		/**
502		* iterator remove throws ISE
503		*/
504	<	public void testIteratorRemove() {
505	<	SynchronousQueue q = new SynchronousQueue();
506	<	Iterator it = q.iterator();
504	>	public void testIteratorRemove()      { testIteratorRemove(false); }
505	>	public void testIteratorRemove_fair() { testIteratorRemove(true); }
506	>	public void testIteratorRemove(boolean fair) {
507	>	final SynchronousQueue q = new SynchronousQueue(fair);
508	>	Iterator it = q.iterator();
509		try {
510		it.remove();
511		shouldThrow();
512	<	}
656	<	catch (IllegalStateException success) {}
512	>	} catch (IllegalStateException success) {}
513		}
514
515		/**
516		* toString returns a non-null string
517		*/
518	<	public void testToString() {
519	<	SynchronousQueue q = new SynchronousQueue();
518	>	public void testToString()      { testToString(false); }
519	>	public void testToString_fair() { testToString(true); }
520	>	public void testToString(boolean fair) {
521	>	final SynchronousQueue q = new SynchronousQueue(fair);
522		String s = q.toString();
523		assertNotNull(s);
524		}
525
668	–
526		/**
527		* offer transfers elements across Executor tasks
528		*/
529	<	public void testOfferInExecutor() {
530	<	final SynchronousQueue q = new SynchronousQueue();
529	>	public void testOfferInExecutor()      { testOfferInExecutor(false); }
530	>	public void testOfferInExecutor_fair() { testOfferInExecutor(true); }
531	>	public void testOfferInExecutor(boolean fair) {
532	>	final SynchronousQueue q = new SynchronousQueue(fair);
533		ExecutorService executor = Executors.newFixedThreadPool(2);
534	<	final Integer one = new Integer(1);
676	<
677	<	executor.execute(new Runnable() {
678	<	public void run() {
679	<	threadAssertFalse(q.offer(one));
680	<	try {
681	<	threadAssertTrue(q.offer(one, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
682	<	threadAssertEquals(0, q.remainingCapacity());
683	<	}
684	<	catch (InterruptedException e) {
685	<	threadUnexpectedException();
686	<	}
687	<	}
688	<	});
534	>	final CheckedBarrier threadsStarted = new CheckedBarrier(2);
535
536	<	executor.execute(new Runnable() {
537	<	public void run() {
538	<	try {
539	<	Thread.sleep(SMALL_DELAY_MS);
540	<	threadAssertEquals(one, q.take());
541	<	}
542	<	catch (InterruptedException e) {
543	<	threadUnexpectedException();
544	<	}
545	<	}
546	<	});
536	>	executor.execute(new CheckedRunnable() {
537	>	public void realRun() throws InterruptedException {
538	>	assertFalse(q.offer(one));
539	>	threadsStarted.await();
540	>	assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
541	>	assertEquals(0, q.remainingCapacity());
542	>	}});
543	>
544	>	executor.execute(new CheckedRunnable() {
545	>	public void realRun() throws InterruptedException {
546	>	threadsStarted.await();
547	>	assertSame(one, q.take());
548	>	}});
549
550		joinPool(executor);
703	–
551		}
552
553		/**
554	<	* poll retrieves elements across Executor threads
554	>	* timed poll retrieves elements across Executor threads
555		*/
556	<	public void testPollInExecutor() {
557	<	final SynchronousQueue q = new SynchronousQueue();
556	>	public void testPollInExecutor()      { testPollInExecutor(false); }
557	>	public void testPollInExecutor_fair() { testPollInExecutor(true); }
558	>	public void testPollInExecutor(boolean fair) {
559	>	final SynchronousQueue q = new SynchronousQueue(fair);
560	>	final CheckedBarrier threadsStarted = new CheckedBarrier(2);
561		ExecutorService executor = Executors.newFixedThreadPool(2);
562	<	executor.execute(new Runnable() {
563	<	public void run() {
564	<	threadAssertNull(q.poll());
565	<	try {
566	<	threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
567	<	threadAssertTrue(q.isEmpty());
568	<	}
569	<	catch (InterruptedException e) {
570	<	threadUnexpectedException();
571	<	}
572	<	}
573	<	});
574	<
725	<	executor.execute(new Runnable() {
726	<	public void run() {
727	<	try {
728	<	Thread.sleep(SMALL_DELAY_MS);
729	<	q.put(new Integer(1));
730	<	}
731	<	catch (InterruptedException e) {
732	<	threadUnexpectedException();
733	<	}
734	<	}
735	<	});
562	>	executor.execute(new CheckedRunnable() {
563	>	public void realRun() throws InterruptedException {
564	>	assertNull(q.poll());
565	>	threadsStarted.await();
566	>	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
567	>	assertTrue(q.isEmpty());
568	>	}});
569	>
570	>	executor.execute(new CheckedRunnable() {
571	>	public void realRun() throws InterruptedException {
572	>	threadsStarted.await();
573	>	q.put(one);
574	>	}});
575
576		joinPool(executor);
577		}
#	Line 740 | Line 579 | public class SynchronousQueueTest extend
579		/**
580		* a deserialized serialized queue is usable
581		*/
582	<	public void testSerialization() {
583	<	SynchronousQueue q = new SynchronousQueue();
584	<	try {
585	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
586	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
587	<	out.writeObject(q);
588	<	out.close();
589	<
590	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
752	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
753	<	SynchronousQueue r = (SynchronousQueue)in.readObject();
754	<	assertEquals(q.size(), r.size());
755	<	while (!q.isEmpty())
756	<	assertEquals(q.remove(), r.remove());
757	<	} catch (Exception e){
758	<	e.printStackTrace();
759	<	unexpectedException();
760	<	}
582	>	public void testSerialization()      { testSerialization(false); }
583	>	public void testSerialization_fair() { testSerialization(true); }
584	>	public void testSerialization(boolean fair) {
585	>	final SynchronousQueue q = new SynchronousQueue(fair);
586	>	final SynchronousQueue r = serialClone(q);
587	>	assertTrue(q != r);
588	>	assertEquals(q.size(), r.size());
589	>	while (!q.isEmpty())
590	>	assertEquals(q.remove(), r.remove());
591		}
592
593		/**
594		* drainTo(null) throws NPE
595		*/
596	<	public void testDrainToNull() {
597	<	SynchronousQueue q = new SynchronousQueue();
596	>	public void testDrainToNull()      { testDrainToNull(false); }
597	>	public void testDrainToNull_fair() { testDrainToNull(true); }
598	>	public void testDrainToNull(boolean fair) {
599	>	final SynchronousQueue q = new SynchronousQueue(fair);
600		try {
601		q.drainTo(null);
602		shouldThrow();
603	<	} catch (NullPointerException success) {
772	<	}
603	>	} catch (NullPointerException success) {}
604		}
605
606		/**
607		* drainTo(this) throws IAE
608		*/
609	<	public void testDrainToSelf() {
610	<	SynchronousQueue q = new SynchronousQueue();
609	>	public void testDrainToSelf()      { testDrainToSelf(false); }
610	>	public void testDrainToSelf_fair() { testDrainToSelf(true); }
611	>	public void testDrainToSelf(boolean fair) {
612	>	final SynchronousQueue q = new SynchronousQueue(fair);
613		try {
614		q.drainTo(q);
615		shouldThrow();
616	<	} catch (IllegalArgumentException success) {
784	<	}
616	>	} catch (IllegalArgumentException success) {}
617		}
618
619		/**
620		* drainTo(c) of empty queue doesn't transfer elements
621		*/
622	<	public void testDrainTo() {
623	<	SynchronousQueue q = new SynchronousQueue();
622	>	public void testDrainTo()      { testDrainTo(false); }
623	>	public void testDrainTo_fair() { testDrainTo(true); }
624	>	public void testDrainTo(boolean fair) {
625	>	final SynchronousQueue q = new SynchronousQueue(fair);
626		ArrayList l = new ArrayList();
627		q.drainTo(l);
628		assertEquals(q.size(), 0);
#	Line 798 | Line 632 | public class SynchronousQueueTest extend
632		/**
633		* drainTo empties queue, unblocking a waiting put.
634		*/
635	<	public void testDrainToWithActivePut() {
636	<	final SynchronousQueue q = new SynchronousQueue();
637	<	Thread t = new Thread(new Runnable() {
638	<	public void run() {
639	<	try {
640	<	q.put(new Integer(1));
641	<	} catch (InterruptedException ie){
642	<	threadUnexpectedException();
643	<	}
644	<	}
645	<	});
646	<	try {
813	<	t.start();
814	<	ArrayList l = new ArrayList();
815	<	Thread.sleep(SHORT_DELAY_MS);
635	>	public void testDrainToWithActivePut()      { testDrainToWithActivePut(false); }
636	>	public void testDrainToWithActivePut_fair() { testDrainToWithActivePut(true); }
637	>	public void testDrainToWithActivePut(boolean fair) {
638	>	final SynchronousQueue q = new SynchronousQueue(fair);
639	>	Thread t = newStartedThread(new CheckedRunnable() {
640	>	public void realRun() throws InterruptedException {
641	>	q.put(one);
642	>	}});
643	>
644	>	ArrayList l = new ArrayList();
645	>	long startTime = System.nanoTime();
646	>	while (l.isEmpty()) {
647		q.drainTo(l);
648	<	assertTrue(l.size() <= 1);
649	<	if (l.size() > 0)
650	<	assertEquals(l.get(0), new Integer(1));
820	<	t.join();
821	<	assertTrue(l.size() <= 1);
822	<	} catch (Exception e){
823	<	unexpectedException();
648	>	if (millisElapsedSince(startTime) > LONG_DELAY_MS)
649	>	fail("timed out");
650	>	Thread.yield();
651		}
652	+	assertTrue(l.size() == 1);
653	+	assertSame(one, l.get(0));
654	+	awaitTermination(t);
655		}
656
657		/**
658	<	* drainTo(null, n) throws NPE
658	>	* drainTo(null, n) throws NullPointerException
659		*/
660	<	public void testDrainToNullN() {
661	<	SynchronousQueue q = new SynchronousQueue();
660	>	public void testDrainToNullN()      { testDrainToNullN(false); }
661	>	public void testDrainToNullN_fair() { testDrainToNullN(true); }
662	>	public void testDrainToNullN(boolean fair) {
663	>	final SynchronousQueue q = new SynchronousQueue(fair);
664		try {
665		q.drainTo(null, 0);
666		shouldThrow();
667	<	} catch (NullPointerException success) {
836	<	}
667	>	} catch (NullPointerException success) {}
668		}
669
670		/**
671	<	* drainTo(this, n) throws IAE
671	>	* drainTo(this, n) throws IllegalArgumentException
672		*/
673	<	public void testDrainToSelfN() {
674	<	SynchronousQueue q = new SynchronousQueue();
673	>	public void testDrainToSelfN()      { testDrainToSelfN(false); }
674	>	public void testDrainToSelfN_fair() { testDrainToSelfN(true); }
675	>	public void testDrainToSelfN(boolean fair) {
676	>	final SynchronousQueue q = new SynchronousQueue(fair);
677		try {
678		q.drainTo(q, 0);
679		shouldThrow();
680	<	} catch (IllegalArgumentException success) {
848	<	}
680	>	} catch (IllegalArgumentException success) {}
681		}
682
683		/**
684		* drainTo(c, n) empties up to n elements of queue into c
685		*/
686	<	public void testDrainToN() {
686	>	public void testDrainToN() throws InterruptedException {
687		final SynchronousQueue q = new SynchronousQueue();
688	<	Thread t1 = new Thread(new Runnable() {
689	<	public void run() {
690	<	try {
691	<	q.put(one);
692	<	} catch (InterruptedException ie){
693	<	threadUnexpectedException();
694	<	}
695	<	}
696	<	});
865	<	Thread t2 = new Thread(new Runnable() {
866	<	public void run() {
867	<	try {
868	<	q.put(two);
869	<	} catch (InterruptedException ie){
870	<	threadUnexpectedException();
871	<	}
872	<	}
873	<	});
874	<
875	<	try {
876	<	t1.start();
877	<	t2.start();
878	<	ArrayList l = new ArrayList();
879	<	Thread.sleep(SHORT_DELAY_MS);
880	<	q.drainTo(l, 1);
881	<	assertTrue(l.size() == 1);
882	<	q.drainTo(l, 1);
883	<	assertTrue(l.size() == 2);
884	<	assertTrue(l.contains(one));
885	<	assertTrue(l.contains(two));
886	<	t1.join();
887	<	t2.join();
888	<	} catch (Exception e){
889	<	unexpectedException();
890	<	}
891	<	}
688	>	Thread t1 = newStartedThread(new CheckedRunnable() {
689	>	public void realRun() throws InterruptedException {
690	>	q.put(one);
691	>	}});
692	>
693	>	Thread t2 = newStartedThread(new CheckedRunnable() {
694	>	public void realRun() throws InterruptedException {
695	>	q.put(two);
696	>	}});
697
698	+	ArrayList l = new ArrayList();
699	+	delay(SHORT_DELAY_MS);
700	+	q.drainTo(l, 1);
701	+	assertEquals(1, l.size());
702	+	q.drainTo(l, 1);
703	+	assertEquals(2, l.size());
704	+	assertTrue(l.contains(one));
705	+	assertTrue(l.contains(two));
706	+	awaitTermination(t1);
707	+	awaitTermination(t2);
708	+	}
709
710		}

Diff Legend

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