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

Diff Legend

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