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.1 by dl, Tue Dec 23 19:40:24 2003 UTC vs.
Revision 1.5 by dl, Mon Aug 1 19:54:04 2005 UTC

# Line 1 | Line 1
1   /*
2 < * Written by members of JCP JSR-166 Expert Group and released to the
3 < * public domain. Use, modify, and redistribute this code in any way
4 < * without acknowledgement. Other contributors include Andrew Wright,
5 < * Jeffrey Hayes, Pat Fischer, Mike Judd.
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.
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  
# Line 86 | Line 88 | public class ExecutorCompletionServiceTe
88              Callable c = new StringTask();
89              ecs.submit(c);
90              Future f = ecs.take();
91 <            assert(f.isDone());
91 >            assertTrue(f.isDone());
92          } catch (Exception ex) {
93              unexpectedException();
94          } finally {
# Line 126 | Line 128 | public class ExecutorCompletionServiceTe
128              for (;;) {
129                  Future f = ecs.poll();
130                  if (f != null) {
131 <                    assert(f.isDone());
131 >                    assertTrue(f.isDone());
132                      break;
133                  }
134              }
# Line 149 | Line 151 | public class ExecutorCompletionServiceTe
151              ecs.submit(c);
152              Future f = ecs.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
153              if (f != null)
154 <                assert(f.isDone());
154 >                assertTrue(f.isDone());
155          } catch (Exception ex) {
156              unexpectedException();
157          } finally {
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 +             Callable<String> c = new StringTask();
218 +             Future f1 = ecs.submit(c);
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