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.60 by jsr166, Sat Feb 28 20:13:46 2015 UTC vs.
Revision 1.80 by jsr166, Sun May 6 22:29:24 2018 UTC

#	Line 20 | Line 20 | import java.util.concurrent.CountDownLat
20		import java.util.concurrent.Executors;
21		import java.util.concurrent.ExecutorService;
22		import java.util.concurrent.PriorityBlockingQueue;
23	+	import java.util.concurrent.ThreadLocalRandom;
24
25		import junit.framework.Test;
26
#	Line 33 | Line 34 | public class PriorityBlockingQueueTest e
34
35		public static class InitialCapacity extends BlockingQueueTest {
36		protected BlockingQueue emptyCollection() {
37	<	return new PriorityBlockingQueue(SIZE);
37	>	ThreadLocalRandom rnd = ThreadLocalRandom.current();
38	>	int initialCapacity = rnd.nextInt(1, SIZE);
39	>	return new PriorityBlockingQueue(initialCapacity);
40		}
41		}
42
43		public static void main(String[] args) {
44	<	junit.textui.TestRunner.run(suite());
44	>	main(suite(), args);
45		}
46
47		public static Test suite() {
48	<	return newTestSuite(PriorityBlockingQueueTest.class,
49	<	new Generic().testSuite(),
50	<	new InitialCapacity().testSuite());
48	>	class Implementation implements CollectionImplementation {
49	>	public Class<?> klazz() { return PriorityBlockingQueue.class; }
50	>	public Collection emptyCollection() {
51	>	return new PriorityBlockingQueue();
52	>	}
53	>	public Object makeElement(int i) { return i; }
54	>	public boolean isConcurrent() { return true; }
55	>	public boolean permitsNulls() { return false; }
56	>	}
57	>	class ComparatorImplementation implements CollectionImplementation {
58	>	public Class<?> klazz() { return PriorityBlockingQueue.class; }
59	>	public Collection emptyCollection() {
60	>	ThreadLocalRandom rnd = ThreadLocalRandom.current();
61	>	int initialCapacity = rnd.nextInt(1, 10);
62	>	return new PriorityBlockingQueue(
63	>	initialCapacity, new MyReverseComparator());
64	>	}
65	>	public Object makeElement(int i) { return i; }
66	>	public boolean isConcurrent() { return true; }
67	>	public boolean permitsNulls() { return false; }
68	>	}
69	>	return newTestSuite(
70	>	PriorityBlockingQueueTest.class,
71	>	new Generic().testSuite(),
72	>	new InitialCapacity().testSuite(),
73	>	CollectionTest.testSuite(new Implementation()),
74	>	CollectionTest.testSuite(new ComparatorImplementation()));
75		}
76
77		/** Sample Comparator */
78	<	static class MyReverseComparator implements Comparator {
78	>	static class MyReverseComparator implements Comparator, java.io.Serializable {
79		public int compare(Object x, Object y) {
80		return ((Comparable)y).compareTo(x);
81		}
#	Line 56 | Line 83 | public class PriorityBlockingQueueTest e
83
84		/**
85		* Returns a new queue of given size containing consecutive
86	<	* Integers 0 ... n.
86	>	* Integers 0 ... n - 1.
87		*/
88	<	private PriorityBlockingQueue<Integer> populatedQueue(int n) {
88	>	private static PriorityBlockingQueue<Integer> populatedQueue(int n) {
89		PriorityBlockingQueue<Integer> q =
90		new PriorityBlockingQueue<Integer>(n);
91		assertTrue(q.isEmpty());
92	<	for (int i = n-1; i >= 0; i -= 2)
92	>	for (int i = n - 1; i >= 0; i -= 2)
93		assertTrue(q.offer(new Integer(i)));
94		for (int i = (n & 1); i < n; i += 2)
95		assertTrue(q.offer(new Integer(i)));
96		assertFalse(q.isEmpty());
97		assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
98		assertEquals(n, q.size());
99	+	assertEquals((Integer) 0, q.peek());
100		return q;
101		}
102
#	Line 81 | Line 109 | public class PriorityBlockingQueueTest e
109		}
110
111		/**
112	<	* Constructor throws IAE if capacity argument nonpositive
112	>	* Constructor throws IllegalArgumentException if capacity argument nonpositive
113		*/
114		public void testConstructor2() {
115		try {
#	Line 116 | Line 144 | public class PriorityBlockingQueueTest e
144		*/
145		public void testConstructor5() {
146		Integer[] ints = new Integer[SIZE];
147	<	for (int i = 0; i < SIZE-1; ++i)
147	>	for (int i = 0; i < SIZE - 1; ++i)
148		ints[i] = i;
149		Collection<Integer> elements = Arrays.asList(ints);
150		try {
#	Line 148 | Line 176 | public class PriorityBlockingQueueTest e
176		for (int i = 0; i < SIZE; ++i)
177		ints[i] = new Integer(i);
178		q.addAll(Arrays.asList(ints));
179	<	for (int i = SIZE-1; i >= 0; --i)
179	>	for (int i = SIZE - 1; i >= 0; --i)
180		assertEquals(ints[i], q.poll());
181		}
182
#	Line 200 | Line 228 | public class PriorityBlockingQueueTest e
228		PriorityBlockingQueue q = new PriorityBlockingQueue(1);
229		try {
230		q.offer(new Object());
203	–	q.offer(new Object());
231		shouldThrow();
232	<	} catch (ClassCastException success) {}
232	>	} catch (ClassCastException success) {
233	>	assertTrue(q.isEmpty());
234	>	assertEquals(0, q.size());
235	>	assertNull(q.poll());
236	>	}
237		}
238
239		/**
#	Line 217 | Line 248 | public class PriorityBlockingQueueTest e
248		}
249
250		/**
251	<	* addAll(this) throws IAE
251	>	* addAll(this) throws IllegalArgumentException
252		*/
253		public void testAddAllSelf() {
254	+	PriorityBlockingQueue q = populatedQueue(SIZE);
255		try {
224	–	PriorityBlockingQueue q = populatedQueue(SIZE);
256		q.addAll(q);
257		shouldThrow();
258		} catch (IllegalArgumentException success) {}
#	Line 232 | Line 263 | public class PriorityBlockingQueueTest e
263		* possibly adding some elements
264		*/
265		public void testAddAll3() {
266	+	PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
267	+	Integer[] ints = new Integer[SIZE];
268	+	for (int i = 0; i < SIZE - 1; ++i)
269	+	ints[i] = new Integer(i);
270		try {
236	–	PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
237	–	Integer[] ints = new Integer[SIZE];
238	–	for (int i = 0; i < SIZE-1; ++i)
239	–	ints[i] = new Integer(i);
271		q.addAll(Arrays.asList(ints));
272		shouldThrow();
273		} catch (NullPointerException success) {}
#	Line 248 | Line 279 | public class PriorityBlockingQueueTest e
279		public void testAddAll5() {
280		Integer[] empty = new Integer[0];
281		Integer[] ints = new Integer[SIZE];
282	<	for (int i = SIZE-1; i >= 0; --i)
282	>	for (int i = SIZE - 1; i >= 0; --i)
283		ints[i] = new Integer(i);
284		PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE);
285		assertFalse(q.addAll(Arrays.asList(empty)));
#	Line 290 | Line 321 | public class PriorityBlockingQueueTest e
321		/**
322		* timed offer does not time out
323		*/
324	<	public void testTimedOffer() throws InterruptedException {
324	>	public void testTimedOffer() {
325		final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
326		Thread t = newStartedThread(new CheckedRunnable() {
327		public void realRun() {
#	Line 321 | Line 352 | public class PriorityBlockingQueueTest e
352		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
353		Thread t = newStartedThread(new CheckedRunnable() {
354		public void realRun() throws InterruptedException {
355	<	for (int i = 0; i < SIZE; ++i) {
325	<	assertEquals(i, q.take());
326	<	}
355	>	for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
356
357		Thread.currentThread().interrupt();
358		try {
#	Line 341 | Line 370 | public class PriorityBlockingQueueTest e
370		}});
371
372		await(pleaseInterrupt);
373	<	assertThreadStaysAlive(t);
373	>	assertThreadBlocks(t, Thread.State.WAITING);
374		t.interrupt();
375		awaitTermination(t);
376		}
#	Line 390 | Line 419 | public class PriorityBlockingQueueTest e
419		*/
420		public void testInterruptedTimedPoll() throws InterruptedException {
421		final BlockingQueue<Integer> q = populatedQueue(SIZE);
422	<	final CountDownLatch aboutToWait = new CountDownLatch(1);
422	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
423		Thread t = newStartedThread(new CheckedRunnable() {
424		public void realRun() throws InterruptedException {
425	<	for (int i = 0; i < SIZE; ++i) {
426	<	long t0 = System.nanoTime();
425	>	long startTime = System.nanoTime();
426	>	for (int i = 0; i < SIZE; i++)
427		assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
428	<	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
429	<	}
401	<	long t0 = System.nanoTime();
402	<	aboutToWait.countDown();
428	>
429	>	Thread.currentThread().interrupt();
430		try {
431		q.poll(LONG_DELAY_MS, MILLISECONDS);
432		shouldThrow();
433	<	} catch (InterruptedException success) {
434	<	assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
435	<	}
433	>	} catch (InterruptedException success) {}
434	>	assertFalse(Thread.interrupted());
435	>
436	>	pleaseInterrupt.countDown();
437	>	try {
438	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
439	>	shouldThrow();
440	>	} catch (InterruptedException success) {}
441	>	assertFalse(Thread.interrupted());
442	>
443	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
444		}});
445
446	<	aboutToWait.await();
447	<	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
446	>	await(pleaseInterrupt);
447	>	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
448		t.interrupt();
449	<	awaitTermination(t, MEDIUM_DELAY_MS);
449	>	awaitTermination(t);
450		}
451
452		/**
#	Line 512 | Line 547 | public class PriorityBlockingQueueTest e
547		assertTrue(changed);
548
549		assertTrue(q.containsAll(p));
550	<	assertEquals(SIZE-i, q.size());
550	>	assertEquals(SIZE - i, q.size());
551		p.remove();
552		}
553		}
#	Line 525 | Line 560 | public class PriorityBlockingQueueTest e
560		PriorityBlockingQueue q = populatedQueue(SIZE);
561		PriorityBlockingQueue p = populatedQueue(i);
562		assertTrue(q.removeAll(p));
563	<	assertEquals(SIZE-i, q.size());
563	>	assertEquals(SIZE - i, q.size());
564		for (int j = 0; j < i; ++j) {
565		Integer x = (Integer)(p.remove());
566		assertFalse(q.contains(x));
#	Line 624 | Line 659 | public class PriorityBlockingQueueTest e
659		public void testPollInExecutor() {
660		final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
661		final CheckedBarrier threadsStarted = new CheckedBarrier(2);
662	<	ExecutorService executor = Executors.newFixedThreadPool(2);
663	<	executor.execute(new CheckedRunnable() {
664	<	public void realRun() throws InterruptedException {
665	<	assertNull(q.poll());
666	<	threadsStarted.await();
667	<	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
668	<	checkEmpty(q);
669	<	}});
670	<
671	<	executor.execute(new CheckedRunnable() {
672	<	public void realRun() throws InterruptedException {
673	<	threadsStarted.await();
674	<	q.put(one);
675	<	}});
676	<
677	<	joinPool(executor);
662	>	final ExecutorService executor = Executors.newFixedThreadPool(2);
663	>	try (PoolCleaner cleaner = cleaner(executor)) {
664	>	executor.execute(new CheckedRunnable() {
665	>	public void realRun() throws InterruptedException {
666	>	assertNull(q.poll());
667	>	threadsStarted.await();
668	>	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
669	>	checkEmpty(q);
670	>	}});
671	>
672	>	executor.execute(new CheckedRunnable() {
673	>	public void realRun() throws InterruptedException {
674	>	threadsStarted.await();
675	>	q.put(one);
676	>	}});
677	>	}
678		}
679
680		/**
681	<	* A deserialized serialized queue has same elements
681	>	* A deserialized/reserialized queue has same elements
682		*/
683		public void testSerialization() throws Exception {
684		Queue x = populatedQueue(SIZE);
#	Line 689 | Line 724 | public class PriorityBlockingQueueTest e
724		final PriorityBlockingQueue q = populatedQueue(SIZE);
725		Thread t = new Thread(new CheckedRunnable() {
726		public void realRun() {
727	<	q.put(new Integer(SIZE+1));
727	>	q.put(new Integer(SIZE + 1));
728		}});
729
730		t.start();
#	Line 706 | Line 741 | public class PriorityBlockingQueueTest e
741		* drainTo(c, n) empties first min(n, size) elements of queue into c
742		*/
743		public void testDrainToN() {
744	<	PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE*2);
744	>	PriorityBlockingQueue q = new PriorityBlockingQueue(SIZE * 2);
745		for (int i = 0; i < SIZE + 2; ++i) {
746		for (int j = 0; j < SIZE; j++)
747		assertTrue(q.offer(new Integer(j)));
#	Line 714 | Line 749 | public class PriorityBlockingQueueTest e
749		q.drainTo(l, i);
750		int k = (i < SIZE) ? i : SIZE;
751		assertEquals(k, l.size());
752	<	assertEquals(SIZE-k, q.size());
752	>	assertEquals(SIZE - k, q.size());
753		for (int j = 0; j < k; ++j)
754		assertEquals(l.get(j), new Integer(j));
755		do {} while (q.poll() != null);

Diff Legend

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