ViewVC Help

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

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

Comparing jsr166/src/test/tck/SynchronousQueueTest.java (file contents):
Revision 1.59 by jsr166, Sun May 14 04:14:10 2017 UTC vs.
Revision 1.64 by jsr166, Tue Aug 13 00:54:51 2019 UTC

#	Line 97 | Line 97 | public class SynchronousQueueTest extend
97		}
98
99		/**
100	<	* addAll throws ISE if no active taker
100	>	* addAll throws IllegalStateException if no active taker
101		*/
102		public void testAddAll_ISE()      { testAddAll_ISE(false); }
103		public void testAddAll_ISE_fair() { testAddAll_ISE(true); }
#	Line 139 | Line 139 | public class SynchronousQueueTest extend
139		}});
140
141		await(pleaseInterrupt);
142	<	assertThreadBlocks(t, Thread.State.WAITING);
142	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
143		t.interrupt();
144		awaitTermination(t);
145		assertEquals(0, q.remainingCapacity());
#	Line 180 | Line 180 | public class SynchronousQueueTest extend
180		catch (InterruptedException e) { threadUnexpectedException(e); }
181
182		await(pleaseInterrupt);
183	<	assertThreadBlocks(t, Thread.State.WAITING);
183	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
184		t.interrupt();
185		awaitTermination(t);
186		assertEquals(0, q.remainingCapacity());
#	Line 190 | Line 190 | public class SynchronousQueueTest extend
190		* timed offer times out if elements not taken
191		*/
192		public void testTimedOffer() {
193	<	final boolean fair = ThreadLocalRandom.current().nextBoolean();
193	>	final boolean fair = randomBoolean();
194		final SynchronousQueue q = new SynchronousQueue(fair);
195		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
196		Thread t = newStartedThread(new CheckedRunnable() {
197		public void realRun() throws InterruptedException {
198		long startTime = System.nanoTime();
199	+
200		assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
201		assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
202
203		Thread.currentThread().interrupt();
204		try {
205	<	q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
205	>	q.offer(new Object(), randomTimeout(), randomTimeUnit());
206		shouldThrow();
207		} catch (InterruptedException success) {}
208		assertFalse(Thread.interrupted());
209
210		pleaseInterrupt.countDown();
211		try {
212	<	q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
212	>	q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
213		shouldThrow();
214		} catch (InterruptedException success) {}
215		assertFalse(Thread.interrupted());
216	+
217	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
218		}});
219
220		await(pleaseInterrupt);
221	<	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
221	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
222		t.interrupt();
223		awaitTermination(t);
224		}
#	Line 245 | Line 248 | public class SynchronousQueueTest extend
248		* timed poll with nonzero timeout times out if no active putter
249		*/
250		public void testTimedPoll() {
251	<	final boolean fair = ThreadLocalRandom.current().nextBoolean();
251	>	final boolean fair = randomBoolean();
252		final SynchronousQueue q = new SynchronousQueue(fair);
253		final long startTime = System.nanoTime();
254		try { assertNull(q.poll(timeoutMillis(), MILLISECONDS)); }
#	Line 258 | Line 261 | public class SynchronousQueueTest extend
261		* after offer succeeds; on interruption throws
262		*/
263		public void testTimedPollWithOffer() {
264	<	final boolean fair = ThreadLocalRandom.current().nextBoolean();
264	>	final boolean fair = randomBoolean();
265		final SynchronousQueue q = new SynchronousQueue(fair);
266		final CountDownLatch pleaseOffer = new CountDownLatch(1);
267		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
#	Line 274 | Line 277 | public class SynchronousQueueTest extend
277
278		Thread.currentThread().interrupt();
279		try {
280	<	q.poll(LONG_DELAY_MS, MILLISECONDS);
280	>	q.poll(randomTimeout(), randomTimeUnit());
281		shouldThrow();
282		} catch (InterruptedException success) {}
283		assertFalse(Thread.interrupted());
#	Line 296 | Line 299 | public class SynchronousQueueTest extend
299		assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
300
301		await(pleaseInterrupt);
302	<	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
302	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
303		t.interrupt();
304		awaitTermination(t);
305		}
#	Line 437 | Line 440 | public class SynchronousQueueTest extend
440		public void testToArray_null(boolean fair) {
441		final SynchronousQueue q = new SynchronousQueue(fair);
442		try {
443	<	Object[] o = q.toArray(null);
443	>	Object[] o = q.toArray((Object[])null);
444		shouldThrow();
445		} catch (NullPointerException success) {}
446		}
#	Line 452 | Line 455 | public class SynchronousQueueTest extend
455		}
456
457		/**
458	<	* iterator remove throws ISE
458	>	* iterator remove throws IllegalStateException
459		*/
460		public void testIteratorRemove()      { testIteratorRemove(false); }
461		public void testIteratorRemove_fair() { testIteratorRemove(true); }
#	Line 530 | Line 533 | public class SynchronousQueueTest extend
533		}
534
535		/**
536	<	* a deserialized serialized queue is usable
536	>	* a deserialized/reserialized queue is usable
537		*/
538		public void testSerialization() {
539		final SynchronousQueue x = new SynchronousQueue();

Diff Legend

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