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.48 by jsr166, Mon Jun 2 19:07:14 2014 UTC vs.
Revision 1.50 by jsr166, Mon Jun 2 19:32:57 2014 UTC

#	Line 416 | Line 416 | public class CompletableFutureTest exten
416		throw new CFException();
417		}
418		}
419	<	static final class FailingNoop implements Runnable {
419	>	static final class FailingRunnable implements Runnable {
420		int invocationCount = 0;
421		public void run() {
422		invocationCount++;
#	Line 933 | Line 933 | public class CompletableFutureTest exten
933		* failing runAsync completes exceptionally after running Runnable
934		*/
935		public void testRunAsync3() {
936	<	FailingNoop r = new FailingNoop();
936	>	FailingRunnable r = new FailingRunnable();
937		CompletableFuture<Void> f = CompletableFuture.runAsync(r);
938		checkCompletedWithWrappedCFException(f);
939		assertEquals(1, r.invocationCount);
#	Line 1038 | Line 1038 | public class CompletableFutureTest exten
1038		for (Integer v1 : new Integer[] { 1, null })
1039		{
1040		final CompletableFuture<Integer> f = new CompletableFuture<>();
1041	<	final FailingNoop r = new FailingNoop();
1041	>	final FailingRunnable r = new FailingRunnable();
1042		if (!createIncomplete) f.complete(v1);
1043		final CompletableFuture<Void> g = f.thenRun(r);
1044		if (createIncomplete) f.complete(v1);
#	Line 1050 | Line 1050 | public class CompletableFutureTest exten
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() {
1075	<	CompletableFuture<Integer> f = new CompletableFuture<>();
1076	<	CompletableFuture<Integer> g = f.thenApply(new FailingFunction());
1077	<	f.complete(one);
1078	<	checkCompletedWithWrappedCFException(g);
1079	<	}
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
1131		*/
1132	<	public void testThenAccept() {
1133	<	CompletableFuture<Integer> f = new CompletableFuture<>();
1134	<	IncAction r = new IncAction();
1135	<	CompletableFuture<Void> g = f.thenAccept(r);
1136	<	f.complete(one);
1132	>	public void testThenAccept_normalCompletion() {
1133	>	for (ExecutionMode m : ExecutionMode.values())
1134	>	for (boolean createIncomplete : new boolean[] { true, false })
1135	>	for (Integer v1 : new Integer[] { 1, null })
1136	>	{
1137	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1138	>	final IncAction r = new IncAction();
1139	>	if (!createIncomplete) f.complete(v1);
1140	>	final CompletableFuture<Void> g = m.thenAccept(f, r);
1141	>	if (createIncomplete) f.complete(v1);
1142	>
1143		checkCompletedNormally(g, null);
1144	<	assertEquals(r.value, (Integer) 2);
1145	<	}
1144	>	checkCompletedNormally(f, v1);
1145	>	assertEquals(1, r.invocationCount);
1146	>	assertEquals(inc(v1), r.value);
1147	>	}}
1148
1149		/**
1150		* thenAccept result completes exceptionally after exceptional
1151		* completion of source
1152		*/
1153	<	public void testThenAccept2() {
1154	<	CompletableFuture<Integer> f = new CompletableFuture<>();
1155	<	IncAction r = new IncAction();
1156	<	CompletableFuture<Void> g = f.thenAccept(r);
1157	<	f.completeExceptionally(new CFException());
1158	<	checkCompletedWithWrappedCFException(g);
1159	<	}
1153	>	public void testThenAccept_exceptionalCompletion() {
1154	>	for (ExecutionMode m : ExecutionMode.values())
1155	>	for (boolean createIncomplete : new boolean[] { true, false })
1156	>	{
1157	>	final CFException ex = new CFException();
1158	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1159	>	final IncAction r = new IncAction();
1160	>	if (!createIncomplete) f.completeExceptionally(ex);
1161	>	final CompletableFuture<Void> g = m.thenAccept(f, r);
1162	>	if (createIncomplete) f.completeExceptionally(ex);
1163	>
1164	>	checkCompletedWithWrappedCFException(g, ex);
1165	>	checkCompletedWithWrappedCFException(f, ex);
1166	>	assertEquals(0, r.invocationCount);
1167	>	}}
1168
1169		/**
1170		* thenAccept result completes exceptionally if action does
1171		*/
1172	<	public void testThenAccept3() {
1173	<	CompletableFuture<Integer> f = new CompletableFuture<>();
1174	<	FailingConsumer r = new FailingConsumer();
1175	<	CompletableFuture<Void> g = f.thenAccept(r);
1176	<	f.complete(one);
1172	>	public void testThenAccept_actionFailed() {
1173	>	for (ExecutionMode m : ExecutionMode.values())
1174	>	for (boolean createIncomplete : new boolean[] { true, false })
1175	>	for (Integer v1 : new Integer[] { 1, null })
1176	>	{
1177	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1178	>	final FailingConsumer r = new FailingConsumer();
1179	>	if (!createIncomplete) f.complete(v1);
1180	>	final CompletableFuture<Void> g = f.thenAccept(r);
1181	>	if (createIncomplete) f.complete(v1);
1182	>
1183		checkCompletedWithWrappedCFException(g);
1184	<	assertEquals(1, r.invocationCount);
1185	<	}
1184	>	checkCompletedNormally(f, v1);
1185	>	}}
1186
1187		/**
1188		* thenAccept result completes exceptionally if source cancelled
1189		*/
1190	<	public void testThenAccept4() {
1191	<	CompletableFuture<Integer> f = new CompletableFuture<>();
1192	<	IncAction r = new IncAction();
1193	<	CompletableFuture<Void> g = f.thenAccept(r);
1194	<	assertTrue(f.cancel(true));
1190	>	public void testThenAccept_sourceCancelled() {
1191	>	for (ExecutionMode m : ExecutionMode.values())
1192	>	for (boolean createIncomplete : new boolean[] { true, false })
1193	>	for (boolean mayInterruptIfRunning : new boolean[] { true, false })
1194	>	{
1195	>	final CompletableFuture<Integer> f = new CompletableFuture<>();
1196	>	final IncAction r = new IncAction();
1197	>	if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
1198	>	final CompletableFuture<Void> g = f.thenAccept(r);
1199	>	if (createIncomplete) {
1200	>	checkIncomplete(g);
1201	>	assertTrue(f.cancel(mayInterruptIfRunning));
1202	>	}
1203	>
1204		checkCompletedWithWrappedCancellationException(g);
1205	<	}
1205	>	checkCancelled(f);
1206	>	assertEquals(0, r.invocationCount);
1207	>	}}
1208
1209		/**
1210		* thenCombine result completes normally after normal completion
#	Line 1838 | Line 1909 | public class CompletableFutureTest exten
1909		{
1910		final CompletableFuture<Integer> f = new CompletableFuture<>();
1911		final CompletableFuture<Integer> g = new CompletableFuture<>();
1912	<	final FailingNoop r = new FailingNoop();
1912	>	final FailingRunnable r = new FailingRunnable();
1913		final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1914
1915		f.complete(v1);
#	Line 1857 | Line 1928 | public class CompletableFutureTest exten
1928		{
1929		final CompletableFuture<Integer> f = new CompletableFuture<>();
1930		final CompletableFuture<Integer> g = new CompletableFuture<>();
1931	<	final FailingNoop r = new FailingNoop();
1931	>	final FailingRunnable r = new FailingRunnable();
1932		final CompletableFuture<Void> h = m.runAfterBoth(f, g, r);
1933
1934		g.complete(v2);
#	Line 2721 | Line 2792 | public class CompletableFutureTest exten
2792		{
2793		final CompletableFuture<Integer> f = new CompletableFuture<>();
2794		final CompletableFuture<Integer> g = new CompletableFuture<>();
2795	<	final FailingNoop r = new FailingNoop();
2795	>	final FailingRunnable r = new FailingRunnable();
2796		final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2797
2798		f.complete(v1);
#	Line 2738 | Line 2809 | public class CompletableFutureTest exten
2809		{
2810		final CompletableFuture<Integer> f = new CompletableFuture<>();
2811		final CompletableFuture<Integer> g = new CompletableFuture<>();
2812	<	final FailingNoop r = new FailingNoop();
2812	>	final FailingRunnable r = new FailingRunnable();
2813		final CompletableFuture<Void> h = m.runAfterEither(f, g, r);
2814
2815		g.complete(v2);
#	Line 2915 | Line 2986 | public class CompletableFutureTest exten
2986		final CompletableFutureInc r = new CompletableFutureInc();
2987		if (!createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2988		final CompletableFuture<Integer> g = f.thenCompose(r);
2989	<	if (createIncomplete) assertTrue(f.cancel(mayInterruptIfRunning));
2989	>	if (createIncomplete) {
2990	>	checkIncomplete(g);
2991	>	assertTrue(f.cancel(mayInterruptIfRunning));
2992	>	}
2993
2994		checkCompletedWithWrappedCancellationException(g);
2995		checkCancelled(f);
2996		}}
2997
2924	–	// asyncs
2925	–
2926	–	/**
2927	–	* thenApplyAsync result completes normally after normal completion of source
2928	–	*/
2929	–	public void testThenApplyAsync() {
2930	–	CompletableFuture<Integer> f = new CompletableFuture<>();
2931	–	CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2932	–	f.complete(one);
2933	–	checkCompletedNormally(g, two);
2934	–	}
2935	–
2936	–	/**
2937	–	* thenApplyAsync result completes exceptionally after exceptional
2938	–	* completion of source
2939	–	*/
2940	–	public void testThenApplyAsync2() {
2941	–	CompletableFuture<Integer> f = new CompletableFuture<>();
2942	–	CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2943	–	f.completeExceptionally(new CFException());
2944	–	checkCompletedWithWrappedCFException(g);
2945	–	}
2946	–
2947	–	/**
2948	–	* thenApplyAsync result completes exceptionally if action does
2949	–	*/
2950	–	public void testThenApplyAsync3() {
2951	–	CompletableFuture<Integer> f = new CompletableFuture<>();
2952	–	FailingFunction r = new FailingFunction();
2953	–	CompletableFuture<Integer> g = f.thenApplyAsync(r);
2954	–	f.complete(null);
2955	–	checkCompletedWithWrappedCFException(g);
2956	–	}
2957	–
2958	–	/**
2959	–	* thenApplyAsync result completes exceptionally if source cancelled
2960	–	*/
2961	–	public void testThenApplyAsync4() {
2962	–	CompletableFuture<Integer> f = new CompletableFuture<>();
2963	–	CompletableFuture<Integer> g = f.thenApplyAsync(inc);
2964	–	assertTrue(f.cancel(true));
2965	–	checkCompletedWithWrappedCancellationException(g);
2966	–	}
2967	–
2968	–	/**
2969	–	* thenAcceptAsync result completes normally after normal
2970	–	* completion of source
2971	–	*/
2972	–	public void testThenAcceptAsync() {
2973	–	CompletableFuture<Integer> f = new CompletableFuture<>();
2974	–	IncAction r = new IncAction();
2975	–	CompletableFuture<Void> g = f.thenAcceptAsync(r);
2976	–	f.complete(one);
2977	–	checkCompletedNormally(g, null);
2978	–	assertEquals(r.value, (Integer) 2);
2979	–	}
2980	–
2981	–	/**
2982	–	* thenAcceptAsync result completes exceptionally after exceptional
2983	–	* completion of source
2984	–	*/
2985	–	public void testThenAcceptAsync2() {
2986	–	CompletableFuture<Integer> f = new CompletableFuture<>();
2987	–	IncAction r = new IncAction();
2988	–	CompletableFuture<Void> g = f.thenAcceptAsync(r);
2989	–	f.completeExceptionally(new CFException());
2990	–	checkCompletedWithWrappedCFException(g);
2991	–	}
2992	–
2993	–	/**
2994	–	* thenAcceptAsync result completes exceptionally if action does
2995	–	*/
2996	–	public void testThenAcceptAsync3() {
2997	–	CompletableFuture<Integer> f = new CompletableFuture<>();
2998	–	FailingConsumer r = new FailingConsumer();
2999	–	CompletableFuture<Void> g = f.thenAcceptAsync(r);
3000	–	f.complete(null);
3001	–	checkCompletedWithWrappedCFException(g);
3002	–	}
3003	–
3004	–	/**
3005	–	* thenAcceptAsync result completes exceptionally if source cancelled
3006	–	*/
3007	–	public void testThenAcceptAsync4() {
3008	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3009	–	IncAction r = new IncAction();
3010	–	CompletableFuture<Void> g = f.thenAcceptAsync(r);
3011	–	assertTrue(f.cancel(true));
3012	–	checkCompletedWithWrappedCancellationException(g);
3013	–	}
3014	–
3015	–	// async with explicit executors
3016	–
3017	–	/**
3018	–	* thenApplyAsync result completes normally after normal completion of source
3019	–	*/
3020	–	public void testThenApplyAsyncE() {
3021	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3022	–	CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3023	–	f.complete(one);
3024	–	checkCompletedNormally(g, two);
3025	–	}
3026	–
3027	–	/**
3028	–	* thenApplyAsync result completes exceptionally after exceptional
3029	–	* completion of source
3030	–	*/
3031	–	public void testThenApplyAsync2E() {
3032	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3033	–	CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3034	–	f.completeExceptionally(new CFException());
3035	–	checkCompletedWithWrappedCFException(g);
3036	–	}
3037	–
3038	–	/**
3039	–	* thenApplyAsync result completes exceptionally if action does
3040	–	*/
3041	–	public void testThenApplyAsync3E() {
3042	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3043	–	FailingFunction r = new FailingFunction();
3044	–	CompletableFuture<Integer> g = f.thenApplyAsync(r, new ThreadExecutor());
3045	–	f.complete(null);
3046	–	checkCompletedWithWrappedCFException(g);
3047	–	}
3048	–
3049	–	/**
3050	–	* thenApplyAsync result completes exceptionally if source cancelled
3051	–	*/
3052	–	public void testThenApplyAsync4E() {
3053	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3054	–	CompletableFuture<Integer> g = f.thenApplyAsync(inc, new ThreadExecutor());
3055	–	assertTrue(f.cancel(true));
3056	–	checkCompletedWithWrappedCancellationException(g);
3057	–	}
3058	–
3059	–	/**
3060	–	* thenAcceptAsync result completes normally after normal
3061	–	* completion of source
3062	–	*/
3063	–	public void testThenAcceptAsyncE() {
3064	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3065	–	IncAction r = new IncAction();
3066	–	CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3067	–	f.complete(one);
3068	–	checkCompletedNormally(g, null);
3069	–	assertEquals(r.value, (Integer) 2);
3070	–	}
3071	–
3072	–	/**
3073	–	* thenAcceptAsync result completes exceptionally after exceptional
3074	–	* completion of source
3075	–	*/
3076	–	public void testThenAcceptAsync2E() {
3077	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3078	–	IncAction r = new IncAction();
3079	–	CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3080	–	f.completeExceptionally(new CFException());
3081	–	checkCompletedWithWrappedCFException(g);
3082	–	}
3083	–
3084	–	/**
3085	–	* thenAcceptAsync result completes exceptionally if action does
3086	–	*/
3087	–	public void testThenAcceptAsync3E() {
3088	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3089	–	FailingConsumer r = new FailingConsumer();
3090	–	CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3091	–	f.complete(null);
3092	–	checkCompletedWithWrappedCFException(g);
3093	–	}
3094	–
3095	–	/**
3096	–	* thenAcceptAsync result completes exceptionally if source cancelled
3097	–	*/
3098	–	public void testThenAcceptAsync4E() {
3099	–	CompletableFuture<Integer> f = new CompletableFuture<>();
3100	–	IncAction r = new IncAction();
3101	–	CompletableFuture<Void> g = f.thenAcceptAsync(r, new ThreadExecutor());
3102	–	assertTrue(f.cancel(true));
3103	–	checkCompletedWithWrappedCancellationException(g);
3104	–	}
3105	–
2998		// other static methods
2999
3000		/**

Diff Legend

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