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.154 by jsr166, Sun Jun 26 19:27:42 2016 UTC vs.
Revision 1.159 by jsr166, Mon Jun 27 21:39:37 2016 UTC

#	Line 550 | Line 550 | public class CompletableFutureTest exten
550		}
551		}
552
553	+	static class CountingRejectingExecutor implements Executor {
554	+	final RejectedExecutionException ex = new RejectedExecutionException();
555	+	final AtomicInteger count = new AtomicInteger(0);
556	+	public void execute(Runnable r) {
557	+	count.getAndIncrement();
558	+	throw ex;
559	+	}
560	+	}
561	+
562		// Used for explicit executor tests
563		static final class ThreadExecutor implements Executor {
564		final AtomicInteger count = new AtomicInteger(0);
#	Line 1234 | Line 1243 | public class CompletableFutureTest exten
1243		r.assertInvoked();
1244		}}
1245
1246	+	public void testRunAsync_rejectingExecutor() {
1247	+	CountingRejectingExecutor e = new CountingRejectingExecutor();
1248	+	try {
1249	+	CompletableFuture.runAsync(() -> {}, e);
1250	+	shouldThrow();
1251	+	} catch (Throwable t) {
1252	+	assertSame(e.ex, t);
1253	+	}
1254	+
1255	+	assertEquals(1, e.count.get());
1256	+	}
1257	+
1258		/**
1259		* supplyAsync completes with result of supplier
1260		*/
#	Line 1268 | Line 1289 | public class CompletableFutureTest exten
1289		r.assertInvoked();
1290		}}
1291
1292	+	public void testSupplyAsync_rejectingExecutor() {
1293	+	CountingRejectingExecutor e = new CountingRejectingExecutor();
1294	+	try {
1295	+	CompletableFuture.supplyAsync(() -> null, e);
1296	+	shouldThrow();
1297	+	} catch (Throwable t) {
1298	+	assertSame(e.ex, t);
1299	+	}
1300	+
1301	+	assertEquals(1, e.count.get());
1302	+	}
1303	+
1304		// seq completion methods
1305
1306		/**
#	Line 3317 | Line 3350 | public class CompletableFutureTest exten
3350		assertEquals(0, exec.count.get());
3351		}
3352
3320	–	static class CountingRejectingExecutor implements Executor {
3321	–	final RejectedExecutionException ex = new RejectedExecutionException();
3322	–	final AtomicInteger count = new AtomicInteger(0);
3323	–	public void execute(Runnable r) {
3324	–	count.getAndIncrement();
3325	–	throw ex;
3326	–	}
3327	–	}
3328	–
3353		/**
3354		* Test submissions to an executor that rejects all tasks.
3355		*/
#	Line 4119 | Line 4143 | public class CompletableFutureTest exten
4143		* A demo of scalability - runtime is O(n).
4144		*/
4145		public void testManyDependents() throws Throwable {
4146	<	final int n = 1_000;
4146	>	final int n = expensiveTests ? 1_000_000 : 10;
4147		final CompletableFuture<Void> head = new CompletableFuture<>();
4148		final CompletableFuture<Void> complete = CompletableFuture.completedFuture((Void)null);
4149		final AtomicInteger count = new AtomicInteger(0);
#	Line 4146 | Line 4170 | public class CompletableFutureTest exten
4170		assertEquals(5 * 3 * n, count.get());
4171		}
4172
4173	+	/** ant -Dvmoptions=-Xmx8m -Djsr166.tckTestClass=CompletableFutureTest tck */
4174	+	public void testCoCompletionGarbage() throws Throwable {
4175	+	final int n = expensiveTests ? 1_000_000 : 10;
4176	+	final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
4177	+	CompletableFuture<Integer> f;
4178	+	for (int i = 0; i < n; i++) {
4179	+	f = new CompletableFuture<>();
4180	+	f.runAfterEither(incomplete, () -> {});
4181	+	f.complete(null);
4182	+
4183	+	f = new CompletableFuture<>();
4184	+	f.acceptEither(incomplete, (x) -> {});
4185	+	f.complete(null);
4186	+
4187	+	f = new CompletableFuture<>();
4188	+	f.applyToEither(incomplete, (x) -> x);
4189	+	f.complete(null);
4190	+
4191	+	f = new CompletableFuture<>();
4192	+	CompletableFuture.anyOf(new CompletableFuture<?>[] { f, incomplete });
4193	+	f.complete(null);
4194	+	}
4195	+
4196	+	for (int i = 0; i < n; i++) {
4197	+	f = new CompletableFuture<>();
4198	+	incomplete.runAfterEither(f, () -> {});
4199	+	f.complete(null);
4200	+
4201	+	f = new CompletableFuture<>();
4202	+	incomplete.acceptEither(f, (x) -> {});
4203	+	f.complete(null);
4204	+
4205	+	f = new CompletableFuture<>();
4206	+	incomplete.applyToEither(f, (x) -> x);
4207	+	f.complete(null);
4208	+
4209	+	f = new CompletableFuture<>();
4210	+	CompletableFuture.anyOf(new CompletableFuture<?>[] { incomplete, f });
4211	+	f.complete(null);
4212	+	}
4213	+	}
4214	+
4215	+	/*
4216	+	* Tests below currently fail in stress mode due to memory retention.
4217	+	* ant -Dvmoptions=-Xmx8m -Djsr166.expensiveTests=true -Djsr166.tckTestClass=CompletableFutureTest tck
4218	+	*/
4219	+
4220	+	/** Checks for garbage retention with anyOf. */
4221	+	public void testAnyOfGarbageRetention() throws Throwable {
4222	+	for (Integer v : new Integer[] { 1, null })
4223	+	{
4224	+	final int n = expensiveTests ? 100_000 : 10;
4225	+	CompletableFuture<Integer>[] fs
4226	+	= (CompletableFuture<Integer>[]) new CompletableFuture<?>[100];
4227	+	for (int i = 0; i < fs.length; i++)
4228	+	fs[i] = new CompletableFuture<>();
4229	+	fs[fs.length - 1].complete(v);
4230	+	for (int i = 0; i < n; i++)
4231	+	checkCompletedNormally(CompletableFuture.anyOf(fs), v);
4232	+	}}
4233	+
4234	+	/** Checks for garbage retention with allOf. */
4235	+	public void testCancelledAllOfGarbageRetention() throws Throwable {
4236	+	final int n = expensiveTests ? 100_000 : 10;
4237	+	CompletableFuture<Integer>[] fs
4238	+	= (CompletableFuture<Integer>[]) new CompletableFuture<?>[100];
4239	+	for (int i = 0; i < fs.length; i++)
4240	+	fs[i] = new CompletableFuture<>();
4241	+	for (int i = 0; i < n; i++)
4242	+	assertTrue(CompletableFuture.allOf(fs).cancel(false));
4243	+	}
4244	+
4245		//     static <U> U join(CompletionStage<U> stage) {
4246		//         CompletableFuture<U> f = new CompletableFuture<>();
4247		//         stage.whenComplete((v, ex) -> {

Diff Legend

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