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.4 by dl, Sat Sep 20 18:20:08 2003 UTC vs.
Revision 1.36 by jsr166, Sat May 28 13:40:20 2011 UTC

#	Line 1 | Line 1
1		/*
2	<	* Written by members of JCP JSR-166 Expert Group and released to the
3	<	* public domain. Use, modify, and redistribute this code in any way
4	<	* without acknowledgement. Other contributors include Andrew Wright,
5	<	* Jeffrey Hayes, Pat Fischer, Mike Judd.
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/publicdomain/zero/1.0/
5	>	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	>	* Pat Fisher, Mike Judd.
7		*/
8
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 class Fair extends BlockingQueueTest {
18	+	protected BlockingQueue emptyCollection() {
19	+	return new SynchronousQueue(true);
20	+	}
21	+	}
22	+
23	+	public static class NonFair extends BlockingQueueTest {
24	+	protected BlockingQueue emptyCollection() {
25	+	return new SynchronousQueue(false);
26	+	}
27	+	}
28	+
29		public static void main(String[] args) {
30	<	junit.textui.TestRunner.run (suite());
30	>	junit.textui.TestRunner.run(suite());
31		}
32
33		public static Test suite() {
34	<	return new TestSuite(SynchronousQueueTest.class);
34	>	return newTestSuite(SynchronousQueueTest.class,
35	>	new Fair().testSuite(),
36	>	new NonFair().testSuite());
37		}
38
39		/**
40	<	*
40	>	* Any SynchronousQueue is both empty and full
41		*/
42	<	public void testEmptyFull() {
43	<	SynchronousQueue q = new SynchronousQueue();
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(new Integer(3)));
49	>	assertFalse(q.offer(zero));
50		}
51
52		/**
53	<	*
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	<	*
66	>	* add(null) throws NullPointerException
67		*/
68	<	public void testOffer() {
69	<	SynchronousQueue q = new SynchronousQueue();
70	<	assertFalse(q.offer(new Integer(1)));
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) {}
76		}
77
78		/**
79	<	*
79	>	* offer fails if no active taker
80		*/
81	<	public void testAdd() {
82	<	try {
83	<	SynchronousQueue q = new SynchronousQueue();
84	<	assertEquals(0, q.remainingCapacity());
85	<	q.add(new Integer(0));
61	<	} catch (IllegalStateException success){
62	<	}
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	<	*
89	>	* add throws IllegalStateException if no active taker
90		*/
91	<	public void testAddAll1() {
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	<	SynchronousQueue q = new SynchronousQueue();
71	<	q.addAll(null);
97	>	q.add(one);
98		shouldThrow();
99	<	}
74	<	catch (NullPointerException success) {}
99	>	} catch (IllegalStateException success) {}
100		}
101	+
102		/**
103	<	*
103	>	* addAll(null) throws NullPointerException
104		*/
105	<	public void testAddAll2() {
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 {
110	<	SynchronousQueue q = new SynchronousQueue();
82	<	Integer[] ints = new Integer[1];
83	<	q.addAll(Arrays.asList(ints));
110	>	q.addAll(null);
111		shouldThrow();
112	<	}
86	<	catch (NullPointerException success) {}
112	>	} catch (NullPointerException success) {}
113		}
114	+
115		/**
116	<	*
116	>	* addAll(this) throws IllegalArgumentException
117		*/
118	<	public void testAddAll4() {
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 {
123	<	SynchronousQueue q = new SynchronousQueue();
94	<	Integer[] ints = new Integer[1];
95	<	for (int i = 0; i < 1; ++i)
96	<	ints[i] = new Integer(i);
97	<	q.addAll(Arrays.asList(ints));
123	>	q.addAll(q);
124		shouldThrow();
125	<	}
100	<	catch (IllegalStateException success) {}
125	>	} catch (IllegalArgumentException success) {}
126		}
127
128		/**
129	<	*
129	>	* addAll of a collection with null elements throws NullPointerException
130		*/
131	<	public void testPutNull() {
132	<	try {
133	<	SynchronousQueue q = new SynchronousQueue();
134	<	q.put(null);
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	>	q.addAll(ints);
138		shouldThrow();
139	<	}
140	<	catch (NullPointerException success){
113	<	}
114	<	catch (InterruptedException ie) {
115	<	unexpectedException();
116	<	}
117	<	}
139	>	} catch (NullPointerException success) {}
140	>	}
141
142		/**
143	<	*
143	>	* addAll throws ISE if no active taker
144		*/
145	<	public void testBlockingPut() {
146	<	Thread t = new Thread(new Runnable() {
147	<	public void run() {
148	<	try {
149	<	SynchronousQueue q = new SynchronousQueue();
150	<	q.put(new Integer(0));
151	<	threadShouldThrow();
152	<	} catch (InterruptedException ie){
153	<	}
154	<	}});
155	<	t.start();
156	<	try {
134	<	Thread.sleep(SHORT_DELAY_MS);
135	<	t.interrupt();
136	<	t.join();
137	<	}
138	<	catch (InterruptedException ie) {
139	<	unexpectedException();
140	<	}
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	>	q.addAll(coll);
155	>	shouldThrow();
156	>	} catch (IllegalStateException success) {}
157		}
158
159		/**
160	<	*
160	>	* put(null) throws NPE
161		*/
162	<	public void testPutWithTake() {
163	<	final SynchronousQueue q = new SynchronousQueue();
164	<	Thread t = new Thread(new Runnable() {
165	<	public void run() {
166	<	int added = 0;
167	<	try {
152	<	q.put(new Object());
153	<	++added;
154	<	q.put(new Object());
155	<	++added;
156	<	q.put(new Object());
157	<	++added;
158	<	q.put(new Object());
159	<	++added;
160	<	threadShouldThrow();
161	<	} catch (InterruptedException e){
162	<	assertTrue(added >= 1);
163	<	}
164	<	}
165	<	});
166	<	try {
167	<	t.start();
168	<	Thread.sleep(SHORT_DELAY_MS);
169	<	q.take();
170	<	Thread.sleep(SHORT_DELAY_MS);
171	<	t.interrupt();
172	<	t.join();
173	<	} catch (Exception e){
174	<	unexpectedException();
175	<	}
162	>	public void testPutNull() throws InterruptedException {
163	>	try {
164	>	SynchronousQueue q = new SynchronousQueue();
165	>	q.put(null);
166	>	shouldThrow();
167	>	} catch (NullPointerException success) {}
168		}
169
170		/**
171	<	*
171	>	* put blocks interruptibly if no active taker
172		*/
173	<	public void testTimedOffer() {
174	<	final SynchronousQueue q = new SynchronousQueue();
175	<	Thread t = new Thread(new Runnable() {
176	<	public void run() {
177	<	try {
178	<
179	<	threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
180	<	q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
181	<	threadShouldThrow();
182	<	} catch (InterruptedException success){}
183	<	}
184	<	});
185	<
194	<	try {
195	<	t.start();
196	<	Thread.sleep(SMALL_DELAY_MS);
197	<	t.interrupt();
198	<	t.join();
199	<	} catch (Exception e){
200	<	unexpectedException();
201	<	}
202	<	}
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	+	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	<	*
203	>	* put blocks interruptibly waiting for take
204		*/
205	<	public void testTakeFromEmpty() {
206	<	final SynchronousQueue q = new SynchronousQueue();
207	<	Thread t = new Thread(new Runnable() {
208	<	public void run() {
209	<	try {
210	<	q.take();
211	<	threadShouldThrow();
212	<	} catch (InterruptedException success){ }
213	<	}
214	<	});
215	<	try {
216	<	t.start();
217	<	Thread.sleep(SHORT_DELAY_MS);
218	<	t.interrupt();
219	<	t.join();
220	<	} catch (Exception e){
221	<	unexpectedException();
222	<	}
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	>	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
236		/**
237	<	*
238	<	*/
239	<	public void testPoll() {
240	<	SynchronousQueue q = new SynchronousQueue();
241	<	assertNull(q.poll());
237	>	* timed offer times out if elements not taken
238	>	*/
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	>	await(pleaseInterrupt);
257	>	assertThreadStaysAlive(t);
258	>	t.interrupt();
259	>	awaitTermination(t);
260		}
261
262		/**
263	<	*
263	>	* poll return null if no active putter
264		*/
265	<	public void testTimedPoll0() {
266	<	try {
267	<	SynchronousQueue q = new SynchronousQueue();
268	<	assertNull(q.poll(0, TimeUnit.MILLISECONDS));
269	<	} catch (InterruptedException e){
244	<	unexpectedException();
245	<	}
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
272		/**
273	<	*
273	>	* timed poll with zero timeout times out if no active putter
274		*/
275	<	public void testTimedPoll() {
276	<	try {
277	<	SynchronousQueue q = new SynchronousQueue();
278	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
279	<	} catch (InterruptedException e){
280	<	unexpectedException();
257	<	}
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	<	*
285	<	*/
286	<	public void testInterruptedTimedPoll() {
287	<	Thread t = new Thread(new Runnable() {
288	<	public void run() {
289	<	try {
290	<	SynchronousQueue q = new SynchronousQueue();
291	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
292	<	} catch (InterruptedException success){
293	<	}
271	<	}});
272	<	t.start();
273	<	try {
274	<	Thread.sleep(SHORT_DELAY_MS);
275	<	t.interrupt();
276	<	t.join();
277	<	}
278	<	catch (InterruptedException ie) {
279	<	unexpectedException();
280	<	}
284	>	* timed poll with nonzero timeout times out if no active putter
285	>	*/
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	<	*
297	>	* timed poll before a delayed offer times out, returning null;
298	>	* after offer succeeds; on interruption throws
299		*/
300	<	public void testTimedPollWithOffer() {
301	<	final SynchronousQueue q = new SynchronousQueue();
302	<	Thread t = new Thread(new Runnable() {
303	<	public void run() {
304	<	try {
305	<	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
306	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
307	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
308	<	threadShouldThrow();
309	<	} catch (InterruptedException success) { }
310	<	}
311	<	});
312	<	try {
313	<	t.start();
314	<	Thread.sleep(SMALL_DELAY_MS);
315	<	assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
316	<	t.interrupt();
317	<	t.join();
318	<	} catch (Exception e){
319	<	unexpectedException();
320	<	}
321	<	}
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	>	pleaseOffer.countDown();
313	>	startTime = System.nanoTime();
314	>	assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
315	>	assertTrue(millisElapsedSince(startTime) < MEDIUM_DELAY_MS);
316	>
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	+	pleaseInterrupt.countDown();
325	+	try {
326	+	q.poll(LONG_DELAY_MS, MILLISECONDS);
327	+	shouldThrow();
328	+	} catch (InterruptedException success) {}
329	+	assertFalse(Thread.interrupted());
330	+	}});
331	+
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	+	await(pleaseInterrupt);
339	+	assertThreadStaysAlive(t);
340	+	t.interrupt();
341	+	awaitTermination(t);
342	+	}
343
344		/**
345	<	*
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	<	*
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	<	}
327	<	catch (NoSuchElementException success) {}
364	>	} catch (NoSuchElementException success) {}
365		}
366
367		/**
368	<	*
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){
339	<	}
377	>	} catch (NoSuchElementException success) {}
378		}
379
380		/**
381	<	*
381	>	* remove(x) returns false
382		*/
383	<	public void testRemoveElement() {
384	<	SynchronousQueue q = new SynchronousQueue();
385	<	assertFalse(q.remove(new Integer(0)));
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		}
390	<
390	>
391		/**
392	<	*
392	>	* contains returns false
393		*/
394	<	public void testContains() {
395	<	SynchronousQueue q = new SynchronousQueue();
396	<	assertFalse(q.contains(new Integer(0)));
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	<	*
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		}
411
412		/**
413	<	*
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	<	Integer[] ints = new Integer[1]; ints[0] = new Integer(0);
420	>	assertTrue(q.containsAll(Arrays.asList(empty)));
421	>	Integer[] ints = new Integer[1]; ints[0] = zero;
422		assertFalse(q.containsAll(Arrays.asList(ints)));
423		}
424
425		/**
426	<	*
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	<	Integer[] ints = new Integer[1]; ints[0] = new Integer(0);
434	<	q.retainAll(Arrays.asList(ints));
435	<	assertFalse(q.containsAll(Arrays.asList(ints)));
433	>	assertFalse(q.retainAll(Arrays.asList(empty)));
434	>	Integer[] ints = new Integer[1]; ints[0] = zero;
435	>	assertFalse(q.retainAll(Arrays.asList(ints)));
436		}
437
438		/**
439	<	*
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	<	Integer[] ints = new Integer[1]; ints[0] = new Integer(0);
447	<	q.removeAll(Arrays.asList(ints));
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
400	–
451		/**
452	<	*
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	<	*
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	<
472	>
473	>	/**
474	>	* toArray(null) throws NPE
475	>	*/
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	>
486		/**
487	<	*
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	<	}
430	<	catch (NoSuchElementException success) {}
498	>	} catch (NoSuchElementException success) {}
499		}
500
501		/**
502	<	*
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	<	}
443	<	catch (IllegalStateException success) {}
512	>	} catch (IllegalStateException success) {}
513		}
514
515		/**
516	<	*
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	<	assertTrue(s != null);
524	<	}
454	<
523	>	assertNotNull(s);
524	>	}
525
526		/**
527	<	*
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);
534	>	final CheckedBarrier threadsStarted = new CheckedBarrier(2);
535
536	<	executor.execute(new Runnable() {
537	<	public void run() {
538	<	threadAssertFalse(q.offer(one));
539	<	try {
540	<	threadAssertTrue(q.offer(one, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
541	<	threadAssertEquals(0, q.remainingCapacity());
542	<	}
543	<	catch (InterruptedException e) {
544	<	threadUnexpectedException();
545	<	}
546	<	}
547	<	});
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
477	–	executor.execute(new Runnable() {
478	–	public void run() {
479	–	try {
480	–	Thread.sleep(SMALL_DELAY_MS);
481	–	threadAssertEquals(one, q.take());
482	–	}
483	–	catch (InterruptedException e) {
484	–	threadUnexpectedException();
485	–	}
486	–	}
487	–	});
488	–
550		joinPool(executor);
551	+	}
552	+
553	+	/**
554	+	* timed poll retrieves elements across Executor threads
555	+	*/
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 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		}
578
579		/**
580	<	*
580	>	* a deserialized serialized queue is usable
581		*/
582	<	public void testPollInExecutor() {
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	<	final SynchronousQueue q = new SynchronousQueue();
593	>	/**
594	>	* drainTo(null) throws NPE
595	>	*/
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) {}
604	>	}
605
606	<	ExecutorService executor = Executors.newFixedThreadPool(2);
606	>	/**
607	>	* drainTo(this) throws IAE
608	>	*/
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) {}
617	>	}
618
619	<	executor.execute(new Runnable() {
620	<	public void run() {
621	<	threadAssertNull(q.poll());
622	<	try {
623	<	threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
624	<	threadAssertTrue(q.isEmpty());
625	<	}
626	<	catch (InterruptedException e) {
627	<	threadUnexpectedException();
628	<	}
629	<	}
630	<	});
619	>	/**
620	>	* drainTo(c) of empty queue doesn't transfer elements
621	>	*/
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);
629	>	assertEquals(l.size(), 0);
630	>	}
631
632	<	executor.execute(new Runnable() {
633	<	public void run() {
634	<	try {
635	<	Thread.sleep(SMALL_DELAY_MS);
636	<	q.put(new Integer(1));
637	<	}
638	<	catch (InterruptedException e) {
639	<	threadUnexpectedException();
640	<	}
641	<	}
642	<	});
526	<
527	<	joinPool(executor);
632	>	/**
633	>	* drainTo empties queue, unblocking a waiting put.
634	>	*/
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	+	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	<	*
658	>	* drainTo(null, n) throws NullPointerException
659		*/
660	<	public void testSerialization() {
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	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
666	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
667	<	out.writeObject(q);
668	<	out.close();
669	<
670	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
671	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
672	<	SynchronousQueue r = (SynchronousQueue)in.readObject();
673	<	assertEquals(q.size(), r.size());
674	<	while (!q.isEmpty())
675	<	assertEquals(q.remove(), r.remove());
676	<	} catch(Exception e){
677	<	unexpectedException();
678	<	}
665	>	q.drainTo(null, 0);
666	>	shouldThrow();
667	>	} catch (NullPointerException success) {}
668	>	}
669	>
670	>	/**
671	>	* drainTo(this, n) throws IllegalArgumentException
672	>	*/
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) {}
681	>	}
682	>
683	>	/**
684	>	* drainTo(c, n) empties up to n elements of queue into c
685	>	*/
686	>	public void testDrainToN() throws InterruptedException {
687	>	final SynchronousQueue q = new SynchronousQueue();
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