test/tck/ForkJoinPool19Test.java

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/publicdomain/zero/1.0/
 */

import static java.util.concurrent.TimeUnit.MILLISECONDS;

import java.util.HashSet;
import java.util.concurrent.CancellationException;
import java.util.concurrent.CountedCompleter;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.TimeoutException;
import java.util.concurrent.Callable;

import junit.framework.Test;
import junit.framework.TestSuite;

/**
 * Tests for ForkJoinPool and corresponding ForkJoinTask additions.
 */
public class ForkJoinPool19Test extends JSR166TestCase {
    public static void main(String[] args) {
        main(suite(), args);
    }

    public static Test suite() {
        return new TestSuite(ForkJoinPool8Test.class);
    }

    /**
     * SetParallelism sets reported parallellism and returns previous value
     */
    public void testSetParallelism() {
        final ForkJoinPool p = new ForkJoinPool(2);
        assertEquals(2, p.getParallelism());
        assertEquals(2, p.setParallelism(3));
        assertEquals(3, p.setParallelism(2));
        p.shutdown();
    }

    /**
     * SetParallelism throws exception if argument out of bounds
     */
    public void testSetParallelismBadArgs() {
        final ForkJoinPool p = new ForkJoinPool(2);
        try {
            p.setParallelism(0);
            shouldThrow();
        } catch (Exception success) {
        }
        try {
            p.setParallelism(Integer.MAX_VALUE);
            shouldThrow();
        } catch (Exception success) {
        }
        assertEquals(2, p.getParallelism());
        p.shutdown();
    }


    /*
     * Some test methods adapted from RecursiveAction
     */
    private static ForkJoinPool mainPool() {
        return new ForkJoinPool();
    }

    private void testInvokeOnPool(ForkJoinPool pool, RecursiveAction a) {
        try (PoolCleaner cleaner = cleaner(pool)) {
            checkNotDone(a);
            assertNull(pool.invoke(a));
            checkCompletedNormally(a);
        }
    }

    private void checkInvoke(ForkJoinTask<?> a) {
        checkNotDone(a);
        assertNull(a.invoke());
        checkCompletedNormally(a);
    }

    void checkNotDone(ForkJoinTask<?> a) {
        assertFalse(a.isDone());
        assertFalse(a.isCompletedNormally());
        assertFalse(a.isCompletedAbnormally());
        assertFalse(a.isCancelled());
        assertNull(a.getException());
        assertNull(a.getRawResult());

        if (! ForkJoinTask.inForkJoinPool()) {
            Thread.currentThread().interrupt();
            try {
                a.get();
                shouldThrow();
            } catch (InterruptedException success) {
            } catch (Throwable fail) { threadUnexpectedException(fail); }

            Thread.currentThread().interrupt();
            try {
                a.get(randomTimeout(), randomTimeUnit());
                shouldThrow();
            } catch (InterruptedException success) {
            } catch (Throwable fail) { threadUnexpectedException(fail); }
        }

        try {
            a.get(randomExpiredTimeout(), randomTimeUnit());
            shouldThrow();
        } catch (TimeoutException success) {
        } catch (Throwable fail) { threadUnexpectedException(fail); }
    }

    void checkCompletedNormally(ForkJoinTask<?> a) {
        assertTrue(a.isDone());
        assertFalse(a.isCancelled());
        assertTrue(a.isCompletedNormally());
        assertFalse(a.isCompletedAbnormally());
        assertNull(a.getException());
        assertNull(a.getRawResult());
        assertNull(a.join());
        assertFalse(a.cancel(false));
        assertFalse(a.cancel(true));

        Object v1 = null, v2 = null;
        try {
            v1 = a.get();
            v2 = a.get(randomTimeout(), randomTimeUnit());
        } catch (Throwable fail) { threadUnexpectedException(fail); }
        assertNull(v1);
        assertNull(v2);
    }

