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.2 by dl, Sun Sep 7 20:39:11 2003 UTC vs.
Revision 1.27 by jsr166, Thu Oct 28 17:57:26 2010 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/licenses/publicdomain
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 TestCase {
15	>	public class SynchronousQueueTest extends JSR166TestCase {
16
17	<	private final static int N = 1;
18	<	private static long SHORT_DELAY_MS = 100;
19	<	private static long MEDIUM_DELAY_MS = 1000;
20	<	private static long LONG_DELAY_MS = 10000;
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
41	+	*/
42		public void testEmptyFull() {
43		SynchronousQueue q = new SynchronousQueue();
44		assertTrue(q.isEmpty());
45	<	assertEquals(0, q.size());
45	>	assertEquals(0, q.size());
46	>	assertEquals(0, q.remainingCapacity());
47	>	assertFalse(q.offer(zero));
48	>	}
49	>
50	>	/**
51	>	* A fair SynchronousQueue is both empty and full
52	>	*/
53	>	public void testFairEmptyFull() {
54	>	SynchronousQueue q = new SynchronousQueue(true);
55	>	assertTrue(q.isEmpty());
56	>	assertEquals(0, q.size());
57		assertEquals(0, q.remainingCapacity());
58	<	assertFalse(q.offer(new Integer(3)));
58	>	assertFalse(q.offer(zero));
59		}
60
61	<	public void testOfferNull(){
62	<	try {
61	>	/**
62	>	* offer(null) throws NPE
63	>	*/
64	>	public void testOfferNull() {
65	>	try {
66		SynchronousQueue q = new SynchronousQueue();
67		q.offer(null);
68	<	fail("should throw NPE");
69	<	} catch (NullPointerException success) { }
68	>	shouldThrow();
69	>	} catch (NullPointerException success) {}
70	>	}
71	>
72	>	/**
73	>	* add(null) throws NPE
74	>	*/
75	>	public void testAddNull() {
76	>	try {
77	>	SynchronousQueue q = new SynchronousQueue();
78	>	q.add(null);
79	>	shouldThrow();
80	>	} catch (NullPointerException success) {}
81		}
82
83	<	public void testOffer(){
83	>	/**
84	>	* offer fails if no active taker
85	>	*/
86	>	public void testOffer() {
87		SynchronousQueue q = new SynchronousQueue();
88	<	assertFalse(q.offer(new Integer(1)));
88	>	assertFalse(q.offer(one));
89		}
90
91	<	public void testAdd(){
92	<	try {
91	>	/**
92	>	* add throws ISE if no active taker
93	>	*/
94	>	public void testAdd() {
95	>	try {
96		SynchronousQueue q = new SynchronousQueue();
97		assertEquals(0, q.remainingCapacity());
98	<	q.add(new Integer(0));
99	<	} catch (IllegalStateException success){
100	<	}
98	>	q.add(one);
99	>	shouldThrow();
100	>	} catch (IllegalStateException success) {}
101		}
102
103	<	public void testAddAll1(){
103	>	/**
104	>	* addAll(null) throws NPE
105	>	*/
106	>	public void testAddAll1() {
107		try {
108		SynchronousQueue q = new SynchronousQueue();
109		q.addAll(null);
110	<	fail("Cannot add null collection");
111	<	}
64	<	catch (NullPointerException success) {}
110	>	shouldThrow();
111	>	} catch (NullPointerException success) {}
112		}
113	<	public void testAddAll2(){
113	>
114	>	/**
115	>	* addAll(this) throws IAE
116	>	*/
117	>	public void testAddAllSelf() {
118		try {
119		SynchronousQueue q = new SynchronousQueue();
120	<	Integer[] ints = new Integer[N];
120	>	q.addAll(q);
121	>	shouldThrow();
122	>	} catch (IllegalArgumentException success) {}
123	>	}
124	>
125	>	/**
126	>	* addAll of a collection with null elements throws NPE
127	>	*/
128	>	public void testAddAll2() {
129	>	try {
130	>	SynchronousQueue q = new SynchronousQueue();
131	>	Integer[] ints = new Integer[1];
132		q.addAll(Arrays.asList(ints));
133	<	fail("Cannot add null elements");
134	<	}
73	<	catch (NullPointerException success) {}
133	>	shouldThrow();
134	>	} catch (NullPointerException success) {}
135		}
136	<	public void testAddAll4(){
136	>
137	>	/**
138	>	* addAll throws ISE if no active taker
139	>	*/
140	>	public void testAddAll4() {
141		try {
142		SynchronousQueue q = new SynchronousQueue();
143	<	Integer[] ints = new Integer[N];
144	<	for (int i = 0; i < N; ++i)
143	>	Integer[] ints = new Integer[1];
144	>	for (int i = 0; i < 1; ++i)
145		ints[i] = new Integer(i);
146		q.addAll(Arrays.asList(ints));
147	<	fail("Cannot add with insufficient capacity");
148	<	}
84	<	catch (IllegalStateException success) {}
147	>	shouldThrow();
148	>	} catch (IllegalStateException success) {}
149		}
150
151	<	public void testPutNull() {
152	<	try {
151	>	/**
152	>	* put(null) throws NPE
153	>	*/
154	>	public void testPutNull() throws InterruptedException {
155	>	try {
156		SynchronousQueue q = new SynchronousQueue();
157		q.put(null);
158	<	fail("put should throw NPE");
159	<	}
93	<	catch (NullPointerException success){
94	<	}
95	<	catch (InterruptedException ie) {
96	<	fail("Unexpected exception");
97	<	}
158	>	shouldThrow();
159	>	} catch (NullPointerException success) {}
160		}
161
162	<	public void testBlockingPut(){
163	<	Thread t = new Thread(new Runnable() {
164	<	public void run() {
165	<	try {
166	<	SynchronousQueue q = new SynchronousQueue();
167	<	q.put(new Integer(0));
168	<	fail("put should block");
169	<	} catch (InterruptedException ie){
170	<	}
171	<	}});
172	<	t.start();
173	<	try {
174	<	Thread.sleep(SHORT_DELAY_MS);
175	<	t.interrupt();
114	<	t.join();
115	<	}
116	<	catch (InterruptedException ie) {
117	<	fail("Unexpected exception");
118	<	}
162	>	/**
163	>	* put blocks interruptibly if no active taker
164	>	*/
165	>	public void testBlockingPut() throws InterruptedException {
166	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
167	>	public void realRun() throws InterruptedException {
168	>	SynchronousQueue q = new SynchronousQueue();
169	>	q.put(zero);
170	>	}});
171	>
172	>	t.start();
173	>	Thread.sleep(SHORT_DELAY_MS);
174	>	t.interrupt();
175	>	t.join();
176		}
177
178	<	public void testPutWithTake() {
178	>	/**
179	>	* put blocks waiting for take
180	>	*/
181	>	public void testPutWithTake() throws InterruptedException {
182		final SynchronousQueue q = new SynchronousQueue();
183	<	Thread t = new Thread(new Runnable() {
184	<	public void run(){
185	<	int added = 0;
186	<	try {
187	<	q.put(new Object());
188	<	++added;
129	<	q.put(new Object());
130	<	++added;
131	<	q.put(new Object());
132	<	++added;
133	<	q.put(new Object());
183	>	Thread t = new Thread(new CheckedRunnable() {
184	>	public void realRun() throws InterruptedException {
185	>	int added = 0;
186	>	try {
187	>	while (true) {
188	>	q.put(added);
189		++added;
135	–	fail("Should block");
136	–	} catch (InterruptedException e){
137	–	assertTrue(added >= 1);
190		}
191	+	} catch (InterruptedException success) {
192	+	assertEquals(1, added);
193		}
194	<	});
195	<	try {
196	<	t.start();
197	<	Thread.sleep(SHORT_DELAY_MS);
198	<	q.take();
199	<	Thread.sleep(SHORT_DELAY_MS);
200	<	t.interrupt();
201	<	t.join();
148	<	} catch (Exception e){
149	<	fail("Unexpected exception");
150	<	}
194	>	}});
195	>
196	>	t.start();
197	>	Thread.sleep(SHORT_DELAY_MS);
198	>	assertEquals(0, q.take());
199	>	Thread.sleep(SHORT_DELAY_MS);
200	>	t.interrupt();
201	>	t.join();
202		}
203
204	<	public void testTimedOffer() {
204	>	/**
205	>	* timed offer times out if elements not taken
206	>	*/
207	>	public void testTimedOffer() throws InterruptedException {
208		final SynchronousQueue q = new SynchronousQueue();
209	<	Thread t = new Thread(new Runnable() {
210	<	public void run(){
211	<	try {
212	<
213	<	assertFalse(q.offer(new Object(), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));
214	<	q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
215	<	fail("Should block");
216	<	} catch (InterruptedException success){}
217	<	}
218	<	});
165	<
166	<	try {
167	<	t.start();
168	<	Thread.sleep(SHORT_DELAY_MS);
169	<	t.interrupt();
170	<	t.join();
171	<	} catch (Exception e){
172	<	fail("Unexpected exception");
173	<	}
209	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
210	>	public void realRun() throws InterruptedException {
211	>	assertFalse(q.offer(new Object(), SHORT_DELAY_MS, MILLISECONDS));
212	>	q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
213	>	}});
214	>
215	>	t.start();
216	>	Thread.sleep(SMALL_DELAY_MS);
217	>	t.interrupt();
218	>	t.join();
219		}
220
221	+	/**
222	+	* put blocks interruptibly if no active taker
223	+	*/
224	+	public void testFairBlockingPut() throws InterruptedException {
225	+	Thread t = new Thread(new CheckedInterruptedRunnable() {
226	+	public void realRun() throws InterruptedException {
227	+	SynchronousQueue q = new SynchronousQueue(true);
228	+	q.put(zero);
229	+	}});
230
231	<	public void testTakeFromEmpty() {
232	<	final SynchronousQueue q = new SynchronousQueue();
233	<	Thread t = new Thread(new Runnable() {
234	<	public void run(){
235	<	try {
236	<	q.take();
237	<	fail("Should block");
238	<	} catch (InterruptedException success){ }
231	>	t.start();
232	>	Thread.sleep(SHORT_DELAY_MS);
233	>	t.interrupt();
234	>	t.join();
235	>	}
236	>
237	>	/**
238	>	* put blocks waiting for take
239	>	*/
240	>	public void testFairPutWithTake() throws InterruptedException {
241	>	final SynchronousQueue q = new SynchronousQueue(true);
242	>	Thread t = new Thread(new CheckedRunnable() {
243	>	public void realRun() throws InterruptedException {
244	>	int added = 0;
245	>	try {
246	>	while (true) {
247	>	q.put(added);
248	>	++added;
249	>	}
250	>	} catch (InterruptedException success) {
251	>	assertEquals(1, added);
252		}
253	<	});
254	<	try {
255	<	t.start();
256	<	Thread.sleep(SHORT_DELAY_MS);
257	<	t.interrupt();
258	<	t.join();
259	<	} catch (Exception e){
260	<	fail("Unexpected exception");
261	<	}
253	>	}});
254	>
255	>	t.start();
256	>	Thread.sleep(SHORT_DELAY_MS);
257	>	assertEquals(0, q.take());
258	>	Thread.sleep(SHORT_DELAY_MS);
259	>	t.interrupt();
260	>	t.join();
261	>	}
262	>
263	>	/**
264	>	* timed offer times out if elements not taken
265	>	*/
266	>	public void testFairTimedOffer() throws InterruptedException {
267	>	final SynchronousQueue q = new SynchronousQueue(true);
268	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
269	>	public void realRun() throws InterruptedException {
270	>	assertFalse(q.offer(new Object(), SHORT_DELAY_MS, MILLISECONDS));
271	>	q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
272	>	}});
273	>
274	>	t.start();
275	>	Thread.sleep(SMALL_DELAY_MS);
276	>	t.interrupt();
277	>	t.join();
278		}
279
280	<	public void testPoll(){
280	>
281	>	/**
282	>	* take blocks interruptibly when empty
283	>	*/
284	>	public void testFairTakeFromEmpty() throws InterruptedException {
285	>	final SynchronousQueue q = new SynchronousQueue(true);
286	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
287	>	public void realRun() throws InterruptedException {
288	>	q.take();
289	>	}});
290	>
291	>	t.start();
292	>	Thread.sleep(SHORT_DELAY_MS);
293	>	t.interrupt();
294	>	t.join();
295	>	}
296	>
297	>	/**
298	>	* poll fails unless active taker
299	>	*/
300	>	public void testPoll() {
301		SynchronousQueue q = new SynchronousQueue();
302	<	assertNull(q.poll());
302	>	assertNull(q.poll());
303		}
304
305	<	public void testTimedPoll0() {
306	<	try {
307	<	SynchronousQueue q = new SynchronousQueue();
308	<	assertNull(q.poll(0, TimeUnit.MILLISECONDS));
309	<	} catch (InterruptedException e){
310	<	fail("Unexpected exception");
208	<	}
305	>	/**
306	>	* timed pool with zero timeout times out if no active taker
307	>	*/
308	>	public void testTimedPoll0() throws InterruptedException {
309	>	SynchronousQueue q = new SynchronousQueue();
310	>	assertNull(q.poll(0, MILLISECONDS));
311		}
312
313	<	public void testTimedPoll() {
314	<	try {
315	<	SynchronousQueue q = new SynchronousQueue();
316	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
317	<	} catch (InterruptedException e){
318	<	fail("Unexpected exception");
217	<	}
218	<	}
219	<
220	<	public void testInterruptedTimedPoll(){
221	<	Thread t = new Thread(new Runnable() {
222	<	public void run() {
223	<	try {
224	<	SynchronousQueue q = new SynchronousQueue();
225	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
226	<	} catch (InterruptedException success){
227	<	}
228	<	}});
229	<	t.start();
230	<	try {
231	<	Thread.sleep(SHORT_DELAY_MS);
232	<	t.interrupt();
233	<	t.join();
234	<	}
235	<	catch (InterruptedException ie) {
236	<	fail("Unexpected exception");
237	<	}
313	>	/**
314	>	* timed pool with nonzero timeout times out if no active taker
315	>	*/
316	>	public void testTimedPoll() throws InterruptedException {
317	>	SynchronousQueue q = new SynchronousQueue();
318	>	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
319		}
320
321	<	public void testTimedPollWithOffer(){
321	>	/**
322	>	* Interrupted timed poll throws InterruptedException instead of
323	>	* returning timeout status
324	>	*/
325	>	public void testInterruptedTimedPoll() throws InterruptedException {
326		final SynchronousQueue q = new SynchronousQueue();
327	<	Thread t = new Thread(new Runnable() {
328	<	public void run(){
329	<	try {
330	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
331	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
332	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
333	<	fail("Should block");
334	<	} catch (InterruptedException success) { }
335	<	}
336	<	});
337	<	try {
338	<	t.start();
339	<	Thread.sleep(SHORT_DELAY_MS * 2);
340	<	assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
341	<	t.interrupt();
342	<	t.join();
343	<	} catch (Exception e){
344	<	fail("Unexpected exception");
345	<	}
346	<	}
327	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
328	>	public void realRun() throws InterruptedException {
329	>	q.poll(SMALL_DELAY_MS, MILLISECONDS);
330	>	}});
331	>
332	>	t.start();
333	>	Thread.sleep(SHORT_DELAY_MS);
334	>	t.interrupt();
335	>	t.join();
336	>	}
337	>
338	>	/**
339	>	* Interrupted timed poll throws InterruptedException instead of
340	>	* returning timeout status
341	>	*/
342	>	public void testFairInterruptedTimedPoll() throws InterruptedException {
343	>	Thread t = new Thread(new CheckedInterruptedRunnable() {
344	>	public void realRun() throws InterruptedException {
345	>	SynchronousQueue q = new SynchronousQueue(true);
346	>	q.poll(SMALL_DELAY_MS, MILLISECONDS);
347	>	}});
348	>
349	>	t.start();
350	>	Thread.sleep(SHORT_DELAY_MS);
351	>	t.interrupt();
352	>	t.join();
353	>	}
354	>
355	>	/**
356	>	* timed poll before a delayed offer fails; after offer succeeds;
357	>	* on interruption throws
358	>	*/
359	>	public void testFairTimedPollWithOffer() throws InterruptedException {
360	>	final SynchronousQueue q = new SynchronousQueue(true);
361	>	Thread t = new Thread(new CheckedRunnable() {
362	>	public void realRun() throws InterruptedException {
363	>	try {
364	>	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
365	>	assertSame(zero, q.poll(LONG_DELAY_MS, MILLISECONDS));
366	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
367	>	threadShouldThrow();
368	>	} catch (InterruptedException success) {}
369	>	}});
370	>
371	>	t.start();
372	>	Thread.sleep(SMALL_DELAY_MS);
373	>	assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
374	>	t.interrupt();
375	>	t.join();
376	>	}
377
378
379	<	public void testPeek(){
379	>	/**
380	>	* peek returns null
381	>	*/
382	>	public void testPeek() {
383		SynchronousQueue q = new SynchronousQueue();
384	<	assertNull(q.peek());
384	>	assertNull(q.peek());
385		}
386
387	<	public void testElement(){
387	>	/**
388	>	* element throws NSEE
389	>	*/
390	>	public void testElement() {
391		SynchronousQueue q = new SynchronousQueue();
392		try {
393		q.element();
394	<	fail("no such element");
395	<	}
275	<	catch (NoSuchElementException success) {}
394	>	shouldThrow();
395	>	} catch (NoSuchElementException success) {}
396		}
397
398	<	public void testRemove(){
398	>	/**
399	>	* remove throws NSEE if no active taker
400	>	*/
401	>	public void testRemove() {
402		SynchronousQueue q = new SynchronousQueue();
403		try {
404		q.remove();
405	<	fail("remove should throw");
406	<	} catch (NoSuchElementException success){
284	<	}
405	>	shouldThrow();
406	>	} catch (NoSuchElementException success) {}
407		}
408
409	<	public void testRemoveElement(){
409	>	/**
410	>	* remove(x) returns false
411	>	*/
412	>	public void testRemoveElement() {
413		SynchronousQueue q = new SynchronousQueue();
414	<	for (int i = 1; i < N; i+=2) {
290	<	assertFalse(q.remove(new Integer(i)));
291	<	}
414	>	assertFalse(q.remove(zero));
415		assertTrue(q.isEmpty());
416		}
417	<
418	<	public void testContains(){
419	<	SynchronousQueue q = new SynchronousQueue();
420	<	for (int i = 0; i < N; ++i) {
421	<	assertFalse(q.contains(new Integer(i)));
422	<	}
417	>
418	>	/**
419	>	* contains returns false
420	>	*/
421	>	public void testContains() {
422	>	SynchronousQueue q = new SynchronousQueue();
423	>	assertFalse(q.contains(zero));
424		}
425
426	<	public void testClear(){
426	>	/**
427	>	* clear ensures isEmpty
428	>	*/
429	>	public void testClear() {
430		SynchronousQueue q = new SynchronousQueue();
431		q.clear();
432		assertTrue(q.isEmpty());
433		}
434
435	<	public void testContainsAll(){
435	>	/**
436	>	* containsAll returns false unless empty
437	>	*/
438	>	public void testContainsAll() {
439		SynchronousQueue q = new SynchronousQueue();
440		Integer[] empty = new Integer[0];
441	<	Integer[] ints = new Integer[1]; ints[0] = new Integer(0);
442	<	//        assertTrue(q.containsAll(Arrays.asList(empty)));
441	>	assertTrue(q.containsAll(Arrays.asList(empty)));
442	>	Integer[] ints = new Integer[1]; ints[0] = zero;
443		assertFalse(q.containsAll(Arrays.asList(ints)));
444		}
445
446	<	public void testRetainAll(){
446	>	/**
447	>	* retainAll returns false
448	>	*/
449	>	public void testRetainAll() {
450		SynchronousQueue q = new SynchronousQueue();
451		Integer[] empty = new Integer[0];
452	<	Integer[] ints = new Integer[1]; ints[0] = new Integer(0);
453	<	q.retainAll(Arrays.asList(ints));
454	<	//        assertTrue(q.containsAll(Arrays.asList(empty)));
322	<	assertFalse(q.containsAll(Arrays.asList(ints)));
452	>	assertFalse(q.retainAll(Arrays.asList(empty)));
453	>	Integer[] ints = new Integer[1]; ints[0] = zero;
454	>	assertFalse(q.retainAll(Arrays.asList(ints)));
455		}
456
457	<	public void testRemoveAll(){
457	>	/**
458	>	* removeAll returns false
459	>	*/
460	>	public void testRemoveAll() {
461		SynchronousQueue q = new SynchronousQueue();
462		Integer[] empty = new Integer[0];
463	<	Integer[] ints = new Integer[1]; ints[0] = new Integer(0);
464	<	q.removeAll(Arrays.asList(ints));
330	<	//        assertTrue(q.containsAll(Arrays.asList(empty)));
463	>	assertFalse(q.removeAll(Arrays.asList(empty)));
464	>	Integer[] ints = new Integer[1]; ints[0] = zero;
465		assertFalse(q.containsAll(Arrays.asList(ints)));
466		}
467
468
469	<	public void testToArray(){
469	>	/**
470	>	* toArray is empty
471	>	*/
472	>	public void testToArray() {
473		SynchronousQueue q = new SynchronousQueue();
474	<	Object[] o = q.toArray();
474	>	Object[] o = q.toArray();
475		assertEquals(o.length, 0);
476		}
477
478	<	public void testToArray2(){
478	>	/**
479	>	* toArray(a) is nulled at position 0
480	>	*/
481	>	public void testToArray2() {
482		SynchronousQueue q = new SynchronousQueue();
483	<	Integer[] ints = new Integer[1];
483	>	Integer[] ints = new Integer[1];
484		assertNull(ints[0]);
485		}
486	<
487	<	public void testIterator(){
486	>
487	>	/**
488	>	* toArray(null) throws NPE
489	>	*/
490	>	public void testToArray_BadArg() {
491		SynchronousQueue q = new SynchronousQueue();
492	<	Iterator it = q.iterator();
492	>	try {
493	>	Object o[] = q.toArray(null);
494	>	shouldThrow();
495	>	} catch (NullPointerException success) {}
496	>	}
497	>
498	>
499	>	/**
500	>	* iterator does not traverse any elements
501	>	*/
502	>	public void testIterator() {
503	>	SynchronousQueue q = new SynchronousQueue();
504	>	Iterator it = q.iterator();
505		assertFalse(it.hasNext());
506		try {
507		Object x = it.next();
508	<	fail("should throw");
509	<	}
355	<	catch (NoSuchElementException success) {}
508	>	shouldThrow();
509	>	} catch (NoSuchElementException success) {}
510		}
511
512	<	public void testIteratorRemove(){
512	>	/**
513	>	* iterator remove throws ISE
514	>	*/
515	>	public void testIteratorRemove() {
516		SynchronousQueue q = new SynchronousQueue();
517	<	Iterator it = q.iterator();
517	>	Iterator it = q.iterator();
518		try {
519		it.remove();
520	<	fail("should throw");
521	<	}
365	<	catch (IllegalStateException success) {}
520	>	shouldThrow();
521	>	} catch (IllegalStateException success) {}
522		}
523
524	<	public void testToString(){
524	>	/**
525	>	* toString returns a non-null string
526	>	*/
527	>	public void testToString() {
528		SynchronousQueue q = new SynchronousQueue();
529		String s = q.toString();
530	<	assertTrue(s != null);
531	<	}
530	>	assertNotNull(s);
531	>	}
532
533
534	+	/**
535	+	* offer transfers elements across Executor tasks
536	+	*/
537		public void testOfferInExecutor() {
538		final SynchronousQueue q = new SynchronousQueue();
539		ExecutorService executor = Executors.newFixedThreadPool(2);
378	–	final Integer one = new Integer(1);
540
541	<	executor.execute(new Runnable() {
542	<	public void run() {
541	>	executor.execute(new CheckedRunnable() {
542	>	public void realRun() throws InterruptedException {
543		assertFalse(q.offer(one));
544	<	try {
545	<	assertTrue(q.offer(one, MEDIUM_DELAY_MS * 2, TimeUnit.MILLISECONDS));
546	<	assertEquals(0, q.remainingCapacity());
547	<	}
548	<	catch (InterruptedException e) {
549	<	fail("should not be interrupted");
550	<	}
551	<	}
552	<	});
544	>	assertTrue(q.offer(one, MEDIUM_DELAY_MS, MILLISECONDS));
545	>	assertEquals(0, q.remainingCapacity());
546	>	}});
547	>
548	>	executor.execute(new CheckedRunnable() {
549	>	public void realRun() throws InterruptedException {
550	>	Thread.sleep(SMALL_DELAY_MS);
551	>	assertSame(one, q.take());
552	>	}});
553	>
554	>	joinPool(executor);
555	>	}
556	>
557	>	/**
558	>	* poll retrieves elements across Executor threads
559	>	*/
560	>	public void testPollInExecutor() {
561	>	final SynchronousQueue q = new SynchronousQueue();
562	>	ExecutorService executor = Executors.newFixedThreadPool(2);
563	>	executor.execute(new CheckedRunnable() {
564	>	public void realRun() throws InterruptedException {
565	>	assertNull(q.poll());
566	>	assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
567	>	assertTrue(q.isEmpty());
568	>	}});
569
570	<	executor.execute(new Runnable() {
571	<	public void run() {
572	<	try {
573	<	Thread.sleep(MEDIUM_DELAY_MS);
574	<	assertEquals(one, q.take());
398	<	}
399	<	catch (InterruptedException e) {
400	<	fail("should not be interrupted");
401	<	}
402	<	}
403	<	});
404	<
405	<	executor.shutdown();
570	>	executor.execute(new CheckedRunnable() {
571	>	public void realRun() throws InterruptedException {
572	>	Thread.sleep(SHORT_DELAY_MS);
573	>	q.put(one);
574	>	}});
575
576	+	joinPool(executor);
577		}
578
579	<	public void testPollInExecutor() {
579	>	/**
580	>	* a deserialized serialized queue is usable
581	>	*/
582	>	public void testSerialization() throws Exception {
583	>	SynchronousQueue q = new SynchronousQueue();
584	>	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
585	>	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
586	>	out.writeObject(q);
587	>	out.close();
588
589	<	final SynchronousQueue q = new SynchronousQueue();
589	>	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
590	>	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
591	>	SynchronousQueue r = (SynchronousQueue)in.readObject();
592	>	assertEquals(q.size(), r.size());
593	>	while (!q.isEmpty())
594	>	assertEquals(q.remove(), r.remove());
595	>	}
596
597	<	ExecutorService executor = Executors.newFixedThreadPool(2);
597	>	/**
598	>	* drainTo(null) throws NPE
599	>	*/
600	>	public void testDrainToNull() {
601	>	SynchronousQueue q = new SynchronousQueue();
602	>	try {
603	>	q.drainTo(null);
604	>	shouldThrow();
605	>	} catch (NullPointerException success) {}
606	>	}
607
608	<	executor.execute(new Runnable() {
609	<	public void run() {
610	<	assertNull(q.poll());
611	<	try {
612	<	assertTrue(null != q.poll(MEDIUM_DELAY_MS * 2, TimeUnit.MILLISECONDS));
613	<	assertTrue(q.isEmpty());
614	<	}
615	<	catch (InterruptedException e) {
616	<	fail("should not be interrupted");
617	<	}
425	<	}
426	<	});
608	>	/**
609	>	* drainTo(this) throws IAE
610	>	*/
611	>	public void testDrainToSelf() {
612	>	SynchronousQueue q = new SynchronousQueue();
613	>	try {
614	>	q.drainTo(q);
615	>	shouldThrow();
616	>	} catch (IllegalArgumentException success) {}
617	>	}
618
619	<	executor.execute(new Runnable() {
620	<	public void run() {
621	<	try {
622	<	Thread.sleep(MEDIUM_DELAY_MS);
623	<	q.put(new Integer(1));
624	<	}
625	<	catch (InterruptedException e) {
626	<	fail("should not be interrupted");
627	<	}
628	<	}
629	<	});
630	<
631	<	executor.shutdown();
619	>	/**
620	>	* drainTo(c) of empty queue doesn't transfer elements
621	>	*/
622	>	public void testDrainTo() {
623	>	SynchronousQueue q = new SynchronousQueue();
624	>	ArrayList l = new ArrayList();
625	>	q.drainTo(l);
626	>	assertEquals(q.size(), 0);
627	>	assertEquals(l.size(), 0);
628	>	}
629	>
630	>	/**
631	>	* drainTo empties queue, unblocking a waiting put.
632	>	*/
633	>	public void testDrainToWithActivePut() throws InterruptedException {
634	>	final SynchronousQueue q = new SynchronousQueue();
635	>	Thread t = new Thread(new CheckedRunnable() {
636	>	public void realRun() throws InterruptedException {
637	>	q.put(new Integer(1));
638	>	}});
639
640	+	t.start();
641	+	ArrayList l = new ArrayList();
642	+	Thread.sleep(SHORT_DELAY_MS);
643	+	q.drainTo(l);
644	+	assertTrue(l.size() <= 1);
645	+	if (l.size() > 0)
646	+	assertEquals(l.get(0), new Integer(1));
647	+	t.join();
648	+	assertTrue(l.size() <= 1);
649		}
650
651	<	public void testSerialization() {
651	>	/**
652	>	* drainTo(null, n) throws NPE
653	>	*/
654	>	public void testDrainToNullN() {
655		SynchronousQueue q = new SynchronousQueue();
656		try {
657	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
658	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
659	<	out.writeObject(q);
660	<	out.close();
657	>	q.drainTo(null, 0);
658	>	shouldThrow();
659	>	} catch (NullPointerException success) {}
660	>	}
661
662	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
663	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
664	<	SynchronousQueue r = (SynchronousQueue)in.readObject();
665	<	assertEquals(q.size(), r.size());
666	<	while (!q.isEmpty())
667	<	assertEquals(q.remove(), r.remove());
668	<	} catch(Exception e){
669	<	fail("unexpected exception");
670	<	}
662	>	/**
663	>	* drainTo(this, n) throws IAE
664	>	*/
665	>	public void testDrainToSelfN() {
666	>	SynchronousQueue q = new SynchronousQueue();
667	>	try {
668	>	q.drainTo(q, 0);
669	>	shouldThrow();
670	>	} catch (IllegalArgumentException success) {}
671	>	}
672	>
673	>	/**
674	>	* drainTo(c, n) empties up to n elements of queue into c
675	>	*/
676	>	public void testDrainToN() throws InterruptedException {
677	>	final SynchronousQueue q = new SynchronousQueue();
678	>	Thread t1 = new Thread(new CheckedRunnable() {
679	>	public void realRun() throws InterruptedException {
680	>	q.put(one);
681	>	}});
682	>
683	>	Thread t2 = new Thread(new CheckedRunnable() {
684	>	public void realRun() throws InterruptedException {
685	>	q.put(two);
686	>	}});
687	>
688	>	t1.start();
689	>	t2.start();
690	>	ArrayList l = new ArrayList();
691	>	Thread.sleep(SHORT_DELAY_MS);
692	>	q.drainTo(l, 1);
693	>	assertEquals(1, l.size());
694	>	q.drainTo(l, 1);
695	>	assertEquals(2, l.size());
696	>	assertTrue(l.contains(one));
697	>	assertTrue(l.contains(two));
698	>	t1.join();
699	>	t2.join();
700		}
701
702		}

Diff Legend

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