ViewVC Help

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

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

Comparing jsr166/src/test/tck/ForkJoinPoolTest.java (file contents):
Revision 1.62 by jsr166, Sun Oct 4 07:42:07 2015 UTC vs.
Revision 1.76 by jsr166, Tue Jan 23 20:44:11 2018 UTC

#	Line 11 | Line 11 | import java.security.PrivilegedAction;
11		import java.security.PrivilegedExceptionAction;
12		import java.util.ArrayList;
13		import java.util.Collection;
14	+	import java.util.Collections;
15		import java.util.List;
16		import java.util.concurrent.Callable;
17		import java.util.concurrent.CountDownLatch;
#	Line 24 | Line 25 | import java.util.concurrent.Future;
25		import java.util.concurrent.RecursiveTask;
26		import java.util.concurrent.RejectedExecutionException;
27		import java.util.concurrent.atomic.AtomicBoolean;
28	+	import java.util.concurrent.atomic.AtomicInteger;
29		import java.util.concurrent.locks.ReentrantLock;
30
29	–	import junit.framework.AssertionFailedError;
31		import junit.framework.Test;
32		import junit.framework.TestSuite;
33
#	Line 57 | Line 58 | public class ForkJoinPoolTest extends JS
58
59		// Some classes to test extension and factory methods
60
61	<	static class MyHandler implements Thread.UncaughtExceptionHandler {
61	<	volatile int catches = 0;
62	<	public void uncaughtException(Thread t, Throwable e) {
63	<	++catches;
64	<	}
65	<	}
61	>	static class MyError extends Error {}
62
63		// to test handlers
64		static class FailingFJWSubclass extends ForkJoinWorkerThread {
65		public FailingFJWSubclass(ForkJoinPool p) { super(p) ; }
66	<	protected void onStart() { super.onStart(); throw new Error(); }
66	>	protected void onStart() { super.onStart(); throw new MyError(); }
67		}
68
69		static class FailingThreadFactory
70		implements ForkJoinPool.ForkJoinWorkerThreadFactory {
71	<	volatile int calls = 0;
71	>	final AtomicInteger calls = new AtomicInteger(0);
72		public ForkJoinWorkerThread newThread(ForkJoinPool p) {
73	<	if (++calls > 1) return null;
73	>	if (calls.incrementAndGet() > 1) return null;
74		return new FailingFJWSubclass(p);
75		}
76		}
#	Line 211 | Line 207 | public class ForkJoinPoolTest extends JS
207		* getPoolSize returns number of started workers.
208		*/
209		public void testGetPoolSize() {
210	<	ForkJoinPool p = new ForkJoinPool(1);
210	>	final CountDownLatch taskStarted = new CountDownLatch(1);
211	>	final CountDownLatch done = new CountDownLatch(1);
212	>	final ForkJoinPool p = new ForkJoinPool(1);
213		try (PoolCleaner cleaner = cleaner(p)) {
214		assertEquals(0, p.getActiveThreadCount());
215	<	Future<String> future = p.submit(new StringTask());
215	>	final Runnable task = new CheckedRunnable() {
216	>	public void realRun() throws InterruptedException {
217	>	taskStarted.countDown();
218	>	assertEquals(1, p.getPoolSize());
219	>	assertEquals(1, p.getActiveThreadCount());
220	>	await(done);
221	>	}};
222	>	Future<?> future = p.submit(task);
223	>	await(taskStarted);
224		assertEquals(1, p.getPoolSize());
225	+	assertEquals(1, p.getActiveThreadCount());
226	+	done.countDown();
227		}
228	+	assertEquals(0, p.getPoolSize());
229	+	assertEquals(0, p.getActiveThreadCount());
230		}
231
232		/**
#	Line 230 | Line 240 | public class ForkJoinPoolTest extends JS
240		assertFalse(p.awaitTermination(Long.MIN_VALUE, MILLISECONDS));
241		assertFalse(p.awaitTermination(-1L, NANOSECONDS));
242		assertFalse(p.awaitTermination(-1L, MILLISECONDS));
243	<	assertFalse(p.awaitTermination(0L, NANOSECONDS));
244	<	assertFalse(p.awaitTermination(0L, MILLISECONDS));
243	>	assertFalse(p.awaitTermination(randomExpiredTimeout(),
244	>	randomTimeUnit()));
245		long timeoutNanos = 999999L;
246		long startTime = System.nanoTime();
247		assertFalse(p.awaitTermination(timeoutNanos, NANOSECONDS));
#	Line 256 | Line 266 | public class ForkJoinPoolTest extends JS
266		*/
267		public void testSetUncaughtExceptionHandler() throws InterruptedException {
268		final CountDownLatch uehInvoked = new CountDownLatch(1);
269	<	final Thread.UncaughtExceptionHandler eh =
269	>	final Thread.UncaughtExceptionHandler ueh =
270		new Thread.UncaughtExceptionHandler() {
271		public void uncaughtException(Thread t, Throwable e) {
272	+	threadAssertTrue(e instanceof MyError);
273	+	threadAssertTrue(t instanceof FailingFJWSubclass);
274		uehInvoked.countDown();
275		}};
276		ForkJoinPool p = new ForkJoinPool(1, new FailingThreadFactory(),
277	<	eh, false);
278	<	try {
279	<	assertSame(eh, p.getUncaughtExceptionHandler());
277	>	ueh, false);
278	>	try (PoolCleaner cleaner = cleaner(p)) {
279	>	assertSame(ueh, p.getUncaughtExceptionHandler());
280		try {
281		p.execute(new FibTask(8));
282	<	assertTrue(uehInvoked.await(MEDIUM_DELAY_MS, MILLISECONDS));
283	<	} catch (RejectedExecutionException ok) {
282	>	await(uehInvoked);
283	>	} finally {
284	>	p.shutdownNow(); // failure might have prevented processing task
285		}
273	–	} finally {
274	–	p.shutdownNow(); // failure might have prevented processing task
275	–	joinPool(p);
286		}
287		}
288
#	Line 293 | Line 303 | public class ForkJoinPoolTest extends JS
303		p.getFactory());
304		while (! p.isQuiescent()) {
305		if (millisElapsedSince(startTime) > LONG_DELAY_MS)
306	<	throw new AssertionFailedError("timed out");
306	>	throw new AssertionError("timed out");
307		assertFalse(p.getAsyncMode());
308		assertFalse(p.isShutdown());
309		assertFalse(p.isTerminating());
#	Line 303 | Line 313 | public class ForkJoinPoolTest extends JS
313
314		assertTrue(p.isQuiescent());
315		assertFalse(p.getAsyncMode());
306	–	assertEquals(0, p.getActiveThreadCount());
316		assertEquals(0, p.getQueuedTaskCount());
317		assertEquals(0, p.getQueuedSubmissionCount());
318		assertFalse(p.hasQueuedSubmissions());
319	+	while (p.getActiveThreadCount() != 0
320	+	&& millisElapsedSince(startTime) < LONG_DELAY_MS)
321	+	Thread.yield();
322		assertFalse(p.isShutdown());
323		assertFalse(p.isTerminating());
324		assertFalse(p.isTerminated());
325		assertTrue(f.isDone());
326		assertEquals(6765, (int) f.get());
327	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
328		}
329		}
330
#	Line 409 | Line 422 | public class ForkJoinPoolTest extends JS
422		done.set(true);
423		}});
424		assertNull(future.get());
425	<	assertNull(future.get(0, MILLISECONDS));
425	>	assertNull(future.get(randomExpiredTimeout(), randomTimeUnit()));
426		assertTrue(done.get());
427		assertTrue(future.isDone());
428		assertFalse(future.isCancelled());
#	Line 548 | Line 561 | public class ForkJoinPoolTest extends JS
561		public void testInterruptedSubmit() throws InterruptedException {
562		final CountDownLatch submitted    = new CountDownLatch(1);
563		final CountDownLatch quittingTime = new CountDownLatch(1);
551	–	final ExecutorService p = new ForkJoinPool(1);
564		final Callable<Void> awaiter = new CheckedCallable<Void>() {
565		public Void realCall() throws InterruptedException {
566	<	assertTrue(quittingTime.await(MEDIUM_DELAY_MS, MILLISECONDS));
566	>	assertTrue(quittingTime.await(2*LONG_DELAY_MS, MILLISECONDS));
567		return null;
568		}};
569	<	try {
569	>	final ExecutorService p = new ForkJoinPool(1);
570	>	try (PoolCleaner cleaner = cleaner(p, quittingTime)) {
571		Thread t = new Thread(new CheckedInterruptedRunnable() {
572		public void realRun() throws Exception {
573		Future<Void> future = p.submit(awaiter);
#	Line 562 | Line 575 | public class ForkJoinPoolTest extends JS
575		future.get();
576		}});
577		t.start();
578	<	assertTrue(submitted.await(MEDIUM_DELAY_MS, MILLISECONDS));
578	>	await(submitted);
579		t.interrupt();
580	<	t.join();
568	<	} finally {
569	<	quittingTime.countDown();
570	<	joinPool(p);
580	>	awaitTermination(t);
581		}
582		}
583
#	Line 621 | Line 631 | public class ForkJoinPoolTest extends JS
631		public void testInvokeAny3() throws Throwable {
632		ExecutorService e = new ForkJoinPool(1);
633		try (PoolCleaner cleaner = cleaner(e)) {
634	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
634	>	List<Callable<String>> l = new ArrayList<>();
635		l.add(null);
636		try {
637		e.invokeAny(l);
#	Line 637 | Line 647 | public class ForkJoinPoolTest extends JS
647		CountDownLatch latch = new CountDownLatch(1);
648		ExecutorService e = new ForkJoinPool(1);
649		try (PoolCleaner cleaner = cleaner(e)) {
650	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
650	>	List<Callable<String>> l = new ArrayList<>();
651		l.add(latchAwaitingStringTask(latch));
652		l.add(null);
653		try {
#	Line 654 | Line 664 | public class ForkJoinPoolTest extends JS
664		public void testInvokeAny5() throws Throwable {
665		ExecutorService e = new ForkJoinPool(1);
666		try (PoolCleaner cleaner = cleaner(e)) {
667	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
667	>	List<Callable<String>> l = new ArrayList<>();
668		l.add(new NPETask());
669		try {
670		e.invokeAny(l);
#	Line 671 | Line 681 | public class ForkJoinPoolTest extends JS
681		public void testInvokeAny6() throws Throwable {
682		ExecutorService e = new ForkJoinPool(1);
683		try (PoolCleaner cleaner = cleaner(e)) {
684	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
684	>	List<Callable<String>> l = new ArrayList<>();
685		l.add(new StringTask());
686		l.add(new StringTask());
687		String result = e.invokeAny(l);
#	Line 693 | Line 703 | public class ForkJoinPoolTest extends JS
703		}
704
705		/**
706	<	* invokeAll(empty collection) returns empty collection
706	>	* invokeAll(empty collection) returns empty list
707		*/
708		public void testInvokeAll2() throws InterruptedException {
709		ExecutorService e = new ForkJoinPool(1);
710	+	final Collection<Callable<String>> emptyCollection
711	+	= Collections.emptyList();
712		try (PoolCleaner cleaner = cleaner(e)) {
713	<	List<Future<String>> r
702	<	= e.invokeAll(new ArrayList<Callable<String>>());
713	>	List<Future<String>> r = e.invokeAll(emptyCollection);
714		assertTrue(r.isEmpty());
715		}
716		}
#	Line 710 | Line 721 | public class ForkJoinPoolTest extends JS
721		public void testInvokeAll3() throws InterruptedException {
722		ExecutorService e = new ForkJoinPool(1);
723		try (PoolCleaner cleaner = cleaner(e)) {
724	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
724	>	List<Callable<String>> l = new ArrayList<>();
725		l.add(new StringTask());
726		l.add(null);
727		try {
#	Line 727 | Line 738 | public class ForkJoinPoolTest extends JS
738		public void testInvokeAll4() throws Throwable {
739		ExecutorService e = new ForkJoinPool(1);
740		try (PoolCleaner cleaner = cleaner(e)) {
741	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
741	>	List<Callable<String>> l = new ArrayList<>();
742		l.add(new NPETask());
743		List<Future<String>> futures = e.invokeAll(l);
744		assertEquals(1, futures.size());
#	Line 746 | Line 757 | public class ForkJoinPoolTest extends JS
757		public void testInvokeAll5() throws Throwable {
758		ExecutorService e = new ForkJoinPool(1);
759		try (PoolCleaner cleaner = cleaner(e)) {
760	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
760	>	List<Callable<String>> l = new ArrayList<>();
761		l.add(new StringTask());
762		l.add(new StringTask());
763		List<Future<String>> futures = e.invokeAll(l);
#	Line 763 | Line 774 | public class ForkJoinPoolTest extends JS
774		ExecutorService e = new ForkJoinPool(1);
775		try (PoolCleaner cleaner = cleaner(e)) {
776		try {
777	<	e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
777	>	e.invokeAny(null, randomTimeout(), randomTimeUnit());
778		shouldThrow();
779		} catch (NullPointerException success) {}
780		}
#	Line 775 | Line 786 | public class ForkJoinPoolTest extends JS
786		public void testTimedInvokeAnyNullTimeUnit() throws Throwable {
787		ExecutorService e = new ForkJoinPool(1);
788		try (PoolCleaner cleaner = cleaner(e)) {
789	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
789	>	List<Callable<String>> l = new ArrayList<>();
790		l.add(new StringTask());
791		try {
792	<	e.invokeAny(l, MEDIUM_DELAY_MS, null);
792	>	e.invokeAny(l, randomTimeout(), null);
793		shouldThrow();
794		} catch (NullPointerException success) {}
795		}
#	Line 792 | Line 803 | public class ForkJoinPoolTest extends JS
803		try (PoolCleaner cleaner = cleaner(e)) {
804		try {
805		e.invokeAny(new ArrayList<Callable<String>>(),
806	<	MEDIUM_DELAY_MS, MILLISECONDS);
806	>	randomTimeout(), randomTimeUnit());
807		shouldThrow();
808		} catch (IllegalArgumentException success) {}
809		}
#	Line 805 | Line 816 | public class ForkJoinPoolTest extends JS
816		CountDownLatch latch = new CountDownLatch(1);
817		ExecutorService e = new ForkJoinPool(1);
818		try (PoolCleaner cleaner = cleaner(e)) {
819	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
819	>	List<Callable<String>> l = new ArrayList<>();
820		l.add(latchAwaitingStringTask(latch));
821		l.add(null);
822		try {
823	<	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
823	>	e.invokeAny(l, randomTimeout(), randomTimeUnit());
824		shouldThrow();
825		} catch (NullPointerException success) {}
826		latch.countDown();
#	Line 822 | Line 833 | public class ForkJoinPoolTest extends JS
833		public void testTimedInvokeAny4() throws Throwable {
834		ExecutorService e = new ForkJoinPool(1);
835		try (PoolCleaner cleaner = cleaner(e)) {
836	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
836	>	long startTime = System.nanoTime();
837	>	List<Callable<String>> l = new ArrayList<>();
838		l.add(new NPETask());
839		try {
840	<	e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
840	>	e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
841		shouldThrow();
842		} catch (ExecutionException success) {
843		assertTrue(success.getCause() instanceof NullPointerException);
844		}
845	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
846		}
847		}
848
#	Line 839 | Line 852 | public class ForkJoinPoolTest extends JS
852		public void testTimedInvokeAny5() throws Throwable {
853		ExecutorService e = new ForkJoinPool(1);
854		try (PoolCleaner cleaner = cleaner(e)) {
855	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
855	>	long startTime = System.nanoTime();
856	>	List<Callable<String>> l = new ArrayList<>();
857		l.add(new StringTask());
858		l.add(new StringTask());
859	<	String result = e.invokeAny(l, MEDIUM_DELAY_MS, MILLISECONDS);
859	>	String result = e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
860		assertSame(TEST_STRING, result);
861	+	assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
862		}
863		}
864
#	Line 854 | Line 869 | public class ForkJoinPoolTest extends JS
869		ExecutorService e = new ForkJoinPool(1);
870		try (PoolCleaner cleaner = cleaner(e)) {
871		try {
872	<	e.invokeAll(null, MEDIUM_DELAY_MS, MILLISECONDS);
872	>	e.invokeAll(null, randomTimeout(), randomTimeUnit());
873		shouldThrow();
874		} catch (NullPointerException success) {}
875		}
#	Line 866 | Line 881 | public class ForkJoinPoolTest extends JS
881		public void testTimedInvokeAllNullTimeUnit() throws Throwable {
882		ExecutorService e = new ForkJoinPool(1);
883		try (PoolCleaner cleaner = cleaner(e)) {
884	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
884	>	List<Callable<String>> l = new ArrayList<>();
885		l.add(new StringTask());
886		try {
887	<	e.invokeAll(l, MEDIUM_DELAY_MS, null);
887	>	e.invokeAll(l, randomTimeout(), null);
888		shouldThrow();
889		} catch (NullPointerException success) {}
890		}
891		}
892
893		/**
894	<	* timed invokeAll(empty collection) returns empty collection
894	>	* timed invokeAll(empty collection) returns empty list
895		*/
896		public void testTimedInvokeAll2() throws InterruptedException {
897		ExecutorService e = new ForkJoinPool(1);
898	+	final Collection<Callable<String>> emptyCollection
899	+	= Collections.emptyList();
900		try (PoolCleaner cleaner = cleaner(e)) {
901		List<Future<String>> r
902	<	= e.invokeAll(new ArrayList<Callable<String>>(),
903	<	MEDIUM_DELAY_MS, MILLISECONDS);
902	>	= e.invokeAll(emptyCollection,
903	>	randomTimeout(), randomTimeUnit());
904		assertTrue(r.isEmpty());
905		}
906		}
#	Line 894 | Line 911 | public class ForkJoinPoolTest extends JS
911		public void testTimedInvokeAll3() throws InterruptedException {
912		ExecutorService e = new ForkJoinPool(1);
913		try (PoolCleaner cleaner = cleaner(e)) {
914	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
914	>	List<Callable<String>> l = new ArrayList<>();
915		l.add(new StringTask());
916		l.add(null);
917		try {
918	<	e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
918	>	e.invokeAll(l, randomTimeout(), randomTimeUnit());
919		shouldThrow();
920		} catch (NullPointerException success) {}
921		}
#	Line 910 | Line 927 | public class ForkJoinPoolTest extends JS
927		public void testTimedInvokeAll4() throws Throwable {
928		ExecutorService e = new ForkJoinPool(1);
929		try (PoolCleaner cleaner = cleaner(e)) {
930	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
930	>	List<Callable<String>> l = new ArrayList<>();
931		l.add(new NPETask());
932		List<Future<String>> futures
933	<	= e.invokeAll(l, MEDIUM_DELAY_MS, MILLISECONDS);
933	>	= e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
934		assertEquals(1, futures.size());
935		try {
936		futures.get(0).get();
#	Line 930 | Line 947 | public class ForkJoinPoolTest extends JS
947		public void testTimedInvokeAll5() throws Throwable {
948		ForkJoinPool e = new ForkJoinPool(1);
949		try (PoolCleaner cleaner = cleaner(e)) {
950	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
950	>	List<Callable<String>> l = new ArrayList<>();
951		l.add(new StringTask());
952		l.add(new StringTask());
953		List<Future<String>> futures

Diff Legend

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