ViewVC Help

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

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

Comparing jsr166/src/test/tck/CompletableFutureTest.java (file contents):
Revision 1.41 by jsr166, Mon Jun 2 01:46:11 2014 UTC vs.
Revision 1.42 by jsr166, Mon Jun 2 02:19:23 2014 UTC

#	Line 3468 | Line 3468 | public class CompletableFutureTest exten
3468		* whenComplete action executes on normal completion, propagating
3469		* source result.
3470		*/
3471	<	public void testWhenComplete1() {
3472	<	final AtomicInteger a = new AtomicInteger();
3473	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3474	<	CompletableFuture<Integer> g =
3475	<	f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
3476	<	f.complete(three);
3477	<	checkCompletedNormally(f, three);
3478	<	checkCompletedNormally(g, three);
3471	>	public void testWhenComplete_normalCompletion1() {
3472	>	for (ExecutionMode m : ExecutionMode.values())
3473	>	for (Integer v1 : new Integer[] { 1, null }) {
3474	>
3475	>	final AtomicInteger a = new AtomicInteger();
3476	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
3477	>	final CompletableFuture<Integer> g =
3478	>	m.whenComplete(f,
3479	>	(Integer x, Throwable t) -> {
3480	>	threadAssertSame(x, v1);
3481	>	threadAssertNull(t);
3482	>	a.getAndIncrement();
3483	>	});
3484	>	f.complete(v1);
3485	>	checkCompletedNormally(f, v1);
3486	>	checkCompletedNormally(g, v1);
3487		assertEquals(a.get(), 1);
3488	+	}
3489		}
3490
3491		/**
3492		* whenComplete action executes on exceptional completion, propagating
3493		* source result.
3494		*/
3495	<	public void testWhenComplete2() {
3496	<	final AtomicInteger a = new AtomicInteger();
3497	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3498	<	CompletableFuture<Integer> g =
3499	<	f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
3500	<	f.completeExceptionally(new CFException());
3501	<	assertTrue(f.isCompletedExceptionally());
3502	<	assertTrue(g.isCompletedExceptionally());
3495	>	public void testWhenComplete_exceptionalCompletion() {
3496	>	for (ExecutionMode m : ExecutionMode.values())
3497	>	for (Integer v1 : new Integer[] { 1, null }) {
3498	>
3499	>	final AtomicInteger a = new AtomicInteger();
3500	>	final CFException ex = new CFException();
3501	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
3502	>	final CompletableFuture<Integer> g = m.whenComplete
3503	>	(f,
3504	>	(Integer x, Throwable t) -> {
3505	>	threadAssertNull(x);
3506	>	threadAssertSame(t, ex);
3507	>	a.getAndIncrement();
3508	>	});
3509	>	f.completeExceptionally(ex);
3510	>	checkCompletedWithWrappedCFException(f, ex);
3511	>	checkCompletedWithWrappedCFException(g, ex);
3512		assertEquals(a.get(), 1);
3513	+	}
3514		}
3515
3516		/**
3517		* If a whenComplete action throws an exception when triggered by
3518		* a normal completion, it completes exceptionally
3519		*/
3520	<	public void testWhenComplete3() {
3521	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3522	<	CompletableFuture<Integer> g =
3523	<	f.whenComplete((Integer x, Throwable t) ->
3524	<	{ throw new CFException(); } );
3525	<	f.complete(three);
3526	<	checkCompletedNormally(f, three);
3527	<	assertTrue(g.isCompletedExceptionally());
3528	<	checkCompletedWithWrappedCFException(g);
3529	<	}
3530	<
3531	<	/**
3532	<	* whenCompleteAsync action executes on normal completion, propagating
3533	<	* source result.
3534	<	*/
3535	<	public void testWhenCompleteAsync1() {
3536	<	final AtomicInteger a = new AtomicInteger();
3518	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3519	<	CompletableFuture<Integer> g =
3520	<	f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3521	<	f.complete(three);
3522	<	checkCompletedNormally(f, three);
3523	<	checkCompletedNormally(g, three);
3524	<	assertEquals(a.get(), 1);
3520	>	public void testWhenComplete_actionFailed() {
3521	>	for (ExecutionMode m : ExecutionMode.values())
3522	>	for (Integer v1 : new Integer[] { 1, null }) {
3523	>
3524	>	final CFException ex = new CFException();
3525	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
3526	>	final CompletableFuture<Integer> g = m.whenComplete
3527	>	(f,
3528	>	(Integer x, Throwable t) -> {
3529	>	threadAssertSame(x, v1);
3530	>	threadAssertNull(t);
3531	>	throw ex;
3532	>	});
3533	>	f.complete(v1);
3534	>	checkCompletedNormally(f, v1);
3535	>	checkCompletedWithWrappedCFException(g, ex);
3536	>	}
3537		}
3538
3539		/**
3540	<	* whenCompleteAsync action executes on exceptional completion, propagating
3541	<	* source result.
3542	<	*/
3531	<	public void testWhenCompleteAsync2() {
3532	<	final AtomicInteger a = new AtomicInteger();
3533	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3534	<	CompletableFuture<Integer> g =
3535	<	f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3536	<	f.completeExceptionally(new CFException());
3537	<	checkCompletedWithWrappedCFException(f);
3538	<	checkCompletedWithWrappedCFException(g);
3539	<	}
3540	<
3541	<	/**
3542	<	* If a whenCompleteAsync action throws an exception when
3543	<	* triggered by a normal completion, it completes exceptionally
3544	<	*/
3545	<	public void testWhenCompleteAsync3() {
3546	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3547	<	CompletableFuture<Integer> g =
3548	<	f.whenCompleteAsync((Integer x, Throwable t) ->
3549	<	{ throw new CFException(); } );
3550	<	f.complete(three);
3551	<	checkCompletedNormally(f, three);
3552	<	checkCompletedWithWrappedCFException(g);
3553	<	}
3554	<
3555	<	/**
3556	<	* whenCompleteAsync action executes on normal completion, propagating
3557	<	* source result.
3558	<	*/
3559	<	public void testWhenCompleteAsync1e() {
3560	<	final AtomicInteger a = new AtomicInteger();
3561	<	ThreadExecutor exec = new ThreadExecutor();
3562	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3563	<	CompletableFuture<Integer> g =
3564	<	f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
3565	<	exec);
3566	<	f.complete(three);
3567	<	checkCompletedNormally(f, three);
3568	<	checkCompletedNormally(g, three);
3569	<	assertEquals(a.get(), 1);
3570	<	}
3571	<
3572	<	/**
3573	<	* whenCompleteAsync action executes on exceptional completion, propagating
3574	<	* source result.
3575	<	*/
3576	<	public void testWhenCompleteAsync2e() {
3577	<	final AtomicInteger a = new AtomicInteger();
3578	<	ThreadExecutor exec = new ThreadExecutor();
3579	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3580	<	CompletableFuture<Integer> g =
3581	<	f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
3582	<	exec);
3583	<	f.completeExceptionally(new CFException());
3584	<	checkCompletedWithWrappedCFException(f);
3585	<	checkCompletedWithWrappedCFException(g);
3586	<	}
3587	<
3588	<	/**
3589	<	* If a whenCompleteAsync action throws an exception when triggered
3590	<	* by a normal completion, it completes exceptionally
3540	>	* If a whenComplete action throws an exception when triggered by
3541	>	* a source completion that also throws an exception, the source
3542	>	* exception takes precedence.
3543		*/
3544	<	public void testWhenCompleteAsync3e() {
3545	<	ThreadExecutor exec = new ThreadExecutor();
3546	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3547	<	CompletableFuture<Integer> g =
3548	<	f.whenCompleteAsync((Integer x, Throwable t) ->
3549	<	{ throw new CFException(); },
3550	<	exec);
3551	<	f.complete(three);
3552	<	checkCompletedNormally(f, three);
3553	<	checkCompletedWithWrappedCFException(g);
3544	>	public void testWhenComplete_actionFailedSourceFailed() {
3545	>	for (ExecutionMode m : ExecutionMode.values())
3546	>	for (Integer v1 : new Integer[] { 1, null }) {
3547	>
3548	>	final CFException ex1 = new CFException();
3549	>	final CFException ex2 = new CFException();
3550	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
3551	>	final CompletableFuture<Integer> g = m.whenComplete
3552	>	(f,
3553	>	(Integer x, Throwable t) -> {
3554	>	threadAssertSame(t, ex1);
3555	>	threadAssertNull(x);
3556	>	throw ex2;
3557	>	});
3558	>	f.completeExceptionally(ex1);
3559	>	checkCompletedWithWrappedCFException(f, ex1);
3560	>	checkCompletedWithWrappedCFException(g, ex1);
3561	>	}
3562		}
3563
3564		/**

Diff Legend

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