    void checkCancelled(ForkJoinTask<?> a) {
        assertTrue(a.isDone());
        assertTrue(a.isCancelled());
        assertFalse(a.isCompletedNormally());
        assertTrue(a.isCompletedAbnormally());
        assertTrue(a.getException() instanceof CancellationException);
        assertNull(a.getRawResult());

        try {
            a.join();
            shouldThrow();
        } catch (CancellationException success) {
        } catch (Throwable fail) { threadUnexpectedException(fail); }

        try {
            a.get();
            shouldThrow();
        } catch (CancellationException success) {
        } catch (Throwable fail) { threadUnexpectedException(fail); }

        try {
            a.get(randomTimeout(), randomTimeUnit());
            shouldThrow();
        } catch (CancellationException success) {
        } catch (Throwable fail) { threadUnexpectedException(fail); }
    }

    void checkCompletedAbnormally(ForkJoinTask<?> a, Throwable t) {
        assertTrue(a.isDone());
        assertFalse(a.isCancelled());
        assertFalse(a.isCompletedNormally());
        assertTrue(a.isCompletedAbnormally());
        assertSame(t.getClass(), a.getException().getClass());
        assertNull(a.getRawResult());
        assertFalse(a.cancel(false));
        assertFalse(a.cancel(true));

        try {
            a.join();
            shouldThrow();
        } catch (Throwable expected) {
            assertSame(expected.getClass(), t.getClass());
        }

        try {
            a.get();
            shouldThrow();
        } catch (ExecutionException success) {
            assertSame(t.getClass(), success.getCause().getClass());
        } catch (Throwable fail) { threadUnexpectedException(fail); }

        try {
            a.get(randomTimeout(), randomTimeUnit());
            shouldThrow();
        } catch (ExecutionException success) {
            assertSame(t.getClass(), success.getCause().getClass());
        } catch (Throwable fail) { threadUnexpectedException(fail); }
    }

    public static final class FJException extends RuntimeException {
        public FJException() { super(); }
        public FJException(Throwable cause) { super(cause); }
    }

    /** A simple recursive action for testing. */
    final class FibAction extends CheckedRecursiveAction {
        final int number;
        int result;
        FibAction(int n) { number = n; }
        protected void realCompute() {
            int n = number;
            if (n <= 1)
                result = n;
            else {
                FibAction f1 = new FibAction(n - 1);
                FibAction f2 = new FibAction(n - 2);
                invokeAll(f1, f2);
                result = f1.result + f2.result;
            }
        }
    }

    /** A recursive action failing in base case. */
    static final class FailingFibAction extends RecursiveAction {
        final int number;
        int result;
        FailingFibAction(int n) { number = n; }
        public void compute() {
            int n = number;
            if (n <= 1)
                throw new FJException();
            else {
                FailingFibAction f1 = new FailingFibAction(n - 1);
                FailingFibAction f2 = new FailingFibAction(n - 2);
                invokeAll(f1, f2);
                result = f1.result + f2.result;
            }
        }
    }

    /**
     * lazySubmit submits a task that is not executed until new
     * workers are created or it is explicitly joined by a worker.
     */
    public void testLazySubmit() {
        RecursiveAction a = new CheckedRecursiveAction() {
            protected void realCompute() {
                final ForkJoinPool p = mainPool();
                FibAction f = new FibAction(8);
                p.lazySubmit(f);
                checkNotDone(f);
                FibAction g = new FibAction(8);
                p.submit(g);
                g.join();
                f.join();
                assertEquals(21, f.result);
                checkCompletedNormally(f);
            }};
        testInvokeOnPool(mainPool(), a);
    }

    /**
     * quietlyInvoke task returns when task completes normally.
     * isCompletedAbnormally and isCancelled return false for normally
     * completed tasks
     */
    public void testQuietlyInvoke() {
        RecursiveAction a = new CheckedRecursiveAction() {
            protected void realCompute() {
                FibAction f = new FibAction(8);
                f.quietlyInvoke();
                assertEquals(21, f.result);
                checkCompletedNormally(f);
            }};
        checkInvoke(a);
    }

    /**
     * join of a forked task returns when task completes
     */
    public void testForkJoin() {
        RecursiveAction a = new CheckedRecursiveAction() {
            protected void realCompute() {
                FibAction f = new FibAction(8);
                assertSame(f, f.fork());
                assertNull(f.join());
                assertEquals(21, f.result);
                checkCompletedNormally(f);
            }};
        checkInvoke(a);
    }

