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.17 by jsr166, Mon Nov 16 05:30:07 2009 UTC vs.
Revision 1.21 by jsr166, Sat Nov 21 10:29:50 2009 UTC

#	Line 8 | Line 8
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;
#	Line 119 | 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
#	Line 143 | Line 144 | public class DelayQueueTest extends JSR1
144		try {
145		DelayQueue q = new DelayQueue(null);
146		shouldThrow();
147	<	}
147	<	catch (NullPointerException success) {}
147	>	} catch (NullPointerException success) {}
148		}
149
150		/**
#	Line 155 | Line 155 | public class DelayQueueTest extends JSR1
155		PDelay[] ints = new PDelay[SIZE];
156		DelayQueue q = new DelayQueue(Arrays.asList(ints));
157		shouldThrow();
158	<	}
159	<	catch (NullPointerException success) {}
158	>	} catch (NullPointerException success) {}
159		}
160
161		/**
#	Line 169 | Line 168 | public class DelayQueueTest extends JSR1
168		ints[i] = new PDelay(i);
169		DelayQueue q = new DelayQueue(Arrays.asList(ints));
170		shouldThrow();
171	<	}
173	<	catch (NullPointerException success) {}
171	>	} catch (NullPointerException success) {}
172		}
173
174		/**
175		* Queue contains all elements of collection used to initialize
176		*/
177		public void testConstructor6() {
178	<	try {
179	<	PDelay[] ints = new PDelay[SIZE];
180	<	for (int i = 0; i < SIZE; ++i)
181	<	ints[i] = new PDelay(i);
182	<	DelayQueue q = new DelayQueue(Arrays.asList(ints));
183	<	for (int i = 0; i < SIZE; ++i)
186	<	assertEquals(ints[i], q.poll());
187	<	}
188	<	finally {}
178	>	PDelay[] ints = new PDelay[SIZE];
179	>	for (int i = 0; i < SIZE; ++i)
180	>	ints[i] = new PDelay(i);
181	>	DelayQueue q = new DelayQueue(Arrays.asList(ints));
182	>	for (int i = 0; i < SIZE; ++i)
183	>	assertEquals(ints[i], q.poll());
184		}
185
186		/**
#	Line 225 | Line 220 | public class DelayQueueTest extends JSR1
220		* offer(null) throws NPE
221		*/
222		public void testOfferNull() {
223	<	try {
223	>	try {
224		DelayQueue q = new DelayQueue();
225		q.offer(null);
226		shouldThrow();
227	<	} catch (NullPointerException success) { }
227	>	} catch (NullPointerException success) {}
228		}
229
230		/**
231		* add(null) throws NPE
232		*/
233		public void testAddNull() {
234	<	try {
234	>	try {
235		DelayQueue q = new DelayQueue();
236		q.add(null);
237		shouldThrow();
238	<	} catch (NullPointerException success) { }
238	>	} catch (NullPointerException success) {}
239		}
240
241		/**
#	Line 271 | Line 266 | public class DelayQueueTest extends JSR1
266		DelayQueue q = new DelayQueue();
267		q.addAll(null);
268		shouldThrow();
269	<	}
275	<	catch (NullPointerException success) {}
269	>	} catch (NullPointerException success) {}
270		}
271
272
#	Line 284 | Line 278 | public class DelayQueueTest extends JSR1
278		DelayQueue q = populatedQueue(SIZE);
279		q.addAll(q);
280		shouldThrow();
281	<	}
288	<	catch (IllegalArgumentException success) {}
281	>	} catch (IllegalArgumentException success) {}
282		}
283
284		/**
#	Line 297 | Line 290 | public class DelayQueueTest extends JSR1
290		PDelay[] ints = new PDelay[SIZE];
291		q.addAll(Arrays.asList(ints));
292		shouldThrow();
293	<	}
301	<	catch (NullPointerException success) {}
293	>	} catch (NullPointerException success) {}
294		}
295		/**
296		* addAll of a collection with any null elements throws NPE after
#	Line 312 | Line 304 | public class DelayQueueTest extends JSR1
304		ints[i] = new PDelay(i);
305		q.addAll(Arrays.asList(ints));
306		shouldThrow();
307	<	}
316	<	catch (NullPointerException success) {}
307	>	} catch (NullPointerException success) {}
308		}
309
310		/**
311		* Queue contains all elements of successful addAll
312		*/
313		public void testAddAll5() {
314	<	try {
315	<	PDelay[] empty = new PDelay[0];
316	<	PDelay[] ints = new PDelay[SIZE];
317	<	for (int i = SIZE-1; i >= 0; --i)
318	<	ints[i] = new PDelay(i);
319	<	DelayQueue q = new DelayQueue();
320	<	assertFalse(q.addAll(Arrays.asList(empty)));
321	<	assertTrue(q.addAll(Arrays.asList(ints)));
322	<	for (int i = 0; i < SIZE; ++i)
332	<	assertEquals(ints[i], q.poll());
333	<	}
334	<	finally {}
314	>	PDelay[] empty = new PDelay[0];
315	>	PDelay[] ints = new PDelay[SIZE];
316	>	for (int i = SIZE-1; i >= 0; --i)
317	>	ints[i] = new PDelay(i);
318	>	DelayQueue q = new DelayQueue();
319	>	assertFalse(q.addAll(Arrays.asList(empty)));
320	>	assertTrue(q.addAll(Arrays.asList(ints)));
321	>	for (int i = 0; i < SIZE; ++i)
322	>	assertEquals(ints[i], q.poll());
323		}
324
325		/**
326		* put(null) throws NPE
327		*/
328		public void testPutNull() {
329	<	try {
329	>	try {
330		DelayQueue q = new DelayQueue();
331		q.put(null);
332		shouldThrow();
333	<	}
346	<	catch (NullPointerException success) {
347	<	}
333	>	} catch (NullPointerException success) {}
334		}
335
336		/**
337		* all elements successfully put are contained
338		*/
339		public void testPut() {
340	<	try {
341	<	DelayQueue q = new DelayQueue();
342	<	for (int i = 0; i < SIZE; ++i) {
343	<	PDelay I = new PDelay(i);
344	<	q.put(I);
359	<	assertTrue(q.contains(I));
360	<	}
361	<	assertEquals(SIZE, q.size());
340	>	DelayQueue q = new DelayQueue();
341	>	for (int i = 0; i < SIZE; ++i) {
342	>	PDelay I = new PDelay(i);
343	>	q.put(I);
344	>	assertTrue(q.contains(I));
345		}
346	<	finally {
364	<	}
346	>	assertEquals(SIZE, q.size());
347		}
348
349		/**
350		* put doesn't block waiting for take
351		*/
352	<	public void testPutWithTake() {
352	>	public void testPutWithTake() throws InterruptedException {
353		final DelayQueue q = new DelayQueue();
354	<	Thread t = new Thread(new Runnable() {
355	<	public void run() {
356	<	int added = 0;
357	<	try {
358	<	q.put(new PDelay(0));
359	<	++added;
360	<	q.put(new PDelay(0));
361	<	++added;
362	<	q.put(new PDelay(0));
363	<	++added;
364	<	q.put(new PDelay(0));
365	<	++added;
366	<	threadAssertTrue(added == 4);
385	<	} finally {
386	<	}
387	<	}
388	<	});
389	<	try {
390	<	t.start();
391	<	Thread.sleep(SHORT_DELAY_MS);
392	<	q.take();
393	<	t.interrupt();
394	<	t.join();
395	<	} catch (Exception e) {
396	<	unexpectedException();
397	<	}
354	>	Thread t = new Thread(new CheckedRunnable() {
355	>	public void realRun() {
356	>	q.put(new PDelay(0));
357	>	q.put(new PDelay(0));
358	>	q.put(new PDelay(0));
359	>	q.put(new PDelay(0));
360	>	}});
361	>
362	>	t.start();
363	>	Thread.sleep(SHORT_DELAY_MS);
364	>	q.take();
365	>	t.interrupt();
366	>	t.join();
367		}
368
369		/**
370		* timed offer does not time out
371		*/
372	<	public void testTimedOffer() {
372	>	public void testTimedOffer() throws InterruptedException {
373		final DelayQueue q = new DelayQueue();
374	<	Thread t = new Thread(new Runnable() {
375	<	public void run() {
376	<	try {
377	<	q.put(new PDelay(0));
378	<	q.put(new PDelay(0));
379	<	threadAssertTrue(q.offer(new PDelay(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
380	<	threadAssertTrue(q.offer(new PDelay(0), LONG_DELAY_MS, TimeUnit.MILLISECONDS));
412	<	} finally { }
413	<	}
414	<	});
374	>	Thread t = new Thread(new CheckedRunnable() {
375	>	public void realRun() throws InterruptedException {
376	>	q.put(new PDelay(0));
377	>	q.put(new PDelay(0));
378	>	threadAssertTrue(q.offer(new PDelay(0), SHORT_DELAY_MS, MILLISECONDS));
379	>	threadAssertTrue(q.offer(new PDelay(0), LONG_DELAY_MS, MILLISECONDS));
380	>	}});
381
382	<	try {
383	<	t.start();
384	<	Thread.sleep(SMALL_DELAY_MS);
385	<	t.interrupt();
420	<	t.join();
421	<	} catch (Exception e) {
422	<	unexpectedException();
423	<	}
382	>	t.start();
383	>	Thread.sleep(SMALL_DELAY_MS);
384	>	t.interrupt();
385	>	t.join();
386		}
387
388		/**
389		* take retrieves elements in priority order
390		*/
391	<	public void testTake() {
392	<	try {
393	<	DelayQueue q = populatedQueue(SIZE);
394	<	for (int i = 0; i < SIZE; ++i) {
395	<	assertEquals(new PDelay(i), ((PDelay)q.take()));
434	<	}
435	<	} catch (InterruptedException e) {
436	<	unexpectedException();
437	<	}
391	>	public void testTake() throws InterruptedException {
392	>	DelayQueue q = populatedQueue(SIZE);
393	>	for (int i = 0; i < SIZE; ++i) {
394	>	assertEquals(new PDelay(i), ((PDelay)q.take()));
395	>	}
396		}
397
398		/**
399		* take blocks interruptibly when empty
400		*/
401	<	public void testTakeFromEmpty() {
401	>	public void testTakeFromEmpty() throws InterruptedException {
402		final DelayQueue q = new DelayQueue();
403	<	Thread t = new Thread(new Runnable() {
404	<	public void run() {
405	<	try {
406	<	q.take();
407	<	threadShouldThrow();
408	<	} catch (InterruptedException success) { }
409	<	}
410	<	});
411	<	try {
454	<	t.start();
455	<	Thread.sleep(SHORT_DELAY_MS);
456	<	t.interrupt();
457	<	t.join();
458	<	} catch (Exception e) {
459	<	unexpectedException();
460	<	}
403	>	Thread t = new ThreadShouldThrow(InterruptedException.class) {
404	>	public void realRun() throws InterruptedException {
405	>	q.take();
406	>	}};
407	>
408	>	t.start();
409	>	Thread.sleep(SHORT_DELAY_MS);
410	>	t.interrupt();
411	>	t.join();
412		}
413
414		/**
415		* Take removes existing elements until empty, then blocks interruptibly
416		*/
417	<	public void testBlockingTake() {
418	<	Thread t = new Thread(new Runnable() {
419	<	public void run() {
420	<	try {
421	<	DelayQueue q = populatedQueue(SIZE);
422	<	for (int i = 0; i < SIZE; ++i) {
423	<	threadAssertEquals(new PDelay(i), ((PDelay)q.take()));
424	<	}
425	<	q.take();
426	<	threadShouldThrow();
476	<	} catch (InterruptedException success) {
477	<	}
478	<	}});
417	>	public void testBlockingTake() throws InterruptedException {
418	>	Thread t = new ThreadShouldThrow(InterruptedException.class) {
419	>	public void realRun() throws InterruptedException {
420	>	DelayQueue q = populatedQueue(SIZE);
421	>	for (int i = 0; i < SIZE; ++i) {
422	>	threadAssertEquals(new PDelay(i), ((PDelay)q.take()));
423	>	}
424	>	q.take();
425	>	}};
426	>
427		t.start();
428	<	try {
429	<	Thread.sleep(SHORT_DELAY_MS);
430	<	t.interrupt();
483	<	t.join();
484	<	}
485	<	catch (InterruptedException ie) {
486	<	unexpectedException();
487	<	}
428	>	Thread.sleep(SHORT_DELAY_MS);
429	>	t.interrupt();
430	>	t.join();
431		}
432
433
#	Line 496 | Line 439 | public class DelayQueueTest extends JSR1
439		for (int i = 0; i < SIZE; ++i) {
440		assertEquals(new PDelay(i), ((PDelay)q.poll()));
441		}
442	<	assertNull(q.poll());
442	>	assertNull(q.poll());
443		}
444
445		/**
446		* timed pool with zero timeout succeeds when non-empty, else times out
447		*/
448	<	public void testTimedPoll0() {
449	<	try {
450	<	DelayQueue q = populatedQueue(SIZE);
451	<	for (int i = 0; i < SIZE; ++i) {
452	<	assertEquals(new PDelay(i), ((PDelay)q.poll(0, TimeUnit.MILLISECONDS)));
453	<	}
511	<	assertNull(q.poll(0, TimeUnit.MILLISECONDS));
512	<	} catch (InterruptedException e) {
513	<	unexpectedException();
514	<	}
448	>	public void testTimedPoll0() throws InterruptedException {
449	>	DelayQueue q = populatedQueue(SIZE);
450	>	for (int i = 0; i < SIZE; ++i) {
451	>	assertEquals(new PDelay(i), ((PDelay)q.poll(0, MILLISECONDS)));
452	>	}
453	>	assertNull(q.poll(0, MILLISECONDS));
454		}
455
456		/**
457		* timed pool with nonzero timeout succeeds when non-empty, else times out
458		*/
459	<	public void testTimedPoll() {
460	<	try {
461	<	DelayQueue q = populatedQueue(SIZE);
462	<	for (int i = 0; i < SIZE; ++i) {
463	<	assertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)));
464	<	}
526	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
527	<	} catch (InterruptedException e) {
528	<	unexpectedException();
529	<	}
459	>	public void testTimedPoll() throws InterruptedException {
460	>	DelayQueue q = populatedQueue(SIZE);
461	>	for (int i = 0; i < SIZE; ++i) {
462	>	assertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, MILLISECONDS)));
463	>	}
464	>	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
465		}
466
467		/**
468		* Interrupted timed poll throws InterruptedException instead of
469		* returning timeout status
470		*/
471	<	public void testInterruptedTimedPoll() {
472	<	Thread t = new Thread(new Runnable() {
473	<	public void run() {
474	<	try {
475	<	DelayQueue q = populatedQueue(SIZE);
476	<	for (int i = 0; i < SIZE; ++i) {
477	<	threadAssertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS)));
478	<	}
479	<	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
480	<	} catch (InterruptedException success) {
481	<	}
482	<	}});
471	>	public void testInterruptedTimedPoll() throws InterruptedException {
472	>	Thread t = new Thread(new CheckedRunnable() {
473	>	public void realRun() throws InterruptedException {
474	>	DelayQueue q = populatedQueue(SIZE);
475	>	for (int i = 0; i < SIZE; ++i) {
476	>	assertEquals(new PDelay(i), ((PDelay)q.poll(SHORT_DELAY_MS, MILLISECONDS)));
477	>	}
478	>	try {
479	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
480	>	shouldThrow();
481	>	} catch (InterruptedException success) {}
482	>	}});
483	>
484		t.start();
485	<	try {
486	<	Thread.sleep(SHORT_DELAY_MS);
487	<	t.interrupt();
552	<	t.join();
553	<	}
554	<	catch (InterruptedException ie) {
555	<	unexpectedException();
556	<	}
485	>	Thread.sleep(SHORT_DELAY_MS);
486	>	t.interrupt();
487	>	t.join();
488		}
489
490		/**
491		*  timed poll before a delayed offer fails; after offer succeeds;
492		*  on interruption throws
493		*/
494	<	public void testTimedPollWithOffer() {
494	>	public void testTimedPollWithOffer() throws InterruptedException {
495		final DelayQueue q = new DelayQueue();
496	<	Thread t = new Thread(new Runnable() {
497	<	public void run() {
498	<	try {
499	<	threadAssertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
500	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
501	<	q.poll(LONG_DELAY_MS, TimeUnit.MILLISECONDS);
502	<	threadFail("Should block");
503	<	} catch (InterruptedException success) { }
504	<	}
505	<	});
506	<	try {
507	<	t.start();
508	<	Thread.sleep(SMALL_DELAY_MS);
509	<	assertTrue(q.offer(new PDelay(0), SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
510	<	t.interrupt();
580	<	t.join();
581	<	} catch (Exception e) {
582	<	unexpectedException();
583	<	}
496	>	Thread t = new Thread(new CheckedRunnable() {
497	>	public void realRun() throws InterruptedException {
498	>	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
499	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
500	>	try {
501	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
502	>	shouldThrow();
503	>	} catch (InterruptedException success) {}
504	>	}});
505	>
506	>	t.start();
507	>	Thread.sleep(SMALL_DELAY_MS);
508	>	assertTrue(q.offer(new PDelay(0), SHORT_DELAY_MS, MILLISECONDS));
509	>	t.interrupt();
510	>	t.join();
511		}
512
513
#	Line 597 | Line 524 | public class DelayQueueTest extends JSR1
524		else
525		assertTrue(i != ((PDelay)q.peek()).intValue());
526		}
527	<	assertNull(q.peek());
527	>	assertNull(q.peek());
528		}
529
530		/**
#	Line 612 | Line 539 | public class DelayQueueTest extends JSR1
539		try {
540		q.element();
541		shouldThrow();
542	<	}
616	<	catch (NoSuchElementException success) {}
542	>	} catch (NoSuchElementException success) {}
543		}
544
545		/**
#	Line 627 | Line 553 | public class DelayQueueTest extends JSR1
553		try {
554		q.remove();
555		shouldThrow();
556	<	} catch (NoSuchElementException success) {
631	<	}
556	>	} catch (NoSuchElementException success) {}
557		}
558
559		/**
#	Line 727 | Line 652 | public class DelayQueueTest extends JSR1
652		/**
653		* toArray contains all elements
654		*/
655	<	public void testToArray() {
655	>	public void testToArray() throws InterruptedException {
656		DelayQueue q = populatedQueue(SIZE);
657	<	Object[] o = q.toArray();
657	>	Object[] o = q.toArray();
658		Arrays.sort(o);
659	<	try {
660	<	for (int i = 0; i < o.length; i++)
736	<	assertEquals(o[i], q.take());
737	<	} catch (InterruptedException e) {
738	<	unexpectedException();
739	<	}
659	>	for (int i = 0; i < o.length; i++)
660	>	assertEquals(o[i], q.take());
661		}
662
663		/**
664		* toArray(a) contains all elements
665		*/
666	<	public void testToArray2() {
666	>	public void testToArray2() throws InterruptedException {
667		DelayQueue q = populatedQueue(SIZE);
668	<	PDelay[] ints = new PDelay[SIZE];
669	<	ints = (PDelay[])q.toArray(ints);
668	>	PDelay[] ints = new PDelay[SIZE];
669	>	ints = (PDelay[])q.toArray(ints);
670		Arrays.sort(ints);
671	<	try {
672	<	for (int i = 0; i < ints.length; i++)
752	<	assertEquals(ints[i], q.take());
753	<	} catch (InterruptedException e) {
754	<	unexpectedException();
755	<	}
671	>	for (int i = 0; i < ints.length; i++)
672	>	assertEquals(ints[i], q.take());
673		}
674
675
#	Line 760 | Line 677 | public class DelayQueueTest extends JSR1
677		* toArray(null) throws NPE
678		*/
679		public void testToArray_BadArg() {
680	<	try {
680	>	try {
681		DelayQueue q = populatedQueue(SIZE);
682	<	Object o[] = q.toArray(null);
683	<	shouldThrow();
684	<	} catch (NullPointerException success) {}
682	>	Object o[] = q.toArray(null);
683	>	shouldThrow();
684	>	} catch (NullPointerException success) {}
685		}
686
687		/**
688		* toArray with incompatible array type throws CCE
689		*/
690		public void testToArray1_BadArg() {
691	<	try {
691	>	try {
692		DelayQueue q = populatedQueue(SIZE);
693	<	Object o[] = q.toArray(new String[10] );
694	<	shouldThrow();
695	<	} catch (ArrayStoreException  success) {}
693	>	Object o[] = q.toArray(new String[10] );
694	>	shouldThrow();
695	>	} catch (ArrayStoreException success) {}
696		}
697
698		/**
#	Line 784 | Line 701 | public class DelayQueueTest extends JSR1
701		public void testIterator() {
702		DelayQueue q = populatedQueue(SIZE);
703		int i = 0;
704	<	Iterator it = q.iterator();
704	>	Iterator it = q.iterator();
705		while (it.hasNext()) {
706		assertTrue(q.contains(it.next()));
707		++i;
#	Line 827 | Line 744 | public class DelayQueueTest extends JSR1
744		public void testPollInExecutor() {
745		final DelayQueue q = new DelayQueue();
746		ExecutorService executor = Executors.newFixedThreadPool(2);
747	<	executor.execute(new Runnable() {
748	<	public void run() {
747	>	executor.execute(new CheckedRunnable() {
748	>	public void realRun() throws InterruptedException {
749		threadAssertNull(q.poll());
750	<	try {
751	<	threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS));
752	<	threadAssertTrue(q.isEmpty());
753	<	}
754	<	catch (InterruptedException e) {
755	<	threadUnexpectedException();
756	<	}
757	<	}
758	<	});
750	>	threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
751	>	threadAssertTrue(q.isEmpty());
752	>	}});
753	>
754	>	executor.execute(new CheckedRunnable() {
755	>	public void realRun() throws InterruptedException {
756	>	Thread.sleep(SHORT_DELAY_MS);
757	>	q.put(new PDelay(1));
758	>	}});
759
843	–	executor.execute(new Runnable() {
844	–	public void run() {
845	–	try {
846	–	Thread.sleep(SHORT_DELAY_MS);
847	–	q.put(new PDelay(1));
848	–	}
849	–	catch (InterruptedException e) {
850	–	threadUnexpectedException();
851	–	}
852	–	}
853	–	});
760		joinPool(executor);
761
762		}
#	Line 859 | Line 765 | public class DelayQueueTest extends JSR1
765		/**
766		* Delayed actions do not occur until their delay elapses
767		*/
768	<	public void testDelay() {
768	>	public void testDelay() throws InterruptedException {
769		DelayQueue q = new DelayQueue();
770		NanoDelay[] elements = new NanoDelay[SIZE];
771		for (int i = 0; i < SIZE; ++i) {
#	Line 869 | Line 775 | public class DelayQueueTest extends JSR1
775		q.add(elements[i]);
776		}
777
778	<	try {
779	<	long last = 0;
780	<	for (int i = 0; i < SIZE; ++i) {
781	<	NanoDelay e = (NanoDelay)(q.take());
782	<	long tt = e.getTriggerTime();
783	<	assertTrue(tt <= System.nanoTime());
784	<	if (i != 0)
785	<	assertTrue(tt >= last);
880	<	last = tt;
881	<	}
882	<	}
883	<	catch (InterruptedException ie) {
884	<	unexpectedException();
778	>	long last = 0;
779	>	for (int i = 0; i < SIZE; ++i) {
780	>	NanoDelay e = (NanoDelay)(q.take());
781	>	long tt = e.getTriggerTime();
782	>	assertTrue(tt <= System.nanoTime());
783	>	if (i != 0)
784	>	assertTrue(tt >= last);
785	>	last = tt;
786		}
787		}
788
#	Line 907 | Line 808 | public class DelayQueueTest extends JSR1
808		/**
809		* timed poll of a non-empty queue returns null if no expired elements.
810		*/
811	<	public void testTimedPollDelayed() {
811	>	public void testTimedPollDelayed() throws InterruptedException {
812		DelayQueue q = new DelayQueue();
813		q.add(new NanoDelay(LONG_DELAY_MS * 1000000L));
814	<	try {
914	<	assertNull(q.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS));
915	<	} catch (Exception ex) {
916	<	unexpectedException();
917	<	}
814	>	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
815		}
816
817		/**
#	Line 925 | Line 822 | public class DelayQueueTest extends JSR1
822		try {
823		q.drainTo(null);
824		shouldThrow();
825	<	} catch (NullPointerException success) {
929	<	}
825	>	} catch (NullPointerException success) {}
826		}
827
828		/**
#	Line 937 | Line 833 | public class DelayQueueTest extends JSR1
833		try {
834		q.drainTo(q);
835		shouldThrow();
836	<	} catch (IllegalArgumentException success) {
941	<	}
836	>	} catch (IllegalArgumentException success) {}
837		}
838
839		/**
#	Line 972 | Line 867 | public class DelayQueueTest extends JSR1
867		/**
868		* drainTo empties queue
869		*/
870	<	public void testDrainToWithActivePut() {
870	>	public void testDrainToWithActivePut() throws InterruptedException {
871		final DelayQueue q = populatedQueue(SIZE);
872	<	Thread t = new Thread(new Runnable() {
873	<	public void run() {
874	<	q.put(new PDelay(SIZE+1));
875	<	}
876	<	});
877	<	try {
878	<	t.start();
879	<	ArrayList l = new ArrayList();
880	<	q.drainTo(l);
881	<	assertTrue(l.size() >= SIZE);
882	<	t.join();
988	<	assertTrue(q.size() + l.size() >= SIZE);
989	<	} catch (Exception e) {
990	<	unexpectedException();
991	<	}
872	>	Thread t = new Thread(new CheckedRunnable() {
873	>	public void realRun() {
874	>	q.put(new PDelay(SIZE+1));
875	>	}});
876	>
877	>	t.start();
878	>	ArrayList l = new ArrayList();
879	>	q.drainTo(l);
880	>	assertTrue(l.size() >= SIZE);
881	>	t.join();
882	>	assertTrue(q.size() + l.size() >= SIZE);
883		}
884
885		/**
#	Line 999 | Line 890 | public class DelayQueueTest extends JSR1
890		try {
891		q.drainTo(null, 0);
892		shouldThrow();
893	<	} catch (NullPointerException success) {
1003	<	}
893	>	} catch (NullPointerException success) {}
894		}
895
896		/**
#	Line 1011 | Line 901 | public class DelayQueueTest extends JSR1
901		try {
902		q.drainTo(q, 0);
903		shouldThrow();
904	<	} catch (IllegalArgumentException success) {
1015	<	}
904	>	} catch (IllegalArgumentException success) {}
905		}
906
907		/**

Diff Legend

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