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.64 by jsr166, Sun May 24 01:42:14 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
#	Line 42 | Line 45 | public class PriorityBlockingQueueTest e
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());
#	Line 69 | Line 96 | public class PriorityBlockingQueueTest e
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 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);
#	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	<	}
430	<	long t0 = System.nanoTime();
431	<	aboutToWait.countDown();
428	>
429	>	Thread.currentThread().interrupt();
430	>	try {
431	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
432	>	shouldThrow();
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	<	assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
442	<	}
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 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);

Diff Legend

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