    /**
     * timed quietlyJoinUninterruptibly of a forked task succeeds in
     * the presence of interrupts
     */
    public void testTimedQuietlyJoinUninterruptiblyInterrupts() {
        RecursiveAction a = new CheckedRecursiveAction() {
            protected void realCompute() {
                FibAction f;
                final Thread currentThread = Thread.currentThread();

                // test quietlyJoin()
                f = new FibAction(8);
                assertSame(f, f.fork());
                currentThread.interrupt();
                f.quietlyJoinUninterruptibly(LONG_DELAY_MS, MILLISECONDS);
                Thread.interrupted();
                assertEquals(21, f.result);
                checkCompletedNormally(f);

                f = new FibAction(8);
                f.cancel(true);
                assertSame(f, f.fork());
                currentThread.interrupt();
                f.quietlyJoinUninterruptibly(LONG_DELAY_MS, MILLISECONDS);
                Thread.interrupted();
                checkCancelled(f);

                f = new FibAction(8);
                f.completeExceptionally(new FJException());
                assertSame(f, f.fork());
                currentThread.interrupt();
                f.quietlyJoinUninterruptibly(LONG_DELAY_MS, MILLISECONDS);
                Thread.interrupted();
                checkCompletedAbnormally(f, f.getException());
            }};
        checkInvoke(a);
        a.reinitialize();
        checkInvoke(a);
    }

    /**
     * timed quietlyJoin throws IE in the presence of interrupts
     */
    public void testTimedQuietlyJoinInterrupts() {
        RecursiveAction a = new CheckedRecursiveAction() {
            protected void realCompute() {
                FibAction f;
                final Thread currentThread = Thread.currentThread();

                f = new FibAction(8);
                assertSame(f, f.fork());
                currentThread.interrupt();
                try {
                    f.quietlyJoin(LONG_DELAY_MS, MILLISECONDS);
                } catch (InterruptedException success) {
                }
                Thread.interrupted();
                f.quietlyJoin();

                f = new FibAction(8);
                f.cancel(true);
                assertSame(f, f.fork());
                currentThread.interrupt();
                try {
                    f.quietlyJoin(LONG_DELAY_MS, MILLISECONDS);
                } catch (InterruptedException success) {
                }
                f.quietlyJoin();
                checkCancelled(f);
            }};
        checkInvoke(a);
        a.reinitialize();
        checkInvoke(a);
    }

    /**
     * timed quietlyJoin of a forked task returns when task completes
     */
    public void testForkTimedQuietlyJoin() {
        RecursiveAction a = new CheckedRecursiveAction() {
            protected void realCompute() throws Exception {
                FibAction f = new FibAction(8);
                assertSame(f, f.fork());
                assertTrue(f.quietlyJoin(LONG_DELAY_MS, MILLISECONDS));
                assertEquals(21, f.result);
                checkCompletedNormally(f);
            }};
        checkInvoke(a);
    }

    /**
     * timed quietlyJoin with null time unit throws NPE
     */
    public void testForkTimedQuietlyJoinNPE() {
        RecursiveAction a = new CheckedRecursiveAction() {
            protected void realCompute() throws Exception {
                FibAction f = new FibAction(8);
                assertSame(f, f.fork());
                try {
                    f.quietlyJoin(randomTimeout(), null);
                    shouldThrow();
                } catch (NullPointerException success) {}
            }};
        checkInvoke(a);
    }

    /**
     * quietlyInvoke task returns when task completes abnormally
     */
    public void testAbnormalTimedQuietlyJoin() {
        RecursiveAction a = new CheckedRecursiveAction() {
            protected void realCompute() throws Exception {
                FailingFibAction f = new FailingFibAction(8);
                assertSame(f, f.fork());
                assertTrue(f.quietlyJoin(LONG_DELAY_MS, MILLISECONDS));
                assertTrue(f.getException() instanceof FJException);
                checkCompletedAbnormally(f, f.getException());
            }};
        checkInvoke(a);
    }

