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.21 by jsr166, Sat Nov 21 10:29:50 2009 UTC vs.
Revision 1.48 by jsr166, Thu Apr 14 22:55:08 2011 UTC

#	Line 1 | Line 1
1		/*
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
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		* Other contributors include Andrew Wright, Jeffrey Hayes,
6		* Pat Fisher, Mike Judd.
7		*/
#	Line 13 | Line 13 | 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() {
#	Line 24 | Line 24 | public class DelayQueueTest extends JSR1
24
25		/**
26		* A delayed implementation for testing.
27	<	* Most  tests use Pseudodelays, where delays are all elapsed
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 {
#	Line 32 | Line 32 | public class DelayQueueTest extends JSR1
32		PDelay(int i) { pseudodelay = Integer.MIN_VALUE + i; }
33		public int compareTo(PDelay y) {
34		int i = pseudodelay;
35	<	int j = ((PDelay)y).pseudodelay;
35	>	int j = y.pseudodelay;
36		if (i < j) return -1;
37		if (i > j) return 1;
38		return 0;
39		}
40
41		public int compareTo(Delayed y) {
42	<	int i = pseudodelay;
43	<	int j = ((PDelay)y).pseudodelay;
44	<	if (i < j) return -1;
45	<	if (i > j) return 1;
46	<	return 0;
42	>	return compareTo((PDelay)y);
43		}
44
45		public boolean equals(Object other) {
46	<	return ((PDelay)other).pseudodelay == pseudodelay;
46	>	return equals((PDelay)other);
47		}
48		public boolean equals(PDelay other) {
49	<	return ((PDelay)other).pseudodelay == pseudodelay;
49	>	return other.pseudodelay == pseudodelay;
50		}
51
52
#	Line 77 | Line 73 | public class DelayQueueTest extends JSR1
73		}
74		public int compareTo(NanoDelay y) {
75		long i = trigger;
76	<	long j = ((NanoDelay)y).trigger;
76	>	long j = y.trigger;
77		if (i < j) return -1;
78		if (i > j) return 1;
79		return 0;
80		}
81
82		public int compareTo(Delayed y) {
83	<	long i = trigger;
88	<	long j = ((NanoDelay)y).trigger;
89	<	if (i < j) return -1;
90	<	if (i > j) return 1;
91	<	return 0;
83	>	return compareTo((NanoDelay)y);
84		}
85
86		public boolean equals(Object other) {
87	<	return ((NanoDelay)other).trigger == trigger;
87	>	return equals((NanoDelay)other);
88		}
89		public boolean equals(NanoDelay other) {
90	<	return ((NanoDelay)other).trigger == trigger;
90	>	return other.trigger == trigger;
91		}
92
93		public long getDelay(TimeUnit unit) {
#	Line 117 | 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 199 | Line 191 | public class DelayQueueTest extends JSR1
191		}
192
193		/**
194	<	* remainingCapacity does not change when elementa added or removed,
194	>	* remainingCapacity does not change when elements added or removed,
195		* but size does
196		*/
197		public void testRemainingCapacity() {
#	Line 292 | Line 284 | public class DelayQueueTest extends JSR1
284		shouldThrow();
285		} catch (NullPointerException success) {}
286		}
287	+
288		/**
289		* addAll of a collection with any null elements throws NPE after
290		* possibly adding some elements
#	Line 325 | Line 318 | public class DelayQueueTest extends JSR1
318		/**
319		* put(null) throws NPE
320		*/
321	<	public void testPutNull() {
321	>	public void testPutNull() {
322		try {
323		DelayQueue q = new DelayQueue();
324		q.put(null);
325		shouldThrow();
326		} catch (NullPointerException success) {}
327	<	}
327	>	}
328
329		/**
330		* all elements successfully put are contained
331		*/
332	<	public void testPut() {
333	<	DelayQueue q = new DelayQueue();
334	<	for (int i = 0; i < SIZE; ++i) {
335	<	PDelay I = new PDelay(i);
336	<	q.put(I);
337	<	assertTrue(q.contains(I));
338	<	}
339	<	assertEquals(SIZE, q.size());
332	>	public void testPut() {
333	>	DelayQueue q = new DelayQueue();
334	>	for (int i = 0; i < SIZE; ++i) {
335	>	PDelay I = new PDelay(i);
336	>	q.put(I);
337	>	assertTrue(q.contains(I));
338	>	}
339	>	assertEquals(SIZE, q.size());
340		}
341
342		/**
#	Line 375 | Line 368 | public class DelayQueueTest extends JSR1
368		public void realRun() throws InterruptedException {
369		q.put(new PDelay(0));
370		q.put(new PDelay(0));
371	<	threadAssertTrue(q.offer(new PDelay(0), SHORT_DELAY_MS, MILLISECONDS));
372	<	threadAssertTrue(q.offer(new PDelay(0), LONG_DELAY_MS, MILLISECONDS));
371	>	assertTrue(q.offer(new PDelay(0), SHORT_DELAY_MS, MILLISECONDS));
372	>	assertTrue(q.offer(new PDelay(0), LONG_DELAY_MS, MILLISECONDS));
373		}});
374
375		t.start();
#	Line 398 | 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		/**
417		* Take removes existing elements until empty, then blocks interruptibly
418		*/
419		public void testBlockingTake() throws InterruptedException {
420	<	Thread t = new ThreadShouldThrow(InterruptedException.class) {
420	>	final DelayQueue q = populatedQueue(SIZE);
421	>	Thread t = new Thread(new CheckedRunnable() {
422		public void realRun() throws InterruptedException {
420	–	DelayQueue q = populatedQueue(SIZE);
423		for (int i = 0; i < SIZE; ++i) {
424	<	threadAssertEquals(new PDelay(i), ((PDelay)q.take()));
424	>	assertEquals(new PDelay(i), ((PDelay)q.take()));
425		}
426	<	q.take();
427	<	}};
426	>	try {
427	>	q.take();
428	>	shouldThrow();
429	>	} catch (InterruptedException success) {}
430	>	}});
431
432		t.start();
433		Thread.sleep(SHORT_DELAY_MS);
#	Line 443 | 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 454 | 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 476 | Line 481 | public class DelayQueueTest extends JSR1
481		assertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, MILLISECONDS)));
482		}
483		try {
484	<	q.poll(LONG_DELAY_MS, MILLISECONDS);
484	>	q.poll(SMALL_DELAY_MS, MILLISECONDS);
485		shouldThrow();
486		} catch (InterruptedException success) {}
487		}});
#	Line 488 | Line 493 | public class DelayQueueTest extends JSR1
493		}
494
495		/**
496	<	*  timed poll before a delayed offer fails; after offer succeeds;
497	<	*  on interruption throws
496	>	* timed poll before a delayed offer fails; after offer succeeds;
497	>	* on interruption throws
498		*/
499		public void testTimedPollWithOffer() throws InterruptedException {
500		final DelayQueue q = new DelayQueue();
501	+	final PDelay pdelay = new PDelay(0);
502	+	final CheckedBarrier barrier = new CheckedBarrier(2);
503		Thread t = new Thread(new CheckedRunnable() {
504		public void realRun() throws InterruptedException {
505		assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
506	<	q.poll(LONG_DELAY_MS, MILLISECONDS);
506	>
507	>	barrier.await();
508	>	assertSame(pdelay, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
509	>
510	>	Thread.currentThread().interrupt();
511		try {
512	<	q.poll(LONG_DELAY_MS, MILLISECONDS);
512	>	q.poll(SHORT_DELAY_MS, MILLISECONDS);
513	>	shouldThrow();
514	>	} catch (InterruptedException success) {}
515	>
516	>	barrier.await();
517	>	try {
518	>	q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
519		shouldThrow();
520		} catch (InterruptedException success) {}
521		}});
522
523		t.start();
524	<	Thread.sleep(SMALL_DELAY_MS);
525	<	assertTrue(q.offer(new PDelay(0), SHORT_DELAY_MS, MILLISECONDS));
524	>	barrier.await();
525	>	assertTrue(q.offer(pdelay, SHORT_DELAY_MS, MILLISECONDS));
526	>	barrier.await();
527	>	sleep(SHORT_DELAY_MS);
528		t.interrupt();
529		t.join();
530		}
#	Line 518 | Line 537 | public class DelayQueueTest extends JSR1
537		DelayQueue q = populatedQueue(SIZE);
538		for (int i = 0; i < SIZE; ++i) {
539		assertEquals(new PDelay(i), ((PDelay)q.peek()));
540	<	q.poll();
540	>	assertEquals(new PDelay(i), ((PDelay)q.poll()));
541		if (q.isEmpty())
542		assertNull(q.peek());
543		else
544	<	assertTrue(i != ((PDelay)q.peek()).intValue());
544	>	assertFalse(new PDelay(i).equals(q.peek()));
545		}
546		assertNull(q.peek());
547		}
#	Line 657 | 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	<	DelayQueue q = populatedQueue(SIZE);
682	<	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	<	DelayQueue q = populatedQueue(SIZE);
693	<	Object o[] = q.toArray(new String[10] );
713	>	q.toArray(new String[10]);
714		shouldThrow();
715		} catch (ArrayStoreException success) {}
716		}
#	Line 712 | Line 732 | public class DelayQueueTest extends JSR1
732		/**
733		* iterator.remove removes current element
734		*/
735	<	public void testIteratorRemove () {
735	>	public void testIteratorRemove() {
736		final DelayQueue q = new DelayQueue();
737		q.add(new PDelay(2));
738		q.add(new PDelay(1));
#	Line 746 | Line 766 | public class DelayQueueTest extends JSR1
766		ExecutorService executor = Executors.newFixedThreadPool(2);
767		executor.execute(new CheckedRunnable() {
768		public void realRun() throws InterruptedException {
769	<	threadAssertNull(q.poll());
770	<	threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
771	<	threadAssertTrue(q.isEmpty());
769	>	assertNull(q.poll());
770	>	assertTrue(null != q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
771	>	assertTrue(q.isEmpty());
772		}});
773
774		executor.execute(new CheckedRunnable() {
#	Line 758 | Line 778 | public class DelayQueueTest extends JSR1
778		}});
779
780		joinPool(executor);
761	–
781		}
782
783
#	Line 766 | 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) {
772	<	elements[i] = new NanoDelay(1000000000L + 1000000L * (SIZE - i));
773	<	}
774	<	for (int i = 0; i < SIZE; ++i) {
775	<	q.add(elements[i]);
776	<	}
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());
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 792 | Line 807 | public class DelayQueueTest extends JSR1
807		public void testPeekDelayed() {
808		DelayQueue q = new DelayQueue();
809		q.add(new NanoDelay(Long.MAX_VALUE));
810	<	assert(q.peek() != null);
810	>	assertNotNull(q.peek());
811		}
812
813
#	Line 905 | 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