ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/DelayQueueTest.java

Comparing jsr166/src/test/tck/DelayQueueTest.java (file contents):
Revision 1.4 by dl, Sat Sep 20 18:20:07 2003 UTC vs.
Revision 1.17 by jsr166, Mon Nov 16 05:30:07 2009 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 11 | Line 12 | import java.util.concurrent.*;
12
13		public class DelayQueueTest extends JSR166TestCase {
14		public static void main(String[] args) {
15	<	junit.textui.TestRunner.run (suite());
15	>	junit.textui.TestRunner.run (suite());
16		}
17
18		public static Test suite() {
#	Line 21 | Line 22 | public class DelayQueueTest extends JSR1
22		private static final int NOCAP = Integer.MAX_VALUE;
23
24		/**
25	<	* A delayed implmentation for testing.
26	<	* Most Q/BQ tests use Pseudodelays, where delays are all elapsed
25	>	* A delayed implementation for testing.
26	>	* Most  tests use Pseudodelays, where delays are all elapsed
27		* (so, no blocking solely for delays) but are still ordered
28	<	*/
29	<	static class PDelay implements Delayed {
28	>	*/
29	>	static class PDelay implements Delayed {
30		int pseudodelay;
31		PDelay(int i) { pseudodelay = Integer.MIN_VALUE + i; }
32	<	public int compareTo(Object y) {
32	>	public int compareTo(PDelay y) {
33		int i = pseudodelay;
34		int j = ((PDelay)y).pseudodelay;
35		if (i < j) return -1;
#	Line 36 | Line 37 | public class DelayQueueTest extends JSR1
37		return 0;
38		}
39
40	<	public int compareTo(PDelay y) {
40	>	public int compareTo(Delayed y) {
41		int i = pseudodelay;
42		int j = ((PDelay)y).pseudodelay;
43		if (i < j) return -1;
#	Line 68 | Line 69 | public class DelayQueueTest extends JSR1
69		/**
70		* Delayed implementation that actually delays
71		*/
72	<	static class NanoDelay implements Delayed {
72	>	static class NanoDelay implements Delayed {
73		long trigger;
74	<	NanoDelay(long i) {
74	>	NanoDelay(long i) {
75		trigger = System.nanoTime() + i;
76		}
77	<	public int compareTo(Object y) {
77	>	public int compareTo(NanoDelay y) {
78		long i = trigger;
79		long j = ((NanoDelay)y).trigger;
80		if (i < j) return -1;
#	Line 81 | Line 82 | public class DelayQueueTest extends JSR1
82		return 0;
83		}
84
85	<	public int compareTo(NanoDelay y) {
85	>	public int compareTo(Delayed y) {
86		long i = trigger;
87		long j = ((NanoDelay)y).trigger;
88		if (i < j) return -1;
#	Line 118 | Line 119 | public class DelayQueueTest extends JSR1
119		private DelayQueue populatedQueue(int n) {
120		DelayQueue q = new DelayQueue();
121		assertTrue(q.isEmpty());
122	<	for(int i = n-1; i >= 0; i-=2)
122	>	for (int i = n-1; i >= 0; i-=2)
123		assertTrue(q.offer(new PDelay(i)));
124	<	for(int i = (n & 1); i < n; i+=2)
124	>	for (int i = (n & 1); i < n; i+=2)
125		assertTrue(q.offer(new PDelay(i)));
126		assertFalse(q.isEmpty());
127		assertEquals(NOCAP, q.remainingCapacity());
128		assertEquals(n, q.size());
129		return q;
130		}
131	<
131	>
132		/**
133	<	*
133	>	* A new queue has unbounded capacity
134		*/
135		public void testConstructor1() {
136		assertEquals(NOCAP, new DelayQueue().remainingCapacity());
137		}
138
139		/**
140	<	*
140	>	* Initializing from null Collection throws NPE
141		*/
142		public void testConstructor3() {
143		try {
#	Line 147 | Line 148 | public class DelayQueueTest extends JSR1
148		}
149
150		/**
151	<	*
151	>	* Initializing from Collection of null elements throws NPE
152		*/
153		public void testConstructor4() {
154		try {
#	Line 159 | Line 160 | public class DelayQueueTest extends JSR1
160		}
161
162		/**
163	<	*
163	>	* Initializing from Collection with some null elements throws NPE
164		*/
165		public void testConstructor5() {
166		try {
#	Line 173 | Line 174 | public class DelayQueueTest extends JSR1
174		}
175
176		/**
177	<	*
177	>	* Queue contains all elements of collection used to initialize
178		*/
179		public void testConstructor6() {
180		try {
#	Line 188 | Line 189 | public class DelayQueueTest extends JSR1
189		}
190
191		/**
192	<	*
192	>	* isEmpty is true before add, false after
193		*/
194		public void testEmpty() {
195		DelayQueue q = new DelayQueue();
#	Line 203 | Line 204 | public class DelayQueueTest extends JSR1
204		}
205
206		/**
207	<	*
207	>	* remainingCapacity does not change when elementa added or removed,
208	>	* but size does
209		*/
210		public void testRemainingCapacity() {
211		DelayQueue q = populatedQueue(SIZE);
#	Line 220 | Line 222 | public class DelayQueueTest extends JSR1
222		}
223
224		/**
225	<	*
225	>	* offer(null) throws NPE
226		*/
227		public void testOfferNull() {
228		try {
229		DelayQueue q = new DelayQueue();
230		q.offer(null);
231		shouldThrow();
232	<	} catch (NullPointerException success) { }
232	>	} catch (NullPointerException success) { }
233		}
234
235		/**
236	<	*
236	>	* add(null) throws NPE
237	>	*/
238	>	public void testAddNull() {
239	>	try {
240	>	DelayQueue q = new DelayQueue();
241	>	q.add(null);
242	>	shouldThrow();
243	>	} catch (NullPointerException success) { }
244	>	}
245	>
246	>	/**
247	>	* offer non-null succeeds
248		*/
249		public void testOffer() {
250		DelayQueue q = new DelayQueue();
#	Line 240 | Line 253 | public class DelayQueueTest extends JSR1
253		}
254
255		/**
256	<	*
256	>	* add succeeds
257		*/
258		public void testAdd() {
259		DelayQueue q = new DelayQueue();
#	Line 251 | Line 264 | public class DelayQueueTest extends JSR1
264		}
265
266		/**
267	<	*
267	>	* addAll(null) throws NPE
268		*/
269		public void testAddAll1() {
270		try {
#	Line 261 | Line 274 | public class DelayQueueTest extends JSR1
274		}
275		catch (NullPointerException success) {}
276		}
277	+
278	+
279	+	/**
280	+	* addAll(this) throws IAE
281	+	*/
282	+	public void testAddAllSelf() {
283	+	try {
284	+	DelayQueue q = populatedQueue(SIZE);
285	+	q.addAll(q);
286	+	shouldThrow();
287	+	}
288	+	catch (IllegalArgumentException success) {}
289	+	}
290	+
291		/**
292	<	*
292	>	* addAll of a collection with null elements throws NPE
293		*/
294		public void testAddAll2() {
295		try {
#	Line 274 | Line 301 | public class DelayQueueTest extends JSR1
301		catch (NullPointerException success) {}
302		}
303		/**
304	<	*
304	>	* addAll of a collection with any null elements throws NPE after
305	>	* possibly adding some elements
306		*/
307		public void testAddAll3() {
308		try {
#	Line 289 | Line 317 | public class DelayQueueTest extends JSR1
317		}
318
319		/**
320	<	*
320	>	* Queue contains all elements of successful addAll
321		*/
322		public void testAddAll5() {
323		try {
#	Line 307 | Line 335 | public class DelayQueueTest extends JSR1
335		}
336
337		/**
338	<	*
338	>	* put(null) throws NPE
339		*/
340		public void testPutNull() {
341		try {
342		DelayQueue q = new DelayQueue();
343		q.put(null);
344		shouldThrow();
345	<	}
346	<	catch (NullPointerException success){
347	<	}
345	>	}
346	>	catch (NullPointerException success) {
347	>	}
348		}
349
350		/**
351	<	*
351	>	* all elements successfully put are contained
352		*/
353		public void testPut() {
354		try {
#	Line 337 | Line 365 | public class DelayQueueTest extends JSR1
365		}
366
367		/**
368	<	*
368	>	* put doesn't block waiting for take
369		*/
370		public void testPutWithTake() {
371		final DelayQueue q = new DelayQueue();
#	Line 364 | Line 392 | public class DelayQueueTest extends JSR1
392		q.take();
393		t.interrupt();
394		t.join();
395	<	} catch (Exception e){
395	>	} catch (Exception e) {
396		unexpectedException();
397		}
398		}
399
400		/**
401	<	*
401	>	* timed offer does not time out
402		*/
403		public void testTimedOffer() {
404		final DelayQueue q = new DelayQueue();
#	Line 384 | Line 412 | public class DelayQueueTest extends JSR1
412		} finally { }
413		}
414		});
415	<
415	>
416		try {
417		t.start();
418		Thread.sleep(SMALL_DELAY_MS);
419		t.interrupt();
420		t.join();
421	<	} catch (Exception e){
421	>	} catch (Exception e) {
422		unexpectedException();
423		}
424		}
425
426		/**
427	<	*
427	>	* take retrieves elements in priority order
428		*/
429		public void testTake() {
430		try {
#	Line 404 | Line 432 | public class DelayQueueTest extends JSR1
432		for (int i = 0; i < SIZE; ++i) {
433		assertEquals(new PDelay(i), ((PDelay)q.take()));
434		}
435	<	} catch (InterruptedException e){
435	>	} catch (InterruptedException e) {
436		unexpectedException();
437	<	}
437	>	}
438		}
439
440		/**
441	<	*
441	>	* take blocks interruptibly when empty
442		*/
443		public void testTakeFromEmpty() {
444		final DelayQueue q = new DelayQueue();
#	Line 419 | Line 447 | public class DelayQueueTest extends JSR1
447		try {
448		q.take();
449		threadShouldThrow();
450	<	} catch (InterruptedException success){ }
450	>	} catch (InterruptedException success) { }
451		}
452		});
453		try {
#	Line 427 | Line 455 | public class DelayQueueTest extends JSR1
455		Thread.sleep(SHORT_DELAY_MS);
456		t.interrupt();
457		t.join();
458	<	} catch (Exception e){
458	>	} catch (Exception e) {
459		unexpectedException();
460		}
461		}
462
463		/**
464	<	*
464	>	* Take removes existing elements until empty, then blocks interruptibly
465		*/
466		public void testBlockingTake() {
467		Thread t = new Thread(new Runnable() {
#	Line 445 | Line 473 | public class DelayQueueTest extends JSR1
473		}
474		q.take();
475		threadShouldThrow();
476	<	} catch (InterruptedException success){
477	<	}
476	>	} catch (InterruptedException success) {
477	>	}
478		}});
479		t.start();
480	<	try {
481	<	Thread.sleep(SHORT_DELAY_MS);
480	>	try {
481	>	Thread.sleep(SHORT_DELAY_MS);
482		t.interrupt();
483		t.join();
484		}
#	Line 461 | Line 489 | public class DelayQueueTest extends JSR1
489
490
491		/**
492	<	*
492	>	* poll succeeds unless empty
493		*/
494		public void testPoll() {
495		DelayQueue q = populatedQueue(SIZE);
#	Line 472 | Line 500 | public class DelayQueueTest extends JSR1
500		}
501
502		/**
503	<	*
503	>	* timed pool with zero timeout succeeds when non-empty, else times out
504		*/
505		public void testTimedPoll0() {
506		try {
#	Line 481 | Line 509 | public class DelayQueueTest extends JSR1
509		assertEquals(new PDelay(i), ((PDelay)q.poll(0, TimeUnit.MILLISECONDS)));
510		}
511		assertNull(q.poll(0, TimeUnit.MILLISECONDS));
512	<	} catch (InterruptedException e){
512	>	} catch (InterruptedException e) {
513		unexpectedException();
514	<	}
514	>	}
515		}
516
517		/**
518	<	*
518	>	* timed pool with nonzero timeout succeeds when non-empty, else times out
519		*/
520		public void testTimedPoll() {
521		try {
#	Line 496 | Line 524 | public class DelayQueueTest extends JSR1
524		assertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)));
525		}
526		assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
527	<	} catch (InterruptedException e){
527	>	} catch (InterruptedException e) {
528		unexpectedException();
529	<	}
529	>	}
530		}
531
532		/**
533	<	*
533	>	* Interrupted timed poll throws InterruptedException instead of
534	>	* returning timeout status
535		*/
536		public void testInterruptedTimedPoll() {
537		Thread t = new Thread(new Runnable() {
#	Line 513 | Line 542 | public class DelayQueueTest extends JSR1
542		threadAssertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)));
543		}
544		threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
545	<	} catch (InterruptedException success){
546	<	}
545	>	} catch (InterruptedException success) {
546	>	}
547		}});
548		t.start();
549	<	try {
550	<	Thread.sleep(SHORT_DELAY_MS);
549	>	try {
550	>	Thread.sleep(SHORT_DELAY_MS);
551		t.interrupt();
552		t.join();
553		}
#	Line 528 | Line 557 | public class DelayQueueTest extends JSR1
557		}
558
559		/**
560	<	*
560	>	*  timed poll before a delayed offer fails; after offer succeeds;
561	>	*  on interruption throws
562		*/
563		public void testTimedPollWithOffer() {
564		final DelayQueue q = new DelayQueue();
#	Line 539 | Line 569 | public class DelayQueueTest extends JSR1
569		q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
570		q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
571		threadFail("Should block");
572	<	} catch (InterruptedException success) { }
572	>	} catch (InterruptedException success) { }
573		}
574		});
575		try {
#	Line 548 | Line 578 | public class DelayQueueTest extends JSR1
578		assertTrue(q.offer(new PDelay(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
579		t.interrupt();
580		t.join();
581	<	} catch (Exception e){
581	>	} catch (Exception e) {
582		unexpectedException();
583		}
584	<	}
584	>	}
585
586
587		/**
588	<	*
588	>	* peek returns next element, or null if empty
589		*/
590		public void testPeek() {
591		DelayQueue q = populatedQueue(SIZE);
592		for (int i = 0; i < SIZE; ++i) {
593		assertEquals(new PDelay(i), ((PDelay)q.peek()));
594		q.poll();
595	<	assertTrue(q.peek() == null ||
596	<	i != ((PDelay)q.peek()).intValue());
595	>	if (q.isEmpty())
596	>	assertNull(q.peek());
597	>	else
598	>	assertTrue(i != ((PDelay)q.peek()).intValue());
599		}
600		assertNull(q.peek());
601		}
602
603		/**
604	<	*
604	>	* element returns next element, or throws NSEE if empty
605		*/
606		public void testElement() {
607		DelayQueue q = populatedQueue(SIZE);
#	Line 585 | Line 617 | public class DelayQueueTest extends JSR1
617		}
618
619		/**
620	<	*
620	>	* remove removes next element, or throws NSEE if empty
621		*/
622		public void testRemove() {
623		DelayQueue q = populatedQueue(SIZE);
#	Line 595 | Line 627 | public class DelayQueueTest extends JSR1
627		try {
628		q.remove();
629		shouldThrow();
630	<	} catch (NoSuchElementException success){
631	<	}
630	>	} catch (NoSuchElementException success) {
631	>	}
632		}
633
634		/**
635	<	*
635	>	* remove(x) removes x and returns true if present
636		*/
637		public void testRemoveElement() {
638		DelayQueue q = populatedQueue(SIZE);
#	Line 613 | Line 645 | public class DelayQueueTest extends JSR1
645		}
646		assertTrue(q.isEmpty());
647		}
648	<
648	>
649		/**
650	<	*
650	>	* contains(x) reports true when elements added but not yet removed
651		*/
652		public void testContains() {
653		DelayQueue q = populatedQueue(SIZE);
#	Line 627 | Line 659 | public class DelayQueueTest extends JSR1
659		}
660
661		/**
662	<	*
662	>	* clear removes all elements
663		*/
664		public void testClear() {
665		DelayQueue q = populatedQueue(SIZE);
#	Line 635 | Line 667 | public class DelayQueueTest extends JSR1
667		assertTrue(q.isEmpty());
668		assertEquals(0, q.size());
669		assertEquals(NOCAP, q.remainingCapacity());
670	<	q.add(new PDelay(1));
670	>	PDelay x = new PDelay(1);
671	>	q.add(x);
672		assertFalse(q.isEmpty());
673	+	assertTrue(q.contains(x));
674		q.clear();
675		assertTrue(q.isEmpty());
676		}
677
678		/**
679	<	*
679	>	* containsAll(c) is true when c contains a subset of elements
680		*/
681		public void testContainsAll() {
682		DelayQueue q = populatedQueue(SIZE);
#	Line 656 | Line 690 | public class DelayQueueTest extends JSR1
690		}
691
692		/**
693	<	*
693	>	* retainAll(c) retains only those elements of c and reports true if changed
694		*/
695		public void testRetainAll() {
696		DelayQueue q = populatedQueue(SIZE);
#	Line 675 | Line 709 | public class DelayQueueTest extends JSR1
709		}
710
711		/**
712	<	*
712	>	* removeAll(c) removes only those elements of c and reports true if changed
713		*/
714		public void testRemoveAll() {
715		for (int i = 1; i < SIZE; ++i) {
#	Line 691 | Line 725 | public class DelayQueueTest extends JSR1
725		}
726
727		/**
728	<	*
728	>	* toArray contains all elements
729		*/
730		public void testToArray() {
731		DelayQueue q = populatedQueue(SIZE);
732		Object[] o = q.toArray();
733		Arrays.sort(o);
734		try {
735	<	for(int i = 0; i < o.length; i++)
735	>	for (int i = 0; i < o.length; i++)
736		assertEquals(o[i], q.take());
737	<	} catch (InterruptedException e){
737	>	} catch (InterruptedException e) {
738		unexpectedException();
739	<	}
739	>	}
740		}
741
742		/**
743	<	*
743	>	* toArray(a) contains all elements
744		*/
745		public void testToArray2() {
746		DelayQueue q = populatedQueue(SIZE);
#	Line 714 | Line 748 | public class DelayQueueTest extends JSR1
748		ints = (PDelay[])q.toArray(ints);
749		Arrays.sort(ints);
750		try {
751	<	for(int i = 0; i < ints.length; i++)
751	>	for (int i = 0; i < ints.length; i++)
752		assertEquals(ints[i], q.take());
753	<	} catch (InterruptedException e){
753	>	} catch (InterruptedException e) {
754		unexpectedException();
755	<	}
755	>	}
756	>	}
757	>
758	>
759	>	/**
760	>	* toArray(null) throws NPE
761	>	*/
762	>	public void testToArray_BadArg() {
763	>	try {
764	>	DelayQueue q = populatedQueue(SIZE);
765	>	Object o[] = q.toArray(null);
766	>	shouldThrow();
767	>	} catch (NullPointerException success) {}
768		}
769	<
769	>
770		/**
771	<	*
771	>	* toArray with incompatible array type throws CCE
772	>	*/
773	>	public void testToArray1_BadArg() {
774	>	try {
775	>	DelayQueue q = populatedQueue(SIZE);
776	>	Object o[] = q.toArray(new String[10] );
777	>	shouldThrow();
778	>	} catch (ArrayStoreException  success) {}
779	>	}
780	>
781	>	/**
782	>	* iterator iterates through all elements
783		*/
784		public void testIterator() {
785		DelayQueue q = populatedQueue(SIZE);
786		int i = 0;
787		Iterator it = q.iterator();
788	<	while(it.hasNext()) {
788	>	while (it.hasNext()) {
789		assertTrue(q.contains(it.next()));
790		++i;
791		}
#	Line 736 | Line 793 | public class DelayQueueTest extends JSR1
793		}
794
795		/**
796	<	*
796	>	* iterator.remove removes current element
797		*/
798		public void testIteratorRemove () {
742	–
799		final DelayQueue q = new DelayQueue();
744	–
800		q.add(new PDelay(2));
801		q.add(new PDelay(1));
802		q.add(new PDelay(3));
748	–
803		Iterator it = q.iterator();
804		it.next();
805		it.remove();
752	–
806		it = q.iterator();
807		assertEquals(it.next(), new PDelay(2));
808		assertEquals(it.next(), new PDelay(3));
#	Line 758 | Line 811 | public class DelayQueueTest extends JSR1
811
812
813		/**
814	<	*
814	>	* toString contains toStrings of elements
815		*/
816		public void testToString() {
817		DelayQueue q = populatedQueue(SIZE);
#	Line 766 | Line 819 | public class DelayQueueTest extends JSR1
819		for (int i = 0; i < SIZE; ++i) {
820		assertTrue(s.indexOf(String.valueOf(Integer.MIN_VALUE+i)) >= 0);
821		}
822	<	}
822	>	}
823
824		/**
825	<	*
825	>	* offer transfers elements across Executor tasks
826		*/
827		public void testPollInExecutor() {
775	–
828		final DelayQueue q = new DelayQueue();
777	–
829		ExecutorService executor = Executors.newFixedThreadPool(2);
779	–
830		executor.execute(new Runnable() {
831		public void run() {
832		threadAssertNull(q.poll());
#	Line 801 | Line 851 | public class DelayQueueTest extends JSR1
851		}
852		}
853		});
804	–
854		joinPool(executor);
855
856		}
857
858
859		/**
860	<	*
860	>	* Delayed actions do not occur until their delay elapses
861		*/
862		public void testDelay() {
863		DelayQueue q = new DelayQueue();
#	Line 826 | Line 875 | public class DelayQueueTest extends JSR1
875		NanoDelay e = (NanoDelay)(q.take());
876		long tt = e.getTriggerTime();
877		assertTrue(tt <= System.nanoTime());
878	<	if (i != 0)
878	>	if (i != 0)
879		assertTrue(tt >= last);
880		last = tt;
881		}
882		}
883	<	catch(InterruptedException ie) {
883	>	catch (InterruptedException ie) {
884	>	unexpectedException();
885	>	}
886	>	}
887	>
888	>	/**
889	>	* peek of a non-empty queue returns non-null even if not expired
890	>	*/
891	>	public void testPeekDelayed() {
892	>	DelayQueue q = new DelayQueue();
893	>	q.add(new NanoDelay(Long.MAX_VALUE));
894	>	assert(q.peek() != null);
895	>	}
896	>
897	>
898	>	/**
899	>	* poll of a non-empty queue returns null if no expired elements.
900	>	*/
901	>	public void testPollDelayed() {
902	>	DelayQueue q = new DelayQueue();
903	>	q.add(new NanoDelay(Long.MAX_VALUE));
904	>	assertNull(q.poll());
905	>	}
906	>
907	>	/**
908	>	* timed poll of a non-empty queue returns null if no expired elements.
909	>	*/
910	>	public void testTimedPollDelayed() {
911	>	DelayQueue q = new DelayQueue();
912	>	q.add(new NanoDelay(LONG_DELAY_MS * 1000000L));
913	>	try {
914	>	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
915	>	} catch (Exception ex) {
916	>	unexpectedException();
917	>	}
918	>	}
919	>
920	>	/**
921	>	* drainTo(null) throws NPE
922	>	*/
923	>	public void testDrainToNull() {
924	>	DelayQueue q = populatedQueue(SIZE);
925	>	try {
926	>	q.drainTo(null);
927	>	shouldThrow();
928	>	} catch (NullPointerException success) {
929	>	}
930	>	}
931	>
932	>	/**
933	>	* drainTo(this) throws IAE
934	>	*/
935	>	public void testDrainToSelf() {
936	>	DelayQueue q = populatedQueue(SIZE);
937	>	try {
938	>	q.drainTo(q);
939	>	shouldThrow();
940	>	} catch (IllegalArgumentException success) {
941	>	}
942	>	}
943	>
944	>	/**
945	>	* drainTo(c) empties queue into another collection c
946	>	*/
947	>	public void testDrainTo() {
948	>	DelayQueue q = new DelayQueue();
949	>	PDelay[] elems = new PDelay[SIZE];
950	>	for (int i = 0; i < SIZE; ++i) {
951	>	elems[i] = new PDelay(i);
952	>	q.add(elems[i]);
953	>	}
954	>	ArrayList l = new ArrayList();
955	>	q.drainTo(l);
956	>	assertEquals(q.size(), 0);
957	>	for (int i = 0; i < SIZE; ++i)
958	>	assertEquals(l.get(i), elems[i]);
959	>	q.add(elems[0]);
960	>	q.add(elems[1]);
961	>	assertFalse(q.isEmpty());
962	>	assertTrue(q.contains(elems[0]));
963	>	assertTrue(q.contains(elems[1]));
964	>	l.clear();
965	>	q.drainTo(l);
966	>	assertEquals(q.size(), 0);
967	>	assertEquals(l.size(), 2);
968	>	for (int i = 0; i < 2; ++i)
969	>	assertEquals(l.get(i), elems[i]);
970	>	}
971	>
972	>	/**
973	>	* drainTo empties queue
974	>	*/
975	>	public void testDrainToWithActivePut() {
976	>	final DelayQueue q = populatedQueue(SIZE);
977	>	Thread t = new Thread(new Runnable() {
978	>	public void run() {
979	>	q.put(new PDelay(SIZE+1));
980	>	}
981	>	});
982	>	try {
983	>	t.start();
984	>	ArrayList l = new ArrayList();
985	>	q.drainTo(l);
986	>	assertTrue(l.size() >= SIZE);
987	>	t.join();
988	>	assertTrue(q.size() + l.size() >= SIZE);
989	>	} catch (Exception e) {
990		unexpectedException();
991		}
992		}
993
994	+	/**
995	+	* drainTo(null, n) throws NPE
996	+	*/
997	+	public void testDrainToNullN() {
998	+	DelayQueue q = populatedQueue(SIZE);
999	+	try {
1000	+	q.drainTo(null, 0);
1001	+	shouldThrow();
1002	+	} catch (NullPointerException success) {
1003	+	}
1004	+	}
1005	+
1006	+	/**
1007	+	* drainTo(this, n) throws IAE
1008	+	*/
1009	+	public void testDrainToSelfN() {
1010	+	DelayQueue q = populatedQueue(SIZE);
1011	+	try {
1012	+	q.drainTo(q, 0);
1013	+	shouldThrow();
1014	+	} catch (IllegalArgumentException success) {
1015	+	}
1016	+	}
1017	+
1018	+	/**
1019	+	* drainTo(c, n) empties first max {n, size} elements of queue into c
1020	+	*/
1021	+	public void testDrainToN() {
1022	+	for (int i = 0; i < SIZE + 2; ++i) {
1023	+	DelayQueue q = populatedQueue(SIZE);
1024	+	ArrayList l = new ArrayList();
1025	+	q.drainTo(l, i);
1026	+	int k = (i < SIZE)? i : SIZE;
1027	+	assertEquals(q.size(), SIZE-k);
1028	+	assertEquals(l.size(), k);
1029	+	}
1030	+	}
1031	+
1032	+
1033		}

Diff Legend

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