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.67 by jsr166, Thu Oct 8 03:03:36 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
60	–	static class MyHandler implements Thread.UncaughtExceptionHandler {
61	–	volatile int catches = 0;
62	–	public void uncaughtException(Thread t, Throwable e) {
63	–	++catches;
64	–	}
65	–	}
66	–
61		static class MyError extends Error {}
62
63		// to test handlers
#	Line 74 | Line 68 | public class ForkJoinPoolTest extends JS
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 213 | 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 232 | 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 295 | 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 305 | Line 313 | public class ForkJoinPoolTest extends JS
313
314		assertTrue(p.isQuiescent());
315		assertFalse(p.getAsyncMode());
308	–	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 411 | 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 620 | 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 636 | 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 653 | 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 670 | 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 692 | 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
701	<	= e.invokeAll(new ArrayList<Callable<String>>());
713	>	List<Future<String>> r = e.invokeAll(emptyCollection);
714		assertTrue(r.isEmpty());
715		}
716		}
#	Line 709 | 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 726 | 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 745 | 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 762 | 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 774 | 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 791 | 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 804 | 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 834 | public class ForkJoinPoolTest extends JS
834		ExecutorService e = new ForkJoinPool(1);
835		try (PoolCleaner cleaner = cleaner(e)) {
836		long startTime = System.nanoTime();
837	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
837	>	List<Callable<String>> l = new ArrayList<>();
838		l.add(new NPETask());
839		try {
840		e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
#	Line 840 | 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 855 | 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 867 | 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 895 | 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 911 | 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, LONG_DELAY_MS, MILLISECONDS);
#	Line 931 | 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