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.36 by jsr166, Mon Oct 11 04:19:16 2010 UTC vs.
Revision 1.46 by jsr166, Thu Nov 18 18:49:18 2010 UTC

#	Line 109 | Line 109 | public class DelayQueueTest extends JSR1
109		* Create a queue of given size containing consecutive
110		* PDelays 0 ... n.
111		*/
112	<	private DelayQueue populatedQueue(int n) {
113	<	DelayQueue q = new DelayQueue();
112	>	private DelayQueue<PDelay> populatedQueue(int n) {
113	>	DelayQueue<PDelay> q = new DelayQueue<PDelay>();
114		assertTrue(q.isEmpty());
115		for (int i = n-1; i >= 0; i-=2)
116		assertTrue(q.offer(new PDelay(i)));
#	Line 391 | Line 391 | public class DelayQueueTest extends JSR1
391		/**
392		* take blocks interruptibly when empty
393		*/
394	<	public void testTakeFromEmpty() throws InterruptedException {
395	<	final DelayQueue q = new DelayQueue();
396	<	Thread t = new ThreadShouldThrow(InterruptedException.class) {
397	<	public void realRun() throws InterruptedException {
398	<	q.take();
399	<	}};
400	<
401	<	t.start();
394	>	public void testTakeFromEmptyBlocksInterruptibly()
395	>	throws InterruptedException {
396	>	final BlockingQueue q = new DelayQueue();
397	>	final CountDownLatch threadStarted = new CountDownLatch(1);
398	>	Thread t = newStartedThread(new CheckedRunnable() {
399	>	public void realRun() {
400	>	long t0 = System.nanoTime();
401	>	threadStarted.countDown();
402	>	try {
403	>	q.take();
404	>	shouldThrow();
405	>	} catch (InterruptedException success) {}
406	>	assertTrue(millisElapsedSince(t0) >= SHORT_DELAY_MS);
407	>	}});
408	>	threadStarted.await();
409		Thread.sleep(SHORT_DELAY_MS);
410	+	assertTrue(t.isAlive());
411		t.interrupt();
412	<	t.join();
412	>	awaitTermination(t, MEDIUM_DELAY_MS);
413	>	assertFalse(t.isAlive());
414		}
415
416		/**
#	Line 439 | Line 448 | public class DelayQueueTest extends JSR1
448		}
449
450		/**
451	<	* timed pool with zero timeout succeeds when non-empty, else times out
451	>	* timed poll with zero timeout succeeds when non-empty, else times out
452		*/
453		public void testTimedPoll0() throws InterruptedException {
454		DelayQueue q = populatedQueue(SIZE);
#	Line 450 | Line 459 | public class DelayQueueTest extends JSR1
459		}
460
461		/**
462	<	* timed pool with nonzero timeout succeeds when non-empty, else times out
462	>	* timed poll with nonzero timeout succeeds when non-empty, else times out
463		*/
464		public void testTimedPoll() throws InterruptedException {
465		DelayQueue q = populatedQueue(SIZE);
#	Line 667 | Line 676 | public class DelayQueueTest extends JSR1
676		Object[] o = q.toArray();
677		Arrays.sort(o);
678		for (int i = 0; i < o.length; i++)
679	<	assertEquals(o[i], q.take());
679	>	assertSame(o[i], q.take());
680		}
681
682		/**
683		* toArray(a) contains all elements
684		*/
685	<	public void testToArray2() throws InterruptedException {
686	<	DelayQueue q = populatedQueue(SIZE);
685	>	public void testToArray2() {
686	>	DelayQueue<PDelay> q = populatedQueue(SIZE);
687		PDelay[] ints = new PDelay[SIZE];
688	<	ints = (PDelay[])q.toArray(ints);
688	>	PDelay[] array = q.toArray(ints);
689	>	assertSame(ints, array);
690		Arrays.sort(ints);
691		for (int i = 0; i < ints.length; i++)
692	<	assertEquals(ints[i], q.take());
692	>	assertSame(ints[i], q.remove());
693		}
694
695
696		/**
697	<	* toArray(null) throws NPE
697	>	* toArray(null) throws NullPointerException
698		*/
699	<	public void testToArray_BadArg() {
699	>	public void testToArray_NullArg() {
700		DelayQueue q = populatedQueue(SIZE);
701		try {
702	<	Object o[] = q.toArray(null);
702	>	q.toArray(null);
703		shouldThrow();
704		} catch (NullPointerException success) {}
705		}
706
707		/**
708	<	* toArray with incompatible array type throws CCE
708	>	* toArray(incompatible array type) throws ArrayStoreException
709		*/
710		public void testToArray1_BadArg() {
711		DelayQueue q = populatedQueue(SIZE);
712		try {
713	<	Object o[] = q.toArray(new String[10]);
713	>	q.toArray(new String[10]);
714		shouldThrow();
715		} catch (ArrayStoreException success) {}
716		}
#	Line 775 | Line 785 | public class DelayQueueTest extends JSR1
785		* Delayed actions do not occur until their delay elapses
786		*/
787		public void testDelay() throws InterruptedException {
788	<	DelayQueue q = new DelayQueue();
789	<	NanoDelay[] elements = new NanoDelay[SIZE];
790	<	for (int i = 0; i < SIZE; ++i) {
781	<	elements[i] = new NanoDelay(1000000000L + 1000000L * (SIZE - i));
782	<	}
783	<	for (int i = 0; i < SIZE; ++i) {
784	<	q.add(elements[i]);
785	<	}
788	>	DelayQueue<NanoDelay> q = new DelayQueue<NanoDelay>();
789	>	for (int i = 0; i < SIZE; ++i)
790	>	q.add(new NanoDelay(1000000L * (SIZE - i)));
791
792		long last = 0;
793		for (int i = 0; i < SIZE; ++i) {
794	<	NanoDelay e = (NanoDelay)(q.take());
794	>	NanoDelay e = q.take();
795		long tt = e.getTriggerTime();
796	<	assertTrue(tt - System.nanoTime() <= 0);
796	>	assertTrue(System.nanoTime() - tt >= 0);
797		if (i != 0)
798		assertTrue(tt >= last);
799		last = tt;
800		}
801	+	assertTrue(q.isEmpty());
802		}
803
804		/**
#	Line 914 | Line 920 | public class DelayQueueTest extends JSR1
920		}
921
922		/**
923	<	* drainTo(c, n) empties first max {n, size} elements of queue into c
923	>	* drainTo(c, n) empties first min(n, size) elements of queue into c
924		*/
925		public void testDrainToN() {
926		for (int i = 0; i < SIZE + 2; ++i) {
927		DelayQueue q = populatedQueue(SIZE);
928		ArrayList l = new ArrayList();
929		q.drainTo(l, i);
930	<	int k = (i < SIZE)? i : SIZE;
930	>	int k = (i < SIZE) ? i : SIZE;
931		assertEquals(q.size(), SIZE-k);
932		assertEquals(l.size(), k);
933		}

Diff Legend

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