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.158 by jsr166, Mon Jun 27 21:17:49 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 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 = 3_000_000;
4176	+	final int n = 100;
4177	+	final CompletableFuture<Integer> incomplete = new CompletableFuture<>();
4178	+	CompletableFuture<Integer> f;
4179	+	for (int i = 0; i < n; i++) {
4180	+	f = new CompletableFuture<>();
4181	+	f.runAfterEither(incomplete, () -> {});
4182	+	f.complete(null);
4183	+
4184	+	f = new CompletableFuture<>();
4185	+	f.acceptEither(incomplete, (x) -> {});
4186	+	f.complete(null);
4187	+
4188	+	f = new CompletableFuture<>();
4189	+	f.applyToEither(incomplete, (x) -> x);
4190	+	f.complete(null);
4191	+
4192	+	f = new CompletableFuture<>();
4193	+	CompletableFuture.anyOf(new CompletableFuture<?>[] { f, incomplete });
4194	+	f.complete(null);
4195	+	}
4196	+
4197	+	for (int i = 0; i < n; i++) {
4198	+	f = new CompletableFuture<>();
4199	+	incomplete.runAfterEither(f, () -> {});
4200	+	f.complete(null);
4201	+
4202	+	f = new CompletableFuture<>();
4203	+	incomplete.acceptEither(f, (x) -> {});
4204	+	f.complete(null);
4205	+
4206	+	f = new CompletableFuture<>();
4207	+	incomplete.applyToEither(f, (x) -> x);
4208	+	f.complete(null);
4209	+
4210	+	f = new CompletableFuture<>();
4211	+	CompletableFuture.anyOf(new CompletableFuture<?>[] { incomplete, f });
4212	+	f.complete(null);
4213	+	}
4214	+	}
4215	+
4216	+	/*
4217	+	* Tests below currently fail in stress mode due to memory retention.
4218	+	* ant -Dvmoptions=-Xmx8m -Djsr166.expensiveTests=true -Djsr166.tckTestClass=CompletableFutureTest tck
4219	+	*/
4220	+
4221	+	/** Checks for garbage retention with anyOf. */
4222	+	public void testAnyOfGarbageRetention() throws Throwable {
4223	+	for (Integer v : new Integer[] { 1, null })
4224	+	{
4225	+	final int n = expensiveTests ? 100_000 : 10;
4226	+	CompletableFuture<Integer>[] fs
4227	+	= (CompletableFuture<Integer>[]) new CompletableFuture<?>[100];
4228	+	for (int i = 0; i < fs.length; i++)
4229	+	fs[i] = new CompletableFuture<>();
4230	+	fs[fs.length - 1].complete(v);
4231	+	for (int i = 0; i < n; i++)
4232	+	checkCompletedNormally(CompletableFuture.anyOf(fs), v);
4233	+	}}
4234	+
4235	+	/** Checks for garbage retention with allOf. */
4236	+	public void testCancelledAllOfGarbageRetention() throws Throwable {
4237	+	final int n = expensiveTests ? 100_000 : 10;
4238	+	CompletableFuture<Integer>[] fs
4239	+	= (CompletableFuture<Integer>[]) new CompletableFuture<?>[100];
4240	+	for (int i = 0; i < fs.length; i++)
4241	+	fs[i] = new CompletableFuture<>();
4242	+	for (int i = 0; i < n; i++)
4243	+	assertTrue(CompletableFuture.allOf(fs).cancel(false));
4244	+	}
4245	+
4246		//     static <U> U join(CompletionStage<U> stage) {
4247		//         CompletableFuture<U> f = new CompletableFuture<>();
4248		//         stage.whenComplete((v, ex) -> {

Diff Legend

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