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.200 by jsr166, Thu Sep 20 20:17:13 2018 UTC vs.
Revision 1.217 by jsr166, Sat Nov 24 18:13:28 2018 UTC

#	Line 551 | Line 551 | public class CompletableFutureTest exten
551		public CompletableFuture<Integer> apply(Integer x) {
552		invoked();
553		value = x;
554	<	CompletableFuture<Integer> f = new CompletableFuture<>();
555	<	assertTrue(f.complete(inc(x)));
556	<	return f;
554	>	return CompletableFuture.completedFuture(inc(x));
555		}
556		}
557
#	Line 574 | Line 572 | public class CompletableFutureTest exten
572		ExceptionalCompletableFutureFunction(ExecutionMode m) { super(m); }
573		public CompletionStage<Integer> apply(Throwable x) {
574		invoked();
575	<	CompletableFuture<Integer> d = new CompletableFuture<Integer>();
578	<	d.complete(value);
579	<	return d;
575	>	return CompletableFuture.completedFuture(value);
576		}
577		}
578
#	Line 930 | Line 926 | public class CompletableFutureTest exten
926		for (boolean createIncomplete : new boolean[] { true, false })
927		for (Integer v1 : new Integer[] { 1, null })
928		{
933	–	final AtomicInteger a = new AtomicInteger(0);
929		final CompletableFuture<Integer> f = new CompletableFuture<>();
930		if (!createIncomplete) assertTrue(f.complete(v1));
931		final CompletableFuture<Integer> g = m.exceptionally
932		(f, (Throwable t) -> {
938	–	a.getAndIncrement();
933		threadFail("should not be called");
934		return null;            // unreached
935		});
#	Line 943 | Line 937 | public class CompletableFutureTest exten
937
938		checkCompletedNormally(g, v1);
939		checkCompletedNormally(f, v1);
946	–	assertEquals(0, a.get());
940		}}
941
942		/**
#	Line 962 | Line 955 | public class CompletableFutureTest exten
955		final CompletableFuture<Integer> g = m.exceptionally
956		(f, (Throwable t) -> {
957		m.checkExecutionMode();
958	<	threadAssertSame(t, ex);
958	>	assertSame(t, ex);
959		a.getAndIncrement();
960		return v1;
961		});
#	Line 988 | Line 981 | public class CompletableFutureTest exten
981		final CompletableFuture<Integer> g = m.exceptionally
982		(f, (Throwable t) -> {
983		m.checkExecutionMode();
984	<	threadAssertSame(t, ex1);
984	>	assertSame(t, ex1);
985		a.getAndIncrement();
986		throw ex2;
987		});
#	Line 1015 | Line 1008 | public class CompletableFutureTest exten
1008		(f,
1009		(Integer result, Throwable t) -> {
1010		m.checkExecutionMode();
1011	<	threadAssertSame(result, v1);
1012	<	threadAssertNull(t);
1011	>	assertSame(result, v1);
1012	>	assertNull(t);
1013		a.getAndIncrement();
1014		});
1015		if (createIncomplete) assertTrue(f.complete(v1));
#	Line 1042 | Line 1035 | public class CompletableFutureTest exten
1035		(f,
1036		(Integer result, Throwable t) -> {
1037		m.checkExecutionMode();
1038	<	threadAssertNull(result);
1039	<	threadAssertSame(t, ex);
1038	>	assertNull(result);
1039	>	assertSame(t, ex);
1040		a.getAndIncrement();
1041		});
1042		if (createIncomplete) f.completeExceptionally(ex);
#	Line 1069 | Line 1062 | public class CompletableFutureTest exten
1062		(f,
1063		(Integer result, Throwable t) -> {
1064		m.checkExecutionMode();
1065	<	threadAssertNull(result);
1066	<	threadAssertTrue(t instanceof CancellationException);
1065	>	assertNull(result);
1066	>	assertTrue(t instanceof CancellationException);
1067		a.getAndIncrement();
1068		});
1069		if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
#	Line 1097 | Line 1090 | public class CompletableFutureTest exten
1090		(f,
1091		(Integer result, Throwable t) -> {
1092		m.checkExecutionMode();
1093	<	threadAssertSame(result, v1);
1094	<	threadAssertNull(t);
1093	>	assertSame(result, v1);
1094	>	assertNull(t);
1095		a.getAndIncrement();
1096		throw ex;
1097		});
#	Line 1128 | Line 1121 | public class CompletableFutureTest exten
1121		(f,
1122		(Integer result, Throwable t) -> {
1123		m.checkExecutionMode();
1124	<	threadAssertSame(t, ex1);
1125	<	threadAssertNull(result);
1124	>	assertSame(t, ex1);
1125	>	assertNull(result);
1126		a.getAndIncrement();
1127		throw ex2;
1128		});
#	Line 1160 | Line 1153 | public class CompletableFutureTest exten
1153		(f,
1154		(Integer result, Throwable t) -> {
1155		m.checkExecutionMode();
1156	<	threadAssertSame(result, v1);
1157	<	threadAssertNull(t);
1156	>	assertSame(result, v1);
1157	>	assertNull(t);
1158		a.getAndIncrement();
1159		return inc(v1);
1160		});
#	Line 1189 | Line 1182 | public class CompletableFutureTest exten
1182		(f,
1183		(Integer result, Throwable t) -> {
1184		m.checkExecutionMode();
1185	<	threadAssertNull(result);
1186	<	threadAssertSame(t, ex);
1185	>	assertNull(result);
1186	>	assertSame(t, ex);
1187		a.getAndIncrement();
1188		return v1;
1189		});
#	Line 1218 | Line 1211 | public class CompletableFutureTest exten
1211		(f,
1212		(Integer result, Throwable t) -> {
1213		m.checkExecutionMode();
1214	<	threadAssertNull(result);
1215	<	threadAssertTrue(t instanceof CancellationException);
1214	>	assertNull(result);
1215	>	assertTrue(t instanceof CancellationException);
1216		a.getAndIncrement();
1217		return v1;
1218		});
#	Line 1247 | Line 1240 | public class CompletableFutureTest exten
1240		(f,
1241		(Integer result, Throwable t) -> {
1242		m.checkExecutionMode();
1243	<	threadAssertSame(result, v1);
1244	<	threadAssertNull(t);
1243	>	assertSame(result, v1);
1244	>	assertNull(t);
1245		a.getAndIncrement();
1246		throw ex;
1247		});
#	Line 1278 | Line 1271 | public class CompletableFutureTest exten
1271		(f,
1272		(Integer result, Throwable t) -> {
1273		m.checkExecutionMode();
1274	<	threadAssertNull(result);
1275	<	threadAssertSame(ex1, t);
1274	>	assertNull(result);
1275	>	assertSame(ex1, t);
1276		a.getAndIncrement();
1277		throw ex2;
1278		});
#	Line 3123 | Line 3116 | public class CompletableFutureTest exten
3116		case 0:
3117		assertTrue(f.complete(v1));
3118		assertTrue(g.completeExceptionally(ex));
3119	<	h = m.thenCompose(f, (x -> g));
3119	>	h = m.thenCompose(f, x -> g);
3120		break;
3121		case 1:
3122		assertTrue(f.complete(v1));
3123	<	h = m.thenCompose(f, (x -> g));
3123	>	h = m.thenCompose(f, x -> g);
3124		assertTrue(g.completeExceptionally(ex));
3125		break;
3126		case 2:
3127		assertTrue(g.completeExceptionally(ex));
3128		assertTrue(f.complete(v1));
3129	<	h = m.thenCompose(f, (x -> g));
3129	>	h = m.thenCompose(f, x -> g);
3130		break;
3131		case 3:
3132		assertTrue(g.completeExceptionally(ex));
3133	<	h = m.thenCompose(f, (x -> g));
3133	>	h = m.thenCompose(f, x -> g);
3134		assertTrue(f.complete(v1));
3135		break;
3136		case 4:
3137	<	h = m.thenCompose(f, (x -> g));
3137	>	h = m.thenCompose(f, x -> g);
3138		assertTrue(f.complete(v1));
3139		assertTrue(g.completeExceptionally(ex));
3140		break;
3141		case 5:
3142	<	h = m.thenCompose(f, (x -> g));
3142	>	h = m.thenCompose(f, x -> g);
3143		assertTrue(f.complete(v1));
3144		assertTrue(g.completeExceptionally(ex));
3145		break;
#	Line 3206 | Line 3199 | public class CompletableFutureTest exten
3199		public void testExceptionallyCompose_actionFailed() {
3200		for (ExecutionMode m : ExecutionMode.values())
3201		for (boolean createIncomplete : new boolean[] { true, false })
3209	–	for (Integer v1 : new Integer[] { 1, null })
3202		{
3203		final CFException ex = new CFException();
3204		final CompletableFuture<Integer> f = new CompletableFuture<>();
#	Line 3221 | Line 3213 | public class CompletableFutureTest exten
3213		r.assertInvoked();
3214		}}
3215
3216	+	/**
3217	+	* exceptionallyCompose result completes exceptionally if the
3218	+	* result of the action does
3219	+	*/
3220	+	public void testExceptionallyCompose_actionReturnsFailingFuture() {
3221	+	for (ExecutionMode m : ExecutionMode.values())
3222	+	for (int order = 0; order < 6; order++)
3223	+	{
3224	+	final CFException ex0 = new CFException();
3225	+	final CFException ex = new CFException();
3226	+	final CompletableFuture<Integer> f = new CompletableFuture<>();
3227	+	final CompletableFuture<Integer> g = new CompletableFuture<>();
3228	+	final CompletableFuture<Integer> h;
3229	+	// Test all permutations of orders
3230	+	switch (order) {
3231	+	case 0:
3232	+	assertTrue(f.completeExceptionally(ex0));
3233	+	assertTrue(g.completeExceptionally(ex));
3234	+	h = m.exceptionallyCompose(f, x -> g);
3235	+	break;
3236	+	case 1:
3237	+	assertTrue(f.completeExceptionally(ex0));
3238	+	h = m.exceptionallyCompose(f, x -> g);
3239	+	assertTrue(g.completeExceptionally(ex));
3240	+	break;
3241	+	case 2:
3242	+	assertTrue(g.completeExceptionally(ex));
3243	+	assertTrue(f.completeExceptionally(ex0));
3244	+	h = m.exceptionallyCompose(f, x -> g);
3245	+	break;
3246	+	case 3:
3247	+	assertTrue(g.completeExceptionally(ex));
3248	+	h = m.exceptionallyCompose(f, x -> g);
3249	+	assertTrue(f.completeExceptionally(ex0));
3250	+	break;
3251	+	case 4:
3252	+	h = m.exceptionallyCompose(f, x -> g);
3253	+	assertTrue(f.completeExceptionally(ex0));
3254	+	assertTrue(g.completeExceptionally(ex));
3255	+	break;
3256	+	case 5:
3257	+	h = m.exceptionallyCompose(f, x -> g);
3258	+	assertTrue(f.completeExceptionally(ex0));
3259	+	assertTrue(g.completeExceptionally(ex));
3260	+	break;
3261	+	default: throw new AssertionError();
3262	+	}
3263	+
3264	+	checkCompletedExceptionally(g, ex);
3265	+	checkCompletedWithWrappedException(h, ex);
3266	+	checkCompletedExceptionally(f, ex0);
3267	+	}}
3268
3269		// other static methods
3270
#	Line 3601 | Line 3645 | public class CompletableFutureTest exten
3645		final CompletableFuture<Integer> complete = CompletableFuture.completedFuture(v);
3646		final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
3647
3604	–	List<CompletableFuture<?>> futures = new ArrayList<>();
3605	–
3606	–	List<CompletableFuture<Integer>> srcs = new ArrayList<>();
3607	–	srcs.add(complete);
3608	–	srcs.add(incomplete);
3609	–
3648		List<CompletableFuture<?>> fs = new ArrayList<>();
3649		fs.add(incomplete.thenRunAsync(() -> {}, e));
3650		fs.add(incomplete.thenAcceptAsync(z -> {}, e));
#	Line 4784 | Line 4822 | public class CompletableFutureTest exten
4822		}
4823
4824		/**
4825	+	* default-implemented exceptionallyAsync action is not invoked when
4826	+	* source completes normally, and source result is propagated
4827	+	*/
4828	+	public void testDefaultExceptionallyAsync_normalCompletion() {
4829	+	for (boolean createIncomplete : new boolean[] { true, false })
4830	+	for (Integer v1 : new Integer[] { 1, null })
4831	+	{
4832	+	final CompletableFuture<Integer> f = new CompletableFuture<>();
4833	+	final DelegatedCompletionStage<Integer> d =
4834	+	new DelegatedCompletionStage<Integer>(f);
4835	+	if (!createIncomplete) assertTrue(f.complete(v1));
4836	+	final CompletionStage<Integer> g = d.exceptionallyAsync
4837	+	((Throwable t) -> {
4838	+	threadFail("should not be called");
4839	+	return null;            // unreached
4840	+	});
4841	+	if (createIncomplete) assertTrue(f.complete(v1));
4842	+
4843	+	checkCompletedNormally(g.toCompletableFuture(), v1);
4844	+	}}
4845	+
4846	+	/**
4847		* default-implemented exceptionallyAsync action completes with
4848		* function value on source exception
4849		*/
4850	<	public void testDefaulExceptionallyAsync_exceptionalCompletion() {
4850	>	public void testDefaultExceptionallyAsync_exceptionalCompletion() {
4851		for (boolean createIncomplete : new boolean[] { true, false })
4852		for (Integer v1 : new Integer[] { 1, null })
4853		{
#	Line 4799 | Line 4859 | public class CompletableFutureTest exten
4859		if (!createIncomplete) f.completeExceptionally(ex);
4860		final CompletionStage<Integer> g = d.exceptionallyAsync
4861		((Throwable t) -> {
4862	<	threadAssertSame(t, ex);
4862	>	assertSame(t, ex);
4863		a.getAndIncrement();
4864		return v1;
4865		});
#	Line 4814 | Line 4874 | public class CompletableFutureTest exten
4874		* throws an exception, it completes exceptionally with that
4875		* exception
4876		*/
4877	<	public void testDefaulExceptionallyAsync_exceptionalCompletionActionFailed() {
4877	>	public void testDefaultExceptionallyAsync_exceptionalCompletionActionFailed() {
4878		for (boolean createIncomplete : new boolean[] { true, false })
4879		{
4880		final AtomicInteger a = new AtomicInteger(0);
#	Line 4826 | Line 4886 | public class CompletableFutureTest exten
4886		if (!createIncomplete) f.completeExceptionally(ex1);
4887		final CompletionStage<Integer> g = d.exceptionallyAsync
4888		((Throwable t) -> {
4889	<	threadAssertSame(t, ex1);
4889	>	assertSame(t, ex1);
4890		a.getAndIncrement();
4891		throw ex2;
4892		});
#	Line 4839 | Line 4899 | public class CompletableFutureTest exten
4899		}}
4900
4901		/**
4902	<	* defult exceptionallyCompose result completes normally after normal
4903	<	* completion of source
4902	>	* default-implemented exceptionallyCompose result completes
4903	>	* normally after normal completion of source
4904		*/
4905		public void testDefaultExceptionallyCompose_normalCompletion() {
4906		for (boolean createIncomplete : new boolean[] { true, false })
#	Line 4888 | Line 4948 | public class CompletableFutureTest exten
4948		*/
4949		public void testDefaultExceptionallyCompose_actionFailed() {
4950		for (boolean createIncomplete : new boolean[] { true, false })
4891	–	for (Integer v1 : new Integer[] { 1, null })
4951		{
4952		final CFException ex = new CFException();
4953		final CompletableFuture<Integer> f = new CompletableFuture<>();
#	Line 4906 | Line 4965 | public class CompletableFutureTest exten
4965		}}
4966
4967		/**
4968	<	* defult exceptionallyComposeAsync result completes normally after normal
4969	<	* completion of source
4968	>	* default-implemented exceptionallyComposeAsync result completes
4969	>	* normally after normal completion of source
4970		*/
4971		public void testDefaultExceptionallyComposeAsync_normalCompletion() {
4972		for (boolean createIncomplete : new boolean[] { true, false })
#	Line 4955 | Line 5014 | public class CompletableFutureTest exten
5014		*/
5015		public void testDefaultExceptionallyComposeAsync_actionFailed() {
5016		for (boolean createIncomplete : new boolean[] { true, false })
4958	–	for (Integer v1 : new Integer[] { 1, null })
5017		{
5018		final CFException ex = new CFException();
5019		final CompletableFuture<Integer> f = new CompletableFuture<>();
#	Line 4972 | Line 5030 | public class CompletableFutureTest exten
5030		r.assertInvoked();
5031		}}
5032
4975	–
5033		/**
5034	<	* defult exceptionallyComposeAsync result completes normally after normal
5035	<	* completion of source
5034	>	* default-implemented exceptionallyComposeAsync result completes
5035	>	* normally after normal completion of source
5036		*/
5037		public void testDefaultExceptionallyComposeAsyncExecutor_normalCompletion() {
5038		for (boolean createIncomplete : new boolean[] { true, false })
#	Line 4987 | Line 5044 | public class CompletableFutureTest exten
5044		final DelegatedCompletionStage<Integer> d =
5045		new DelegatedCompletionStage<Integer>(f);
5046		if (!createIncomplete) assertTrue(f.complete(v1));
5047	<	final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5047	>	final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5048		if (createIncomplete) assertTrue(f.complete(v1));
5049
5050		checkCompletedNormally(f, v1);
#	Line 5009 | Line 5066 | public class CompletableFutureTest exten
5066		final DelegatedCompletionStage<Integer> d =
5067		new DelegatedCompletionStage<Integer>(f);
5068		if (!createIncomplete) f.completeExceptionally(ex);
5069	<	final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5069	>	final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5070		if (createIncomplete) f.completeExceptionally(ex);
5071
5072		checkCompletedExceptionally(f, ex);
#	Line 5023 | Line 5080 | public class CompletableFutureTest exten
5080		*/
5081		public void testDefaultExceptionallyComposeAsyncExecutor_actionFailed() {
5082		for (boolean createIncomplete : new boolean[] { true, false })
5026	–	for (Integer v1 : new Integer[] { 1, null })
5083		{
5084		final CFException ex = new CFException();
5085		final CompletableFuture<Integer> f = new CompletableFuture<>();
#	Line 5032 | Line 5088 | public class CompletableFutureTest exten
5088		final DelegatedCompletionStage<Integer> d =
5089		new DelegatedCompletionStage<Integer>(f);
5090		if (!createIncomplete) f.completeExceptionally(ex);
5091	<	final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r,  new ThreadExecutor());
5091	>	final CompletionStage<Integer> g = d.exceptionallyComposeAsync(r, new ThreadExecutor());
5092		if (createIncomplete) f.completeExceptionally(ex);
5093
5094		checkCompletedExceptionally(f, ex);

Diff Legend

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