[ViewVC] Diff of: jsr166/jsr166/src/test/tck/PriorityBlockingQueueTest.java

Comparing jsr166/src/test/tck/PriorityBlockingQueueTest.java (file contents):
Revision 1.59 by jsr166, Sat Feb 28 19:59:23 2015 UTC vs.
Revision 1.79 by jsr166, Fri Aug 4 03:30:21 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
58		/** Sample Comparator */
#	Line 56 \| 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)
76		assertTrue(q.offer(new Integer(i)));
77		assertFalse(q.isEmpty());
78		assertEquals(Integer.MAX_VALUE, q.remainingCapacity());
79		assertEquals(n, q.size());
80	+	assertEquals((Integer) 0, q.peek());
81		return q;
82		}
83
#	Line 81 \| Line 90 \| public class PriorityBlockingQueueTest e
90		}
91
92		/**
93	<	* Constructor throws IAE if capacity argument nonpositive
93	>	* Constructor throws IllegalArgumentException if capacity argument nonpositive
94		*/
95		public void testConstructor2() {
96		try {
#	Line 116 \| 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 148 \| 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 197 \| 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 {
201	–	PriorityBlockingQueue q = new PriorityBlockingQueue(1);
202	–	q.offer(new Object());
203	–	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 218 \| Line 229 \| public class PriorityBlockingQueueTest e
229		}
230
231		/**
232	<	* addAll(this) throws IAE
232	>	* addAll(this) throws IllegalArgumentException
233		*/
234		public void testAddAllSelf() {
235	+	PriorityBlockingQueue q = populatedQueue(SIZE);
236		try {
225	–	PriorityBlockingQueue q = populatedQueue(SIZE);
237		q.addAll(q);
238		shouldThrow();
239		} catch (IllegalArgumentException success) {}
#	Line 233 \| 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 {
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);
252		q.addAll(Arrays.asList(ints));
253		shouldThrow();
254		} catch (NullPointerException success) {}
#	Line 249 \| 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 291 \| Line 302 \| public class PriorityBlockingQueueTest e
302		/**
303		* timed offer does not time out
304		*/
305	<	public void testTimedOffer() throws InterruptedException {
305	>	public void testTimedOffer() {
306		final PriorityBlockingQueue q = new PriorityBlockingQueue(2);
307		Thread t = newStartedThread(new CheckedRunnable() {
308		public void realRun() {
#	Line 322 \| 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) {
326	<	assertEquals(i, q.take());
327	<	}
336	>	for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
337
338		Thread.currentThread().interrupt();
339		try {
#	Line 342 \| 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 391 \| 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	<	}
411	<	long t0 = System.nanoTime();
412	<	aboutToWait.countDown();
409	>
410	>	Thread.currentThread().interrupt();
411	>	try {
412	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
413	>	shouldThrow();
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	<	assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
423	<	}
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 513 \| 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 526 \| 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 x = (Integer)(p.remove());
547		assertFalse(q.contains(x));
#	Line 625 \| 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		/**
662	<	* A deserialized serialized queue has same elements
662	>	* A deserialized/reserialized queue has same elements
663		*/
664		public void testSerialization() throws Exception {
665		Queue x = populatedQueue(SIZE);
#	Line 690 \| 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 707 \| 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 715 \| 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

Comparing jsr166/src/test/tck/PriorityBlockingQueueTest.java (file contents): Revision 1.59 by jsr166, Sat Feb 28 19:59:23 2015 UTC vs. Revision 1.79 by jsr166, Fri Aug 4 03:30:21 2017 UTC

Diff Legend

Comparing jsr166/src/test/tck/PriorityBlockingQueueTest.java (file contents):
Revision 1.59 by jsr166, Sat Feb 28 19:59:23 2015 UTC vs.
Revision 1.79 by jsr166, Fri Aug 4 03:30:21 2017 UTC