    /**
     * timed quietlyJoinUninterruptibly of a forked task returns when task completes
     */
    public void testForkTimedQuietlyJoinUninterruptibly() {
        RecursiveAction a = new CheckedRecursiveAction() {
            protected void realCompute() throws Exception {
                FibAction f = new FibAction(8);
                assertSame(f, f.fork());
                assertTrue(f.quietlyJoinUninterruptibly(LONG_DELAY_MS, MILLISECONDS));
                assertEquals(21, f.result);
                checkCompletedNormally(f);
            }};
        checkInvoke(a);
    }

    /**
     * timed quietlyJoinUninterruptibly with null time unit throws NPE
     */
    public void testForkTimedQuietlyJoinUninterruptiblyNPE() {
        RecursiveAction a = new CheckedRecursiveAction() {
            protected void realCompute() throws Exception {
                FibAction f = new FibAction(8);
                assertSame(f, f.fork());
                try {
                    f.quietlyJoinUninterruptibly(randomTimeout(), null);
                    shouldThrow();
                } catch (NullPointerException success) {}
            }};
        checkInvoke(a);
    }

    /**
     * quietlyInvoke task returns when task completes abnormally
     */
    public void testAbnormalTimedQuietlyJoinUninterruptibly() {
        RecursiveAction a = new CheckedRecursiveAction() {
            protected void realCompute() {
                FailingFibAction f = new FailingFibAction(8);
                assertSame(f, f.fork());
                assertTrue(f.quietlyJoinUninterruptibly(LONG_DELAY_MS, MILLISECONDS));
                assertTrue(f.getException() instanceof FJException);
                checkCompletedAbnormally(f, f.getException());
            }};
        checkInvoke(a);
    }

    /**
     * adaptInterruptible(callable).toString() contains toString of wrapped task
     */
    public void testAdaptInterruptible_Callable_toString() {
        if (testImplementationDetails) {
            Callable<String> c = () -> "";
            ForkJoinTask<String> task = ForkJoinTask.adaptInterruptible(c);
            assertEquals(
                identityString(task) + "[Wrapped task = " + c.toString() + "]",
                task.toString());
        }
    }

    /**
     * Implictly closing a new pool using try-with-resources terminates it
     */
    public void testClose() {
        ForkJoinTask f = new FibAction(8);
        ForkJoinPool pool = null;
        try (ForkJoinPool p = new ForkJoinPool()) {
            pool = p;
            p.execute(f);
        }
        checkCompletedNormally(f);
        assertTrue(pool != null && pool.isTerminated());
    }

