ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ExecutorCompletionServiceTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ExecutorCompletionServiceTest.java (file contents):
Revision 1.3 by dl, Tue May 3 16:02:00 2005 UTC vs.
Revision 1.7 by jsr166, Mon Nov 2 20:28:31 2009 UTC

# Line 2 | Line 2
2   * Written by Doug Lea with assistance from members of JCP JSR-166
3   * Expert Group and released to the public domain, as explained at
4   * http://creativecommons.org/licenses/publicdomain
5 < * Other contributors include Andrew Wright, Jeffrey Hayes,
6 < * Pat Fisher, Mike Judd.
5 > * Other contributors include Andrew Wright, Jeffrey Hayes,
6 > * Pat Fisher, Mike Judd.
7   */
8  
9  
10   import junit.framework.*;
11   import java.util.*;
12   import java.util.concurrent.*;
13 + import java.util.concurrent.atomic.*;
14   import java.math.BigInteger;
15   import java.security.*;
16  
17   public class ExecutorCompletionServiceTest extends JSR166TestCase{
18      public static void main(String[] args) {
19 <        junit.textui.TestRunner.run (suite());  
19 >        junit.textui.TestRunner.run (suite());
20      }
21      public static Test suite() {
22          return new TestSuite(ExecutorCompletionServiceTest.class);
# Line 24 | Line 25 | public class ExecutorCompletionServiceTe
25  
26      /**
27       * Creating a new ECS with null Executor throw NPE
28 <     */
28 >     */
29      public void testConstructorNPE() {
30          try {
31              ExecutorCompletionService ecs = new ExecutorCompletionService(null);
# Line 35 | Line 36 | public class ExecutorCompletionServiceTe
36  
37      /**
38       * Creating a new ECS with null queue throw NPE
39 <     */
39 >     */
40      public void testConstructorNPE2() {
41          try {
42              ExecutorService e = Executors.newCachedThreadPool();
# Line 47 | Line 48 | public class ExecutorCompletionServiceTe
48  
49      /**
50       * Submitting a null callable throws NPE
51 <     */
51 >     */
52      public void testSubmitNPE() {
53          ExecutorService e = Executors.newCachedThreadPool();
54          ExecutorCompletionService ecs = new ExecutorCompletionService(e);
# Line 63 | Line 64 | public class ExecutorCompletionServiceTe
64  
65      /**
66       * Submitting a null runnable throws NPE
67 <     */
67 >     */
68      public void testSubmitNPE2() {
69          ExecutorService e = Executors.newCachedThreadPool();
70          ExecutorCompletionService ecs = new ExecutorCompletionService(e);
# Line 79 | Line 80 | public class ExecutorCompletionServiceTe
80  
81      /**
82       * A taken submitted task is completed
83 <     */
83 >     */
84      public void testTake() {
85          ExecutorService e = Executors.newCachedThreadPool();
86          ExecutorCompletionService ecs = new ExecutorCompletionService(e);
# Line 97 | Line 98 | public class ExecutorCompletionServiceTe
98  
99      /**
100       * Take returns the same future object returned by submit
101 <     */
101 >     */
102      public void testTake2() {
103          ExecutorService e = Executors.newCachedThreadPool();
104          ExecutorCompletionService ecs = new ExecutorCompletionService(e);
# Line 115 | Line 116 | public class ExecutorCompletionServiceTe
116  
117      /**
118       * If poll returns non-null, the returned task is completed
119 <     */
119 >     */
120      public void testPoll1() {
121          ExecutorService e = Executors.newCachedThreadPool();
122          ExecutorCompletionService ecs = new ExecutorCompletionService(e);
# Line 140 | Line 141 | public class ExecutorCompletionServiceTe
141  
142      /**
143       * If timed poll returns non-null, the returned task is completed
144 <     */
144 >     */
145      public void testPoll2() {
146          ExecutorService e = Executors.newCachedThreadPool();
147          ExecutorCompletionService ecs = new ExecutorCompletionService(e);
# Line 149 | Line 150 | public class ExecutorCompletionServiceTe
150              Callable c = new StringTask();
151              ecs.submit(c);
152              Future f = ecs.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
153 <            if (f != null)
153 >            if (f != null)
154                  assertTrue(f.isDone());
155          } catch (Exception ex) {
156              unexpectedException();
# Line 157 | Line 158 | public class ExecutorCompletionServiceTe
158              joinPool(e);
159          }
160      }
161 +     /**
162 +      * Submitting to underlying AES that overrides newTaskFor(Callable)
163 +      * returns and eventually runs Future returned by newTaskFor.
164 +      */
165 +     public void testNewTaskForCallable() {
166 +         final AtomicBoolean done = new AtomicBoolean(false);
167 +         class MyCallableFuture<V> extends FutureTask<V> {
168 +             MyCallableFuture(Callable<V> c) { super(c); }
169 +             protected void done() { done.set(true); }
170 +         }
171 +         ExecutorService e = new ThreadPoolExecutor(
172 +                                 1, 1, 30L, TimeUnit.SECONDS,
173 +                                 new ArrayBlockingQueue<Runnable>(1)) {
174 +             protected <T> RunnableFuture<T> newTaskFor(Callable<T> c) {
175 +                 return new MyCallableFuture<T>(c);
176 +             }
177 +         };
178 +         ExecutorCompletionService<String> ecs =
179 +             new ExecutorCompletionService<String>(e);
180 +         try {
181 +             assertNull(ecs.poll());
182 +             Callable<String> c = new StringTask();
183 +             Future f1 = ecs.submit(c);
184 +             assertTrue("submit must return MyCallableFuture",
185 +                        f1 instanceof MyCallableFuture);
186 +             Future f2 = ecs.take();
187 +             assertSame("submit and take must return same objects", f1, f2);
188 +             assertTrue("completed task must have set done", done.get());
189 +         } catch (Exception ex) {
190 +             unexpectedException();
191 +         } finally {
192 +             joinPool(e);
193 +         }
194 +     }
195 +
196 +     /**
197 +      * Submitting to underlying AES that overrides newTaskFor(Runnable,T)
198 +      * returns and eventually runs Future returned by newTaskFor.
199 +      */
200 +     public void testNewTaskForRunnable() {
201 +         final AtomicBoolean done = new AtomicBoolean(false);
202 +         class MyRunnableFuture<V> extends FutureTask<V> {
203 +             MyRunnableFuture(Runnable t, V r) { super(t, r); }
204 +             protected void done() { done.set(true); }
205 +         }
206 +         ExecutorService e = new ThreadPoolExecutor(
207 +                                 1, 1, 30L, TimeUnit.SECONDS,
208 +                                 new ArrayBlockingQueue<Runnable>(1)) {
209 +             protected <T> RunnableFuture<T> newTaskFor(Runnable t, T r) {
210 +                 return new MyRunnableFuture<T>(t, r);
211 +             }
212 +         };
213 +         ExecutorCompletionService<String> ecs =
214 +             new ExecutorCompletionService<String>(e);
215 +         try {
216 +             assertNull(ecs.poll());
217 +             Runnable r = new NoOpRunnable();
218 +             Future f1 = ecs.submit(r, null);
219 +             assertTrue("submit must return MyRunnableFuture",
220 +                        f1 instanceof MyRunnableFuture);
221 +             Future f2 = ecs.take();
222 +             assertSame("submit and take must return same objects", f1, f2);
223 +             assertTrue("completed task must have set done", done.get());
224 +         } catch (Exception ex) {
225 +             unexpectedException();
226 +         } finally {
227 +             joinPool(e);
228 +         }
229 +     }
230 +
231 +
232  
233   }

Diff Legend

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