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.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 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	>	* 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		/**
62	<	*
62	>	* offer(null) throws NPE
63		*/
64		public void testOfferNull() {
65	<	try {
65	>	try {
66		SynchronousQueue q = new SynchronousQueue();
67		q.offer(null);
68		shouldThrow();
69	<	} catch (NullPointerException success) { }
69	>	} catch (NullPointerException success) {}
70		}
71
72		/**
73	<	*
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	>	/**
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		/**
92	<	*
92	>	* add throws ISE if no active taker
93		*/
94		public void testAdd() {
95	<	try {
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		/**
104	<	*
104	>	* addAll(null) throws NPE
105		*/
106		public void testAddAll1() {
107		try {
108		SynchronousQueue q = new SynchronousQueue();
109		q.addAll(null);
110		shouldThrow();
111	<	}
74	<	catch (NullPointerException success) {}
111	>	} catch (NullPointerException success) {}
112		}
113	+
114		/**
115	<	*
115	>	* addAll(this) throws IAE
116	>	*/
117	>	public void testAddAllSelf() {
118	>	try {
119	>	SynchronousQueue q = new SynchronousQueue();
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 {
#	Line 82 | Line 131 | public class SynchronousQueueTest extend
131		Integer[] ints = new Integer[1];
132		q.addAll(Arrays.asList(ints));
133		shouldThrow();
134	<	}
86	<	catch (NullPointerException success) {}
134	>	} catch (NullPointerException success) {}
135		}
136	+
137		/**
138	<	*
138	>	* addAll throws ISE if no active taker
139		*/
140		public void testAddAll4() {
141		try {
#	Line 96 | Line 145 | public class SynchronousQueueTest extend
145		ints[i] = new Integer(i);
146		q.addAll(Arrays.asList(ints));
147		shouldThrow();
148	<	}
100	<	catch (IllegalStateException success) {}
148	>	} catch (IllegalStateException success) {}
149		}
150
151		/**
152	<	*
152	>	* put(null) throws NPE
153		*/
154	<	public void testPutNull() {
155	<	try {
154	>	public void testPutNull() throws InterruptedException {
155	>	try {
156		SynchronousQueue q = new SynchronousQueue();
157		q.put(null);
158		shouldThrow();
159	<	}
112	<	catch (NullPointerException success){
113	<	}
114	<	catch (InterruptedException ie) {
115	<	unexpectedException();
116	<	}
159	>	} catch (NullPointerException success) {}
160		}
161
162		/**
163	<	*
163	>	* put blocks interruptibly if no active taker
164		*/
165	<	public void testBlockingPut() {
166	<	Thread t = new Thread(new Runnable() {
167	<	public void run() {
168	<	try {
169	<	SynchronousQueue q = new SynchronousQueue();
170	<	q.put(new Integer(0));
171	<	threadShouldThrow();
172	<	} catch (InterruptedException ie){
173	<	}
174	<	}});
175	<	t.start();
133	<	try {
134	<	Thread.sleep(SHORT_DELAY_MS);
135	<	t.interrupt();
136	<	t.join();
137	<	}
138	<	catch (InterruptedException ie) {
139	<	unexpectedException();
140	<	}
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		/**
179	<	*
179	>	* put blocks waiting for take
180		*/
181	<	public void testPutWithTake() {
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;
154	<	q.put(new Object());
155	<	++added;
156	<	q.put(new Object());
157	<	++added;
158	<	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;
160	–	threadShouldThrow();
161	–	} catch (InterruptedException e){
162	–	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();
173	<	} catch (Exception e){
174	<	unexpectedException();
175	<	}
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		/**
205	<	*
205	>	* timed offer times out if elements not taken
206		*/
207	<	public void testTimedOffer() {
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	<	threadAssertFalse(q.offer(new Object(), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
214	<	q.offer(new Object(), LONG_DELAY_MS, TimeUnit.MILLISECONDS);
215	<	threadShouldThrow();
216	<	} catch (InterruptedException success){}
217	<	}
218	<	});
193	<
194	<	try {
195	<	t.start();
196	<	Thread.sleep(SMALL_DELAY_MS);
197	<	t.interrupt();
198	<	t.join();
199	<	} catch (Exception e){
200	<	unexpectedException();
201	<	}
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	+	t.start();
232	+	Thread.sleep(SHORT_DELAY_MS);
233	+	t.interrupt();
234	+	t.join();
235	+	}
236
237		/**
238	<	*
238	>	* put blocks waiting for take
239		*/
240	<	public void testTakeFromEmpty() {
241	<	final SynchronousQueue q = new SynchronousQueue();
242	<	Thread t = new Thread(new Runnable() {
243	<	public void run() {
244	<	try {
245	<	q.take();
246	<	threadShouldThrow();
247	<	} catch (InterruptedException success){ }
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	<	unexpectedException();
225	<	}
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	<	*
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	>
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		/**
306	<	*
306	>	* timed pool with zero timeout times out if no active taker
307		*/
308	<	public void testTimedPoll0() {
309	<	try {
310	<	SynchronousQueue q = new SynchronousQueue();
242	<	assertNull(q.poll(0, TimeUnit.MILLISECONDS));
243	<	} catch (InterruptedException e){
244	<	unexpectedException();
245	<	}
308	>	public void testTimedPoll0() throws InterruptedException {
309	>	SynchronousQueue q = new SynchronousQueue();
310	>	assertNull(q.poll(0, MILLISECONDS));
311		}
312
313		/**
314	<	*
314	>	* timed pool with nonzero timeout times out if no active taker
315		*/
316	<	public void testTimedPoll() {
317	<	try {
318	<	SynchronousQueue q = new SynchronousQueue();
254	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
255	<	} catch (InterruptedException e){
256	<	unexpectedException();
257	<	}
316	>	public void testTimedPoll() throws InterruptedException {
317	>	SynchronousQueue q = new SynchronousQueue();
318	>	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
319		}
320
321		/**
322	<	*
323	<	*/
324	<	public void testInterruptedTimedPoll() {
325	<	Thread t = new Thread(new Runnable() {
326	<	public void run() {
327	<	try {
328	<	SynchronousQueue q = new SynchronousQueue();
329	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
330	<	} catch (InterruptedException success){
331	<	}
332	<	}});
333	<	t.start();
334	<	try {
335	<	Thread.sleep(SHORT_DELAY_MS);
275	<	t.interrupt();
276	<	t.join();
277	<	}
278	<	catch (InterruptedException ie) {
279	<	unexpectedException();
280	<	}
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 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	<	*
339	>	* Interrupted timed poll throws InterruptedException instead of
340	>	* returning timeout status
341		*/
342	<	public void testTimedPollWithOffer() {
343	<	final SynchronousQueue q = new SynchronousQueue();
344	<	Thread t = new Thread(new Runnable() {
345	<	public void run() {
346	<	try {
347	<	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
292	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
293	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
294	<	threadShouldThrow();
295	<	} catch (InterruptedException success) { }
296	<	}
297	<	});
298	<	try {
299	<	t.start();
300	<	Thread.sleep(SMALL_DELAY_MS);
301	<	assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
302	<	t.interrupt();
303	<	t.join();
304	<	} catch (Exception e){
305	<	unexpectedException();
306	<	}
307	<	}
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	<	*
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	>	/**
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		/**
388	<	*
388	>	* element throws NSEE
389		*/
390		public void testElement() {
391		SynchronousQueue q = new SynchronousQueue();
392		try {
393		q.element();
394		shouldThrow();
395	<	}
327	<	catch (NoSuchElementException success) {}
395	>	} catch (NoSuchElementException success) {}
396		}
397
398		/**
399	<	*
399	>	* remove throws NSEE if no active taker
400		*/
401		public void testRemove() {
402		SynchronousQueue q = new SynchronousQueue();
403		try {
404		q.remove();
405		shouldThrow();
406	<	} catch (NoSuchElementException success){
339	<	}
406	>	} catch (NoSuchElementException success) {}
407		}
408
409		/**
410	<	*
410	>	* remove(x) returns false
411		*/
412		public void testRemoveElement() {
413		SynchronousQueue q = new SynchronousQueue();
414	<	assertFalse(q.remove(new Integer(0)));
414	>	assertFalse(q.remove(zero));
415		assertTrue(q.isEmpty());
416		}
417	<
417	>
418		/**
419	<	*
419	>	* contains returns false
420		*/
421		public void testContains() {
422		SynchronousQueue q = new SynchronousQueue();
423	<	assertFalse(q.contains(new Integer(0)));
423	>	assertFalse(q.contains(zero));
424		}
425
426		/**
427	<	*
427	>	* clear ensures isEmpty
428		*/
429		public void testClear() {
430		SynchronousQueue q = new SynchronousQueue();
#	Line 366 | Line 433 | public class SynchronousQueueTest extend
433		}
434
435		/**
436	<	*
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);
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		/**
447	<	*
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	<	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		/**
458	<	*
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));
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		/**
470	<	*
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		/**
479	<	*
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	<
486	>
487		/**
488	<	*
488	>	* toArray(null) throws NPE
489	>	*/
490	>	public void testToArray_BadArg() {
491	>	SynchronousQueue q = new SynchronousQueue();
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();
504	>	Iterator it = q.iterator();
505		assertFalse(it.hasNext());
506		try {
507		Object x = it.next();
508		shouldThrow();
509	<	}
430	<	catch (NoSuchElementException success) {}
509	>	} catch (NoSuchElementException success) {}
510		}
511
512		/**
513	<	*
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		shouldThrow();
521	<	}
443	<	catch (IllegalStateException success) {}
521	>	} catch (IllegalStateException success) {}
522		}
523
524		/**
525	<	*
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	<	*
535	>	* offer transfers elements across Executor tasks
536		*/
537		public void testOfferInExecutor() {
538		final SynchronousQueue q = new SynchronousQueue();
539		ExecutorService executor = Executors.newFixedThreadPool(2);
462	–	final Integer one = new Integer(1);
540
541	<	executor.execute(new Runnable() {
542	<	public void run() {
543	<	threadAssertFalse(q.offer(one));
544	<	try {
545	<	threadAssertTrue(q.offer(one, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
546	<	threadAssertEquals(0, q.remainingCapacity());
547	<	}
548	<	catch (InterruptedException e) {
549	<	threadUnexpectedException();
550	<	}
551	<	}
552	<	});
541	>	executor.execute(new CheckedRunnable() {
542	>	public void realRun() throws InterruptedException {
543	>	assertFalse(q.offer(one));
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
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	–
554		joinPool(executor);
490	–
555		}
556
557		/**
558	<	*
558	>	* poll retrieves elements across Executor threads
559		*/
560		public void testPollInExecutor() {
497	–
561		final SynchronousQueue q = new SynchronousQueue();
499	–
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 CheckedRunnable() {
571	+	public void realRun() throws InterruptedException {
572	+	Thread.sleep(SHORT_DELAY_MS);
573	+	q.put(one);
574	+	}});
575
502	–	executor.execute(new Runnable() {
503	–	public void run() {
504	–	threadAssertNull(q.poll());
505	–	try {
506	–	threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
507	–	threadAssertTrue(q.isEmpty());
508	–	}
509	–	catch (InterruptedException e) {
510	–	threadUnexpectedException();
511	–	}
512	–	}
513	–	});
514	–
515	–	executor.execute(new Runnable() {
516	–	public void run() {
517	–	try {
518	–	Thread.sleep(SMALL_DELAY_MS);
519	–	q.put(new Integer(1));
520	–	}
521	–	catch (InterruptedException e) {
522	–	threadUnexpectedException();
523	–	}
524	–	}
525	–	});
526	–
576		joinPool(executor);
577	+	}
578	+
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	+	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		/**
598	<	*
598	>	* drainTo(null) throws NPE
599		*/
600	<	public void testSerialization() {
600	>	public void testDrainToNull() {
601		SynchronousQueue q = new SynchronousQueue();
602		try {
603	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
604	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
605	<	out.writeObject(q);
606	<	out.close();
607	<
608	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
609	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
610	<	SynchronousQueue r = (SynchronousQueue)in.readObject();
611	<	assertEquals(q.size(), r.size());
612	<	while (!q.isEmpty())
613	<	assertEquals(q.remove(), r.remove());
614	<	} catch(Exception e){
615	<	unexpectedException();
616	<	}
603	>	q.drainTo(null);
604	>	shouldThrow();
605	>	} catch (NullPointerException success) {}
606	>	}
607	>
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	>	/**
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	>	/**
652	>	* drainTo(null, n) throws NPE
653	>	*/
654	>	public void testDrainToNullN() {
655	>	SynchronousQueue q = new SynchronousQueue();
656	>	try {
657	>	q.drainTo(null, 0);
658	>	shouldThrow();
659	>	} catch (NullPointerException success) {}
660	>	}
661	>
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