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.39 by jsr166, Mon Jun 2 00:46:52 2014 UTC vs.
Revision 1.49 by jsr166, Mon Jun 2 19:20:51 2014 UTC

#	Line 17 | Line 17 | import java.util.concurrent.Future;
17		import java.util.concurrent.CompletableFuture;
18		import java.util.concurrent.CompletionException;
19		import java.util.concurrent.CompletionStage;
20	+	import java.util.concurrent.ForkJoinPool;
21	+	import java.util.concurrent.ForkJoinTask;
22		import java.util.concurrent.TimeoutException;
23		import java.util.concurrent.atomic.AtomicInteger;
24		import static java.util.concurrent.TimeUnit.MILLISECONDS;
#	Line 247 | Line 249 | public class CompletableFutureTest exten
249		f = new CompletableFuture<>();
250		f.obtrudeValue(three);
251		checkCompletedNormally(f, three);
252	+	f.obtrudeValue(null);
253	+	checkCompletedNormally(f, null);
254		f = new CompletableFuture<>();
255		f.completeExceptionally(new CFException());
256		f.obtrudeValue(four);
#	Line 279 | Line 283 | public class CompletableFutureTest exten
283		*/
284		public void testGetNumberOfDependents() {
285		CompletableFuture<Integer> f = new CompletableFuture<>();
286	<	assertEquals(f.getNumberOfDependents(), 0);
286	>	assertEquals(0, f.getNumberOfDependents());
287		CompletableFuture g = f.thenRun(new Noop());
288	<	assertEquals(f.getNumberOfDependents(), 1);
289	<	assertEquals(g.getNumberOfDependents(), 0);
288	>	assertEquals(1, f.getNumberOfDependents());
289	>	assertEquals(0, g.getNumberOfDependents());
290		CompletableFuture h = f.thenRun(new Noop());
291	<	assertEquals(f.getNumberOfDependents(), 2);
291	>	assertEquals(2, f.getNumberOfDependents());
292		f.complete(1);
293		checkCompletedNormally(g, null);
294	<	assertEquals(f.getNumberOfDependents(), 0);
295	<	assertEquals(g.getNumberOfDependents(), 0);
294	>	assertEquals(0, f.getNumberOfDependents());
295	>	assertEquals(0, g.getNumberOfDependents());
296		}
297
298		/**
#	Line 339 | Line 343 | public class CompletableFutureTest exten
343		static final class IncAction implements Consumer<Integer> {
344		int invocationCount = 0;
345		Integer value;
342	–	public boolean ran() { return invocationCount == 1; }
346		public void accept(Integer x) {
347		invocationCount++;
348		value = inc(x);
#	Line 348 | Line 351 | public class CompletableFutureTest exten
351		static final class IncFunction implements Function<Integer,Integer> {
352		int invocationCount = 0;
353		Integer value;
351	–	public boolean ran() { return invocationCount == 1; }
354		public Integer apply(Integer x) {
355		invocationCount++;
356		return value = inc(x);
#	Line 358 | Line 360 | public class CompletableFutureTest exten
360		int invocationCount = 0;
361		Integer value;
362		// Check this action was invoked exactly once when result is computed.
361	–	public boolean ran() { return invocationCount == 1; }
363		public void accept(Integer x, Integer y) {
364		invocationCount++;
365		value = subtract(x, y);
#	Line 368 | Line 369 | public class CompletableFutureTest exten
369		int invocationCount = 0;
370		Integer value;
371		// Check this action was invoked exactly once when result is computed.
371	–	public boolean ran() { return invocationCount == 1; }
372		public Integer apply(Integer x, Integer y) {
373		invocationCount++;
374		return value = subtract(x, y);
375		}
376		}
377		static final class Noop implements Runnable {
378	<	boolean ran;
379	<	public void run() { ran = true; }
378	>	int invocationCount = 0;
379	>	public void run() {
380	>	invocationCount++;
381	>	}
382		}
383
384		static final class FailingSupplier implements Supplier<Integer> {
385	<	boolean ran;
386	<	public Integer get() { ran = true; throw new CFException(); }
385	>	int invocationCount = 0;
386	>	public Integer get() {
387	>	invocationCount++;
388	>	throw new CFException();
389	>	}
390		}
391		static final class FailingConsumer implements Consumer<Integer> {
392	<	boolean ran;
393	<	public void accept(Integer x) { ran = true; throw new CFException(); }
392	>	int invocationCount = 0;
393	>	public void accept(Integer x) {
394	>	invocationCount++;
395	>	throw new CFException();
396	>	}
397		}
398		static final class FailingBiConsumer implements BiConsumer<Integer, Integer> {
399	<	boolean ran;
400	<	public void accept(Integer x, Integer y) { ran = true; throw new CFException(); }
399	>	int invocationCount = 0;
400	>	public void accept(Integer x, Integer y) {
401	>	invocationCount++;
402	>	throw new CFException();
403	>	}
404		}
405		static final class FailingFunction implements Function<Integer, Integer> {
406	<	boolean ran;
407	<	public Integer apply(Integer x) { ran = true; throw new CFException(); }
406	>	int invocationCount = 0;
407	>	public Integer apply(Integer x) {
408	>	invocationCount++;
409	>	throw new CFException();
410	>	}
411		}
412		static final class FailingBiFunction implements BiFunction<Integer, Integer, Integer> {
413	<	boolean ran;
414	<	public Integer apply(Integer x, Integer y) { ran = true; throw new CFException(); }
413	>	int invocationCount = 0;
414	>	public Integer apply(Integer x, Integer y) {
415	>	invocationCount++;
416	>	throw new CFException();
417	>	}
418		}
419		static final class FailingNoop implements Runnable {
420	<	boolean ran;
421	<	public void run() { ran = true; throw new CFException(); }
420	>	int invocationCount = 0;
421	>	public void run() {
422	>	invocationCount++;
423	>	throw new CFException();
424	>	}
425		}
426
427		static final class CompletableFutureInc
428		implements Function<Integer, CompletableFuture<Integer>> {
429	<	boolean ran;
429	>	int invocationCount = 0;
430		public CompletableFuture<Integer> apply(Integer x) {
431	<	ran = true;
431	>	invocationCount++;
432		CompletableFuture<Integer> f = new CompletableFuture<>();
433	<	f.complete(Integer.valueOf(x.intValue() + 1));
433	>	f.complete(inc(x));
434		return f;
435		}
436		}
437
438		static final class FailingCompletableFutureFunction
439		implements Function<Integer, CompletableFuture<Integer>> {
440	<	boolean ran;
440	>	int invocationCount = 0;
441		public CompletableFuture<Integer> apply(Integer x) {
442	<	ran = true; throw new CFException();
442	>	invocationCount++;
443	>	throw new CFException();
444		}
445		}
446
#	Line 433 | Line 454 | public class CompletableFutureTest exten
454		}
455		}
456
436	–	static final class ExceptionToInteger implements Function<Throwable, Integer> {
437	–	public Integer apply(Throwable x) { return Integer.valueOf(3); }
438	–	}
439	–
440	–	static final class IntegerHandler implements BiFunction<Integer, Throwable, Integer> {
441	–	boolean ran;
442	–	public Integer apply(Integer x, Throwable t) {
443	–	ran = true;
444	–	return (t == null) ? two : three;
445	–	}
446	–	}
447	–
457		/**
458		* Permits the testing of parallel code for the 3 different
459		* execution modes without repeating all the testing code.
460		*/
461		enum ExecutionMode {
462		DEFAULT {
463	+	public void checkExecutionMode() {
464	+	assertNull(ForkJoinTask.getPool());
465	+	}
466	+	public <T> CompletableFuture<Void> thenRun
467	+	(CompletableFuture<T> f, Runnable a) {
468	+	return f.thenRun(a);
469	+	}
470	+	public <T> CompletableFuture<Void> thenAccept
471	+	(CompletableFuture<T> f, Consumer<? super T> a) {
472	+	return f.thenAccept(a);
473	+	}
474	+	public <T,U> CompletableFuture<U> thenApply
475	+	(CompletableFuture<T> f, Function<? super T,U> a) {
476	+	return f.thenApply(a);
477	+	}
478	+	public <T,U> CompletableFuture<U> thenCompose
479	+	(CompletableFuture<T> f,
480	+	Function<? super T,? extends CompletionStage<U>> a) {
481	+	return f.thenCompose(a);
482	+	}
483	+	public <T,U> CompletableFuture<U> handle
484	+	(CompletableFuture<T> f,
485	+	BiFunction<? super T,Throwable,? extends U> a) {
486	+	return f.handle(a);
487	+	}
488	+	public <T> CompletableFuture<T> whenComplete
489	+	(CompletableFuture<T> f,
490	+	BiConsumer<? super T,? super Throwable> a) {
491	+	return f.whenComplete(a);
492	+	}
493		public <T,U> CompletableFuture<Void> runAfterBoth
494		(CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
495		return f.runAfterBoth(g, a);
#	Line 467 | Line 506 | public class CompletableFutureTest exten
506		BiFunction<? super T,? super U,? extends V> a) {
507		return f.thenCombine(g, a);
508		}
509	<	public <T,U> CompletableFuture<U> applyToEither
509	>	public <T> CompletableFuture<Void> runAfterEither
510		(CompletableFuture<T> f,
511	<	CompletionStage<? extends T> g,
512	<	Function<? super T,U> a) {
513	<	return f.applyToEither(g, a);
511	>	CompletionStage<?> g,
512	>	java.lang.Runnable a) {
513	>	return f.runAfterEither(g, a);
514		}
515		public <T> CompletableFuture<Void> acceptEither
516		(CompletableFuture<T> f,
#	Line 479 | Line 518 | public class CompletableFutureTest exten
518		Consumer<? super T> a) {
519		return f.acceptEither(g, a);
520		}
521	<	public <T> CompletableFuture<Void> runAfterEither
521	>	public <T,U> CompletableFuture<U> applyToEither
522		(CompletableFuture<T> f,
523	<	CompletionStage<?> g,
524	<	java.lang.Runnable a) {
525	<	return f.runAfterEither(g, a);
523	>	CompletionStage<? extends T> g,
524	>	Function<? super T,U> a) {
525	>	return f.applyToEither(g, a);
526	>	}
527	>	},
528	>
529	>	ASYNC {
530	>	public void checkExecutionMode() {
531	>	assertSame(ForkJoinPool.commonPool(),
532	>	ForkJoinTask.getPool());
533	>	}
534	>	public <T> CompletableFuture<Void> thenRun
535	>	(CompletableFuture<T> f, Runnable a) {
536	>	return f.thenRunAsync(a);
537	>	}
538	>	public <T> CompletableFuture<Void> thenAccept
539	>	(CompletableFuture<T> f, Consumer<? super T> a) {
540	>	return f.thenAcceptAsync(a);
541	>	}
542	>	public <T,U> CompletableFuture<U> thenApply
543	>	(CompletableFuture<T> f, Function<? super T,U> a) {
544	>	return f.thenApplyAsync(a);
545		}
546		public <T,U> CompletableFuture<U> thenCompose
547		(CompletableFuture<T> f,
548		Function<? super T,? extends CompletionStage<U>> a) {
549	<	return f.thenCompose(a);
549	>	return f.thenComposeAsync(a);
550	>	}
551	>	public <T,U> CompletableFuture<U> handle
552	>	(CompletableFuture<T> f,
553	>	BiFunction<? super T,Throwable,? extends U> a) {
554	>	return f.handleAsync(a);
555		}
556		public <T> CompletableFuture<T> whenComplete
557		(CompletableFuture<T> f,
558		BiConsumer<? super T,? super Throwable> a) {
559	<	return f.whenComplete(a);
559	>	return f.whenCompleteAsync(a);
560		}
498	–	},
499	–
500	–	//             /** Experimental way to do more testing */
501	–	//         REVERSE_DEFAULT {
502	–	//             public <T,U> CompletableFuture<Void> runAfterBoth
503	–	//                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
504	–	//                 return g.runAfterBoth(f, a);
505	–	//             }
506	–	//             public <T,U> CompletableFuture<Void> thenAcceptBoth
507	–	//                 (CompletableFuture<T> f,
508	–	//                  CompletionStage<? extends U> g,
509	–	//                  BiConsumer<? super T,? super U> a) {
510	–	//                 return DEFAULT.thenAcceptBoth(f, g, a);
511	–	//             }
512	–	//         },
513	–
514	–	DEFAULT_ASYNC {
561		public <T,U> CompletableFuture<Void> runAfterBoth
562		(CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
563		return f.runAfterBothAsync(g, a);
#	Line 528 | Line 574 | public class CompletableFutureTest exten
574		BiFunction<? super T,? super U,? extends V> a) {
575		return f.thenCombineAsync(g, a);
576		}
577	<	public <T,U> CompletableFuture<U> applyToEither
577	>	public <T> CompletableFuture<Void> runAfterEither
578		(CompletableFuture<T> f,
579	<	CompletionStage<? extends T> g,
580	<	Function<? super T,U> a) {
581	<	return f.applyToEitherAsync(g, a);
579	>	CompletionStage<?> g,
580	>	java.lang.Runnable a) {
581	>	return f.runAfterEitherAsync(g, a);
582		}
583		public <T> CompletableFuture<Void> acceptEither
584		(CompletableFuture<T> f,
#	Line 540 | Line 586 | public class CompletableFutureTest exten
586		Consumer<? super T> a) {
587		return f.acceptEitherAsync(g, a);
588		}
589	<	public <T> CompletableFuture<Void> runAfterEither
589	>	public <T,U> CompletableFuture<U> applyToEither
590		(CompletableFuture<T> f,
591	<	CompletionStage<?> g,
592	<	java.lang.Runnable a) {
593	<	return f.runAfterEitherAsync(g, a);
591	>	CompletionStage<? extends T> g,
592	>	Function<? super T,U> a) {
593	>	return f.applyToEitherAsync(g, a);
594	>	}
595	>	},
596	>
597	>	EXECUTOR {
598	>	public void checkExecutionMode() {
599	>	//TODO
600	>	}
601	>	public <T> CompletableFuture<Void> thenRun
602	>	(CompletableFuture<T> f, Runnable a) {
603	>	return f.thenRunAsync(a, new ThreadExecutor());
604	>	}
605	>	public <T> CompletableFuture<Void> thenAccept
606	>	(CompletableFuture<T> f, Consumer<? super T> a) {
607	>	return f.thenAcceptAsync(a, new ThreadExecutor());
608	>	}
609	>	public <T,U> CompletableFuture<U> thenApply
610	>	(CompletableFuture<T> f, Function<? super T,U> a) {
611	>	return f.thenApplyAsync(a, new ThreadExecutor());
612		}
613		public <T,U> CompletableFuture<U> thenCompose
614		(CompletableFuture<T> f,
615		Function<? super T,? extends CompletionStage<U>> a) {
616	<	return f.thenComposeAsync(a);
616	>	return f.thenComposeAsync(a, new ThreadExecutor());
617	>	}
618	>	public <T,U> CompletableFuture<U> handle
619	>	(CompletableFuture<T> f,
620	>	BiFunction<? super T,Throwable,? extends U> a) {
621	>	return f.handleAsync(a, new ThreadExecutor());
622		}
623		public <T> CompletableFuture<T> whenComplete
624		(CompletableFuture<T> f,
625		BiConsumer<? super T,? super Throwable> a) {
626	<	return f.whenCompleteAsync(a);
626	>	return f.whenCompleteAsync(a, new ThreadExecutor());
627		}
559	–	},
560	–
561	–	//         REVERSE_DEFAULT_ASYNC {
562	–	//             public <T,U> CompletableFuture<Void> runAfterBoth
563	–	//                 (CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
564	–	//                 return f.runAfterBothAsync(g, a);
565	–	//             }
566	–	//             public <T,U> CompletableFuture<Void> thenAcceptBoth
567	–	//                 (CompletableFuture<T> f,
568	–	//                  CompletionStage<? extends U> g,
569	–	//                  BiConsumer<? super T,? super U> a) {
570	–	//                 return DEFAULT_ASYNC.thenAcceptBoth(f, g, a);
571	–	//             }
572	–	//         },
573	–
574	–	EXECUTOR {
628		public <T,U> CompletableFuture<Void> runAfterBoth
629		(CompletableFuture<T> f, CompletableFuture<U> g, Runnable a) {
630		return f.runAfterBothAsync(g, a, new ThreadExecutor());
#	Line 588 | Line 641 | public class CompletableFutureTest exten
641		BiFunction<? super T,? super U,? extends V> a) {
642		return f.thenCombineAsync(g, a, new ThreadExecutor());
643		}
591	–	public <T,U> CompletableFuture<U> applyToEither
592	–	(CompletableFuture<T> f,
593	–	CompletionStage<? extends T> g,
594	–	Function<? super T,U> a) {
595	–	return f.applyToEitherAsync(g, a, new ThreadExecutor());
596	–	}
597	–	public <T> CompletableFuture<Void> acceptEither
598	–	(CompletableFuture<T> f,
599	–	CompletionStage<? extends T> g,
600	–	Consumer<? super T> a) {
601	–	return f.acceptEitherAsync(g, a, new ThreadExecutor());
602	–	}
644		public <T> CompletableFuture<Void> runAfterEither
645		(CompletableFuture<T> f,
646		CompletionStage<?> g,
647		java.lang.Runnable a) {
648		return f.runAfterEitherAsync(g, a, new ThreadExecutor());
649		}
650	<	public <T,U> CompletableFuture<U> thenCompose
650	>	public <T> CompletableFuture<Void> acceptEither
651		(CompletableFuture<T> f,
652	<	Function<? super T,? extends CompletionStage<U>> a) {
653	<	return f.thenComposeAsync(a, new ThreadExecutor());
652	>	CompletionStage<? extends T> g,
653	>	Consumer<? super T> a) {
654	>	return f.acceptEitherAsync(g, a, new ThreadExecutor());
655		}
656	<	public <T> CompletableFuture<T> whenComplete
656	>	public <T,U> CompletableFuture<U> applyToEither
657		(CompletableFuture<T> f,
658	<	BiConsumer<? super T,? super Throwable> a) {
659	<	return f.whenCompleteAsync(a, new ThreadExecutor());
658	>	CompletionStage<? extends T> g,
659	>	Function<? super T,U> a) {
660	>	return f.applyToEitherAsync(g, a, new ThreadExecutor());
661		}
662		};
663
664	+	public abstract void checkExecutionMode();
665	+	public abstract <T> CompletableFuture<Void> thenRun
666	+	(CompletableFuture<T> f, Runnable a);
667	+	public abstract <T> CompletableFuture<Void> thenAccept
668	+	(CompletableFuture<T> f, Consumer<? super T> a);
669	+	public abstract <T,U> CompletableFuture<U> thenApply
670	+	(CompletableFuture<T> f, Function<? super T,U> a);
671	+	public abstract <T,U> CompletableFuture<U> thenCompose
672	+	(CompletableFuture<T> f,
673	+	Function<? super T,? extends CompletionStage<U>> a);
674	+	public abstract <T,U> CompletableFuture<U> handle
675	+	(CompletableFuture<T> f,
676	+	BiFunction<? super T,Throwable,? extends U> a);
677	+	public abstract <T> CompletableFuture<T> whenComplete
678	+	(CompletableFuture<T> f,
679	+	BiConsumer<? super T,? super Throwable> a);
680		public abstract <T,U> CompletableFuture<Void> runAfterBoth
681		(CompletableFuture<T> f, CompletableFuture<U> g, Runnable a);
682		public abstract <T,U> CompletableFuture<Void> thenAcceptBoth
#	Line 628 | Line 687 | public class CompletableFutureTest exten
687		(CompletableFuture<T> f,
688		CompletionStage<? extends U> g,
689		BiFunction<? super T,? super U,? extends V> a);
631	–	public abstract <T,U> CompletableFuture<U> applyToEither
632	–	(CompletableFuture<T> f,
633	–	CompletionStage<? extends T> g,
634	–	Function<? super T,U> a);
635	–	public abstract <T> CompletableFuture<Void> acceptEither
636	–	(CompletableFuture<T> f,
637	–	CompletionStage<? extends T> g,
638	–	Consumer<? super T> a);
690		public abstract <T> CompletableFuture<Void> runAfterEither
691		(CompletableFuture<T> f,
692		CompletionStage<?> g,
693		java.lang.Runnable a);
694	<	public abstract <T,U> CompletableFuture<U> thenCompose
694	>	public abstract <T> CompletableFuture<Void> acceptEither
695		(CompletableFuture<T> f,
696	<	Function<? super T,? extends CompletionStage<U>> a);
697	<	public abstract <T> CompletableFuture<T> whenComplete
696	>	CompletionStage<? extends T> g,
697	>	Consumer<? super T> a);
698	>	public abstract <T,U> CompletableFuture<U> applyToEither
699		(CompletableFuture<T> f,
700	<	BiConsumer<? super T,? super Throwable> a);
700	>	CompletionStage<? extends T> g,
701	>	Function<? super T,U> a);
702	>	}
703	>
704	>	/**
705	>	* exceptionally action is not invoked when source completes
706	>	* normally, and source result is propagated
707	>	*/
708	>	public void testExceptionally_normalCompletion() {
709	>	for (boolean createIncomplete : new boolean[] { true, false })
710	>	for (Integer v1 : new Integer[] { 1, null })
711	>	{
712	>	final AtomicInteger a = new AtomicInteger(0);
713	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
714	>	if (!createIncomplete) f.complete(v1);
715	>	final CompletableFuture<Integer> g = f.exceptionally
716	>	((Throwable t) -> {
717	>	// Should not be called
718	>	a.getAndIncrement();
719	>	throw new AssertionError();
720	>	});
721	>	if (createIncomplete) f.complete(v1);
722
723	+	checkCompletedNormally(g, v1);
724	+	checkCompletedNormally(f, v1);
725	+	assertEquals(0, a.get());
726	+	}}
727
651	–	}
728
729		/**
730		* exceptionally action completes with function value on source
731	<	* exception; otherwise with source value
731	>	* exception
732		*/
733	<	public void testExceptionally() {
734	<	CompletableFuture<Integer> f = new CompletableFuture<>();
735	<	ExceptionToInteger r = new ExceptionToInteger();
736	<	CompletableFuture<Integer> g = f.exceptionally(r);
737	<	f.completeExceptionally(new CFException());
738	<	checkCompletedNormally(g, three);
733	>	public void testExceptionally_exceptionalCompletion() {
734	>	for (boolean createIncomplete : new boolean[] { true, false })
735	>	for (Integer v1 : new Integer[] { 1, null })
736	>	{
737	>	final AtomicInteger a = new AtomicInteger(0);
738	>	final CFException ex = new CFException();
739	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
740	>	if (!createIncomplete) f.completeExceptionally(ex);
741	>	final CompletableFuture<Integer> g = f.exceptionally
742	>	((Throwable t) -> {
743	>	threadAssertSame(t, ex);
744	>	a.getAndIncrement();
745	>	return v1;
746	>	});
747	>	if (createIncomplete) f.completeExceptionally(ex);
748
749	<	f = new CompletableFuture<>();
750	<	r = new ExceptionToInteger();
751	<	g = f.exceptionally(r);
752	<	f.complete(one);
753	<	checkCompletedNormally(g, one);
754	<	}
749	>	checkCompletedNormally(g, v1);
750	>	assertEquals(1, a.get());
751	>	}}
752	>
753	>	public void testExceptionally_exceptionalCompletionActionFailed() {
754	>	for (boolean createIncomplete : new boolean[] { true, false })
755	>	for (Integer v1 : new Integer[] { 1, null })
756	>	{
757	>	final AtomicInteger a = new AtomicInteger(0);
758	>	final CFException ex1 = new CFException();
759	>	final CFException ex2 = new CFException();
760	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
761	>	if (!createIncomplete) f.completeExceptionally(ex1);
762	>	final CompletableFuture<Integer> g = f.exceptionally
763	>	((Throwable t) -> {
764	>	threadAssertSame(t, ex1);
765	>	a.getAndIncrement();
766	>	throw ex2;
767	>	});
768	>	if (createIncomplete) f.completeExceptionally(ex1);
769	>
770	>	checkCompletedWithWrappedCFException(g, ex2);
771	>	assertEquals(1, a.get());
772	>	}}
773
774		/**
775	<	* handle action completes normally with function value on either
776	<	* normal or exceptional completion of source
775	>	* handle action completes normally with function value on normal
776	>	* completion of source
777		*/
778	<	public void testHandle() {
779	<	CompletableFuture<Integer> f, g;
780	<	IntegerHandler r;
778	>	public void testHandle_normalCompletion() {
779	>	for (ExecutionMode m : ExecutionMode.values())
780	>	for (boolean createIncomplete : new boolean[] { true, false })
781	>	for (Integer v1 : new Integer[] { 1, null })
782	>	{
783	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
784	>	final AtomicInteger a = new AtomicInteger(0);
785	>	if (!createIncomplete) f.complete(v1);
786	>	final CompletableFuture<Integer> g = m.handle
787	>	(f,
788	>	(Integer x, Throwable t) -> {
789	>	threadAssertSame(x, v1);
790	>	threadAssertNull(t);
791	>	a.getAndIncrement();
792	>	return inc(v1);
793	>	});
794	>	if (createIncomplete) f.complete(v1);
795
796	<	f = new CompletableFuture<>();
797	<	f.completeExceptionally(new CFException());
798	<	g = f.handle(r = new IntegerHandler());
799	<	assertTrue(r.ran);
683	<	checkCompletedNormally(g, three);
796	>	checkCompletedNormally(g, inc(v1));
797	>	checkCompletedNormally(f, v1);
798	>	assertEquals(1, a.get());
799	>	}}
800
801	<	f = new CompletableFuture<>();
802	<	g = f.handle(r = new IntegerHandler());
803	<	assertFalse(r.ran);
804	<	f.completeExceptionally(new CFException());
805	<	checkCompletedNormally(g, three);
806	<	assertTrue(r.ran);
801	>	/**
802	>	* handle action completes normally with function value on
803	>	* exceptional completion of source
804	>	*/
805	>	public void testHandle_exceptionalCompletion() {
806	>	for (ExecutionMode m : ExecutionMode.values())
807	>	for (boolean createIncomplete : new boolean[] { true, false })
808	>	for (Integer v1 : new Integer[] { 1, null })
809	>	{
810	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
811	>	final AtomicInteger a = new AtomicInteger(0);
812	>	final CFException ex = new CFException();
813	>	if (!createIncomplete) f.completeExceptionally(ex);
814	>	final CompletableFuture<Integer> g = m.handle
815	>	(f,
816	>	(Integer x, Throwable t) -> {
817	>	threadAssertNull(x);
818	>	threadAssertSame(t, ex);
819	>	a.getAndIncrement();
820	>	return v1;
821	>	});
822	>	if (createIncomplete) f.completeExceptionally(ex);
823
824	<	f = new CompletableFuture<>();
825	<	f.complete(one);
826	<	g = f.handle(r = new IntegerHandler());
827	<	assertTrue(r.ran);
696	<	checkCompletedNormally(g, two);
824	>	checkCompletedNormally(g, v1);
825	>	checkCompletedWithWrappedCFException(f, ex);
826	>	assertEquals(1, a.get());
827	>	}}
828
829	<	f = new CompletableFuture<>();
830	<	g = f.handle(r = new IntegerHandler());
831	<	assertFalse(r.ran);
832	<	f.complete(one);
833	<	assertTrue(r.ran);
834	<	checkCompletedNormally(g, two);
835	<	}
829	>	/**
830	>	* handle action completes normally with function value on
831	>	* cancelled source
832	>	*/
833	>	public void testHandle_sourceCancelled() {
834	>	for (ExecutionMode m : ExecutionMode.values())
835	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
836	>	for (boolean createIncomplete : new boolean[] { true, false })
837	>	for (Integer v1 : new Integer[] { 1, null })
838	>	{
839	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
840	>	final AtomicInteger a = new AtomicInteger(0);
841	>	if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
842	>	final CompletableFuture<Integer> g = m.handle
843	>	(f,
844	>	(Integer x, Throwable t) -> {
845	>	threadAssertNull(x);
846	>	threadAssertTrue(t instanceof CancellationException);
847	>	a.getAndIncrement();
848	>	return v1;
849	>	});
850	>	if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
851	>
852	>	checkCompletedNormally(g, v1);
853	>	checkCancelled(f);
854	>	assertEquals(1, a.get());
855	>	}}
856	>
857	>	/**
858	>	* handle result completes exceptionally if action does
859	>	*/
860	>	public void testHandle_sourceFailedActionFailed() {
861	>	for (ExecutionMode m : ExecutionMode.values())
862	>	for (boolean createIncomplete : new boolean[] { true, false })
863	>	{
864	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
865	>	final AtomicInteger a = new AtomicInteger(0);
866	>	final CFException ex1 = new CFException();
867	>	final CFException ex2 = new CFException();
868	>	if (!createIncomplete) f.completeExceptionally(ex1);
869	>	final CompletableFuture<Integer> g = m.handle
870	>	(f,
871	>	(Integer x, Throwable t) -> {
872	>	threadAssertNull(x);
873	>	threadAssertSame(ex1, t);
874	>	a.getAndIncrement();
875	>	throw ex2;
876	>	});
877	>	if (createIncomplete) f.completeExceptionally(ex1);
878	>
879	>	checkCompletedWithWrappedCFException(g, ex2);
880	>	checkCompletedWithWrappedCFException(f, ex1);
881	>	assertEquals(1, a.get());
882	>	}}
883	>
884	>	public void testHandle_sourceCompletedNormallyActionFailed() {
885	>	for (ExecutionMode m : ExecutionMode.values())
886	>	for (boolean createIncomplete : new boolean[] { true, false })
887	>	for (Integer v1 : new Integer[] { 1, null })
888	>	{
889	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
890	>	final AtomicInteger a = new AtomicInteger(0);
891	>	final CFException ex = new CFException();
892	>	if (!createIncomplete) f.complete(v1);
893	>	final CompletableFuture<Integer> g = m.handle
894	>	(f,
895	>	(Integer x, Throwable t) -> {
896	>	threadAssertSame(x, v1);
897	>	threadAssertNull(t);
898	>	a.getAndIncrement();
899	>	throw ex;
900	>	});
901	>	if (createIncomplete) f.complete(v1);
902	>
903	>	checkCompletedWithWrappedCFException(g, ex);
904	>	checkCompletedNormally(f, v1);
905	>	assertEquals(1, a.get());
906	>	}}
907
908		/**
909		* runAsync completes after running Runnable
#	Line 710 | Line 912 | public class CompletableFutureTest exten
912		Noop r = new Noop();
913		CompletableFuture<Void> f = CompletableFuture.runAsync(r);
914		assertNull(f.join());
915	<	assertTrue(r.ran);
915	>	assertEquals(1, r.invocationCount);
916		checkCompletedNormally(f, null);
917		}
918
#	Line 722 | Line 924 | public class CompletableFutureTest exten
924		ThreadExecutor exec = new ThreadExecutor();
925		CompletableFuture<Void> f = CompletableFuture.runAsync(r, exec);
926		assertNull(f.join());
927	<	assertTrue(r.ran);
927	>	assertEquals(1, r.invocationCount);
928		checkCompletedNormally(f, null);
929		assertEquals(1, exec.count.get());
930		}
#	Line 734 | Line 936 | public class CompletableFutureTest exten
936		FailingNoop r = new FailingNoop();
937		CompletableFuture<Void> f = CompletableFuture.runAsync(r);
938		checkCompletedWithWrappedCFException(f);
939	<	assertTrue(r.ran);
939	>	assertEquals(1, r.invocationCount);
940		}
941
942		/**
#	Line 764 | Line 966 | public class CompletableFutureTest exten
966		FailingSupplier r = new FailingSupplier();
967		CompletableFuture<Integer> f = CompletableFuture.supplyAsync(r);
968		checkCompletedWithWrappedCFException(f);
969	<	assertTrue(r.ran);
969	>	assertEquals(1, r.invocationCount);
970		}
971
972		// seq completion methods
#	Line 772 | Line 974 | public class CompletableFutureTest exten
974		/**
975		* thenRun result completes normally after normal completion of source
976		*/
977	<	public void testThenRun() {
978	<	CompletableFuture<Integer> f;
979	<	CompletableFuture<Void> g;
980	<	Noop r;
981	<
982	<	f = new CompletableFuture<>();
983	<	g = f.thenRun(r = new Noop());
984	<	f.complete(null);
985	<	checkCompletedNormally(g, null);
986	<	assertTrue(r.ran);
977	>	public void testThenRun_normalCompletion() {
978	>	for (ExecutionMode m : ExecutionMode.values())
979	>	for (boolean createIncomplete : new boolean[] { true, false })
980	>	for (Integer v1 : new Integer[] { 1, null })
981	>	{
982	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
983	>	final Noop r = new Noop();
984	>	if (!createIncomplete) f.complete(v1);
985	>	final CompletableFuture<Void> g = m.thenRun(f, r);
986	>	if (createIncomplete) f.complete(v1);
987
786	–	f = new CompletableFuture<>();
787	–	f.complete(null);
788	–	g = f.thenRun(r = new Noop());
988		checkCompletedNormally(g, null);
989	<	assertTrue(r.ran);
990	<	}
989	>	checkCompletedNormally(f, v1);
990	>	assertEquals(1, r.invocationCount);
991	>	}}
992
993		/**
994		* thenRun result completes exceptionally after exceptional
995		* completion of source
996		*/
997	<	public void testThenRun2() {
998	<	CompletableFuture<Integer> f;
999	<	CompletableFuture<Void> g;
1000	<	Noop r;
1001	<
1002	<	f = new CompletableFuture<>();
1003	<	g = f.thenRun(r = new Noop());
1004	<	f.completeExceptionally(new CFException());
1005	<	checkCompletedWithWrappedCFException(g);
1006	<	assertFalse(r.ran);
997	>	public void testThenRun_exceptionalCompletion() {
998	>	for (ExecutionMode m : ExecutionMode.values())
999	>	for (boolean createIncomplete : new boolean[] { true, false })
1000	>	{
1001	>	final CFException ex = new CFException();
1002	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1003	>	final Noop r = new Noop();
1004	>	if (!createIncomplete) f.completeExceptionally(ex);
1005	>	final CompletableFuture<Void> g = m.thenRun(f, r);
1006	>	if (createIncomplete) f.completeExceptionally(ex);
1007
1008	<	f = new CompletableFuture<>();
1009	<	f.completeExceptionally(new CFException());
1010	<	g = f.thenRun(r = new Noop());
1011	<	checkCompletedWithWrappedCFException(g);
812	<	assertFalse(r.ran);
813	<	}
1008	>	checkCompletedWithWrappedCFException(g, ex);
1009	>	checkCompletedWithWrappedCFException(f, ex);
1010	>	assertEquals(0, r.invocationCount);
1011	>	}}
1012
1013		/**
1014	<	* thenRun result completes exceptionally if action does
1014	>	* thenRun result completes exceptionally if source cancelled
1015		*/
1016	<	public void testThenRun3() {
1017	<	CompletableFuture<Integer> f;
1018	<	CompletableFuture<Void> g;
1019	<	FailingNoop r;
1020	<
1021	<	f = new CompletableFuture<>();
1022	<	g = f.thenRun(r = new FailingNoop());
1023	<	f.complete(null);
1024	<	checkCompletedWithWrappedCFException(g);
1016	>	public void testThenRun_sourceCancelled() {
1017	>	for (ExecutionMode m : ExecutionMode.values())
1018	>	for (boolean createIncomplete : new boolean[] { true, false })
1019	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1020	>	{
1021	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1022	>	final Noop r = new Noop();
1023	>	if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1024	>	final CompletableFuture<Void> g = f.thenRun(r);
1025	>	if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1026
1027	<	f = new CompletableFuture<>();
1028	<	f.complete(null);
1029	<	g = f.thenRun(r = new FailingNoop());
1030	<	checkCompletedWithWrappedCFException(g);
832	<	}
1027	>	checkCompletedWithWrappedCancellationException(g);
1028	>	checkCancelled(f);
1029	>	assertEquals(0, r.invocationCount);
1030	>	}}
1031
1032		/**
1033	<	* thenRun result completes exceptionally if source cancelled
1033	>	* thenRun result completes exceptionally if action does
1034		*/
1035	<	public void testThenRun4() {
1036	<	CompletableFuture<Integer> f;
1037	<	CompletableFuture<Void> g;
1038	<	Noop r;
1039	<
1040	<	f = new CompletableFuture<>();
1041	<	g = f.thenRun(r = new Noop());
1042	<	assertTrue(f.cancel(true));
1043	<	checkCompletedWithWrappedCancellationException(g);
1035	>	public void testThenRun_actionFailed() {
1036	>	for (ExecutionMode m : ExecutionMode.values())
1037	>	for (boolean createIncomplete : new boolean[] { true, false })
1038	>	for (Integer v1 : new Integer[] { 1, null })
1039	>	{
1040	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1041	>	final FailingNoop r = new FailingNoop();
1042	>	if (!createIncomplete) f.complete(v1);
1043	>	final CompletableFuture<Void> g = f.thenRun(r);
1044	>	if (createIncomplete) f.complete(v1);
1045
1046	<	f = new CompletableFuture<>();
1047	<	assertTrue(f.cancel(true));
1048	<	g = f.thenRun(r = new Noop());
850	<	checkCompletedWithWrappedCancellationException(g);
851	<	}
1046	>	checkCompletedWithWrappedCFException(g);
1047	>	checkCompletedNormally(f, v1);
1048	>	}}
1049
1050		/**
1051		* thenApply result completes normally after normal completion of source
1052		*/
1053	<	public void testThenApply() {
1054	<	CompletableFuture<Integer> f = new CompletableFuture<>();
1055	<	CompletableFuture<Integer> g = f.thenApply(inc);
1056	<	f.complete(one);
1057	<	checkCompletedNormally(g, two);
1058	<	}
1053	>	public void testThenApply_normalCompletion() {
1054	>	for (ExecutionMode m : ExecutionMode.values())
1055	>	for (boolean createIncomplete : new boolean[] { true, false })
1056	>	for (Integer v1 : new Integer[] { 1, null })
1057	>	{
1058	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1059	>	final IncFunction r = new IncFunction();
1060	>	if (!createIncomplete) f.complete(v1);
1061	>	final CompletableFuture<Integer> g = m.thenApply(f, r);
1062	>	if (createIncomplete) {
1063	>	checkIncomplete(g);
1064	>	f.complete(v1);
1065	>	}
1066	>
1067	>	checkCompletedNormally(g, inc(v1));
1068	>	checkCompletedNormally(f, v1);
1069	>	assertEquals(1, r.invocationCount);
1070	>	}}
1071
1072		/**
1073		* thenApply result completes exceptionally after exceptional
1074		* completion of source
1075		*/
1076	<	public void testThenApply2() {
1077	<	CompletableFuture<Integer> f = new CompletableFuture<>();
1078	<	CompletableFuture<Integer> g = f.thenApply(inc);
1079	<	f.completeExceptionally(new CFException());
1080	<	checkCompletedWithWrappedCFException(g);
1081	<	}
1076	>	public void testThenApply_exceptionalCompletion() {
1077	>	for (ExecutionMode m : ExecutionMode.values())
1078	>	for (boolean createIncomplete : new boolean[] { true, false })
1079	>	{
1080	>	final CFException ex = new CFException();
1081	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1082	>	final IncFunction r = new IncFunction();
1083	>	if (!createIncomplete) f.completeExceptionally(ex);
1084	>	final CompletableFuture<Integer> g = m.thenApply(f, r);
1085	>	if (createIncomplete) f.completeExceptionally(ex);
1086
1087	<	/**
1088	<	* thenApply result completes exceptionally if action does
1089	<	*/
1090	<	public void testThenApply3() {
878	<	CompletableFuture<Integer> f = new CompletableFuture<>();
879	<	CompletableFuture<Integer> g = f.thenApply(new FailingFunction());
880	<	f.complete(one);
881	<	checkCompletedWithWrappedCFException(g);
882	<	}
1087	>	checkCompletedWithWrappedCFException(g, ex);
1088	>	checkCompletedWithWrappedCFException(f, ex);
1089	>	assertEquals(0, r.invocationCount);
1090	>	}}
1091
1092		/**
1093		* thenApply result completes exceptionally if source cancelled
1094		*/
1095	<	public void testThenApply4() {
1096	<	CompletableFuture<Integer> f = new CompletableFuture<>();
1097	<	CompletableFuture<Integer> g = f.thenApply(inc);
1098	<	assertTrue(f.cancel(true));
1095	>	public void testThenApply_sourceCancelled() {
1096	>	for (ExecutionMode m : ExecutionMode.values())
1097	>	for (boolean createIncomplete : new boolean[] { true, false })
1098	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1099	>	{
1100	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1101	>	final IncFunction r = new IncFunction();
1102	>	if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1103	>	final CompletableFuture<Integer> g = f.thenApply(r);
1104	>	if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1105	>
1106		checkCompletedWithWrappedCancellationException(g);
1107	<	}
1107	>	checkCancelled(f);
1108	>	assertEquals(0, r.invocationCount);
1109	>	}}
1110	>
1111	>	/**
1112	>	* thenApply result completes exceptionally if action does
1113	>	*/
1114	>	public void testThenApply_actionFailed() {
1115	>	for (ExecutionMode m : ExecutionMode.values())
1116	>	for (boolean createIncomplete : new boolean[] { true, false })
1117	>	for (Integer v1 : new Integer[] { 1, null })
1118	>	{
1119	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1120	>	final FailingFunction r = new FailingFunction();
1121	>	if (!createIncomplete) f.complete(v1);
1122	>	final CompletableFuture<Integer> g = f.thenApply(r);
1123	>	if (createIncomplete) f.complete(v1);
1124	>
1125	>	checkCompletedWithWrappedCFException(g);
1126	>	checkCompletedNormally(f, v1);
1127	>	}}
1128
1129		/**
1130		* thenAccept result completes normally after normal completion of source
#	Line 924 | Line 1159 | public class CompletableFutureTest exten
1159		CompletableFuture<Void> g = f.thenAccept(r);
1160		f.complete(one);
1161		checkCompletedWithWrappedCFException(g);
1162	<	assertTrue(r.ran);
1162	>	assertEquals(1, r.invocationCount);
1163		}
1164
1165		/**
#	Line 943 | Line 1178 | public class CompletableFutureTest exten
1178		* of sources
1179		*/
1180		public void testThenCombine_normalCompletion1() {
1181	+	for (boolean createIncomplete : new boolean[] { true, false })
1182	+	for (boolean fFirst : new boolean[] { true, false })
1183		for (ExecutionMode m : ExecutionMode.values())
1184		for (Integer v1 : new Integer[] { 1, null })
1185	<	for (Integer v2 : new Integer[] { 2, null }) {
1186	<
1185	>	for (Integer v2 : new Integer[] { 2, null })
1186	>	{
1187		final CompletableFuture<Integer> f = new CompletableFuture<>();
1188		final CompletableFuture<Integer> g = new CompletableFuture<>();
1189		final SubtractFunction r = new SubtractFunction();
1190	<	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1190	>	CompletableFuture<Integer> h = null;
1191	>	if (createIncomplete) h = m.thenCombine(f, g, r);
1192
1193	<	f.complete(v1);
1194	<	checkIncomplete(h);
1195	<	assertFalse(r.ran());
1196	<	g.complete(v2);
1193	>	if (fFirst)
1194	>	f.complete(v1);
1195	>	else
1196	>	g.complete(v2);
1197	>	if (createIncomplete) checkIncomplete(h);
1198	>	assertEquals(0, r.invocationCount);
1199	>	if (!fFirst)
1200	>	f.complete(v1);
1201	>	else
1202	>	g.complete(v2);
1203	>	if (!createIncomplete) h = m.thenCombine(f, g, r);
1204
1205		checkCompletedNormally(h, subtract(v1, v2));
1206		checkCompletedNormally(f, v1);
1207		checkCompletedNormally(g, v2);
1208	<	}
1209	<	}
965	<
966	<	public void testThenCombine_normalCompletion2() {
967	<	for (ExecutionMode m : ExecutionMode.values())
968	<	for (Integer v1 : new Integer[] { 1, null })
969	<	for (Integer v2 : new Integer[] { 2, null }) {
970	<
971	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
972	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
973	<	final SubtractFunction r = new SubtractFunction();
974	<	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
975	<
976	<	g.complete(v2);
977	<	checkIncomplete(h);
978	<	assertFalse(r.ran());
979	<	f.complete(v1);
980	<
981	<	checkCompletedNormally(h, subtract(v1, v2));
982	<	checkCompletedNormally(f, v1);
983	<	checkCompletedNormally(g, v2);
984	<	}
985	<	}
986	<
987	<	public void testThenCombine_normalCompletion3() {
988	<	for (ExecutionMode m : ExecutionMode.values())
989	<	for (Integer v1 : new Integer[] { 1, null })
990	<	for (Integer v2 : new Integer[] { 2, null }) {
991	<
992	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
993	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
994	<	final SubtractFunction r = new SubtractFunction();
995	<
996	<	g.complete(v2);
997	<	f.complete(v1);
998	<	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
999	<
1000	<	checkCompletedNormally(h, subtract(v1, v2));
1001	<	checkCompletedNormally(f, v1);
1002	<	checkCompletedNormally(g, v2);
1003	<	}
1004	<	}
1005	<
1006	<	public void testThenCombine_normalCompletion4() {
1007	<	for (ExecutionMode m : ExecutionMode.values())
1008	<	for (Integer v1 : new Integer[] { 1, null })
1009	<	for (Integer v2 : new Integer[] { 2, null }) {
1010	<
1011	<	final CompletableFuture<Integer> f = new CompletableFuture<>();
1012	<	final CompletableFuture<Integer> g = new CompletableFuture<>();
1013	<	final SubtractFunction r = new SubtractFunction();
1014	<
1015	<	f.complete(v1);
1016	<	g.complete(v2);
1017	<	final CompletableFuture<Integer> h = m.thenCombine(f, g, r);
1018	<
1019	<	checkCompletedNormally(h, subtract(v1, v2));
1020	<	checkCompletedNormally(f, v1);
1021	<	checkCompletedNormally(g, v2);
1022	<	}
1023	<	}
1208	>	assertEquals(1, r.invocationCount);
1209	>	}}
1210
1211		/**
1212		* thenCombine result completes exceptionally after exceptional
#	Line 1028 | Line 1214 | public class CompletableFutureTest exten
1214		*/
1215		public void testThenCombine_exceptionalCompletion1() {
1216		for (ExecutionMode m : ExecutionMode.values())
1217	<	for (Integer v1 : new Integer[] { 1, null }) {
1218	<
1217	>	for (Integer v1 : new Integer[] { 1, null })
1218	>	{
1219		final CompletableFuture<Integer> f = new CompletableFuture<>();
1220		final CompletableFuture<Integer> g = new CompletableFuture<>();
1221		final SubtractFunction r = new SubtractFunction();
#	Line 1042 | Line 1228 | public class CompletableFutureTest exten
1228
1229		checkCompletedWithWrappedCFException(h, ex);
1230		checkCompletedWithWrappedCFException(f, ex);
1231	<	assertFalse(r.ran());
1231	>	assertEquals(0, r.invocationCount);
1232		checkCompletedNormally(g, v1);
1233	<	}
1048	<	}
1233	>	}}
1234
1235		public void testThenCombine_exceptionalCompletion2() {
1236		for (ExecutionMode m : ExecutionMode.values())
1237	<	for (Integer v1 : new Integer[] { 1, null }) {
1238	<
1237	>	for (Integer v1 : new Integer[] { 1, null })
1238	>	{
1239		final CompletableFuture<Integer> f = new CompletableFuture<>();
1240		final CompletableFuture<Integer> g = new CompletableFuture<>();
1241		final SubtractFunction r = new SubtractFunction();
#	Line 1063 | Line 1248 | public class CompletableFutureTest exten
1248
1249		checkCompletedWithWrappedCFException(h, ex);
1250		checkCompletedWithWrappedCFException(g, ex);
1251	<	assertFalse(r.ran());
1251	>	assertEquals(0, r.invocationCount);
1252		checkCompletedNormally(f, v1);
1253	<	}
1069	<	}
1253	>	}}
1254
1255		public void testThenCombine_exceptionalCompletion3() {
1256		for (ExecutionMode m : ExecutionMode.values())
1257	<	for (Integer v1 : new Integer[] { 1, null }) {
1258	<
1257	>	for (Integer v1 : new Integer[] { 1, null })
1258	>	{
1259		final CompletableFuture<Integer> f = new CompletableFuture<>();
1260		final CompletableFuture<Integer> g = new CompletableFuture<>();
1261		final SubtractFunction r = new SubtractFunction();
#	Line 1083 | Line 1267 | public class CompletableFutureTest exten
1267
1268		checkCompletedWithWrappedCFException(h, ex);
1269		checkCompletedWithWrappedCFException(g, ex);
1270	<	assertFalse(r.ran());
1270	>	assertEquals(0, r.invocationCount);
1271		checkCompletedNormally(f, v1);
1272	<	}
1089	<	}
1272	>	}}
1273
1274		public void testThenCombine_exceptionalCompletion4() {
1275		for (ExecutionMode m : ExecutionMode.values())
1276	<	for (Integer v1 : new Integer[] { 1, null }) {
1277	<
1276	>	for (Integer v1 : new Integer[] { 1, null })
1277	>	{
1278		final CompletableFuture<Integer> f = new CompletableFuture<>();
1279		final CompletableFuture<Integer> g = new CompletableFuture<>();
1280		final SubtractFunction r = new SubtractFunction();
#	Line 1103 | Line 1286 | public class CompletableFutureTest exten
1286
1287		checkCompletedWithWrappedCFException(h, ex);
1288		checkCompletedWithWrappedCFException(f, ex);
1289	<	assertFalse(r.ran());
1289	>	assertEquals(0, r.invocationCount);
1290		checkCompletedNormally(g, v1);
1291	<	}
1109	<	}
1291	>	}}
1292
1293		/**
1294		* thenCombine result completes exceptionally if action does
#	Line 1114 | Line 1296 | public class CompletableFutureTest exten
1296		public void testThenCombine_actionFailed1() {
1297		for (ExecutionMode m : ExecutionMode.values())
1298		for (Integer v1 : new Integer[] { 1, null })
1299	<	for (Integer v2 : new Integer[] { 2, null }) {
1300	<
1299	>	for (Integer v2 : new Integer[] { 2, null })
1300	>	{
1301		final CompletableFuture<Integer> f = new CompletableFuture<>();
1302		final CompletableFuture<Integer> g = new CompletableFuture<>();
1303		final FailingBiFunction r = new FailingBiFunction();
#	Line 1128 | Line 1310 | public class CompletableFutureTest exten
1310		checkCompletedWithWrappedCFException(h);
1311		checkCompletedNormally(f, v1);
1312		checkCompletedNormally(g, v2);
1313	<	}
1132	<	}
1313	>	}}
1314
1315		public void testThenCombine_actionFailed2() {
1316		for (ExecutionMode m : ExecutionMode.values())
1317		for (Integer v1 : new Integer[] { 1, null })
1318	<	for (Integer v2 : new Integer[] { 2, null }) {
1319	<
1318	>	for (Integer v2 : new Integer[] { 2, null })
1319	>	{
1320		final CompletableFuture<Integer> f = new CompletableFuture<>();
1321		final CompletableFuture<Integer> g = new CompletableFuture<>();
1322		final FailingBiFunction r = new FailingBiFunction();
#	Line 1148 | Line 1329 | public class CompletableFutureTest exten
1329		checkCompletedWithWrappedCFException(h);
1330		checkCompletedNormally(f, v1);
1331		checkCompletedNormally(g, v2);
1332	<	}
1152	<	}
1332	>	}}
1333
1334		/**
1335		* thenCombine result completes exceptionally if either source cancelled
#	Line 1157 | Line 1337 | public class CompletableFutureTest exten
1337		public void testThenCombine_sourceCancelled1() {
1338		for (ExecutionMode m : ExecutionMode.values())
1339		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1340	<	for (Integer v1 : new Integer[] { 1, null }) {
1341	<
1340	>	for (Integer v1 : new Integer[] { 1, null })
1341	>	{
1342		final CompletableFuture<Integer> f = new CompletableFuture<>();
1343		final CompletableFuture<Integer> g = new CompletableFuture<>();
1344		final SubtractFunction r = new SubtractFunction();
#	Line 1170 | Line 1350 | public class CompletableFutureTest exten
1350
1351		checkCompletedWithWrappedCancellationException(h);
1352		checkCancelled(f);
1353	<	assertFalse(r.ran());
1353	>	assertEquals(0, r.invocationCount);
1354		checkCompletedNormally(g, v1);
1355	<	}
1176	<	}
1355	>	}}
1356
1357		public void testThenCombine_sourceCancelled2() {
1358		for (ExecutionMode m : ExecutionMode.values())
1359		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1360	<	for (Integer v1 : new Integer[] { 1, null }) {
1361	<
1360	>	for (Integer v1 : new Integer[] { 1, null })
1361	>	{
1362		final CompletableFuture<Integer> f = new CompletableFuture<>();
1363		final CompletableFuture<Integer> g = new CompletableFuture<>();
1364		final SubtractFunction r = new SubtractFunction();
#	Line 1191 | Line 1370 | public class CompletableFutureTest exten
1370
1371		checkCompletedWithWrappedCancellationException(h);
1372		checkCancelled(g);
1373	<	assertFalse(r.ran());
1373	>	assertEquals(0, r.invocationCount);
1374		checkCompletedNormally(f, v1);
1375	<	}
1197	<	}
1375	>	}}
1376
1377		public void testThenCombine_sourceCancelled3() {
1378		for (ExecutionMode m : ExecutionMode.values())
1379		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1380	<	for (Integer v1 : new Integer[] { 1, null }) {
1381	<
1380	>	for (Integer v1 : new Integer[] { 1, null })
1381	>	{
1382		final CompletableFuture<Integer> f = new CompletableFuture<>();
1383		final CompletableFuture<Integer> g = new CompletableFuture<>();
1384		final SubtractFunction r = new SubtractFunction();
#	Line 1211 | Line 1389 | public class CompletableFutureTest exten
1389
1390		checkCompletedWithWrappedCancellationException(h);
1391		checkCancelled(g);
1392	<	assertFalse(r.ran());
1392	>	assertEquals(0, r.invocationCount);
1393		checkCompletedNormally(f, v1);
1394	<	}
1217	<	}
1394	>	}}
1395
1396		public void testThenCombine_sourceCancelled4() {
1397		for (ExecutionMode m : ExecutionMode.values())
1398		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1399	<	for (Integer v1 : new Integer[] { 1, null }) {
1400	<
1399	>	for (Integer v1 : new Integer[] { 1, null })
1400	>	{
1401		final CompletableFuture<Integer> f = new CompletableFuture<>();
1402		final CompletableFuture<Integer> g = new CompletableFuture<>();
1403		final SubtractFunction r = new SubtractFunction();
#	Line 1231 | Line 1408 | public class CompletableFutureTest exten
1408
1409		checkCompletedWithWrappedCancellationException(h);
1410		checkCancelled(f);
1411	<	assertFalse(r.ran());
1411	>	assertEquals(0, r.invocationCount);
1412		checkCompletedNormally(g, v1);
1413	<	}
1237	<	}
1413	>	}}
1414
1415		/**
1416		* thenAcceptBoth result completes normally after normal
#	Line 1243 | Line 1419 | public class CompletableFutureTest exten
1419		public void testThenAcceptBoth_normalCompletion1() {
1420		for (ExecutionMode m : ExecutionMode.values())
1421		for (Integer v1 : new Integer[] { 1, null })
1422	<	for (Integer v2 : new Integer[] { 2, null }) {
1423	<
1422	>	for (Integer v2 : new Integer[] { 2, null })
1423	>	{
1424		final CompletableFuture<Integer> f = new CompletableFuture<>();
1425		final CompletableFuture<Integer> g = new CompletableFuture<>();
1426		final SubtractAction r = new SubtractAction();
#	Line 1252 | Line 1428 | public class CompletableFutureTest exten
1428
1429		f.complete(v1);
1430		checkIncomplete(h);
1431	<	assertFalse(r.ran());
1431	>	assertEquals(0, r.invocationCount);
1432		g.complete(v2);
1433
1434		checkCompletedNormally(h, null);
1435	<	assertEquals(r.value, subtract(v1, v2));
1435	>	assertEquals(subtract(v1, v2), r.value);
1436		checkCompletedNormally(f, v1);
1437		checkCompletedNormally(g, v2);
1438	<	}
1263	<	}
1438	>	}}
1439
1440		public void testThenAcceptBoth_normalCompletion2() {
1441		for (ExecutionMode m : ExecutionMode.values())
1442		for (Integer v1 : new Integer[] { 1, null })
1443	<	for (Integer v2 : new Integer[] { 2, null }) {
1444	<
1443	>	for (Integer v2 : new Integer[] { 2, null })
1444	>	{
1445		final CompletableFuture<Integer> f = new CompletableFuture<>();
1446		final CompletableFuture<Integer> g = new CompletableFuture<>();
1447		final SubtractAction r = new SubtractAction();
#	Line 1274 | Line 1449 | public class CompletableFutureTest exten
1449
1450		g.complete(v2);
1451		checkIncomplete(h);
1452	<	assertFalse(r.ran());
1452	>	assertEquals(0, r.invocationCount);
1453		f.complete(v1);
1454
1455		checkCompletedNormally(h, null);
1456	<	assertEquals(r.value, subtract(v1, v2));
1456	>	assertEquals(subtract(v1, v2), r.value);
1457		checkCompletedNormally(f, v1);
1458		checkCompletedNormally(g, v2);
1459	<	}
1285	<	}
1459	>	}}
1460
1461		public void testThenAcceptBoth_normalCompletion3() {
1462		for (ExecutionMode m : ExecutionMode.values())
1463		for (Integer v1 : new Integer[] { 1, null })
1464	<	for (Integer v2 : new Integer[] { 2, null }) {
1465	<
1464	>	for (Integer v2 : new Integer[] { 2, null })
1465	>	{
1466		final CompletableFuture<Integer> f = new CompletableFuture<>();
1467		final CompletableFuture<Integer> g = new CompletableFuture<>();
1468		final SubtractAction r = new SubtractAction();
#	Line 1298 | Line 1472 | public class CompletableFutureTest exten
1472		final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1473
1474		checkCompletedNormally(h, null);
1475	<	assertEquals(r.value, subtract(v1, v2));
1475	>	assertEquals(subtract(v1, v2), r.value);
1476		checkCompletedNormally(f, v1);
1477		checkCompletedNormally(g, v2);
1478	<	}
1305	<	}
1478	>	}}
1479
1480		public void testThenAcceptBoth_normalCompletion4() {
1481		for (ExecutionMode m : ExecutionMode.values())
1482		for (Integer v1 : new Integer[] { 1, null })
1483	<	for (Integer v2 : new Integer[] { 2, null }) {
1484	<
1483	>	for (Integer v2 : new Integer[] { 2, null })
1484	>	{
1485		final CompletableFuture<Integer> f = new CompletableFuture<>();
1486		final CompletableFuture<Integer> g = new CompletableFuture<>();
1487		final SubtractAction r = new SubtractAction();
#	Line 1318 | Line 1491 | public class CompletableFutureTest exten
1491		final CompletableFuture<Void> h = m.thenAcceptBoth(f, g, r);
1492
1493		checkCompletedNormally(h, null);
1494	<	assertEquals(r.value, subtract(v1, v2));
1494	>	assertEquals(subtract(v1, v2), r.value);
1495		checkCompletedNormally(f, v1);
1496		checkCompletedNormally(g, v2);
1497	<	}
1325	<	}
1497	>	}}
1498
1499		/**
1500		* thenAcceptBoth result completes exceptionally after exceptional
#	Line 1330 | Line 1502 | public class CompletableFutureTest exten
1502		*/
1503		public void testThenAcceptBoth_exceptionalCompletion1() {
1504		for (ExecutionMode m : ExecutionMode.values())
1505	<	for (Integer v1 : new Integer[] { 1, null }) {
1506	<
1505	>	for (Integer v1 : new Integer[] { 1, null })
1506	>	{
1507		final CompletableFuture<Integer> f = new CompletableFuture<>();
1508		final CompletableFuture<Integer> g = new CompletableFuture<>();
1509		final SubtractAction r = new SubtractAction();
#	Line 1344 | Line 1516 | public class CompletableFutureTest exten
1516
1517		checkCompletedWithWrappedCFException(h, ex);
1518		checkCompletedWithWrappedCFException(f, ex);
1519	<	assertFalse(r.ran());
1519	>	assertEquals(0, r.invocationCount);
1520		checkCompletedNormally(g, v1);
1521	<	}
1350	<	}
1521	>	}}
1522
1523		public void testThenAcceptBoth_exceptionalCompletion2() {
1524		for (ExecutionMode m : ExecutionMode.values())
1525	<	for (Integer v1 : new Integer[] { 1, null }) {
1526	<
1525	>	for (Integer v1 : new Integer[] { 1, null })
1526	>	{
1527		final CompletableFuture<Integer> f = new CompletableFuture<>();
1528		final CompletableFuture<Integer> g = new CompletableFuture<>();
1529		final SubtractAction r = new SubtractAction();
#	Line 1365 | Line 1536 | public class CompletableFutureTest exten
1536
1537		checkCompletedWithWrappedCFException(h, ex);
1538		checkCompletedWithWrappedCFException(g, ex);
1539	<	assertFalse(r.ran());
1539	>	assertEquals(0, r.invocationCount);
1540		checkCompletedNormally(f, v1);
1541	<	}
1371	<	}
1541	>	}}
1542
1543		public void testThenAcceptBoth_exceptionalCompletion3() {
1544		for (ExecutionMode m : ExecutionMode.values())
1545	<	for (Integer v1 : new Integer[] { 1, null }) {
1546	<
1545	>	for (Integer v1 : new Integer[] { 1, null })
1546	>	{
1547		final CompletableFuture<Integer> f = new CompletableFuture<>();
1548		final CompletableFuture<Integer> g = new CompletableFuture<>();
1549		final SubtractAction r = new SubtractAction();
#	Line 1385 | Line 1555 | public class CompletableFutureTest exten
1555
1556		checkCompletedWithWrappedCFException(h, ex);
1557		checkCompletedWithWrappedCFException(g, ex);
1558	<	assertFalse(r.ran());
1558	>	assertEquals(0, r.invocationCount);
1559		checkCompletedNormally(f, v1);
1560	<	}
1391	<	}
1560	>	}}
1561
1562		public void testThenAcceptBoth_exceptionalCompletion4() {
1563		for (ExecutionMode m : ExecutionMode.values())
1564	<	for (Integer v1 : new Integer[] { 1, null }) {
1565	<
1564	>	for (Integer v1 : new Integer[] { 1, null })
1565	>	{
1566		final CompletableFuture<Integer> f = new CompletableFuture<>();
1567		final CompletableFuture<Integer> g = new CompletableFuture<>();
1568		final SubtractAction r = new SubtractAction();
#	Line 1405 | Line 1574 | public class CompletableFutureTest exten
1574
1575		checkCompletedWithWrappedCFException(h, ex);
1576		checkCompletedWithWrappedCFException(f, ex);
1577	<	assertFalse(r.ran());
1577	>	assertEquals(0, r.invocationCount);
1578		checkCompletedNormally(g, v1);
1579	<	}
1411	<	}
1579	>	}}
1580
1581		/**
1582		* thenAcceptBoth result completes exceptionally if action does
#	Line 1416 | Line 1584 | public class CompletableFutureTest exten
1584		public void testThenAcceptBoth_actionFailed1() {
1585		for (ExecutionMode m : ExecutionMode.values())
1586		for (Integer v1 : new Integer[] { 1, null })
1587	<	for (Integer v2 : new Integer[] { 2, null }) {
1588	<
1587	>	for (Integer v2 : new Integer[] { 2, null })
1588	>	{
1589		final CompletableFuture<Integer> f = new CompletableFuture<>();
1590		final CompletableFuture<Integer> g = new CompletableFuture<>();
1591		final FailingBiConsumer r = new FailingBiConsumer();
#	Line 1430 | Line 1598 | public class CompletableFutureTest exten
1598		checkCompletedWithWrappedCFException(h);
1599		checkCompletedNormally(f, v1);
1600		checkCompletedNormally(g, v2);
1601	<	}
1434	<	}
1601	>	}}
1602
1603		public void testThenAcceptBoth_actionFailed2() {
1604		for (ExecutionMode m : ExecutionMode.values())
1605		for (Integer v1 : new Integer[] { 1, null })
1606	<	for (Integer v2 : new Integer[] { 2, null }) {
1607	<
1606	>	for (Integer v2 : new Integer[] { 2, null })
1607	>	{
1608		final CompletableFuture<Integer> f = new CompletableFuture<>();
1609		final CompletableFuture<Integer> g = new CompletableFuture<>();
1610		final FailingBiConsumer r = new FailingBiConsumer();
#	Line 1450 | Line 1617 | public class CompletableFutureTest exten
1617		checkCompletedWithWrappedCFException(h);
1618		checkCompletedNormally(f, v1);
1619		checkCompletedNormally(g, v2);
1620	<	}
1454	<	}
1620	>	}}
1621
1622		/**
1623		* thenAcceptBoth result completes exceptionally if either source cancelled
#	Line 1459 | Line 1625 | public class CompletableFutureTest exten
1625		public void testThenAcceptBoth_sourceCancelled1() {
1626		for (ExecutionMode m : ExecutionMode.values())
1627		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1628	<	for (Integer v1 : new Integer[] { 1, null }) {
1629	<
1628	>	for (Integer v1 : new Integer[] { 1, null })
1629	>	{
1630		final CompletableFuture<Integer> f = new CompletableFuture<>();
1631		final CompletableFuture<Integer> g = new CompletableFuture<>();
1632		final SubtractAction r = new SubtractAction();
#	Line 1472 | Line 1638 | public class CompletableFutureTest exten
1638
1639		checkCompletedWithWrappedCancellationException(h);
1640		checkCancelled(f);
1641	<	assertFalse(r.ran());
1641	>	assertEquals(0, r.invocationCount);
1642		checkCompletedNormally(g, v1);
1643	<	}
1478	<	}
1643	>	}}
1644
1645		public void testThenAcceptBoth_sourceCancelled2() {
1646		for (ExecutionMode m : ExecutionMode.values())
1647		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1648	<	for (Integer v1 : new Integer[] { 1, null }) {
1649	<
1648	>	for (Integer v1 : new Integer[] { 1, null })
1649	>	{
1650		final CompletableFuture<Integer> f = new CompletableFuture<>();
1651		final CompletableFuture<Integer> g = new CompletableFuture<>();
1652		final SubtractAction r = new SubtractAction();
#	Line 1493 | Line 1658 | public class CompletableFutureTest exten
1658
1659		checkCompletedWithWrappedCancellationException(h);
1660		checkCancelled(g);
1661	<	assertFalse(r.ran());
1661	>	assertEquals(0, r.invocationCount);
1662		checkCompletedNormally(f, v1);
1663	<	}
1499	<	}
1663	>	}}
1664
1665		public void testThenAcceptBoth_sourceCancelled3() {
1666		for (ExecutionMode m : ExecutionMode.values())
1667		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1668	<	for (Integer v1 : new Integer[] { 1, null }) {
1669	<
1668	>	for (Integer v1 : new Integer[] { 1, null })
1669	>	{
1670		final CompletableFuture<Integer> f = new CompletableFuture<>();
1671		final CompletableFuture<Integer> g = new CompletableFuture<>();
1672		final SubtractAction r = new SubtractAction();
#	Line 1513 | Line 1677 | public class CompletableFutureTest exten
1677
1678		checkCompletedWithWrappedCancellationException(h);
1679		checkCancelled(g);
1680	<	assertFalse(r.ran());
1680	>	assertEquals(0, r.invocationCount);
1681		checkCompletedNormally(f, v1);
1682	<	}
1519	<	}
1682	>	}}
1683
1684		public void testThenAcceptBoth_sourceCancelled4() {
1685		for (ExecutionMode m : ExecutionMode.values())
1686		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1687	<	for (Integer v1 : new Integer[] { 1, null }) {
1688	<
1687	>	for (Integer v1 : new Integer[] { 1, null })
1688	>	{
1689		final CompletableFuture<Integer> f = new CompletableFuture<>();
1690		final CompletableFuture<Integer> g = new CompletableFuture<>();
1691		final SubtractAction r = new SubtractAction();
#	Line 1533 | Line 1696 | public class CompletableFutureTest exten
1696
1697		checkCompletedWithWrappedCancellationException(h);
1698		checkCancelled(f);
1699	<	assertFalse(r.ran());
1699	>	assertEquals(0, r.invocationCount);
1700		checkCompletedNormally(g, v1);
1701	<	}
1539	<	}
1701	>	}}
1702
1703		/**
1704		* runAfterBoth result completes normally after normal
#	Line 1545 | Line 1707 | public class CompletableFutureTest exten
1707		public void testRunAfterBoth_normalCompletion1() {
1708		for (ExecutionMode m : ExecutionMode.values())
1709		for (Integer v1 : new Integer[] { 1, null })
1710	<	for (Integer v2 : new Integer[] { 2, null }) {
1711	<
1710	>	for (Integer v2 : new Integer[] { 2, null })
1711	>	{
1712		final CompletableFuture<Integer> f = new CompletableFuture<>();
1713		final CompletableFuture<Integer> g = new CompletableFuture<>();
1714		final Noop r = new Noop();
#	Line 1554 | Line 1716 | public class CompletableFutureTest exten
1716
1717		f.complete(v1);
1718		checkIncomplete(h);
1719	<	assertFalse(r.ran);
1719	>	assertEquals(0, r.invocationCount);
1720		g.complete(v2);
1721
1722		checkCompletedNormally(h, null);
1723	<	assertTrue(r.ran);
1723	>	assertEquals(1, r.invocationCount);
1724		checkCompletedNormally(f, v1);
1725		checkCompletedNormally(g, v2);
1726	<	}
1565	<	}
1726	>	}}
1727
1728		public void testRunAfterBoth_normalCompletion2() {
1729		for (ExecutionMode m : ExecutionMode.values())
1730		for (Integer v1 : new Integer[] { 1, null })
1731	<	for (Integer v2 : new Integer[] { 2, null }) {
1732	<
1731	>	for (Integer v2 : new Integer[] { 2, null })
1732	>	{
1733		final CompletableFuture<Integer> f = new CompletableFuture<>();
1734		final CompletableFuture<Integer> g = new CompletableFuture<>();
1735		final Noop r = new Noop();
#	Line 1576 | Line 1737 | public class CompletableFutureTest exten
1737
1738		g.complete(v2);
1739		checkIncomplete(h);
1740	<	assertFalse(r.ran);
1740	>	assertEquals(0, r.invocationCount);
1741		f.complete(v1);
1742
1743		checkCompletedNormally(h, null);
1744	<	assertTrue(r.ran);
1744	>	assertEquals(1, r.invocationCount);
1745		checkCompletedNormally(f, v1);
1746		checkCompletedNormally(g, v2);
1747	<	}
1587	<	}
1747	>	}}
1748
1749		public void testRunAfterBoth_normalCompletion3() {
1750		for (ExecutionMode m : ExecutionMode.values())
1751		for (Integer v1 : new Integer[] { 1, null })
1752	<	for (Integer v2 : new Integer[] { 2, null }) {
1753	<
1752	>	for (Integer v2 : new Integer[] { 2, null })
1753	>	{
1754		final CompletableFuture<Integer> f = new CompletableFuture<>();
1755		final CompletableFuture<Integer> g = new CompletableFuture<>();
1756		final Noop r = new Noop();
#	Line 1600 | Line 1760 | public class CompletableFutureTest exten
1760		final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1761
1762		checkCompletedNormally(h, null);
1763	<	assertTrue(r.ran);
1763	>	assertEquals(1, r.invocationCount);
1764		checkCompletedNormally(f, v1);
1765		checkCompletedNormally(g, v2);
1766	<	}
1607	<	}
1766	>	}}
1767
1768		public void testRunAfterBoth_normalCompletion4() {
1769		for (ExecutionMode m : ExecutionMode.values())
1770		for (Integer v1 : new Integer[] { 1, null })
1771	<	for (Integer v2 : new Integer[] { 2, null }) {
1772	<
1771	>	for (Integer v2 : new Integer[] { 2, null })
1772	>	{
1773		final CompletableFuture<Integer> f = new CompletableFuture<>();
1774		final CompletableFuture<Integer> g = new CompletableFuture<>();
1775		final Noop r = new Noop();
#	Line 1620 | Line 1779 | public class CompletableFutureTest exten
1779		final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1780
1781		checkCompletedNormally(h, null);
1782	<	assertTrue(r.ran);
1782	>	assertEquals(1, r.invocationCount);
1783		checkCompletedNormally(f, v1);
1784		checkCompletedNormally(g, v2);
1785	<	}
1627	<	}
1785	>	}}
1786
1787		/**
1788		* runAfterBoth result completes exceptionally after exceptional
#	Line 1632 | Line 1790 | public class CompletableFutureTest exten
1790		*/
1791		public void testRunAfterBoth_exceptionalCompletion1() {
1792		for (ExecutionMode m : ExecutionMode.values())
1793	<	for (Integer v1 : new Integer[] { 1, null }) {
1794	<
1793	>	for (Integer v1 : new Integer[] { 1, null })
1794	>	{
1795		final CompletableFuture<Integer> f = new CompletableFuture<>();
1796		final CompletableFuture<Integer> g = new CompletableFuture<>();
1797		final Noop r = new Noop();
#	Line 1646 | Line 1804 | public class CompletableFutureTest exten
1804
1805		checkCompletedWithWrappedCFException(h, ex);
1806		checkCompletedWithWrappedCFException(f, ex);
1807	<	assertFalse(r.ran);
1807	>	assertEquals(0, r.invocationCount);
1808		checkCompletedNormally(g, v1);
1809	<	}
1652	<	}
1809	>	}}
1810
1811		public void testRunAfterBoth_exceptionalCompletion2() {
1812		for (ExecutionMode m : ExecutionMode.values())
1813	<	for (Integer v1 : new Integer[] { 1, null }) {
1814	<
1813	>	for (Integer v1 : new Integer[] { 1, null })
1814	>	{
1815		final CompletableFuture<Integer> f = new CompletableFuture<>();
1816		final CompletableFuture<Integer> g = new CompletableFuture<>();
1817		final Noop r = new Noop();
#	Line 1667 | Line 1824 | public class CompletableFutureTest exten
1824
1825		checkCompletedWithWrappedCFException(h, ex);
1826		checkCompletedWithWrappedCFException(g, ex);
1827	<	assertFalse(r.ran);
1827	>	assertEquals(0, r.invocationCount);
1828		checkCompletedNormally(f, v1);
1829	<	}
1673	<	}
1829	>	}}
1830
1831		public void testRunAfterBoth_exceptionalCompletion3() {
1832		for (ExecutionMode m : ExecutionMode.values())
1833	<	for (Integer v1 : new Integer[] { 1, null }) {
1834	<
1833	>	for (Integer v1 : new Integer[] { 1, null })
1834	>	{
1835		final CompletableFuture<Integer> f = new CompletableFuture<>();
1836		final CompletableFuture<Integer> g = new CompletableFuture<>();
1837		final Noop r = new Noop();
#	Line 1687 | Line 1843 | public class CompletableFutureTest exten
1843
1844		checkCompletedWithWrappedCFException(h, ex);
1845		checkCompletedWithWrappedCFException(g, ex);
1846	<	assertFalse(r.ran);
1846	>	assertEquals(0, r.invocationCount);
1847		checkCompletedNormally(f, v1);
1848	<	}
1693	<	}
1848	>	}}
1849
1850		public void testRunAfterBoth_exceptionalCompletion4() {
1851		for (ExecutionMode m : ExecutionMode.values())
1852	<	for (Integer v1 : new Integer[] { 1, null }) {
1853	<
1852	>	for (Integer v1 : new Integer[] { 1, null })
1853	>	{
1854		final CompletableFuture<Integer> f = new CompletableFuture<>();
1855		final CompletableFuture<Integer> g = new CompletableFuture<>();
1856		final Noop r = new Noop();
#	Line 1707 | Line 1862 | public class CompletableFutureTest exten
1862
1863		checkCompletedWithWrappedCFException(h, ex);
1864		checkCompletedWithWrappedCFException(f, ex);
1865	<	assertFalse(r.ran);
1865	>	assertEquals(0, r.invocationCount);
1866		checkCompletedNormally(g, v1);
1867	<	}
1713	<	}
1867	>	}}
1868
1869		/**
1870		* runAfterBoth result completes exceptionally if action does
#	Line 1718 | Line 1872 | public class CompletableFutureTest exten
1872		public void testRunAfterBoth_actionFailed1() {
1873		for (ExecutionMode m : ExecutionMode.values())
1874		for (Integer v1 : new Integer[] { 1, null })
1875	<	for (Integer v2 : new Integer[] { 2, null }) {
1876	<
1875	>	for (Integer v2 : new Integer[] { 2, null })
1876	>	{
1877		final CompletableFuture<Integer> f = new CompletableFuture<>();
1878		final CompletableFuture<Integer> g = new CompletableFuture<>();
1879		final FailingNoop r = new FailingNoop();
#	Line 1732 | Line 1886 | public class CompletableFutureTest exten
1886		checkCompletedWithWrappedCFException(h);
1887		checkCompletedNormally(f, v1);
1888		checkCompletedNormally(g, v2);
1889	<	}
1736	<	}
1889	>	}}
1890
1891		public void testRunAfterBoth_actionFailed2() {
1892		for (ExecutionMode m : ExecutionMode.values())
1893		for (Integer v1 : new Integer[] { 1, null })
1894	<	for (Integer v2 : new Integer[] { 2, null }) {
1895	<
1894	>	for (Integer v2 : new Integer[] { 2, null })
1895	>	{
1896		final CompletableFuture<Integer> f = new CompletableFuture<>();
1897		final CompletableFuture<Integer> g = new CompletableFuture<>();
1898		final FailingNoop r = new FailingNoop();
#	Line 1752 | Line 1905 | public class CompletableFutureTest exten
1905		checkCompletedWithWrappedCFException(h);
1906		checkCompletedNormally(f, v1);
1907		checkCompletedNormally(g, v2);
1908	<	}
1756	<	}
1908	>	}}
1909
1910		/**
1911		* runAfterBoth result completes exceptionally if either source cancelled
#	Line 1761 | Line 1913 | public class CompletableFutureTest exten
1913		public void testRunAfterBoth_sourceCancelled1() {
1914		for (ExecutionMode m : ExecutionMode.values())
1915		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1916	<	for (Integer v1 : new Integer[] { 1, null }) {
1917	<
1916	>	for (Integer v1 : new Integer[] { 1, null })
1917	>	{
1918		final CompletableFuture<Integer> f = new CompletableFuture<>();
1919		final CompletableFuture<Integer> g = new CompletableFuture<>();
1920		final Noop r = new Noop();
#	Line 1774 | Line 1926 | public class CompletableFutureTest exten
1926
1927		checkCompletedWithWrappedCancellationException(h);
1928		checkCancelled(f);
1929	<	assertFalse(r.ran);
1929	>	assertEquals(0, r.invocationCount);
1930		checkCompletedNormally(g, v1);
1931	<	}
1780	<	}
1931	>	}}
1932
1933		public void testRunAfterBoth_sourceCancelled2() {
1934		for (ExecutionMode m : ExecutionMode.values())
1935		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1936	<	for (Integer v1 : new Integer[] { 1, null }) {
1937	<
1936	>	for (Integer v1 : new Integer[] { 1, null })
1937	>	{
1938		final CompletableFuture<Integer> f = new CompletableFuture<>();
1939		final CompletableFuture<Integer> g = new CompletableFuture<>();
1940		final Noop r = new Noop();
#	Line 1795 | Line 1946 | public class CompletableFutureTest exten
1946
1947		checkCompletedWithWrappedCancellationException(h);
1948		checkCancelled(g);
1949	<	assertFalse(r.ran);
1949	>	assertEquals(0, r.invocationCount);
1950		checkCompletedNormally(f, v1);
1951	<	}
1801	<	}
1951	>	}}
1952
1953		public void testRunAfterBoth_sourceCancelled3() {
1954		for (ExecutionMode m : ExecutionMode.values())
1955		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1956	<	for (Integer v1 : new Integer[] { 1, null }) {
1957	<
1956	>	for (Integer v1 : new Integer[] { 1, null })
1957	>	{
1958		final CompletableFuture<Integer> f = new CompletableFuture<>();
1959		final CompletableFuture<Integer> g = new CompletableFuture<>();
1960		final Noop r = new Noop();
#	Line 1815 | Line 1965 | public class CompletableFutureTest exten
1965
1966		checkCompletedWithWrappedCancellationException(h);
1967		checkCancelled(g);
1968	<	assertFalse(r.ran);
1968	>	assertEquals(0, r.invocationCount);
1969		checkCompletedNormally(f, v1);
1970	<	}
1821	<	}
1970	>	}}
1971
1972		public void testRunAfterBoth_sourceCancelled4() {
1973		for (ExecutionMode m : ExecutionMode.values())
1974		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1975	<	for (Integer v1 : new Integer[] { 1, null }) {
1976	<
1975	>	for (Integer v1 : new Integer[] { 1, null })
1976	>	{
1977		final CompletableFuture<Integer> f = new CompletableFuture<>();
1978		final CompletableFuture<Integer> g = new CompletableFuture<>();
1979		final Noop r = new Noop();
#	Line 1835 | Line 1984 | public class CompletableFutureTest exten
1984
1985		checkCompletedWithWrappedCancellationException(h);
1986		checkCancelled(f);
1987	<	assertFalse(r.ran);
1987	>	assertEquals(0, r.invocationCount);
1988		checkCompletedNormally(g, v1);
1989	<	}
1841	<	}
1989	>	}}
1990
1991		/**
1992		* applyToEither result completes normally after normal completion
#	Line 1847 | Line 1995 | public class CompletableFutureTest exten
1995		public void testApplyToEither_normalCompletion1() {
1996		for (ExecutionMode m : ExecutionMode.values())
1997		for (Integer v1 : new Integer[] { 1, null })
1998	<	for (Integer v2 : new Integer[] { 2, null }) {
1999	<
1998	>	for (Integer v2 : new Integer[] { 2, null })
1999	>	{
2000		final CompletableFuture<Integer> f = new CompletableFuture<>();
2001		final CompletableFuture<Integer> g = new CompletableFuture<>();
2002		final IncFunction r = new IncFunction();
#	Line 1861 | Line 2009 | public class CompletableFutureTest exten
2009		checkCompletedNormally(f, v1);
2010		checkCompletedNormally(g, v2);
2011		checkCompletedNormally(h, inc(v1));
2012	<	}
1865	<	}
2012	>	}}
2013
2014		public void testApplyToEither_normalCompletion2() {
2015		for (ExecutionMode m : ExecutionMode.values())
2016		for (Integer v1 : new Integer[] { 1, null })
2017	<	for (Integer v2 : new Integer[] { 2, null }) {
2018	<
2017	>	for (Integer v2 : new Integer[] { 2, null })
2018	>	{
2019		final CompletableFuture<Integer> f = new CompletableFuture<>();
2020		final CompletableFuture<Integer> g = new CompletableFuture<>();
2021		final IncFunction r = new IncFunction();
#	Line 1881 | Line 2028 | public class CompletableFutureTest exten
2028		checkCompletedNormally(f, v1);
2029		checkCompletedNormally(g, v2);
2030		checkCompletedNormally(h, inc(v2));
2031	<	}
2032	<	}
2031	>	}}
2032	>
2033		public void testApplyToEither_normalCompletion3() {
2034		for (ExecutionMode m : ExecutionMode.values())
2035		for (Integer v1 : new Integer[] { 1, null })
2036	<	for (Integer v2 : new Integer[] { 2, null }) {
2037	<
2036	>	for (Integer v2 : new Integer[] { 2, null })
2037	>	{
2038		final CompletableFuture<Integer> f = new CompletableFuture<>();
2039		final CompletableFuture<Integer> g = new CompletableFuture<>();
2040		final IncFunction r = new IncFunction();
#	Line 1902 | Line 2049 | public class CompletableFutureTest exten
2049		// unspecified behavior
2050		assertTrue(Objects.equals(h.join(), inc(v1)) ||
2051		Objects.equals(h.join(), inc(v2)));
2052	<	}
2053	<	}
2052	>	assertEquals(1, r.invocationCount);
2053	>	}}
2054
2055		/**
2056		* applyToEither result completes exceptionally after exceptional
#	Line 1911 | Line 2058 | public class CompletableFutureTest exten
2058		*/
2059		public void testApplyToEither_exceptionalCompletion1() {
2060		for (ExecutionMode m : ExecutionMode.values())
2061	<	for (Integer v1 : new Integer[] { 1, null }) {
2062	<
2061	>	for (Integer v1 : new Integer[] { 1, null })
2062	>	{
2063		final CompletableFuture<Integer> f = new CompletableFuture<>();
2064		final CompletableFuture<Integer> g = new CompletableFuture<>();
2065		final IncFunction r = new IncFunction();
#	Line 1923 | Line 2070 | public class CompletableFutureTest exten
2070		checkCompletedWithWrappedCFException(h, ex);
2071		g.complete(v1);
2072
2073	<	assertFalse(r.ran());
2073	>	assertEquals(0, r.invocationCount);
2074		checkCompletedNormally(g, v1);
2075		checkCompletedWithWrappedCFException(f, ex);
2076		checkCompletedWithWrappedCFException(h, ex);
2077	<	}
1931	<	}
2077	>	}}
2078
2079		public void testApplyToEither_exceptionalCompletion2() {
2080		for (ExecutionMode m : ExecutionMode.values())
2081	<	for (Integer v1 : new Integer[] { 1, null }) {
2082	<
2081	>	for (Integer v1 : new Integer[] { 1, null })
2082	>	{
2083		final CompletableFuture<Integer> f = new CompletableFuture<>();
2084		final CompletableFuture<Integer> g = new CompletableFuture<>();
2085		final IncFunction r = new IncFunction();
#	Line 1944 | Line 2090 | public class CompletableFutureTest exten
2090		checkCompletedWithWrappedCFException(h, ex);
2091		f.complete(v1);
2092
2093	<	assertFalse(r.ran());
2093	>	assertEquals(0, r.invocationCount);
2094		checkCompletedNormally(f, v1);
2095		checkCompletedWithWrappedCFException(g, ex);
2096		checkCompletedWithWrappedCFException(h, ex);
2097	<	}
1952	<	}
2097	>	}}
2098
2099		public void testApplyToEither_exceptionalCompletion3() {
2100		for (ExecutionMode m : ExecutionMode.values())
2101	<	for (Integer v1 : new Integer[] { 1, null }) {
2102	<
2101	>	for (Integer v1 : new Integer[] { 1, null })
2102	>	{
2103		final CompletableFuture<Integer> f = new CompletableFuture<>();
2104		final CompletableFuture<Integer> g = new CompletableFuture<>();
2105		final IncFunction r = new IncFunction();
#	Line 1967 | Line 2112 | public class CompletableFutureTest exten
2112		// unspecified behavior
2113		Integer v;
2114		try {
2115	<	assertEquals(h.join(), inc(v1));
2116	<	assertTrue(r.ran());
2115	>	assertEquals(inc(v1), h.join());
2116	>	assertEquals(1, r.invocationCount);
2117		} catch (CompletionException ok) {
2118		checkCompletedWithWrappedCFException(h, ex);
2119	<	assertFalse(r.ran());
2119	>	assertEquals(0, r.invocationCount);
2120		}
2121
2122		checkCompletedWithWrappedCFException(g, ex);
2123		checkCompletedNormally(f, v1);
2124	<	}
1980	<	}
2124	>	}}
2125
2126		public void testApplyToEither_exceptionalCompletion4() {
2127		for (ExecutionMode m : ExecutionMode.values())
2128	<	for (Integer v1 : new Integer[] { 1, null }) {
2129	<
2128	>	for (Integer v1 : new Integer[] { 1, null })
2129	>	{
2130		final CompletableFuture<Integer> f = new CompletableFuture<>();
2131		final CompletableFuture<Integer> g = new CompletableFuture<>();
2132		final IncFunction r = new IncFunction();
#	Line 1995 | Line 2139 | public class CompletableFutureTest exten
2139		// unspecified behavior
2140		Integer v;
2141		try {
2142	<	assertEquals(h.join(), inc(v1));
2143	<	assertTrue(r.ran());
2142	>	assertEquals(inc(v1), h.join());
2143	>	assertEquals(1, r.invocationCount);
2144		} catch (CompletionException ok) {
2145		checkCompletedWithWrappedCFException(h, ex);
2146	<	assertFalse(r.ran());
2146	>	assertEquals(0, r.invocationCount);
2147		}
2148
2149		checkCompletedWithWrappedCFException(f, ex);
2006	–	assertFalse(r.ran());
2150		checkCompletedNormally(g, v1);
2151	<	}
2009	<	}
2151	>	}}
2152
2153		/**
2154		* applyToEither result completes exceptionally if action does
#	Line 2014 | Line 2156 | public class CompletableFutureTest exten
2156		public void testApplyToEither_actionFailed1() {
2157		for (ExecutionMode m : ExecutionMode.values())
2158		for (Integer v1 : new Integer[] { 1, null })
2159	<	for (Integer v2 : new Integer[] { 2, null }) {
2160	<
2159	>	for (Integer v2 : new Integer[] { 2, null })
2160	>	{
2161		final CompletableFuture<Integer> f = new CompletableFuture<>();
2162		final CompletableFuture<Integer> g = new CompletableFuture<>();
2163		final FailingFunction r = new FailingFunction();
#	Line 2026 | Line 2168 | public class CompletableFutureTest exten
2168		g.complete(v2);
2169		checkCompletedNormally(f, v1);
2170		checkCompletedNormally(g, v2);
2171	<	}
2030	<	}
2171	>	}}
2172
2173		public void testApplyToEither_actionFailed2() {
2174		for (ExecutionMode m : ExecutionMode.values())
2175		for (Integer v1 : new Integer[] { 1, null })
2176	<	for (Integer v2 : new Integer[] { 2, null }) {
2177	<
2176	>	for (Integer v2 : new Integer[] { 2, null })
2177	>	{
2178		final CompletableFuture<Integer> f = new CompletableFuture<>();
2179		final CompletableFuture<Integer> g = new CompletableFuture<>();
2180		final FailingFunction r = new FailingFunction();
#	Line 2044 | Line 2185 | public class CompletableFutureTest exten
2185		f.complete(v1);
2186		checkCompletedNormally(f, v1);
2187		checkCompletedNormally(g, v2);
2188	<	}
2048	<	}
2188	>	}}
2189
2190		/**
2191		* applyToEither result completes exceptionally if either source cancelled
#	Line 2053 | Line 2193 | public class CompletableFutureTest exten
2193		public void testApplyToEither_sourceCancelled1() {
2194		for (ExecutionMode m : ExecutionMode.values())
2195		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2196	<	for (Integer v1 : new Integer[] { 1, null }) {
2197	<
2196	>	for (Integer v1 : new Integer[] { 1, null })
2197	>	{
2198		final CompletableFuture<Integer> f = new CompletableFuture<>();
2199		final CompletableFuture<Integer> g = new CompletableFuture<>();
2200		final IncFunction r = new IncFunction();
#	Line 2065 | Line 2205 | public class CompletableFutureTest exten
2205		g.complete(v1);
2206
2207		checkCancelled(f);
2208	<	assertFalse(r.ran());
2208	>	assertEquals(0, r.invocationCount);
2209		checkCompletedNormally(g, v1);
2210		checkCompletedWithWrappedCancellationException(h);
2211	<	}
2072	<	}
2211	>	}}
2212
2213		public void testApplyToEither_sourceCancelled2() {
2214		for (ExecutionMode m : ExecutionMode.values())
2215		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2216	<	for (Integer v1 : new Integer[] { 1, null }) {
2217	<
2216	>	for (Integer v1 : new Integer[] { 1, null })
2217	>	{
2218		final CompletableFuture<Integer> f = new CompletableFuture<>();
2219		final CompletableFuture<Integer> g = new CompletableFuture<>();
2220		final IncFunction r = new IncFunction();
#	Line 2086 | Line 2225 | public class CompletableFutureTest exten
2225		f.complete(v1);
2226
2227		checkCancelled(g);
2228	<	assertFalse(r.ran());
2228	>	assertEquals(0, r.invocationCount);
2229		checkCompletedNormally(f, v1);
2230		checkCompletedWithWrappedCancellationException(h);
2231	<	}
2093	<	}
2231	>	}}
2232
2233		public void testApplyToEither_sourceCancelled3() {
2234		for (ExecutionMode m : ExecutionMode.values())
2235		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2236	<	for (Integer v1 : new Integer[] { 1, null }) {
2237	<
2236	>	for (Integer v1 : new Integer[] { 1, null })
2237	>	{
2238		final CompletableFuture<Integer> f = new CompletableFuture<>();
2239		final CompletableFuture<Integer> g = new CompletableFuture<>();
2240		final IncFunction r = new IncFunction();
#	Line 2108 | Line 2246 | public class CompletableFutureTest exten
2246		// unspecified behavior
2247		Integer v;
2248		try {
2249	<	assertEquals(h.join(), inc(v1));
2250	<	assertTrue(r.ran());
2249	>	assertEquals(inc(v1), h.join());
2250	>	assertEquals(1, r.invocationCount);
2251		} catch (CompletionException ok) {
2252		checkCompletedWithWrappedCancellationException(h);
2253	<	assertFalse(r.ran());
2253	>	assertEquals(0, r.invocationCount);
2254		}
2255
2256		checkCancelled(g);
2257		checkCompletedNormally(f, v1);
2258	<	}
2121	<	}
2258	>	}}
2259
2260		public void testApplyToEither_sourceCancelled4() {
2261		for (ExecutionMode m : ExecutionMode.values())
2262		for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2263	<	for (Integer v1 : new Integer[] { 1, null }) {
2264	<
2263	>	for (Integer v1 : new Integer[] { 1, null })
2264	>	{
2265		final CompletableFuture<Integer> f = new CompletableFuture<>();
2266		final CompletableFuture<Integer> g = new CompletableFuture<>();
2267		final IncFunction r = new IncFunction();
#	Line 2136 | Line 2273 | public class CompletableFutureTest exten
2273		// unspecified behavior
2274		Integer v;
2275		try {
2276	<	assertEquals(h.join(), inc(v1));
2277	<	assertTrue(r.ran());
2276	>	assertEquals(inc(v1), h.join());
2277	>	assertEquals(1, r.invocationCount);
2278		} catch (CompletionException ok) {
2279		checkCompletedWithWrappedCancellationException(h);
2280	<	assertFalse(r.ran());
2280	>	assertEquals(0, r.invocationCount);
2281		}
2282
2283		checkCancelled(f);
2284		checkCompletedNormally(g, v1);
2285	<	}
2149	<	}
2285	>	}}
2286
2287		/**
2288		* acceptEither result completes normally after normal completion
2289		* of either source
2290		*/
2291	<	public void testAcceptEither() {
2292	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2293	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2294	<	IncAction r = new IncAction();
2295	<	CompletableFuture<Void> g = f.acceptEither(f2, r);
2296	<	f.complete(one);
2297	<	checkCompletedNormally(g, null);
2298	<	f2.complete(one);
2299	<	checkCompletedNormally(g, null);
2164	<	assertEquals(r.value, (Integer) 2);
2291	>	public void testAcceptEither_normalCompletion1() {
2292	>	for (ExecutionMode m : ExecutionMode.values())
2293	>	for (Integer v1 : new Integer[] { 1, null })
2294	>	for (Integer v2 : new Integer[] { 2, null })
2295	>	{
2296	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2297	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2298	>	final IncAction r = new IncAction();
2299	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2300
2301	<	r = new IncAction();
2302	<	f = new CompletableFuture<>();
2303	<	f.complete(one);
2304	<	f2 = new CompletableFuture<>();
2305	<	g = f.acceptEither(f2, r);
2306	<	checkCompletedNormally(g, null);
2307	<	assertEquals(r.value, (Integer) 2);
2308	<	}
2301	>	f.complete(v1);
2302	>	checkCompletedNormally(h, null);
2303	>	assertEquals(inc(v1), r.value);
2304	>	g.complete(v2);
2305	>
2306	>	checkCompletedNormally(f, v1);
2307	>	checkCompletedNormally(g, v2);
2308	>	checkCompletedNormally(h, null);
2309	>	}}
2310	>
2311	>	public void testAcceptEither_normalCompletion2() {
2312	>	for (ExecutionMode m : ExecutionMode.values())
2313	>	for (Integer v1 : new Integer[] { 1, null })
2314	>	for (Integer v2 : new Integer[] { 2, null })
2315	>	{
2316	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2317	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2318	>	final IncAction r = new IncAction();
2319	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2320	>
2321	>	g.complete(v2);
2322	>	checkCompletedNormally(h, null);
2323	>	assertEquals(inc(v2), r.value);
2324	>	f.complete(v1);
2325	>
2326	>	checkCompletedNormally(f, v1);
2327	>	checkCompletedNormally(g, v2);
2328	>	checkCompletedNormally(h, null);
2329	>	}}
2330	>
2331	>	public void testAcceptEither_normalCompletion3() {
2332	>	for (ExecutionMode m : ExecutionMode.values())
2333	>	for (Integer v1 : new Integer[] { 1, null })
2334	>	for (Integer v2 : new Integer[] { 2, null })
2335	>	{
2336	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2337	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2338	>	final IncAction r = new IncAction();
2339	>
2340	>	f.complete(v1);
2341	>	g.complete(v2);
2342	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2343	>
2344	>	checkCompletedNormally(h, null);
2345	>	checkCompletedNormally(f, v1);
2346	>	checkCompletedNormally(g, v2);
2347	>
2348	>	// unspecified behavior
2349	>	assertTrue(Objects.equals(r.value, inc(v1)) ||
2350	>	Objects.equals(r.value, inc(v2)));
2351	>	}}
2352
2353		/**
2354		* acceptEither result completes exceptionally after exceptional
2355		* completion of either source
2356		*/
2357	<	public void testAcceptEither2() {
2358	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2359	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2360	<	IncAction r = new IncAction();
2361	<	CompletableFuture<Void> g = f.acceptEither(f2, r);
2362	<	f.completeExceptionally(new CFException());
2363	<	f2.complete(one);
2364	<	checkCompletedWithWrappedCFException(g);
2357	>	public void testAcceptEither_exceptionalCompletion1() {
2358	>	for (ExecutionMode m : ExecutionMode.values())
2359	>	for (Integer v1 : new Integer[] { 1, null })
2360	>	{
2361	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2362	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2363	>	final IncAction r = new IncAction();
2364	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2365	>	final CFException ex = new CFException();
2366
2367	<	r = new IncAction();
2368	<	f = new CompletableFuture<>();
2369	<	f2 = new CompletableFuture<>();
2191	<	f2.completeExceptionally(new CFException());
2192	<	g = f.acceptEither(f2, r);
2193	<	checkCompletedWithWrappedCFException(g);
2194	<	}
2367	>	f.completeExceptionally(ex);
2368	>	checkCompletedWithWrappedCFException(h, ex);
2369	>	g.complete(v1);
2370
2371	<	/**
2372	<	* acceptEither result completes exceptionally if action does
2373	<	*/
2374	<	public void testAcceptEither3() {
2375	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2201	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2202	<	FailingConsumer r = new FailingConsumer();
2203	<	CompletableFuture<Void> g = f.acceptEither(f2, r);
2204	<	f2.complete(two);
2205	<	checkCompletedWithWrappedCFException(g);
2206	<	}
2371	>	assertEquals(0, r.invocationCount);
2372	>	checkCompletedNormally(g, v1);
2373	>	checkCompletedWithWrappedCFException(f, ex);
2374	>	checkCompletedWithWrappedCFException(h, ex);
2375	>	}}
2376
2377	<	/**
2378	<	* acceptEither result completes exceptionally if either source cancelled
2379	<	*/
2380	<	public void testAcceptEither4() {
2381	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2382	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2383	<	IncAction r = new IncAction();
2384	<	CompletableFuture<Void> g = f.acceptEither(f2, r);
2385	<	assertTrue(f.cancel(true));
2217	<	checkCompletedWithWrappedCancellationException(g);
2218	<	f = new CompletableFuture<>();
2219	<	f2 = new CompletableFuture<>();
2220	<	assertTrue(f2.cancel(true));
2221	<	checkCompletedWithWrappedCancellationException(g);
2222	<	}
2377	>	public void testAcceptEither_exceptionalCompletion2() {
2378	>	for (ExecutionMode m : ExecutionMode.values())
2379	>	for (Integer v1 : new Integer[] { 1, null })
2380	>	{
2381	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2382	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2383	>	final IncAction r = new IncAction();
2384	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2385	>	final CFException ex = new CFException();
2386
2387	<	/**
2388	<	* runAfterEither result completes normally after normal completion
2389	<	* of either source
2227	<	*/
2228	<	public void testRunAfterEither() {
2229	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2230	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2231	<	Noop r = new Noop();
2232	<	CompletableFuture<Void> g = f.runAfterEither(f2, r);
2233	<	f.complete(one);
2234	<	checkCompletedNormally(g, null);
2235	<	f2.complete(one);
2236	<	checkCompletedNormally(g, null);
2237	<	assertTrue(r.ran);
2387	>	g.completeExceptionally(ex);
2388	>	checkCompletedWithWrappedCFException(h, ex);
2389	>	f.complete(v1);
2390
2391	<	r = new Noop();
2392	<	f = new CompletableFuture<>();
2393	<	f.complete(one);
2394	<	f2 = new CompletableFuture<>();
2395	<	g = f.runAfterEither(f2, r);
2244	<	checkCompletedNormally(g, null);
2245	<	assertTrue(r.ran);
2246	<	}
2391	>	assertEquals(0, r.invocationCount);
2392	>	checkCompletedNormally(f, v1);
2393	>	checkCompletedWithWrappedCFException(g, ex);
2394	>	checkCompletedWithWrappedCFException(h, ex);
2395	>	}}
2396
2397	<	/**
2398	<	* runAfterEither result completes exceptionally after exceptional
2399	<	* completion of either source
2400	<	*/
2401	<	public void testRunAfterEither2() {
2402	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2403	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2404	<	Noop r = new Noop();
2256	<	CompletableFuture<Void> g = f.runAfterEither(f2, r);
2257	<	f.completeExceptionally(new CFException());
2258	<	f2.complete(one);
2259	<	checkCompletedWithWrappedCFException(g);
2397	>	public void testAcceptEither_exceptionalCompletion3() {
2398	>	for (ExecutionMode m : ExecutionMode.values())
2399	>	for (Integer v1 : new Integer[] { 1, null })
2400	>	{
2401	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2402	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2403	>	final IncAction r = new IncAction();
2404	>	final CFException ex = new CFException();
2405
2406	<	r = new Noop();
2407	<	f = new CompletableFuture<>();
2408	<	f2 = new CompletableFuture<>();
2264	<	f2.completeExceptionally(new CFException());
2265	<	g = f.runAfterEither(f2, r);
2266	<	checkCompletedWithWrappedCFException(g);
2267	<	}
2406	>	g.completeExceptionally(ex);
2407	>	f.complete(v1);
2408	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2409
2410	<	/**
2411	<	* runAfterEither result completes exceptionally if action does
2412	<	*/
2413	<	public void testRunAfterEither3() {
2414	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2415	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2416	<	FailingNoop r = new FailingNoop();
2417	<	CompletableFuture<Void> g = f.runAfterEither(f2, r);
2418	<	f2.complete(two);
2419	<	checkCompletedWithWrappedCFException(g);
2279	<	}
2410	>	// unspecified behavior
2411	>	Integer v;
2412	>	try {
2413	>	assertNull(h.join());
2414	>	assertEquals(1, r.invocationCount);
2415	>	assertEquals(inc(v1), r.value);
2416	>	} catch (CompletionException ok) {
2417	>	checkCompletedWithWrappedCFException(h, ex);
2418	>	assertEquals(0, r.invocationCount);
2419	>	}
2420
2421	<	/**
2422	<	* runAfterEither result completes exceptionally if either source cancelled
2423	<	*/
2284	<	public void testRunAfterEither4() {
2285	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2286	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2287	<	Noop r = new Noop();
2288	<	CompletableFuture<Void> g = f.runAfterEither(f2, r);
2289	<	assertTrue(f.cancel(true));
2290	<	checkCompletedWithWrappedCancellationException(g);
2291	<	f = new CompletableFuture<>();
2292	<	f2 = new CompletableFuture<>();
2293	<	assertTrue(f2.cancel(true));
2294	<	checkCompletedWithWrappedCancellationException(g);
2295	<	}
2421	>	checkCompletedWithWrappedCFException(g, ex);
2422	>	checkCompletedNormally(f, v1);
2423	>	}}
2424
2425	<	/**
2426	<	* thenCompose result completes normally after normal completion of source
2427	<	*/
2428	<	public void testThenCompose() {
2429	<	CompletableFuture<Integer> f, g;
2430	<	CompletableFutureInc r;
2425	>	public void testAcceptEither_exceptionalCompletion4() {
2426	>	for (ExecutionMode m : ExecutionMode.values())
2427	>	for (Integer v1 : new Integer[] { 1, null })
2428	>	{
2429	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2430	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2431	>	final IncAction r = new IncAction();
2432	>	final CFException ex = new CFException();
2433
2434	<	f = new CompletableFuture<>();
2435	<	g = f.thenCompose(r = new CompletableFutureInc());
2436	<	f.complete(one);
2307	<	checkCompletedNormally(g, two);
2308	<	assertTrue(r.ran);
2434	>	f.completeExceptionally(ex);
2435	>	g.complete(v1);
2436	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2437
2438	<	f = new CompletableFuture<>();
2439	<	f.complete(one);
2440	<	g = f.thenCompose(r = new CompletableFutureInc());
2441	<	checkCompletedNormally(g, two);
2442	<	assertTrue(r.ran);
2443	<	}
2438	>	// unspecified behavior
2439	>	Integer v;
2440	>	try {
2441	>	assertNull(h.join());
2442	>	assertEquals(1, r.invocationCount);
2443	>	assertEquals(inc(v1), r.value);
2444	>	} catch (CompletionException ok) {
2445	>	checkCompletedWithWrappedCFException(h, ex);
2446	>	assertEquals(0, r.invocationCount);
2447	>	}
2448	>
2449	>	checkCompletedWithWrappedCFException(f, ex);
2450	>	checkCompletedNormally(g, v1);
2451	>	}}
2452
2453		/**
2454	<	* thenCompose result completes exceptionally after exceptional
2319	<	* completion of source
2454	>	* acceptEither result completes exceptionally if action does
2455		*/
2456	<	public void testThenCompose2() {
2457	<	CompletableFuture<Integer> f, g;
2458	<	CompletableFutureInc r;
2456	>	public void testAcceptEither_actionFailed1() {
2457	>	for (ExecutionMode m : ExecutionMode.values())
2458	>	for (Integer v1 : new Integer[] { 1, null })
2459	>	for (Integer v2 : new Integer[] { 2, null })
2460	>	{
2461	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2462	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2463	>	final FailingConsumer r = new FailingConsumer();
2464	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2465
2466	<	f = new CompletableFuture<>();
2467	<	g = f.thenCompose(r = new CompletableFutureInc());
2468	<	f.completeExceptionally(new CFException());
2469	<	checkCompletedWithWrappedCFException(g);
2466	>	f.complete(v1);
2467	>	checkCompletedWithWrappedCFException(h);
2468	>	g.complete(v2);
2469	>	checkCompletedNormally(f, v1);
2470	>	checkCompletedNormally(g, v2);
2471	>	}}
2472
2473	<	f = new CompletableFuture<>();
2474	<	f.completeExceptionally(new CFException());
2475	<	g = f.thenCompose(r = new CompletableFutureInc());
2476	<	checkCompletedWithWrappedCFException(g);
2477	<	}
2473	>	public void testAcceptEither_actionFailed2() {
2474	>	for (ExecutionMode m : ExecutionMode.values())
2475	>	for (Integer v1 : new Integer[] { 1, null })
2476	>	for (Integer v2 : new Integer[] { 2, null })
2477	>	{
2478	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2479	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2480	>	final FailingConsumer r = new FailingConsumer();
2481	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2482	>
2483	>	g.complete(v2);
2484	>	checkCompletedWithWrappedCFException(h);
2485	>	f.complete(v1);
2486	>	checkCompletedNormally(f, v1);
2487	>	checkCompletedNormally(g, v2);
2488	>	}}
2489
2490		/**
2491	<	* thenCompose result completes exceptionally if action does
2491	>	* acceptEither result completes exceptionally if either source cancelled
2492		*/
2493	<	public void testThenCompose3() {
2494	<	CompletableFuture<Integer> f, g;
2495	<	FailingCompletableFutureFunction r;
2493	>	public void testAcceptEither_sourceCancelled1() {
2494	>	for (ExecutionMode m : ExecutionMode.values())
2495	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2496	>	for (Integer v1 : new Integer[] { 1, null })
2497	>	{
2498	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2499	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2500	>	final IncAction r = new IncAction();
2501	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2502
2503	<	f = new CompletableFuture<>();
2504	<	g = f.thenCompose(r = new FailingCompletableFutureFunction());
2505	<	f.complete(one);
2346	<	checkCompletedWithWrappedCFException(g);
2503	>	assertTrue(f.cancel(mayInterruptIfRunning));
2504	>	checkCompletedWithWrappedCancellationException(h);
2505	>	g.complete(v1);
2506
2507	<	f = new CompletableFuture<>();
2508	<	f.complete(one);
2509	<	g = f.thenCompose(r = new FailingCompletableFutureFunction());
2510	<	checkCompletedWithWrappedCFException(g);
2511	<	}
2507	>	checkCancelled(f);
2508	>	assertEquals(0, r.invocationCount);
2509	>	checkCompletedNormally(g, v1);
2510	>	checkCompletedWithWrappedCancellationException(h);
2511	>	}}
2512
2513	<	/**
2514	<	* thenCompose result completes exceptionally if source cancelled
2515	<	*/
2516	<	public void testThenCompose4() {
2517	<	CompletableFuture<Integer> f, g;
2518	<	CompletableFutureInc r;
2513	>	public void testAcceptEither_sourceCancelled2() {
2514	>	for (ExecutionMode m : ExecutionMode.values())
2515	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2516	>	for (Integer v1 : new Integer[] { 1, null })
2517	>	{
2518	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2519	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2520	>	final IncAction r = new IncAction();
2521	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2522
2523	<	f = new CompletableFuture<>();
2524	<	g = f.thenCompose(r = new CompletableFutureInc());
2525	<	assertTrue(f.cancel(true));
2364	<	checkCompletedWithWrappedCancellationException(g);
2523	>	assertTrue(g.cancel(mayInterruptIfRunning));
2524	>	checkCompletedWithWrappedCancellationException(h);
2525	>	f.complete(v1);
2526
2527	<	f = new CompletableFuture<>();
2528	<	assertTrue(f.cancel(true));
2529	<	g = f.thenCompose(r = new CompletableFutureInc());
2530	<	checkCompletedWithWrappedCancellationException(g);
2531	<	}
2527	>	checkCancelled(g);
2528	>	assertEquals(0, r.invocationCount);
2529	>	checkCompletedNormally(f, v1);
2530	>	checkCompletedWithWrappedCancellationException(h);
2531	>	}}
2532
2533	<	// asyncs
2533	>	public void testAcceptEither_sourceCancelled3() {
2534	>	for (ExecutionMode m : ExecutionMode.values())
2535	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2536	>	for (Integer v1 : new Integer[] { 1, null })
2537	>	{
2538	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2539	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2540	>	final IncAction r = new IncAction();
2541
2542	<	/**
2543	<	* thenRunAsync result completes normally after normal completion of source
2544	<	*/
2377	<	public void testThenRunAsync() {
2378	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2379	<	Noop r = new Noop();
2380	<	CompletableFuture<Void> g = f.thenRunAsync(r);
2381	<	f.complete(null);
2382	<	checkCompletedNormally(g, null);
2542	>	assertTrue(g.cancel(mayInterruptIfRunning));
2543	>	f.complete(v1);
2544	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2545
2546	<	// reordered version
2547	<	f = new CompletableFuture<>();
2548	<	f.complete(null);
2549	<	r = new Noop();
2550	<	g = f.thenRunAsync(r);
2551	<	checkCompletedNormally(g, null);
2552	<	}
2546	>	// unspecified behavior
2547	>	Integer v;
2548	>	try {
2549	>	assertNull(h.join());
2550	>	assertEquals(1, r.invocationCount);
2551	>	assertEquals(inc(v1), r.value);
2552	>	} catch (CompletionException ok) {
2553	>	checkCompletedWithWrappedCancellationException(h);
2554	>	assertEquals(0, r.invocationCount);
2555	>	}
2556
2557	<	/**
2558	<	* thenRunAsync result completes exceptionally after exceptional
2559	<	* completion of source
2560	<	*/
2561	<	public void testThenRunAsync2() {
2562	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2563	<	Noop r = new Noop();
2564	<	CompletableFuture<Void> g = f.thenRunAsync(r);
2565	<	f.completeExceptionally(new CFException());
2557	>	checkCancelled(g);
2558	>	checkCompletedNormally(f, v1);
2559	>	}}
2560	>
2561	>	public void testAcceptEither_sourceCancelled4() {
2562	>	for (ExecutionMode m : ExecutionMode.values())
2563	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2564	>	for (Integer v1 : new Integer[] { 1, null })
2565	>	{
2566	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2567	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2568	>	final IncAction r = new IncAction();
2569	>
2570	>	assertTrue(f.cancel(mayInterruptIfRunning));
2571	>	g.complete(v1);
2572	>	final CompletableFuture<Void> h = m.acceptEither(f, g, r);
2573	>
2574	>	// unspecified behavior
2575	>	Integer v;
2576		try {
2577	<	g.join();
2578	<	shouldThrow();
2579	<	} catch (CompletionException success) {}
2580	<	checkCompletedWithWrappedCFException(g);
2581	<	}
2577	>	assertNull(h.join());
2578	>	assertEquals(1, r.invocationCount);
2579	>	assertEquals(inc(v1), r.value);
2580	>	} catch (CompletionException ok) {
2581	>	checkCompletedWithWrappedCancellationException(h);
2582	>	assertEquals(0, r.invocationCount);
2583	>	}
2584
2585	<	/**
2586	<	* thenRunAsync result completes exceptionally if action does
2587	<	*/
2411	<	public void testThenRunAsync3() {
2412	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2413	<	FailingNoop r = new FailingNoop();
2414	<	CompletableFuture<Void> g = f.thenRunAsync(r);
2415	<	f.complete(null);
2416	<	checkCompletedWithWrappedCFException(g);
2417	<	}
2585	>	checkCancelled(f);
2586	>	checkCompletedNormally(g, v1);
2587	>	}}
2588
2589		/**
2590	<	* thenRunAsync result completes exceptionally if source cancelled
2590	>	* runAfterEither result completes normally after normal completion
2591	>	* of either source
2592		*/
2593	<	public void testThenRunAsync4() {
2594	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2595	<	Noop r = new Noop();
2596	<	CompletableFuture<Void> g = f.thenRunAsync(r);
2597	<	assertTrue(f.cancel(true));
2598	<	checkCompletedWithWrappedCancellationException(g);
2599	<	}
2593	>	public void testRunAfterEither_normalCompletion1() {
2594	>	for (ExecutionMode m : ExecutionMode.values())
2595	>	for (Integer v1 : new Integer[] { 1, null })
2596	>	for (Integer v2 : new Integer[] { 2, null })
2597	>	{
2598	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2599	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2600	>	final Noop r = new Noop();
2601	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2602
2603	<	/**
2604	<	* thenApplyAsync result completes normally after normal completion of source
2605	<	*/
2606	<	public void testThenApplyAsync() {
2434	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2435	<	CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2436	<	f.complete(one);
2437	<	checkCompletedNormally(g, two);
2438	<	}
2603	>	f.complete(v1);
2604	>	checkCompletedNormally(h, null);
2605	>	assertEquals(1, r.invocationCount);
2606	>	g.complete(v2);
2607
2608	<	/**
2609	<	* thenApplyAsync result completes exceptionally after exceptional
2610	<	* completion of source
2611	<	*/
2612	<	public void testThenApplyAsync2() {
2445	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2446	<	CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2447	<	f.completeExceptionally(new CFException());
2448	<	checkCompletedWithWrappedCFException(g);
2449	<	}
2608	>	checkCompletedNormally(f, v1);
2609	>	checkCompletedNormally(g, v2);
2610	>	checkCompletedNormally(h, null);
2611	>	assertEquals(1, r.invocationCount);
2612	>	}}
2613
2614	<	/**
2615	<	* thenApplyAsync result completes exceptionally if action does
2616	<	*/
2617	<	public void testThenApplyAsync3() {
2618	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2619	<	FailingFunction r = new FailingFunction();
2620	<	CompletableFuture<Integer> g = f.thenApplyAsync(r);
2621	<	f.complete(null);
2622	<	checkCompletedWithWrappedCFException(g);
2460	<	}
2614	>	public void testRunAfterEither_normalCompletion2() {
2615	>	for (ExecutionMode m : ExecutionMode.values())
2616	>	for (Integer v1 : new Integer[] { 1, null })
2617	>	for (Integer v2 : new Integer[] { 2, null })
2618	>	{
2619	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2620	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2621	>	final Noop r = new Noop();
2622	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2623
2624	<	/**
2625	<	* thenApplyAsync result completes exceptionally if source cancelled
2626	<	*/
2627	<	public void testThenApplyAsync4() {
2466	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2467	<	CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2468	<	assertTrue(f.cancel(true));
2469	<	checkCompletedWithWrappedCancellationException(g);
2470	<	}
2624	>	g.complete(v2);
2625	>	checkCompletedNormally(h, null);
2626	>	assertEquals(1, r.invocationCount);
2627	>	f.complete(v1);
2628
2629	<	/**
2630	<	* thenAcceptAsync result completes normally after normal
2631	<	* completion of source
2632	<	*/
2633	<	public void testThenAcceptAsync() {
2477	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2478	<	IncAction r = new IncAction();
2479	<	CompletableFuture<Void> g = f.thenAcceptAsync(r);
2480	<	f.complete(one);
2481	<	checkCompletedNormally(g, null);
2482	<	assertEquals(r.value, (Integer) 2);
2483	<	}
2629	>	checkCompletedNormally(f, v1);
2630	>	checkCompletedNormally(g, v2);
2631	>	checkCompletedNormally(h, null);
2632	>	assertEquals(1, r.invocationCount);
2633	>	}}
2634
2635	<	/**
2636	<	* thenAcceptAsync result completes exceptionally after exceptional
2637	<	* completion of source
2638	<	*/
2639	<	public void testThenAcceptAsync2() {
2640	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2641	<	IncAction r = new IncAction();
2642	<	CompletableFuture<Void> g = f.thenAcceptAsync(r);
2493	<	f.completeExceptionally(new CFException());
2494	<	checkCompletedWithWrappedCFException(g);
2495	<	}
2635	>	public void testRunAfterEither_normalCompletion3() {
2636	>	for (ExecutionMode m : ExecutionMode.values())
2637	>	for (Integer v1 : new Integer[] { 1, null })
2638	>	for (Integer v2 : new Integer[] { 2, null })
2639	>	{
2640	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2641	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2642	>	final Noop r = new Noop();
2643
2644	<	/**
2645	<	* thenAcceptAsync result completes exceptionally if action does
2646	<	*/
2500	<	public void testThenAcceptAsync3() {
2501	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2502	<	FailingConsumer r = new FailingConsumer();
2503	<	CompletableFuture<Void> g = f.thenAcceptAsync(r);
2504	<	f.complete(null);
2505	<	checkCompletedWithWrappedCFException(g);
2506	<	}
2644	>	f.complete(v1);
2645	>	g.complete(v2);
2646	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2647
2648	<	/**
2649	<	* thenAcceptAsync result completes exceptionally if source cancelled
2650	<	*/
2651	<	public void testThenAcceptAsync4() {
2652	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2513	<	IncAction r = new IncAction();
2514	<	CompletableFuture<Void> g = f.thenAcceptAsync(r);
2515	<	assertTrue(f.cancel(true));
2516	<	checkCompletedWithWrappedCancellationException(g);
2517	<	}
2648	>	checkCompletedNormally(h, null);
2649	>	checkCompletedNormally(f, v1);
2650	>	checkCompletedNormally(g, v2);
2651	>	assertEquals(1, r.invocationCount);
2652	>	}}
2653
2654		/**
2655	<	* acceptEitherAsync result completes normally after normal
2656	<	* completion of sources
2655	>	* runAfterEither result completes exceptionally after exceptional
2656	>	* completion of either source
2657		*/
2658	<	public void testAcceptEitherAsync() {
2659	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2660	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2661	<	IncAction r = new IncAction();
2662	<	CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
2663	<	f.complete(one);
2664	<	checkCompletedNormally(g, null);
2665	<	assertEquals(r.value, (Integer) 2);
2658	>	public void testRunAfterEither_exceptionalCompletion1() {
2659	>	for (ExecutionMode m : ExecutionMode.values())
2660	>	for (Integer v1 : new Integer[] { 1, null })
2661	>	{
2662	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2663	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2664	>	final Noop r = new Noop();
2665	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2666	>	final CFException ex = new CFException();
2667
2668	<	r = new IncAction();
2669	<	f = new CompletableFuture<>();
2670	<	f.complete(one);
2535	<	f2 = new CompletableFuture<>();
2536	<	g = f.acceptEitherAsync(f2, r);
2537	<	checkCompletedNormally(g, null);
2538	<	assertEquals(r.value, (Integer) 2);
2539	<	}
2668	>	f.completeExceptionally(ex);
2669	>	checkCompletedWithWrappedCFException(h, ex);
2670	>	g.complete(v1);
2671
2672	<	/**
2673	<	* acceptEitherAsync result completes exceptionally after exceptional
2674	<	* completion of source
2675	<	*/
2676	<	public void testAcceptEitherAsync2() {
2546	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2547	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2548	<	IncAction r = new IncAction();
2549	<	CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
2550	<	f.completeExceptionally(new CFException());
2551	<	checkCompletedWithWrappedCFException(g);
2672	>	assertEquals(0, r.invocationCount);
2673	>	checkCompletedNormally(g, v1);
2674	>	checkCompletedWithWrappedCFException(f, ex);
2675	>	checkCompletedWithWrappedCFException(h, ex);
2676	>	}}
2677
2678	<	r = new IncAction();
2679	<	f = new CompletableFuture<>();
2680	<	f2 = new CompletableFuture<>();
2681	<	f2.completeExceptionally(new CFException());
2682	<	g = f.acceptEitherAsync(f2, r);
2683	<	f.complete(one);
2684	<	checkCompletedWithWrappedCFException(g);
2685	<	}
2678	>	public void testRunAfterEither_exceptionalCompletion2() {
2679	>	for (ExecutionMode m : ExecutionMode.values())
2680	>	for (Integer v1 : new Integer[] { 1, null })
2681	>	{
2682	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2683	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2684	>	final Noop r = new Noop();
2685	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2686	>	final CFException ex = new CFException();
2687
2688	<	/**
2689	<	* acceptEitherAsync result completes exceptionally if action does
2690	<	*/
2565	<	public void testAcceptEitherAsync3() {
2566	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2567	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2568	<	FailingConsumer r = new FailingConsumer();
2569	<	CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
2570	<	f.complete(one);
2571	<	checkCompletedWithWrappedCFException(g);
2572	<	}
2688	>	g.completeExceptionally(ex);
2689	>	checkCompletedWithWrappedCFException(h, ex);
2690	>	f.complete(v1);
2691
2692	<	/**
2693	<	* acceptEitherAsync result completes exceptionally if either
2694	<	* source cancelled
2695	<	*/
2696	<	public void testAcceptEitherAsync4() {
2579	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2580	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2581	<	IncAction r = new IncAction();
2582	<	CompletableFuture<Void> g = f.acceptEitherAsync(f2, r);
2583	<	assertTrue(f.cancel(true));
2584	<	checkCompletedWithWrappedCancellationException(g);
2692	>	assertEquals(0, r.invocationCount);
2693	>	checkCompletedNormally(f, v1);
2694	>	checkCompletedWithWrappedCFException(g, ex);
2695	>	checkCompletedWithWrappedCFException(h, ex);
2696	>	}}
2697
2698	<	r = new IncAction();
2699	<	f = new CompletableFuture<>();
2700	<	f2 = new CompletableFuture<>();
2701	<	assertTrue(f2.cancel(true));
2702	<	g = f.acceptEitherAsync(f2, r);
2703	<	checkCompletedWithWrappedCancellationException(g);
2704	<	}
2698	>	public void testRunAfterEither_exceptionalCompletion3() {
2699	>	for (ExecutionMode m : ExecutionMode.values())
2700	>	for (Integer v1 : new Integer[] { 1, null })
2701	>	{
2702	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2703	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2704	>	final Noop r = new Noop();
2705	>	final CFException ex = new CFException();
2706
2707	<	/**
2708	<	* runAfterEitherAsync result completes normally after normal
2709	<	* completion of sources
2597	<	*/
2598	<	public void testRunAfterEitherAsync() {
2599	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2600	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2601	<	Noop r = new Noop();
2602	<	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2603	<	f.complete(one);
2604	<	checkCompletedNormally(g, null);
2605	<	assertTrue(r.ran);
2707	>	g.completeExceptionally(ex);
2708	>	f.complete(v1);
2709	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2710
2711	<	r = new Noop();
2712	<	f = new CompletableFuture<>();
2713	<	f.complete(one);
2714	<	f2 = new CompletableFuture<>();
2715	<	g = f.runAfterEitherAsync(f2, r);
2716	<	checkCompletedNormally(g, null);
2717	<	assertTrue(r.ran);
2718	<	}
2711	>	// unspecified behavior
2712	>	Integer v;
2713	>	try {
2714	>	assertNull(h.join());
2715	>	assertEquals(1, r.invocationCount);
2716	>	} catch (CompletionException ok) {
2717	>	checkCompletedWithWrappedCFException(h, ex);
2718	>	assertEquals(0, r.invocationCount);
2719	>	}
2720
2721	<	/**
2722	<	* runAfterEitherAsync result completes exceptionally after exceptional
2723	<	* completion of source
2619	<	*/
2620	<	public void testRunAfterEitherAsync2() {
2621	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2622	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2623	<	Noop r = new Noop();
2624	<	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2625	<	f.completeExceptionally(new CFException());
2626	<	checkCompletedWithWrappedCFException(g);
2721	>	checkCompletedWithWrappedCFException(g, ex);
2722	>	checkCompletedNormally(f, v1);
2723	>	}}
2724
2725	<	r = new Noop();
2726	<	f = new CompletableFuture<>();
2727	<	f2 = new CompletableFuture<>();
2728	<	f2.completeExceptionally(new CFException());
2729	<	g = f.runAfterEitherAsync(f2, r);
2730	<	f.complete(one);
2731	<	checkCompletedWithWrappedCFException(g);
2732	<	}
2725	>	public void testRunAfterEither_exceptionalCompletion4() {
2726	>	for (ExecutionMode m : ExecutionMode.values())
2727	>	for (Integer v1 : new Integer[] { 1, null })
2728	>	{
2729	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2730	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2731	>	final Noop r = new Noop();
2732	>	final CFException ex = new CFException();
2733
2734	<	/**
2735	<	* runAfterEitherAsync result completes exceptionally if action does
2736	<	*/
2640	<	public void testRunAfterEitherAsync3() {
2641	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2642	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2643	<	FailingNoop r = new FailingNoop();
2644	<	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2645	<	f.complete(one);
2646	<	checkCompletedWithWrappedCFException(g);
2647	<	}
2734	>	f.completeExceptionally(ex);
2735	>	g.complete(v1);
2736	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2737
2738	<	/**
2739	<	* runAfterEitherAsync result completes exceptionally if either
2740	<	* source cancelled
2741	<	*/
2742	<	public void testRunAfterEitherAsync4() {
2743	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2744	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2745	<	Noop r = new Noop();
2746	<	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r);
2658	<	assertTrue(f.cancel(true));
2659	<	checkCompletedWithWrappedCancellationException(g);
2738	>	// unspecified behavior
2739	>	Integer v;
2740	>	try {
2741	>	assertNull(h.join());
2742	>	assertEquals(1, r.invocationCount);
2743	>	} catch (CompletionException ok) {
2744	>	checkCompletedWithWrappedCFException(h, ex);
2745	>	assertEquals(0, r.invocationCount);
2746	>	}
2747
2748	<	r = new Noop();
2749	<	f = new CompletableFuture<>();
2750	<	f2 = new CompletableFuture<>();
2664	<	assertTrue(f2.cancel(true));
2665	<	g = f.runAfterEitherAsync(f2, r);
2666	<	checkCompletedWithWrappedCancellationException(g);
2667	<	}
2748	>	checkCompletedWithWrappedCFException(f, ex);
2749	>	checkCompletedNormally(g, v1);
2750	>	}}
2751
2752		/**
2753	<	* thenComposeAsync result completes normally after normal
2671	<	* completion of source
2753	>	* runAfterEither result completes exceptionally if action does
2754		*/
2755	<	public void testThenComposeAsync() {
2756	<	CompletableFuture<Integer> f, g;
2757	<	CompletableFutureInc r;
2755	>	public void testRunAfterEither_actionFailed1() {
2756	>	for (ExecutionMode m : ExecutionMode.values())
2757	>	for (Integer v1 : new Integer[] { 1, null })
2758	>	for (Integer v2 : new Integer[] { 2, null })
2759	>	{
2760	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2761	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2762	>	final FailingNoop r = new FailingNoop();
2763	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2764
2765	<	f = new CompletableFuture<>();
2766	<	g = f.thenComposeAsync(r = new CompletableFutureInc());
2767	<	f.complete(one);
2768	<	checkCompletedNormally(g, two);
2765	>	f.complete(v1);
2766	>	checkCompletedWithWrappedCFException(h);
2767	>	g.complete(v2);
2768	>	checkCompletedNormally(f, v1);
2769	>	checkCompletedNormally(g, v2);
2770	>	}}
2771
2772	<	f = new CompletableFuture<>();
2773	<	f.complete(one);
2774	<	g = f.thenComposeAsync(r = new CompletableFutureInc());
2775	<	checkCompletedNormally(g, two);
2776	<	}
2772	>	public void testRunAfterEither_actionFailed2() {
2773	>	for (ExecutionMode m : ExecutionMode.values())
2774	>	for (Integer v1 : new Integer[] { 1, null })
2775	>	for (Integer v2 : new Integer[] { 2, null })
2776	>	{
2777	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2778	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2779	>	final FailingNoop r = new FailingNoop();
2780	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2781	>
2782	>	g.complete(v2);
2783	>	checkCompletedWithWrappedCFException(h);
2784	>	f.complete(v1);
2785	>	checkCompletedNormally(f, v1);
2786	>	checkCompletedNormally(g, v2);
2787	>	}}
2788
2789		/**
2790	<	* thenComposeAsync result completes exceptionally after
2690	<	* exceptional completion of source
2790	>	* runAfterEither result completes exceptionally if either source cancelled
2791		*/
2792	<	public void testThenComposeAsync2() {
2793	<	CompletableFuture<Integer> f, g;
2794	<	CompletableFutureInc r;
2792	>	public void testRunAfterEither_sourceCancelled1() {
2793	>	for (ExecutionMode m : ExecutionMode.values())
2794	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2795	>	for (Integer v1 : new Integer[] { 1, null })
2796	>	{
2797	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2798	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2799	>	final Noop r = new Noop();
2800	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2801
2802	<	f = new CompletableFuture<>();
2803	<	g = f.thenComposeAsync(r = new CompletableFutureInc());
2804	<	f.completeExceptionally(new CFException());
2699	<	checkCompletedWithWrappedCFException(g);
2700	<	assertFalse(r.ran);
2802	>	assertTrue(f.cancel(mayInterruptIfRunning));
2803	>	checkCompletedWithWrappedCancellationException(h);
2804	>	g.complete(v1);
2805
2806	<	f = new CompletableFuture<>();
2807	<	f.completeExceptionally(new CFException());
2808	<	g = f.thenComposeAsync(r = new CompletableFutureInc());
2809	<	checkCompletedWithWrappedCFException(g);
2810	<	assertFalse(r.ran);
2707	<	}
2806	>	checkCancelled(f);
2807	>	assertEquals(0, r.invocationCount);
2808	>	checkCompletedNormally(g, v1);
2809	>	checkCompletedWithWrappedCancellationException(h);
2810	>	}}
2811
2812	<	/**
2813	<	* thenComposeAsync result completes exceptionally if action does
2814	<	*/
2815	<	public void testThenComposeAsync3() {
2816	<	CompletableFuture<Integer> f, g;
2817	<	FailingCompletableFutureFunction r;
2812	>	public void testRunAfterEither_sourceCancelled2() {
2813	>	for (ExecutionMode m : ExecutionMode.values())
2814	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2815	>	for (Integer v1 : new Integer[] { 1, null })
2816	>	{
2817	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2818	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2819	>	final Noop r = new Noop();
2820	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2821
2822	<	f = new CompletableFuture<>();
2823	<	g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
2824	<	f.complete(one);
2719	<	checkCompletedWithWrappedCFException(g);
2822	>	assertTrue(g.cancel(mayInterruptIfRunning));
2823	>	checkCompletedWithWrappedCancellationException(h);
2824	>	f.complete(v1);
2825
2826	<	f = new CompletableFuture<>();
2827	<	f.complete(one);
2828	<	g = f.thenComposeAsync(r = new FailingCompletableFutureFunction());
2829	<	checkCompletedWithWrappedCFException(g);
2830	<	}
2826	>	checkCancelled(g);
2827	>	assertEquals(0, r.invocationCount);
2828	>	checkCompletedNormally(f, v1);
2829	>	checkCompletedWithWrappedCancellationException(h);
2830	>	}}
2831
2832	<	/**
2833	<	* thenComposeAsync result completes exceptionally if source cancelled
2834	<	*/
2835	<	public void testThenComposeAsync4() {
2836	<	CompletableFuture<Integer> f, g;
2837	<	CompletableFutureInc r;
2832	>	public void testRunAfterEither_sourceCancelled3() {
2833	>	for (ExecutionMode m : ExecutionMode.values())
2834	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2835	>	for (Integer v1 : new Integer[] { 1, null })
2836	>	{
2837	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2838	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2839	>	final Noop r = new Noop();
2840
2841	<	f = new CompletableFuture<>();
2842	<	g = f.thenComposeAsync(r = new CompletableFutureInc());
2843	<	assertTrue(f.cancel(true));
2737	<	checkCompletedWithWrappedCancellationException(g);
2841	>	assertTrue(g.cancel(mayInterruptIfRunning));
2842	>	f.complete(v1);
2843	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2844
2845	<	f = new CompletableFuture<>();
2846	<	assertTrue(f.cancel(true));
2847	<	g = f.thenComposeAsync(r = new CompletableFutureInc());
2848	<	checkCompletedWithWrappedCancellationException(g);
2849	<	}
2845	>	// unspecified behavior
2846	>	Integer v;
2847	>	try {
2848	>	assertNull(h.join());
2849	>	assertEquals(1, r.invocationCount);
2850	>	} catch (CompletionException ok) {
2851	>	checkCompletedWithWrappedCancellationException(h);
2852	>	assertEquals(0, r.invocationCount);
2853	>	}
2854
2855	<	// async with explicit executors
2855	>	checkCancelled(g);
2856	>	checkCompletedNormally(f, v1);
2857	>	}}
2858
2859	<	/**
2860	<	* thenRunAsync result completes normally after normal completion of source
2861	<	*/
2862	<	public void testThenRunAsyncE() {
2863	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2864	<	Noop r = new Noop();
2865	<	CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2866	<	f.complete(null);
2755	<	checkCompletedNormally(g, null);
2859	>	public void testRunAfterEither_sourceCancelled4() {
2860	>	for (ExecutionMode m : ExecutionMode.values())
2861	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2862	>	for (Integer v1 : new Integer[] { 1, null })
2863	>	{
2864	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2865	>	final CompletableFuture<Integer> g = new CompletableFuture<>();
2866	>	final Noop r = new Noop();
2867
2868	<	// reordered version
2869	<	f = new CompletableFuture<>();
2870	<	f.complete(null);
2760	<	r = new Noop();
2761	<	g = f.thenRunAsync(r, new ThreadExecutor());
2762	<	checkCompletedNormally(g, null);
2763	<	}
2868	>	assertTrue(f.cancel(mayInterruptIfRunning));
2869	>	g.complete(v1);
2870	>	final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2871
2872	<	/**
2873	<	* thenRunAsync result completes exceptionally after exceptional
2767	<	* completion of source
2768	<	*/
2769	<	public void testThenRunAsync2E() {
2770	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2771	<	Noop r = new Noop();
2772	<	CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2773	<	f.completeExceptionally(new CFException());
2872	>	// unspecified behavior
2873	>	Integer v;
2874		try {
2875	<	g.join();
2876	<	shouldThrow();
2877	<	} catch (CompletionException success) {}
2878	<	checkCompletedWithWrappedCFException(g);
2879	<	}
2875	>	assertNull(h.join());
2876	>	assertEquals(1, r.invocationCount);
2877	>	} catch (CompletionException ok) {
2878	>	checkCompletedWithWrappedCancellationException(h);
2879	>	assertEquals(0, r.invocationCount);
2880	>	}
2881
2882	<	/**
2883	<	* thenRunAsync result completes exceptionally if action does
2884	<	*/
2784	<	public void testThenRunAsync3E() {
2785	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2786	<	FailingNoop r = new FailingNoop();
2787	<	CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2788	<	f.complete(null);
2789	<	checkCompletedWithWrappedCFException(g);
2790	<	}
2882	>	checkCancelled(f);
2883	>	checkCompletedNormally(g, v1);
2884	>	}}
2885
2886		/**
2887	<	* thenRunAsync result completes exceptionally if source cancelled
2887	>	* thenCompose result completes normally after normal completion of source
2888		*/
2889	<	public void testThenRunAsync4E() {
2890	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2891	<	Noop r = new Noop();
2892	<	CompletableFuture<Void> g = f.thenRunAsync(r, new ThreadExecutor());
2893	<	assertTrue(f.cancel(true));
2894	<	checkCompletedWithWrappedCancellationException(g);
2895	<	}
2889	>	public void testThenCompose_normalCompletion() {
2890	>	for (ExecutionMode m : ExecutionMode.values())
2891	>	for (boolean createIncomplete : new boolean[] { true, false })
2892	>	for (Integer v1 : new Integer[] { 1, null })
2893	>	{
2894	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2895	>	final CompletableFutureInc r = new CompletableFutureInc();
2896	>	if (!createIncomplete) f.complete(v1);
2897	>	final CompletableFuture<Integer> g = f.thenCompose(r);
2898	>	if (createIncomplete) f.complete(v1);
2899
2900	<	/**
2901	<	* thenApplyAsync result completes normally after normal completion of source
2902	<	*/
2903	<	public void testThenApplyAsyncE() {
2807	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2808	<	CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
2809	<	f.complete(one);
2810	<	checkCompletedNormally(g, two);
2811	<	}
2900	>	checkCompletedNormally(g, inc(v1));
2901	>	checkCompletedNormally(f, v1);
2902	>	assertEquals(1, r.invocationCount);
2903	>	}}
2904
2905		/**
2906	<	* thenApplyAsync result completes exceptionally after exceptional
2906	>	* thenCompose result completes exceptionally after exceptional
2907		* completion of source
2908		*/
2909	<	public void testThenApplyAsync2E() {
2910	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2911	<	CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
2912	<	f.completeExceptionally(new CFException());
2913	<	checkCompletedWithWrappedCFException(g);
2914	<	}
2909	>	public void testThenCompose_exceptionalCompletion() {
2910	>	for (ExecutionMode m : ExecutionMode.values())
2911	>	for (boolean createIncomplete : new boolean[] { true, false })
2912	>	{
2913	>	final CFException ex = new CFException();
2914	>	final CompletableFutureInc r = new CompletableFutureInc();
2915	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2916	>	if (!createIncomplete) f.completeExceptionally(ex);
2917	>	final CompletableFuture<Integer> g = f.thenCompose(r);
2918	>	if (createIncomplete) f.completeExceptionally(ex);
2919	>
2920	>	checkCompletedWithWrappedCFException(g, ex);
2921	>	checkCompletedWithWrappedCFException(f, ex);
2922	>	assertEquals(0, r.invocationCount);
2923	>	}}
2924
2925		/**
2926	<	* thenApplyAsync result completes exceptionally if action does
2926	>	* thenCompose result completes exceptionally if action does
2927		*/
2928	<	public void testThenApplyAsync3E() {
2929	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2930	<	FailingFunction r = new FailingFunction();
2931	<	CompletableFuture<Integer> g = f.thenApplyAsync(r, new ThreadExecutor());
2932	<	f.complete(null);
2928	>	public void testThenCompose_actionFailed() {
2929	>	for (ExecutionMode m : ExecutionMode.values())
2930	>	for (boolean createIncomplete : new boolean[] { true, false })
2931	>	for (Integer v1 : new Integer[] { 1, null })
2932	>	{
2933	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2934	>	final FailingCompletableFutureFunction r
2935	>	= new FailingCompletableFutureFunction();
2936	>	if (!createIncomplete) f.complete(v1);
2937	>	final CompletableFuture<Integer> g = f.thenCompose(r);
2938	>	if (createIncomplete) f.complete(v1);
2939	>
2940		checkCompletedWithWrappedCFException(g);
2941	<	}
2941	>	checkCompletedNormally(f, v1);
2942	>	}}
2943
2944		/**
2945	<	* thenApplyAsync result completes exceptionally if source cancelled
2945	>	* thenCompose result completes exceptionally if source cancelled
2946		*/
2947	<	public void testThenApplyAsync4E() {
2948	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2949	<	CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
2950	<	assertTrue(f.cancel(true));
2947	>	public void testThenCompose_sourceCancelled() {
2948	>	for (ExecutionMode m : ExecutionMode.values())
2949	>	for (boolean createIncomplete : new boolean[] { true, false })
2950	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
2951	>	{
2952	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
2953	>	final CompletableFutureInc r = new CompletableFutureInc();
2954	>	if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2955	>	final CompletableFuture<Integer> g = f.thenCompose(r);
2956	>	if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2957	>
2958		checkCompletedWithWrappedCancellationException(g);
2959	<	}
2959	>	checkCancelled(f);
2960	>	}}
2961	>
2962	>	// asyncs
2963
2964		/**
2965		* thenAcceptAsync result completes normally after normal
2966		* completion of source
2967		*/
2968	<	public void testThenAcceptAsyncE() {
2968	>	public void testThenAcceptAsync() {
2969		CompletableFuture<Integer> f = new CompletableFuture<>();
2970		IncAction r = new IncAction();
2971	<	CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2971	>	CompletableFuture<Void> g = f.thenAcceptAsync(r);
2972		f.complete(one);
2973		checkCompletedNormally(g, null);
2974		assertEquals(r.value, (Integer) 2);
#	Line 2859 | Line 2978 | public class CompletableFutureTest exten
2978		* thenAcceptAsync result completes exceptionally after exceptional
2979		* completion of source
2980		*/
2981	<	public void testThenAcceptAsync2E() {
2981	>	public void testThenAcceptAsync2() {
2982		CompletableFuture<Integer> f = new CompletableFuture<>();
2983		IncAction r = new IncAction();
2984	<	CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2984	>	CompletableFuture<Void> g = f.thenAcceptAsync(r);
2985		f.completeExceptionally(new CFException());
2986		checkCompletedWithWrappedCFException(g);
2987		}
#	Line 2870 | Line 2989 | public class CompletableFutureTest exten
2989		/**
2990		* thenAcceptAsync result completes exceptionally if action does
2991		*/
2992	<	public void testThenAcceptAsync3E() {
2992	>	public void testThenAcceptAsync3() {
2993		CompletableFuture<Integer> f = new CompletableFuture<>();
2994		FailingConsumer r = new FailingConsumer();
2995	<	CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
2995	>	CompletableFuture<Void> g = f.thenAcceptAsync(r);
2996		f.complete(null);
2997		checkCompletedWithWrappedCFException(g);
2998		}
#	Line 2881 | Line 3000 | public class CompletableFutureTest exten
3000		/**
3001		* thenAcceptAsync result completes exceptionally if source cancelled
3002		*/
3003	<	public void testThenAcceptAsync4E() {
3003	>	public void testThenAcceptAsync4() {
3004		CompletableFuture<Integer> f = new CompletableFuture<>();
3005		IncAction r = new IncAction();
3006	<	CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3006	>	CompletableFuture<Void> g = f.thenAcceptAsync(r);
3007		assertTrue(f.cancel(true));
3008		checkCompletedWithWrappedCancellationException(g);
3009		}
3010
3011	+	// async with explicit executors
3012	+
3013		/**
3014	<	* acceptEitherAsync result completes normally after normal
3015	<	* completion of sources
3014	>	* thenAcceptAsync result completes normally after normal
3015	>	* completion of source
3016		*/
3017	<	public void testAcceptEitherAsyncE() {
3017	>	public void testThenAcceptAsyncE() {
3018		CompletableFuture<Integer> f = new CompletableFuture<>();
2898	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
3019		IncAction r = new IncAction();
3020	<	CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2901	<	f.complete(one);
2902	<	checkCompletedNormally(g, null);
2903	<	assertEquals(r.value, (Integer) 2);
2904	<
2905	<	r = new IncAction();
2906	<	f = new CompletableFuture<>();
3020	>	CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3021		f.complete(one);
2908	–	f2 = new CompletableFuture<>();
2909	–	g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
3022		checkCompletedNormally(g, null);
3023		assertEquals(r.value, (Integer) 2);
3024		}
3025
3026		/**
3027	<	* acceptEitherAsync result completes exceptionally after exceptional
3027	>	* thenAcceptAsync result completes exceptionally after exceptional
3028		* completion of source
3029		*/
3030	<	public void testAcceptEitherAsync2E() {
3030	>	public void testThenAcceptAsync2E() {
3031		CompletableFuture<Integer> f = new CompletableFuture<>();
2920	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
3032		IncAction r = new IncAction();
3033	<	CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
3033	>	CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3034		f.completeExceptionally(new CFException());
3035		checkCompletedWithWrappedCFException(g);
2925	–
2926	–	r = new IncAction();
2927	–	f = new CompletableFuture<>();
2928	–	f2 = new CompletableFuture<>();
2929	–	f2.completeExceptionally(new CFException());
2930	–	g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2931	–	f.complete(one);
2932	–	checkCompletedWithWrappedCFException(g);
3036		}
3037
3038		/**
3039	<	* acceptEitherAsync result completes exceptionally if action does
3039	>	* thenAcceptAsync result completes exceptionally if action does
3040		*/
3041	<	public void testAcceptEitherAsync3E() {
3041	>	public void testThenAcceptAsync3E() {
3042		CompletableFuture<Integer> f = new CompletableFuture<>();
2940	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
3043		FailingConsumer r = new FailingConsumer();
3044	<	CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
3045	<	f.complete(one);
3044	>	CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3045	>	f.complete(null);
3046		checkCompletedWithWrappedCFException(g);
3047		}
3048
3049		/**
3050	<	* acceptEitherAsync result completes exceptionally if either
2949	<	* source cancelled
3050	>	* thenAcceptAsync result completes exceptionally if source cancelled
3051		*/
3052	<	public void testAcceptEitherAsync4E() {
3052	>	public void testThenAcceptAsync4E() {
3053		CompletableFuture<Integer> f = new CompletableFuture<>();
2953	–	CompletableFuture<Integer> f2 = new CompletableFuture<>();
3054		IncAction r = new IncAction();
3055	<	CompletableFuture<Void> g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2956	<	assertTrue(f.cancel(true));
2957	<	checkCompletedWithWrappedCancellationException(g);
2958	<
2959	<	r = new IncAction();
2960	<	f = new CompletableFuture<>();
2961	<	f2 = new CompletableFuture<>();
2962	<	assertTrue(f2.cancel(true));
2963	<	g = f.acceptEitherAsync(f2, r, new ThreadExecutor());
2964	<	checkCompletedWithWrappedCancellationException(g);
2965	<	}
2966	<
2967	<	/**
2968	<	* runAfterEitherAsync result completes normally after normal
2969	<	* completion of sources
2970	<	*/
2971	<	public void testRunAfterEitherAsyncE() {
2972	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2973	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2974	<	Noop r = new Noop();
2975	<	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2976	<	f.complete(one);
2977	<	checkCompletedNormally(g, null);
2978	<	assertTrue(r.ran);
2979	<
2980	<	r = new Noop();
2981	<	f = new CompletableFuture<>();
2982	<	f.complete(one);
2983	<	f2 = new CompletableFuture<>();
2984	<	g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2985	<	checkCompletedNormally(g, null);
2986	<	assertTrue(r.ran);
2987	<	}
2988	<
2989	<	/**
2990	<	* runAfterEitherAsync result completes exceptionally after exceptional
2991	<	* completion of source
2992	<	*/
2993	<	public void testRunAfterEitherAsync2E() {
2994	<	CompletableFuture<Integer> f = new CompletableFuture<>();
2995	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
2996	<	Noop r = new Noop();
2997	<	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
2998	<	f.completeExceptionally(new CFException());
2999	<	checkCompletedWithWrappedCFException(g);
3000	<
3001	<	r = new Noop();
3002	<	f = new CompletableFuture<>();
3003	<	f2 = new CompletableFuture<>();
3004	<	f2.completeExceptionally(new CFException());
3005	<	g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3006	<	f.complete(one);
3007	<	checkCompletedWithWrappedCFException(g);
3008	<	}
3009	<
3010	<	/**
3011	<	* runAfterEitherAsync result completes exceptionally if action does
3012	<	*/
3013	<	public void testRunAfterEitherAsync3E() {
3014	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3015	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
3016	<	FailingNoop r = new FailingNoop();
3017	<	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3018	<	f.complete(one);
3019	<	checkCompletedWithWrappedCFException(g);
3020	<	}
3021	<
3022	<	/**
3023	<	* runAfterEitherAsync result completes exceptionally if either
3024	<	* source cancelled
3025	<	*/
3026	<	public void testRunAfterEitherAsync4E() {
3027	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3028	<	CompletableFuture<Integer> f2 = new CompletableFuture<>();
3029	<	Noop r = new Noop();
3030	<	CompletableFuture<Void> g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3031	<	assertTrue(f.cancel(true));
3032	<	checkCompletedWithWrappedCancellationException(g);
3033	<
3034	<	r = new Noop();
3035	<	f = new CompletableFuture<>();
3036	<	f2 = new CompletableFuture<>();
3037	<	assertTrue(f2.cancel(true));
3038	<	g = f.runAfterEitherAsync(f2, r, new ThreadExecutor());
3039	<	checkCompletedWithWrappedCancellationException(g);
3040	<	}
3041	<
3042	<	/**
3043	<	* thenComposeAsync result completes normally after normal
3044	<	* completion of source
3045	<	*/
3046	<	public void testThenComposeAsyncE() {
3047	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3048	<	CompletableFutureInc r = new CompletableFutureInc();
3049	<	CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3050	<	f.complete(one);
3051	<	checkCompletedNormally(g, two);
3052	<	}
3053	<
3054	<	/**
3055	<	* thenComposeAsync result completes exceptionally after
3056	<	* exceptional completion of source
3057	<	*/
3058	<	public void testThenComposeAsync2E() {
3059	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3060	<	CompletableFutureInc r = new CompletableFutureInc();
3061	<	CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3062	<	f.completeExceptionally(new CFException());
3063	<	checkCompletedWithWrappedCFException(g);
3064	<	}
3065	<
3066	<	/**
3067	<	* thenComposeAsync result completes exceptionally if action does
3068	<	*/
3069	<	public void testThenComposeAsync3E() {
3070	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3071	<	FailingCompletableFutureFunction r = new FailingCompletableFutureFunction();
3072	<	CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3073	<	f.complete(one);
3074	<	checkCompletedWithWrappedCFException(g);
3075	<	}
3076	<
3077	<	/**
3078	<	* thenComposeAsync result completes exceptionally if source cancelled
3079	<	*/
3080	<	public void testThenComposeAsync4E() {
3081	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3082	<	CompletableFutureInc r = new CompletableFutureInc();
3083	<	CompletableFuture<Integer> g = f.thenComposeAsync(r, new ThreadExecutor());
3055	>	CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3056		assertTrue(f.cancel(true));
3057		checkCompletedWithWrappedCancellationException(g);
3058		}
#	Line 3283 | Line 3255 | public class CompletableFutureTest exten
3255		* whenComplete action executes on normal completion, propagating
3256		* source result.
3257		*/
3258	<	public void testWhenComplete1() {
3259	<	final AtomicInteger a = new AtomicInteger();
3260	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3261	<	CompletableFuture<Integer> g =
3262	<	f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
3263	<	f.complete(three);
3264	<	checkCompletedNormally(f, three);
3265	<	checkCompletedNormally(g, three);
3266	<	assertEquals(a.get(), 1);
3267	<	}
3268	<
3269	<	/**
3270	<	* whenComplete action executes on exceptional completion, propagating
3271	<	* source result.
3272	<	*/
3273	<	public void testWhenComplete2() {
3302	<	final AtomicInteger a = new AtomicInteger();
3303	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3304	<	CompletableFuture<Integer> g =
3305	<	f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
3306	<	f.completeExceptionally(new CFException());
3307	<	assertTrue(f.isCompletedExceptionally());
3308	<	assertTrue(g.isCompletedExceptionally());
3309	<	assertEquals(a.get(), 1);
3310	<	}
3311	<
3312	<	/**
3313	<	* If a whenComplete action throws an exception when triggered by
3314	<	* a normal completion, it completes exceptionally
3315	<	*/
3316	<	public void testWhenComplete3() {
3317	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3318	<	CompletableFuture<Integer> g =
3319	<	f.whenComplete((Integer x, Throwable t) ->
3320	<	{ throw new CFException(); } );
3321	<	f.complete(three);
3322	<	checkCompletedNormally(f, three);
3323	<	assertTrue(g.isCompletedExceptionally());
3324	<	checkCompletedWithWrappedCFException(g);
3325	<	}
3326	<
3327	<	/**
3328	<	* whenCompleteAsync action executes on normal completion, propagating
3329	<	* source result.
3330	<	*/
3331	<	public void testWhenCompleteAsync1() {
3332	<	final AtomicInteger a = new AtomicInteger();
3333	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3334	<	CompletableFuture<Integer> g =
3335	<	f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3336	<	f.complete(three);
3337	<	checkCompletedNormally(f, three);
3338	<	checkCompletedNormally(g, three);
3339	<	assertEquals(a.get(), 1);
3340	<	}
3341	<
3342	<	/**
3343	<	* whenCompleteAsync action executes on exceptional completion, propagating
3344	<	* source result.
3345	<	*/
3346	<	public void testWhenCompleteAsync2() {
3347	<	final AtomicInteger a = new AtomicInteger();
3348	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3349	<	CompletableFuture<Integer> g =
3350	<	f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3351	<	f.completeExceptionally(new CFException());
3352	<	checkCompletedWithWrappedCFException(f);
3353	<	checkCompletedWithWrappedCFException(g);
3354	<	}
3258	>	public void testWhenComplete_normalCompletion1() {
3259	>	for (ExecutionMode m : ExecutionMode.values())
3260	>	for (boolean createIncomplete : new boolean[] { true, false })
3261	>	for (Integer v1 : new Integer[] { 1, null })
3262	>	{
3263	>	final AtomicInteger a = new AtomicInteger(0);
3264	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
3265	>	if (!createIncomplete) f.complete(v1);
3266	>	final CompletableFuture<Integer> g = m.whenComplete
3267	>	(f,
3268	>	(Integer x, Throwable t) -> {
3269	>	threadAssertSame(x, v1);
3270	>	threadAssertNull(t);
3271	>	a.getAndIncrement();
3272	>	});
3273	>	if (createIncomplete) f.complete(v1);
3274
3275	<	/**
3276	<	* If a whenCompleteAsync action throws an exception when
3277	<	* triggered by a normal completion, it completes exceptionally
3278	<	*/
3360	<	public void testWhenCompleteAsync3() {
3361	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3362	<	CompletableFuture<Integer> g =
3363	<	f.whenCompleteAsync((Integer x, Throwable t) ->
3364	<	{ throw new CFException(); } );
3365	<	f.complete(three);
3366	<	checkCompletedNormally(f, three);
3367	<	checkCompletedWithWrappedCFException(g);
3368	<	}
3275	>	checkCompletedNormally(g, v1);
3276	>	checkCompletedNormally(f, v1);
3277	>	assertEquals(1, a.get());
3278	>	}}
3279
3280		/**
3281	<	* whenCompleteAsync action executes on normal completion, propagating
3281	>	* whenComplete action executes on exceptional completion, propagating
3282		* source result.
3283		*/
3284	<	public void testWhenCompleteAsync1e() {
3285	<	final AtomicInteger a = new AtomicInteger();
3286	<	ThreadExecutor exec = new ThreadExecutor();
3287	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3288	<	CompletableFuture<Integer> g =
3289	<	f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
3290	<	exec);
3291	<	f.complete(three);
3292	<	checkCompletedNormally(f, three);
3293	<	checkCompletedNormally(g, three);
3294	<	assertEquals(a.get(), 1);
3295	<	}
3284	>	public void testWhenComplete_exceptionalCompletion() {
3285	>	for (ExecutionMode m : ExecutionMode.values())
3286	>	for (boolean createIncomplete : new boolean[] { true, false })
3287	>	for (Integer v1 : new Integer[] { 1, null })
3288	>	{
3289	>	final AtomicInteger a = new AtomicInteger(0);
3290	>	final CFException ex = new CFException();
3291	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
3292	>	if (!createIncomplete) f.completeExceptionally(ex);
3293	>	final CompletableFuture<Integer> g = m.whenComplete
3294	>	(f,
3295	>	(Integer x, Throwable t) -> {
3296	>	threadAssertNull(x);
3297	>	threadAssertSame(t, ex);
3298	>	a.getAndIncrement();
3299	>	});
3300	>	if (createIncomplete) f.completeExceptionally(ex);
3301	>	checkCompletedWithWrappedCFException(f, ex);
3302	>	checkCompletedWithWrappedCFException(g, ex);
3303	>	assertEquals(1, a.get());
3304	>	}}
3305
3306		/**
3307	<	* whenCompleteAsync action executes on exceptional completion, propagating
3308	<	* source result.
3307	>	* whenComplete action executes on cancelled source, propagating
3308	>	* CancellationException.
3309		*/
3310	<	public void testWhenCompleteAsync2e() {
3311	<	final AtomicInteger a = new AtomicInteger();
3312	<	ThreadExecutor exec = new ThreadExecutor();
3313	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3314	<	CompletableFuture<Integer> g =
3315	<	f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
3316	<	exec);
3317	<	f.completeExceptionally(new CFException());
3318	<	checkCompletedWithWrappedCFException(f);
3319	<	checkCompletedWithWrappedCFException(g);
3320	<	}
3310	>	public void testWhenComplete_sourceCancelled() {
3311	>	for (ExecutionMode m : ExecutionMode.values())
3312	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
3313	>	for (boolean createIncomplete : new boolean[] { true, false })
3314	>	{
3315	>	final AtomicInteger a = new AtomicInteger(0);
3316	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
3317	>	if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
3318	>	final CompletableFuture<Integer> g = m.whenComplete
3319	>	(f,
3320	>	(Integer x, Throwable t) -> {
3321	>	threadAssertNull(x);
3322	>	threadAssertTrue(t instanceof CancellationException);
3323	>	a.getAndIncrement();
3324	>	});
3325	>	if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
3326
3327	<	/**
3328	<	* If a whenCompleteAsync action throws an exception when triggered
3329	<	* by a normal completion, it completes exceptionally
3330	<	*/
3331	<	public void testWhenCompleteAsync3e() {
3408	<	ThreadExecutor exec = new ThreadExecutor();
3409	<	CompletableFuture<Integer> f = new CompletableFuture<>();
3410	<	CompletableFuture<Integer> g =
3411	<	f.whenCompleteAsync((Integer x, Throwable t) ->
3412	<	{ throw new CFException(); },
3413	<	exec);
3414	<	f.complete(three);
3415	<	checkCompletedNormally(f, three);
3416	<	checkCompletedWithWrappedCFException(g);
3417	<	}
3327	>	//try { g.join(); } catch (Throwable t) { throw new Error(t); }
3328	>	checkCompletedWithWrappedCancellationException(g);
3329	>	checkCancelled(f);
3330	>	assertEquals(1, a.get());
3331	>	}}
3332
3333		/**
3334	<	* handleAsync action completes normally with function value on
3335	<	* either normal or exceptional completion of source
3334	>	* If a whenComplete action throws an exception when triggered by
3335	>	* a normal completion, it completes exceptionally
3336		*/
3337	<	public void testHandleAsync() {
3338	<	CompletableFuture<Integer> f, g;
3339	<	IntegerHandler r;
3340	<
3341	<	f = new CompletableFuture<>();
3342	<	g = f.handleAsync(r = new IntegerHandler());
3343	<	assertFalse(r.ran);
3344	<	f.completeExceptionally(new CFException());
3345	<	checkCompletedWithWrappedCFException(f);
3346	<	checkCompletedNormally(g, three);
3347	<	assertTrue(r.ran);
3348	<
3349	<	f = new CompletableFuture<>();
3350	<	g = f.handleAsync(r = new IntegerHandler());
3351	<	assertFalse(r.ran);
3352	<	f.completeExceptionally(new CFException());
3353	<	checkCompletedWithWrappedCFException(f);
3354	<	checkCompletedNormally(g, three);
3355	<	assertTrue(r.ran);
3356	<
3357	<	f = new CompletableFuture<>();
3358	<	g = f.handleAsync(r = new IntegerHandler());
3445	<	assertFalse(r.ran);
3446	<	f.complete(one);
3447	<	checkCompletedNormally(f, one);
3448	<	checkCompletedNormally(g, two);
3449	<	assertTrue(r.ran);
3450	<
3451	<	f = new CompletableFuture<>();
3452	<	g = f.handleAsync(r = new IntegerHandler());
3453	<	assertFalse(r.ran);
3454	<	f.complete(one);
3455	<	checkCompletedNormally(f, one);
3456	<	checkCompletedNormally(g, two);
3457	<	assertTrue(r.ran);
3458	<	}
3337	>	public void testWhenComplete_actionFailed() {
3338	>	for (boolean createIncomplete : new boolean[] { true, false })
3339	>	for (ExecutionMode m : ExecutionMode.values())
3340	>	for (Integer v1 : new Integer[] { 1, null })
3341	>	{
3342	>	final AtomicInteger a = new AtomicInteger(0);
3343	>	final CFException ex = new CFException();
3344	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
3345	>	if (!createIncomplete) f.complete(v1);
3346	>	final CompletableFuture<Integer> g = m.whenComplete
3347	>	(f,
3348	>	(Integer x, Throwable t) -> {
3349	>	threadAssertSame(x, v1);
3350	>	threadAssertNull(t);
3351	>	a.getAndIncrement();
3352	>	throw ex;
3353	>	});
3354	>	if (createIncomplete) f.complete(v1);
3355	>	checkCompletedNormally(f, v1);
3356	>	checkCompletedWithWrappedCFException(g, ex);
3357	>	assertEquals(1, a.get());
3358	>	}}
3359
3360		/**
3361	<	* handleAsync action with Executor completes normally with
3362	<	* function value on either normal or exceptional completion of
3363	<	* source
3361	>	* If a whenComplete action throws an exception when triggered by
3362	>	* a source completion that also throws an exception, the source
3363	>	* exception takes precedence.
3364		*/
3365	<	public void testHandleAsync2() {
3366	<	CompletableFuture<Integer> f, g;
3367	<	ThreadExecutor exec = new ThreadExecutor();
3368	<	IntegerHandler r;
3369	<
3370	<	f = new CompletableFuture<>();
3371	<	g = f.handleAsync(r = new IntegerHandler(), exec);
3372	<	assertFalse(r.ran);
3373	<	f.completeExceptionally(new CFException());
3374	<	checkCompletedWithWrappedCFException(f);
3375	<	checkCompletedNormally(g, three);
3376	<	assertTrue(r.ran);
3377	<
3378	<	f = new CompletableFuture<>();
3379	<	g = f.handleAsync(r = new IntegerHandler(), exec);
3380	<	assertFalse(r.ran);
3381	<	f.completeExceptionally(new CFException());
3382	<	checkCompletedWithWrappedCFException(f);
3383	<	checkCompletedNormally(g, three);
3384	<	assertTrue(r.ran);
3385	<
3386	<	f = new CompletableFuture<>();
3387	<	g = f.handleAsync(r = new IntegerHandler(), exec);
3388	<	assertFalse(r.ran);
3389	<	f.complete(one);
3490	<	checkCompletedNormally(f, one);
3491	<	checkCompletedNormally(g, two);
3492	<	assertTrue(r.ran);
3493	<
3494	<	f = new CompletableFuture<>();
3495	<	g = f.handleAsync(r = new IntegerHandler(), exec);
3496	<	assertFalse(r.ran);
3497	<	f.complete(one);
3498	<	checkCompletedNormally(f, one);
3499	<	checkCompletedNormally(g, two);
3500	<	assertTrue(r.ran);
3501	<	}
3365	>	public void testWhenComplete_actionFailedSourceFailed() {
3366	>	for (boolean createIncomplete : new boolean[] { true, false })
3367	>	for (ExecutionMode m : ExecutionMode.values())
3368	>	for (Integer v1 : new Integer[] { 1, null })
3369	>	{
3370	>	final AtomicInteger a = new AtomicInteger(0);
3371	>	final CFException ex1 = new CFException();
3372	>	final CFException ex2 = new CFException();
3373	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
3374	>
3375	>	if (!createIncomplete) f.completeExceptionally(ex1);
3376	>	final CompletableFuture<Integer> g = m.whenComplete
3377	>	(f,
3378	>	(Integer x, Throwable t) -> {
3379	>	threadAssertSame(t, ex1);
3380	>	threadAssertNull(x);
3381	>	a.getAndIncrement();
3382	>	throw ex2;
3383	>	});
3384	>	if (createIncomplete) f.completeExceptionally(ex1);
3385	>
3386	>	checkCompletedWithWrappedCFException(f, ex1);
3387	>	checkCompletedWithWrappedCFException(g, ex1);
3388	>	assertEquals(1, a.get());
3389	>	}}
3390
3391		}

Diff Legend

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