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.2 by dl, Sun Sep 7 20:39:11 2003 UTC vs.
Revision 1.53 by jsr166, Mon May 30 22:43:20 2011 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/publicdomain/zero/1.0/
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 java.util.concurrent.*;
12	<
13	<	public class DelayQueueTest extends TestCase {
14	<
15	<	private static final int N = 10;
16	<	private static final long SHORT_DELAY_MS = 100;
17	<	private static final long MEDIUM_DELAY_MS = 1000;
18	<	private static final long LONG_DELAY_MS = 10000;
19	<	private static final int NOCAP = Integer.MAX_VALUE;
10	>	import java.util.Arrays;
11	>	import java.util.ArrayList;
12	>	import java.util.Collection;
13	>	import java.util.Iterator;
14	>	import java.util.NoSuchElementException;
15	>	import java.util.concurrent.BlockingQueue;
16	>	import java.util.concurrent.CountDownLatch;
17	>	import java.util.concurrent.Delayed;
18	>	import java.util.concurrent.DelayQueue;
19	>	import java.util.concurrent.Executors;
20	>	import java.util.concurrent.ExecutorService;
21	>	import java.util.concurrent.TimeUnit;
22	>	import static java.util.concurrent.TimeUnit.MILLISECONDS;
23	>
24	>	public class DelayQueueTest extends JSR166TestCase {
25	>
26	>	public static class Generic extends BlockingQueueTest {
27	>	protected BlockingQueue emptyCollection() {
28	>	return new DelayQueue();
29	>	}
30	>	protected PDelay makeElement(int i) {
31	>	return new PDelay(i);
32	>	}
33	>	}
34
35		public static void main(String[] args) {
36	<	junit.textui.TestRunner.run (suite());
36	>	junit.textui.TestRunner.run(suite());
37		}
38
39		public static Test suite() {
40	<	return new TestSuite(DelayQueueTest.class);
40	>	return newTestSuite(DelayQueueTest.class,
41	>	new Generic().testSuite());
42		}
43
44	<	// Most Q/BQ tests use Pseudodelays, where delays are all elapsed
29	<	// (so, no blocking solely for delays) but are still ordered
44	>	private static final int NOCAP = Integer.MAX_VALUE;
45
46	<	static class PDelay implements Delayed {
46	>	/**
47	>	* A delayed implementation for testing.
48	>	* Most tests use Pseudodelays, where delays are all elapsed
49	>	* (so, no blocking solely for delays) but are still ordered
50	>	*/
51	>	static class PDelay implements Delayed {
52		int pseudodelay;
53		PDelay(int i) { pseudodelay = Integer.MIN_VALUE + i; }
54	<	public int compareTo(Object y) {
54	>	public int compareTo(PDelay y) {
55		int i = pseudodelay;
56	<	int j = ((PDelay)y).pseudodelay;
56	>	int j = y.pseudodelay;
57		if (i < j) return -1;
58		if (i > j) return 1;
59		return 0;
60		}
61
62	<	public int compareTo(PDelay y) {
63	<	int i = pseudodelay;
44	<	int j = ((PDelay)y).pseudodelay;
45	<	if (i < j) return -1;
46	<	if (i > j) return 1;
47	<	return 0;
62	>	public int compareTo(Delayed y) {
63	>	return compareTo((PDelay)y);
64		}
65
66		public boolean equals(Object other) {
67	<	return ((PDelay)other).pseudodelay == pseudodelay;
67	>	return equals((PDelay)other);
68		}
69		public boolean equals(PDelay other) {
70	<	return ((PDelay)other).pseudodelay == pseudodelay;
70	>	return other.pseudodelay == pseudodelay;
71		}
72
57	–
73		public long getDelay(TimeUnit ignore) {
74		return pseudodelay;
75		}
#	Line 67 | Line 82 | public class DelayQueueTest extends Test
82		}
83		}
84
85	+	/**
86	+	* Delayed implementation that actually delays
87	+	*/
88	+	static class NanoDelay implements Delayed {
89	+	long trigger;
90	+	NanoDelay(long i) {
91	+	trigger = System.nanoTime() + i;
92	+	}
93	+	public int compareTo(NanoDelay y) {
94	+	long i = trigger;
95	+	long j = y.trigger;
96	+	if (i < j) return -1;
97	+	if (i > j) return 1;
98	+	return 0;
99	+	}
100
101	+	public int compareTo(Delayed y) {
102	+	return compareTo((NanoDelay)y);
103	+	}
104
105	+	public boolean equals(Object other) {
106	+	return equals((NanoDelay)other);
107	+	}
108	+	public boolean equals(NanoDelay other) {
109	+	return other.trigger == trigger;
110	+	}
111	+
112	+	public long getDelay(TimeUnit unit) {
113	+	long n = trigger - System.nanoTime();
114	+	return unit.convert(n, TimeUnit.NANOSECONDS);
115	+	}
116	+
117	+	public long getTriggerTime() {
118	+	return trigger;
119	+	}
120	+
121	+	public String toString() {
122	+	return String.valueOf(trigger);
123	+	}
124	+	}
125
126		/**
127		* Create a queue of given size containing consecutive
128		* PDelays 0 ... n.
129		*/
130	<	private DelayQueue fullQueue(int n) {
131	<	DelayQueue q = new DelayQueue();
130	>	private DelayQueue<PDelay> populatedQueue(int n) {
131	>	DelayQueue<PDelay> q = new DelayQueue<PDelay>();
132		assertTrue(q.isEmpty());
133	<	for(int i = n-1; i >= 0; i-=2)
134	<	assertTrue(q.offer(new PDelay(i)));
135	<	for(int i = (n & 1); i < n; i+=2)
136	<	assertTrue(q.offer(new PDelay(i)));
133	>	for (int i = n-1; i >= 0; i-=2)
134	>	assertTrue(q.offer(new PDelay(i)));
135	>	for (int i = (n & 1); i < n; i+=2)
136	>	assertTrue(q.offer(new PDelay(i)));
137		assertFalse(q.isEmpty());
138		assertEquals(NOCAP, q.remainingCapacity());
139	<	assertEquals(n, q.size());
139	>	assertEquals(n, q.size());
140		return q;
141		}
142	<
143	<	public void testConstructor1(){
142	>
143	>	/**
144	>	* A new queue has unbounded capacity
145	>	*/
146	>	public void testConstructor1() {
147		assertEquals(NOCAP, new DelayQueue().remainingCapacity());
148		}
149
150	<	public void testConstructor3(){
151	<
150	>	/**
151	>	* Initializing from null Collection throws NPE
152	>	*/
153	>	public void testConstructor3() {
154		try {
155		DelayQueue q = new DelayQueue(null);
156	<	fail("Cannot make from null collection");
157	<	}
100	<	catch (NullPointerException success) {}
156	>	shouldThrow();
157	>	} catch (NullPointerException success) {}
158		}
159
160	<	public void testConstructor4(){
160	>	/**
161	>	* Initializing from Collection of null elements throws NPE
162	>	*/
163	>	public void testConstructor4() {
164		try {
165	<	PDelay[] ints = new PDelay[N];
165	>	PDelay[] ints = new PDelay[SIZE];
166		DelayQueue q = new DelayQueue(Arrays.asList(ints));
167	<	fail("Cannot make with null elements");
168	<	}
109	<	catch (NullPointerException success) {}
167	>	shouldThrow();
168	>	} catch (NullPointerException success) {}
169		}
170
171	<	public void testConstructor5(){
171	>	/**
172	>	* Initializing from Collection with some null elements throws NPE
173	>	*/
174	>	public void testConstructor5() {
175		try {
176	<	PDelay[] ints = new PDelay[N];
177	<	for (int i = 0; i < N-1; ++i)
176	>	PDelay[] ints = new PDelay[SIZE];
177	>	for (int i = 0; i < SIZE-1; ++i)
178		ints[i] = new PDelay(i);
179		DelayQueue q = new DelayQueue(Arrays.asList(ints));
180	<	fail("Cannot make with null elements");
181	<	}
120	<	catch (NullPointerException success) {}
180	>	shouldThrow();
181	>	} catch (NullPointerException success) {}
182		}
183
184	<	public void testConstructor6(){
185	<	try {
186	<	PDelay[] ints = new PDelay[N];
187	<	for (int i = 0; i < N; ++i)
188	<	ints[i] = new PDelay(i);
189	<	DelayQueue q = new DelayQueue(Arrays.asList(ints));
190	<	for (int i = 0; i < N; ++i)
191	<	assertEquals(ints[i], q.poll());
192	<	}
193	<	finally {}
184	>	/**
185	>	* Queue contains all elements of collection used to initialize
186	>	*/
187	>	public void testConstructor6() {
188	>	PDelay[] ints = new PDelay[SIZE];
189	>	for (int i = 0; i < SIZE; ++i)
190	>	ints[i] = new PDelay(i);
191	>	DelayQueue q = new DelayQueue(Arrays.asList(ints));
192	>	for (int i = 0; i < SIZE; ++i)
193	>	assertEquals(ints[i], q.poll());
194		}
195
196	+	/**
197	+	* isEmpty is true before add, false after
198	+	*/
199		public void testEmpty() {
200		DelayQueue q = new DelayQueue();
201		assertTrue(q.isEmpty());
#	Line 144 | Line 208 | public class DelayQueueTest extends Test
208		assertTrue(q.isEmpty());
209		}
210
211	<	public void testRemainingCapacity(){
212	<	DelayQueue q = fullQueue(N);
213	<	for (int i = 0; i < N; ++i) {
211	>	/**
212	>	* remainingCapacity does not change when elements added or removed,
213	>	* but size does
214	>	*/
215	>	public void testRemainingCapacity() {
216	>	DelayQueue q = populatedQueue(SIZE);
217	>	for (int i = 0; i < SIZE; ++i) {
218		assertEquals(NOCAP, q.remainingCapacity());
219	<	assertEquals(N-i, q.size());
219	>	assertEquals(SIZE-i, q.size());
220		q.remove();
221		}
222	<	for (int i = 0; i < N; ++i) {
222	>	for (int i = 0; i < SIZE; ++i) {
223		assertEquals(NOCAP, q.remainingCapacity());
224		assertEquals(i, q.size());
225		q.add(new PDelay(i));
226		}
227		}
228
229	<	public void testOfferNull(){
230	<	try {
231	<	DelayQueue q = new DelayQueue();
164	<	q.offer(null);
165	<	fail("should throw NPE");
166	<	} catch (NullPointerException success) { }
167	<	}
168	<
229	>	/**
230	>	* offer non-null succeeds
231	>	*/
232		public void testOffer() {
233		DelayQueue q = new DelayQueue();
234		assertTrue(q.offer(new PDelay(0)));
235		assertTrue(q.offer(new PDelay(1)));
236		}
237
238	<	public void testAdd(){
238	>	/**
239	>	* add succeeds
240	>	*/
241	>	public void testAdd() {
242		DelayQueue q = new DelayQueue();
243	<	for (int i = 0; i < N; ++i) {
243	>	for (int i = 0; i < SIZE; ++i) {
244		assertEquals(i, q.size());
245		assertTrue(q.add(new PDelay(i)));
246		}
247		}
248
249	<	public void testAddAll1(){
250	<	try {
251	<	DelayQueue q = new DelayQueue();
252	<	q.addAll(null);
187	<	fail("Cannot add null collection");
188	<	}
189	<	catch (NullPointerException success) {}
190	<	}
191	<	public void testAddAll2(){
249	>	/**
250	>	* addAll(this) throws IAE
251	>	*/
252	>	public void testAddAllSelf() {
253		try {
254	<	DelayQueue q = new DelayQueue();
255	<	PDelay[] ints = new PDelay[N];
256	<	q.addAll(Arrays.asList(ints));
257	<	fail("Cannot add null elements");
197	<	}
198	<	catch (NullPointerException success) {}
254	>	DelayQueue q = populatedQueue(SIZE);
255	>	q.addAll(q);
256	>	shouldThrow();
257	>	} catch (IllegalArgumentException success) {}
258		}
259	<	public void testAddAll3(){
259	>
260	>	/**
261	>	* addAll of a collection with any null elements throws NPE after
262	>	* possibly adding some elements
263	>	*/
264	>	public void testAddAll3() {
265		try {
266		DelayQueue q = new DelayQueue();
267	<	PDelay[] ints = new PDelay[N];
268	<	for (int i = 0; i < N-1; ++i)
267	>	PDelay[] ints = new PDelay[SIZE];
268	>	for (int i = 0; i < SIZE-1; ++i)
269		ints[i] = new PDelay(i);
270		q.addAll(Arrays.asList(ints));
271	<	fail("Cannot add null elements");
272	<	}
209	<	catch (NullPointerException success) {}
271	>	shouldThrow();
272	>	} catch (NullPointerException success) {}
273		}
274
275	<	public void testAddAll5(){
276	<	try {
277	<	PDelay[] empty = new PDelay[0];
278	<	PDelay[] ints = new PDelay[N];
279	<	for (int i = N-1; i >= 0; --i)
280	<	ints[i] = new PDelay(i);
281	<	DelayQueue q = new DelayQueue();
282	<	assertFalse(q.addAll(Arrays.asList(empty)));
283	<	assertTrue(q.addAll(Arrays.asList(ints)));
284	<	for (int i = 0; i < N; ++i)
285	<	assertEquals(ints[i], q.poll());
286	<	}
287	<	finally {}
275	>	/**
276	>	* Queue contains all elements of successful addAll
277	>	*/
278	>	public void testAddAll5() {
279	>	PDelay[] empty = new PDelay[0];
280	>	PDelay[] ints = new PDelay[SIZE];
281	>	for (int i = SIZE-1; i >= 0; --i)
282	>	ints[i] = new PDelay(i);
283	>	DelayQueue q = new DelayQueue();
284	>	assertFalse(q.addAll(Arrays.asList(empty)));
285	>	assertTrue(q.addAll(Arrays.asList(ints)));
286	>	for (int i = 0; i < SIZE; ++i)
287	>	assertEquals(ints[i], q.poll());
288		}
289
290	<	public void testPutNull() {
291	<	try {
292	<	DelayQueue q = new DelayQueue();
293	<	q.put(null);
294	<	fail("put should throw NPE");
295	<	}
296	<	catch (NullPointerException success){
297	<	}
298	<	}
236	<
237	<	public void testPut() {
238	<	try {
239	<	DelayQueue q = new DelayQueue();
240	<	for (int i = 0; i < N; ++i) {
241	<	PDelay I = new PDelay(i);
242	<	q.put(I);
243	<	assertTrue(q.contains(I));
244	<	}
245	<	assertEquals(N, q.size());
246	<	}
247	<	finally {
290	>	/**
291	>	* all elements successfully put are contained
292	>	*/
293	>	public void testPut() {
294	>	DelayQueue q = new DelayQueue();
295	>	for (int i = 0; i < SIZE; ++i) {
296	>	PDelay I = new PDelay(i);
297	>	q.put(I);
298	>	assertTrue(q.contains(I));
299		}
300	+	assertEquals(SIZE, q.size());
301		}
302
303	<	public void testPutWithTake() {
303	>	/**
304	>	* put doesn't block waiting for take
305	>	*/
306	>	public void testPutWithTake() throws InterruptedException {
307		final DelayQueue q = new DelayQueue();
308	<	Thread t = new Thread(new Runnable() {
309	<	public void run(){
310	<	int added = 0;
311	<	try {
312	<	q.put(new PDelay(0));
313	<	++added;
314	<	q.put(new PDelay(0));
315	<	++added;
316	<	q.put(new PDelay(0));
317	<	++added;
263	<	q.put(new PDelay(0));
264	<	++added;
265	<	assertTrue(added == 4);
266	<	} finally {
267	<	}
268	<	}
269	<	});
270	<	try {
271	<	t.start();
272	<	Thread.sleep(SHORT_DELAY_MS);
273	<	q.take();
274	<	t.interrupt();
275	<	t.join();
276	<	} catch (Exception e){
277	<	fail("Unexpected exception");
278	<	}
308	>	Thread t = newStartedThread(new CheckedRunnable() {
309	>	public void realRun() {
310	>	q.put(new PDelay(0));
311	>	q.put(new PDelay(0));
312	>	q.put(new PDelay(0));
313	>	q.put(new PDelay(0));
314	>	}});
315	>
316	>	awaitTermination(t);
317	>	assertEquals(4, q.size());
318		}
319
320	<	public void testTimedOffer() {
320	>	/**
321	>	* timed offer does not time out
322	>	*/
323	>	public void testTimedOffer() throws InterruptedException {
324		final DelayQueue q = new DelayQueue();
325	<	Thread t = new Thread(new Runnable() {
326	<	public void run(){
327	<	try {
328	<	q.put(new PDelay(0));
329	<	q.put(new PDelay(0));
330	<	assertTrue(q.offer(new PDelay(0), SHORT_DELAY_MS/2, TimeUnit.MILLISECONDS));
331	<	assertTrue(q.offer(new PDelay(0), LONG_DELAY_MS, TimeUnit.MILLISECONDS));
290	<	} finally { }
291	<	}
292	<	});
293	<
294	<	try {
295	<	t.start();
296	<	Thread.sleep(SHORT_DELAY_MS);
297	<	t.interrupt();
298	<	t.join();
299	<	} catch (Exception e){
300	<	fail("Unexpected exception");
301	<	}
302	<	}
325	>	Thread t = newStartedThread(new CheckedRunnable() {
326	>	public void realRun() throws InterruptedException {
327	>	q.put(new PDelay(0));
328	>	q.put(new PDelay(0));
329	>	assertTrue(q.offer(new PDelay(0), SHORT_DELAY_MS, MILLISECONDS));
330	>	assertTrue(q.offer(new PDelay(0), LONG_DELAY_MS, MILLISECONDS));
331	>	}});
332
333	<	public void testTake(){
305	<	try {
306	<	DelayQueue q = fullQueue(N);
307	<	for (int i = 0; i < N; ++i) {
308	<	assertEquals(new PDelay(i), ((PDelay)q.take()));
309	<	}
310	<	} catch (InterruptedException e){
311	<	fail("Unexpected exception");
312	<	}
333	>	awaitTermination(t);
334		}
335
336	<	public void testTakeFromEmpty() {
337	<	final DelayQueue q = new DelayQueue();
338	<	Thread t = new Thread(new Runnable() {
339	<	public void run(){
340	<	try {
341	<	q.take();
342	<	fail("Should block");
322	<	} catch (InterruptedException success){ }
323	<	}
324	<	});
325	<	try {
326	<	t.start();
327	<	Thread.sleep(SHORT_DELAY_MS);
328	<	t.interrupt();
329	<	t.join();
330	<	} catch (Exception e){
331	<	fail("Unexpected exception");
336	>	/**
337	>	* take retrieves elements in priority order
338	>	*/
339	>	public void testTake() throws InterruptedException {
340	>	DelayQueue q = populatedQueue(SIZE);
341	>	for (int i = 0; i < SIZE; ++i) {
342	>	assertEquals(new PDelay(i), ((PDelay)q.take()));
343		}
344		}
345
346	<	public void testBlockingTake(){
347	<	Thread t = new Thread(new Runnable() {
348	<	public void run() {
349	<	try {
350	<	DelayQueue q = fullQueue(N);
351	<	for (int i = 0; i < N; ++i) {
352	<	assertEquals(new PDelay(i), ((PDelay)q.take()));
353	<	}
354	<	q.take();
355	<	fail("take should block");
356	<	} catch (InterruptedException success){
346	<	}
347	<	}});
348	<	t.start();
349	<	try {
350	<	Thread.sleep(SHORT_DELAY_MS);
351	<	t.interrupt();
352	<	t.join();
353	<	}
354	<	catch (InterruptedException ie) {
355	<	fail("Unexpected exception");
356	<	}
357	<	}
346	>	/**
347	>	* Take removes existing elements until empty, then blocks interruptibly
348	>	*/
349	>	public void testBlockingTake() throws InterruptedException {
350	>	final DelayQueue q = populatedQueue(SIZE);
351	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
352	>	Thread t = newStartedThread(new CheckedRunnable() {
353	>	public void realRun() throws InterruptedException {
354	>	for (int i = 0; i < SIZE; ++i) {
355	>	assertEquals(new PDelay(i), ((PDelay)q.take()));
356	>	}
357
358	+	Thread.currentThread().interrupt();
359	+	try {
360	+	q.take();
361	+	shouldThrow();
362	+	} catch (InterruptedException success) {}
363	+	assertFalse(Thread.interrupted());
364	+
365	+	pleaseInterrupt.countDown();
366	+	try {
367	+	q.take();
368	+	shouldThrow();
369	+	} catch (InterruptedException success) {}
370	+	assertFalse(Thread.interrupted());
371	+	}});
372	+
373	+	await(pleaseInterrupt);
374	+	assertThreadStaysAlive(t);
375	+	t.interrupt();
376	+	awaitTermination(t);
377	+	}
378
379	<	public void testPoll(){
380	<	DelayQueue q = fullQueue(N);
381	<	for (int i = 0; i < N; ++i) {
379	>	/**
380	>	* poll succeeds unless empty
381	>	*/
382	>	public void testPoll() {
383	>	DelayQueue q = populatedQueue(SIZE);
384	>	for (int i = 0; i < SIZE; ++i) {
385		assertEquals(new PDelay(i), ((PDelay)q.poll()));
386		}
387	<	assertNull(q.poll());
387	>	assertNull(q.poll());
388		}
389
390	<	public void testTimedPoll0() {
391	<	try {
392	<	DelayQueue q = fullQueue(N);
393	<	for (int i = 0; i < N; ++i) {
394	<	assertEquals(new PDelay(i), ((PDelay)q.poll(0, TimeUnit.MILLISECONDS)));
395	<	}
396	<	assertNull(q.poll(0, TimeUnit.MILLISECONDS));
397	<	} catch (InterruptedException e){
398	<	fail("Unexpected exception");
377	<	}
390	>	/**
391	>	* timed poll with zero timeout succeeds when non-empty, else times out
392	>	*/
393	>	public void testTimedPoll0() throws InterruptedException {
394	>	DelayQueue q = populatedQueue(SIZE);
395	>	for (int i = 0; i < SIZE; ++i) {
396	>	assertEquals(new PDelay(i), ((PDelay)q.poll(0, MILLISECONDS)));
397	>	}
398	>	assertNull(q.poll(0, MILLISECONDS));
399		}
400
401	<	public void testTimedPoll() {
402	<	try {
403	<	DelayQueue q = fullQueue(N);
404	<	for (int i = 0; i < N; ++i) {
405	<	assertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)));
406	<	}
407	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
408	<	} catch (InterruptedException e){
409	<	fail("Unexpected exception");
410	<	}
411	<	}
412	<
413	<	public void testInterruptedTimedPoll(){
414	<	Thread t = new Thread(new Runnable() {
394	<	public void run() {
395	<	try {
396	<	DelayQueue q = fullQueue(N);
397	<	for (int i = 0; i < N; ++i) {
398	<	assertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)));
399	<	}
400	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
401	<	} catch (InterruptedException success){
402	<	}
403	<	}});
404	<	t.start();
405	<	try {
406	<	Thread.sleep(SHORT_DELAY_MS);
407	<	t.interrupt();
408	<	t.join();
409	<	}
410	<	catch (InterruptedException ie) {
411	<	fail("Unexpected exception");
412	<	}
401	>	/**
402	>	* timed poll with nonzero timeout succeeds when non-empty, else times out
403	>	*/
404	>	public void testTimedPoll() throws InterruptedException {
405	>	DelayQueue q = populatedQueue(SIZE);
406	>	for (int i = 0; i < SIZE; ++i) {
407	>	long startTime = System.nanoTime();
408	>	assertEquals(new PDelay(i), ((PDelay)q.poll(LONG_DELAY_MS, MILLISECONDS)));
409	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
410	>	}
411	>	long startTime = System.nanoTime();
412	>	assertNull(q.poll(timeoutMillis(), MILLISECONDS));
413	>	assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
414	>	checkEmpty(q);
415		}
416
417	<	public void testTimedPollWithOffer(){
418	<	final DelayQueue q = new DelayQueue();
419	<	Thread t = new Thread(new Runnable() {
420	<	public void run(){
421	<	try {
422	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
423	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
424	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
425	<	fail("Should block");
426	<	} catch (InterruptedException success) { }
417	>	/**
418	>	* Interrupted timed poll throws InterruptedException instead of
419	>	* returning timeout status
420	>	*/
421	>	public void testInterruptedTimedPoll() throws InterruptedException {
422	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
423	>	Thread t = newStartedThread(new CheckedRunnable() {
424	>	public void realRun() throws InterruptedException {
425	>	DelayQueue q = populatedQueue(SIZE);
426	>	for (int i = 0; i < SIZE; ++i) {
427	>	assertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, MILLISECONDS)));
428		}
426	–	});
427	–	try {
428	–	t.start();
429	–	Thread.sleep(SHORT_DELAY_MS * 2);
430	–	assertTrue(q.offer(new PDelay(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
431	–	t.interrupt();
432	–	t.join();
433	–	} catch (Exception e){
434	–	fail("Unexpected exception");
435	–	}
436	–	}
429
430	+	Thread.currentThread().interrupt();
431	+	try {
432	+	q.poll(LONG_DELAY_MS, MILLISECONDS);
433	+	shouldThrow();
434	+	} catch (InterruptedException success) {}
435	+	assertFalse(Thread.interrupted());
436	+
437	+	pleaseInterrupt.countDown();
438	+	try {
439	+	q.poll(LONG_DELAY_MS, MILLISECONDS);
440	+	shouldThrow();
441	+	} catch (InterruptedException success) {}
442	+	assertFalse(Thread.interrupted());
443	+	}});
444	+
445	+	await(pleaseInterrupt);
446	+	assertThreadStaysAlive(t);
447	+	t.interrupt();
448	+	awaitTermination(t);
449	+	}
450
451	<	public void testPeek(){
452	<	DelayQueue q = fullQueue(N);
453	<	for (int i = 0; i < N; ++i) {
451	>	/**
452	>	* peek returns next element, or null if empty
453	>	*/
454	>	public void testPeek() {
455	>	DelayQueue q = populatedQueue(SIZE);
456	>	for (int i = 0; i < SIZE; ++i) {
457		assertEquals(new PDelay(i), ((PDelay)q.peek()));
458	<	q.poll();
459	<	assertTrue(q.peek() == null ||
460	<	i != ((PDelay)q.peek()).intValue());
458	>	assertEquals(new PDelay(i), ((PDelay)q.poll()));
459	>	if (q.isEmpty())
460	>	assertNull(q.peek());
461	>	else
462	>	assertFalse(new PDelay(i).equals(q.peek()));
463		}
464	<	assertNull(q.peek());
464	>	assertNull(q.peek());
465		}
466
467	<	public void testElement(){
468	<	DelayQueue q = fullQueue(N);
469	<	for (int i = 0; i < N; ++i) {
467	>	/**
468	>	* element returns next element, or throws NSEE if empty
469	>	*/
470	>	public void testElement() {
471	>	DelayQueue q = populatedQueue(SIZE);
472	>	for (int i = 0; i < SIZE; ++i) {
473		assertEquals(new PDelay(i), ((PDelay)q.element()));
474		q.poll();
475		}
476		try {
477		q.element();
478	<	fail("no such element");
479	<	}
460	<	catch (NoSuchElementException success) {}
478	>	shouldThrow();
479	>	} catch (NoSuchElementException success) {}
480		}
481
482	<	public void testRemove(){
483	<	DelayQueue q = fullQueue(N);
484	<	for (int i = 0; i < N; ++i) {
482	>	/**
483	>	* remove removes next element, or throws NSEE if empty
484	>	*/
485	>	public void testRemove() {
486	>	DelayQueue q = populatedQueue(SIZE);
487	>	for (int i = 0; i < SIZE; ++i) {
488		assertEquals(new PDelay(i), ((PDelay)q.remove()));
489		}
490		try {
491		q.remove();
492	<	fail("remove should throw");
493	<	} catch (NoSuchElementException success){
472	<	}
492	>	shouldThrow();
493	>	} catch (NoSuchElementException success) {}
494		}
495
496	<	public void testRemoveElement(){
497	<	DelayQueue q = fullQueue(N);
498	<	for (int i = 1; i < N; i+=2) {
496	>	/**
497	>	* remove(x) removes x and returns true if present
498	>	*/
499	>	public void testRemoveElement() {
500	>	DelayQueue q = populatedQueue(SIZE);
501	>	for (int i = 1; i < SIZE; i+=2) {
502		assertTrue(q.remove(new PDelay(i)));
503		}
504	<	for (int i = 0; i < N; i+=2) {
504	>	for (int i = 0; i < SIZE; i+=2) {
505		assertTrue(q.remove(new PDelay(i)));
506		assertFalse(q.remove(new PDelay(i+1)));
507		}
508		assertTrue(q.isEmpty());
509		}
510	<
511	<	public void testContains(){
512	<	DelayQueue q = fullQueue(N);
513	<	for (int i = 0; i < N; ++i) {
510	>
511	>	/**
512	>	* contains(x) reports true when elements added but not yet removed
513	>	*/
514	>	public void testContains() {
515	>	DelayQueue q = populatedQueue(SIZE);
516	>	for (int i = 0; i < SIZE; ++i) {
517		assertTrue(q.contains(new PDelay(i)));
518		q.poll();
519		assertFalse(q.contains(new PDelay(i)));
520		}
521		}
522
523	<	public void testClear(){
524	<	DelayQueue q = fullQueue(N);
523	>	/**
524	>	* clear removes all elements
525	>	*/
526	>	public void testClear() {
527	>	DelayQueue q = populatedQueue(SIZE);
528		q.clear();
529		assertTrue(q.isEmpty());
530		assertEquals(0, q.size());
531		assertEquals(NOCAP, q.remainingCapacity());
532	<	q.add(new PDelay(1));
532	>	PDelay x = new PDelay(1);
533	>	q.add(x);
534		assertFalse(q.isEmpty());
535	+	assertTrue(q.contains(x));
536		q.clear();
537		assertTrue(q.isEmpty());
538		}
539
540	<	public void testContainsAll(){
541	<	DelayQueue q = fullQueue(N);
540	>	/**
541	>	* containsAll(c) is true when c contains a subset of elements
542	>	*/
543	>	public void testContainsAll() {
544	>	DelayQueue q = populatedQueue(SIZE);
545		DelayQueue p = new DelayQueue();
546	<	for (int i = 0; i < N; ++i) {
546	>	for (int i = 0; i < SIZE; ++i) {
547		assertTrue(q.containsAll(p));
548		assertFalse(p.containsAll(q));
549		p.add(new PDelay(i));
#	Line 516 | Line 551 | public class DelayQueueTest extends Test
551		assertTrue(p.containsAll(q));
552		}
553
554	<	public void testRetainAll(){
555	<	DelayQueue q = fullQueue(N);
556	<	DelayQueue p = fullQueue(N);
557	<	for (int i = 0; i < N; ++i) {
554	>	/**
555	>	* retainAll(c) retains only those elements of c and reports true if changed
556	>	*/
557	>	public void testRetainAll() {
558	>	DelayQueue q = populatedQueue(SIZE);
559	>	DelayQueue p = populatedQueue(SIZE);
560	>	for (int i = 0; i < SIZE; ++i) {
561		boolean changed = q.retainAll(p);
562		if (i == 0)
563		assertFalse(changed);
#	Line 527 | Line 565 | public class DelayQueueTest extends Test
565		assertTrue(changed);
566
567		assertTrue(q.containsAll(p));
568	<	assertEquals(N-i, q.size());
568	>	assertEquals(SIZE-i, q.size());
569		p.remove();
570		}
571		}
572
573	<	public void testRemoveAll(){
574	<	for (int i = 1; i < N; ++i) {
575	<	DelayQueue q = fullQueue(N);
576	<	DelayQueue p = fullQueue(i);
573	>	/**
574	>	* removeAll(c) removes only those elements of c and reports true if changed
575	>	*/
576	>	public void testRemoveAll() {
577	>	for (int i = 1; i < SIZE; ++i) {
578	>	DelayQueue q = populatedQueue(SIZE);
579	>	DelayQueue p = populatedQueue(i);
580		assertTrue(q.removeAll(p));
581	<	assertEquals(N-i, q.size());
581	>	assertEquals(SIZE-i, q.size());
582		for (int j = 0; j < i; ++j) {
583		PDelay I = (PDelay)(p.remove());
584		assertFalse(q.contains(I));
#	Line 545 | Line 586 | public class DelayQueueTest extends Test
586		}
587		}
588
589	<	/*
590	<	public void testEqualsAndHashCode(){
591	<	DelayQueue q1 = fullQueue(N);
592	<	DelayQueue q2 = fullQueue(N);
593	<	assertTrue(q1.equals(q2));
594	<	assertTrue(q2.equals(q1));
554	<	assertEquals(q1.hashCode(), q2.hashCode());
555	<	q1.remove();
556	<	assertFalse(q1.equals(q2));
557	<	assertFalse(q2.equals(q1));
558	<	assertFalse(q1.hashCode() == q2.hashCode());
559	<	q2.remove();
560	<	assertTrue(q1.equals(q2));
561	<	assertTrue(q2.equals(q1));
562	<	assertEquals(q1.hashCode(), q2.hashCode());
563	<	}
564	<	*/
565	<
566	<	public void testToArray(){
567	<	DelayQueue q = fullQueue(N);
568	<	Object[] o = q.toArray();
589	>	/**
590	>	* toArray contains all elements
591	>	*/
592	>	public void testToArray() throws InterruptedException {
593	>	DelayQueue q = populatedQueue(SIZE);
594	>	Object[] o = q.toArray();
595		Arrays.sort(o);
596	<	try {
597	<	for(int i = 0; i < o.length; i++)
572	<	assertEquals(o[i], q.take());
573	<	} catch (InterruptedException e){
574	<	fail("Unexpected exception");
575	<	}
596	>	for (int i = 0; i < o.length; i++)
597	>	assertSame(o[i], q.take());
598		}
599
600	<	public void testToArray2(){
601	<	DelayQueue q = fullQueue(N);
602	<	PDelay[] ints = new PDelay[N];
603	<	ints = (PDelay[])q.toArray(ints);
600	>	/**
601	>	* toArray(a) contains all elements
602	>	*/
603	>	public void testToArray2() {
604	>	DelayQueue<PDelay> q = populatedQueue(SIZE);
605	>	PDelay[] ints = new PDelay[SIZE];
606	>	PDelay[] array = q.toArray(ints);
607	>	assertSame(ints, array);
608		Arrays.sort(ints);
609	<	try {
610	<	for(int i = 0; i < ints.length; i++)
611	<	assertEquals(ints[i], q.take());
612	<	} catch (InterruptedException e){
613	<	fail("Unexpected exception");
614	<	}
615	<	}
616	<
617	<	public void testIterator(){
618	<	DelayQueue q = fullQueue(N);
609	>	for (int i = 0; i < ints.length; i++)
610	>	assertSame(ints[i], q.remove());
611	>	}
612	>
613	>	/**
614	>	* toArray(incompatible array type) throws ArrayStoreException
615	>	*/
616	>	public void testToArray1_BadArg() {
617	>	DelayQueue q = populatedQueue(SIZE);
618	>	try {
619	>	q.toArray(new String[10]);
620	>	shouldThrow();
621	>	} catch (ArrayStoreException success) {}
622	>	}
623	>
624	>	/**
625	>	* iterator iterates through all elements
626	>	*/
627	>	public void testIterator() {
628	>	DelayQueue q = populatedQueue(SIZE);
629		int i = 0;
630	<	Iterator it = q.iterator();
631	<	while(it.hasNext()) {
630	>	Iterator it = q.iterator();
631	>	while (it.hasNext()) {
632		assertTrue(q.contains(it.next()));
633		++i;
634		}
635	<	assertEquals(i, N);
635	>	assertEquals(i, SIZE);
636		}
637
638	<	public void testIteratorRemove () {
639	<
638	>	/**
639	>	* iterator.remove removes current element
640	>	*/
641	>	public void testIteratorRemove() {
642		final DelayQueue q = new DelayQueue();
605	–
643		q.add(new PDelay(2));
644		q.add(new PDelay(1));
645		q.add(new PDelay(3));
609	–
646		Iterator it = q.iterator();
647		it.next();
648		it.remove();
613	–
649		it = q.iterator();
650		assertEquals(it.next(), new PDelay(2));
651		assertEquals(it.next(), new PDelay(3));
652		assertFalse(it.hasNext());
653		}
654
655	<
656	<	public void testToString(){
657	<	DelayQueue q = fullQueue(N);
655	>	/**
656	>	* toString contains toStrings of elements
657	>	*/
658	>	public void testToString() {
659	>	DelayQueue q = populatedQueue(SIZE);
660		String s = q.toString();
661	<	for (int i = 0; i < N; ++i) {
662	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
661	>	for (int i = 0; i < SIZE; ++i) {
662	>	assertTrue(s.contains(String.valueOf(Integer.MIN_VALUE+i)));
663		}
664	<	}
664	>	}
665
666	+	/**
667	+	* timed poll transfers elements across Executor tasks
668	+	*/
669		public void testPollInExecutor() {
630	–
670		final DelayQueue q = new DelayQueue();
671	<
671	>	final CheckedBarrier threadsStarted = new CheckedBarrier(2);
672		ExecutorService executor = Executors.newFixedThreadPool(2);
673	+	executor.execute(new CheckedRunnable() {
674	+	public void realRun() throws InterruptedException {
675	+	assertNull(q.poll());
676	+	threadsStarted.await();
677	+	assertTrue(null != q.poll(LONG_DELAY_MS, MILLISECONDS));
678	+	checkEmpty(q);
679	+	}});
680	+
681	+	executor.execute(new CheckedRunnable() {
682	+	public void realRun() throws InterruptedException {
683	+	threadsStarted.await();
684	+	q.put(new PDelay(1));
685	+	}});
686
687	<	executor.execute(new Runnable() {
636	<	public void run() {
637	<	assertNull("poll should fail", q.poll());
638	<	try {
639	<	assertTrue(null != q.poll(MEDIUM_DELAY_MS * 2, TimeUnit.MILLISECONDS));
640	<	assertTrue(q.isEmpty());
641	<	}
642	<	catch (InterruptedException e) {
643	<	fail("should not be interrupted");
644	<	}
645	<	}
646	<	});
647	<
648	<	executor.execute(new Runnable() {
649	<	public void run() {
650	<	try {
651	<	Thread.sleep(MEDIUM_DELAY_MS);
652	<	q.put(new PDelay(1));
653	<	}
654	<	catch (InterruptedException e) {
655	<	fail("should not be interrupted");
656	<	}
657	<	}
658	<	});
659	<
660	<	executor.shutdown();
661	<
687	>	joinPool(executor);
688		}
689
690	<	static class NanoDelay implements Delayed {
691	<	long trigger;
692	<	NanoDelay(long i) {
693	<	trigger = System.nanoTime() + i;
694	<	}
695	<	public int compareTo(Object y) {
696	<	long i = trigger;
697	<	long j = ((NanoDelay)y).trigger;
698	<	if (i < j) return -1;
699	<	if (i > j) return 1;
700	<	return 0;
701	<	}
702	<
703	<	public int compareTo(NanoDelay y) {
704	<	long i = trigger;
705	<	long j = ((NanoDelay)y).trigger;
680	<	if (i < j) return -1;
681	<	if (i > j) return 1;
682	<	return 0;
683	<	}
684	<
685	<	public boolean equals(Object other) {
686	<	return ((NanoDelay)other).trigger == trigger;
687	<	}
688	<	public boolean equals(NanoDelay other) {
689	<	return ((NanoDelay)other).trigger == trigger;
690	>	/**
691	>	* Delayed actions do not occur until their delay elapses
692	>	*/
693	>	public void testDelay() throws InterruptedException {
694	>	DelayQueue<NanoDelay> q = new DelayQueue<NanoDelay>();
695	>	for (int i = 0; i < SIZE; ++i)
696	>	q.add(new NanoDelay(1000000L * (SIZE - i)));
697	>
698	>	long last = 0;
699	>	for (int i = 0; i < SIZE; ++i) {
700	>	NanoDelay e = q.take();
701	>	long tt = e.getTriggerTime();
702	>	assertTrue(System.nanoTime() - tt >= 0);
703	>	if (i != 0)
704	>	assertTrue(tt >= last);
705	>	last = tt;
706		}
707	+	assertTrue(q.isEmpty());
708	+	}
709
710	<	public long getDelay(TimeUnit unit) {
711	<	long n = trigger - System.nanoTime();
712	<	return unit.convert(n, TimeUnit.NANOSECONDS);
713	<	}
710	>	/**
711	>	* peek of a non-empty queue returns non-null even if not expired
712	>	*/
713	>	public void testPeekDelayed() {
714	>	DelayQueue q = new DelayQueue();
715	>	q.add(new NanoDelay(Long.MAX_VALUE));
716	>	assertNotNull(q.peek());
717	>	}
718
719	<	public long getTriggerTime() {
720	<	return trigger;
721	<	}
719	>	/**
720	>	* poll of a non-empty queue returns null if no expired elements.
721	>	*/
722	>	public void testPollDelayed() {
723	>	DelayQueue q = new DelayQueue();
724	>	q.add(new NanoDelay(Long.MAX_VALUE));
725	>	assertNull(q.poll());
726	>	}
727
728	<	public String toString() {
729	<	return String.valueOf(trigger);
730	<	}
728	>	/**
729	>	* timed poll of a non-empty queue returns null if no expired elements.
730	>	*/
731	>	public void testTimedPollDelayed() throws InterruptedException {
732	>	DelayQueue q = new DelayQueue();
733	>	q.add(new NanoDelay(LONG_DELAY_MS * 1000000L));
734	>	assertNull(q.poll(timeoutMillis(), MILLISECONDS));
735		}
736
737	<	public void testDelay() {
737	>	/**
738	>	* drainTo(c) empties queue into another collection c
739	>	*/
740	>	public void testDrainTo() {
741		DelayQueue q = new DelayQueue();
742	<	NanoDelay[] elements = new NanoDelay[N];
743	<	for (int i = 0; i < N; ++i) {
744	<	elements[i] = new NanoDelay(1000000000L + 1000000L * (N - i));
745	<	}
746	<	for (int i = 0; i < N; ++i) {
747	<	q.add(elements[i]);
748	<	}
742	>	PDelay[] elems = new PDelay[SIZE];
743	>	for (int i = 0; i < SIZE; ++i) {
744	>	elems[i] = new PDelay(i);
745	>	q.add(elems[i]);
746	>	}
747	>	ArrayList l = new ArrayList();
748	>	q.drainTo(l);
749	>	assertEquals(q.size(), 0);
750	>	for (int i = 0; i < SIZE; ++i)
751	>	assertEquals(l.get(i), elems[i]);
752	>	q.add(elems[0]);
753	>	q.add(elems[1]);
754	>	assertFalse(q.isEmpty());
755	>	assertTrue(q.contains(elems[0]));
756	>	assertTrue(q.contains(elems[1]));
757	>	l.clear();
758	>	q.drainTo(l);
759	>	assertEquals(q.size(), 0);
760	>	assertEquals(l.size(), 2);
761	>	for (int i = 0; i < 2; ++i)
762	>	assertEquals(l.get(i), elems[i]);
763	>	}
764
765	<	try {
766	<	long last = 0;
767	<	for (int i = 0; i < N; ++i) {
768	<	NanoDelay e = (NanoDelay)(q.take());
769	<	long tt = e.getTriggerTime();
770	<	assertTrue(tt <= System.nanoTime());
771	<	if (i != 0)
772	<	assertTrue(tt >= last);
773	<	last = tt;
774	<	}
775	<	}
776	<	catch(InterruptedException ie) {
777	<	fail("Unexpected Exception");
765	>	/**
766	>	* drainTo empties queue
767	>	*/
768	>	public void testDrainToWithActivePut() throws InterruptedException {
769	>	final DelayQueue q = populatedQueue(SIZE);
770	>	Thread t = new Thread(new CheckedRunnable() {
771	>	public void realRun() {
772	>	q.put(new PDelay(SIZE+1));
773	>	}});
774	>
775	>	t.start();
776	>	ArrayList l = new ArrayList();
777	>	q.drainTo(l);
778	>	assertTrue(l.size() >= SIZE);
779	>	t.join();
780	>	assertTrue(q.size() + l.size() >= SIZE);
781	>	}
782	>
783	>	/**
784	>	* drainTo(c, n) empties first min(n, size) elements of queue into c
785	>	*/
786	>	public void testDrainToN() {
787	>	for (int i = 0; i < SIZE + 2; ++i) {
788	>	DelayQueue q = populatedQueue(SIZE);
789	>	ArrayList l = new ArrayList();
790	>	q.drainTo(l, i);
791	>	int k = (i < SIZE) ? i : SIZE;
792	>	assertEquals(q.size(), SIZE-k);
793	>	assertEquals(l.size(), k);
794		}
795		}
796

Diff Legend

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