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.55 by jsr166, Wed Dec 31 19:21:20 2014 UTC vs.
Revision 1.76 by jsr166, Sun May 14 01:30:34 2017 UTC

#	Line 38 | Line 38 | public class PriorityBlockingQueueTest e
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() {
45	+	class Implementation implements CollectionImplementation {
46	+	public Class<?> klazz() { return PriorityBlockingQueue.class; }
47	+	public Collection emptyCollection() { return new PriorityBlockingQueue(); }
48	+	public Object makeElement(int i) { return i; }
49	+	public boolean isConcurrent() { return true; }
50	+	public boolean permitsNulls() { return false; }
51	+	}
52		return newTestSuite(PriorityBlockingQueueTest.class,
53		new Generic().testSuite(),
54	<	new InitialCapacity().testSuite());
54	>	new InitialCapacity().testSuite(),
55	>	CollectionTest.testSuite(new Implementation()));
56		}
57
50	–	private static final int NOCAP = Integer.MAX_VALUE;
51	–
58		/** Sample Comparator */
59		static class MyReverseComparator implements Comparator {
60		public int compare(Object x, Object y) {
#	Line 58 | Line 64 | public class PriorityBlockingQueueTest e
64
65		/**
66		* Returns a new queue of given size containing consecutive
67	<	* Integers 0 ... n.
67	>	* Integers 0 ... n - 1.
68		*/
69	<	private PriorityBlockingQueue<Integer> populatedQueue(int n) {
69	>	private static PriorityBlockingQueue<Integer> populatedQueue(int n) {
70		PriorityBlockingQueue<Integer> q =
71		new PriorityBlockingQueue<Integer>(n);
72		assertTrue(q.isEmpty());
73	<	for (int i = n-1; i >= 0; i-=2)
73	>	for (int i = n - 1; i >= 0; i -= 2)
74		assertTrue(q.offer(new Integer(i)));
75	<	for (int i = (n & 1); i < n; i+=2)
75	>	for (int i = (n & 1); i < n; i += 2)
76		assertTrue(q.offer(new Integer(i)));
77		assertFalse(q.isEmpty());
78	<	assertEquals(NOCAP, q.remainingCapacity());
78	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
79		assertEquals(n, q.size());
80	+	assertEquals((Integer) 0, q.peek());
81		return q;
82		}
83
#	Line 78 | Line 85 | public class PriorityBlockingQueueTest e
85		* A new queue has unbounded capacity
86		*/
87		public void testConstructor1() {
88	<	assertEquals(NOCAP, new PriorityBlockingQueue(SIZE).remainingCapacity());
88	>	assertEquals(Integer.MAX_VALUE,
89	>	new PriorityBlockingQueue(SIZE).remainingCapacity());
90		}
91
92		/**
#	Line 117 | Line 125 | public class PriorityBlockingQueueTest e
125		*/
126		public void testConstructor5() {
127		Integer[] ints = new Integer[SIZE];
128	<	for (int i = 0; i < SIZE-1; ++i)
128	>	for (int i = 0; i < SIZE - 1; ++i)
129		ints[i] = i;
130		Collection<Integer> elements = Arrays.asList(ints);
131		try {
#	Line 149 | Line 157 | public class PriorityBlockingQueueTest e
157		for (int i = 0; i < SIZE; ++i)
158		ints[i] = new Integer(i);
159		q.addAll(Arrays.asList(ints));
160	<	for (int i = SIZE-1; i >= 0; --i)
160	>	for (int i = SIZE - 1; i >= 0; --i)
161		assertEquals(ints[i], q.poll());
162		}
163
#	Line 159 | Line 167 | public class PriorityBlockingQueueTest e
167		public void testEmpty() {
168		PriorityBlockingQueue q = new PriorityBlockingQueue(2);
169		assertTrue(q.isEmpty());
170	<	assertEquals(NOCAP, q.remainingCapacity());
170	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
171		q.add(one);
172		assertFalse(q.isEmpty());
173		q.add(two);
#	Line 169 | Line 177 | public class PriorityBlockingQueueTest e
177		}
178
179		/**
180	<	* remainingCapacity does not change when elements added or removed,
173	<	* but size does
180	>	* remainingCapacity() always returns Integer.MAX_VALUE
181		*/
182		public void testRemainingCapacity() {
183	<	PriorityBlockingQueue q = populatedQueue(SIZE);
183	>	BlockingQueue q = populatedQueue(SIZE);
184		for (int i = 0; i < SIZE; ++i) {
185	<	assertEquals(NOCAP, q.remainingCapacity());
186	<	assertEquals(SIZE-i, q.size());
187	<	q.remove();
185	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
186	>	assertEquals(SIZE - i, q.size());
187	>	assertEquals(i, q.remove());
188		}
189		for (int i = 0; i < SIZE; ++i) {
190	<	assertEquals(NOCAP, q.remainingCapacity());
190	>	assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
191		assertEquals(i, q.size());
192	<	q.add(new Integer(i));
192	>	assertTrue(q.add(i));
193		}
194		}
195
#	Line 199 | Line 206 | public class PriorityBlockingQueueTest e
206		* Offer of non-Comparable throws CCE
207		*/
208		public void testOfferNonComparable() {
209	+	PriorityBlockingQueue q = new PriorityBlockingQueue(1);
210		try {
203	–	PriorityBlockingQueue q = new PriorityBlockingQueue(1);
204	–	q.offer(new Object());
205	–	q.offer(new Object());
211		q.offer(new Object());
212		shouldThrow();
213	<	} catch (ClassCastException success) {}
213	>	} catch (ClassCastException success) {
214	>	assertTrue(q.isEmpty());
215	>	assertEquals(0, q.size());
216	>	assertNull(q.poll());
217	>	}
218		}
219
220		/**
#	Line 223 | Line 232 | public class PriorityBlockingQueueTest e
232		* addAll(this) throws IAE
233		*/
234		public void testAddAllSelf() {
235	+	PriorityBlockingQueue q = populatedQueue(SIZE);
236		try {
227	–	PriorityBlockingQueue q = populatedQueue(SIZE);
237		q.addAll(q);
238		shouldThrow();
239		} catch (IllegalArgumentException success) {}
#	Line 235 | Line 244 | public class PriorityBlockingQueueTest e
244		* possibly adding some elements
245		*/
246		public void testAddAll3() {
247	+	PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
248	+	Integer[] ints = new Integer[SIZE];
249	+	for (int i = 0; i < SIZE - 1; ++i)
250	+	ints[i] = new Integer(i);
251		try {
239	–	PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
240	–	Integer[] ints = new Integer[SIZE];
241	–	for (int i = 0; i < SIZE-1; ++i)
242	–	ints[i] = new Integer(i);
252		q.addAll(Arrays.asList(ints));
253		shouldThrow();
254		} catch (NullPointerException success) {}
#	Line 251 | Line 260 | public class PriorityBlockingQueueTest e
260		public void testAddAll5() {
261		Integer[] empty = new Integer[0];
262		Integer[] ints = new Integer[SIZE];
263	<	for (int i = SIZE-1; i >= 0; --i)
263	>	for (int i = SIZE - 1; i >= 0; --i)
264		ints[i] = new Integer(i);
265		PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
266		assertFalse(q.addAll(Arrays.asList(empty)));
#	Line 266 | Line 275 | public class PriorityBlockingQueueTest e
275		public void testPut() {
276		PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
277		for (int i = 0; i < SIZE; ++i) {
278	<	Integer I = new Integer(i);
279	<	q.put(I);
280	<	assertTrue(q.contains(I));
278	>	Integer x = new Integer(i);
279	>	q.put(x);
280	>	assertTrue(q.contains(x));
281		}
282		assertEquals(SIZE, q.size());
283		}
#	Line 324 | Line 333 | public class PriorityBlockingQueueTest e
333		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
334		Thread t = newStartedThread(new CheckedRunnable() {
335		public void realRun() throws InterruptedException {
336	<	for (int i = 0; i < SIZE; ++i) {
328	<	assertEquals(i, q.take());
329	<	}
336	>	for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
337
338		Thread.currentThread().interrupt();
339		try {
#	Line 344 | Line 351 | public class PriorityBlockingQueueTest e
351		}});
352
353		await(pleaseInterrupt);
354	<	assertThreadStaysAlive(t);
354	>	assertThreadBlocks(t, Thread.State.WAITING);
355		t.interrupt();
356		awaitTermination(t);
357		}
#	Line 393 | Line 400 | public class PriorityBlockingQueueTest e
400		*/
401		public void testInterruptedTimedPoll() throws InterruptedException {
402		final BlockingQueue<Integer> q = populatedQueue(SIZE);
403	<	final CountDownLatch aboutToWait = new CountDownLatch(1);
403	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
404		Thread t = newStartedThread(new CheckedRunnable() {
405		public void realRun() throws InterruptedException {
406	<	for (int i = 0; i < SIZE; ++i) {
407	<	long t0 = System.nanoTime();
406	>	long startTime = System.nanoTime();
407	>	for (int i = 0; i < SIZE; i++)
408		assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
409	<	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
410	<	}
404	<	long t0 = System.nanoTime();
405	<	aboutToWait.countDown();
409	>
410	>	Thread.currentThread().interrupt();
411		try {
412		q.poll(LONG_DELAY_MS, MILLISECONDS);
413		shouldThrow();
414	<	} catch (InterruptedException success) {
415	<	assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
416	<	}
414	>	} catch (InterruptedException success) {}
415	>	assertFalse(Thread.interrupted());
416	>
417	>	pleaseInterrupt.countDown();
418	>	try {
419	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
420	>	shouldThrow();
421	>	} catch (InterruptedException success) {}
422	>	assertFalse(Thread.interrupted());
423	>
424	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
425		}});
426
427	<	aboutToWait.await();
428	<	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
427	>	await(pleaseInterrupt);
428	>	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
429		t.interrupt();
430	<	awaitTermination(t, MEDIUM_DELAY_MS);
430	>	awaitTermination(t);
431		}
432
433		/**
#	Line 515 | Line 528 | public class PriorityBlockingQueueTest e
528		assertTrue(changed);
529
530		assertTrue(q.containsAll(p));
531	<	assertEquals(SIZE-i, q.size());
531	>	assertEquals(SIZE - i, q.size());
532		p.remove();
533		}
534		}
#	Line 528 | Line 541 | public class PriorityBlockingQueueTest e
541		PriorityBlockingQueue q = populatedQueue(SIZE);
542		PriorityBlockingQueue p = populatedQueue(i);
543		assertTrue(q.removeAll(p));
544	<	assertEquals(SIZE-i, q.size());
544	>	assertEquals(SIZE - i, q.size());
545		for (int j = 0; j < i; ++j) {
546	<	Integer I = (Integer)(p.remove());
547	<	assertFalse(q.contains(I));
546	>	Integer x = (Integer)(p.remove());
547	>	assertFalse(q.contains(x));
548		}
549		}
550		}
#	Line 576 | Line 589 | public class PriorityBlockingQueueTest e
589		*/
590		public void testIterator() {
591		PriorityBlockingQueue q = populatedQueue(SIZE);
579	–	int i = 0;
592		Iterator it = q.iterator();
593	<	while (it.hasNext()) {
593	>	int i;
594	>	for (i = 0; it.hasNext(); i++)
595		assertTrue(q.contains(it.next()));
583	–	++i;
584	–	}
596		assertEquals(i, SIZE);
597	+	assertIteratorExhausted(it);
598	+	}
599	+
600	+	/**
601	+	* iterator of empty collection has no elements
602	+	*/
603	+	public void testEmptyIterator() {
604	+	assertIteratorExhausted(new PriorityBlockingQueue().iterator());
605		}
606
607		/**
#	Line 621 | Line 640 | public class PriorityBlockingQueueTest e
640		public void testPollInExecutor() {
641		final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
642		final CheckedBarrier threadsStarted = new CheckedBarrier(2);
643	<	ExecutorService executor = Executors.newFixedThreadPool(2);
644	<	executor.execute(new CheckedRunnable() {
645	<	public void realRun() throws InterruptedException {
646	<	assertNull(q.poll());
647	<	threadsStarted.await();
648	<	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
649	<	checkEmpty(q);
650	<	}});
651	<
652	<	executor.execute(new CheckedRunnable() {
653	<	public void realRun() throws InterruptedException {
654	<	threadsStarted.await();
655	<	q.put(one);
656	<	}});
657	<
658	<	joinPool(executor);
643	>	final ExecutorService executor = Executors.newFixedThreadPool(2);
644	>	try (PoolCleaner cleaner = cleaner(executor)) {
645	>	executor.execute(new CheckedRunnable() {
646	>	public void realRun() throws InterruptedException {
647	>	assertNull(q.poll());
648	>	threadsStarted.await();
649	>	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
650	>	checkEmpty(q);
651	>	}});
652	>
653	>	executor.execute(new CheckedRunnable() {
654	>	public void realRun() throws InterruptedException {
655	>	threadsStarted.await();
656	>	q.put(one);
657	>	}});
658	>	}
659		}
660
661		/**
#	Line 686 | Line 705 | public class PriorityBlockingQueueTest e
705		final PriorityBlockingQueue q = populatedQueue(SIZE);
706		Thread t = new Thread(new CheckedRunnable() {
707		public void realRun() {
708	<	q.put(new Integer(SIZE+1));
708	>	q.put(new Integer(SIZE + 1));
709		}});
710
711		t.start();
#	Line 703 | Line 722 | public class PriorityBlockingQueueTest e
722		* drainTo(c, n) empties first min(n, size) elements of queue into c
723		*/
724		public void testDrainToN() {
725	<	PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE*2);
725	>	PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE * 2);
726		for (int i = 0; i < SIZE + 2; ++i) {
727		for (int j = 0; j < SIZE; j++)
728		assertTrue(q.offer(new Integer(j)));
#	Line 711 | Line 730 | public class PriorityBlockingQueueTest e
730		q.drainTo(l, i);
731		int k = (i < SIZE) ? i : SIZE;
732		assertEquals(k, l.size());
733	<	assertEquals(SIZE-k, q.size());
733	>	assertEquals(SIZE - k, q.size());
734		for (int j = 0; j < k; ++j)
735		assertEquals(l.get(j), new Integer(j));
736		do {} while (q.poll() != null);

Diff Legend

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