ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/ExecutorCompletionServiceTest.java

Comparing jsr166/src/test/tck/ExecutorCompletionServiceTest.java (file contents):
Revision 1.8 by jsr166, Mon Nov 16 05:30:07 2009 UTC vs.
Revision 1.11 by jsr166, Wed Aug 25 00:07:03 2010 UTC

#	Line 10 | Line 10
10		import junit.framework.*;
11		import java.util.*;
12		import java.util.concurrent.*;
13	+	import static java.util.concurrent.TimeUnit.MILLISECONDS;
14		import java.util.concurrent.atomic.*;
15		import java.math.BigInteger;
16		import java.security.*;
17
18		public class ExecutorCompletionServiceTest extends JSR166TestCase {
19		public static void main(String[] args) {
20	<	junit.textui.TestRunner.run (suite());
20	>	junit.textui.TestRunner.run(suite());
21		}
22		public static Test suite() {
23		return new TestSuite(ExecutorCompletionServiceTest.class);
#	Line 30 | Line 31 | public class ExecutorCompletionServiceTe
31		try {
32		ExecutorCompletionService ecs = new ExecutorCompletionService(null);
33		shouldThrow();
34	<	} catch (NullPointerException success) {
34	<	}
34	>	} catch (NullPointerException success) {}
35		}
36
37		/**
#	Line 42 | Line 42 | public class ExecutorCompletionServiceTe
42		ExecutorService e = Executors.newCachedThreadPool();
43		ExecutorCompletionService ecs = new ExecutorCompletionService(e, null);
44		shouldThrow();
45	<	} catch (NullPointerException success) {
46	<	}
45	>	} catch (NullPointerException success) {}
46		}
47
48		/**
#	Line 81 | Line 80 | public class ExecutorCompletionServiceTe
80		/**
81		* A taken submitted task is completed
82		*/
83	<	public void testTake() {
83	>	public void testTake() throws InterruptedException {
84		ExecutorService e = Executors.newCachedThreadPool();
85		ExecutorCompletionService ecs = new ExecutorCompletionService(e);
86		try {
#	Line 89 | Line 88 | public class ExecutorCompletionServiceTe
88		ecs.submit(c);
89		Future f = ecs.take();
90		assertTrue(f.isDone());
92	–	} catch (Exception ex) {
93	–	unexpectedException();
91		} finally {
92		joinPool(e);
93		}
#	Line 99 | Line 96 | public class ExecutorCompletionServiceTe
96		/**
97		* Take returns the same future object returned by submit
98		*/
99	<	public void testTake2() {
99	>	public void testTake2() throws InterruptedException {
100		ExecutorService e = Executors.newCachedThreadPool();
101		ExecutorCompletionService ecs = new ExecutorCompletionService(e);
102		try {
#	Line 107 | Line 104 | public class ExecutorCompletionServiceTe
104		Future f1 = ecs.submit(c);
105		Future f2 = ecs.take();
106		assertSame(f1, f2);
110	–	} catch (Exception ex) {
111	–	unexpectedException();
107		} finally {
108		joinPool(e);
109		}
#	Line 117 | Line 112 | public class ExecutorCompletionServiceTe
112		/**
113		* If poll returns non-null, the returned task is completed
114		*/
115	<	public void testPoll1() {
115	>	public void testPoll1() throws InterruptedException {
116		ExecutorService e = Executors.newCachedThreadPool();
117		ExecutorCompletionService ecs = new ExecutorCompletionService(e);
118		try {
#	Line 132 | Line 127 | public class ExecutorCompletionServiceTe
127		break;
128		}
129		}
135	–	} catch (Exception ex) {
136	–	unexpectedException();
130		} finally {
131		joinPool(e);
132		}
#	Line 142 | Line 135 | public class ExecutorCompletionServiceTe
135		/**
136		* If timed poll returns non-null, the returned task is completed
137		*/
138	<	public void testPoll2() {
138	>	public void testPoll2() throws InterruptedException {
139		ExecutorService e = Executors.newCachedThreadPool();
140		ExecutorCompletionService ecs = new ExecutorCompletionService(e);
141		try {
142		assertNull(ecs.poll());
143		Callable c = new StringTask();
144		ecs.submit(c);
145	<	Future f = ecs.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
145	>	Future f = ecs.poll(SHORT_DELAY_MS, MILLISECONDS);
146		if (f != null)
147		assertTrue(f.isDone());
155	–	} catch (Exception ex) {
156	–	unexpectedException();
148		} finally {
149		joinPool(e);
150		}
#	Line 162 | Line 153 | public class ExecutorCompletionServiceTe
153		* Submitting to underlying AES that overrides newTaskFor(Callable)
154		* returns and eventually runs Future returned by newTaskFor.
155		*/
156	<	public void testNewTaskForCallable() {
156	>	public void testNewTaskForCallable() throws InterruptedException {
157		final AtomicBoolean done = new AtomicBoolean(false);
158		class MyCallableFuture<V> extends FutureTask<V> {
159		MyCallableFuture(Callable<V> c) { super(c); }
#	Line 186 | Line 177 | public class ExecutorCompletionServiceTe
177		Future f2 = ecs.take();
178		assertSame("submit and take must return same objects", f1, f2);
179		assertTrue("completed task must have set done", done.get());
189	–	} catch (Exception ex) {
190	–	unexpectedException();
180		} finally {
181		joinPool(e);
182		}
#	Line 197 | Line 186 | public class ExecutorCompletionServiceTe
186		* Submitting to underlying AES that overrides newTaskFor(Runnable,T)
187		* returns and eventually runs Future returned by newTaskFor.
188		*/
189	<	public void testNewTaskForRunnable() {
189	>	public void testNewTaskForRunnable() throws InterruptedException {
190		final AtomicBoolean done = new AtomicBoolean(false);
191		class MyRunnableFuture<V> extends FutureTask<V> {
192		MyRunnableFuture(Runnable t, V r) { super(t, r); }
#	Line 221 | Line 210 | public class ExecutorCompletionServiceTe
210		Future f2 = ecs.take();
211		assertSame("submit and take must return same objects", f1, f2);
212		assertTrue("completed task must have set done", done.get());
224	–	} catch (Exception ex) {
225	–	unexpectedException();
213		} finally {
214		joinPool(e);
215		}
216		}
217
231	–
232	–
218		}

Diff Legend

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