    /**
     * Implictly closing commonpool using try-with-resources does not
     * terminate it
     */
    public void testCloseCommonPool() {
        ForkJoinTask f = new FibAction(8);
        ForkJoinPool pool;
        try (ForkJoinPool p = ForkJoinPool.commonPool()) {
            pool = p;
            p.execute(f);
        }
        assertFalse(pool.isTerminated());
    }
}
Revision:	1.3
Committed:	Fri Nov 25 16:39:48 2022 UTC (17 months, 3 weeks ago) by jsr166
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.2:	+2 -1 lines
Log Message:	whitespace
#	User	Rev	Content
1	dl	1.1	/*
2			* Written by Doug Lea with assistance from members of JCP JSR-166
3			* Expert Group and released to the public domain, as explained at
4			* http://creativecommons.org/publicdomain/zero/1.0/
5			*/
6
7			import static java.util.concurrent.TimeUnit.MILLISECONDS;
8
9			import java.util.HashSet;
10			import java.util.concurrent.CancellationException;
11			import java.util.concurrent.CountedCompleter;
12			import java.util.concurrent.ExecutionException;
13			import java.util.concurrent.ForkJoinPool;
14			import java.util.concurrent.ForkJoinTask;
15			import java.util.concurrent.RecursiveAction;
16			import java.util.concurrent.TimeoutException;
17			import java.util.concurrent.Callable;
18
19			import junit.framework.Test;
20			import junit.framework.TestSuite;
21
22			/**
23			* Tests for ForkJoinPool and corresponding ForkJoinTask additions.
24			*/
25			public class ForkJoinPool19Test extends JSR166TestCase {
26			public static void main(String[] args) {
27			main(suite(), args);
28			}
29
30			public static Test suite() {
31			return new TestSuite(ForkJoinPool8Test.class);
32			}
33
34			/**
35			* SetParallelism sets reported parallellism and returns previous value
36			*/
37			public void testSetParallelism() {
38			final ForkJoinPool p = new ForkJoinPool(2);
39			assertEquals(2, p.getParallelism());
40			assertEquals(2, p.setParallelism(3));
41			assertEquals(3, p.setParallelism(2));
42			p.shutdown();
43			}
44	jsr166	1.3
45	dl	1.1	/**
46			* SetParallelism throws exception if argument out of bounds
47			*/
48			public void testSetParallelismBadArgs() {
49			final ForkJoinPool p = new ForkJoinPool(2);
50			try {
51			p.setParallelism(0);
52			shouldThrow();
53			} catch (Exception success) {
54			}
55			try {
56			p.setParallelism(Integer.MAX_VALUE);
57			shouldThrow();
58			} catch (Exception success) {
59			}
60			assertEquals(2, p.getParallelism());
61			p.shutdown();
62			}
63
64	jsr166	1.3
65	dl	1.1	/*
66			* Some test methods adapted from RecursiveAction
67			*/
68			private static ForkJoinPool mainPool() {
69			return new ForkJoinPool();
70			}
71
72			private void testInvokeOnPool(ForkJoinPool pool, RecursiveAction a) {
73			try (PoolCleaner cleaner = cleaner(pool)) {
74			checkNotDone(a);
75			assertNull(pool.invoke(a));
76			checkCompletedNormally(a);
77			}
78			}
79
80			private void checkInvoke(ForkJoinTask<?> a) {
81			checkNotDone(a);
82			assertNull(a.invoke());
83			checkCompletedNormally(a);
84			}
85
86			void checkNotDone(ForkJoinTask<?> a) {
87			assertFalse(a.isDone());
88			assertFalse(a.isCompletedNormally());
89			assertFalse(a.isCompletedAbnormally());
90			assertFalse(a.isCancelled());
91			assertNull(a.getException());
92			assertNull(a.getRawResult());
93
94			if (! ForkJoinTask.inForkJoinPool()) {
95			Thread.currentThread().interrupt();
96			try {
97			a.get();
98			shouldThrow();
99			} catch (InterruptedException success) {
100			} catch (Throwable fail) { threadUnexpectedException(fail); }
101
102			Thread.currentThread().interrupt();
103			try {
104			a.get(randomTimeout(), randomTimeUnit());
105			shouldThrow();
106			} catch (InterruptedException success) {
107			} catch (Throwable fail) { threadUnexpectedException(fail); }
108			}
109
110			try {
111			a.get(randomExpiredTimeout(), randomTimeUnit());
112			shouldThrow();
113			} catch (TimeoutException success) {
114			} catch (Throwable fail) { threadUnexpectedException(fail); }
115			}
116
117			void checkCompletedNormally(ForkJoinTask<?> a) {
118			assertTrue(a.isDone());
119			assertFalse(a.isCancelled());
120			assertTrue(a.isCompletedNormally());
121			assertFalse(a.isCompletedAbnormally());
122			assertNull(a.getException());
123			assertNull(a.getRawResult());
124			assertNull(a.join());
125			assertFalse(a.cancel(false));
126			assertFalse(a.cancel(true));
127
128			Object v1 = null, v2 = null;
129			try {
130			v1 = a.get();
131			v2 = a.get(randomTimeout(), randomTimeUnit());
132			} catch (Throwable fail) { threadUnexpectedException(fail); }
133			assertNull(v1);
134			assertNull(v2);
135			}
136
137			void checkCancelled(ForkJoinTask<?> a) {
138			assertTrue(a.isDone());
139			assertTrue(a.isCancelled());
140			assertFalse(a.isCompletedNormally());
141			assertTrue(a.isCompletedAbnormally());
142			assertTrue(a.getException() instanceof CancellationException);
143			assertNull(a.getRawResult());
144
145			try {
146			a.join();
147			shouldThrow();
148			} catch (CancellationException success) {
149			} catch (Throwable fail) { threadUnexpectedException(fail); }
150
151			try {
152			a.get();
153			shouldThrow();
154			} catch (CancellationException success) {
155			} catch (Throwable fail) { threadUnexpectedException(fail); }
156
157			try {
158			a.get(randomTimeout(), randomTimeUnit());
159			shouldThrow();
160			} catch (CancellationException success) {
161			} catch (Throwable fail) { threadUnexpectedException(fail); }
162			}
163
164			void checkCompletedAbnormally(ForkJoinTask<?> a, Throwable t) {
165			assertTrue(a.isDone());
166			assertFalse(a.isCancelled());
167			assertFalse(a.isCompletedNormally());
168			assertTrue(a.isCompletedAbnormally());
169			assertSame(t.getClass(), a.getException().getClass());
170			assertNull(a.getRawResult());
171			assertFalse(a.cancel(false));
172			assertFalse(a.cancel(true));
173
174			try {
175			a.join();
176			shouldThrow();
177			} catch (Throwable expected) {
178			assertSame(expected.getClass(), t.getClass());
179			}
180
181			try {
182			a.get();
183			shouldThrow();
184			} catch (ExecutionException success) {
185			assertSame(t.getClass(), success.getCause().getClass());
186			} catch (Throwable fail) { threadUnexpectedException(fail); }
187
188			try {
189			a.get(randomTimeout(), randomTimeUnit());
190			shouldThrow();
191			} catch (ExecutionException success) {
192			assertSame(t.getClass(), success.getCause().getClass());
193			} catch (Throwable fail) { threadUnexpectedException(fail); }
194			}
195
196			public static final class FJException extends RuntimeException {
197			public FJException() { super(); }
198			public FJException(Throwable cause) { super(cause); }
199			}
200
201			/** A simple recursive action for testing. */
202			final class FibAction extends CheckedRecursiveAction {
203			final int number;
204			int result;
205			FibAction(int n) { number = n; }
206			protected void realCompute() {
207			int n = number;
208			if (n <= 1)
209			result = n;
210			else {
211			FibAction f1 = new FibAction(n - 1);
212			FibAction f2 = new FibAction(n - 2);
213			invokeAll(f1, f2);
214			result = f1.result + f2.result;
215			}
216			}
217			}
218
219			/** A recursive action failing in base case. */
220			static final class FailingFibAction extends RecursiveAction {
221			final int number;
222			int result;
223			FailingFibAction(int n) { number = n; }
224			public void compute() {
225			int n = number;
226			if (n <= 1)
227			throw new FJException();
228			else {
229			FailingFibAction f1 = new FailingFibAction(n - 1);
230			FailingFibAction f2 = new FailingFibAction(n - 2);
231			invokeAll(f1, f2);
232			result = f1.result + f2.result;
233			}
234			}
235			}
236
237			/**
238			* lazySubmit submits a task that is not executed until new
239			* workers are created or it is explicitly joined by a worker.
240			*/
241			public void testLazySubmit() {
242			RecursiveAction a = new CheckedRecursiveAction() {
243			protected void realCompute() {
244			final ForkJoinPool p = mainPool();
245			FibAction f = new FibAction(8);
246			p.lazySubmit(f);
247			checkNotDone(f);
248			FibAction g = new FibAction(8);
249			p.submit(g);
250			g.join();
251			f.join();
252			assertEquals(21, f.result);
253			checkCompletedNormally(f);
254			}};
255			testInvokeOnPool(mainPool(), a);
256			}
257
258			/**
259			* quietlyInvoke task returns when task completes normally.
260			* isCompletedAbnormally and isCancelled return false for normally
261			* completed tasks
262			*/
263			public void testQuietlyInvoke() {
264			RecursiveAction a = new CheckedRecursiveAction() {
265			protected void realCompute() {
266			FibAction f = new FibAction(8);
267			f.quietlyInvoke();
268			assertEquals(21, f.result);
269			checkCompletedNormally(f);
270			}};
271			checkInvoke(a);
272			}
273
274			/**
275			* join of a forked task returns when task completes
276			*/
277			public void testForkJoin() {
278			RecursiveAction a = new CheckedRecursiveAction() {
279			protected void realCompute() {
280			FibAction f = new FibAction(8);
281			assertSame(f, f.fork());
282			assertNull(f.join());
283			assertEquals(21, f.result);
284			checkCompletedNormally(f);
285			}};
286			checkInvoke(a);
287			}
288
289			/**
290			* timed quietlyJoinUninterruptibly of a forked task succeeds in
291			* the presence of interrupts
292			*/
293			public void testTimedQuietlyJoinUninterruptiblyInterrupts() {
294			RecursiveAction a = new CheckedRecursiveAction() {
295			protected void realCompute() {
296			FibAction f;
297			final Thread currentThread = Thread.currentThread();
298
299			// test quietlyJoin()
300			f = new FibAction(8);
301			assertSame(f, f.fork());
302			currentThread.interrupt();
303			f.quietlyJoinUninterruptibly(LONG_DELAY_MS, MILLISECONDS);
304			Thread.interrupted();
305			assertEquals(21, f.result);
306			checkCompletedNormally(f);
307
308			f = new FibAction(8);
309			f.cancel(true);
310			assertSame(f, f.fork());
311			currentThread.interrupt();
312			f.quietlyJoinUninterruptibly(LONG_DELAY_MS, MILLISECONDS);
313			Thread.interrupted();
314			checkCancelled(f);
315
316			f = new FibAction(8);
317			f.completeExceptionally(new FJException());
318			assertSame(f, f.fork());
319			currentThread.interrupt();
320			f.quietlyJoinUninterruptibly(LONG_DELAY_MS, MILLISECONDS);
321			Thread.interrupted();
322			checkCompletedAbnormally(f, f.getException());
323			}};
324			checkInvoke(a);
325			a.reinitialize();
326			checkInvoke(a);
327			}
328
329			/**
330			* timed quietlyJoin throws IE in the presence of interrupts
331			*/
332			public void testTimedQuietlyJoinInterrupts() {
333			RecursiveAction a = new CheckedRecursiveAction() {
334			protected void realCompute() {
335			FibAction f;
336			final Thread currentThread = Thread.currentThread();
337
338			f = new FibAction(8);
339			assertSame(f, f.fork());
340			currentThread.interrupt();
341			try {
342			f.quietlyJoin(LONG_DELAY_MS, MILLISECONDS);
343			} catch (InterruptedException success) {
344			}
345			Thread.interrupted();
346			f.quietlyJoin();
347
348			f = new FibAction(8);
349			f.cancel(true);
350			assertSame(f, f.fork());
351			currentThread.interrupt();
352			try {
353			f.quietlyJoin(LONG_DELAY_MS, MILLISECONDS);
354			} catch (InterruptedException success) {
355			}
356			f.quietlyJoin();
357			checkCancelled(f);
358			}};
359			checkInvoke(a);
360			a.reinitialize();
361			checkInvoke(a);
362			}
363
364			/**
365			* timed quietlyJoin of a forked task returns when task completes
366			*/
367			public void testForkTimedQuietlyJoin() {
368			RecursiveAction a = new CheckedRecursiveAction() {
369			protected void realCompute() throws Exception {
370			FibAction f = new FibAction(8);
371			assertSame(f, f.fork());
372			assertTrue(f.quietlyJoin(LONG_DELAY_MS, MILLISECONDS));
373			assertEquals(21, f.result);
374			checkCompletedNormally(f);
375			}};
376			checkInvoke(a);
377			}
378
379			/**
380			* timed quietlyJoin with null time unit throws NPE
381			*/
382			public void testForkTimedQuietlyJoinNPE() {
383			RecursiveAction a = new CheckedRecursiveAction() {
384			protected void realCompute() throws Exception {
385			FibAction f = new FibAction(8);
386			assertSame(f, f.fork());
387			try {
388			f.quietlyJoin(randomTimeout(), null);
389			shouldThrow();
390			} catch (NullPointerException success) {}
391			}};
392			checkInvoke(a);
393			}
394
395			/**
396			* quietlyInvoke task returns when task completes abnormally
397			*/
398			public void testAbnormalTimedQuietlyJoin() {
399			RecursiveAction a = new CheckedRecursiveAction() {
400			protected void realCompute() throws Exception {
401			FailingFibAction f = new FailingFibAction(8);
402			assertSame(f, f.fork());
403			assertTrue(f.quietlyJoin(LONG_DELAY_MS, MILLISECONDS));
404			assertTrue(f.getException() instanceof FJException);
405			checkCompletedAbnormally(f, f.getException());
406			}};
407			checkInvoke(a);
408			}
409
410			/**
411			* timed quietlyJoinUninterruptibly of a forked task returns when task completes
412			*/
413			public void testForkTimedQuietlyJoinUninterruptibly() {
414			RecursiveAction a = new CheckedRecursiveAction() {
415			protected void realCompute() throws Exception {
416			FibAction f = new FibAction(8);
417			assertSame(f, f.fork());
418			assertTrue(f.quietlyJoinUninterruptibly(LONG_DELAY_MS, MILLISECONDS));
419			assertEquals(21, f.result);
420			checkCompletedNormally(f);
421			}};
422			checkInvoke(a);
423			}
424
425			/**
426			* timed quietlyJoinUninterruptibly with null time unit throws NPE
427			*/
428			public void testForkTimedQuietlyJoinUninterruptiblyNPE() {
429			RecursiveAction a = new CheckedRecursiveAction() {
430			protected void realCompute() throws Exception {
431			FibAction f = new FibAction(8);
432			assertSame(f, f.fork());
433			try {
434			f.quietlyJoinUninterruptibly(randomTimeout(), null);
435			shouldThrow();
436			} catch (NullPointerException success) {}
437			}};
438			checkInvoke(a);
439			}
440
441			/**
442			* quietlyInvoke task returns when task completes abnormally
443			*/
444			public void testAbnormalTimedQuietlyJoinUninterruptibly() {
445			RecursiveAction a = new CheckedRecursiveAction() {
446			protected void realCompute() {
447			FailingFibAction f = new FailingFibAction(8);
448			assertSame(f, f.fork());
449			assertTrue(f.quietlyJoinUninterruptibly(LONG_DELAY_MS, MILLISECONDS));
450			assertTrue(f.getException() instanceof FJException);
451			checkCompletedAbnormally(f, f.getException());
452			}};
453			checkInvoke(a);
454			}
455
456			/**
457			* adaptInterruptible(callable).toString() contains toString of wrapped task
458			*/
459			public void testAdaptInterruptible_Callable_toString() {
460			if (testImplementationDetails) {
461			Callable<String> c = () -> "";
462			ForkJoinTask<String> task = ForkJoinTask.adaptInterruptible(c);
463			assertEquals(
464			identityString(task) + "[Wrapped task = " + c.toString() + "]",
465			task.toString());
466			}
467			}
468
469	dl	1.2	/**
470			* Implictly closing a new pool using try-with-resources terminates it
471			*/
472			public void testClose() {
473			ForkJoinTask f = new FibAction(8);
474			ForkJoinPool pool = null;
475			try (ForkJoinPool p = new ForkJoinPool()) {
476			pool = p;
477			p.execute(f);
478			}
479			checkCompletedNormally(f);
480			assertTrue(pool != null && pool.isTerminated());
481			}
482
483			/**
484			* Implictly closing commonpool using try-with-resources does not
485			* terminate it
486			*/
487			public void testCloseCommonPool() {
488			ForkJoinTask f = new FibAction(8);
489			ForkJoinPool pool;
490			try (ForkJoinPool p = ForkJoinPool.commonPool()) {
491			pool = p;
492			p.execute(f);
493			}
494			assertFalse(pool.isTerminated());
495			}
496	dl	1.1	}