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.27 by jsr166, Thu Oct 28 17:57:26 2010 UTC

#	Line 2 | Line 2
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.
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		/**
#	Line 27 | Line 42 | public class SynchronousQueueTest extend
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(zero));
59		}
#	Line 36 | Line 62 | public class SynchronousQueueTest extend
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		* add(null) throws NPE
74		*/
75		public void testAddNull() {
76	<	try {
76	>	try {
77		SynchronousQueue q = new SynchronousQueue();
78		q.add(null);
79		shouldThrow();
80	<	} catch (NullPointerException success) { }
80	>	} catch (NullPointerException success) {}
81		}
82
83		/**
#	Line 66 | Line 92 | public class SynchronousQueueTest extend
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(one);
99		shouldThrow();
100	<	} catch (IllegalStateException success){
75	<	}
100	>	} catch (IllegalStateException success) {}
101		}
102
103		/**
#	Line 83 | Line 108 | public class SynchronousQueueTest extend
108		SynchronousQueue q = new SynchronousQueue();
109		q.addAll(null);
110		shouldThrow();
111	<	}
87	<	catch (NullPointerException success) {}
111	>	} catch (NullPointerException success) {}
112		}
113
114		/**
#	Line 95 | Line 119 | public class SynchronousQueueTest extend
119		SynchronousQueue q = new SynchronousQueue();
120		q.addAll(q);
121		shouldThrow();
122	<	}
99	<	catch (IllegalArgumentException success) {}
122	>	} catch (IllegalArgumentException success) {}
123		}
124
125		/**
#	Line 108 | Line 131 | public class SynchronousQueueTest extend
131		Integer[] ints = new Integer[1];
132		q.addAll(Arrays.asList(ints));
133		shouldThrow();
134	<	}
112	<	catch (NullPointerException success) {}
134	>	} catch (NullPointerException success) {}
135		}
136	+
137		/**
138		* addAll throws ISE if no active taker
139		*/
#	Line 122 | Line 145 | public class SynchronousQueueTest extend
145		ints[i] = new Integer(i);
146		q.addAll(Arrays.asList(ints));
147		shouldThrow();
148	<	}
126	<	catch (IllegalStateException success) {}
148	>	} catch (IllegalStateException success) {}
149		}
150
151		/**
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	<	}
138	<	catch (NullPointerException success){
139	<	}
140	<	catch (InterruptedException ie) {
141	<	unexpectedException();
142	<	}
159	>	} catch (NullPointerException success) {}
160		}
161
162		/**
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(zero);
171	<	threadShouldThrow();
172	<	} catch (InterruptedException ie){
173	<	}
174	<	}});
175	<	t.start();
159	<	try {
160	<	Thread.sleep(SHORT_DELAY_MS);
161	<	t.interrupt();
162	<	t.join();
163	<	}
164	<	catch (InterruptedException ie) {
165	<	unexpectedException();
166	<	}
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	<	* put blocks waiting for take
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;
180	<	q.put(new Object());
181	<	++added;
182	<	q.put(new Object());
183	<	++added;
184	<	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;
186	–	threadShouldThrow();
187	–	} catch (InterruptedException e){
188	–	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();
199	<	} catch (Exception e){
200	<	unexpectedException();
201	<	}
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		* 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){}
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	>	* 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	<
255	<	try {
256	<	t.start();
257	<	Thread.sleep(SMALL_DELAY_MS);
258	<	t.interrupt();
259	<	t.join();
260	<	} catch (Exception e){
261	<	unexpectedException();
262	<	}
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
281		/**
282		* take blocks interruptibly when empty
283		*/
284	<	public void testTakeFromEmpty() {
285	<	final SynchronousQueue q = new SynchronousQueue();
286	<	Thread t = new Thread(new Runnable() {
287	<	public void run() {
288	<	try {
289	<	q.take();
290	<	threadShouldThrow();
291	<	} catch (InterruptedException success){ }
292	<	}
293	<	});
294	<	try {
245	<	t.start();
246	<	Thread.sleep(SHORT_DELAY_MS);
247	<	t.interrupt();
248	<	t.join();
249	<	} catch (Exception e){
250	<	unexpectedException();
251	<	}
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		/**
#	Line 256 | Line 299 | public class SynchronousQueueTest extend
299		*/
300		public void testPoll() {
301		SynchronousQueue q = new SynchronousQueue();
302	<	assertNull(q.poll());
302	>	assertNull(q.poll());
303		}
304
305		/**
306		* timed pool with zero timeout times out if no active taker
307		*/
308	<	public void testTimedPoll0() {
309	<	try {
310	<	SynchronousQueue q = new SynchronousQueue();
268	<	assertNull(q.poll(0, TimeUnit.MILLISECONDS));
269	<	} catch (InterruptedException e){
270	<	unexpectedException();
271	<	}
308	>	public void testTimedPoll0() throws InterruptedException {
309	>	SynchronousQueue q = new SynchronousQueue();
310	>	assertNull(q.poll(0, MILLISECONDS));
311		}
312
313		/**
314		* timed pool with nonzero timeout times out if no active taker
315		*/
316	<	public void testTimedPoll() {
317	<	try {
318	<	SynchronousQueue q = new SynchronousQueue();
280	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
281	<	} catch (InterruptedException e){
282	<	unexpectedException();
283	<	}
316	>	public void testTimedPoll() throws InterruptedException {
317	>	SynchronousQueue q = new SynchronousQueue();
318	>	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
319		}
320
321		/**
322		* Interrupted timed poll throws InterruptedException instead of
323		* returning timeout status
324		*/
325	<	public void testInterruptedTimedPoll() {
326	<	Thread t = new Thread(new Runnable() {
327	<	public void run() {
328	<	try {
329	<	SynchronousQueue q = new SynchronousQueue();
330	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
331	<	} catch (InterruptedException success){
332	<	}
333	<	}});
334	<	t.start();
335	<	try {
301	<	Thread.sleep(SHORT_DELAY_MS);
302	<	t.interrupt();
303	<	t.join();
304	<	}
305	<	catch (InterruptedException ie) {
306	<	unexpectedException();
307	<	}
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	<	*  timed poll before a delayed offer fails; after offer succeeds;
340	<	*  on interruption throws
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));
348	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
349	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
350	<	threadShouldThrow();
351	<	} catch (InterruptedException success) { }
352	<	}
353	<	});
354	<	try {
355	<	t.start();
356	<	Thread.sleep(SMALL_DELAY_MS);
357	<	assertTrue(q.offer(zero, SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
358	<	t.interrupt();
359	<	t.join();
360	<	} catch (Exception e){
361	<	unexpectedException();
362	<	}
363	<	}
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		/**
#	Line 340 | Line 381 | public class SynchronousQueueTest extend
381		*/
382		public void testPeek() {
383		SynchronousQueue q = new SynchronousQueue();
384	<	assertNull(q.peek());
384	>	assertNull(q.peek());
385		}
386
387		/**
#	Line 351 | Line 392 | public class SynchronousQueueTest extend
392		try {
393		q.element();
394		shouldThrow();
395	<	}
355	<	catch (NoSuchElementException success) {}
395	>	} catch (NoSuchElementException success) {}
396		}
397
398		/**
#	Line 363 | Line 403 | public class SynchronousQueueTest extend
403		try {
404		q.remove();
405		shouldThrow();
406	<	} catch (NoSuchElementException success){
367	<	}
406	>	} catch (NoSuchElementException success) {}
407		}
408
409		/**
#	Line 375 | Line 414 | public class SynchronousQueueTest extend
414		assertFalse(q.remove(zero));
415		assertTrue(q.isEmpty());
416		}
417	<
417	>
418		/**
419		* contains returns false
420		*/
#	Line 432 | Line 471 | public class SynchronousQueueTest extend
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
#	Line 441 | Line 480 | public class SynchronousQueueTest extend
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		* toArray(null) throws NPE
489		*/
490		public void testToArray_BadArg() {
491	<	try {
492	<	SynchronousQueue q = new SynchronousQueue();
493	<	Object o[] = q.toArray(null);
494	<	shouldThrow();
495	<	} catch(NullPointerException success){}
491	>	SynchronousQueue q = new SynchronousQueue();
492	>	try {
493	>	Object o[] = q.toArray(null);
494	>	shouldThrow();
495	>	} catch (NullPointerException success) {}
496		}
497
498
#	Line 462 | Line 501 | public class SynchronousQueueTest extend
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	<	}
471	<	catch (NoSuchElementException success) {}
509	>	} catch (NoSuchElementException success) {}
510		}
511
512		/**
#	Line 476 | Line 514 | public class SynchronousQueueTest extend
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	<	}
484	<	catch (IllegalStateException success) {}
521	>	} catch (IllegalStateException success) {}
522		}
523
524		/**
#	Line 491 | Line 528 | public class SynchronousQueueTest extend
528		SynchronousQueue q = new SynchronousQueue();
529		String s = q.toString();
530		assertNotNull(s);
531	<	}
531	>	}
532
533
534		/**
#	Line 500 | Line 537 | public class SynchronousQueueTest extend
537		public void testOfferInExecutor() {
538		final SynchronousQueue q = new SynchronousQueue();
539		ExecutorService executor = Executors.newFixedThreadPool(2);
503	–	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
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	–
554		joinPool(executor);
531	–
555		}
556
557		/**
#	Line 537 | Line 560 | public class SynchronousQueueTest extend
560		public void testPollInExecutor() {
561		final SynchronousQueue q = new SynchronousQueue();
562		ExecutorService executor = Executors.newFixedThreadPool(2);
563	<	executor.execute(new Runnable() {
564	<	public void run() {
565	<	threadAssertNull(q.poll());
566	<	try {
567	<	threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
568	<	threadAssertTrue(q.isEmpty());
569	<	}
570	<	catch (InterruptedException e) {
571	<	threadUnexpectedException();
572	<	}
573	<	}
574	<	});
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
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() {
582	>	public void testSerialization() throws Exception {
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());
591	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
592	<	SynchronousQueue r = (SynchronousQueue)in.readObject();
593	<	assertEquals(q.size(), r.size());
594	<	while (!q.isEmpty())
584	<	assertEquals(q.remove(), r.remove());
585	<	} catch(Exception e){
586	<	unexpectedException();
587	<	}
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		* drainTo(null) throws NPE
599	<	*/
599	>	*/
600		public void testDrainToNull() {
601		SynchronousQueue q = new SynchronousQueue();
602		try {
603		q.drainTo(null);
604		shouldThrow();
605	<	} catch(NullPointerException success) {
599	<	}
605	>	} catch (NullPointerException success) {}
606		}
607
608		/**
609		* drainTo(this) throws IAE
610	<	*/
610	>	*/
611		public void testDrainToSelf() {
612		SynchronousQueue q = new SynchronousQueue();
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	<	*/
621	>	*/
622		public void testDrainTo() {
623		SynchronousQueue q = new SynchronousQueue();
624		ArrayList l = new ArrayList();
#	Line 624 | Line 629 | public class SynchronousQueueTest extend
629
630		/**
631		* drainTo empties queue, unblocking a waiting put.
632	<	*/
633	<	public void testDrainToWithActivePut() {
632	>	*/
633	>	public void testDrainToWithActivePut() throws InterruptedException {
634		final SynchronousQueue q = new SynchronousQueue();
635	<	Thread t = new Thread(new Runnable() {
636	<	public void run() {
637	<	try {
638	<	q.put(new Integer(1));
639	<	} catch (InterruptedException ie){
640	<	threadUnexpectedException();
641	<	}
642	<	}
643	<	});
644	<	try {
645	<	t.start();
646	<	ArrayList l = new ArrayList();
647	<	Thread.sleep(SHORT_DELAY_MS);
648	<	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	<	} catch(Exception e){
650	<	unexpectedException();
651	<	}
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	<	*/
653	>	*/
654		public void testDrainToNullN() {
655		SynchronousQueue q = new SynchronousQueue();
656		try {
657		q.drainTo(null, 0);
658		shouldThrow();
659	<	} catch(NullPointerException success) {
663	<	}
659	>	} catch (NullPointerException success) {}
660		}
661
662		/**
663		* drainTo(this, n) throws IAE
664	<	*/
664	>	*/
665		public void testDrainToSelfN() {
666		SynchronousQueue q = new SynchronousQueue();
667		try {
668		q.drainTo(q, 0);
669		shouldThrow();
670	<	} catch(IllegalArgumentException success) {
675	<	}
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() {
675	>	*/
676	>	public void testDrainToN() throws InterruptedException {
677		final SynchronousQueue q = new SynchronousQueue();
678	<	Thread t1 = new Thread(new Runnable() {
679	<	public void run() {
680	<	try {
681	<	q.put(one);
682	<	} catch (InterruptedException ie){
683	<	threadUnexpectedException();
684	<	}
685	<	}
686	<	});
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	<	});
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	<	try {
689	<	t1.start();
690	<	t2.start();
691	<	ArrayList l = new ArrayList();
692	<	Thread.sleep(SHORT_DELAY_MS);
693	<	q.drainTo(l, 1);
694	<	assertTrue(l.size() == 1);
695	<	q.drainTo(l, 1);
696	<	assertTrue(l.size() == 2);
697	<	assertTrue(l.contains(one));
698	<	assertTrue(l.contains(two));
699	<	t1.join();
714	<	t2.join();
715	<	} catch(Exception e){
716	<	unexpectedException();
717	<	}
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
720	–
702		}

Diff Legend

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