ViewVC Help

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

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

Comparing jsr166/src/test/tck/RecursiveActionTest.java (file contents):
Revision 1.23 by jsr166, Mon Nov 22 07:50:50 2010 UTC vs.
Revision 1.31 by jsr166, Fri May 27 19:13:51 2011 UTC

#	Line 1 | Line 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/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6
7		import junit.framework.*;
8		import java.util.concurrent.CancellationException;
9	+	import java.util.concurrent.SynchronousQueue;
10		import java.util.concurrent.ExecutionException;
11		import java.util.concurrent.ForkJoinPool;
12	+	import java.util.concurrent.ForkJoinTask;
13		import java.util.concurrent.ForkJoinWorkerThread;
14		import java.util.concurrent.RecursiveAction;
15		import java.util.concurrent.TimeUnit;
#	Line 59 | Line 61 | public class RecursiveActionTest extends
61		assertNull(a.getException());
62		assertNull(a.getRawResult());
63
64	<	if (! (Thread.currentThread() instanceof ForkJoinWorkerThread)) {
64	>	if (! ForkJoinTask.inForkJoinPool()) {
65		Thread.currentThread().interrupt();
66		try {
67		a.get();
#	Line 132 | Line 134 | public class RecursiveActionTest extends
134		assertFalse(a.isCancelled());
135		assertFalse(a.isCompletedNormally());
136		assertTrue(a.isCompletedAbnormally());
137	<	assertSame(t, a.getException());
137	>	assertSame(t.getClass(), a.getException().getClass());
138		assertNull(a.getRawResult());
139		assertFalse(a.cancel(false));
140		assertFalse(a.cancel(true));
#	Line 141 | Line 143 | public class RecursiveActionTest extends
143		a.join();
144		shouldThrow();
145		} catch (Throwable expected) {
146	<	assertSame(t, expected);
146	>	assertSame(expected.getClass(), t.getClass());
147		}
148
149		try {
150		a.get();
151		shouldThrow();
152		} catch (ExecutionException success) {
153	<	assertSame(t, success.getCause());
153	>	assertSame(t.getClass(), success.getCause().getClass());
154		} catch (Throwable fail) { threadUnexpectedException(fail); }
155
156		try {
157		a.get(5L, SECONDS);
158		shouldThrow();
159		} catch (ExecutionException success) {
160	<	assertSame(t, success.getCause());
160	>	assertSame(t.getClass(), success.getCause().getClass());
161		} catch (Throwable fail) { threadUnexpectedException(fail); }
162		}
163
164	<	static final class FJException extends RuntimeException {
165	<	FJException() { super(); }
164	>	public static final class FJException extends RuntimeException {
165	>	public FJException() { super(); }
166	>	public FJException(Throwable cause) { super(cause); }
167		}
168
169		// A simple recursive action for testing
#	Line 247 | Line 250 | public class RecursiveActionTest extends
250		}
251
252		/**
253	+	* join/quietlyJoin of a forked task succeeds in the presence of interrupts
254	+	*/
255	+	public void testJoinIgnoresInterrupts() {
256	+	RecursiveAction a = new CheckedRecursiveAction() {
257	+	public void realCompute() {
258	+	FibAction f = new FibAction(8);
259	+	final Thread myself = Thread.currentThread();
260	+
261	+	// test join()
262	+	assertSame(f, f.fork());
263	+	myself.interrupt();
264	+	assertTrue(myself.isInterrupted());
265	+	assertNull(f.join());
266	+	Thread.interrupted();
267	+	assertEquals(21, f.result);
268	+	checkCompletedNormally(f);
269	+
270	+	f.reinitialize();
271	+	f.cancel(true);
272	+	assertSame(f, f.fork());
273	+	myself.interrupt();
274	+	assertTrue(myself.isInterrupted());
275	+	try {
276	+	f.join();
277	+	shouldThrow();
278	+	} catch (CancellationException success) {
279	+	Thread.interrupted();
280	+	checkCancelled(f);
281	+	}
282	+
283	+	f.reinitialize();
284	+	f.completeExceptionally(new FJException());
285	+	assertSame(f, f.fork());
286	+	myself.interrupt();
287	+	assertTrue(myself.isInterrupted());
288	+	try {
289	+	f.join();
290	+	shouldThrow();
291	+	} catch (FJException success) {
292	+	Thread.interrupted();
293	+	checkCompletedAbnormally(f, success);
294	+	}
295	+
296	+	// test quietlyJoin()
297	+	f.reinitialize();
298	+	assertSame(f, f.fork());
299	+	myself.interrupt();
300	+	assertTrue(myself.isInterrupted());
301	+	f.quietlyJoin();
302	+	Thread.interrupted();
303	+	assertEquals(21, f.result);
304	+	checkCompletedNormally(f);
305	+
306	+	f.reinitialize();
307	+	f.cancel(true);
308	+	assertSame(f, f.fork());
309	+	myself.interrupt();
310	+	assertTrue(myself.isInterrupted());
311	+	f.quietlyJoin();
312	+	Thread.interrupted();
313	+	checkCancelled(f);
314	+
315	+	f.reinitialize();
316	+	f.completeExceptionally(new FJException());
317	+	assertSame(f, f.fork());
318	+	myself.interrupt();
319	+	assertTrue(myself.isInterrupted());
320	+	f.quietlyJoin();
321	+	Thread.interrupted();
322	+	checkCompletedAbnormally(f, f.getException());
323	+	}};
324	+	testInvokeOnPool(mainPool(), a);
325	+	a.reinitialize();
326	+	testInvokeOnPool(singletonPool(), a);
327	+	}
328	+
329	+	/**
330	+	* join/quietlyJoin of a forked task when not in ForkJoinPool
331	+	* succeeds in the presence of interrupts
332	+	*/
333	+	public void testJoinIgnoresInterruptsOutsideForkJoinPool() {
334	+	final SynchronousQueue<FibAction[]> sq =
335	+	new SynchronousQueue<FibAction[]>();
336	+	RecursiveAction a = new CheckedRecursiveAction() {
337	+	public void realCompute() throws InterruptedException {
338	+	FibAction[] fibActions = new FibAction[6];
339	+	for (int i = 0; i < fibActions.length; i++)
340	+	fibActions[i] = new FibAction(8);
341	+
342	+	fibActions[1].cancel(false);
343	+	fibActions[2].completeExceptionally(new FJException());
344	+	fibActions[4].cancel(true);
345	+	fibActions[5].completeExceptionally(new FJException());
346	+
347	+	for (int i = 0; i < fibActions.length; i++)
348	+	fibActions[i].fork();
349	+
350	+	sq.put(fibActions);
351	+
352	+	helpQuiesce();
353	+	}};
354	+
355	+	Runnable r = new CheckedRunnable() {
356	+	public void realRun() throws InterruptedException {
357	+	FibAction[] fibActions = sq.take();
358	+	FibAction f;
359	+	final Thread myself = Thread.currentThread();
360	+
361	+	// test join() ------------
362	+
363	+	f = fibActions[0];
364	+	assertFalse(ForkJoinTask.inForkJoinPool());
365	+	myself.interrupt();
366	+	assertTrue(myself.isInterrupted());
367	+	assertNull(f.join());
368	+	assertTrue(Thread.interrupted());
369	+	assertEquals(21, f.result);
370	+	checkCompletedNormally(f);
371	+
372	+	f = fibActions[1];
373	+	myself.interrupt();
374	+	assertTrue(myself.isInterrupted());
375	+	try {
376	+	f.join();
377	+	shouldThrow();
378	+	} catch (CancellationException success) {
379	+	assertTrue(Thread.interrupted());
380	+	checkCancelled(f);
381	+	}
382	+
383	+	f = fibActions[2];
384	+	myself.interrupt();
385	+	assertTrue(myself.isInterrupted());
386	+	try {
387	+	f.join();
388	+	shouldThrow();
389	+	} catch (FJException success) {
390	+	assertTrue(Thread.interrupted());
391	+	checkCompletedAbnormally(f, success);
392	+	}
393	+
394	+	// test quietlyJoin() ---------
395	+
396	+	f = fibActions[3];
397	+	myself.interrupt();
398	+	assertTrue(myself.isInterrupted());
399	+	f.quietlyJoin();
400	+	assertTrue(Thread.interrupted());
401	+	assertEquals(21, f.result);
402	+	checkCompletedNormally(f);
403	+
404	+	f = fibActions[4];
405	+	myself.interrupt();
406	+	assertTrue(myself.isInterrupted());
407	+	f.quietlyJoin();
408	+	assertTrue(Thread.interrupted());
409	+	checkCancelled(f);
410	+
411	+	f = fibActions[5];
412	+	myself.interrupt();
413	+	assertTrue(myself.isInterrupted());
414	+	f.quietlyJoin();
415	+	assertTrue(Thread.interrupted());
416	+	assertTrue(f.getException() instanceof FJException);
417	+	checkCompletedAbnormally(f, f.getException());
418	+	}};
419	+
420	+	Thread t;
421	+
422	+	t = newStartedThread(r);
423	+	testInvokeOnPool(mainPool(), a);
424	+	awaitTermination(t, LONG_DELAY_MS);
425	+
426	+	a.reinitialize();
427	+	t = newStartedThread(r);
428	+	testInvokeOnPool(singletonPool(), a);
429	+	awaitTermination(t, LONG_DELAY_MS);
430	+	}
431	+
432	+	/**
433		* get of a forked task returns when task completes
434		*/
435		public void testForkGet() {
#	Line 307 | Line 490 | public class RecursiveActionTest extends
490		testInvokeOnPool(mainPool(), a);
491		}
492
310	–
493		/**
494		* helpQuiesce returns when tasks are complete.
495		* getQueuedTaskCount returns 0 when quiescent
#	Line 317 | Line 499 | public class RecursiveActionTest extends
499		public void realCompute() {
500		FibAction f = new FibAction(8);
501		assertSame(f, f.fork());
502	<	f.helpQuiesce();
502	>	helpQuiesce();
503		assertEquals(21, f.result);
504		assertEquals(0, getQueuedTaskCount());
505		checkCompletedNormally(f);
#	Line 325 | Line 507 | public class RecursiveActionTest extends
507		testInvokeOnPool(mainPool(), a);
508		}
509
328	–
510		/**
511		* invoke task throws exception when task completes abnormally
512		*/
#	Line 587 | Line 768 | public class RecursiveActionTest extends
768		RecursiveAction a = new CheckedRecursiveAction() {
769		public void realCompute() {
770		ForkJoinWorkerThread w =
771	<	(ForkJoinWorkerThread)(Thread.currentThread());
771	>	(ForkJoinWorkerThread) Thread.currentThread();
772		assertTrue(w.getPoolIndex() >= 0);
773	<	assertTrue(w.getPoolIndex() < mainPool.getPoolSize());
773	>	// pool size can shrink after assigning index, so cannot check
774	>	// assertTrue(w.getPoolIndex() < mainPool.getPoolSize());
775		}};
776		testInvokeOnPool(mainPool, a);
777		}
778
597	–
779		/**
780		* setRawResult(null) succeeds
781		*/
#	Line 741 | Line 922 | public class RecursiveActionTest extends
922		testInvokeOnPool(mainPool(), a);
923		}
924
744	–
925		/**
926		* invokeAll(tasks) with any null task throws NPE
927		*/

Diff Legend

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