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.25 by jsr166, Sat Apr 20 23:28:35 2013 UTC vs.
Revision 1.31 by jsr166, Mon Sep 9 06:48:27 2013 UTC

#	Line 68 | Line 68 | public class CompletableFutureTest exten
68		} catch (Throwable fail) { threadUnexpectedException(fail); }
69		assertTrue(f.isDone());
70		assertFalse(f.isCancelled());
71	+	assertFalse(f.isCompletedExceptionally());
72		assertTrue(f.toString().contains("[Completed normally]"));
73		}
74
#	Line 121 | Line 122 | public class CompletableFutureTest exten
122		} catch (CancellationException success) {
123		} catch (Throwable fail) { threadUnexpectedException(fail); }
124		assertTrue(f.isDone());
125	+	assertTrue(f.isCompletedExceptionally());
126		assertTrue(f.isCancelled());
127		assertTrue(f.toString().contains("[Completed exceptionally]"));
128		}
#	Line 152 | Line 154 | public class CompletableFutureTest exten
154		} catch (Throwable fail) { threadUnexpectedException(fail); }
155		assertTrue(f.isDone());
156		assertFalse(f.isCancelled());
157	+	assertTrue(f.isCompletedExceptionally());
158		assertTrue(f.toString().contains("[Completed exceptionally]"));
159		}
160
#	Line 256 | Line 259 | public class CompletableFutureTest exten
259		assertEquals(g.getNumberOfDependents(), 0);
260		}
261
259	–
262		/**
263		* toString indicates current completion state
264		*/
#	Line 371 | Line 373 | public class CompletableFutureTest exten
373		}
374		}
375
374	–
376		/**
377		* exceptionally action completes with function value on source
378	<	* exception;  otherwise with source value
378	>	* exception; otherwise with source value
379		*/
380		public void testExceptionally() {
381		CompletableFuture<Integer> f = new CompletableFuture<>();
#	Line 660 | Line 661 | public class CompletableFutureTest exten
661		checkCompletedWithWrappedCancellationException(g);
662		}
663
663	–
664		/**
665		* thenCombine result completes normally after normal completion
666		* of sources
#	Line 1168 | Line 1168 | public class CompletableFutureTest exten
1168		checkCompletedWithWrappedCancellationException(g);
1169		}
1170
1171	–
1171		/**
1172		* runAfterEither result completes normally after normal completion
1173		* of either source
#	Line 1317 | Line 1316 | public class CompletableFutureTest exten
1316		checkCompletedWithWrappedCancellationException(g);
1317		}
1318
1320	–
1319		// asyncs
1320
1321		/**
#	Line 1350 | Line 1348 | public class CompletableFutureTest exten
1348		try {
1349		g.join();
1350		shouldThrow();
1351	<	} catch (Exception ok) {
1354	<	}
1351	>	} catch (CompletionException success) {}
1352		checkCompletedWithWrappedCFException(g);
1353		}
1354
#	Line 2085 | Line 2082 | public class CompletableFutureTest exten
2082		checkCompletedWithWrappedCancellationException(g);
2083		}
2084
2088	–
2085		// async with explicit executors
2086
2087		/**
#	Line 2118 | Line 2114 | public class CompletableFutureTest exten
2114		try {
2115		g.join();
2116		shouldThrow();
2117	<	} catch (Exception ok) {
2122	<	}
2117	>	} catch (CompletionException success) {}
2118		checkCompletedWithWrappedCFException(g);
2119		}
2120
#	Line 2936 | Line 2931 | public class CompletableFutureTest exten
2931		ThreadExecutor exec = new ThreadExecutor();
2932
2933		Runnable[] throwingActions = {
2934	<	() -> { CompletableFuture.supplyAsync(null); },
2935	<	() -> { CompletableFuture.supplyAsync(null, exec); },
2936	<	() -> { CompletableFuture.supplyAsync(supplyOne, null); },
2937	<
2938	<	() -> { CompletableFuture.runAsync(null); },
2939	<	() -> { CompletableFuture.runAsync(null, exec); },
2940	<	() -> { CompletableFuture.runAsync(() -> {}, null); },
2941	<
2942	<	() -> { f.completeExceptionally(null); },
2943	<
2944	<	() -> { f.thenApply(null); },
2945	<	() -> { f.thenApplyAsync(null); },
2946	<	() -> { f.thenApplyAsync((x) -> x, null); },
2947	<	() -> { f.thenApplyAsync(null, exec); },
2948	<
2949	<	() -> { f.thenAccept(null); },
2950	<	() -> { f.thenAcceptAsync(null); },
2951	<	() -> { f.thenAcceptAsync((x) -> { ; }, null); },
2952	<	() -> { f.thenAcceptAsync(null, exec); },
2953	<
2954	<	() -> { f.thenRun(null); },
2955	<	() -> { f.thenRunAsync(null); },
2956	<	() -> { f.thenRunAsync(() -> { ; }, null); },
2957	<	() -> { f.thenRunAsync(null, exec); },
2958	<
2959	<	() -> { f.thenCombine(g, null); },
2960	<	() -> { f.thenCombineAsync(g, null); },
2961	<	() -> { f.thenCombineAsync(g, null, exec); },
2962	<	() -> { f.thenCombine(nullFuture, (x, y) -> x); },
2963	<	() -> { f.thenCombineAsync(nullFuture, (x, y) -> x); },
2964	<	() -> { f.thenCombineAsync(nullFuture, (x, y) -> x, exec); },
2965	<	() -> { f.thenCombineAsync(g, (x, y) -> x, null); },
2966	<
2967	<	() -> { f.thenAcceptBoth(g, null); },
2968	<	() -> { f.thenAcceptBothAsync(g, null); },
2969	<	() -> { f.thenAcceptBothAsync(g, null, exec); },
2970	<	() -> { f.thenAcceptBoth(nullFuture, (x, y) -> {}); },
2971	<	() -> { f.thenAcceptBothAsync(nullFuture, (x, y) -> {}); },
2972	<	() -> { f.thenAcceptBothAsync(nullFuture, (x, y) -> {}, exec); },
2973	<	() -> { f.thenAcceptBothAsync(g, (x, y) -> {}, null); },
2974	<
2975	<	() -> { f.runAfterBoth(g, null); },
2976	<	() -> { f.runAfterBothAsync(g, null); },
2977	<	() -> { f.runAfterBothAsync(g, null, exec); },
2978	<	() -> { f.runAfterBoth(nullFuture, () -> {}); },
2979	<	() -> { f.runAfterBothAsync(nullFuture, () -> {}); },
2980	<	() -> { f.runAfterBothAsync(nullFuture, () -> {}, exec); },
2981	<	() -> { f.runAfterBothAsync(g, () -> {}, null); },
2982	<
2983	<	() -> { f.applyToEither(g, null); },
2984	<	() -> { f.applyToEitherAsync(g, null); },
2985	<	() -> { f.applyToEitherAsync(g, null, exec); },
2986	<	() -> { f.applyToEither(nullFuture, (x) -> x); },
2987	<	() -> { f.applyToEitherAsync(nullFuture, (x) -> x); },
2988	<	() -> { f.applyToEitherAsync(nullFuture, (x) -> x, exec); },
2989	<	() -> { f.applyToEitherAsync(g, (x) -> x, null); },
2990	<
2991	<	() -> { f.acceptEither(g, null); },
2992	<	() -> { f.acceptEitherAsync(g, null); },
2993	<	() -> { f.acceptEitherAsync(g, null, exec); },
2994	<	() -> { f.acceptEither(nullFuture, (x) -> {}); },
2995	<	() -> { f.acceptEitherAsync(nullFuture, (x) -> {}); },
2996	<	() -> { f.acceptEitherAsync(nullFuture, (x) -> {}, exec); },
2997	<	() -> { f.acceptEitherAsync(g, (x) -> {}, null); },
2998	<
2999	<	() -> { f.runAfterEither(g, null); },
3000	<	() -> { f.runAfterEitherAsync(g, null); },
3001	<	() -> { f.runAfterEitherAsync(g, null, exec); },
3002	<	() -> { f.runAfterEither(nullFuture, () -> {}); },
3003	<	() -> { f.runAfterEitherAsync(nullFuture, () -> {}); },
3004	<	() -> { f.runAfterEitherAsync(nullFuture, () -> {}, exec); },
3005	<	() -> { f.runAfterEitherAsync(g, () -> {}, null); },
3006	<
3007	<	() -> { f.thenCompose(null); },
3008	<	() -> { f.thenComposeAsync(null); },
3009	<	() -> { f.thenComposeAsync(new CompletableFutureInc(), null); },
3010	<	() -> { f.thenComposeAsync(null, exec); },
3011	<
3012	<	() -> { f.exceptionally(null); },
3013	<
3014	<	() -> { f.handle(null); },
3015	<
3016	<	() -> { CompletableFuture.allOf((CompletableFuture<?>)null); },
3017	<	() -> { CompletableFuture.allOf((CompletableFuture<?>[])null); },
3018	<	() -> { CompletableFuture.allOf(f, null); },
3019	<	() -> { CompletableFuture.allOf(null, f); },
3020	<
3021	<	() -> { CompletableFuture.anyOf((CompletableFuture<?>)null); },
3022	<	() -> { CompletableFuture.anyOf((CompletableFuture<?>[])null); },
3023	<	() -> { CompletableFuture.anyOf(f, null); },
3024	<	() -> { CompletableFuture.anyOf(null, f); },
2934	>	() -> CompletableFuture.supplyAsync(null),
2935	>	() -> CompletableFuture.supplyAsync(null, exec),
2936	>	() -> CompletableFuture.supplyAsync(supplyOne, null),
2937	>
2938	>	() -> CompletableFuture.runAsync(null),
2939	>	() -> CompletableFuture.runAsync(null, exec),
2940	>	() -> CompletableFuture.runAsync(() -> {}, null),
2941	>
2942	>	() -> f.completeExceptionally(null),
2943	>
2944	>	() -> f.thenApply(null),
2945	>	() -> f.thenApplyAsync(null),
2946	>	() -> f.thenApplyAsync((x) -> x, null),
2947	>	() -> f.thenApplyAsync(null, exec),
2948	>
2949	>	() -> f.thenAccept(null),
2950	>	() -> f.thenAcceptAsync(null),
2951	>	() -> f.thenAcceptAsync((x) -> {} , null),
2952	>	() -> f.thenAcceptAsync(null, exec),
2953	>
2954	>	() -> f.thenRun(null),
2955	>	() -> f.thenRunAsync(null),
2956	>	() -> f.thenRunAsync(() -> {} , null),
2957	>	() -> f.thenRunAsync(null, exec),
2958	>
2959	>	() -> f.thenCombine(g, null),
2960	>	() -> f.thenCombineAsync(g, null),
2961	>	() -> f.thenCombineAsync(g, null, exec),
2962	>	() -> f.thenCombine(nullFuture, (x, y) -> x),
2963	>	() -> f.thenCombineAsync(nullFuture, (x, y) -> x),
2964	>	() -> f.thenCombineAsync(nullFuture, (x, y) -> x, exec),
2965	>	() -> f.thenCombineAsync(g, (x, y) -> x, null),
2966	>
2967	>	() -> f.thenAcceptBoth(g, null),
2968	>	() -> f.thenAcceptBothAsync(g, null),
2969	>	() -> f.thenAcceptBothAsync(g, null, exec),
2970	>	() -> f.thenAcceptBoth(nullFuture, (x, y) -> {}),
2971	>	() -> f.thenAcceptBothAsync(nullFuture, (x, y) -> {}),
2972	>	() -> f.thenAcceptBothAsync(nullFuture, (x, y) -> {}, exec),
2973	>	() -> f.thenAcceptBothAsync(g, (x, y) -> {}, null),
2974	>
2975	>	() -> f.runAfterBoth(g, null),
2976	>	() -> f.runAfterBothAsync(g, null),
2977	>	() -> f.runAfterBothAsync(g, null, exec),
2978	>	() -> f.runAfterBoth(nullFuture, () -> {}),
2979	>	() -> f.runAfterBothAsync(nullFuture, () -> {}),
2980	>	() -> f.runAfterBothAsync(nullFuture, () -> {}, exec),
2981	>	() -> f.runAfterBothAsync(g, () -> {}, null),
2982	>
2983	>	() -> f.applyToEither(g, null),
2984	>	() -> f.applyToEitherAsync(g, null),
2985	>	() -> f.applyToEitherAsync(g, null, exec),
2986	>	() -> f.applyToEither(nullFuture, (x) -> x),
2987	>	() -> f.applyToEitherAsync(nullFuture, (x) -> x),
2988	>	() -> f.applyToEitherAsync(nullFuture, (x) -> x, exec),
2989	>	() -> f.applyToEitherAsync(g, (x) -> x, null),
2990	>
2991	>	() -> f.acceptEither(g, null),
2992	>	() -> f.acceptEitherAsync(g, null),
2993	>	() -> f.acceptEitherAsync(g, null, exec),
2994	>	() -> f.acceptEither(nullFuture, (x) -> {}),
2995	>	() -> f.acceptEitherAsync(nullFuture, (x) -> {}),
2996	>	() -> f.acceptEitherAsync(nullFuture, (x) -> {}, exec),
2997	>	() -> f.acceptEitherAsync(g, (x) -> {}, null),
2998	>
2999	>	() -> f.runAfterEither(g, null),
3000	>	() -> f.runAfterEitherAsync(g, null),
3001	>	() -> f.runAfterEitherAsync(g, null, exec),
3002	>	() -> f.runAfterEither(nullFuture, () -> {}),
3003	>	() -> f.runAfterEitherAsync(nullFuture, () -> {}),
3004	>	() -> f.runAfterEitherAsync(nullFuture, () -> {}, exec),
3005	>	() -> f.runAfterEitherAsync(g, () -> {}, null),
3006	>
3007	>	() -> f.thenCompose(null),
3008	>	() -> f.thenComposeAsync(null),
3009	>	() -> f.thenComposeAsync(new CompletableFutureInc(), null),
3010	>	() -> f.thenComposeAsync(null, exec),
3011	>
3012	>	() -> f.exceptionally(null),
3013	>
3014	>	() -> f.handle(null),
3015	>
3016	>	() -> CompletableFuture.allOf((CompletableFuture<?>)null),
3017	>	() -> CompletableFuture.allOf((CompletableFuture<?>[])null),
3018	>	() -> CompletableFuture.allOf(f, null),
3019	>	() -> CompletableFuture.allOf(null, f),
3020	>
3021	>	() -> CompletableFuture.anyOf((CompletableFuture<?>)null),
3022	>	() -> CompletableFuture.anyOf((CompletableFuture<?>[])null),
3023	>	() -> CompletableFuture.anyOf(f, null),
3024	>	() -> CompletableFuture.anyOf(null, f),
3025		};
3026
3027		assertThrows(NullPointerException.class, throwingActions);
3028		assertEquals(0, exec.count.get());
3029		}
3030
3031	+	/**
3032	+	* toCompletableFuture returns this CompletableFuture.
3033	+	*/
3034	+	public void testToCompletableFuture() {
3035	+	CompletableFuture<Integer> f = new CompletableFuture<>();
3036	+	assertSame(f, f.toCompletableFuture());
3037	+	}
3038	+
3039	+	/**
3040	+	* whenComplete action executes on normal completion, propagating
3041	+	* source result.
3042	+	*/
3043	+	public void testWhenComplete1() {
3044	+	final AtomicInteger a = new AtomicInteger();
3045	+	CompletableFuture<Integer> f = new CompletableFuture<>();
3046	+	CompletableFuture<Integer> g =
3047	+	f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
3048	+	f.complete(three);
3049	+	checkCompletedNormally(f, three);
3050	+	checkCompletedNormally(g, three);
3051	+	assertEquals(a.get(), 1);
3052	+	}
3053	+
3054	+	/**
3055	+	* whenComplete action executes on exceptional completion, propagating
3056	+	* source result.
3057	+	*/
3058	+	public void testWhenComplete2() {
3059	+	final AtomicInteger a = new AtomicInteger();
3060	+	CompletableFuture<Integer> f = new CompletableFuture<>();
3061	+	CompletableFuture<Integer> g =
3062	+	f.whenComplete((Integer x, Throwable t) -> a.getAndIncrement());
3063	+	f.completeExceptionally(new CFException());
3064	+	assertTrue(f.isCompletedExceptionally());
3065	+	assertTrue(g.isCompletedExceptionally());
3066	+	assertEquals(a.get(), 1);
3067	+	}
3068	+
3069	+	/**
3070	+	* If a whenComplete action throws an exception when triggered by
3071	+	* a normal completion, it completes exceptionally
3072	+	*/
3073	+	public void testWhenComplete3() {
3074	+	CompletableFuture<Integer> f = new CompletableFuture<>();
3075	+	CompletableFuture<Integer> g =
3076	+	f.whenComplete((Integer x, Throwable t) ->
3077	+	{ throw new CFException(); } );
3078	+	f.complete(three);
3079	+	checkCompletedNormally(f, three);
3080	+	assertTrue(g.isCompletedExceptionally());
3081	+	checkCompletedWithWrappedCFException(g);
3082	+	}
3083	+
3084	+	/**
3085	+	* whenCompleteAsync action executes on normal completion, propagating
3086	+	* source result.
3087	+	*/
3088	+	public void testWhenCompleteAsync1() {
3089	+	final AtomicInteger a = new AtomicInteger();
3090	+	CompletableFuture<Integer> f = new CompletableFuture<>();
3091	+	CompletableFuture<Integer> g =
3092	+	f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3093	+	f.complete(three);
3094	+	checkCompletedNormally(f, three);
3095	+	checkCompletedNormally(g, three);
3096	+	assertEquals(a.get(), 1);
3097	+	}
3098	+
3099	+	/**
3100	+	* whenCompleteAsync action executes on exceptional completion, propagating
3101	+	* source result.
3102	+	*/
3103	+	public void testWhenCompleteAsync2() {
3104	+	final AtomicInteger a = new AtomicInteger();
3105	+	CompletableFuture<Integer> f = new CompletableFuture<>();
3106	+	CompletableFuture<Integer> g =
3107	+	f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement());
3108	+	f.completeExceptionally(new CFException());
3109	+	checkCompletedWithWrappedCFException(f);
3110	+	checkCompletedWithWrappedCFException(g);
3111	+	}
3112	+
3113	+	/**
3114	+	* If a whenCompleteAsync action throws an exception when
3115	+	* triggered by a normal completion, it completes exceptionally
3116	+	*/
3117	+	public void testWhenCompleteAsync3() {
3118	+	CompletableFuture<Integer> f = new CompletableFuture<>();
3119	+	CompletableFuture<Integer> g =
3120	+	f.whenCompleteAsync((Integer x, Throwable t) ->
3121	+	{ throw new CFException(); } );
3122	+	f.complete(three);
3123	+	checkCompletedNormally(f, three);
3124	+	checkCompletedWithWrappedCFException(g);
3125	+	}
3126	+
3127	+	/**
3128	+	* whenCompleteAsync action executes on normal completion, propagating
3129	+	* source result.
3130	+	*/
3131	+	public void testWhenCompleteAsync1e() {
3132	+	final AtomicInteger a = new AtomicInteger();
3133	+	ThreadExecutor exec = new ThreadExecutor();
3134	+	CompletableFuture<Integer> f = new CompletableFuture<>();
3135	+	CompletableFuture<Integer> g =
3136	+	f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
3137	+	exec);
3138	+	f.complete(three);
3139	+	checkCompletedNormally(f, three);
3140	+	checkCompletedNormally(g, three);
3141	+	assertEquals(a.get(), 1);
3142	+	}
3143	+
3144	+	/**
3145	+	* whenCompleteAsync action executes on exceptional completion, propagating
3146	+	* source result.
3147	+	*/
3148	+	public void testWhenCompleteAsync2e() {
3149	+	final AtomicInteger a = new AtomicInteger();
3150	+	ThreadExecutor exec = new ThreadExecutor();
3151	+	CompletableFuture<Integer> f = new CompletableFuture<>();
3152	+	CompletableFuture<Integer> g =
3153	+	f.whenCompleteAsync((Integer x, Throwable t) -> a.getAndIncrement(),
3154	+	exec);
3155	+	f.completeExceptionally(new CFException());
3156	+	checkCompletedWithWrappedCFException(f);
3157	+	checkCompletedWithWrappedCFException(g);
3158	+	}
3159	+
3160	+	/**
3161	+	* If a whenCompleteAsync action throws an exception when triggered
3162	+	* by a normal completion, it completes exceptionally
3163	+	*/
3164	+	public void testWhenCompleteAsync3e() {
3165	+	ThreadExecutor exec = new ThreadExecutor();
3166	+	CompletableFuture<Integer> f = new CompletableFuture<>();
3167	+	CompletableFuture<Integer> g =
3168	+	f.whenCompleteAsync((Integer x, Throwable t) ->
3169	+	{ throw new CFException(); },
3170	+	exec);
3171	+	f.complete(three);
3172	+	checkCompletedNormally(f, three);
3173	+	checkCompletedWithWrappedCFException(g);
3174	+	}
3175	+
3176	+	/**
3177	+	* handleAsync action completes normally with function value on
3178	+	* either normal or exceptional completion of source
3179	+	*/
3180	+	public void testHandleAsync() {
3181	+	CompletableFuture<Integer> f, g;
3182	+	IntegerHandler r;
3183	+
3184	+	f = new CompletableFuture<>();
3185	+	g = f.handleAsync(r = new IntegerHandler());
3186	+	assertFalse(r.ran);
3187	+	f.completeExceptionally(new CFException());
3188	+	checkCompletedWithWrappedCFException(f);
3189	+	checkCompletedNormally(g, three);
3190	+	assertTrue(r.ran);
3191	+
3192	+	f = new CompletableFuture<>();
3193	+	g = f.handleAsync(r = new IntegerHandler());
3194	+	assertFalse(r.ran);
3195	+	f.completeExceptionally(new CFException());
3196	+	checkCompletedWithWrappedCFException(f);
3197	+	checkCompletedNormally(g, three);
3198	+	assertTrue(r.ran);
3199	+
3200	+	f = new CompletableFuture<>();
3201	+	g = f.handleAsync(r = new IntegerHandler());
3202	+	assertFalse(r.ran);
3203	+	f.complete(one);
3204	+	checkCompletedNormally(f, one);
3205	+	checkCompletedNormally(g, two);
3206	+	assertTrue(r.ran);
3207	+
3208	+	f = new CompletableFuture<>();
3209	+	g = f.handleAsync(r = new IntegerHandler());
3210	+	assertFalse(r.ran);
3211	+	f.complete(one);
3212	+	checkCompletedNormally(f, one);
3213	+	checkCompletedNormally(g, two);
3214	+	assertTrue(r.ran);
3215	+	}
3216	+
3217	+	/**
3218	+	* handleAsync action with Executor completes normally with
3219	+	* function value on either normal or exceptional completion of
3220	+	* source
3221	+	*/
3222	+	public void testHandleAsync2() {
3223	+	CompletableFuture<Integer> f, g;
3224	+	ThreadExecutor exec = new ThreadExecutor();
3225	+	IntegerHandler r;
3226	+
3227	+	f = new CompletableFuture<>();
3228	+	g = f.handleAsync(r = new IntegerHandler(), exec);
3229	+	assertFalse(r.ran);
3230	+	f.completeExceptionally(new CFException());
3231	+	checkCompletedWithWrappedCFException(f);
3232	+	checkCompletedNormally(g, three);
3233	+	assertTrue(r.ran);
3234	+
3235	+	f = new CompletableFuture<>();
3236	+	g = f.handleAsync(r = new IntegerHandler(), exec);
3237	+	assertFalse(r.ran);
3238	+	f.completeExceptionally(new CFException());
3239	+	checkCompletedWithWrappedCFException(f);
3240	+	checkCompletedNormally(g, three);
3241	+	assertTrue(r.ran);
3242	+
3243	+	f = new CompletableFuture<>();
3244	+	g = f.handleAsync(r = new IntegerHandler(), exec);
3245	+	assertFalse(r.ran);
3246	+	f.complete(one);
3247	+	checkCompletedNormally(f, one);
3248	+	checkCompletedNormally(g, two);
3249	+	assertTrue(r.ran);
3250	+
3251	+	f = new CompletableFuture<>();
3252	+	g = f.handleAsync(r = new IntegerHandler(), exec);
3253	+	assertFalse(r.ran);
3254	+	f.complete(one);
3255	+	checkCompletedNormally(f, one);
3256	+	checkCompletedNormally(g, two);
3257	+	assertTrue(r.ran);
3258	+	}
3259	+
3260		}

Diff Legend

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