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.7 by dl, Sat Dec 27 19:26:44 2003 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
5	<	* Other contributors include Andrew Wright, Jeffrey Hayes,
6	<	* Pat Fisher, Mike Judd.
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	<	* A SynchronousQueue is both empty and full
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(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){
75	<	}
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 {
83	–	SynchronousQueue q = new SynchronousQueue();
110		q.addAll(null);
111		shouldThrow();
112	<	}
87	<	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 {
95	–	SynchronousQueue q = new SynchronousQueue();
123		q.addAll(q);
124		shouldThrow();
125	<	}
99	<	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();
108	<	Integer[] ints = new Integer[1];
109	<	q.addAll(Arrays.asList(ints));
137	>	q.addAll(ints);
138		shouldThrow();
139	<	}
112	<	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();
120	<	Integer[] ints = new Integer[1];
121	<	for (int i = 0; i < 1; ++i)
122	<	ints[i] = new Integer(i);
123	<	q.addAll(Arrays.asList(ints));
154	>	q.addAll(coll);
155		shouldThrow();
156	<	}
126	<	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){
139	<	}
140	<	catch (InterruptedException ie) {
141	<	unexpectedException();
142	<	}
143	<	}
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);
186	<	t.interrupt();
187	<	t.join();
188	<	}
189	<	catch (InterruptedException ie) {
190	<	unexpectedException();
191	<	}
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	<	* put blocks waiting for take
203	>	* put blocks interruptibly waiting for take
204		*/
205	<	public void testPutWithTake() {
206	<	final SynchronousQueue q = new SynchronousQueue();
207	<	Thread t = new Thread(new Runnable() {
208	<	public void run() {
209	<	int added = 0;
210	<	try {
211	<	q.put(new Object());
212	<	++added;
213	<	q.put(new Object());
214	<	++added;
215	<	q.put(new Object());
216	<	++added;
217	<	q.put(new Object());
218	<	++added;
219	<	threadShouldThrow();
220	<	} catch (InterruptedException e){
221	<	assertTrue(added >= 1);
222	<	}
223	<	}
224	<	});
225	<	try {
226	<	t.start();
227	<	Thread.sleep(SHORT_DELAY_MS);
228	<	q.take();
229	<	Thread.sleep(SHORT_DELAY_MS);
230	<	t.interrupt();
231	<	t.join();
232	<	} catch (Exception e){
233	<	unexpectedException();
201	<	}
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		* timed offer times out if elements not taken
238		*/
239	<	public void testTimedOffer() {
240	<	final SynchronousQueue q = new SynchronousQueue();
241	<	Thread t = new Thread(new Runnable() {
242	<	public void run() {
243	<	try {
244	<
245	<	threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
246	<	q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
247	<	threadShouldThrow();
248	<	} catch (InterruptedException success){}
249	<	}
250	<	});
251	<
252	<	try {
253	<	t.start();
254	<	Thread.sleep(SMALL_DELAY_MS);
223	<	t.interrupt();
224	<	t.join();
225	<	} catch (Exception e){
226	<	unexpectedException();
227	<	}
228	<	}
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	<	* take blocks interruptibly when empty
263	>	* poll return null if no active putter
264		*/
265	<	public void testTakeFromEmpty() {
266	<	final SynchronousQueue q = new SynchronousQueue();
267	<	Thread t = new Thread(new Runnable() {
268	<	public void run() {
269	<	try {
239	<	q.take();
240	<	threadShouldThrow();
241	<	} catch (InterruptedException success){ }
242	<	}
243	<	});
244	<	try {
245	<	t.start();
246	<	Thread.sleep(SHORT_DELAY_MS);
247	<	t.interrupt();
248	<	t.join();
249	<	} catch (Exception e){
250	<	unexpectedException();
251	<	}
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	<	* poll fails unless active taker
273	>	* timed poll with zero timeout times out if no active putter
274		*/
275	<	public void testPoll() {
276	<	SynchronousQueue q = new SynchronousQueue();
277	<	assertNull(q.poll());
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	<	* timed pool with zero timeout times out if no active taker
284	>	* timed poll with nonzero timeout times out if no active putter
285		*/
286	<	public void testTimedPoll0() {
287	<	try {
288	<	SynchronousQueue q = new SynchronousQueue();
289	<	assertNull(q.poll(0, TimeUnit.MILLISECONDS));
290	<	} catch (InterruptedException e){
291	<	unexpectedException();
292	<	}
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 nonzero 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 testTimedPoll() {
301	<	try {
302	<	SynchronousQueue q = new SynchronousQueue();
303	<	assertNull(q.poll(SHORT_DELAY_MS, 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	<	* Interrupted timed poll throws InterruptedException instead of
314	<	* returning timeout status
315	<	*/
290	<	public void testInterruptedTimedPoll() {
291	<	Thread t = new Thread(new Runnable() {
292	<	public void run() {
293	<	try {
294	<	SynchronousQueue q = new SynchronousQueue();
295	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
296	<	} catch (InterruptedException success){
297	<	}
298	<	}});
299	<	t.start();
300	<	try {
301	<	Thread.sleep(SHORT_DELAY_MS);
302	<	t.interrupt();
303	<	t.join();
304	<	}
305	<	catch (InterruptedException ie) {
306	<	unexpectedException();
307	<	}
308	<	}
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	<	*  timed poll before a delayed offer fails; after offer succeeds;
319	<	*  on interruption throws
320	<	*/
321	<	public void testTimedPollWithOffer() {
322	<	final SynchronousQueue q = new SynchronousQueue();
316	<	Thread t = new Thread(new Runnable() {
317	<	public void run() {
318	<	try {
319	<	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
320	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
321	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
322	<	threadShouldThrow();
323	<	} catch (InterruptedException success) { }
324	<	}
325	<	});
326	<	try {
327	<	t.start();
328	<	Thread.sleep(SMALL_DELAY_MS);
329	<	assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
330	<	t.interrupt();
331	<	t.join();
332	<	} catch (Exception e){
333	<	unexpectedException();
334	<	}
335	<	}
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	<	* 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	<	}
355	<	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){
367	<	}
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		}
390	<
390	>
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 396 | 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 407 | 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 418 | 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
429	–
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	<
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
459	–
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	<	}
471	<	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	<	}
484	<	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	<	}
495	<
524	>	}
525
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);
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
518	–	executor.execute(new Runnable() {
519	–	public void run() {
520	–	try {
521	–	Thread.sleep(SMALL_DELAY_MS);
522	–	threadAssertEquals(one, q.take());
523	–	}
524	–	catch (InterruptedException e) {
525	–	threadUnexpectedException();
526	–	}
527	–	}
528	–	});
529	–
550		joinPool(executor);
531	–
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	<	});
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
553	–	executor.execute(new Runnable() {
554	–	public void run() {
555	–	try {
556	–	Thread.sleep(SMALL_DELAY_MS);
557	–	q.put(new Integer(1));
558	–	}
559	–	catch (InterruptedException e) {
560	–	threadUnexpectedException();
561	–	}
562	–	}
563	–	});
564	–
576		joinPool(executor);
577		}
578
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());
580	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
581	<	SynchronousQueue r = (SynchronousQueue)in.readObject();
582	<	assertEquals(q.size(), r.size());
583	<	while (!q.isEmpty())
584	<	assertEquals(q.remove(), r.remove());
585	<	} catch(Exception e){
586	<	unexpectedException();
587	<	}
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();
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) {
599	<	}
603	>	} catch (NullPointerException success) {}
604		}
605
606		/**
607		* drainTo(this) throws IAE
608	<	*/
609	<	public void testDrainToSelf() {
610	<	SynchronousQueue q = new SynchronousQueue();
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) {
611	<	}
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();
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);
#	Line 624 | Line 631 | public class SynchronousQueueTest extend
631
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 {
640	<	t.start();
641	<	ArrayList l = new ArrayList();
642	<	Thread.sleep(SHORT_DELAY_MS);
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	<	assertTrue(l.size() <= 1);
649	<	if (l.size() > 0)
650	<	assertEquals(l.get(0), new Integer(1));
647	<	t.join();
648	<	assertTrue(l.size() <= 1);
649	<	} catch(Exception e){
650	<	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
659	<	*/
660	<	public void testDrainToNullN() {
661	<	SynchronousQueue q = new SynchronousQueue();
658	>	* drainTo(null, n) throws NullPointerException
659	>	*/
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) {
663	<	}
667	>	} catch (NullPointerException success) {}
668		}
669
670		/**
671	<	* drainTo(this, n) throws IAE
672	<	*/
673	<	public void testDrainToSelfN() {
674	<	SynchronousQueue q = new SynchronousQueue();
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) {
675	<	}
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() {
685	>	*/
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	<	});
692	<	Thread t2 = new Thread(new Runnable() {
693	<	public void run() {
694	<	try {
695	<	q.put(two);
696	<	} catch (InterruptedException ie){
697	<	threadUnexpectedException();
698	<	}
699	<	}
700	<	});
701	<
702	<	try {
703	<	t1.start();
704	<	t2.start();
705	<	ArrayList l = new ArrayList();
706	<	Thread.sleep(SHORT_DELAY_MS);
707	<	q.drainTo(l, 1);
708	<	assertTrue(l.size() == 1);
709	<	q.drainTo(l, 1);
710	<	assertTrue(l.size() == 2);
711	<	assertTrue(l.contains(one));
712	<	assertTrue(l.contains(two));
713	<	t1.join();
714	<	t2.join();
715	<	} catch(Exception e){
716	<	unexpectedException();
717	<	}
718	<	}
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