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.90 by jsr166, Sun May 14 04:14:09 2017 UTC vs.
Revision 1.93 by jsr166, Sun Aug 11 22:29:26 2019 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 340 | Line 340 | public class ArrayBlockingQueueTest exte
340		}});
341
342		await(pleaseInterrupt);
343	<	assertThreadBlocks(t, Thread.State.WAITING);
343	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
344		t.interrupt();
345		awaitTermination(t);
346		assertEquals(SIZE, q.size());
#	Line 382 | Line 382 | public class ArrayBlockingQueueTest exte
382		assertEquals(0, q.take());
383
384		await(pleaseInterrupt);
385	<	assertThreadBlocks(t, Thread.State.WAITING);
385	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
386		t.interrupt();
387		awaitTermination(t);
388		assertEquals(0, q.remainingCapacity());
#	Line 404 | Line 404 | public class ArrayBlockingQueueTest exte
404
405		Thread.currentThread().interrupt();
406		try {
407	<	q.offer(new Object(), 2 * LONG_DELAY_MS, MILLISECONDS);
407	>	q.offer(new Object(), randomTimeout(), randomTimeUnit());
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);
414	>	q.offer(new Object(), LONG_DELAY_MS, MILLISECONDS);
415		shouldThrow();
416		} catch (InterruptedException success) {}
417		assertFalse(Thread.interrupted());
418	+
419	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
420		}});
421
422		await(pleaseInterrupt);
423	<	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
423	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
424		t.interrupt();
425		awaitTermination(t);
426		}
#	Line 459 | Line 461 | public class ArrayBlockingQueueTest exte
461		}});
462
463		await(pleaseInterrupt);
464	<	assertThreadBlocks(t, Thread.State.WAITING);
464	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.WAITING);
465		t.interrupt();
466		awaitTermination(t);
467		}
#	Line 518 | Line 520 | public class ArrayBlockingQueueTest exte
520
521		Thread.currentThread().interrupt();
522		try {
523	<	q.poll(LONG_DELAY_MS, MILLISECONDS);
523	>	q.poll(randomTimeout(), randomTimeUnit());
524		shouldThrow();
525		} catch (InterruptedException success) {}
526		assertFalse(Thread.interrupted());
#	Line 534 | Line 536 | public class ArrayBlockingQueueTest exte
536		}});
537
538		await(pleaseInterrupt);
539	<	assertThreadBlocks(t, Thread.State.TIMED_WAITING);
539	>	if (randomBoolean()) assertThreadBlocks(t, Thread.State.TIMED_WAITING);
540		t.interrupt();
541		awaitTermination(t);
542		checkEmpty(q);
#	Line 876 | Line 878 | public class ArrayBlockingQueueTest exte
878		}
879
880		/**
881	<	* A deserialized serialized queue has same elements in same order
881	>	* A deserialized/reserialized queue has same elements in same order
882		*/
883		public void testSerialization() throws Exception {
884		Queue x = populatedQueue(SIZE);

Diff Legend

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