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.66 by jsr166, Sat May 23 00:53:08 2015 UTC vs.
Revision 1.73 by jsr166, Mon Oct 17 01:52:04 2016 UTC

#	Line 41 | Line 41 | public class ArrayBlockingQueueTest exte
41		}
42
43		public static Test suite() {
44	+	class Implementation implements CollectionImplementation {
45	+	public Class<?> klazz() { return ArrayBlockingQueue.class; }
46	+	public Collection emptyCollection() { return new ArrayBlockingQueue(SIZE, false); }
47	+	public Object makeElement(int i) { return i; }
48	+	public boolean isConcurrent() { return true; }
49	+	public boolean permitsNulls() { return false; }
50	+	}
51		return newTestSuite(ArrayBlockingQueueTest.class,
52		new Fair().testSuite(),
53	<	new NonFair().testSuite());
53	>	new NonFair().testSuite(),
54	>	CollectionTest.testSuite(new Implementation()));
55		}
56
57		/**
58		* Returns a new queue of given size containing consecutive
59	<	* Integers 0 ... n.
59	>	* Integers 0 ... n - 1.
60		*/
61		private ArrayBlockingQueue<Integer> populatedQueue(int n) {
62		ArrayBlockingQueue<Integer> q = new ArrayBlockingQueue<Integer>(n);
#	Line 58 | Line 66 | public class ArrayBlockingQueueTest exte
66		assertFalse(q.isEmpty());
67		assertEquals(0, q.remainingCapacity());
68		assertEquals(n, q.size());
69	+	assertEquals((Integer) 0, q.peek());
70		return q;
71		}
72
#	Line 451 | Line 460 | public class ArrayBlockingQueueTest exte
460		final CountDownLatch aboutToWait = new CountDownLatch(1);
461		Thread t = newStartedThread(new CheckedRunnable() {
462		public void realRun() throws InterruptedException {
463	+	long startTime = System.nanoTime();
464		for (int i = 0; i < SIZE; ++i) {
455	–	long t0 = System.nanoTime();
465		assertEquals(i, (int) q.poll(LONG_DELAY_MS, MILLISECONDS));
457	–	assertTrue(millisElapsedSince(t0) < SMALL_DELAY_MS);
466		}
459	–	long t0 = System.nanoTime();
467		aboutToWait.countDown();
468		try {
469	<	q.poll(MEDIUM_DELAY_MS, MILLISECONDS);
469	>	q.poll(LONG_DELAY_MS, MILLISECONDS);
470		shouldThrow();
471		} catch (InterruptedException success) {
472	<	assertTrue(millisElapsedSince(t0) < MEDIUM_DELAY_MS);
472	>	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
473		}
474		}});
475
476	<	aboutToWait.await();
477	<	waitForThreadToEnterWaitState(t, SMALL_DELAY_MS);
476	>	await(aboutToWait);
477	>	waitForThreadToEnterWaitState(t);
478		t.interrupt();
479	<	awaitTermination(t, MEDIUM_DELAY_MS);
479	>	awaitTermination(t);
480		checkEmpty(q);
481		}
482
#	Line 629 | Line 636 | public class ArrayBlockingQueueTest exte
636
637		void checkToArray2(ArrayBlockingQueue q) {
638		int size = q.size();
639	<	Integer[] a1 = size == 0 ? null : new Integer[size-1];
639	>	Integer[] a1 = (size == 0) ? null : new Integer[size - 1];
640		Integer[] a2 = new Integer[size];
641	<	Integer[] a3 = new Integer[size+2];
641	>	Integer[] a3 = new Integer[size + 2];
642		if (size > 0) Arrays.fill(a1, 42);
643		Arrays.fill(a2, 42);
644		Arrays.fill(a3, 42);
645	<	Integer[] b1 = size == 0 ? null : (Integer[]) q.toArray(a1);
645	>	Integer[] b1 = (size == 0) ? null : (Integer[]) q.toArray(a1);
646		Integer[] b2 = (Integer[]) q.toArray(a2);
647		Integer[] b3 = (Integer[]) q.toArray(a3);
648		assertSame(a2, b2);
#	Line 649 | Line 656 | public class ArrayBlockingQueueTest exte
656		assertSame(b3[i], x);
657		}
658		assertNull(a3[size]);
659	<	assertEquals(42, (int) a3[size+1]);
659	>	assertEquals(42, (int) a3[size + 1]);
660		if (size > 0) {
661		assertNotSame(a1, b1);
662		assertEquals(size, b1.length);
#	Line 788 | Line 795 | public class ArrayBlockingQueueTest exte
795		final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
796		q.add(one);
797		q.add(two);
791	–	ExecutorService executor = Executors.newFixedThreadPool(2);
798		final CheckedBarrier threadsStarted = new CheckedBarrier(2);
799	<	executor.execute(new CheckedRunnable() {
800	<	public void realRun() throws InterruptedException {
801	<	assertFalse(q.offer(three));
802	<	threadsStarted.await();
803	<	assertTrue(q.offer(three, LONG_DELAY_MS, MILLISECONDS));
804	<	assertEquals(0, q.remainingCapacity());
805	<	}});
806	<
807	<	executor.execute(new CheckedRunnable() {
808	<	public void realRun() throws InterruptedException {
809	<	threadsStarted.await();
810	<	assertEquals(0, q.remainingCapacity());
811	<	assertSame(one, q.take());
812	<	}});
813	<
814	<	joinPool(executor);
799	>	final ExecutorService executor = Executors.newFixedThreadPool(2);
800	>	try (PoolCleaner cleaner = cleaner(executor)) {
801	>	executor.execute(new CheckedRunnable() {
802	>	public void realRun() throws InterruptedException {
803	>	assertFalse(q.offer(three));
804	>	threadsStarted.await();
805	>	assertTrue(q.offer(three, LONG_DELAY_MS, MILLISECONDS));
806	>	assertEquals(0, q.remainingCapacity());
807	>	}});
808	>
809	>	executor.execute(new CheckedRunnable() {
810	>	public void realRun() throws InterruptedException {
811	>	threadsStarted.await();
812	>	assertEquals(0, q.remainingCapacity());
813	>	assertSame(one, q.take());
814	>	}});
815	>	}
816		}
817
818		/**
#	Line 814 | Line 821 | public class ArrayBlockingQueueTest exte
821		public void testPollInExecutor() {
822		final ArrayBlockingQueue q = new ArrayBlockingQueue(2);
823		final CheckedBarrier threadsStarted = new CheckedBarrier(2);
824	<	ExecutorService executor = Executors.newFixedThreadPool(2);
825	<	executor.execute(new CheckedRunnable() {
826	<	public void realRun() throws InterruptedException {
827	<	assertNull(q.poll());
828	<	threadsStarted.await();
829	<	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
830	<	checkEmpty(q);
831	<	}});
832	<
833	<	executor.execute(new CheckedRunnable() {
834	<	public void realRun() throws InterruptedException {
835	<	threadsStarted.await();
836	<	q.put(one);
837	<	}});
838	<
839	<	joinPool(executor);
824	>	final ExecutorService executor = Executors.newFixedThreadPool(2);
825	>	try (PoolCleaner cleaner = cleaner(executor)) {
826	>	executor.execute(new CheckedRunnable() {
827	>	public void realRun() throws InterruptedException {
828	>	assertNull(q.poll());
829	>	threadsStarted.await();
830	>	assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
831	>	checkEmpty(q);
832	>	}});
833	>
834	>	executor.execute(new CheckedRunnable() {
835	>	public void realRun() throws InterruptedException {
836	>	threadsStarted.await();
837	>	q.put(one);
838	>	}});
839	>	}
840		}
841
842		/**

Diff Legend

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