ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/LinkedTransferQueueTest.java

Comparing jsr166/src/test/tck/LinkedTransferQueueTest.java (file contents):
Revision 1.70 by jsr166, Sat Feb 18 16:37:49 2017 UTC vs.
Revision 1.81 by jsr166, Mon May 28 21:19:50 2018 UTC

#	Line 209 | Line 209 | public class LinkedTransferQueueTest ext
209		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
210		Thread t = newStartedThread(new CheckedRunnable() {
211		public void realRun() throws InterruptedException {
212	<	for (int i = 0; i < SIZE; ++i) {
213	<	assertEquals(i, q.take());
214	<	}
212	>	for (int i = 0; i < SIZE; i++) assertEquals(i, q.take());
213
214		Thread.currentThread().interrupt();
215		try {
#	Line 229 | Line 227 | public class LinkedTransferQueueTest ext
227		}});
228
229		await(pleaseInterrupt);
230	<	assertThreadStaysAlive(t);
230	>	assertThreadBlocks(t, Thread.State.WAITING);
231		t.interrupt();
232		awaitTermination(t);
233		}
#	Line 280 | Line 278 | public class LinkedTransferQueueTest ext
278		*/
279		public void testInterruptedTimedPoll() throws InterruptedException {
280		final BlockingQueue<Integer> q = populatedQueue(SIZE);
281	<	final CountDownLatch aboutToWait = new CountDownLatch(1);
281	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
282		Thread t = newStartedThread(new CheckedRunnable() {
283		public void realRun() throws InterruptedException {
284		long startTime = System.nanoTime();
285	<	for (int i = 0; i < SIZE; ++i)
285	>	for (int i = 0; i < SIZE; i++)
286		assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
287	<	aboutToWait.countDown();
287	>
288	>	Thread.currentThread().interrupt();
289	>	try {
290	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
291	>	shouldThrow();
292	>	} catch (InterruptedException success) {}
293	>	assertFalse(Thread.interrupted());
294	>
295	>	pleaseInterrupt.countDown();
296		try {
297		q.poll(LONG_DELAY_MS, MILLISECONDS);
298		shouldThrow();
299		} catch (InterruptedException success) {}
300	+	assertFalse(Thread.interrupted());
301	+
302		assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
303		}});
304
305	<	aboutToWait.await();
306	<	waitForThreadToEnterWaitState(t);
305	>	await(pleaseInterrupt);
306	>	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
307		t.interrupt();
308		awaitTermination(t);
309		checkEmpty(q);
#	Line 317 | Line 325 | public class LinkedTransferQueueTest ext
325		q.poll(LONG_DELAY_MS, MILLISECONDS);
326		shouldThrow();
327		} catch (InterruptedException success) {}
328	+	assertFalse(Thread.interrupted());
329		assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
330		}});
331
#	Line 466 | Line 475 | public class LinkedTransferQueueTest ext
475		*/
476		public void testToArray() {
477		LinkedTransferQueue q = populatedQueue(SIZE);
478	<	Object[] o = q.toArray();
479	<	for (int i = 0; i < o.length; i++) {
480	<	assertSame(o[i], q.poll());
481	<	}
478	>	Object[] a = q.toArray();
479	>	assertSame(Object[].class, a.getClass());
480	>	for (Object o : a)
481	>	assertSame(o, q.poll());
482	>	assertTrue(q.isEmpty());
483		}
484
485		/**
#	Line 480 | Line 490 | public class LinkedTransferQueueTest ext
490		Integer[] ints = new Integer[SIZE];
491		Integer[] array = q.toArray(ints);
492		assertSame(ints, array);
493	<	for (int i = 0; i < ints.length; i++) {
494	<	assertSame(ints[i], q.poll());
495	<	}
493	>	for (Integer o : ints)
494	>	assertSame(o, q.poll());
495	>	assertTrue(q.isEmpty());
496		}
497
498		/**
#	Line 638 | Line 648 | public class LinkedTransferQueueTest ext
648		}
649
650		/**
651	<	* A deserialized serialized queue has same elements in same order
651	>	* A deserialized/reserialized queue has same elements in same order
652		*/
653		public void testSerialization() throws Exception {
654		Queue x = populatedQueue(SIZE);
#	Line 765 | Line 775 | public class LinkedTransferQueueTest ext
775		}
776
777		/**
778	<	* transfer waits until a poll occurs. The transfered element
778	>	* transfer waits until a poll occurs. The transferred element
779		* is returned by the associated poll.
780		*/
781		public void testTransfer2() throws InterruptedException {
#	Line 799 | Line 809 | public class LinkedTransferQueueTest ext
809		Thread first = newStartedThread(new CheckedRunnable() {
810		public void realRun() throws InterruptedException {
811		q.transfer(four);
812	<	assertTrue(!q.contains(four));
812	>	assertFalse(q.contains(four));
813		assertEquals(1, q.size());
814		}});
815
#	Line 846 | Line 856 | public class LinkedTransferQueueTest ext
856		}
857
858		/**
859	<	* transfer waits until a take occurs. The transfered element
859	>	* transfer waits until a take occurs. The transferred element
860		* is returned by the associated take.
861		*/
862		public void testTransfer5() throws InterruptedException {
#	Line 963 | Line 973 | public class LinkedTransferQueueTest ext
973		}});
974
975		await(pleaseInterrupt);
976	<	assertThreadStaysAlive(t);
976	>	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
977		t.interrupt();
978		awaitTermination(t);
979		checkEmpty(q);

Diff Legend

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