ViewVC Help

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

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

Comparing jsr166/src/test/tck/ArrayBlockingQueueTest.java (file contents):
Revision 1.84 by jsr166, Sat May 13 22:17:12 2017 UTC vs.
Revision 1.92 by jsr166, Fri Aug 4 03:30:21 2017 UTC

#	Line 103 | Line 103 | public class ArrayBlockingQueueTest exte
103		}
104
105		/**
106	<	* Constructor throws IAE if capacity argument nonpositive
106	>	* Constructor throws IllegalArgumentException if capacity argument nonpositive
107		*/
108		public void testConstructor_nonPositiveCapacity() {
109		for (int i : new int[] { 0, -1, Integer.MIN_VALUE }) {
#	Line 156 | Line 156 | public class ArrayBlockingQueueTest exte
156		}
157
158		/**
159	<	* Initializing from too large collection throws IAE
159	>	* Initializing from too large collection throws IllegalArgumentException
160		*/
161		public void testConstructor_collectionTooLarge() {
162		// just barely fits - succeeds
#	Line 227 | Line 227 | public class ArrayBlockingQueueTest exte
227		}
228
229		/**
230	<	* add succeeds if not full; throws ISE if full
230	>	* add succeeds if not full; throws IllegalStateException if full
231		*/
232		public void testAdd() {
233		ArrayBlockingQueue q = new ArrayBlockingQueue(SIZE);
#	Line 240 | Line 240 | public class ArrayBlockingQueueTest exte
240		}
241
242		/**
243	<	* addAll(this) throws IAE
243	>	* addAll(this) throws IllegalArgumentException
244		*/
245		public void testAddAllSelf() {
246		ArrayBlockingQueue q = populatedQueue(SIZE);
#	Line 266 | Line 266 | public class ArrayBlockingQueueTest exte
266		}
267
268		/**
269	<	* addAll throws ISE if not enough room
269	>	* addAll throws IllegalStateException if not enough room
270		*/
271		public void testAddAll_insufficientSpace() {
272		int size = ThreadLocalRandom.current().nextInt(1, SIZE);
#	Line 362 | Line 362 | public class ArrayBlockingQueueTest exte
362		pleaseTake.countDown();
363		q.put(86);
364
365	+	Thread.currentThread().interrupt();
366	+	try {
367	+	q.put(99);
368	+	shouldThrow();
369	+	} catch (InterruptedException success) {}
370	+	assertFalse(Thread.interrupted());
371	+
372		pleaseInterrupt.countDown();
373		try {
374		q.put(99);
#	Line 384 | Line 391 | public class ArrayBlockingQueueTest exte
391		/**
392		* timed offer times out if full and elements not taken
393		*/
394	<	public void testTimedOffer() throws InterruptedException {
394	>	public void testTimedOffer() {
395		final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
396		final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
397		Thread t = newStartedThread(new CheckedRunnable() {
#	Line 394 | Line 401 | public class ArrayBlockingQueueTest exte
401		long startTime = System.nanoTime();
402		assertFalse(q.offer(new Object(), timeoutMillis(), MILLISECONDS));
403		assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
404	+
405	+	Thread.currentThread().interrupt();
406	+	try {
407	+	q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
408	+	shouldThrow();
409	+	} catch (InterruptedException success) {}
410	+	assertFalse(Thread.interrupted());
411	+
412		pleaseInterrupt.countDown();
413		try {
414		q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
415		shouldThrow();
416		} catch (InterruptedException success) {}
417	+	assertFalse(Thread.interrupted());
418		}});
419
420		await(pleaseInterrupt);
#	Line 493 | Line 509 | public class ArrayBlockingQueueTest exte
509		*/
510		public void testInterruptedTimedPoll() throws InterruptedException {
511		final BlockingQueue<Integer> q = populatedQueue(SIZE);
512	<	final CountDownLatch aboutToWait = new CountDownLatch(1);
512	>	final CountDownLatch pleaseInterrupt = new CountDownLatch(1);
513		Thread t = newStartedThread(new CheckedRunnable() {
514		public void realRun() throws InterruptedException {
515		long startTime = System.nanoTime();
516	<	for (int i = 0; i < SIZE; ++i) {
516	>	for (int i = 0; i < SIZE; i++)
517		assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
518	<	}
519	<	aboutToWait.countDown();
518	>
519	>	Thread.currentThread().interrupt();
520		try {
521		q.poll(LONG_DELAY_MS, MILLISECONDS);
522		shouldThrow();
523	<	} catch (InterruptedException success) {
524	<	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
525	<	}
523	>	} catch (InterruptedException success) {}
524	>	assertFalse(Thread.interrupted());
525	>
526	>	pleaseInterrupt.countDown();
527	>	try {
528	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
529	>	shouldThrow();
530	>	} catch (InterruptedException success) {}
531	>	assertFalse(Thread.interrupted());
532	>
533	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
534		}});
535
536	<	await(aboutToWait);
537	<	waitForThreadToEnterWaitState(t);
536	>	await(pleaseInterrupt);
537	>	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
538		t.interrupt();
539		awaitTermination(t);
540		checkEmpty(q);
#	Line 852 | Line 876 | public class ArrayBlockingQueueTest exte
876		}
877
878		/**
879	<	* A deserialized serialized queue has same elements in same order
879	>	* A deserialized/reserialized queue has same elements in same order
880		*/
881		public void testSerialization() throws Exception {
882		Queue x = populatedQueue(SIZE);

Diff Legend

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