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.45 by jsr166, Mon Jun 2 06:07:34 2014 UTC vs.
Revision 1.47 by jsr166, Mon Jun 2 18:21:34 2014 UTC

#	Line 247 | Line 247 | public class CompletableFutureTest exten
247		f = new CompletableFuture<>();
248		f.obtrudeValue(three);
249		checkCompletedNormally(f, three);
250	+	f.obtrudeValue(null);
251	+	checkCompletedNormally(f, null);
252		f = new CompletableFuture<>();
253		f.completeExceptionally(new CFException());
254		f.obtrudeValue(four);
#	Line 279 | Line 281 | public class CompletableFutureTest exten
281		*/
282		public void testGetNumberOfDependents() {
283		CompletableFuture<Integer> f = new CompletableFuture<>();
284	<	assertEquals(f.getNumberOfDependents(), 0);
284	>	assertEquals(0, f.getNumberOfDependents());
285		CompletableFuture g = f.thenRun(new Noop());
286	<	assertEquals(f.getNumberOfDependents(), 1);
287	<	assertEquals(g.getNumberOfDependents(), 0);
286	>	assertEquals(1, f.getNumberOfDependents());
287	>	assertEquals(0, g.getNumberOfDependents());
288		CompletableFuture h = f.thenRun(new Noop());
289	<	assertEquals(f.getNumberOfDependents(), 2);
289	>	assertEquals(2, f.getNumberOfDependents());
290		f.complete(1);
291		checkCompletedNormally(g, null);
292	<	assertEquals(f.getNumberOfDependents(), 0);
293	<	assertEquals(g.getNumberOfDependents(), 0);
292	>	assertEquals(0, f.getNumberOfDependents());
293	>	assertEquals(0, g.getNumberOfDependents());
294		}
295
296		/**
#	Line 450 | Line 452 | public class CompletableFutureTest exten
452		}
453		}
454
453	–	static final class ExceptionToInteger implements Function<Throwable, Integer> {
454	–	public Integer apply(Throwable x) { return Integer.valueOf(3); }
455	–	}
456	–
457	–	static final class IntegerHandler implements BiFunction<Integer, Throwable, Integer> {
458	–	int invocationCount = 0;
459	–	public Integer apply(Integer x, Throwable t) {
460	–	invocationCount++;
461	–	return (t == null) ? two : three;
462	–	}
463	–	}
464	–
455		/**
456		* Permits the testing of parallel code for the 3 different
457		* execution modes without repeating all the testing code.
458		*/
459		enum ExecutionMode {
460		DEFAULT {
461	+	public <T> CompletableFuture<Void> thenRun
462	+	(CompletableFuture<T> f, Runnable a) {
463	+	return f.thenRun(a);
464	+	}
465	+	public <T> CompletableFuture<Void> thenAccept
466	+	(CompletableFuture<T> f, Consumer<? super T> a) {
467	+	return f.thenAccept(a);
468	+	}
469	+	public <T,U> CompletableFuture<U> thenApply
470	+	(CompletableFuture<T> f, Function<? super T,U> a) {
471	+	return f.thenApply(a);
472	+	}
473	+	public <T,U> CompletableFuture<U> thenCompose
474	+	(CompletableFuture<T> f,
475	+	Function<? super T,? extends CompletionStage<U>> a) {
476	+	return f.thenCompose(a);
477	+	}
478	+	public <T,U> CompletableFuture<U> handle
479	+	(CompletableFuture<T> f,
480	+	BiFunction<? super T,Throwable,? extends U> a) {
481	+	return f.handle(a);
482	+	}
483	+	public <T> CompletableFuture<T> whenComplete
484	+	(CompletableFuture<T> f,
485	+	BiConsumer<? super T,? super Throwable> a) {
486	+	return f.whenComplete(a);
487	+	}
488		public <T,U> CompletableFuture<Void> runAfterBoth
489		(CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
490		return f.runAfterBoth(g, a);
#	Line 484 | Line 501 | public class CompletableFutureTest exten
501		BiFunction<? super T,? super U,? extends V> a) {
502		return f.thenCombine(g, a);
503		}
504	<	public <T,U> CompletableFuture<U> applyToEither
504	>	public <T> CompletableFuture<Void> runAfterEither
505		(CompletableFuture<T> f,
506	<	CompletionStage<? extends T> g,
507	<	Function<? super T,U> a) {
508	<	return f.applyToEither(g, a);
506	>	CompletionStage<?> g,
507	>	java.lang.Runnable a) {
508	>	return f.runAfterEither(g, a);
509		}
510		public <T> CompletableFuture<Void> acceptEither
511		(CompletableFuture<T> f,
#	Line 496 | Line 513 | public class CompletableFutureTest exten
513		Consumer<? super T> a) {
514		return f.acceptEither(g, a);
515		}
516	<	public <T> CompletableFuture<Void> runAfterEither
516	>	public <T,U> CompletableFuture<U> applyToEither
517		(CompletableFuture<T> f,
518	<	CompletionStage<?> g,
519	<	java.lang.Runnable a) {
520	<	return f.runAfterEither(g, a);
518	>	CompletionStage<? extends T> g,
519	>	Function<? super T,U> a) {
520	>	return f.applyToEither(g, a);
521	>	}
522	>	},
523	>
524	>	DEFAULT_ASYNC {
525	>	public <T> CompletableFuture<Void> thenRun
526	>	(CompletableFuture<T> f, Runnable a) {
527	>	return f.thenRunAsync(a);
528	>	}
529	>	public <T> CompletableFuture<Void> thenAccept
530	>	(CompletableFuture<T> f, Consumer<? super T> a) {
531	>	return f.thenAcceptAsync(a);
532	>	}
533	>	public <T,U> CompletableFuture<U> thenApply
534	>	(CompletableFuture<T> f, Function<? super T,U> a) {
535	>	return f.thenApplyAsync(a);
536		}
537		public <T,U> CompletableFuture<U> thenCompose
538		(CompletableFuture<T> f,
539		Function<? super T,? extends CompletionStage<U>> a) {
540	<	return f.thenCompose(a);
540	>	return f.thenComposeAsync(a);
541	>	}
542	>	public <T,U> CompletableFuture<U> handle
543	>	(CompletableFuture<T> f,
544	>	BiFunction<? super T,Throwable,? extends U> a) {
545	>	return f.handleAsync(a);
546		}
547		public <T> CompletableFuture<T> whenComplete
548		(CompletableFuture<T> f,
549		BiConsumer<? super T,? super Throwable> a) {
550	<	return f.whenComplete(a);
550	>	return f.whenCompleteAsync(a);
551		}
515	–	},
516	–
517	–	DEFAULT_ASYNC {
552		public <T,U> CompletableFuture<Void> runAfterBoth
553		(CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
554		return f.runAfterBothAsync(g, a);
#	Line 531 | Line 565 | public class CompletableFutureTest exten
565		BiFunction<? super T,? super U,? extends V> a) {
566		return f.thenCombineAsync(g, a);
567		}
568	<	public <T,U> CompletableFuture<U> applyToEither
568	>	public <T> CompletableFuture<Void> runAfterEither
569		(CompletableFuture<T> f,
570	<	CompletionStage<? extends T> g,
571	<	Function<? super T,U> a) {
572	<	return f.applyToEitherAsync(g, a);
570	>	CompletionStage<?> g,
571	>	java.lang.Runnable a) {
572	>	return f.runAfterEitherAsync(g, a);
573		}
574		public <T> CompletableFuture<Void> acceptEither
575		(CompletableFuture<T> f,
#	Line 543 | Line 577 | public class CompletableFutureTest exten
577		Consumer<? super T> a) {
578		return f.acceptEitherAsync(g, a);
579		}
580	<	public <T> CompletableFuture<Void> runAfterEither
580	>	public <T,U> CompletableFuture<U> applyToEither
581		(CompletableFuture<T> f,
582	<	CompletionStage<?> g,
583	<	java.lang.Runnable a) {
584	<	return f.runAfterEitherAsync(g, a);
582	>	CompletionStage<? extends T> g,
583	>	Function<? super T,U> a) {
584	>	return f.applyToEitherAsync(g, a);
585	>	}
586	>	},
587	>
588	>	EXECUTOR {
589	>	public <T> CompletableFuture<Void> thenRun
590	>	(CompletableFuture<T> f, Runnable a) {
591	>	return f.thenRunAsync(a, new ThreadExecutor());
592	>	}
593	>	public <T> CompletableFuture<Void> thenAccept
594	>	(CompletableFuture<T> f, Consumer<? super T> a) {
595	>	return f.thenAcceptAsync(a, new ThreadExecutor());
596	>	}
597	>	public <T,U> CompletableFuture<U> thenApply
598	>	(CompletableFuture<T> f, Function<? super T,U> a) {
599	>	return f.thenApplyAsync(a, new ThreadExecutor());
600		}
601		public <T,U> CompletableFuture<U> thenCompose
602		(CompletableFuture<T> f,
603		Function<? super T,? extends CompletionStage<U>> a) {
604	<	return f.thenComposeAsync(a);
604	>	return f.thenComposeAsync(a, new ThreadExecutor());
605	>	}
606	>	public <T,U> CompletableFuture<U> handle
607	>	(CompletableFuture<T> f,
608	>	BiFunction<? super T,Throwable,? extends U> a) {
609	>	return f.handleAsync(a, new ThreadExecutor());
610		}
611		public <T> CompletableFuture<T> whenComplete
612		(CompletableFuture<T> f,
613		BiConsumer<? super T,? super Throwable> a) {
614	<	return f.whenCompleteAsync(a);
614	>	return f.whenCompleteAsync(a, new ThreadExecutor());
615		}
562	–	},
563	–
564	–	EXECUTOR {
616		public <T,U> CompletableFuture<Void> runAfterBoth
617		(CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
618		return f.runAfterBothAsync(g, a, new ThreadExecutor());
#	Line 578 | Line 629 | public class CompletableFutureTest exten
629		BiFunction<? super T,? super U,? extends V> a) {
630		return f.thenCombineAsync(g, a, new ThreadExecutor());
631		}
581	–	public <T,U> CompletableFuture<U> applyToEither
582	–	(CompletableFuture<T> f,
583	–	CompletionStage<? extends T> g,
584	–	Function<? super T,U> a) {
585	–	return f.applyToEitherAsync(g, a, new ThreadExecutor());
586	–	}
587	–	public <T> CompletableFuture<Void> acceptEither
588	–	(CompletableFuture<T> f,
589	–	CompletionStage<? extends T> g,
590	–	Consumer<? super T> a) {
591	–	return f.acceptEitherAsync(g, a, new ThreadExecutor());
592	–	}
632		public <T> CompletableFuture<Void> runAfterEither
633		(CompletableFuture<T> f,
634		CompletionStage<?> g,
635		java.lang.Runnable a) {
636		return f.runAfterEitherAsync(g, a, new ThreadExecutor());
637		}
638	<	public <T,U> CompletableFuture<U> thenCompose
638	>	public <T> CompletableFuture<Void> acceptEither
639		(CompletableFuture<T> f,
640	<	Function<? super T,? extends CompletionStage<U>> a) {
641	<	return f.thenComposeAsync(a, new ThreadExecutor());
640	>	CompletionStage<? extends T> g,
641	>	Consumer<? super T> a) {
642	>	return f.acceptEitherAsync(g, a, new ThreadExecutor());
643		}
644	<	public <T> CompletableFuture<T> whenComplete
644	>	public <T,U> CompletableFuture<U> applyToEither
645		(CompletableFuture<T> f,
646	<	BiConsumer<? super T,? super Throwable> a) {
647	<	return f.whenCompleteAsync(a, new ThreadExecutor());
646	>	CompletionStage<? extends T> g,
647	>	Function<? super T,U> a) {
648	>	return f.applyToEitherAsync(g, a, new ThreadExecutor());
649		}
650		};
651
652	+	public abstract <T> CompletableFuture<Void> thenRun
653	+	(CompletableFuture<T> f, Runnable a);
654	+	public abstract <T> CompletableFuture<Void> thenAccept
655	+	(CompletableFuture<T> f, Consumer<? super T> a);
656	+	public abstract <T,U> CompletableFuture<U> thenApply
657	+	(CompletableFuture<T> f, Function<? super T,U> a);
658	+	public abstract <T,U> CompletableFuture<U> thenCompose
659	+	(CompletableFuture<T> f,
660	+	Function<? super T,? extends CompletionStage<U>> a);
661	+	public abstract <T,U> CompletableFuture<U> handle
662	+	(CompletableFuture<T> f,
663	+	BiFunction<? super T,Throwable,? extends U> a);
664	+	public abstract <T> CompletableFuture<T> whenComplete
665	+	(CompletableFuture<T> f,
666	+	BiConsumer<? super T,? super Throwable> a);
667		public abstract <T,U> CompletableFuture<Void> runAfterBoth
668		(CompletableFuture<T> f, CompletableFuture<U> g, Runnable a);
669		public abstract <T,U> CompletableFuture<Void> thenAcceptBoth
#	Line 618 | Line 674 | public class CompletableFutureTest exten
674		(CompletableFuture<T> f,
675		CompletionStage<? extends U> g,
676		BiFunction<? super T,? super U,? extends V> a);
621	–	public abstract <T,U> CompletableFuture<U> applyToEither
622	–	(CompletableFuture<T> f,
623	–	CompletionStage<? extends T> g,
624	–	Function<? super T,U> a);
625	–	public abstract <T> CompletableFuture<Void> acceptEither
626	–	(CompletableFuture<T> f,
627	–	CompletionStage<? extends T> g,
628	–	Consumer<? super T> a);
677		public abstract <T> CompletableFuture<Void> runAfterEither
678		(CompletableFuture<T> f,
679		CompletionStage<?> g,
680		java.lang.Runnable a);
681	<	public abstract <T,U> CompletableFuture<U> thenCompose
681	>	public abstract <T> CompletableFuture<Void> acceptEither
682		(CompletableFuture<T> f,
683	<	Function<? super T,? extends CompletionStage<U>> a);
684	<	public abstract <T> CompletableFuture<T> whenComplete
683	>	CompletionStage<? extends T> g,
684	>	Consumer<? super T> a);
685	>	public abstract <T,U> CompletableFuture<U> applyToEither
686		(CompletableFuture<T> f,
687	<	BiConsumer<? super T,? super Throwable> a);
687	>	CompletionStage<? extends T> g,
688	>	Function<? super T,U> a);
689	>	}
690
691	+	/**
692	+	* exceptionally action is not invoked when source completes
693	+	* normally, and source result is propagated
694	+	*/
695	+	public void testExceptionally_normalCompletion() {
696	+	for (boolean createIncomplete : new boolean[] { true, false })
697	+	for (Integer v1 : new Integer[] { 1, null })
698	+	{
699	+	final AtomicInteger a = new AtomicInteger(0);
700	+	final CompletableFuture<Integer> f = new CompletableFuture<>();
701	+	if (!createIncomplete) f.complete(v1);
702	+	final CompletableFuture<Integer> g = f.exceptionally
703	+	((Throwable t) -> {
704	+	// Should not be called
705	+	a.getAndIncrement();
706	+	throw new AssertionError();
707	+	});
708	+	if (createIncomplete) f.complete(v1);
709	+
710	+	checkCompletedNormally(g, v1);
711	+	checkCompletedNormally(f, v1);
712	+	assertEquals(0, a.get());
713	+	}}
714
641	–	}
715
716		/**
717		* exceptionally action completes with function value on source
718	<	* exception; otherwise with source value
718	>	* exception
719		*/
720	<	public void testExceptionally() {
721	<	CompletableFuture<Integer> f = new CompletableFuture<>();
722	<	ExceptionToInteger r = new ExceptionToInteger();
723	<	CompletableFuture<Integer> g = f.exceptionally(r);
724	<	f.completeExceptionally(new CFException());
725	<	checkCompletedNormally(g, three);
720	>	public void testExceptionally_exceptionalCompletion() {
721	>	for (boolean createIncomplete : new boolean[] { true, false })
722	>	for (Integer v1 : new Integer[] { 1, null })
723	>	{
724	>	final AtomicInteger a = new AtomicInteger(0);
725	>	final CFException ex = new CFException();
726	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
727	>	if (!createIncomplete) f.completeExceptionally(ex);
728	>	final CompletableFuture<Integer> g = f.exceptionally
729	>	((Throwable t) -> {
730	>	threadAssertSame(t, ex);
731	>	a.getAndIncrement();
732	>	return v1;
733	>	});
734	>	if (createIncomplete) f.completeExceptionally(ex);
735
736	<	f = new CompletableFuture<>();
737	<	r = new ExceptionToInteger();
738	<	g = f.exceptionally(r);
739	<	f.complete(one);
740	<	checkCompletedNormally(g, one);
741	<	}
736	>	checkCompletedNormally(g, v1);
737	>	assertEquals(1, a.get());
738	>	}}
739	>
740	>	public void testExceptionally_exceptionalCompletionActionFailed() {
741	>	for (boolean createIncomplete : new boolean[] { true, false })
742	>	for (Integer v1 : new Integer[] { 1, null })
743	>	{
744	>	final AtomicInteger a = new AtomicInteger(0);
745	>	final CFException ex1 = new CFException();
746	>	final CFException ex2 = new CFException();
747	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
748	>	if (!createIncomplete) f.completeExceptionally(ex1);
749	>	final CompletableFuture<Integer> g = f.exceptionally
750	>	((Throwable t) -> {
751	>	threadAssertSame(t, ex1);
752	>	a.getAndIncrement();
753	>	throw ex2;
754	>	});
755	>	if (createIncomplete) f.completeExceptionally(ex1);
756	>
757	>	checkCompletedWithWrappedCFException(g, ex2);
758	>	assertEquals(1, a.get());
759	>	}}
760	>
761	>	/**
762	>	* handle action completes normally with function value on normal
763	>	* completion of source
764	>	*/
765	>	public void testHandle_normalCompletion() {
766	>	for (ExecutionMode m : ExecutionMode.values())
767	>	for (boolean createIncomplete : new boolean[] { true, false })
768	>	for (Integer v1 : new Integer[] { 1, null })
769	>	{
770	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
771	>	final AtomicInteger a = new AtomicInteger(0);
772	>	if (!createIncomplete) f.complete(v1);
773	>	final CompletableFuture<Integer> g = m.handle
774	>	(f,
775	>	(Integer x, Throwable t) -> {
776	>	threadAssertSame(x, v1);
777	>	threadAssertNull(t);
778	>	a.getAndIncrement();
779	>	return inc(v1);
780	>	});
781	>	if (createIncomplete) f.complete(v1);
782	>
783	>	checkCompletedNormally(g, inc(v1));
784	>	checkCompletedNormally(f, v1);
785	>	assertEquals(1, a.get());
786	>	}}
787
788		/**
789	<	* handle action completes normally with function value on either
790	<	* normal or exceptional completion of source
789	>	* handle action completes normally with function value on
790	>	* exceptional completion of source
791		*/
792	<	public void testHandle() {
793	<	CompletableFuture<Integer> f, g;
794	<	IntegerHandler r;
792	>	public void testHandle_exceptionalCompletion() {
793	>	for (ExecutionMode m : ExecutionMode.values())
794	>	for (boolean createIncomplete : new boolean[] { true, false })
795	>	for (Integer v1 : new Integer[] { 1, null })
796	>	{
797	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
798	>	final AtomicInteger a = new AtomicInteger(0);
799	>	final CFException ex = new CFException();
800	>	if (!createIncomplete) f.completeExceptionally(ex);
801	>	final CompletableFuture<Integer> g = m.handle
802	>	(f,
803	>	(Integer x, Throwable t) -> {
804	>	threadAssertNull(x);
805	>	threadAssertSame(t, ex);
806	>	a.getAndIncrement();
807	>	return v1;
808	>	});
809	>	if (createIncomplete) f.completeExceptionally(ex);
810
811	<	f = new CompletableFuture<>();
812	<	f.completeExceptionally(new CFException());
813	<	g = f.handle(r = new IntegerHandler());
814	<	assertEquals(1, r.invocationCount);
673	<	assertEquals(1, r.invocationCount);
674	<	checkCompletedNormally(g, three);
811	>	checkCompletedNormally(g, v1);
812	>	checkCompletedWithWrappedCFException(f, ex);
813	>	assertEquals(1, a.get());
814	>	}}
815
816	<	f = new CompletableFuture<>();
817	<	g = f.handle(r = new IntegerHandler());
818	<	assertEquals(0, r.invocationCount);
819	<	f.completeExceptionally(new CFException());
820	<	checkCompletedNormally(g, three);
821	<	assertEquals(1, r.invocationCount);
816	>	/**
817	>	* handle action completes normally with function value on
818	>	* cancelled source
819	>	*/
820	>	public void testHandle_sourceCancelled() {
821	>	for (ExecutionMode m : ExecutionMode.values())
822	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
823	>	for (boolean createIncomplete : new boolean[] { true, false })
824	>	for (Integer v1 : new Integer[] { 1, null })
825	>	{
826	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
827	>	final AtomicInteger a = new AtomicInteger(0);
828	>	if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
829	>	final CompletableFuture<Integer> g = m.handle
830	>	(f,
831	>	(Integer x, Throwable t) -> {
832	>	threadAssertNull(x);
833	>	threadAssertTrue(t instanceof CancellationException);
834	>	a.getAndIncrement();
835	>	return v1;
836	>	});
837	>	if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
838
839	<	f = new CompletableFuture<>();
840	<	f.complete(one);
841	<	g = f.handle(r = new IntegerHandler());
842	<	assertEquals(1, r.invocationCount);
687	<	checkCompletedNormally(g, two);
839	>	checkCompletedNormally(g, v1);
840	>	checkCancelled(f);
841	>	assertEquals(1, a.get());
842	>	}}
843
844	<	f = new CompletableFuture<>();
845	<	g = f.handle(r = new IntegerHandler());
846	<	assertEquals(0, r.invocationCount);
847	<	f.complete(one);
848	<	assertEquals(1, r.invocationCount);
849	<	checkCompletedNormally(g, two);
850	<	}
844	>	/**
845	>	* handle result completes exceptionally if action does
846	>	*/
847	>	public void testHandle_sourceFailedActionFailed() {
848	>	for (ExecutionMode m : ExecutionMode.values())
849	>	for (boolean createIncomplete : new boolean[] { true, false })
850	>	{
851	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
852	>	final AtomicInteger a = new AtomicInteger(0);
853	>	final CFException ex1 = new CFException();
854	>	final CFException ex2 = new CFException();
855	>	if (!createIncomplete) f.completeExceptionally(ex1);
856	>	final CompletableFuture<Integer> g = m.handle
857	>	(f,
858	>	(Integer x, Throwable t) -> {
859	>	threadAssertNull(x);
860	>	threadAssertSame(ex1, t);
861	>	a.getAndIncrement();
862	>	throw ex2;
863	>	});
864	>	if (createIncomplete) f.completeExceptionally(ex1);
865	>
866	>	checkCompletedWithWrappedCFException(g, ex2);
867	>	checkCompletedWithWrappedCFException(f, ex1);
868	>	assertEquals(1, a.get());
869	>	}}
870	>
871	>	public void testHandle_sourceCompletedNormallyActionFailed() {
872	>	for (ExecutionMode m : ExecutionMode.values())
873	>	for (boolean createIncomplete : new boolean[] { true, false })
874	>	for (Integer v1 : new Integer[] { 1, null })
875	>	{
876	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
877	>	final AtomicInteger a = new AtomicInteger(0);
878	>	final CFException ex = new CFException();
879	>	if (!createIncomplete) f.complete(v1);
880	>	final CompletableFuture<Integer> g = m.handle
881	>	(f,
882	>	(Integer x, Throwable t) -> {
883	>	threadAssertSame(x, v1);
884	>	threadAssertNull(t);
885	>	a.getAndIncrement();
886	>	throw ex;
887	>	});
888	>	if (createIncomplete) f.complete(v1);
889	>
890	>	checkCompletedWithWrappedCFException(g, ex);
891	>	checkCompletedNormally(f, v1);
892	>	assertEquals(1, a.get());
893	>	}}
894
895		/**
896		* runAsync completes after running Runnable
#	Line 938 | Line 1136 | public class CompletableFutureTest exten
1136		for (boolean fFirst : new boolean[] { true, false })
1137		for (ExecutionMode m : ExecutionMode.values())
1138		for (Integer v1 : new Integer[] { 1, null })
1139	<	for (Integer v2 : new Integer[] { 2, null }) {
1140	<
1139	>	for (Integer v2 : new Integer[] { 2, null })
1140	>	{
1141		final CompletableFuture<Integer> f = new CompletableFuture<>();
1142		final CompletableFuture<Integer> g = new CompletableFuture<>();
1143		final SubtractFunction r = new SubtractFunction();
#	Line 962 | Line 1160 | public class CompletableFutureTest exten
1160		checkCompletedNormally(f, v1);
1161		checkCompletedNormally(g, v2);
1162		assertEquals(1, r.invocationCount);
1163	<	}
966	<	}
1163	>	}}
1164
1165		/**
1166		* thenCombine result completes exceptionally after exceptional
#	Line 971 | Line 1168 | public class CompletableFutureTest exten
1168		*/
1169		public void testThenCombine_exceptionalCompletion1() {
1170		for (ExecutionMode m : ExecutionMode.values())
1171	<	for (Integer v1 : new Integer[] { 1, null }) {
1172	<
1171	>	for (Integer v1 : new Integer[] { 1, null })
1172	>	{
1173		final CompletableFuture<Integer> f = new CompletableFuture<>();
1174		final CompletableFuture<Integer> g = new CompletableFuture<>();
1175		final SubtractFunction r = new SubtractFunction();
#	Line 987 | Line 1184 | public class CompletableFutureTest exten
1184		checkCompletedWithWrappedCFException(f, ex);
1185		assertEquals(0, r.invocationCount);
1186		checkCompletedNormally(g, v1);
1187	<	}
991	<	}
1187	>	}}
1188
1189		public void testThenCombine_exceptionalCompletion2() {
1190		for (ExecutionMode m : ExecutionMode.values())
1191	<	for (Integer v1 : new Integer[] { 1, null }) {
1192	<
1191	>	for (Integer v1 : new Integer[] { 1, null })
1192	>	{
1193		final CompletableFuture<Integer> f = new CompletableFuture<>();
1194		final CompletableFuture<Integer> g = new CompletableFuture<>();
1195		final SubtractFunction r = new SubtractFunction();
#	Line 1008 | Line 1204 | public class CompletableFutureTest exten
1204		checkCompletedWithWrappedCFException(g, ex);
1205		assertEquals(0, r.invocationCount);
1206		checkCompletedNormally(f, v1);
1207	<	}
1012	<	}
1207	>	}}
1208
1209		public void testThenCombine_exceptionalCompletion3() {
1210		for (ExecutionMode m : ExecutionMode.values())
1211	<	for (Integer v1 : new Integer[] { 1, null }) {
1212	<
1211	>	for (Integer v1 : new Integer[] { 1, null })
1212	>	{
1213		final CompletableFuture<Integer> f = new CompletableFuture<>();
1214		final CompletableFuture<Integer> g = new CompletableFuture<>();
1215		final SubtractFunction r = new SubtractFunction();
#	Line 1028 | Line 1223 | public class CompletableFutureTest exten
1223		checkCompletedWithWrappedCFException(g, ex);
1224		assertEquals(0, r.invocationCount);
1225		checkCompletedNormally(f, v1);
1226	<	}
1032	<	}
1226	>	}}
1227
1228		public void testThenCombine_exceptionalCompletion4() {
1229		for (ExecutionMode m : ExecutionMode.values())
1230	<	for (Integer v1 : new Integer[] { 1, null }) {
1231	<
1230	>	for (Integer v1 : new Integer[] { 1, null })
1231	>	{
1232		final CompletableFuture<Integer> f = new CompletableFuture<>();
1233		final CompletableFuture<Integer> g = new CompletableFuture<>();
1234		final SubtractFunction r = new SubtractFunction();
#	Line 1048 | Line 1242 | public class CompletableFutureTest exten
1242		checkCompletedWithWrappedCFException(f, ex);
1243		assertEquals(0, r.invocationCount);
1244		checkCompletedNormally(g, v1);
1245	<	}
1052	<	}
1245	>	}}
1246
1247		/**
1248		* thenCombine result completes exceptionally if action does
#	Line 1057 | Line 1250 | public class CompletableFutureTest exten
1250		public void testThenCombine_actionFailed1() {
1251		for (ExecutionMode m : ExecutionMode.values())
1252		for (Integer v1 : new Integer[] { 1, null })
1253	<	for (Integer v2 : new Integer[] { 2, null }) {
1254	<
1253	>	for (Integer v2 : new Integer[] { 2, null })
1254	>	{
1255		final CompletableFuture<Integer> f = new CompletableFuture<>();
1256		final CompletableFuture<Integer> g = new CompletableFuture<>();
1257		final FailingBiFunction r = new FailingBiFunction();
#	Line 1071 | Line 1264 | public class CompletableFutureTest exten
1264		checkCompletedWithWrappedCFException(h);
1265		checkCompletedNormally(f, v1);
1266		checkCompletedNormally(g, v2);
1267	<	}
1075	<	}
1267	>	}}
1268
1269		public void testThenCombine_actionFailed2() {
1270		for (ExecutionMode m : ExecutionMode.values())
1271		for (Integer v1 : new Integer[] { 1, null })
1272	<	for (Integer v2 : new Integer[] { 2, null }) {
1273	<
1272	>	for (Integer v2 : new Integer[] { 2, null })
1273	>	{
1274		final CompletableFuture<Integer> f = new CompletableFuture<>();
1275		final CompletableFuture<Integer> g = new CompletableFuture<>();
1276		final FailingBiFunction r = new FailingBiFunction();
#	Line 1091 | Line 1283 | public class CompletableFutureTest exten
1283		checkCompletedWithWrappedCFException(h);
1284		checkCompletedNormally(f, v1);
1285		checkCompletedNormally(g, v2);
1286	<	}
1095	<	}
1286	>	}}
1287
1288		/**
1289		* thenCombine result completes exceptionally if either source cancelled
#	Line 1100 | Line 1291 | public class CompletableFutureTest exten
1291		public void testThenCombine_sourceCancelled1() {
1292		for (ExecutionMode m : ExecutionMode.values())
1293		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1294	<	for (Integer v1 : new Integer[] { 1, null }) {
1295	<
1294	>	for (Integer v1 : new Integer[] { 1, null })
1295	>	{
1296		final CompletableFuture<Integer> f = new CompletableFuture<>();
1297		final CompletableFuture<Integer> g = new CompletableFuture<>();
1298		final SubtractFunction r = new SubtractFunction();
#	Line 1115 | Line 1306 | public class CompletableFutureTest exten
1306		checkCancelled(f);
1307		assertEquals(0, r.invocationCount);
1308		checkCompletedNormally(g, v1);
1309	<	}
1119	<	}
1309	>	}}
1310
1311		public void testThenCombine_sourceCancelled2() {
1312		for (ExecutionMode m : ExecutionMode.values())
1313		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1314	<	for (Integer v1 : new Integer[] { 1, null }) {
1315	<
1314	>	for (Integer v1 : new Integer[] { 1, null })
1315	>	{
1316		final CompletableFuture<Integer> f = new CompletableFuture<>();
1317		final CompletableFuture<Integer> g = new CompletableFuture<>();
1318		final SubtractFunction r = new SubtractFunction();
#	Line 1136 | Line 1326 | public class CompletableFutureTest exten
1326		checkCancelled(g);
1327		assertEquals(0, r.invocationCount);
1328		checkCompletedNormally(f, v1);
1329	<	}
1140	<	}
1329	>	}}
1330
1331		public void testThenCombine_sourceCancelled3() {
1332		for (ExecutionMode m : ExecutionMode.values())
1333		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1334	<	for (Integer v1 : new Integer[] { 1, null }) {
1335	<
1334	>	for (Integer v1 : new Integer[] { 1, null })
1335	>	{
1336		final CompletableFuture<Integer> f = new CompletableFuture<>();
1337		final CompletableFuture<Integer> g = new CompletableFuture<>();
1338		final SubtractFunction r = new SubtractFunction();
#	Line 1156 | Line 1345 | public class CompletableFutureTest exten
1345		checkCancelled(g);
1346		assertEquals(0, r.invocationCount);
1347		checkCompletedNormally(f, v1);
1348	<	}
1160	<	}
1348	>	}}
1349
1350		public void testThenCombine_sourceCancelled4() {
1351		for (ExecutionMode m : ExecutionMode.values())
1352		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1353	<	for (Integer v1 : new Integer[] { 1, null }) {
1354	<
1353	>	for (Integer v1 : new Integer[] { 1, null })
1354	>	{
1355		final CompletableFuture<Integer> f = new CompletableFuture<>();
1356		final CompletableFuture<Integer> g = new CompletableFuture<>();
1357		final SubtractFunction r = new SubtractFunction();
#	Line 1176 | Line 1364 | public class CompletableFutureTest exten
1364		checkCancelled(f);
1365		assertEquals(0, r.invocationCount);
1366		checkCompletedNormally(g, v1);
1367	<	}
1180	<	}
1367	>	}}
1368
1369		/**
1370		* thenAcceptBoth result completes normally after normal
#	Line 1186 | Line 1373 | public class CompletableFutureTest exten
1373		public void testThenAcceptBoth_normalCompletion1() {
1374		for (ExecutionMode m : ExecutionMode.values())
1375		for (Integer v1 : new Integer[] { 1, null })
1376	<	for (Integer v2 : new Integer[] { 2, null }) {
1377	<
1376	>	for (Integer v2 : new Integer[] { 2, null })
1377	>	{
1378		final CompletableFuture<Integer> f = new CompletableFuture<>();
1379		final CompletableFuture<Integer> g = new CompletableFuture<>();
1380		final SubtractAction r = new SubtractAction();
#	Line 1199 | Line 1386 | public class CompletableFutureTest exten
1386		g.complete(v2);
1387
1388		checkCompletedNormally(h, null);
1389	<	assertEquals(r.value, subtract(v1, v2));
1389	>	assertEquals(subtract(v1, v2), r.value);
1390		checkCompletedNormally(f, v1);
1391		checkCompletedNormally(g, v2);
1392	<	}
1206	<	}
1392	>	}}
1393
1394		public void testThenAcceptBoth_normalCompletion2() {
1395		for (ExecutionMode m : ExecutionMode.values())
1396		for (Integer v1 : new Integer[] { 1, null })
1397	<	for (Integer v2 : new Integer[] { 2, null }) {
1398	<
1397	>	for (Integer v2 : new Integer[] { 2, null })
1398	>	{
1399		final CompletableFuture<Integer> f = new CompletableFuture<>();
1400		final CompletableFuture<Integer> g = new CompletableFuture<>();
1401		final SubtractAction r = new SubtractAction();
#	Line 1221 | Line 1407 | public class CompletableFutureTest exten
1407		f.complete(v1);
1408
1409		checkCompletedNormally(h, null);
1410	<	assertEquals(r.value, subtract(v1, v2));
1410	>	assertEquals(subtract(v1, v2), r.value);
1411		checkCompletedNormally(f, v1);
1412		checkCompletedNormally(g, v2);
1413	<	}
1228	<	}
1413	>	}}
1414
1415		public void testThenAcceptBoth_normalCompletion3() {
1416		for (ExecutionMode m : ExecutionMode.values())
1417		for (Integer v1 : new Integer[] { 1, null })
1418	<	for (Integer v2 : new Integer[] { 2, null }) {
1419	<
1418	>	for (Integer v2 : new Integer[] { 2, null })
1419	>	{
1420		final CompletableFuture<Integer> f = new CompletableFuture<>();
1421		final CompletableFuture<Integer> g = new CompletableFuture<>();
1422		final SubtractAction r = new SubtractAction();
#	Line 1241 | Line 1426 | public class CompletableFutureTest exten
1426		final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1427
1428		checkCompletedNormally(h, null);
1429	<	assertEquals(r.value, subtract(v1, v2));
1429	>	assertEquals(subtract(v1, v2), r.value);
1430		checkCompletedNormally(f, v1);
1431		checkCompletedNormally(g, v2);
1432	<	}
1248	<	}
1432	>	}}
1433
1434		public void testThenAcceptBoth_normalCompletion4() {
1435		for (ExecutionMode m : ExecutionMode.values())
1436		for (Integer v1 : new Integer[] { 1, null })
1437	<	for (Integer v2 : new Integer[] { 2, null }) {
1438	<
1437	>	for (Integer v2 : new Integer[] { 2, null })
1438	>	{
1439		final CompletableFuture<Integer> f = new CompletableFuture<>();
1440		final CompletableFuture<Integer> g = new CompletableFuture<>();
1441		final SubtractAction r = new SubtractAction();
#	Line 1261 | Line 1445 | public class CompletableFutureTest exten
1445		final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1446
1447		checkCompletedNormally(h, null);
1448	<	assertEquals(r.value, subtract(v1, v2));
1448	>	assertEquals(subtract(v1, v2), r.value);
1449		checkCompletedNormally(f, v1);
1450		checkCompletedNormally(g, v2);
1451	<	}
1268	<	}
1451	>	}}
1452
1453		/**
1454		* thenAcceptBoth result completes exceptionally after exceptional
#	Line 1273 | Line 1456 | public class CompletableFutureTest exten
1456		*/
1457		public void testThenAcceptBoth_exceptionalCompletion1() {
1458		for (ExecutionMode m : ExecutionMode.values())
1459	<	for (Integer v1 : new Integer[] { 1, null }) {
1460	<
1459	>	for (Integer v1 : new Integer[] { 1, null })
1460	>	{
1461		final CompletableFuture<Integer> f = new CompletableFuture<>();
1462		final CompletableFuture<Integer> g = new CompletableFuture<>();
1463		final SubtractAction r = new SubtractAction();
#	Line 1289 | Line 1472 | public class CompletableFutureTest exten
1472		checkCompletedWithWrappedCFException(f, ex);
1473		assertEquals(0, r.invocationCount);
1474		checkCompletedNormally(g, v1);
1475	<	}
1293	<	}
1475	>	}}
1476
1477		public void testThenAcceptBoth_exceptionalCompletion2() {
1478		for (ExecutionMode m : ExecutionMode.values())
1479	<	for (Integer v1 : new Integer[] { 1, null }) {
1480	<
1479	>	for (Integer v1 : new Integer[] { 1, null })
1480	>	{
1481		final CompletableFuture<Integer> f = new CompletableFuture<>();
1482		final CompletableFuture<Integer> g = new CompletableFuture<>();
1483		final SubtractAction r = new SubtractAction();
#	Line 1310 | Line 1492 | public class CompletableFutureTest exten
1492		checkCompletedWithWrappedCFException(g, ex);
1493		assertEquals(0, r.invocationCount);
1494		checkCompletedNormally(f, v1);
1495	<	}
1314	<	}
1495	>	}}
1496
1497		public void testThenAcceptBoth_exceptionalCompletion3() {
1498		for (ExecutionMode m : ExecutionMode.values())
1499	<	for (Integer v1 : new Integer[] { 1, null }) {
1500	<
1499	>	for (Integer v1 : new Integer[] { 1, null })
1500	>	{
1501		final CompletableFuture<Integer> f = new CompletableFuture<>();
1502		final CompletableFuture<Integer> g = new CompletableFuture<>();
1503		final SubtractAction r = new SubtractAction();
#	Line 1330 | Line 1511 | public class CompletableFutureTest exten
1511		checkCompletedWithWrappedCFException(g, ex);
1512		assertEquals(0, r.invocationCount);
1513		checkCompletedNormally(f, v1);
1514	<	}
1334	<	}
1514	>	}}
1515
1516		public void testThenAcceptBoth_exceptionalCompletion4() {
1517		for (ExecutionMode m : ExecutionMode.values())
1518	<	for (Integer v1 : new Integer[] { 1, null }) {
1519	<
1518	>	for (Integer v1 : new Integer[] { 1, null })
1519	>	{
1520		final CompletableFuture<Integer> f = new CompletableFuture<>();
1521		final CompletableFuture<Integer> g = new CompletableFuture<>();
1522		final SubtractAction r = new SubtractAction();
#	Line 1350 | Line 1530 | public class CompletableFutureTest exten
1530		checkCompletedWithWrappedCFException(f, ex);
1531		assertEquals(0, r.invocationCount);
1532		checkCompletedNormally(g, v1);
1533	<	}
1354	<	}
1533	>	}}
1534
1535		/**
1536		* thenAcceptBoth result completes exceptionally if action does
#	Line 1359 | Line 1538 | public class CompletableFutureTest exten
1538		public void testThenAcceptBoth_actionFailed1() {
1539		for (ExecutionMode m : ExecutionMode.values())
1540		for (Integer v1 : new Integer[] { 1, null })
1541	<	for (Integer v2 : new Integer[] { 2, null }) {
1542	<
1541	>	for (Integer v2 : new Integer[] { 2, null })
1542	>	{
1543		final CompletableFuture<Integer> f = new CompletableFuture<>();
1544		final CompletableFuture<Integer> g = new CompletableFuture<>();
1545		final FailingBiConsumer r = new FailingBiConsumer();
#	Line 1373 | Line 1552 | public class CompletableFutureTest exten
1552		checkCompletedWithWrappedCFException(h);
1553		checkCompletedNormally(f, v1);
1554		checkCompletedNormally(g, v2);
1555	<	}
1377	<	}
1555	>	}}
1556
1557		public void testThenAcceptBoth_actionFailed2() {
1558		for (ExecutionMode m : ExecutionMode.values())
1559		for (Integer v1 : new Integer[] { 1, null })
1560	<	for (Integer v2 : new Integer[] { 2, null }) {
1561	<
1560	>	for (Integer v2 : new Integer[] { 2, null })
1561	>	{
1562		final CompletableFuture<Integer> f = new CompletableFuture<>();
1563		final CompletableFuture<Integer> g = new CompletableFuture<>();
1564		final FailingBiConsumer r = new FailingBiConsumer();
#	Line 1393 | Line 1571 | public class CompletableFutureTest exten
1571		checkCompletedWithWrappedCFException(h);
1572		checkCompletedNormally(f, v1);
1573		checkCompletedNormally(g, v2);
1574	<	}
1397	<	}
1574	>	}}
1575
1576		/**
1577		* thenAcceptBoth result completes exceptionally if either source cancelled
#	Line 1402 | Line 1579 | public class CompletableFutureTest exten
1579		public void testThenAcceptBoth_sourceCancelled1() {
1580		for (ExecutionMode m : ExecutionMode.values())
1581		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1582	<	for (Integer v1 : new Integer[] { 1, null }) {
1583	<
1582	>	for (Integer v1 : new Integer[] { 1, null })
1583	>	{
1584		final CompletableFuture<Integer> f = new CompletableFuture<>();
1585		final CompletableFuture<Integer> g = new CompletableFuture<>();
1586		final SubtractAction r = new SubtractAction();
#	Line 1417 | Line 1594 | public class CompletableFutureTest exten
1594		checkCancelled(f);
1595		assertEquals(0, r.invocationCount);
1596		checkCompletedNormally(g, v1);
1597	<	}
1421	<	}
1597	>	}}
1598
1599		public void testThenAcceptBoth_sourceCancelled2() {
1600		for (ExecutionMode m : ExecutionMode.values())
1601		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1602	<	for (Integer v1 : new Integer[] { 1, null }) {
1603	<
1602	>	for (Integer v1 : new Integer[] { 1, null })
1603	>	{
1604		final CompletableFuture<Integer> f = new CompletableFuture<>();
1605		final CompletableFuture<Integer> g = new CompletableFuture<>();
1606		final SubtractAction r = new SubtractAction();
#	Line 1438 | Line 1614 | public class CompletableFutureTest exten
1614		checkCancelled(g);
1615		assertEquals(0, r.invocationCount);
1616		checkCompletedNormally(f, v1);
1617	<	}
1442	<	}
1617	>	}}
1618
1619		public void testThenAcceptBoth_sourceCancelled3() {
1620		for (ExecutionMode m : ExecutionMode.values())
1621		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1622	<	for (Integer v1 : new Integer[] { 1, null }) {
1623	<
1622	>	for (Integer v1 : new Integer[] { 1, null })
1623	>	{
1624		final CompletableFuture<Integer> f = new CompletableFuture<>();
1625		final CompletableFuture<Integer> g = new CompletableFuture<>();
1626		final SubtractAction r = new SubtractAction();
#	Line 1458 | Line 1633 | public class CompletableFutureTest exten
1633		checkCancelled(g);
1634		assertEquals(0, r.invocationCount);
1635		checkCompletedNormally(f, v1);
1636	<	}
1462	<	}
1636	>	}}
1637
1638		public void testThenAcceptBoth_sourceCancelled4() {
1639		for (ExecutionMode m : ExecutionMode.values())
1640		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1641	<	for (Integer v1 : new Integer[] { 1, null }) {
1642	<
1641	>	for (Integer v1 : new Integer[] { 1, null })
1642	>	{
1643		final CompletableFuture<Integer> f = new CompletableFuture<>();
1644		final CompletableFuture<Integer> g = new CompletableFuture<>();
1645		final SubtractAction r = new SubtractAction();
#	Line 1478 | Line 1652 | public class CompletableFutureTest exten
1652		checkCancelled(f);
1653		assertEquals(0, r.invocationCount);
1654		checkCompletedNormally(g, v1);
1655	<	}
1482	<	}
1655	>	}}
1656
1657		/**
1658		* runAfterBoth result completes normally after normal
#	Line 1488 | Line 1661 | public class CompletableFutureTest exten
1661		public void testRunAfterBoth_normalCompletion1() {
1662		for (ExecutionMode m : ExecutionMode.values())
1663		for (Integer v1 : new Integer[] { 1, null })
1664	<	for (Integer v2 : new Integer[] { 2, null }) {
1665	<
1664	>	for (Integer v2 : new Integer[] { 2, null })
1665	>	{
1666		final CompletableFuture<Integer> f = new CompletableFuture<>();
1667		final CompletableFuture<Integer> g = new CompletableFuture<>();
1668		final Noop r = new Noop();
#	Line 1504 | Line 1677 | public class CompletableFutureTest exten
1677		assertEquals(1, r.invocationCount);
1678		checkCompletedNormally(f, v1);
1679		checkCompletedNormally(g, v2);
1680	<	}
1508	<	}
1680	>	}}
1681
1682		public void testRunAfterBoth_normalCompletion2() {
1683		for (ExecutionMode m : ExecutionMode.values())
1684		for (Integer v1 : new Integer[] { 1, null })
1685	<	for (Integer v2 : new Integer[] { 2, null }) {
1686	<
1685	>	for (Integer v2 : new Integer[] { 2, null })
1686	>	{
1687		final CompletableFuture<Integer> f = new CompletableFuture<>();
1688		final CompletableFuture<Integer> g = new CompletableFuture<>();
1689		final Noop r = new Noop();
#	Line 1526 | Line 1698 | public class CompletableFutureTest exten
1698		assertEquals(1, r.invocationCount);
1699		checkCompletedNormally(f, v1);
1700		checkCompletedNormally(g, v2);
1701	<	}
1530	<	}
1701	>	}}
1702
1703		public void testRunAfterBoth_normalCompletion3() {
1704		for (ExecutionMode m : ExecutionMode.values())
1705		for (Integer v1 : new Integer[] { 1, null })
1706	<	for (Integer v2 : new Integer[] { 2, null }) {
1707	<
1706	>	for (Integer v2 : new Integer[] { 2, null })
1707	>	{
1708		final CompletableFuture<Integer> f = new CompletableFuture<>();
1709		final CompletableFuture<Integer> g = new CompletableFuture<>();
1710		final Noop r = new Noop();
#	Line 1546 | Line 1717 | public class CompletableFutureTest exten
1717		assertEquals(1, r.invocationCount);
1718		checkCompletedNormally(f, v1);
1719		checkCompletedNormally(g, v2);
1720	<	}
1550	<	}
1720	>	}}
1721
1722		public void testRunAfterBoth_normalCompletion4() {
1723		for (ExecutionMode m : ExecutionMode.values())
1724		for (Integer v1 : new Integer[] { 1, null })
1725	<	for (Integer v2 : new Integer[] { 2, null }) {
1726	<
1725	>	for (Integer v2 : new Integer[] { 2, null })
1726	>	{
1727		final CompletableFuture<Integer> f = new CompletableFuture<>();
1728		final CompletableFuture<Integer> g = new CompletableFuture<>();
1729		final Noop r = new Noop();
#	Line 1566 | Line 1736 | public class CompletableFutureTest exten
1736		assertEquals(1, r.invocationCount);
1737		checkCompletedNormally(f, v1);
1738		checkCompletedNormally(g, v2);
1739	<	}
1570	<	}
1739	>	}}
1740
1741		/**
1742		* runAfterBoth result completes exceptionally after exceptional
#	Line 1575 | Line 1744 | public class CompletableFutureTest exten
1744		*/
1745		public void testRunAfterBoth_exceptionalCompletion1() {
1746		for (ExecutionMode m : ExecutionMode.values())
1747	<	for (Integer v1 : new Integer[] { 1, null }) {
1748	<
1747	>	for (Integer v1 : new Integer[] { 1, null })
1748	>	{
1749		final CompletableFuture<Integer> f = new CompletableFuture<>();
1750		final CompletableFuture<Integer> g = new CompletableFuture<>();
1751		final Noop r = new Noop();
#	Line 1591 | Line 1760 | public class CompletableFutureTest exten
1760		checkCompletedWithWrappedCFException(f, ex);
1761		assertEquals(0, r.invocationCount);
1762		checkCompletedNormally(g, v1);
1763	<	}
1595	<	}
1763	>	}}
1764
1765		public void testRunAfterBoth_exceptionalCompletion2() {
1766		for (ExecutionMode m : ExecutionMode.values())
1767	<	for (Integer v1 : new Integer[] { 1, null }) {
1768	<
1767	>	for (Integer v1 : new Integer[] { 1, null })
1768	>	{
1769		final CompletableFuture<Integer> f = new CompletableFuture<>();
1770		final CompletableFuture<Integer> g = new CompletableFuture<>();
1771		final Noop r = new Noop();
#	Line 1612 | Line 1780 | public class CompletableFutureTest exten
1780		checkCompletedWithWrappedCFException(g, ex);
1781		assertEquals(0, r.invocationCount);
1782		checkCompletedNormally(f, v1);
1783	<	}
1616	<	}
1783	>	}}
1784
1785		public void testRunAfterBoth_exceptionalCompletion3() {
1786		for (ExecutionMode m : ExecutionMode.values())
1787	<	for (Integer v1 : new Integer[] { 1, null }) {
1788	<
1787	>	for (Integer v1 : new Integer[] { 1, null })
1788	>	{
1789		final CompletableFuture<Integer> f = new CompletableFuture<>();
1790		final CompletableFuture<Integer> g = new CompletableFuture<>();
1791		final Noop r = new Noop();
#	Line 1632 | Line 1799 | public class CompletableFutureTest exten
1799		checkCompletedWithWrappedCFException(g, ex);
1800		assertEquals(0, r.invocationCount);
1801		checkCompletedNormally(f, v1);
1802	<	}
1636	<	}
1802	>	}}
1803
1804		public void testRunAfterBoth_exceptionalCompletion4() {
1805		for (ExecutionMode m : ExecutionMode.values())
1806	<	for (Integer v1 : new Integer[] { 1, null }) {
1807	<
1806	>	for (Integer v1 : new Integer[] { 1, null })
1807	>	{
1808		final CompletableFuture<Integer> f = new CompletableFuture<>();
1809		final CompletableFuture<Integer> g = new CompletableFuture<>();
1810		final Noop r = new Noop();
#	Line 1652 | Line 1818 | public class CompletableFutureTest exten
1818		checkCompletedWithWrappedCFException(f, ex);
1819		assertEquals(0, r.invocationCount);
1820		checkCompletedNormally(g, v1);
1821	<	}
1656	<	}
1821	>	}}
1822
1823		/**
1824		* runAfterBoth result completes exceptionally if action does
#	Line 1661 | Line 1826 | public class CompletableFutureTest exten
1826		public void testRunAfterBoth_actionFailed1() {
1827		for (ExecutionMode m : ExecutionMode.values())
1828		for (Integer v1 : new Integer[] { 1, null })
1829	<	for (Integer v2 : new Integer[] { 2, null }) {
1830	<
1829	>	for (Integer v2 : new Integer[] { 2, null })
1830	>	{
1831		final CompletableFuture<Integer> f = new CompletableFuture<>();
1832		final CompletableFuture<Integer> g = new CompletableFuture<>();
1833		final FailingNoop r = new FailingNoop();
#	Line 1675 | Line 1840 | public class CompletableFutureTest exten
1840		checkCompletedWithWrappedCFException(h);
1841		checkCompletedNormally(f, v1);
1842		checkCompletedNormally(g, v2);
1843	<	}
1679	<	}
1843	>	}}
1844
1845		public void testRunAfterBoth_actionFailed2() {
1846		for (ExecutionMode m : ExecutionMode.values())
1847		for (Integer v1 : new Integer[] { 1, null })
1848	<	for (Integer v2 : new Integer[] { 2, null }) {
1849	<
1848	>	for (Integer v2 : new Integer[] { 2, null })
1849	>	{
1850		final CompletableFuture<Integer> f = new CompletableFuture<>();
1851		final CompletableFuture<Integer> g = new CompletableFuture<>();
1852		final FailingNoop r = new FailingNoop();
#	Line 1695 | Line 1859 | public class CompletableFutureTest exten
1859		checkCompletedWithWrappedCFException(h);
1860		checkCompletedNormally(f, v1);
1861		checkCompletedNormally(g, v2);
1862	<	}
1699	<	}
1862	>	}}
1863
1864		/**
1865		* runAfterBoth result completes exceptionally if either source cancelled
#	Line 1704 | Line 1867 | public class CompletableFutureTest exten
1867		public void testRunAfterBoth_sourceCancelled1() {
1868		for (ExecutionMode m : ExecutionMode.values())
1869		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1870	<	for (Integer v1 : new Integer[] { 1, null }) {
1871	<
1870	>	for (Integer v1 : new Integer[] { 1, null })
1871	>	{
1872		final CompletableFuture<Integer> f = new CompletableFuture<>();
1873		final CompletableFuture<Integer> g = new CompletableFuture<>();
1874		final Noop r = new Noop();
#	Line 1719 | Line 1882 | public class CompletableFutureTest exten
1882		checkCancelled(f);
1883		assertEquals(0, r.invocationCount);
1884		checkCompletedNormally(g, v1);
1885	<	}
1723	<	}
1885	>	}}
1886
1887		public void testRunAfterBoth_sourceCancelled2() {
1888		for (ExecutionMode m : ExecutionMode.values())
1889		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1890	<	for (Integer v1 : new Integer[] { 1, null }) {
1891	<
1890	>	for (Integer v1 : new Integer[] { 1, null })
1891	>	{
1892		final CompletableFuture<Integer> f = new CompletableFuture<>();
1893		final CompletableFuture<Integer> g = new CompletableFuture<>();
1894		final Noop r = new Noop();
#	Line 1740 | Line 1902 | public class CompletableFutureTest exten
1902		checkCancelled(g);
1903		assertEquals(0, r.invocationCount);
1904		checkCompletedNormally(f, v1);
1905	<	}
1744	<	}
1905	>	}}
1906
1907		public void testRunAfterBoth_sourceCancelled3() {
1908		for (ExecutionMode m : ExecutionMode.values())
1909		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1910	<	for (Integer v1 : new Integer[] { 1, null }) {
1911	<
1910	>	for (Integer v1 : new Integer[] { 1, null })
1911	>	{
1912		final CompletableFuture<Integer> f = new CompletableFuture<>();
1913		final CompletableFuture<Integer> g = new CompletableFuture<>();
1914		final Noop r = new Noop();
#	Line 1760 | Line 1921 | public class CompletableFutureTest exten
1921		checkCancelled(g);
1922		assertEquals(0, r.invocationCount);
1923		checkCompletedNormally(f, v1);
1924	<	}
1764	<	}
1924	>	}}
1925
1926		public void testRunAfterBoth_sourceCancelled4() {
1927		for (ExecutionMode m : ExecutionMode.values())
1928		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1929	<	for (Integer v1 : new Integer[] { 1, null }) {
1930	<
1929	>	for (Integer v1 : new Integer[] { 1, null })
1930	>	{
1931		final CompletableFuture<Integer> f = new CompletableFuture<>();
1932		final CompletableFuture<Integer> g = new CompletableFuture<>();
1933		final Noop r = new Noop();
#	Line 1780 | Line 1940 | public class CompletableFutureTest exten
1940		checkCancelled(f);
1941		assertEquals(0, r.invocationCount);
1942		checkCompletedNormally(g, v1);
1943	<	}
1784	<	}
1943	>	}}
1944
1945		/**
1946		* applyToEither result completes normally after normal completion
#	Line 1790 | Line 1949 | public class CompletableFutureTest exten
1949		public void testApplyToEither_normalCompletion1() {
1950		for (ExecutionMode m : ExecutionMode.values())
1951		for (Integer v1 : new Integer[] { 1, null })
1952	<	for (Integer v2 : new Integer[] { 2, null }) {
1953	<
1952	>	for (Integer v2 : new Integer[] { 2, null })
1953	>	{
1954		final CompletableFuture<Integer> f = new CompletableFuture<>();
1955		final CompletableFuture<Integer> g = new CompletableFuture<>();
1956		final IncFunction r = new IncFunction();
#	Line 1804 | Line 1963 | public class CompletableFutureTest exten
1963		checkCompletedNormally(f, v1);
1964		checkCompletedNormally(g, v2);
1965		checkCompletedNormally(h, inc(v1));
1966	<	}
1808	<	}
1966	>	}}
1967
1968		public void testApplyToEither_normalCompletion2() {
1969		for (ExecutionMode m : ExecutionMode.values())
1970		for (Integer v1 : new Integer[] { 1, null })
1971	<	for (Integer v2 : new Integer[] { 2, null }) {
1972	<
1971	>	for (Integer v2 : new Integer[] { 2, null })
1972	>	{
1973		final CompletableFuture<Integer> f = new CompletableFuture<>();
1974		final CompletableFuture<Integer> g = new CompletableFuture<>();
1975		final IncFunction r = new IncFunction();
#	Line 1824 | Line 1982 | public class CompletableFutureTest exten
1982		checkCompletedNormally(f, v1);
1983		checkCompletedNormally(g, v2);
1984		checkCompletedNormally(h, inc(v2));
1985	<	}
1986	<	}
1985	>	}}
1986	>
1987		public void testApplyToEither_normalCompletion3() {
1988		for (ExecutionMode m : ExecutionMode.values())
1989		for (Integer v1 : new Integer[] { 1, null })
1990	<	for (Integer v2 : new Integer[] { 2, null }) {
1991	<
1990	>	for (Integer v2 : new Integer[] { 2, null })
1991	>	{
1992		final CompletableFuture<Integer> f = new CompletableFuture<>();
1993		final CompletableFuture<Integer> g = new CompletableFuture<>();
1994		final IncFunction r = new IncFunction();
#	Line 1846 | Line 2004 | public class CompletableFutureTest exten
2004		assertTrue(Objects.equals(h.join(), inc(v1)) ||
2005		Objects.equals(h.join(), inc(v2)));
2006		assertEquals(1, r.invocationCount);
2007	<	}
1850	<	}
2007	>	}}
2008
2009		/**
2010		* applyToEither result completes exceptionally after exceptional
#	Line 1855 | Line 2012 | public class CompletableFutureTest exten
2012		*/
2013		public void testApplyToEither_exceptionalCompletion1() {
2014		for (ExecutionMode m : ExecutionMode.values())
2015	<	for (Integer v1 : new Integer[] { 1, null }) {
2016	<
2015	>	for (Integer v1 : new Integer[] { 1, null })
2016	>	{
2017		final CompletableFuture<Integer> f = new CompletableFuture<>();
2018		final CompletableFuture<Integer> g = new CompletableFuture<>();
2019		final IncFunction r = new IncFunction();
#	Line 1871 | Line 2028 | public class CompletableFutureTest exten
2028		checkCompletedNormally(g, v1);
2029		checkCompletedWithWrappedCFException(f, ex);
2030		checkCompletedWithWrappedCFException(h, ex);
2031	<	}
1875	<	}
2031	>	}}
2032
2033		public void testApplyToEither_exceptionalCompletion2() {
2034		for (ExecutionMode m : ExecutionMode.values())
2035	<	for (Integer v1 : new Integer[] { 1, null }) {
2036	<
2035	>	for (Integer v1 : new Integer[] { 1, null })
2036	>	{
2037		final CompletableFuture<Integer> f = new CompletableFuture<>();
2038		final CompletableFuture<Integer> g = new CompletableFuture<>();
2039		final IncFunction r = new IncFunction();
#	Line 1892 | Line 2048 | public class CompletableFutureTest exten
2048		checkCompletedNormally(f, v1);
2049		checkCompletedWithWrappedCFException(g, ex);
2050		checkCompletedWithWrappedCFException(h, ex);
2051	<	}
1896	<	}
2051	>	}}
2052
2053		public void testApplyToEither_exceptionalCompletion3() {
2054		for (ExecutionMode m : ExecutionMode.values())
2055	<	for (Integer v1 : new Integer[] { 1, null }) {
2056	<
2055	>	for (Integer v1 : new Integer[] { 1, null })
2056	>	{
2057		final CompletableFuture<Integer> f = new CompletableFuture<>();
2058		final CompletableFuture<Integer> g = new CompletableFuture<>();
2059		final IncFunction r = new IncFunction();
#	Line 1911 | Line 2066 | public class CompletableFutureTest exten
2066		// unspecified behavior
2067		Integer v;
2068		try {
2069	<	assertEquals(h.join(), inc(v1));
2069	>	assertEquals(inc(v1), h.join());
2070		assertEquals(1, r.invocationCount);
2071		} catch (CompletionException ok) {
2072		checkCompletedWithWrappedCFException(h, ex);
#	Line 1920 | Line 2075 | public class CompletableFutureTest exten
2075
2076		checkCompletedWithWrappedCFException(g, ex);
2077		checkCompletedNormally(f, v1);
2078	<	}
1924	<	}
2078	>	}}
2079
2080		public void testApplyToEither_exceptionalCompletion4() {
2081		for (ExecutionMode m : ExecutionMode.values())
2082	<	for (Integer v1 : new Integer[] { 1, null }) {
2083	<
2082	>	for (Integer v1 : new Integer[] { 1, null })
2083	>	{
2084		final CompletableFuture<Integer> f = new CompletableFuture<>();
2085		final CompletableFuture<Integer> g = new CompletableFuture<>();
2086		final IncFunction r = new IncFunction();
#	Line 1939 | Line 2093 | public class CompletableFutureTest exten
2093		// unspecified behavior
2094		Integer v;
2095		try {
2096	<	assertEquals(h.join(), inc(v1));
2096	>	assertEquals(inc(v1), h.join());
2097		assertEquals(1, r.invocationCount);
2098		} catch (CompletionException ok) {
2099		checkCompletedWithWrappedCFException(h, ex);
#	Line 1948 | Line 2102 | public class CompletableFutureTest exten
2102
2103		checkCompletedWithWrappedCFException(f, ex);
2104		checkCompletedNormally(g, v1);
2105	<	}
1952	<	}
2105	>	}}
2106
2107		/**
2108		* applyToEither result completes exceptionally if action does
#	Line 1957 | Line 2110 | public class CompletableFutureTest exten
2110		public void testApplyToEither_actionFailed1() {
2111		for (ExecutionMode m : ExecutionMode.values())
2112		for (Integer v1 : new Integer[] { 1, null })
2113	<	for (Integer v2 : new Integer[] { 2, null }) {
2114	<
2113	>	for (Integer v2 : new Integer[] { 2, null })
2114	>	{
2115		final CompletableFuture<Integer> f = new CompletableFuture<>();
2116		final CompletableFuture<Integer> g = new CompletableFuture<>();
2117		final FailingFunction r = new FailingFunction();
#	Line 1969 | Line 2122 | public class CompletableFutureTest exten
2122		g.complete(v2);
2123		checkCompletedNormally(f, v1);
2124		checkCompletedNormally(g, v2);
2125	<	}
1973	<	}
2125	>	}}
2126
2127		public void testApplyToEither_actionFailed2() {
2128		for (ExecutionMode m : ExecutionMode.values())
2129		for (Integer v1 : new Integer[] { 1, null })
2130	<	for (Integer v2 : new Integer[] { 2, null }) {
2131	<
2130	>	for (Integer v2 : new Integer[] { 2, null })
2131	>	{
2132		final CompletableFuture<Integer> f = new CompletableFuture<>();
2133		final CompletableFuture<Integer> g = new CompletableFuture<>();
2134		final FailingFunction r = new FailingFunction();
#	Line 1987 | Line 2139 | public class CompletableFutureTest exten
2139		f.complete(v1);
2140		checkCompletedNormally(f, v1);
2141		checkCompletedNormally(g, v2);
2142	<	}
1991	<	}
2142	>	}}
2143
2144		/**
2145		* applyToEither result completes exceptionally if either source cancelled
#	Line 1996 | Line 2147 | public class CompletableFutureTest exten
2147		public void testApplyToEither_sourceCancelled1() {
2148		for (ExecutionMode m : ExecutionMode.values())
2149		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2150	<	for (Integer v1 : new Integer[] { 1, null }) {
2151	<
2150	>	for (Integer v1 : new Integer[] { 1, null })
2151	>	{
2152		final CompletableFuture<Integer> f = new CompletableFuture<>();
2153		final CompletableFuture<Integer> g = new CompletableFuture<>();
2154		final IncFunction r = new IncFunction();
#	Line 2011 | Line 2162 | public class CompletableFutureTest exten
2162		assertEquals(0, r.invocationCount);
2163		checkCompletedNormally(g, v1);
2164		checkCompletedWithWrappedCancellationException(h);
2165	<	}
2015	<	}
2165	>	}}
2166
2167		public void testApplyToEither_sourceCancelled2() {
2168		for (ExecutionMode m : ExecutionMode.values())
2169		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2170	<	for (Integer v1 : new Integer[] { 1, null }) {
2171	<
2170	>	for (Integer v1 : new Integer[] { 1, null })
2171	>	{
2172		final CompletableFuture<Integer> f = new CompletableFuture<>();
2173		final CompletableFuture<Integer> g = new CompletableFuture<>();
2174		final IncFunction r = new IncFunction();
#	Line 2032 | Line 2182 | public class CompletableFutureTest exten
2182		assertEquals(0, r.invocationCount);
2183		checkCompletedNormally(f, v1);
2184		checkCompletedWithWrappedCancellationException(h);
2185	<	}
2036	<	}
2185	>	}}
2186
2187		public void testApplyToEither_sourceCancelled3() {
2188		for (ExecutionMode m : ExecutionMode.values())
2189		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2190	<	for (Integer v1 : new Integer[] { 1, null }) {
2191	<
2190	>	for (Integer v1 : new Integer[] { 1, null })
2191	>	{
2192		final CompletableFuture<Integer> f = new CompletableFuture<>();
2193		final CompletableFuture<Integer> g = new CompletableFuture<>();
2194		final IncFunction r = new IncFunction();
#	Line 2051 | Line 2200 | public class CompletableFutureTest exten
2200		// unspecified behavior
2201		Integer v;
2202		try {
2203	<	assertEquals(h.join(), inc(v1));
2203	>	assertEquals(inc(v1), h.join());
2204		assertEquals(1, r.invocationCount);
2205		} catch (CompletionException ok) {
2206		checkCompletedWithWrappedCancellationException(h);
#	Line 2060 | Line 2209 | public class CompletableFutureTest exten
2209
2210		checkCancelled(g);
2211		checkCompletedNormally(f, v1);
2212	<	}
2064	<	}
2212	>	}}
2213
2214		public void testApplyToEither_sourceCancelled4() {
2215		for (ExecutionMode m : ExecutionMode.values())
2216		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2217	<	for (Integer v1 : new Integer[] { 1, null }) {
2218	<
2217	>	for (Integer v1 : new Integer[] { 1, null })
2218	>	{
2219		final CompletableFuture<Integer> f = new CompletableFuture<>();
2220		final CompletableFuture<Integer> g = new CompletableFuture<>();
2221		final IncFunction r = new IncFunction();
#	Line 2079 | Line 2227 | public class CompletableFutureTest exten
2227		// unspecified behavior
2228		Integer v;
2229		try {
2230	<	assertEquals(h.join(), inc(v1));
2230	>	assertEquals(inc(v1), h.join());
2231		assertEquals(1, r.invocationCount);
2232		} catch (CompletionException ok) {
2233		checkCompletedWithWrappedCancellationException(h);
#	Line 2088 | Line 2236 | public class CompletableFutureTest exten
2236
2237		checkCancelled(f);
2238		checkCompletedNormally(g, v1);
2239	<	}
2092	<	}
2239	>	}}
2240
2241		/**
2242		* acceptEither result completes normally after normal completion
#	Line 2098 | Line 2245 | public class CompletableFutureTest exten
2245		public void testAcceptEither_normalCompletion1() {
2246		for (ExecutionMode m : ExecutionMode.values())
2247		for (Integer v1 : new Integer[] { 1, null })
2248	<	for (Integer v2 : new Integer[] { 2, null }) {
2249	<
2248	>	for (Integer v2 : new Integer[] { 2, null })
2249	>	{
2250		final CompletableFuture<Integer> f = new CompletableFuture<>();
2251		final CompletableFuture<Integer> g = new CompletableFuture<>();
2252		final IncAction r = new IncAction();
#	Line 2107 | Line 2254 | public class CompletableFutureTest exten
2254
2255		f.complete(v1);
2256		checkCompletedNormally(h, null);
2257	<	assertEquals(r.value, inc(v1));
2257	>	assertEquals(inc(v1), r.value);
2258		g.complete(v2);
2259
2260		checkCompletedNormally(f, v1);
2261		checkCompletedNormally(g, v2);
2262		checkCompletedNormally(h, null);
2263	<	}
2117	<	}
2263	>	}}
2264
2265		public void testAcceptEither_normalCompletion2() {
2266		for (ExecutionMode m : ExecutionMode.values())
2267		for (Integer v1 : new Integer[] { 1, null })
2268	<	for (Integer v2 : new Integer[] { 2, null }) {
2269	<
2268	>	for (Integer v2 : new Integer[] { 2, null })
2269	>	{
2270		final CompletableFuture<Integer> f = new CompletableFuture<>();
2271		final CompletableFuture<Integer> g = new CompletableFuture<>();
2272		final IncAction r = new IncAction();
#	Line 2128 | Line 2274 | public class CompletableFutureTest exten
2274
2275		g.complete(v2);
2276		checkCompletedNormally(h, null);
2277	<	assertEquals(r.value, inc(v2));
2277	>	assertEquals(inc(v2), r.value);
2278		f.complete(v1);
2279
2280		checkCompletedNormally(f, v1);
2281		checkCompletedNormally(g, v2);
2282		checkCompletedNormally(h, null);
2283	<	}
2284	<	}
2283	>	}}
2284	>
2285		public void testAcceptEither_normalCompletion3() {
2286		for (ExecutionMode m : ExecutionMode.values())
2287		for (Integer v1 : new Integer[] { 1, null })
2288	<	for (Integer v2 : new Integer[] { 2, null }) {
2289	<
2288	>	for (Integer v2 : new Integer[] { 2, null })
2289	>	{
2290		final CompletableFuture<Integer> f = new CompletableFuture<>();
2291		final CompletableFuture<Integer> g = new CompletableFuture<>();
2292		final IncAction r = new IncAction();
#	Line 2156 | Line 2302 | public class CompletableFutureTest exten
2302		// unspecified behavior
2303		assertTrue(Objects.equals(r.value, inc(v1)) ||
2304		Objects.equals(r.value, inc(v2)));
2305	<	}
2160	<	}
2305	>	}}
2306
2307		/**
2308		* acceptEither result completes exceptionally after exceptional
#	Line 2165 | Line 2310 | public class CompletableFutureTest exten
2310		*/
2311		public void testAcceptEither_exceptionalCompletion1() {
2312		for (ExecutionMode m : ExecutionMode.values())
2313	<	for (Integer v1 : new Integer[] { 1, null }) {
2314	<
2313	>	for (Integer v1 : new Integer[] { 1, null })
2314	>	{
2315		final CompletableFuture<Integer> f = new CompletableFuture<>();
2316		final CompletableFuture<Integer> g = new CompletableFuture<>();
2317		final IncAction r = new IncAction();
#	Line 2181 | Line 2326 | public class CompletableFutureTest exten
2326		checkCompletedNormally(g, v1);
2327		checkCompletedWithWrappedCFException(f, ex);
2328		checkCompletedWithWrappedCFException(h, ex);
2329	<	}
2185	<	}
2329	>	}}
2330
2331		public void testAcceptEither_exceptionalCompletion2() {
2332		for (ExecutionMode m : ExecutionMode.values())
2333	<	for (Integer v1 : new Integer[] { 1, null }) {
2334	<
2333	>	for (Integer v1 : new Integer[] { 1, null })
2334	>	{
2335		final CompletableFuture<Integer> f = new CompletableFuture<>();
2336		final CompletableFuture<Integer> g = new CompletableFuture<>();
2337		final IncAction r = new IncAction();
#	Line 2202 | Line 2346 | public class CompletableFutureTest exten
2346		checkCompletedNormally(f, v1);
2347		checkCompletedWithWrappedCFException(g, ex);
2348		checkCompletedWithWrappedCFException(h, ex);
2349	<	}
2206	<	}
2349	>	}}
2350
2351		public void testAcceptEither_exceptionalCompletion3() {
2352		for (ExecutionMode m : ExecutionMode.values())
2353	<	for (Integer v1 : new Integer[] { 1, null }) {
2354	<
2353	>	for (Integer v1 : new Integer[] { 1, null })
2354	>	{
2355		final CompletableFuture<Integer> f = new CompletableFuture<>();
2356		final CompletableFuture<Integer> g = new CompletableFuture<>();
2357		final IncAction r = new IncAction();
#	Line 2221 | Line 2364 | public class CompletableFutureTest exten
2364		// unspecified behavior
2365		Integer v;
2366		try {
2367	<	assertEquals(h.join(), null);
2367	>	assertNull(h.join());
2368		assertEquals(1, r.invocationCount);
2369		assertEquals(inc(v1), r.value);
2370		} catch (CompletionException ok) {
#	Line 2231 | Line 2374 | public class CompletableFutureTest exten
2374
2375		checkCompletedWithWrappedCFException(g, ex);
2376		checkCompletedNormally(f, v1);
2377	<	}
2235	<	}
2377	>	}}
2378
2379		public void testAcceptEither_exceptionalCompletion4() {
2380		for (ExecutionMode m : ExecutionMode.values())
2381	<	for (Integer v1 : new Integer[] { 1, null }) {
2382	<
2381	>	for (Integer v1 : new Integer[] { 1, null })
2382	>	{
2383		final CompletableFuture<Integer> f = new CompletableFuture<>();
2384		final CompletableFuture<Integer> g = new CompletableFuture<>();
2385		final IncAction r = new IncAction();
#	Line 2250 | Line 2392 | public class CompletableFutureTest exten
2392		// unspecified behavior
2393		Integer v;
2394		try {
2395	<	assertEquals(h.join(), null);
2395	>	assertNull(h.join());
2396		assertEquals(1, r.invocationCount);
2397		assertEquals(inc(v1), r.value);
2398		} catch (CompletionException ok) {
#	Line 2260 | Line 2402 | public class CompletableFutureTest exten
2402
2403		checkCompletedWithWrappedCFException(f, ex);
2404		checkCompletedNormally(g, v1);
2405	<	}
2264	<	}
2405	>	}}
2406
2407		/**
2408		* acceptEither result completes exceptionally if action does
#	Line 2269 | Line 2410 | public class CompletableFutureTest exten
2410		public void testAcceptEither_actionFailed1() {
2411		for (ExecutionMode m : ExecutionMode.values())
2412		for (Integer v1 : new Integer[] { 1, null })
2413	<	for (Integer v2 : new Integer[] { 2, null }) {
2414	<
2413	>	for (Integer v2 : new Integer[] { 2, null })
2414	>	{
2415		final CompletableFuture<Integer> f = new CompletableFuture<>();
2416		final CompletableFuture<Integer> g = new CompletableFuture<>();
2417		final FailingConsumer r = new FailingConsumer();
#	Line 2281 | Line 2422 | public class CompletableFutureTest exten
2422		g.complete(v2);
2423		checkCompletedNormally(f, v1);
2424		checkCompletedNormally(g, v2);
2425	<	}
2285	<	}
2425	>	}}
2426
2427		public void testAcceptEither_actionFailed2() {
2428		for (ExecutionMode m : ExecutionMode.values())
2429		for (Integer v1 : new Integer[] { 1, null })
2430	<	for (Integer v2 : new Integer[] { 2, null }) {
2431	<
2430	>	for (Integer v2 : new Integer[] { 2, null })
2431	>	{
2432		final CompletableFuture<Integer> f = new CompletableFuture<>();
2433		final CompletableFuture<Integer> g = new CompletableFuture<>();
2434		final FailingConsumer r = new FailingConsumer();
#	Line 2299 | Line 2439 | public class CompletableFutureTest exten
2439		f.complete(v1);
2440		checkCompletedNormally(f, v1);
2441		checkCompletedNormally(g, v2);
2442	<	}
2303	<	}
2442	>	}}
2443
2444		/**
2445		* acceptEither result completes exceptionally if either source cancelled
#	Line 2308 | Line 2447 | public class CompletableFutureTest exten
2447		public void testAcceptEither_sourceCancelled1() {
2448		for (ExecutionMode m : ExecutionMode.values())
2449		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2450	<	for (Integer v1 : new Integer[] { 1, null }) {
2451	<
2450	>	for (Integer v1 : new Integer[] { 1, null })
2451	>	{
2452		final CompletableFuture<Integer> f = new CompletableFuture<>();
2453		final CompletableFuture<Integer> g = new CompletableFuture<>();
2454		final IncAction r = new IncAction();
#	Line 2323 | Line 2462 | public class CompletableFutureTest exten
2462		assertEquals(0, r.invocationCount);
2463		checkCompletedNormally(g, v1);
2464		checkCompletedWithWrappedCancellationException(h);
2465	<	}
2327	<	}
2465	>	}}
2466
2467		public void testAcceptEither_sourceCancelled2() {
2468		for (ExecutionMode m : ExecutionMode.values())
2469		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2470	<	for (Integer v1 : new Integer[] { 1, null }) {
2471	<
2470	>	for (Integer v1 : new Integer[] { 1, null })
2471	>	{
2472		final CompletableFuture<Integer> f = new CompletableFuture<>();
2473		final CompletableFuture<Integer> g = new CompletableFuture<>();
2474		final IncAction r = new IncAction();
#	Line 2344 | Line 2482 | public class CompletableFutureTest exten
2482		assertEquals(0, r.invocationCount);
2483		checkCompletedNormally(f, v1);
2484		checkCompletedWithWrappedCancellationException(h);
2485	<	}
2348	<	}
2485	>	}}
2486
2487		public void testAcceptEither_sourceCancelled3() {
2488		for (ExecutionMode m : ExecutionMode.values())
2489		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2490	<	for (Integer v1 : new Integer[] { 1, null }) {
2491	<
2490	>	for (Integer v1 : new Integer[] { 1, null })
2491	>	{
2492		final CompletableFuture<Integer> f = new CompletableFuture<>();
2493		final CompletableFuture<Integer> g = new CompletableFuture<>();
2494		final IncAction r = new IncAction();
#	Line 2363 | Line 2500 | public class CompletableFutureTest exten
2500		// unspecified behavior
2501		Integer v;
2502		try {
2503	<	assertEquals(h.join(), null);
2503	>	assertNull(h.join());
2504		assertEquals(1, r.invocationCount);
2505		assertEquals(inc(v1), r.value);
2506		} catch (CompletionException ok) {
#	Line 2373 | Line 2510 | public class CompletableFutureTest exten
2510
2511		checkCancelled(g);
2512		checkCompletedNormally(f, v1);
2513	<	}
2377	<	}
2513	>	}}
2514
2515		public void testAcceptEither_sourceCancelled4() {
2516		for (ExecutionMode m : ExecutionMode.values())
2517		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2518	<	for (Integer v1 : new Integer[] { 1, null }) {
2519	<
2518	>	for (Integer v1 : new Integer[] { 1, null })
2519	>	{
2520		final CompletableFuture<Integer> f = new CompletableFuture<>();
2521		final CompletableFuture<Integer> g = new CompletableFuture<>();
2522		final IncAction r = new IncAction();
#	Line 2392 | Line 2528 | public class CompletableFutureTest exten
2528		// unspecified behavior
2529		Integer v;
2530		try {
2531	<	assertEquals(h.join(), null);
2531	>	assertNull(h.join());
2532		assertEquals(1, r.invocationCount);
2533		assertEquals(inc(v1), r.value);
2534		} catch (CompletionException ok) {
#	Line 2402 | Line 2538 | public class CompletableFutureTest exten
2538
2539		checkCancelled(f);
2540		checkCompletedNormally(g, v1);
2541	<	}
2406	<	}
2541	>	}}
2542
2543		/**
2544		* runAfterEither result completes normally after normal completion
#	Line 2412 | Line 2547 | public class CompletableFutureTest exten
2547		public void testRunAfterEither_normalCompletion1() {
2548		for (ExecutionMode m : ExecutionMode.values())
2549		for (Integer v1 : new Integer[] { 1, null })
2550	<	for (Integer v2 : new Integer[] { 2, null }) {
2551	<
2550	>	for (Integer v2 : new Integer[] { 2, null })
2551	>	{
2552		final CompletableFuture<Integer> f = new CompletableFuture<>();
2553		final CompletableFuture<Integer> g = new CompletableFuture<>();
2554		final Noop r = new Noop();
#	Line 2428 | Line 2563 | public class CompletableFutureTest exten
2563		checkCompletedNormally(g, v2);
2564		checkCompletedNormally(h, null);
2565		assertEquals(1, r.invocationCount);
2566	<	}
2432	<	}
2566	>	}}
2567
2568		public void testRunAfterEither_normalCompletion2() {
2569		for (ExecutionMode m : ExecutionMode.values())
2570		for (Integer v1 : new Integer[] { 1, null })
2571	<	for (Integer v2 : new Integer[] { 2, null }) {
2572	<
2571	>	for (Integer v2 : new Integer[] { 2, null })
2572	>	{
2573		final CompletableFuture<Integer> f = new CompletableFuture<>();
2574		final CompletableFuture<Integer> g = new CompletableFuture<>();
2575		final Noop r = new Noop();
#	Line 2450 | Line 2584 | public class CompletableFutureTest exten
2584		checkCompletedNormally(g, v2);
2585		checkCompletedNormally(h, null);
2586		assertEquals(1, r.invocationCount);
2587	<	}
2588	<	}
2587	>	}}
2588	>
2589		public void testRunAfterEither_normalCompletion3() {
2590		for (ExecutionMode m : ExecutionMode.values())
2591		for (Integer v1 : new Integer[] { 1, null })
2592	<	for (Integer v2 : new Integer[] { 2, null }) {
2593	<
2592	>	for (Integer v2 : new Integer[] { 2, null })
2593	>	{
2594		final CompletableFuture<Integer> f = new CompletableFuture<>();
2595		final CompletableFuture<Integer> g = new CompletableFuture<>();
2596		final Noop r = new Noop();
#	Line 2469 | Line 2603 | public class CompletableFutureTest exten
2603		checkCompletedNormally(f, v1);
2604		checkCompletedNormally(g, v2);
2605		assertEquals(1, r.invocationCount);
2606	<	}
2473	<	}
2606	>	}}
2607
2608		/**
2609		* runAfterEither result completes exceptionally after exceptional
#	Line 2478 | Line 2611 | public class CompletableFutureTest exten
2611		*/
2612		public void testRunAfterEither_exceptionalCompletion1() {
2613		for (ExecutionMode m : ExecutionMode.values())
2614	<	for (Integer v1 : new Integer[] { 1, null }) {
2615	<
2614	>	for (Integer v1 : new Integer[] { 1, null })
2615	>	{
2616		final CompletableFuture<Integer> f = new CompletableFuture<>();
2617		final CompletableFuture<Integer> g = new CompletableFuture<>();
2618		final Noop r = new Noop();
#	Line 2494 | Line 2627 | public class CompletableFutureTest exten
2627		checkCompletedNormally(g, v1);
2628		checkCompletedWithWrappedCFException(f, ex);
2629		checkCompletedWithWrappedCFException(h, ex);
2630	<	}
2498	<	}
2630	>	}}
2631
2632		public void testRunAfterEither_exceptionalCompletion2() {
2633		for (ExecutionMode m : ExecutionMode.values())
2634	<	for (Integer v1 : new Integer[] { 1, null }) {
2635	<
2634	>	for (Integer v1 : new Integer[] { 1, null })
2635	>	{
2636		final CompletableFuture<Integer> f = new CompletableFuture<>();
2637		final CompletableFuture<Integer> g = new CompletableFuture<>();
2638		final Noop r = new Noop();
#	Line 2515 | Line 2647 | public class CompletableFutureTest exten
2647		checkCompletedNormally(f, v1);
2648		checkCompletedWithWrappedCFException(g, ex);
2649		checkCompletedWithWrappedCFException(h, ex);
2650	<	}
2519	<	}
2650	>	}}
2651
2652		public void testRunAfterEither_exceptionalCompletion3() {
2653		for (ExecutionMode m : ExecutionMode.values())
2654	<	for (Integer v1 : new Integer[] { 1, null }) {
2655	<
2654	>	for (Integer v1 : new Integer[] { 1, null })
2655	>	{
2656		final CompletableFuture<Integer> f = new CompletableFuture<>();
2657		final CompletableFuture<Integer> g = new CompletableFuture<>();
2658		final Noop r = new Noop();
#	Line 2534 | Line 2665 | public class CompletableFutureTest exten
2665		// unspecified behavior
2666		Integer v;
2667		try {
2668	<	assertEquals(h.join(), null);
2668	>	assertNull(h.join());
2669		assertEquals(1, r.invocationCount);
2670		} catch (CompletionException ok) {
2671		checkCompletedWithWrappedCFException(h, ex);
#	Line 2543 | Line 2674 | public class CompletableFutureTest exten
2674
2675		checkCompletedWithWrappedCFException(g, ex);
2676		checkCompletedNormally(f, v1);
2677	<	}
2547	<	}
2677	>	}}
2678
2679		public void testRunAfterEither_exceptionalCompletion4() {
2680		for (ExecutionMode m : ExecutionMode.values())
2681	<	for (Integer v1 : new Integer[] { 1, null }) {
2682	<
2681	>	for (Integer v1 : new Integer[] { 1, null })
2682	>	{
2683		final CompletableFuture<Integer> f = new CompletableFuture<>();
2684		final CompletableFuture<Integer> g = new CompletableFuture<>();
2685		final Noop r = new Noop();
#	Line 2562 | Line 2692 | public class CompletableFutureTest exten
2692		// unspecified behavior
2693		Integer v;
2694		try {
2695	<	assertEquals(h.join(), null);
2695	>	assertNull(h.join());
2696		assertEquals(1, r.invocationCount);
2697		} catch (CompletionException ok) {
2698		checkCompletedWithWrappedCFException(h, ex);
#	Line 2571 | Line 2701 | public class CompletableFutureTest exten
2701
2702		checkCompletedWithWrappedCFException(f, ex);
2703		checkCompletedNormally(g, v1);
2704	<	}
2575	<	}
2704	>	}}
2705
2706		/**
2707		* runAfterEither result completes exceptionally if action does
#	Line 2580 | Line 2709 | public class CompletableFutureTest exten
2709		public void testRunAfterEither_actionFailed1() {
2710		for (ExecutionMode m : ExecutionMode.values())
2711		for (Integer v1 : new Integer[] { 1, null })
2712	<	for (Integer v2 : new Integer[] { 2, null }) {
2713	<
2712	>	for (Integer v2 : new Integer[] { 2, null })
2713	>	{
2714		final CompletableFuture<Integer> f = new CompletableFuture<>();
2715		final CompletableFuture<Integer> g = new CompletableFuture<>();
2716		final FailingNoop r = new FailingNoop();
#	Line 2592 | Line 2721 | public class CompletableFutureTest exten
2721		g.complete(v2);
2722		checkCompletedNormally(f, v1);
2723		checkCompletedNormally(g, v2);
2724	<	}
2596	<	}
2724	>	}}
2725
2726		public void testRunAfterEither_actionFailed2() {
2727		for (ExecutionMode m : ExecutionMode.values())
2728		for (Integer v1 : new Integer[] { 1, null })
2729	<	for (Integer v2 : new Integer[] { 2, null }) {
2730	<
2729	>	for (Integer v2 : new Integer[] { 2, null })
2730	>	{
2731		final CompletableFuture<Integer> f = new CompletableFuture<>();
2732		final CompletableFuture<Integer> g = new CompletableFuture<>();
2733		final FailingNoop r = new FailingNoop();
#	Line 2610 | Line 2738 | public class CompletableFutureTest exten
2738		f.complete(v1);
2739		checkCompletedNormally(f, v1);
2740		checkCompletedNormally(g, v2);
2741	<	}
2614	<	}
2741	>	}}
2742
2743		/**
2744		* runAfterEither result completes exceptionally if either source cancelled
#	Line 2619 | Line 2746 | public class CompletableFutureTest exten
2746		public void testRunAfterEither_sourceCancelled1() {
2747		for (ExecutionMode m : ExecutionMode.values())
2748		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2749	<	for (Integer v1 : new Integer[] { 1, null }) {
2750	<
2749	>	for (Integer v1 : new Integer[] { 1, null })
2750	>	{
2751		final CompletableFuture<Integer> f = new CompletableFuture<>();
2752		final CompletableFuture<Integer> g = new CompletableFuture<>();
2753		final Noop r = new Noop();
#	Line 2634 | Line 2761 | public class CompletableFutureTest exten
2761		assertEquals(0, r.invocationCount);
2762		checkCompletedNormally(g, v1);
2763		checkCompletedWithWrappedCancellationException(h);
2764	<	}
2638	<	}
2764	>	}}
2765
2766		public void testRunAfterEither_sourceCancelled2() {
2767		for (ExecutionMode m : ExecutionMode.values())
2768		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2769	<	for (Integer v1 : new Integer[] { 1, null }) {
2770	<
2769	>	for (Integer v1 : new Integer[] { 1, null })
2770	>	{
2771		final CompletableFuture<Integer> f = new CompletableFuture<>();
2772		final CompletableFuture<Integer> g = new CompletableFuture<>();
2773		final Noop r = new Noop();
#	Line 2655 | Line 2781 | public class CompletableFutureTest exten
2781		assertEquals(0, r.invocationCount);
2782		checkCompletedNormally(f, v1);
2783		checkCompletedWithWrappedCancellationException(h);
2784	<	}
2659	<	}
2784	>	}}
2785
2786		public void testRunAfterEither_sourceCancelled3() {
2787		for (ExecutionMode m : ExecutionMode.values())
2788		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2789	<	for (Integer v1 : new Integer[] { 1, null }) {
2790	<
2789	>	for (Integer v1 : new Integer[] { 1, null })
2790	>	{
2791		final CompletableFuture<Integer> f = new CompletableFuture<>();
2792		final CompletableFuture<Integer> g = new CompletableFuture<>();
2793		final Noop r = new Noop();
#	Line 2674 | Line 2799 | public class CompletableFutureTest exten
2799		// unspecified behavior
2800		Integer v;
2801		try {
2802	<	assertEquals(h.join(), null);
2802	>	assertNull(h.join());
2803		assertEquals(1, r.invocationCount);
2804		} catch (CompletionException ok) {
2805		checkCompletedWithWrappedCancellationException(h);
#	Line 2683 | Line 2808 | public class CompletableFutureTest exten
2808
2809		checkCancelled(g);
2810		checkCompletedNormally(f, v1);
2811	<	}
2687	<	}
2811	>	}}
2812
2813		public void testRunAfterEither_sourceCancelled4() {
2814		for (ExecutionMode m : ExecutionMode.values())
2815		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2816	<	for (Integer v1 : new Integer[] { 1, null }) {
2817	<
2816	>	for (Integer v1 : new Integer[] { 1, null })
2817	>	{
2818		final CompletableFuture<Integer> f = new CompletableFuture<>();
2819		final CompletableFuture<Integer> g = new CompletableFuture<>();
2820		final Noop r = new Noop();
#	Line 2702 | Line 2826 | public class CompletableFutureTest exten
2826		// unspecified behavior
2827		Integer v;
2828		try {
2829	<	assertEquals(h.join(), null);
2829	>	assertNull(h.join());
2830		assertEquals(1, r.invocationCount);
2831		} catch (CompletionException ok) {
2832		checkCompletedWithWrappedCancellationException(h);
#	Line 2711 | Line 2835 | public class CompletableFutureTest exten
2835
2836		checkCancelled(f);
2837		checkCompletedNormally(g, v1);
2838	<	}
2715	<	}
2838	>	}}
2839
2840		/**
2841		* thenCompose result completes normally after normal completion of source
2842		*/
2843		public void testThenCompose_normalCompletion1() {
2844		for (ExecutionMode m : ExecutionMode.values())
2845	<	for (Integer v1 : new Integer[] { 1, null }) {
2846	<
2845	>	for (Integer v1 : new Integer[] { 1, null })
2846	>	{
2847		final CompletableFuture<Integer> f = new CompletableFuture<>();
2848		final CompletableFutureInc r = new CompletableFutureInc();
2849		final CompletableFuture<Integer> g = f.thenCompose(r);
#	Line 2728 | Line 2851 | public class CompletableFutureTest exten
2851		checkCompletedNormally(g, inc(v1));
2852		checkCompletedNormally(f, v1);
2853		assertEquals(1, r.invocationCount);
2854	<	}
2732	<	}
2854	>	}}
2855
2856		public void testThenCompose_normalCompletion2() {
2857		for (ExecutionMode m : ExecutionMode.values())
2858	<	for (Integer v1 : new Integer[] { 1, null }) {
2859	<
2858	>	for (Integer v1 : new Integer[] { 1, null })
2859	>	{
2860		final CompletableFuture<Integer> f = new CompletableFuture<>();
2861		final CompletableFutureInc r = new CompletableFutureInc();
2862		f.complete(v1);
#	Line 2742 | Line 2864 | public class CompletableFutureTest exten
2864		checkCompletedNormally(g, inc(v1));
2865		checkCompletedNormally(f, v1);
2866		assertEquals(1, r.invocationCount);
2867	<	}
2746	<	}
2867	>	}}
2868
2869		/**
2870		* thenCompose result completes exceptionally after exceptional
2871		* completion of source
2872		*/
2873		public void testThenCompose_exceptionalCompletion1() {
2874	<	for (ExecutionMode m : ExecutionMode.values()) {
2875	<
2874	>	for (ExecutionMode m : ExecutionMode.values())
2875	>	{
2876		final CFException ex = new CFException();
2877		final CompletableFutureInc r = new CompletableFutureInc();
2878		final CompletableFuture<Integer> f = new CompletableFuture<>();
#	Line 2759 | Line 2880 | public class CompletableFutureTest exten
2880		f.completeExceptionally(ex);
2881		checkCompletedWithWrappedCFException(g, ex);
2882		checkCompletedWithWrappedCFException(f, ex);
2883	<	}
2763	<	}
2883	>	}}
2884
2885		public void testThenCompose_exceptionalCompletion2() {
2886	<	for (ExecutionMode m : ExecutionMode.values()) {
2887	<
2886	>	for (ExecutionMode m : ExecutionMode.values())
2887	>	{
2888		final CFException ex = new CFException();
2889		final CompletableFuture<Integer> f = new CompletableFuture<>();
2890		f.completeExceptionally(ex);
#	Line 2772 | Line 2892 | public class CompletableFutureTest exten
2892		final CompletableFuture<Integer> g = f.thenCompose(r);
2893		checkCompletedWithWrappedCFException(g, ex);
2894		checkCompletedWithWrappedCFException(f, ex);
2895	<	}
2776	<	}
2895	>	}}
2896
2897		/**
2898		* thenCompose result completes exceptionally if action does
2899		*/
2900		public void testThenCompose_actionFailed1() {
2901		for (ExecutionMode m : ExecutionMode.values())
2902	<	for (Integer v1 : new Integer[] { 1, null }) {
2903	<
2902	>	for (Integer v1 : new Integer[] { 1, null })
2903	>	{
2904		final CompletableFuture<Integer> f = new CompletableFuture<>();
2905		final FailingCompletableFutureFunction r
2906		= new FailingCompletableFutureFunction();
#	Line 2789 | Line 2908 | public class CompletableFutureTest exten
2908		f.complete(v1);
2909		checkCompletedWithWrappedCFException(g);
2910		checkCompletedNormally(f, v1);
2911	<	}
2793	<	}
2911	>	}}
2912
2913		public void testThenCompose_actionFailed2() {
2914		for (ExecutionMode m : ExecutionMode.values())
2915	<	for (Integer v1 : new Integer[] { 1, null }) {
2916	<
2915	>	for (Integer v1 : new Integer[] { 1, null })
2916	>	{
2917		final CompletableFuture<Integer> f = new CompletableFuture<>();
2918		f.complete(v1);
2919		final FailingCompletableFutureFunction r
#	Line 2803 | Line 2921 | public class CompletableFutureTest exten
2921		final CompletableFuture<Integer> g = f.thenCompose(r);
2922		checkCompletedWithWrappedCFException(g);
2923		checkCompletedNormally(f, v1);
2924	<	}
2807	<	}
2924	>	}}
2925
2926		/**
2927		* thenCompose result completes exceptionally if source cancelled
2928		*/
2929		public void testThenCompose_sourceCancelled1() {
2930		for (ExecutionMode m : ExecutionMode.values())
2931	<	for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {
2932	<
2931	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2932	>	{
2933		final CompletableFuture<Integer> f = new CompletableFuture<>();
2934		final CompletableFutureInc r = new CompletableFutureInc();
2935		final CompletableFuture<Integer> g = f.thenCompose(r);
2936		assertTrue(f.cancel(mayInterruptIfRunning));
2937		checkCompletedWithWrappedCancellationException(g);
2938		checkCancelled(f);
2939	<	}
2823	<	}
2939	>	}}
2940
2941		public void testThenCompose_sourceCancelled2() {
2942		for (ExecutionMode m : ExecutionMode.values())
2943	<	for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {
2944	<
2943	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2944	>	{
2945		final CompletableFuture<Integer> f = new CompletableFuture<>();
2946		assertTrue(f.cancel(mayInterruptIfRunning));
2947		final CompletableFutureInc r = new CompletableFutureInc();
2948		final CompletableFuture<Integer> g = f.thenCompose(r);
2949		checkCompletedWithWrappedCancellationException(g);
2950		checkCancelled(f);
2951	<	}
2836	<	}
2951	>	}}
2952
2953		// asyncs
2954
#	Line 3328 | Line 3443 | public class CompletableFutureTest exten
3443		* source result.
3444		*/
3445		public void testWhenComplete_normalCompletion1() {
3331	–	for (boolean createIncomplete : new boolean[] { true, false })
3446		for (ExecutionMode m : ExecutionMode.values())
3447	<	for (Integer v1 : new Integer[] { 1, null }) {
3448	<
3449	<	final AtomicInteger a = new AtomicInteger();
3447	>	for (boolean createIncomplete : new boolean[] { true, false })
3448	>	for (Integer v1 : new Integer[] { 1, null })
3449	>	{
3450	>	final AtomicInteger a = new AtomicInteger(0);
3451		final CompletableFuture<Integer> f = new CompletableFuture<>();
3452		if (!createIncomplete) f.complete(v1);
3453	<	final CompletableFuture<Integer> g =
3454	<	m.whenComplete(f,
3455	<	(Integer x, Throwable t) -> {
3456	<	threadAssertSame(x, v1);
3457	<	threadAssertNull(t);
3458	<	a.getAndIncrement();
3459	<	});
3453	>	final CompletableFuture<Integer> g = m.whenComplete
3454	>	(f,
3455	>	(Integer x, Throwable t) -> {
3456	>	threadAssertSame(x, v1);
3457	>	threadAssertNull(t);
3458	>	a.getAndIncrement();
3459	>	});
3460		if (createIncomplete) f.complete(v1);
3461	<	checkCompletedNormally(f, v1);
3461	>
3462		checkCompletedNormally(g, v1);
3463	<	assertEquals(a.get(), 1);
3464	<	}
3465	<	}
3463	>	checkCompletedNormally(f, v1);
3464	>	assertEquals(1, a.get());
3465	>	}}
3466
3467		/**
3468		* whenComplete action executes on exceptional completion, propagating
3469		* source result.
3470		*/
3471		public void testWhenComplete_exceptionalCompletion() {
3357	–	for (boolean createIncomplete : new boolean[] { true, false })
3472		for (ExecutionMode m : ExecutionMode.values())
3473	<	for (Integer v1 : new Integer[] { 1, null }) {
3474	<
3475	<	final AtomicInteger a = new AtomicInteger();
3473	>	for (boolean createIncomplete : new boolean[] { true, false })
3474	>	for (Integer v1 : new Integer[] { 1, null })
3475	>	{
3476	>	final AtomicInteger a = new AtomicInteger(0);
3477		final CFException ex = new CFException();
3478		final CompletableFuture<Integer> f = new CompletableFuture<>();
3479		if (!createIncomplete) f.completeExceptionally(ex);
#	Line 3372 | Line 3487 | public class CompletableFutureTest exten
3487		if (createIncomplete) f.completeExceptionally(ex);
3488		checkCompletedWithWrappedCFException(f, ex);
3489		checkCompletedWithWrappedCFException(g, ex);
3490	<	assertEquals(a.get(), 1);
3491	<	}
3492	<	}
3490	>	assertEquals(1, a.get());
3491	>	}}
3492	>
3493	>	/**
3494	>	* whenComplete action executes on cancelled source, propagating
3495	>	* CancellationException.
3496	>	*/
3497	>	public void testWhenComplete_sourceCancelled() {
3498	>	for (ExecutionMode m : ExecutionMode.values())
3499	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3500	>	for (boolean createIncomplete : new boolean[] { true, false })
3501	>	{
3502	>	final AtomicInteger a = new AtomicInteger(0);
3503	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
3504	>	if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
3505	>	final CompletableFuture<Integer> g = m.whenComplete
3506	>	(f,
3507	>	(Integer x, Throwable t) -> {
3508	>	threadAssertNull(x);
3509	>	threadAssertTrue(t instanceof CancellationException);
3510	>	a.getAndIncrement();
3511	>	});
3512	>	if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
3513	>
3514	>	//try { g.join(); } catch (Throwable t) { throw new Error(t); }
3515	>	checkCompletedWithWrappedCancellationException(g);
3516	>	checkCancelled(f);
3517	>	assertEquals(1, a.get());
3518	>	}}
3519
3520		/**
3521		* If a whenComplete action throws an exception when triggered by
#	Line 3383 | Line 3524 | public class CompletableFutureTest exten
3524		public void testWhenComplete_actionFailed() {
3525		for (boolean createIncomplete : new boolean[] { true, false })
3526		for (ExecutionMode m : ExecutionMode.values())
3527	<	for (Integer v1 : new Integer[] { 1, null }) {
3528	<
3527	>	for (Integer v1 : new Integer[] { 1, null })
3528	>	{
3529	>	final AtomicInteger a = new AtomicInteger(0);
3530		final CFException ex = new CFException();
3531		final CompletableFuture<Integer> f = new CompletableFuture<>();
3532		if (!createIncomplete) f.complete(v1);
#	Line 3393 | Line 3535 | public class CompletableFutureTest exten
3535		(Integer x, Throwable t) -> {
3536		threadAssertSame(x, v1);
3537		threadAssertNull(t);
3538	+	a.getAndIncrement();
3539		throw ex;
3540		});
3541		if (createIncomplete) f.complete(v1);
3542		checkCompletedNormally(f, v1);
3543		checkCompletedWithWrappedCFException(g, ex);
3544	<	}
3545	<	}
3544	>	assertEquals(1, a.get());
3545	>	}}
3546
3547		/**
3548		* If a whenComplete action throws an exception when triggered by
#	Line 3409 | Line 3552 | public class CompletableFutureTest exten
3552		public void testWhenComplete_actionFailedSourceFailed() {
3553		for (boolean createIncomplete : new boolean[] { true, false })
3554		for (ExecutionMode m : ExecutionMode.values())
3555	<	for (Integer v1 : new Integer[] { 1, null }) {
3556	<
3555	>	for (Integer v1 : new Integer[] { 1, null })
3556	>	{
3557	>	final AtomicInteger a = new AtomicInteger(0);
3558		final CFException ex1 = new CFException();
3559		final CFException ex2 = new CFException();
3560		final CompletableFuture<Integer> f = new CompletableFuture<>();
#	Line 3421 | Line 3565 | public class CompletableFutureTest exten
3565		(Integer x, Throwable t) -> {
3566		threadAssertSame(t, ex1);
3567		threadAssertNull(x);
3568	+	a.getAndIncrement();
3569		throw ex2;
3570		});
3571		if (createIncomplete) f.completeExceptionally(ex1);
3572
3573		checkCompletedWithWrappedCFException(f, ex1);
3574		checkCompletedWithWrappedCFException(g, ex1);
3575	<	}
3576	<	}
3432	<
3433	<	/**
3434	<	* handleAsync action completes normally with function value on
3435	<	* either normal or exceptional completion of source
3436	<	*/
3437	<	public void testHandleAsync() {
3438	<	CompletableFuture<Integer> f, g;
3439	<	IntegerHandler r;
3440	<
3441	<	f = new CompletableFuture<>();
3442	<	g = f.handleAsync(r = new IntegerHandler());
3443	<	assertEquals(0, r.invocationCount);
3444	<	f.completeExceptionally(new CFException());
3445	<	checkCompletedWithWrappedCFException(f);
3446	<	checkCompletedNormally(g, three);
3447	<	assertEquals(1, r.invocationCount);
3448	<
3449	<	f = new CompletableFuture<>();
3450	<	g = f.handleAsync(r = new IntegerHandler());
3451	<	assertEquals(0, r.invocationCount);
3452	<	f.completeExceptionally(new CFException());
3453	<	checkCompletedWithWrappedCFException(f);
3454	<	checkCompletedNormally(g, three);
3455	<	assertEquals(1, r.invocationCount);
3456	<
3457	<	f = new CompletableFuture<>();
3458	<	g = f.handleAsync(r = new IntegerHandler());
3459	<	assertEquals(0, r.invocationCount);
3460	<	f.complete(one);
3461	<	checkCompletedNormally(f, one);
3462	<	checkCompletedNormally(g, two);
3463	<	assertEquals(1, r.invocationCount);
3464	<
3465	<	f = new CompletableFuture<>();
3466	<	g = f.handleAsync(r = new IntegerHandler());
3467	<	assertEquals(0, r.invocationCount);
3468	<	f.complete(one);
3469	<	checkCompletedNormally(f, one);
3470	<	checkCompletedNormally(g, two);
3471	<	assertEquals(1, r.invocationCount);
3472	<	}
3473	<
3474	<	/**
3475	<	* handleAsync action with Executor completes normally with
3476	<	* function value on either normal or exceptional completion of
3477	<	* source
3478	<	*/
3479	<	public void testHandleAsync2() {
3480	<	CompletableFuture<Integer> f, g;
3481	<	ThreadExecutor exec = new ThreadExecutor();
3482	<	IntegerHandler r;
3483	<
3484	<	f = new CompletableFuture<>();
3485	<	g = f.handleAsync(r = new IntegerHandler(), exec);
3486	<	assertEquals(0, r.invocationCount);
3487	<	f.completeExceptionally(new CFException());
3488	<	checkCompletedWithWrappedCFException(f);
3489	<	checkCompletedNormally(g, three);
3490	<	assertEquals(1, r.invocationCount);
3491	<
3492	<	f = new CompletableFuture<>();
3493	<	g = f.handleAsync(r = new IntegerHandler(), exec);
3494	<	assertEquals(0, r.invocationCount);
3495	<	f.completeExceptionally(new CFException());
3496	<	checkCompletedWithWrappedCFException(f);
3497	<	checkCompletedNormally(g, three);
3498	<	assertEquals(1, r.invocationCount);
3499	<
3500	<	f = new CompletableFuture<>();
3501	<	g = f.handleAsync(r = new IntegerHandler(), exec);
3502	<	assertEquals(0, r.invocationCount);
3503	<	f.complete(one);
3504	<	checkCompletedNormally(f, one);
3505	<	checkCompletedNormally(g, two);
3506	<	assertEquals(1, r.invocationCount);
3507	<
3508	<	f = new CompletableFuture<>();
3509	<	g = f.handleAsync(r = new IntegerHandler(), exec);
3510	<	assertEquals(0, r.invocationCount);
3511	<	f.complete(one);
3512	<	checkCompletedNormally(f, one);
3513	<	checkCompletedNormally(g, two);
3514	<	assertEquals(1, r.invocationCount);
3515	<	}
3575	>	assertEquals(1, a.get());
3576	>	}}
3577
3578		}

Diff Legend

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