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.11 by jsr166, Wed Aug 25 00:07:03 2010 UTC vs.
Revision 1.18 by jsr166, Tue May 31 16:16:23 2011 UTC

# Line 1 | Line 1
1   /*
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
4 > * http://creativecommons.org/publicdomain/zero/1.0/
5   * Other contributors include Andrew Wright, Jeffrey Hayes,
6   * Pat Fisher, Mike Judd.
7   */
8  
9 –
9   import junit.framework.*;
10   import java.util.*;
11 < import java.util.concurrent.*;
11 > import java.util.concurrent.ArrayBlockingQueue;
12 > import java.util.concurrent.Callable;
13 > import java.util.concurrent.ExecutorCompletionService;
14 > import java.util.concurrent.ExecutorService;
15 > import java.util.concurrent.Executors;
16 > import java.util.concurrent.Future;
17 > import java.util.concurrent.FutureTask;
18 > import java.util.concurrent.RunnableFuture;
19 > import java.util.concurrent.ThreadPoolExecutor;
20 > import java.util.concurrent.TimeUnit;
21   import static java.util.concurrent.TimeUnit.MILLISECONDS;
22 < import java.util.concurrent.atomic.*;
15 < import java.math.BigInteger;
22 > import java.util.concurrent.atomic.AtomicBoolean;
23   import java.security.*;
24  
25   public class ExecutorCompletionServiceTest extends JSR166TestCase {
# Line 23 | Line 30 | public class ExecutorCompletionServiceTe
30          return new TestSuite(ExecutorCompletionServiceTest.class);
31      }
32  
26 –
33      /**
34       * Creating a new ECS with null Executor throw NPE
35       */
# Line 112 | Line 118 | public class ExecutorCompletionServiceTe
118      /**
119       * If poll returns non-null, the returned task is completed
120       */
121 <    public void testPoll1() throws InterruptedException {
121 >    public void testPoll1() throws Exception {
122          ExecutorService e = Executors.newCachedThreadPool();
123          ExecutorCompletionService ecs = new ExecutorCompletionService(e);
124          try {
125              assertNull(ecs.poll());
126              Callable c = new StringTask();
127              ecs.submit(c);
128 <            Thread.sleep(SHORT_DELAY_MS);
129 <            for (;;) {
130 <                Future f = ecs.poll();
131 <                if (f != null) {
132 <                    assertTrue(f.isDone());
133 <                    break;
134 <                }
128 >
129 >            long startTime = System.nanoTime();
130 >            Future f;
131 >            while ((f = ecs.poll()) == null) {
132 >                if (millisElapsedSince(startTime) > LONG_DELAY_MS)
133 >                    fail("timed out");
134 >                Thread.yield();
135              }
136 +            assertTrue(f.isDone());
137 +            assertSame(TEST_STRING, f.get());
138          } finally {
139              joinPool(e);
140          }
# Line 149 | Line 157 | public class ExecutorCompletionServiceTe
157              joinPool(e);
158          }
159      }
160 <     /**
161 <      * Submitting to underlying AES that overrides newTaskFor(Callable)
162 <      * returns and eventually runs Future returned by newTaskFor.
163 <      */
164 <     public void testNewTaskForCallable() throws InterruptedException {
165 <         final AtomicBoolean done = new AtomicBoolean(false);
166 <         class MyCallableFuture<V> extends FutureTask<V> {
167 <             MyCallableFuture(Callable<V> c) { super(c); }
168 <             protected void done() { done.set(true); }
169 <         }
170 <         ExecutorService e = new ThreadPoolExecutor(
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() throws InterruptedException {
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 <         } finally {
190 <             joinPool(e);
191 <         }
192 <     }
193 <
194 <     /**
195 <      * Submitting to underlying AES that overrides newTaskFor(Runnable,T)
196 <      * returns and eventually runs Future returned by newTaskFor.
197 <      */
198 <     public void testNewTaskForRunnable() throws InterruptedException {
199 <         final AtomicBoolean done = new AtomicBoolean(false);
200 <         class MyRunnableFuture<V> extends FutureTask<V> {
201 <             MyRunnableFuture(Runnable t, V r) { super(t, r); }
202 <             protected void done() { done.set(true); }
203 <         }
195 <         ExecutorService e = new ThreadPoolExecutor(
174 >            protected <T> RunnableFuture<T> newTaskFor(Callable<T> c) {
175 >                return new MyCallableFuture<T>(c);
176 >            }};
177 >        ExecutorCompletionService<String> ecs =
178 >            new ExecutorCompletionService<String>(e);
179 >        try {
180 >            assertNull(ecs.poll());
181 >            Callable<String> c = new StringTask();
182 >            Future f1 = ecs.submit(c);
183 >            assertTrue("submit must return MyCallableFuture",
184 >                       f1 instanceof MyCallableFuture);
185 >            Future f2 = ecs.take();
186 >            assertSame("submit and take must return same objects", f1, f2);
187 >            assertTrue("completed task must have set done", done.get());
188 >        } finally {
189 >            joinPool(e);
190 >        }
191 >    }
192 >
193 >    /**
194 >     * Submitting to underlying AES that overrides newTaskFor(Runnable,T)
195 >     * returns and eventually runs Future returned by newTaskFor.
196 >     */
197 >    public void testNewTaskForRunnable() throws InterruptedException {
198 >        final AtomicBoolean done = new AtomicBoolean(false);
199 >        class MyRunnableFuture<V> extends FutureTask<V> {
200 >            MyRunnableFuture(Runnable t, V r) { super(t, r); }
201 >            protected void done() { done.set(true); }
202 >        }
203 >        ExecutorService e = new ThreadPoolExecutor(
204                                   1, 1, 30L, TimeUnit.SECONDS,
205                                   new ArrayBlockingQueue<Runnable>(1)) {
206 <             protected <T> RunnableFuture<T> newTaskFor(Runnable t, T r) {
207 <                 return new MyRunnableFuture<T>(t, r);
208 <             }
209 <         };
210 <         ExecutorCompletionService<String> ecs =
211 <             new ExecutorCompletionService<String>(e);
212 <         try {
213 <             assertNull(ecs.poll());
214 <             Runnable r = new NoOpRunnable();
215 <             Future f1 = ecs.submit(r, null);
216 <             assertTrue("submit must return MyRunnableFuture",
217 <                        f1 instanceof MyRunnableFuture);
218 <             Future f2 = ecs.take();
219 <             assertSame("submit and take must return same objects", f1, f2);
220 <             assertTrue("completed task must have set done", done.get());
221 <         } finally {
222 <             joinPool(e);
223 <         }
216 <     }
206 >            protected <T> RunnableFuture<T> newTaskFor(Runnable t, T r) {
207 >                return new MyRunnableFuture<T>(t, r);
208 >            }};
209 >        ExecutorCompletionService<String> ecs =
210 >            new ExecutorCompletionService<String>(e);
211 >        try {
212 >            assertNull(ecs.poll());
213 >            Runnable r = new NoOpRunnable();
214 >            Future f1 = ecs.submit(r, null);
215 >            assertTrue("submit must return MyRunnableFuture",
216 >                       f1 instanceof MyRunnableFuture);
217 >            Future f2 = ecs.take();
218 >            assertSame("submit and take must return same objects", f1, f2);
219 >            assertTrue("completed task must have set done", done.get());
220 >        } finally {
221 >            joinPool(e);
222 >        }
223 >    }
224  
225   }

Diff Legend

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