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

Diff Legend

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