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.20 by jsr166, Sat Nov 21 19:11:53 2009 UTC vs.
Revision 1.38 by jsr166, Fri Nov 5 00:17:22 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());
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 25 | Line 41 | public class PriorityBlockingQueueTest e
41		/** Sample Comparator */
42		static class MyReverseComparator implements Comparator {
43		public int compare(Object x, Object y) {
44	<	int i = ((Integer)x).intValue();
29	<	int j = ((Integer)y).intValue();
30	<	if (i < j) return 1;
31	<	if (i > j) return -1;
32	<	return 0;
44	>	return ((Comparable)y).compareTo(x);
45		}
46		}
47
#	Line 37 | Line 49 | public class PriorityBlockingQueueTest e
49		* Create a queue of given size containing consecutive
50		* Integers 0 ... n.
51		*/
52	<	private PriorityBlockingQueue populatedQueue(int n) {
53	<	PriorityBlockingQueue q = new PriorityBlockingQueue(n);
52	>	private PriorityBlockingQueue<Integer> populatedQueue(int n) {
53	>	PriorityBlockingQueue<Integer> q =
54	>	new PriorityBlockingQueue<Integer>(n);
55		assertTrue(q.isEmpty());
56		for (int i = n-1; i >= 0; i-=2)
57		assertTrue(q.offer(new Integer(i)));
#	Line 249 | Line 262 | public class PriorityBlockingQueueTest e
262		shouldThrow();
263		} catch (NullPointerException success) {}
264		}
265	+
266		/**
267		* addAll of a collection with any null elements throws NPE after
268		* possibly adding some elements
#	Line 332 | Line 346 | public class PriorityBlockingQueueTest e
346		public void realRun() {
347		q.put(new Integer(0));
348		q.put(new Integer(0));
349	<	threadAssertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, MILLISECONDS));
350	<	threadAssertTrue(q.offer(new Integer(0), LONG_DELAY_MS, MILLISECONDS));
349	>	assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, MILLISECONDS));
350	>	assertTrue(q.offer(new Integer(0), LONG_DELAY_MS, MILLISECONDS));
351		}});
352
353		t.start();
#	Line 348 | Line 362 | public class PriorityBlockingQueueTest e
362		public void testTake() throws InterruptedException {
363		PriorityBlockingQueue q = populatedQueue(SIZE);
364		for (int i = 0; i < SIZE; ++i) {
365	<	assertEquals(i, ((Integer)q.take()).intValue());
365	>	assertEquals(i, q.take());
366		}
367		}
368
369		/**
356	–	* take blocks interruptibly when empty
357	–	*/
358	–	public void testTakeFromEmpty() throws InterruptedException {
359	–	final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
360	–	Thread t = new Thread(new CheckedInterruptedRunnable() {
361	–	public void realRun() throws InterruptedException {
362	–	q.take();
363	–	}});
364	–
365	–	t.start();
366	–	Thread.sleep(SHORT_DELAY_MS);
367	–	t.interrupt();
368	–	t.join();
369	–	}
370	–
371	–	/**
370		* Take removes existing elements until empty, then blocks interruptibly
371		*/
372		public void testBlockingTake() throws InterruptedException {
373	<	Thread t = new Thread(new CheckedInterruptedRunnable() {
373	>	final PriorityBlockingQueue q = populatedQueue(SIZE);
374	>	Thread t = new Thread(new CheckedRunnable() {
375		public void realRun() throws InterruptedException {
377	–	PriorityBlockingQueue q = populatedQueue(SIZE);
376		for (int i = 0; i < SIZE; ++i) {
377	<	threadAssertEquals(i, ((Integer)q.take()).intValue());
377	>	assertEquals(i, q.take());
378		}
379	<	q.take();
379	>	try {
380	>	q.take();
381	>	shouldThrow();
382	>	} catch (InterruptedException success) {}
383		}});
384
385		t.start();
#	Line 394 | Line 395 | public class PriorityBlockingQueueTest e
395		public void testPoll() {
396		PriorityBlockingQueue q = populatedQueue(SIZE);
397		for (int i = 0; i < SIZE; ++i) {
398	<	assertEquals(i, ((Integer)q.poll()).intValue());
398	>	assertEquals(i, q.poll());
399		}
400		assertNull(q.poll());
401		}
402
403		/**
404	<	* timed pool with zero timeout succeeds when non-empty, else times out
404	>	* timed poll with zero timeout succeeds when non-empty, else times out
405		*/
406		public void testTimedPoll0() throws InterruptedException {
407		PriorityBlockingQueue q = populatedQueue(SIZE);
408		for (int i = 0; i < SIZE; ++i) {
409	<	assertEquals(i, ((Integer)q.poll(0, MILLISECONDS)).intValue());
409	>	assertEquals(i, q.poll(0, MILLISECONDS));
410		}
411		assertNull(q.poll(0, MILLISECONDS));
412		}
413
414		/**
415	<	* timed pool with nonzero timeout succeeds when non-empty, else times out
415	>	* timed poll with nonzero timeout succeeds when non-empty, else times out
416		*/
417		public void testTimedPoll() throws InterruptedException {
418		PriorityBlockingQueue q = populatedQueue(SIZE);
419		for (int i = 0; i < SIZE; ++i) {
420	<	assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
420	>	assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));
421		}
422		assertNull(q.poll(SHORT_DELAY_MS, MILLISECONDS));
423		}
#	Line 430 | Line 431 | public class PriorityBlockingQueueTest e
431		public void realRun() throws InterruptedException {
432		PriorityBlockingQueue q = populatedQueue(SIZE);
433		for (int i = 0; i < SIZE; ++i) {
434	<	assertEquals(i, ((Integer)q.poll(SHORT_DELAY_MS, MILLISECONDS)).intValue());
434	>	assertEquals(i, q.poll(SHORT_DELAY_MS, MILLISECONDS));
435		}
436		try {
437		q.poll(SMALL_DELAY_MS, MILLISECONDS);
#	Line 445 | Line 446 | public class PriorityBlockingQueueTest e
446		}
447
448		/**
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	–	assertEquals(0, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
457	–	try {
458	–	q.poll(LONG_DELAY_MS, MILLISECONDS);
459	–	threadShouldThrow();
460	–	} catch (InterruptedException success) {}
461	–	}});
462	–
463	–	t.start();
464	–	Thread.sleep(SMALL_DELAY_MS);
465	–	assertTrue(q.offer(new Integer(0), SHORT_DELAY_MS, MILLISECONDS));
466	–	t.interrupt();
467	–	t.join();
468	–	}
469	–
470	–
471	–	/**
449		* peek returns next element, or null if empty
450		*/
451		public void testPeek() {
452		PriorityBlockingQueue q = populatedQueue(SIZE);
453		for (int i = 0; i < SIZE; ++i) {
454	<	assertEquals(i, ((Integer)q.peek()).intValue());
455	<	q.poll();
454	>	assertEquals(i, q.peek());
455	>	assertEquals(i, q.poll());
456		assertTrue(q.peek() == null ||
457	<	i != ((Integer)q.peek()).intValue());
457	>	!q.peek().equals(i));
458		}
459		assertNull(q.peek());
460		}
#	Line 488 | Line 465 | public class PriorityBlockingQueueTest e
465		public void testElement() {
466		PriorityBlockingQueue q = populatedQueue(SIZE);
467		for (int i = 0; i < SIZE; ++i) {
468	<	assertEquals(i, ((Integer)q.element()).intValue());
469	<	q.poll();
468	>	assertEquals(i, q.element());
469	>	assertEquals(i, q.poll());
470		}
471		try {
472		q.element();
#	Line 503 | Line 480 | public class PriorityBlockingQueueTest e
480		public void testRemove() {
481		PriorityBlockingQueue q = populatedQueue(SIZE);
482		for (int i = 0; i < SIZE; ++i) {
483	<	assertEquals(i, ((Integer)q.remove()).intValue());
483	>	assertEquals(i, q.remove());
484		}
485		try {
486		q.remove();
#	Line 603 | Line 580 | public class PriorityBlockingQueueTest e
580		}
581
582		/**
583	<	*  toArray contains all elements
583	>	* toArray contains all elements
584		*/
585		public void testToArray() throws InterruptedException {
586		PriorityBlockingQueue q = populatedQueue(SIZE);
587		Object[] o = q.toArray();
588		Arrays.sort(o);
589		for (int i = 0; i < o.length; i++)
590	<	assertEquals(o[i], q.take());
590	>	assertSame(o[i], q.take());
591		}
592
593		/**
594		* toArray(a) contains all elements
595		*/
596		public void testToArray2() throws InterruptedException {
597	<	PriorityBlockingQueue q = populatedQueue(SIZE);
597	>	PriorityBlockingQueue<Integer> q = populatedQueue(SIZE);
598		Integer[] ints = new Integer[SIZE];
599	<	ints = (Integer[])q.toArray(ints);
599	>	Integer[] array = q.toArray(ints);
600	>	assertSame(ints, array);
601		Arrays.sort(ints);
602		for (int i = 0; i < ints.length; i++)
603	<	assertEquals(ints[i], q.take());
603	>	assertSame(ints[i], q.take());
604		}
605
606		/**
607	<	* toArray(null) throws NPE
607	>	* toArray(null) throws NullPointerException
608		*/
609	<	public void testToArray_BadArg() {
609	>	public void testToArray_NullArg() {
610	>	PriorityBlockingQueue q = populatedQueue(SIZE);
611		try {
612	<	PriorityBlockingQueue q = populatedQueue(SIZE);
634	<	Object o[] = q.toArray(null);
612	>	q.toArray(null);
613		shouldThrow();
614		} catch (NullPointerException success) {}
615		}
616
617		/**
618	<	* toArray with incompatible array type throws CCE
618	>	* toArray(incompatible array type) throws ArrayStoreException
619		*/
620		public void testToArray1_BadArg() {
621	+	PriorityBlockingQueue q = populatedQueue(SIZE);
622		try {
623	<	PriorityBlockingQueue q = populatedQueue(SIZE);
645	<	Object o[] = q.toArray(new String[10] );
623	>	q.toArray(new String[10]);
624		shouldThrow();
625		} catch (ArrayStoreException success) {}
626		}
#	Line 664 | Line 642 | public class PriorityBlockingQueueTest e
642		/**
643		* iterator.remove removes current element
644		*/
645	<	public void testIteratorRemove () {
645	>	public void testIteratorRemove() {
646		final PriorityBlockingQueue q = new PriorityBlockingQueue(3);
647		q.add(new Integer(2));
648		q.add(new Integer(1));
#	Line 700 | Line 678 | public class PriorityBlockingQueueTest e
678		ExecutorService executor = Executors.newFixedThreadPool(2);
679		executor.execute(new CheckedRunnable() {
680		public void realRun() throws InterruptedException {
681	<	threadAssertNull(q.poll());
682	<	threadAssertTrue(null != q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
683	<	threadAssertTrue(q.isEmpty());
681	>	assertNull(q.poll());
682	>	assertSame(one, q.poll(MEDIUM_DELAY_MS, MILLISECONDS));
683	>	assertTrue(q.isEmpty());
684		}});
685
686		executor.execute(new CheckedRunnable() {
687		public void realRun() throws InterruptedException {
688		Thread.sleep(SMALL_DELAY_MS);
689	<	q.put(new Integer(1));
689	>	q.put(one);
690		}});
691
692		joinPool(executor);
#	Line 821 | Line 799 | public class PriorityBlockingQueueTest e
799		}
800
801		/**
802	<	* drainTo(c, n) empties first max {n, size} elements of queue into c
802	>	* drainTo(c, n) empties first min(n, size) elements of queue into c
803		*/
804		public void testDrainToN() {
805		PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE*2);
#	Line 830 | Line 808 | public class PriorityBlockingQueueTest e
808		assertTrue(q.offer(new Integer(j)));
809		ArrayList l = new ArrayList();
810		q.drainTo(l, i);
811	<	int k = (i < SIZE)? i : SIZE;
811	>	int k = (i < SIZE) ? i : SIZE;
812		assertEquals(l.size(), k);
813		assertEquals(q.size(), SIZE-k);
814		for (int j = 0; j < k; ++j)

Diff Legend

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