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.70 by jsr166, Tue Oct 13 21:18:28 2015 UTC vs.
Revision 1.74 by jsr166, Mon May 29 19:15:02 2017 UTC

#	Line 24 | Line 24 | import java.util.concurrent.Future;
24		import java.util.concurrent.RecursiveTask;
25		import java.util.concurrent.RejectedExecutionException;
26		import java.util.concurrent.atomic.AtomicBoolean;
27	+	import java.util.concurrent.atomic.AtomicInteger;
28		import java.util.concurrent.locks.ReentrantLock;
29
30		import junit.framework.AssertionFailedError;
#	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 223 | Line 217 | public class ForkJoinPoolTest extends JS
217		taskStarted.countDown();
218		assertEquals(1, p.getPoolSize());
219		assertEquals(1, p.getActiveThreadCount());
220	<	done.await();
220	>	await(done);
221		}};
222		Future<?> future = p.submit(task);
223		await(taskStarted);
#	Line 246 | 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 428 | 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 637 | 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 653 | 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 670 | 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 687 | 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 726 | Line 720 | public class ForkJoinPoolTest extends JS
720		public void testInvokeAll3() throws InterruptedException {
721		ExecutorService e = new ForkJoinPool(1);
722		try (PoolCleaner cleaner = cleaner(e)) {
723	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
723	>	List<Callable<String>> l = new ArrayList<>();
724		l.add(new StringTask());
725		l.add(null);
726		try {
#	Line 743 | Line 737 | public class ForkJoinPoolTest extends JS
737		public void testInvokeAll4() throws Throwable {
738		ExecutorService e = new ForkJoinPool(1);
739		try (PoolCleaner cleaner = cleaner(e)) {
740	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
740	>	List<Callable<String>> l = new ArrayList<>();
741		l.add(new NPETask());
742		List<Future<String>> futures = e.invokeAll(l);
743		assertEquals(1, futures.size());
#	Line 762 | Line 756 | public class ForkJoinPoolTest extends JS
756		public void testInvokeAll5() throws Throwable {
757		ExecutorService e = new ForkJoinPool(1);
758		try (PoolCleaner cleaner = cleaner(e)) {
759	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
759	>	List<Callable<String>> l = new ArrayList<>();
760		l.add(new StringTask());
761		l.add(new StringTask());
762		List<Future<String>> futures = e.invokeAll(l);
#	Line 779 | Line 773 | public class ForkJoinPoolTest extends JS
773		ExecutorService e = new ForkJoinPool(1);
774		try (PoolCleaner cleaner = cleaner(e)) {
775		try {
776	<	e.invokeAny(null, MEDIUM_DELAY_MS, MILLISECONDS);
776	>	e.invokeAny(null, randomTimeout(), randomTimeUnit());
777		shouldThrow();
778		} catch (NullPointerException success) {}
779		}
#	Line 791 | Line 785 | public class ForkJoinPoolTest extends JS
785		public void testTimedInvokeAnyNullTimeUnit() throws Throwable {
786		ExecutorService e = new ForkJoinPool(1);
787		try (PoolCleaner cleaner = cleaner(e)) {
788	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
788	>	List<Callable<String>> l = new ArrayList<>();
789		l.add(new StringTask());
790		try {
791	<	e.invokeAny(l, MEDIUM_DELAY_MS, null);
791	>	e.invokeAny(l, randomTimeout(), null);
792		shouldThrow();
793		} catch (NullPointerException success) {}
794		}
#	Line 808 | Line 802 | public class ForkJoinPoolTest extends JS
802		try (PoolCleaner cleaner = cleaner(e)) {
803		try {
804		e.invokeAny(new ArrayList<Callable<String>>(),
805	<	MEDIUM_DELAY_MS, MILLISECONDS);
805	>	randomTimeout(), randomTimeUnit());
806		shouldThrow();
807		} catch (IllegalArgumentException success) {}
808		}
#	Line 821 | Line 815 | public class ForkJoinPoolTest extends JS
815		CountDownLatch latch = new CountDownLatch(1);
816		ExecutorService e = new ForkJoinPool(1);
817		try (PoolCleaner cleaner = cleaner(e)) {
818	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
818	>	List<Callable<String>> l = new ArrayList<>();
819		l.add(latchAwaitingStringTask(latch));
820		l.add(null);
821		try {
#	Line 839 | Line 833 | public class ForkJoinPoolTest extends JS
833		ExecutorService e = new ForkJoinPool(1);
834		try (PoolCleaner cleaner = cleaner(e)) {
835		long startTime = System.nanoTime();
836	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
836	>	List<Callable<String>> l = new ArrayList<>();
837		l.add(new NPETask());
838		try {
839		e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
#	Line 858 | Line 852 | public class ForkJoinPoolTest extends JS
852		ExecutorService e = new ForkJoinPool(1);
853		try (PoolCleaner cleaner = cleaner(e)) {
854		long startTime = System.nanoTime();
855	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
855	>	List<Callable<String>> l = new ArrayList<>();
856		l.add(new StringTask());
857		l.add(new StringTask());
858		String result = e.invokeAny(l, LONG_DELAY_MS, MILLISECONDS);
#	Line 886 | Line 880 | public class ForkJoinPoolTest extends JS
880		public void testTimedInvokeAllNullTimeUnit() throws Throwable {
881		ExecutorService e = new ForkJoinPool(1);
882		try (PoolCleaner cleaner = cleaner(e)) {
883	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
883	>	List<Callable<String>> l = new ArrayList<>();
884		l.add(new StringTask());
885		try {
886		e.invokeAll(l, MEDIUM_DELAY_MS, null);
#	Line 914 | Line 908 | public class ForkJoinPoolTest extends JS
908		public void testTimedInvokeAll3() throws InterruptedException {
909		ExecutorService e = new ForkJoinPool(1);
910		try (PoolCleaner cleaner = cleaner(e)) {
911	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
911	>	List<Callable<String>> l = new ArrayList<>();
912		l.add(new StringTask());
913		l.add(null);
914		try {
#	Line 930 | Line 924 | public class ForkJoinPoolTest extends JS
924		public void testTimedInvokeAll4() throws Throwable {
925		ExecutorService e = new ForkJoinPool(1);
926		try (PoolCleaner cleaner = cleaner(e)) {
927	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
927	>	List<Callable<String>> l = new ArrayList<>();
928		l.add(new NPETask());
929		List<Future<String>> futures
930		= e.invokeAll(l, LONG_DELAY_MS, MILLISECONDS);
#	Line 950 | Line 944 | public class ForkJoinPoolTest extends JS
944		public void testTimedInvokeAll5() throws Throwable {
945		ForkJoinPool e = new ForkJoinPool(1);
946		try (PoolCleaner cleaner = cleaner(e)) {
947	<	List<Callable<String>> l = new ArrayList<Callable<String>>();
947	>	List<Callable<String>> l = new ArrayList<>();
948		l.add(new StringTask());
949		l.add(new StringTask());
950		List<Future<String>> futures

Diff Legend

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