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.177 by jsr166, Wed Sep 21 18:25:04 2016 UTC vs.
Revision 1.195 by jsr166, Sun Jul 22 20:09:31 2018 UTC

#	Line 41 | Line 41 | import java.util.function.Function;
41		import java.util.function.Predicate;
42		import java.util.function.Supplier;
43
44	–	import junit.framework.AssertionFailedError;
44		import junit.framework.Test;
45		import junit.framework.TestSuite;
46
#	Line 59 | Line 58 | public class CompletableFutureTest exten
58		void checkIncomplete(CompletableFuture<?> f) {
59		assertFalse(f.isDone());
60		assertFalse(f.isCancelled());
61	<	assertTrue(f.toString().contains("Not completed"));
61	>	assertTrue(f.toString().matches(".*\\[.*Not completed.*\\]"));
62	>
63	>	Object result = null;
64		try {
65	<	assertNull(f.getNow(null));
65	>	result = f.getNow(null);
66		} catch (Throwable fail) { threadUnexpectedException(fail); }
67	+	assertNull(result);
68	+
69		try {
70	<	f.get(0L, SECONDS);
70	>	f.get(randomExpiredTimeout(), randomTimeUnit());
71		shouldThrow();
72		}
73		catch (TimeoutException success) {}
#	Line 76 | Line 79 | public class CompletableFutureTest exten
79
80		try {
81		assertEquals(value, f.join());
79	–	} catch (Throwable fail) { threadUnexpectedException(fail); }
80	–	try {
82		assertEquals(value, f.getNow(null));
82	–	} catch (Throwable fail) { threadUnexpectedException(fail); }
83	–	try {
83		assertEquals(value, f.get());
84		} catch (Throwable fail) { threadUnexpectedException(fail); }
85		assertTrue(f.isDone());
86		assertFalse(f.isCancelled());
87		assertFalse(f.isCompletedExceptionally());
88	<	assertTrue(f.toString().contains("[Completed normally]"));
88	>	assertTrue(f.toString().matches(".*\\[.*Completed normally.*\\]"));
89		}
90
91		/**
92		* Returns the "raw" internal exceptional completion of f,
93		* without any additional wrapping with CompletionException.
94		*/
95	<	<U> Throwable exceptionalCompletion(CompletableFuture<U> f) {
96	<	// handle (and whenComplete) can distinguish between "direct"
97	<	// and "wrapped" exceptional completion
98	<	return f.handle((U u, Throwable t) -> t).join();
95	>	Throwable exceptionalCompletion(CompletableFuture<?> f) {
96	>	// handle (and whenComplete and exceptionally) can distinguish
97	>	// between "direct" and "wrapped" exceptional completion
98	>	return f.handle((u, t) -> t).join();
99		}
100
101		void checkCompletedExceptionally(CompletableFuture<?> f,
#	Line 142 | Line 141 | public class CompletableFutureTest exten
141		assertFalse(f.isCancelled());
142		assertTrue(f.isDone());
143		assertTrue(f.isCompletedExceptionally());
144	<	assertTrue(f.toString().contains("[Completed exceptionally]"));
144	>	assertTrue(f.toString().matches(".*\\[.*Completed exceptionally.*\\]"));
145		}
146
147		void checkCompletedWithWrappedCFException(CompletableFuture<?> f) {
148		checkCompletedExceptionally(f, true,
149	<	(t) -> assertTrue(t instanceof CFException));
149	>	t -> assertTrue(t instanceof CFException));
150		}
151
152		void checkCompletedWithWrappedCancellationException(CompletableFuture<?> f) {
153		checkCompletedExceptionally(f, true,
154	<	(t) -> assertTrue(t instanceof CancellationException));
154	>	t -> assertTrue(t instanceof CancellationException));
155		}
156
157		void checkCompletedWithTimeoutException(CompletableFuture<?> f) {
158		checkCompletedExceptionally(f, false,
159	<	(t) -> assertTrue(t instanceof TimeoutException));
159	>	t -> assertTrue(t instanceof TimeoutException));
160		}
161
162		void checkCompletedWithWrappedException(CompletableFuture<?> f,
163		Throwable ex) {
164	<	checkCompletedExceptionally(f, true, (t) -> assertSame(t, ex));
164	>	checkCompletedExceptionally(f, true, t -> assertSame(t, ex));
165		}
166
167		void checkCompletedExceptionally(CompletableFuture<?> f, Throwable ex) {
168	<	checkCompletedExceptionally(f, false, (t) -> assertSame(t, ex));
168	>	checkCompletedExceptionally(f, false, t -> assertSame(t, ex));
169		}
170
171		void checkCancelled(CompletableFuture<?> f) {
#	Line 197 | Line 196 | public class CompletableFutureTest exten
196		assertTrue(f.isDone());
197		assertTrue(f.isCompletedExceptionally());
198		assertTrue(f.isCancelled());
199	<	assertTrue(f.toString().contains("[Completed exceptionally]"));
199	>	assertTrue(f.toString().matches(".*\\[.*Completed exceptionally.*\\]"));
200		}
201
202		/**
#	Line 296 | Line 295 | public class CompletableFutureTest exten
295		}
296
297		f = new CompletableFuture<>();
298	<	f.completeExceptionally(ex = new CFException());
298	>	f.completeExceptionally(new CFException());
299		f.obtrudeValue(v1);
300		checkCompletedNormally(f, v1);
301		f.obtrudeException(ex = new CFException());
#	Line 333 | Line 332 | public class CompletableFutureTest exten
332		/**
333		* toString indicates current completion state
334		*/
335	<	public void testToString() {
336	<	CompletableFuture<String> f;
337	<
338	<	f = new CompletableFuture<String>();
339	<	assertTrue(f.toString().contains("[Not completed]"));
335	>	public void testToString_incomplete() {
336	>	CompletableFuture<String> f = new CompletableFuture<>();
337	>	assertTrue(f.toString().matches(".*\\[.*Not completed.*\\]"));
338	>	if (testImplementationDetails)
339	>	assertEquals(identityString(f) + "[Not completed]",
340	>	f.toString());
341	>	}
342
343	+	public void testToString_normal() {
344	+	CompletableFuture<String> f = new CompletableFuture<>();
345		assertTrue(f.complete("foo"));
346	<	assertTrue(f.toString().contains("[Completed normally]"));
346	>	assertTrue(f.toString().matches(".*\\[.*Completed normally.*\\]"));
347	>	if (testImplementationDetails)
348	>	assertEquals(identityString(f) + "[Completed normally]",
349	>	f.toString());
350	>	}
351
352	<	f = new CompletableFuture<String>();
352	>	public void testToString_exception() {
353	>	CompletableFuture<String> f = new CompletableFuture<>();
354		assertTrue(f.completeExceptionally(new IndexOutOfBoundsException()));
355	<	assertTrue(f.toString().contains("[Completed exceptionally]"));
355	>	assertTrue(f.toString().matches(".*\\[.*Completed exceptionally.*\\]"));
356	>	if (testImplementationDetails)
357	>	assertTrue(f.toString().startsWith(
358	>	identityString(f) + "[Completed exceptionally: "));
359	>	}
360
361	+	public void testToString_cancelled() {
362		for (boolean mayInterruptIfRunning : new boolean[] { true, false }) {
363	<	f = new CompletableFuture<String>();
363	>	CompletableFuture<String> f = new CompletableFuture<>();
364		assertTrue(f.cancel(mayInterruptIfRunning));
365	<	assertTrue(f.toString().contains("[Completed exceptionally]"));
365	>	assertTrue(f.toString().matches(".*\\[.*Completed exceptionally.*\\]"));
366	>	if (testImplementationDetails)
367	>	assertTrue(f.toString().startsWith(
368	>	identityString(f) + "[Completed exceptionally: "));
369		}
370		}
371
#	Line 1242 | Line 1258 | public class CompletableFutureTest exten
1258		r.assertInvoked();
1259		}}
1260
1261	+	@SuppressWarnings("FutureReturnValueIgnored")
1262		public void testRunAsync_rejectingExecutor() {
1263		CountingRejectingExecutor e = new CountingRejectingExecutor();
1264		try {
#	Line 1288 | Line 1305 | public class CompletableFutureTest exten
1305		r.assertInvoked();
1306		}}
1307
1308	+	@SuppressWarnings("FutureReturnValueIgnored")
1309		public void testSupplyAsync_rejectingExecutor() {
1310		CountingRejectingExecutor e = new CountingRejectingExecutor();
1311		try {
#	Line 2562 | Line 2580 | public class CompletableFutureTest exten
2580
2581		// unspecified behavior - both source completions available
2582		try {
2583	<	assertEquals(null, h0.join());
2583	>	assertNull(h0.join());
2584		rs[0].assertValue(v1);
2585		} catch (CompletionException ok) {
2586		checkCompletedWithWrappedException(h0, ex);
2587		rs[0].assertNotInvoked();
2588		}
2589		try {
2590	<	assertEquals(null, h1.join());
2590	>	assertNull(h1.join());
2591		rs[1].assertValue(v1);
2592		} catch (CompletionException ok) {
2593		checkCompletedWithWrappedException(h1, ex);
2594		rs[1].assertNotInvoked();
2595		}
2596		try {
2597	<	assertEquals(null, h2.join());
2597	>	assertNull(h2.join());
2598		rs[2].assertValue(v1);
2599		} catch (CompletionException ok) {
2600		checkCompletedWithWrappedException(h2, ex);
2601		rs[2].assertNotInvoked();
2602		}
2603		try {
2604	<	assertEquals(null, h3.join());
2604	>	assertNull(h3.join());
2605		rs[3].assertValue(v1);
2606		} catch (CompletionException ok) {
2607		checkCompletedWithWrappedException(h3, ex);
#	Line 2822 | Line 2840 | public class CompletableFutureTest exten
2840
2841		// unspecified behavior - both source completions available
2842		try {
2843	<	assertEquals(null, h0.join());
2843	>	assertNull(h0.join());
2844		rs[0].assertInvoked();
2845		} catch (CompletionException ok) {
2846		checkCompletedWithWrappedException(h0, ex);
2847		rs[0].assertNotInvoked();
2848		}
2849		try {
2850	<	assertEquals(null, h1.join());
2850	>	assertNull(h1.join());
2851		rs[1].assertInvoked();
2852		} catch (CompletionException ok) {
2853		checkCompletedWithWrappedException(h1, ex);
2854		rs[1].assertNotInvoked();
2855		}
2856		try {
2857	<	assertEquals(null, h2.join());
2857	>	assertNull(h2.join());
2858		rs[2].assertInvoked();
2859		} catch (CompletionException ok) {
2860		checkCompletedWithWrappedException(h2, ex);
2861		rs[2].assertNotInvoked();
2862		}
2863		try {
2864	<	assertEquals(null, h3.join());
2864	>	assertNull(h3.join());
2865		rs[3].assertInvoked();
2866		} catch (CompletionException ok) {
2867		checkCompletedWithWrappedException(h3, ex);
#	Line 3238 | Line 3256 | public class CompletableFutureTest exten
3256		/**
3257		* Completion methods throw NullPointerException with null arguments
3258		*/
3259	+	@SuppressWarnings("FutureReturnValueIgnored")
3260		public void testNPE() {
3261		CompletableFuture<Integer> f = new CompletableFuture<>();
3262		CompletableFuture<Integer> g = new CompletableFuture<>();
#	Line 3257 | Line 3276 | public class CompletableFutureTest exten
3276
3277		() -> f.thenApply(null),
3278		() -> f.thenApplyAsync(null),
3279	<	() -> f.thenApplyAsync((x) -> x, null),
3279	>	() -> f.thenApplyAsync(x -> x, null),
3280		() -> f.thenApplyAsync(null, exec),
3281
3282		() -> f.thenAccept(null),
3283		() -> f.thenAcceptAsync(null),
3284	<	() -> f.thenAcceptAsync((x) -> {} , null),
3284	>	() -> f.thenAcceptAsync(x -> {} , null),
3285		() -> f.thenAcceptAsync(null, exec),
3286
3287		() -> f.thenRun(null),
#	Line 3297 | Line 3316 | public class CompletableFutureTest exten
3316		() -> f.applyToEither(g, null),
3317		() -> f.applyToEitherAsync(g, null),
3318		() -> f.applyToEitherAsync(g, null, exec),
3319	<	() -> f.applyToEither(nullFuture, (x) -> x),
3320	<	() -> f.applyToEitherAsync(nullFuture, (x) -> x),
3321	<	() -> f.applyToEitherAsync(nullFuture, (x) -> x, exec),
3322	<	() -> f.applyToEitherAsync(g, (x) -> x, null),
3319	>	() -> f.applyToEither(nullFuture, x -> x),
3320	>	() -> f.applyToEitherAsync(nullFuture, x -> x),
3321	>	() -> f.applyToEitherAsync(nullFuture, x -> x, exec),
3322	>	() -> f.applyToEitherAsync(g, x -> x, null),
3323
3324		() -> f.acceptEither(g, null),
3325		() -> f.acceptEitherAsync(g, null),
3326		() -> f.acceptEitherAsync(g, null, exec),
3327	<	() -> f.acceptEither(nullFuture, (x) -> {}),
3328	<	() -> f.acceptEitherAsync(nullFuture, (x) -> {}),
3329	<	() -> f.acceptEitherAsync(nullFuture, (x) -> {}, exec),
3330	<	() -> f.acceptEitherAsync(g, (x) -> {}, null),
3327	>	() -> f.acceptEither(nullFuture, x -> {}),
3328	>	() -> f.acceptEitherAsync(nullFuture, x -> {}),
3329	>	() -> f.acceptEitherAsync(nullFuture, x -> {}, exec),
3330	>	() -> f.acceptEitherAsync(g, x -> {}, null),
3331
3332		() -> f.runAfterEither(g, null),
3333		() -> f.runAfterEitherAsync(g, null),
#	Line 3374 | Line 3393 | public class CompletableFutureTest exten
3393		for (CompletableFuture<Integer> src : srcs) {
3394		List<CompletableFuture<?>> fs = new ArrayList<>();
3395		fs.add(src.thenRunAsync(() -> {}, e));
3396	<	fs.add(src.thenAcceptAsync((z) -> {}, e));
3397	<	fs.add(src.thenApplyAsync((z) -> z, e));
3396	>	fs.add(src.thenAcceptAsync(z -> {}, e));
3397	>	fs.add(src.thenApplyAsync(z -> z, e));
3398
3399		fs.add(src.thenCombineAsync(src, (x, y) -> x, e));
3400		fs.add(src.thenAcceptBothAsync(src, (x, y) -> {}, e));
3401		fs.add(src.runAfterBothAsync(src, () -> {}, e));
3402
3403	<	fs.add(src.applyToEitherAsync(src, (z) -> z, e));
3404	<	fs.add(src.acceptEitherAsync(src, (z) -> {}, e));
3403	>	fs.add(src.applyToEitherAsync(src, z -> z, e));
3404	>	fs.add(src.acceptEitherAsync(src, z -> {}, e));
3405		fs.add(src.runAfterEitherAsync(src, () -> {}, e));
3406
3407	<	fs.add(src.thenComposeAsync((z) -> null, e));
3407	>	fs.add(src.thenComposeAsync(z -> null, e));
3408		fs.add(src.whenCompleteAsync((z, t) -> {}, e));
3409		fs.add(src.handleAsync((z, t) -> null, e));
3410
#	Line 3418 | Line 3437 | public class CompletableFutureTest exten
3437		{
3438		List<CompletableFuture<?>> fs = new ArrayList<>();
3439
3440	<	fs.add(complete.applyToEitherAsync(incomplete, (z) -> z, e));
3441	<	fs.add(incomplete.applyToEitherAsync(complete, (z) -> z, e));
3440	>	fs.add(complete.applyToEitherAsync(incomplete, z -> z, e));
3441	>	fs.add(incomplete.applyToEitherAsync(complete, z -> z, e));
3442
3443	<	fs.add(complete.acceptEitherAsync(incomplete, (z) -> {}, e));
3444	<	fs.add(incomplete.acceptEitherAsync(complete, (z) -> {}, e));
3443	>	fs.add(complete.acceptEitherAsync(incomplete, z -> {}, e));
3444	>	fs.add(incomplete.acceptEitherAsync(complete, z -> {}, e));
3445
3446		fs.add(complete.runAfterEitherAsync(incomplete, () -> {}, e));
3447		fs.add(incomplete.runAfterEitherAsync(complete, () -> {}, e));
#	Line 3461 | Line 3480 | public class CompletableFutureTest exten
3480
3481		List<CompletableFuture<?>> fs = new ArrayList<>();
3482		fs.add(incomplete.thenRunAsync(() -> {}, e));
3483	<	fs.add(incomplete.thenAcceptAsync((z) -> {}, e));
3484	<	fs.add(incomplete.thenApplyAsync((z) -> z, e));
3483	>	fs.add(incomplete.thenAcceptAsync(z -> {}, e));
3484	>	fs.add(incomplete.thenApplyAsync(z -> z, e));
3485
3486		fs.add(incomplete.thenCombineAsync(incomplete, (x, y) -> x, e));
3487		fs.add(incomplete.thenAcceptBothAsync(incomplete, (x, y) -> {}, e));
3488		fs.add(incomplete.runAfterBothAsync(incomplete, () -> {}, e));
3489
3490	<	fs.add(incomplete.applyToEitherAsync(incomplete, (z) -> z, e));
3491	<	fs.add(incomplete.acceptEitherAsync(incomplete, (z) -> {}, e));
3490	>	fs.add(incomplete.applyToEitherAsync(incomplete, z -> z, e));
3491	>	fs.add(incomplete.acceptEitherAsync(incomplete, z -> {}, e));
3492		fs.add(incomplete.runAfterEitherAsync(incomplete, () -> {}, e));
3493
3494	<	fs.add(incomplete.thenComposeAsync((z) -> null, e));
3494	>	fs.add(incomplete.thenComposeAsync(z -> null, e));
3495		fs.add(incomplete.whenCompleteAsync((z, t) -> {}, e));
3496		fs.add(incomplete.handleAsync((z, t) -> null, e));
3497
#	Line 3532 | Line 3551 | public class CompletableFutureTest exten
3551		*/
3552		public void testCompletedStage() {
3553		AtomicInteger x = new AtomicInteger(0);
3554	<	AtomicReference<Throwable> r = new AtomicReference<Throwable>();
3554	>	AtomicReference<Throwable> r = new AtomicReference<>();
3555		CompletionStage<Integer> f = CompletableFuture.completedStage(1);
3556		f.whenComplete((v, e) -> {if (e != null) r.set(e); else x.set(v);});
3557		assertEquals(x.get(), 1);
#	Line 3634 | Line 3653 | public class CompletableFutureTest exten
3653		CompletableFuture<Integer> f = new CompletableFuture<>();
3654		CompletionStage<Integer> g = f.minimalCompletionStage();
3655		AtomicInteger x = new AtomicInteger(0);
3656	<	AtomicReference<Throwable> r = new AtomicReference<Throwable>();
3656	>	AtomicReference<Throwable> r = new AtomicReference<>();
3657		checkIncomplete(f);
3658		g.whenComplete((v, e) -> {if (e != null) r.set(e); else x.set(v);});
3659		f.complete(1);
#	Line 3651 | Line 3670 | public class CompletableFutureTest exten
3670		CompletableFuture<Integer> f = new CompletableFuture<>();
3671		CompletionStage<Integer> g = f.minimalCompletionStage();
3672		AtomicInteger x = new AtomicInteger(0);
3673	<	AtomicReference<Throwable> r = new AtomicReference<Throwable>();
3673	>	AtomicReference<Throwable> r = new AtomicReference<>();
3674		g.whenComplete((v, e) -> {if (e != null) r.set(e); else x.set(v);});
3675		checkIncomplete(f);
3676		CFException ex = new CFException();
#	Line 3669 | Line 3688 | public class CompletableFutureTest exten
3688		CFException ex = new CFException();
3689		CompletionStage<Integer> f = CompletableFuture.failedStage(ex);
3690		AtomicInteger x = new AtomicInteger(0);
3691	<	AtomicReference<Throwable> r = new AtomicReference<Throwable>();
3691	>	AtomicReference<Throwable> r = new AtomicReference<>();
3692		f.whenComplete((v, e) -> {if (e != null) r.set(e); else x.set(v);});
3693		assertEquals(x.get(), 0);
3694		assertEquals(r.get(), ex);
#	Line 3693 | Line 3712 | public class CompletableFutureTest exten
3712		public void testCompleteAsync2() {
3713		CompletableFuture<Integer> f = new CompletableFuture<>();
3714		CFException ex = new CFException();
3715	<	f.completeAsync(() -> {if (true) throw ex; return 1;});
3715	>	f.completeAsync(() -> { throw ex; });
3716		try {
3717		f.join();
3718		shouldThrow();
#	Line 3723 | Line 3742 | public class CompletableFutureTest exten
3742		CompletableFuture<Integer> f = new CompletableFuture<>();
3743		CFException ex = new CFException();
3744		ThreadExecutor executor = new ThreadExecutor();
3745	<	f.completeAsync(() -> {if (true) throw ex; return 1;}, executor);
3745	>	f.completeAsync(() -> { throw ex; }, executor);
3746		try {
3747		f.join();
3748		shouldThrow();
#	Line 3882 | Line 3901 | public class CompletableFutureTest exten
3901		List<Function<CompletableFuture<Integer>, CompletableFuture<?>>> funs
3902		= new ArrayList<>();
3903
3904	<	funs.add((y) -> m.thenRun(y, noopRunnable));
3905	<	funs.add((y) -> m.thenAccept(y, noopConsumer));
3906	<	funs.add((y) -> m.thenApply(y, incFunction));
3907	<
3908	<	funs.add((y) -> m.runAfterEither(y, incomplete, noopRunnable));
3909	<	funs.add((y) -> m.acceptEither(y, incomplete, noopConsumer));
3910	<	funs.add((y) -> m.applyToEither(y, incomplete, incFunction));
3911	<
3912	<	funs.add((y) -> m.runAfterBoth(y, v42, noopRunnable));
3913	<	funs.add((y) -> m.runAfterBoth(v42, y, noopRunnable));
3914	<	funs.add((y) -> m.thenAcceptBoth(y, v42, new SubtractAction(m)));
3915	<	funs.add((y) -> m.thenAcceptBoth(v42, y, new SubtractAction(m)));
3916	<	funs.add((y) -> m.thenCombine(y, v42, new SubtractFunction(m)));
3917	<	funs.add((y) -> m.thenCombine(v42, y, new SubtractFunction(m)));
3918	<
3919	<	funs.add((y) -> m.whenComplete(y, (Integer r, Throwable t) -> {}));
3920	<
3921	<	funs.add((y) -> m.thenCompose(y, new CompletableFutureInc(m)));
3922	<
3923	<	funs.add((y) -> CompletableFuture.allOf(y));
3924	<	funs.add((y) -> CompletableFuture.allOf(y, v42));
3925	<	funs.add((y) -> CompletableFuture.allOf(v42, y));
3926	<	funs.add((y) -> CompletableFuture.anyOf(y));
3927	<	funs.add((y) -> CompletableFuture.anyOf(y, incomplete));
3928	<	funs.add((y) -> CompletableFuture.anyOf(incomplete, y));
3904	>	funs.add(y -> m.thenRun(y, noopRunnable));
3905	>	funs.add(y -> m.thenAccept(y, noopConsumer));
3906	>	funs.add(y -> m.thenApply(y, incFunction));
3907	>
3908	>	funs.add(y -> m.runAfterEither(y, incomplete, noopRunnable));
3909	>	funs.add(y -> m.acceptEither(y, incomplete, noopConsumer));
3910	>	funs.add(y -> m.applyToEither(y, incomplete, incFunction));
3911	>
3912	>	funs.add(y -> m.runAfterBoth(y, v42, noopRunnable));
3913	>	funs.add(y -> m.runAfterBoth(v42, y, noopRunnable));
3914	>	funs.add(y -> m.thenAcceptBoth(y, v42, new SubtractAction(m)));
3915	>	funs.add(y -> m.thenAcceptBoth(v42, y, new SubtractAction(m)));
3916	>	funs.add(y -> m.thenCombine(y, v42, new SubtractFunction(m)));
3917	>	funs.add(y -> m.thenCombine(v42, y, new SubtractFunction(m)));
3918	>
3919	>	funs.add(y -> m.whenComplete(y, (Integer r, Throwable t) -> {}));
3920	>
3921	>	funs.add(y -> m.thenCompose(y, new CompletableFutureInc(m)));
3922	>
3923	>	funs.add(y -> CompletableFuture.allOf(y));
3924	>	funs.add(y -> CompletableFuture.allOf(y, v42));
3925	>	funs.add(y -> CompletableFuture.allOf(v42, y));
3926	>	funs.add(y -> CompletableFuture.anyOf(y));
3927	>	funs.add(y -> CompletableFuture.anyOf(y, incomplete));
3928	>	funs.add(y -> CompletableFuture.anyOf(incomplete, y));
3929
3930		for (Function<CompletableFuture<Integer>, CompletableFuture<?>>
3931		fun : funs) {
#	Line 3963 | Line 3982 | public class CompletableFutureTest exten
3982		public void testMinimalCompletionStage_minimality() {
3983		if (!testImplementationDetails) return;
3984		Function<Method, String> toSignature =
3985	<	(method) -> method.getName() + Arrays.toString(method.getParameterTypes());
3985	>	method -> method.getName() + Arrays.toString(method.getParameterTypes());
3986		Predicate<Method> isNotStatic =
3987	<	(method) -> (method.getModifiers() & Modifier.STATIC) == 0;
3987	>	method -> (method.getModifiers() & Modifier.STATIC) == 0;
3988		List<Method> minimalMethods =
3989		Stream.of(Object.class, CompletionStage.class)
3990	<	.flatMap((klazz) -> Stream.of(klazz.getMethods()))
3990	>	.flatMap(klazz -> Stream.of(klazz.getMethods()))
3991		.filter(isNotStatic)
3992		.collect(Collectors.toList());
3993		// Methods from CompletableFuture permitted NOT to throw UOE
#	Line 3984 | Line 4003 | public class CompletableFutureTest exten
4003		.collect(Collectors.toSet());
4004		List<Method> allMethods = Stream.of(CompletableFuture.class.getMethods())
4005		.filter(isNotStatic)
4006	<	.filter((method) -> !permittedMethodSignatures.contains(toSignature.apply(method)))
4006	>	.filter(method -> !permittedMethodSignatures.contains(toSignature.apply(method)))
4007		.collect(Collectors.toList());
4008
4009		List<CompletionStage<Integer>> stages = new ArrayList<>();
#	Line 4078 | Line 4097 | public class CompletableFutureTest exten
4097		CompletableFuture<Integer> f = new CompletableFuture<>();
4098		CompletionStage minimal = f.minimalCompletionStage();
4099		CompletableFuture<Integer> g = minimal.toCompletableFuture();
4100	<	g.complete(v1);
4100	>	assertTrue(g.complete(v1));
4101		checkCompletedNormally(g, v1);
4102		checkIncomplete(f);
4103		checkIncomplete(minimal.toCompletableFuture());
#	Line 4144 | Line 4163 | public class CompletableFutureTest exten
4163		CompletionStage<Integer> minimal = f.minimalCompletionStage();
4164		CompletableFuture<Integer> g = new CompletableFuture<>();
4165		if (!createIncomplete) assertTrue(f.complete(v1));
4166	<	minimal.thenAccept((x) -> g.complete(x));
4166	>	minimal.thenAccept(x -> g.complete(x));
4167		if (createIncomplete) assertTrue(f.complete(v1));
4168		g.join();
4169		checkCompletedNormally(g, v1);
#	Line 4168 | Line 4187 | public class CompletableFutureTest exten
4187		static <T,U,V> Function<T, CompletableFuture<V>> compose
4188		(Function<T, CompletableFuture<U>> f,
4189		Function<U, CompletableFuture<V>> g) {
4190	<	return (x) -> f.apply(x).thenCompose(g);
4190	>	return x -> f.apply(x).thenCompose(g);
4191		}
4192
4193		static void assertZero(CompletableFuture<?> f) {
4194		try {
4195		f.getNow(null);
4196	<	throw new AssertionFailedError("should throw");
4196	>	throw new AssertionError("should throw");
4197		} catch (CompletionException success) {
4198		assertTrue(success.getCause() instanceof ZeroException);
4199		}
#	Line 4248 | Line 4267 | public class CompletableFutureTest exten
4267
4268		// Some mutually non-commutative functions
4269		Function<Long, CompletableFuture<Long>> triple
4270	<	= (x) -> Monad.unit(3 * x);
4270	>	= x -> Monad.unit(3 * x);
4271		Function<Long, CompletableFuture<Long>> inc
4272	<	= (x) -> Monad.unit(x + 1);
4272	>	= x -> Monad.unit(x + 1);
4273
4274		// unit is a right identity: m >>= unit === m
4275		Monad.assertFutureEquals(inc.apply(5L).thenCompose(unit),
#	Line 4262 | Line 4281 | public class CompletableFutureTest exten
4281		// associativity: (m >>= f) >>= g === m >>= ( \x -> (f x >>= g) )
4282		Monad.assertFutureEquals(
4283		unit.apply(5L).thenCompose(inc).thenCompose(triple),
4284	<	unit.apply(5L).thenCompose((x) -> inc.apply(x).thenCompose(triple)));
4284	>	unit.apply(5L).thenCompose(x -> inc.apply(x).thenCompose(triple)));
4285
4286		// The case for CompletableFuture as an additive monad is weaker...
4287
#	Line 4272 | Line 4291 | public class CompletableFutureTest exten
4291		// left zero: zero >>= f === zero
4292		Monad.assertZero(zero.thenCompose(inc));
4293		// right zero: f >>= (\x -> zero) === zero
4294	<	Monad.assertZero(inc.apply(5L).thenCompose((x) -> zero));
4294	>	Monad.assertZero(inc.apply(5L).thenCompose(x -> zero));
4295
4296		// f plus zero === f
4297		Monad.assertFutureEquals(Monad.unit(5L),
#	Line 4299 | Line 4318 | public class CompletableFutureTest exten
4318		}
4319
4320		/** Test long recursive chains of CompletableFutures with cascading completions */
4321	+	@SuppressWarnings("FutureReturnValueIgnored")
4322		public void testRecursiveChains() throws Throwable {
4323		for (ExecutionMode m : ExecutionMode.values())
4324		for (boolean addDeadEnds : new boolean[] { true, false })
#	Line 4323 | Line 4343 | public class CompletableFutureTest exten
4343		* A single CompletableFuture with many dependents.
4344		* A demo of scalability - runtime is O(n).
4345		*/
4346	+	@SuppressWarnings("FutureReturnValueIgnored")
4347		public void testManyDependents() throws Throwable {
4348		final int n = expensiveTests ? 1_000_000 : 10;
4349		final CompletableFuture<Void> head = new CompletableFuture<>();
#	Line 4330 | Line 4351 | public class CompletableFutureTest exten
4351		final AtomicInteger count = new AtomicInteger(0);
4352		for (int i = 0; i < n; i++) {
4353		head.thenRun(() -> count.getAndIncrement());
4354	<	head.thenAccept((x) -> count.getAndIncrement());
4355	<	head.thenApply((x) -> count.getAndIncrement());
4354	>	head.thenAccept(x -> count.getAndIncrement());
4355	>	head.thenApply(x -> count.getAndIncrement());
4356
4357		head.runAfterBoth(complete, () -> count.getAndIncrement());
4358		head.thenAcceptBoth(complete, (x, y) -> count.getAndIncrement());
#	Line 4341 | Line 4362 | public class CompletableFutureTest exten
4362		complete.thenCombine(head, (x, y) -> count.getAndIncrement());
4363
4364		head.runAfterEither(new CompletableFuture<Void>(), () -> count.getAndIncrement());
4365	<	head.acceptEither(new CompletableFuture<Void>(), (x) -> count.getAndIncrement());
4366	<	head.applyToEither(new CompletableFuture<Void>(), (x) -> count.getAndIncrement());
4365	>	head.acceptEither(new CompletableFuture<Void>(), x -> count.getAndIncrement());
4366	>	head.applyToEither(new CompletableFuture<Void>(), x -> count.getAndIncrement());
4367		new CompletableFuture<Void>().runAfterEither(head, () -> count.getAndIncrement());
4368	<	new CompletableFuture<Void>().acceptEither(head, (x) -> count.getAndIncrement());
4369	<	new CompletableFuture<Void>().applyToEither(head, (x) -> count.getAndIncrement());
4368	>	new CompletableFuture<Void>().acceptEither(head, x -> count.getAndIncrement());
4369	>	new CompletableFuture<Void>().applyToEither(head, x -> count.getAndIncrement());
4370		}
4371		head.complete(null);
4372		assertEquals(5 * 3 * n, count.get());
4373		}
4374
4375		/** ant -Dvmoptions=-Xmx8m -Djsr166.expensiveTests=true -Djsr166.tckTestClass=CompletableFutureTest tck */
4376	+	@SuppressWarnings("FutureReturnValueIgnored")
4377		public void testCoCompletionGarbageRetention() throws Throwable {
4378		final int n = expensiveTests ? 1_000_000 : 10;
4379		final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
#	Line 4362 | Line 4384 | public class CompletableFutureTest exten
4384		f.complete(null);
4385
4386		f = new CompletableFuture<>();
4387	<	f.acceptEither(incomplete, (x) -> {});
4387	>	f.acceptEither(incomplete, x -> {});
4388		f.complete(null);
4389
4390		f = new CompletableFuture<>();
4391	<	f.applyToEither(incomplete, (x) -> x);
4391	>	f.applyToEither(incomplete, x -> x);
4392		f.complete(null);
4393
4394		f = new CompletableFuture<>();
4395	<	CompletableFuture.anyOf(new CompletableFuture<?>[] { f, incomplete });
4395	>	CompletableFuture.anyOf(f, incomplete);
4396		f.complete(null);
4397		}
4398
#	Line 4380 | Line 4402 | public class CompletableFutureTest exten
4402		f.complete(null);
4403
4404		f = new CompletableFuture<>();
4405	<	incomplete.acceptEither(f, (x) -> {});
4405	>	incomplete.acceptEither(f, x -> {});
4406		f.complete(null);
4407
4408		f = new CompletableFuture<>();
4409	<	incomplete.applyToEither(f, (x) -> x);
4409	>	incomplete.applyToEither(f, x -> x);
4410		f.complete(null);
4411
4412		f = new CompletableFuture<>();
4413	<	CompletableFuture.anyOf(new CompletableFuture<?>[] { incomplete, f });
4413	>	CompletableFuture.anyOf(incomplete, f);
4414		f.complete(null);
4415		}
4416		}
#	Line 4442 | Line 4464 | public class CompletableFutureTest exten
4464		assertTrue(neverCompleted.thenRun(() -> {}).cancel(true));
4465		}
4466
4467	+	/**
4468	+	* Checks for garbage retention when MinimalStage.toCompletableFuture()
4469	+	* is invoked many times.
4470	+	* 8161600: Garbage retention when source CompletableFutures are never completed
4471	+	*
4472	+	* As of 2016-07, fails with OOME:
4473	+	* ant -Dvmoptions=-Xmx8m -Djsr166.expensiveTests=true -Djsr166.tckTestClass=CompletableFutureTest -Djsr166.methodFilter=testToCompletableFutureGarbageRetention tck
4474	+	*/
4475	+	public void testToCompletableFutureGarbageRetention() throws Throwable {
4476	+	final int n = expensiveTests ? 900_000 : 10;
4477	+	CompletableFuture<Integer> neverCompleted = new CompletableFuture<>();
4478	+	CompletionStage minimal = neverCompleted.minimalCompletionStage();
4479	+	for (int i = 0; i < n; i++)
4480	+	assertTrue(minimal.toCompletableFuture().cancel(true));
4481	+	}
4482	+
4483		//     static <U> U join(CompletionStage<U> stage) {
4484		//         CompletableFuture<U> f = new CompletableFuture<>();
4485		//         stage.whenComplete((v, ex) -> {

Diff Legend

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