ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/PriorityBlockingQueueTest.java

Comparing jsr166/src/test/tck/PriorityBlockingQueueTest.java (file contents):
Revision 1.27 by jsr166, Wed Aug 25 01:44:48 2010 UTC vs.
Revision 1.37 by jsr166, Thu Nov 4 01:04:54 2010 UTC

#	Line 13 | Line 13 | import static java.util.concurrent.TimeU
13		import java.io.*;
14
15		public class PriorityBlockingQueueTest extends JSR166TestCase {
16	+
17	+	public static class Generic extends BlockingQueueTest {
18	+	protected BlockingQueue emptyCollection() {
19	+	return new PriorityBlockingQueue();
20	+	}
21	+	}
22	+
23	+	public static class InitialCapacity extends BlockingQueueTest {
24	+	protected BlockingQueue emptyCollection() {
25	+	return new PriorityBlockingQueue(20);
26	+	}
27	+	}
28	+
29		public static void main(String[] args) {
30		junit.textui.TestRunner.run(suite());
31		}
32	+
33		public static Test suite() {
34	<	return new TestSuite(PriorityBlockingQueueTest.class);
34	>	return newTestSuite(PriorityBlockingQueueTest.class,
35	>	new Generic().testSuite(),
36	>	new InitialCapacity().testSuite());
37		}
38
39		private static final int NOCAP = Integer.MAX_VALUE;
#	Line 350 | Line 366 | public class PriorityBlockingQueueTest e
366		}
367
368		/**
353	–	* take blocks interruptibly when empty
354	–	*/
355	–	public void testTakeFromEmpty() throws InterruptedException {
356	–	final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
357	–	Thread t = new Thread(new CheckedInterruptedRunnable() {
358	–	public void realRun() throws InterruptedException {
359	–	q.take();
360	–	}});
361	–
362	–	t.start();
363	–	Thread.sleep(SHORT_DELAY_MS);
364	–	t.interrupt();
365	–	t.join();
366	–	}
367	–
368	–	/**
369		* Take removes existing elements until empty, then blocks interruptibly
370		*/
371		public void testBlockingTake() throws InterruptedException {
#	Line 400 | Line 400 | public class PriorityBlockingQueueTest e
400		}
401
402		/**
403	<	* timed pool with zero timeout succeeds when non-empty, else times out
403	>	* timed poll with zero timeout succeeds when non-empty, else times out
404		*/
405		public void testTimedPoll0() throws InterruptedException {
406		PriorityBlockingQueue q = populatedQueue(SIZE);
#	Line 411 | Line 411 | public class PriorityBlockingQueueTest e
411		}
412
413		/**
414	<	* timed pool with nonzero timeout succeeds when non-empty, else times out
414	>	* timed poll with nonzero timeout succeeds when non-empty, else times out
415		*/
416		public void testTimedPoll() throws InterruptedException {
417		PriorityBlockingQueue q = populatedQueue(SIZE);
#	Line 445 | Line 445 | public class PriorityBlockingQueueTest e
445		}
446
447		/**
448	–	*  timed poll before a delayed offer fails; after offer succeeds;
449	–	*  on interruption throws
450	–	*/
451	–	public void testTimedPollWithOffer() throws InterruptedException {
452	–	final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
453	–	Thread t = new Thread(new CheckedRunnable() {
454	–	public void realRun() throws InterruptedException {
455	–	assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
456	–	assertSame(zero, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
457	–	try {
458	–	q.poll(LONG_DELAY_MS, MILLISECONDS);
459	–	shouldThrow();
460	–	} catch (InterruptedException success) {}
461	–	}});
462	–
463	–	t.start();
464	–	Thread.sleep(SMALL_DELAY_MS);
465	–	assertTrue(q.offer(zero, SHORT_DELAY_MS, MILLISECONDS));
466	–	t.interrupt();
467	–	t.join();
468	–	}
469	–
470	–
471	–	/**
448		* peek returns next element, or null if empty
449		*/
450		public void testPeek() {
#	Line 603 | Line 579 | public class PriorityBlockingQueueTest e
579		}
580
581		/**
582	<	*  toArray contains all elements
582	>	* toArray contains all elements
583		*/
584		public void testToArray() throws InterruptedException {
585		PriorityBlockingQueue q = populatedQueue(SIZE);
586		Object[] o = q.toArray();
587		Arrays.sort(o);
588		for (int i = 0; i < o.length; i++)
589	<	assertEquals(o[i], q.take());
589	>	assertSame(o[i], q.take());
590		}
591
592		/**
#	Line 619 | Line 595 | public class PriorityBlockingQueueTest e
595		public void testToArray2() throws InterruptedException {
596		PriorityBlockingQueue q = populatedQueue(SIZE);
597		Integer[] ints = new Integer[SIZE];
598	<	ints = (Integer[])q.toArray(ints);
598	>	assertSame(ints, q.toArray(ints));
599		Arrays.sort(ints);
600		for (int i = 0; i < ints.length; i++)
601	<	assertEquals(ints[i], q.take());
601	>	assertSame(ints[i], q.take());
602		}
603
604		/**
605	<	* toArray(null) throws NPE
605	>	* toArray(null) throws NullPointerException
606		*/
607	<	public void testToArray_BadArg() {
607	>	public void testToArray_NullArg() {
608		PriorityBlockingQueue q = populatedQueue(SIZE);
609		try {
610	<	Object o[] = q.toArray(null);
610	>	q.toArray(null);
611		shouldThrow();
612		} catch (NullPointerException success) {}
613		}
614
615		/**
616	<	* toArray with incompatible array type throws CCE
616	>	* toArray(incompatible array type) throws ArrayStoreException
617		*/
618		public void testToArray1_BadArg() {
619		PriorityBlockingQueue q = populatedQueue(SIZE);
620		try {
621	<	Object o[] = q.toArray(new String[10]);
621	>	q.toArray(new String[10]);
622		shouldThrow();
623		} catch (ArrayStoreException success) {}
624		}
#	Line 821 | Line 797 | public class PriorityBlockingQueueTest e
797		}
798
799		/**
800	<	* drainTo(c, n) empties first max {n, size} elements of queue into c
800	>	* drainTo(c, n) empties first min(n, size) elements of queue into c
801		*/
802		public void testDrainToN() {
803		PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE*2);
#	Line 830 | Line 806 | public class PriorityBlockingQueueTest e
806		assertTrue(q.offer(new Integer(j)));
807		ArrayList l = new ArrayList();
808		q.drainTo(l, i);
809	<	int k = (i < SIZE)? i : SIZE;
809	>	int k = (i < SIZE) ? i : SIZE;
810		assertEquals(l.size(), k);
811		assertEquals(q.size(), SIZE-k);
812		for (int j = 0; j < k; ++j)

Diff Legend

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