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.45 by jsr166, Mon May 30 22:43:20 2011 UTC vs.
Revision 1.68 by jsr166, Sat Aug 6 17:02:49 2016 UTC

#	Line 6 | Line 6
6		* Pat Fisher, Mike Judd.
7		*/
8
9	<	import junit.framework.*;
10	<	import java.util.Arrays;
9	>	import static java.util.concurrent.TimeUnit.MILLISECONDS;
10	>
11		import java.util.ArrayList;
12	+	import java.util.Arrays;
13		import java.util.Collection;
14		import java.util.Comparator;
15		import java.util.Iterator;
16		import java.util.NoSuchElementException;
17	<	import java.util.concurrent.PriorityBlockingQueue;
17	>	import java.util.Queue;
18		import java.util.concurrent.BlockingQueue;
19		import java.util.concurrent.CountDownLatch;
20		import java.util.concurrent.Executors;
21		import java.util.concurrent.ExecutorService;
22	<	import static java.util.concurrent.TimeUnit.MILLISECONDS;
23	<	import java.io.*;
22	>	import java.util.concurrent.PriorityBlockingQueue;
23	>
24	>	import junit.framework.Test;
25
26		public class PriorityBlockingQueueTest extends JSR166TestCase {
27
#	Line 31 | Line 33 | public class PriorityBlockingQueueTest e
33
34		public static class InitialCapacity extends BlockingQueueTest {
35		protected BlockingQueue emptyCollection() {
36	<	return new PriorityBlockingQueue(20);
36	>	return new PriorityBlockingQueue(SIZE);
37		}
38		}
39
40		public static void main(String[] args) {
41	<	junit.textui.TestRunner.run(suite());
41	>	main(suite(), args);
42		}
43
44		public static Test suite() {
#	Line 45 | Line 47 | public class PriorityBlockingQueueTest e
47		new InitialCapacity().testSuite());
48		}
49
48	–	private static final int NOCAP = Integer.MAX_VALUE;
49	–
50		/** Sample Comparator */
51		static class MyReverseComparator implements Comparator {
52		public int compare(Object x, Object y) {
#	Line 55 | Line 55 | public class PriorityBlockingQueueTest e
55		}
56
57		/**
58	<	* Create a queue of given size containing consecutive
58	>	* Returns a new queue of given size containing consecutive
59		* Integers 0 ... n.
60		*/
61		private PriorityBlockingQueue<Integer> populatedQueue(int n) {
62		PriorityBlockingQueue<Integer> q =
63		new PriorityBlockingQueue<Integer>(n);
64		assertTrue(q.isEmpty());
65	<	for (int i = n-1; i >= 0; i-=2)
65	>	for (int i = n - 1; i >= 0; i -= 2)
66		assertTrue(q.offer(new Integer(i)));
67	<	for (int i = (n & 1); i < n; i+=2)
67	>	for (int i = (n & 1); i < n; i += 2)
68		assertTrue(q.offer(new Integer(i)));
69		assertFalse(q.isEmpty());
70	<	assertEquals(NOCAP, q.remainingCapacity());
70	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
71		assertEquals(n, q.size());
72		return q;
73		}
#	Line 76 | Line 76 | public class PriorityBlockingQueueTest e
76		* A new queue has unbounded capacity
77		*/
78		public void testConstructor1() {
79	<	assertEquals(NOCAP, new PriorityBlockingQueue(SIZE).remainingCapacity());
79	>	assertEquals(Integer.MAX_VALUE,
80	>	new PriorityBlockingQueue(SIZE).remainingCapacity());
81		}
82
83		/**
#	Line 115 | Line 116 | public class PriorityBlockingQueueTest e
116		*/
117		public void testConstructor5() {
118		Integer[] ints = new Integer[SIZE];
119	<	for (int i = 0; i < SIZE-1; ++i)
119	>	for (int i = 0; i < SIZE - 1; ++i)
120		ints[i] = i;
121		Collection<Integer> elements = Arrays.asList(ints);
122		try {
#	Line 147 | Line 148 | public class PriorityBlockingQueueTest e
148		for (int i = 0; i < SIZE; ++i)
149		ints[i] = new Integer(i);
150		q.addAll(Arrays.asList(ints));
151	<	for (int i = SIZE-1; i >= 0; --i)
151	>	for (int i = SIZE - 1; i >= 0; --i)
152		assertEquals(ints[i], q.poll());
153		}
154
#	Line 157 | Line 158 | public class PriorityBlockingQueueTest e
158		public void testEmpty() {
159		PriorityBlockingQueue q = new PriorityBlockingQueue(2);
160		assertTrue(q.isEmpty());
161	<	assertEquals(NOCAP, q.remainingCapacity());
161	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
162		q.add(one);
163		assertFalse(q.isEmpty());
164		q.add(two);
#	Line 167 | Line 168 | public class PriorityBlockingQueueTest e
168		}
169
170		/**
171	<	* remainingCapacity does not change when elements added or removed,
171	<	* but size does
171	>	* remainingCapacity() always returns Integer.MAX_VALUE
172		*/
173		public void testRemainingCapacity() {
174	<	PriorityBlockingQueue q = populatedQueue(SIZE);
174	>	BlockingQueue q = populatedQueue(SIZE);
175		for (int i = 0; i < SIZE; ++i) {
176	<	assertEquals(NOCAP, q.remainingCapacity());
177	<	assertEquals(SIZE-i, q.size());
178	<	q.remove();
176	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
177	>	assertEquals(SIZE - i, q.size());
178	>	assertEquals(i, q.remove());
179		}
180		for (int i = 0; i < SIZE; ++i) {
181	<	assertEquals(NOCAP, q.remainingCapacity());
181	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
182		assertEquals(i, q.size());
183	<	q.add(new Integer(i));
183	>	assertTrue(q.add(i));
184		}
185		}
186
#	Line 197 | Line 197 | public class PriorityBlockingQueueTest e
197		* Offer of non-Comparable throws CCE
198		*/
199		public void testOfferNonComparable() {
200	+	PriorityBlockingQueue q = new PriorityBlockingQueue(1);
201		try {
201	–	PriorityBlockingQueue q = new PriorityBlockingQueue(1);
202	–	q.offer(new Object());
203	–	q.offer(new Object());
202		q.offer(new Object());
203		shouldThrow();
204	<	} catch (ClassCastException success) {}
204	>	} catch (ClassCastException success) {
205	>	assertTrue(q.isEmpty());
206	>	assertEquals(0, q.size());
207	>	assertNull(q.poll());
208	>	}
209		}
210
211		/**
#	Line 221 | Line 223 | public class PriorityBlockingQueueTest e
223		* addAll(this) throws IAE
224		*/
225		public void testAddAllSelf() {
226	+	PriorityBlockingQueue q = populatedQueue(SIZE);
227		try {
225	–	PriorityBlockingQueue q = populatedQueue(SIZE);
228		q.addAll(q);
229		shouldThrow();
230		} catch (IllegalArgumentException success) {}
#	Line 233 | Line 235 | public class PriorityBlockingQueueTest e
235		* possibly adding some elements
236		*/
237		public void testAddAll3() {
238	+	PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
239	+	Integer[] ints = new Integer[SIZE];
240	+	for (int i = 0; i < SIZE - 1; ++i)
241	+	ints[i] = new Integer(i);
242		try {
237	–	PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
238	–	Integer[] ints = new Integer[SIZE];
239	–	for (int i = 0; i < SIZE-1; ++i)
240	–	ints[i] = new Integer(i);
243		q.addAll(Arrays.asList(ints));
244		shouldThrow();
245		} catch (NullPointerException success) {}
#	Line 249 | Line 251 | public class PriorityBlockingQueueTest e
251		public void testAddAll5() {
252		Integer[] empty = new Integer[0];
253		Integer[] ints = new Integer[SIZE];
254	<	for (int i = SIZE-1; i >= 0; --i)
254	>	for (int i = SIZE - 1; i >= 0; --i)
255		ints[i] = new Integer(i);
256		PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
257		assertFalse(q.addAll(Arrays.asList(empty)));
#	Line 264 | Line 266 | public class PriorityBlockingQueueTest e
266		public void testPut() {
267		PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
268		for (int i = 0; i < SIZE; ++i) {
269	<	Integer I = new Integer(i);
270	<	q.put(I);
271	<	assertTrue(q.contains(I));
269	>	Integer x = new Integer(i);
270	>	q.put(x);
271	>	assertTrue(q.contains(x));
272		}
273		assertEquals(SIZE, q.size());
274		}
#	Line 394 | Line 396 | public class PriorityBlockingQueueTest e
396		final CountDownLatch aboutToWait = new CountDownLatch(1);
397		Thread t = newStartedThread(new CheckedRunnable() {
398		public void realRun() throws InterruptedException {
399	+	long startTime = System.nanoTime();
400		for (int i = 0; i < SIZE; ++i) {
398	–	long t0 = System.nanoTime();
401		assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
400	–	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
402		}
402	–	long t0 = System.nanoTime();
403		aboutToWait.countDown();
404		try {
405		q.poll(LONG_DELAY_MS, MILLISECONDS);
406		shouldThrow();
407		} catch (InterruptedException success) {
408	<	assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
408	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
409		}
410		}});
411
412		aboutToWait.await();
413	<	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
413	>	waitForThreadToEnterWaitState(t);
414		t.interrupt();
415	<	awaitTermination(t, MEDIUM_DELAY_MS);
415	>	awaitTermination(t);
416		}
417
418		/**
#	Line 459 | Line 459 | public class PriorityBlockingQueueTest e
459		}
460
461		/**
462	–	* remove(x) removes x and returns true if present
463	–	*/
464	–	public void testRemoveElement() {
465	–	PriorityBlockingQueue q = populatedQueue(SIZE);
466	–	for (int i = 1; i < SIZE; i+=2) {
467	–	assertTrue(q.contains(i));
468	–	assertTrue(q.remove(i));
469	–	assertFalse(q.contains(i));
470	–	assertTrue(q.contains(i-1));
471	–	}
472	–	for (int i = 0; i < SIZE; i+=2) {
473	–	assertTrue(q.contains(i));
474	–	assertTrue(q.remove(i));
475	–	assertFalse(q.contains(i));
476	–	assertFalse(q.remove(i+1));
477	–	assertFalse(q.contains(i+1));
478	–	}
479	–	assertTrue(q.isEmpty());
480	–	}
481	–
482	–	/**
462		* contains(x) reports true when elements added but not yet removed
463		*/
464		public void testContains() {
#	Line 534 | Line 513 | public class PriorityBlockingQueueTest e
513		assertTrue(changed);
514
515		assertTrue(q.containsAll(p));
516	<	assertEquals(SIZE-i, q.size());
516	>	assertEquals(SIZE - i, q.size());
517		p.remove();
518		}
519		}
#	Line 547 | Line 526 | public class PriorityBlockingQueueTest e
526		PriorityBlockingQueue q = populatedQueue(SIZE);
527		PriorityBlockingQueue p = populatedQueue(i);
528		assertTrue(q.removeAll(p));
529	<	assertEquals(SIZE-i, q.size());
529	>	assertEquals(SIZE - i, q.size());
530		for (int j = 0; j < i; ++j) {
531	<	Integer I = (Integer)(p.remove());
532	<	assertFalse(q.contains(I));
531	>	Integer x = (Integer)(p.remove());
532	>	assertFalse(q.contains(x));
533		}
534		}
535		}
#	Line 595 | Line 574 | public class PriorityBlockingQueueTest e
574		*/
575		public void testIterator() {
576		PriorityBlockingQueue q = populatedQueue(SIZE);
598	–	int i = 0;
577		Iterator it = q.iterator();
578	<	while (it.hasNext()) {
578	>	int i;
579	>	for (i = 0; it.hasNext(); i++)
580		assertTrue(q.contains(it.next()));
602	–	++i;
603	–	}
581		assertEquals(i, SIZE);
582	+	assertIteratorExhausted(it);
583	+	}
584	+
585	+	/**
586	+	* iterator of empty collection has no elements
587	+	*/
588	+	public void testEmptyIterator() {
589	+	assertIteratorExhausted(new PriorityBlockingQueue().iterator());
590		}
591
592		/**
#	Line 640 | Line 625 | public class PriorityBlockingQueueTest e
625		public void testPollInExecutor() {
626		final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
627		final CheckedBarrier threadsStarted = new CheckedBarrier(2);
628	<	ExecutorService executor = Executors.newFixedThreadPool(2);
629	<	executor.execute(new CheckedRunnable() {
630	<	public void realRun() throws InterruptedException {
631	<	assertNull(q.poll());
632	<	threadsStarted.await();
633	<	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
634	<	checkEmpty(q);
635	<	}});
636	<
637	<	executor.execute(new CheckedRunnable() {
638	<	public void realRun() throws InterruptedException {
639	<	threadsStarted.await();
640	<	q.put(one);
641	<	}});
642	<
643	<	joinPool(executor);
628	>	final ExecutorService executor = Executors.newFixedThreadPool(2);
629	>	try (PoolCleaner cleaner = cleaner(executor)) {
630	>	executor.execute(new CheckedRunnable() {
631	>	public void realRun() throws InterruptedException {
632	>	assertNull(q.poll());
633	>	threadsStarted.await();
634	>	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
635	>	checkEmpty(q);
636	>	}});
637	>
638	>	executor.execute(new CheckedRunnable() {
639	>	public void realRun() throws InterruptedException {
640	>	threadsStarted.await();
641	>	q.put(one);
642	>	}});
643	>	}
644		}
645
646		/**
647		* A deserialized serialized queue has same elements
648		*/
649		public void testSerialization() throws Exception {
650	<	PriorityBlockingQueue q = populatedQueue(SIZE);
651	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
652	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
653	<	out.writeObject(q);
654	<	out.close();
655	<
656	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
657	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
658	<	PriorityBlockingQueue r = (PriorityBlockingQueue)in.readObject();
659	<	assertEquals(q.size(), r.size());
675	<	while (!q.isEmpty())
676	<	assertEquals(q.remove(), r.remove());
650	>	Queue x = populatedQueue(SIZE);
651	>	Queue y = serialClone(x);
652	>
653	>	assertNotSame(x, y);
654	>	assertEquals(x.size(), y.size());
655	>	while (!x.isEmpty()) {
656	>	assertFalse(y.isEmpty());
657	>	assertEquals(x.remove(), y.remove());
658	>	}
659	>	assertTrue(y.isEmpty());
660		}
661
662		/**
#	Line 683 | Line 666 | public class PriorityBlockingQueueTest e
666		PriorityBlockingQueue q = populatedQueue(SIZE);
667		ArrayList l = new ArrayList();
668		q.drainTo(l);
669	<	assertEquals(q.size(), 0);
670	<	assertEquals(l.size(), SIZE);
669	>	assertEquals(0, q.size());
670	>	assertEquals(SIZE, l.size());
671		for (int i = 0; i < SIZE; ++i)
672		assertEquals(l.get(i), new Integer(i));
673		q.add(zero);
#	Line 694 | Line 677 | public class PriorityBlockingQueueTest e
677		assertTrue(q.contains(one));
678		l.clear();
679		q.drainTo(l);
680	<	assertEquals(q.size(), 0);
681	<	assertEquals(l.size(), 2);
680	>	assertEquals(0, q.size());
681	>	assertEquals(2, l.size());
682		for (int i = 0; i < 2; ++i)
683		assertEquals(l.get(i), new Integer(i));
684		}
#	Line 707 | Line 690 | public class PriorityBlockingQueueTest e
690		final PriorityBlockingQueue q = populatedQueue(SIZE);
691		Thread t = new Thread(new CheckedRunnable() {
692		public void realRun() {
693	<	q.put(new Integer(SIZE+1));
693	>	q.put(new Integer(SIZE + 1));
694		}});
695
696		t.start();
#	Line 724 | Line 707 | public class PriorityBlockingQueueTest e
707		* drainTo(c, n) empties first min(n, size) elements of queue into c
708		*/
709		public void testDrainToN() {
710	<	PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE*2);
710	>	PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE * 2);
711		for (int i = 0; i < SIZE + 2; ++i) {
712		for (int j = 0; j < SIZE; j++)
713		assertTrue(q.offer(new Integer(j)));
714		ArrayList l = new ArrayList();
715		q.drainTo(l, i);
716		int k = (i < SIZE) ? i : SIZE;
717	<	assertEquals(l.size(), k);
718	<	assertEquals(q.size(), SIZE-k);
717	>	assertEquals(k, l.size());
718	>	assertEquals(SIZE - k, q.size());
719		for (int j = 0; j < k; ++j)
720		assertEquals(l.get(j), new Integer(j));
721	<	while (q.poll() != null) ;
721	>	do {} while (q.poll() != null);
722	>	}
723	>	}
724	>
725	>	/**
726	>	* remove(null), contains(null) always return false
727	>	*/
728	>	public void testNeverContainsNull() {
729	>	Collection<?>[] qs = {
730	>	new PriorityBlockingQueue<Object>(),
731	>	populatedQueue(2),
732	>	};
733	>
734	>	for (Collection<?> q : qs) {
735	>	assertFalse(q.contains(null));
736	>	assertFalse(q.remove(null));
737		}
738		}
739

Diff Legend

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