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.10 by jsr166, Sat Nov 21 06:31:05 2009 UTC vs.
Revision 1.15 by jsr166, Fri May 27 19:42:42 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.*;
# Line 17 | Line 16 | 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);
23      }
24  
26 –
25      /**
26       * Creating a new ECS with null Executor throw NPE
27       */
# Line 119 | Line 117 | public class ExecutorCompletionServiceTe
117              assertNull(ecs.poll());
118              Callable c = new StringTask();
119              ecs.submit(c);
120 <            Thread.sleep(SHORT_DELAY_MS);
120 >            delay(SHORT_DELAY_MS);
121              for (;;) {
122                  Future f = ecs.poll();
123                  if (f != null) {
# Line 149 | Line 147 | public class ExecutorCompletionServiceTe
147              joinPool(e);
148          }
149      }
150 <     /**
151 <      * Submitting to underlying AES that overrides newTaskFor(Callable)
152 <      * returns and eventually runs Future returned by newTaskFor.
153 <      */
154 <     public void testNewTaskForCallable() throws InterruptedException {
155 <         final AtomicBoolean done = new AtomicBoolean(false);
156 <         class MyCallableFuture<V> extends FutureTask<V> {
157 <             MyCallableFuture(Callable<V> c) { super(c); }
158 <             protected void done() { done.set(true); }
159 <         }
160 <         ExecutorService e = new ThreadPoolExecutor(
150 >
151 >    /**
152 >     * Submitting to underlying AES that overrides newTaskFor(Callable)
153 >     * returns and eventually runs Future returned by newTaskFor.
154 >     */
155 >    public void testNewTaskForCallable() throws InterruptedException {
156 >        final AtomicBoolean done = new AtomicBoolean(false);
157 >        class MyCallableFuture<V> extends FutureTask<V> {
158 >            MyCallableFuture(Callable<V> c) { super(c); }
159 >            protected void done() { done.set(true); }
160 >        }
161 >        ExecutorService e = new ThreadPoolExecutor(
162                                   1, 1, 30L, TimeUnit.SECONDS,
163                                   new ArrayBlockingQueue<Runnable>(1)) {
164 <             protected <T> RunnableFuture<T> newTaskFor(Callable<T> c) {
165 <                 return new MyCallableFuture<T>(c);
166 <             }
167 <         };
168 <         ExecutorCompletionService<String> ecs =
169 <             new ExecutorCompletionService<String>(e);
170 <         try {
171 <             assertNull(ecs.poll());
172 <             Callable<String> c = new StringTask();
173 <             Future f1 = ecs.submit(c);
174 <             assertTrue("submit must return MyCallableFuture",
175 <                        f1 instanceof MyCallableFuture);
176 <             Future f2 = ecs.take();
177 <             assertSame("submit and take must return same objects", f1, f2);
178 <             assertTrue("completed task must have set done", done.get());
179 <         } finally {
180 <             joinPool(e);
181 <         }
182 <     }
183 <
184 <     /**
185 <      * Submitting to underlying AES that overrides newTaskFor(Runnable,T)
186 <      * returns and eventually runs Future returned by newTaskFor.
187 <      */
188 <     public void testNewTaskForRunnable() throws InterruptedException {
189 <         final AtomicBoolean done = new AtomicBoolean(false);
190 <         class MyRunnableFuture<V> extends FutureTask<V> {
191 <             MyRunnableFuture(Runnable t, V r) { super(t, r); }
192 <             protected void done() { done.set(true); }
193 <         }
195 <         ExecutorService e = new ThreadPoolExecutor(
164 >            protected <T> RunnableFuture<T> newTaskFor(Callable<T> c) {
165 >                return new MyCallableFuture<T>(c);
166 >            }};
167 >        ExecutorCompletionService<String> ecs =
168 >            new ExecutorCompletionService<String>(e);
169 >        try {
170 >            assertNull(ecs.poll());
171 >            Callable<String> c = new StringTask();
172 >            Future f1 = ecs.submit(c);
173 >            assertTrue("submit must return MyCallableFuture",
174 >                       f1 instanceof MyCallableFuture);
175 >            Future f2 = ecs.take();
176 >            assertSame("submit and take must return same objects", f1, f2);
177 >            assertTrue("completed task must have set done", done.get());
178 >        } finally {
179 >            joinPool(e);
180 >        }
181 >    }
182 >
183 >    /**
184 >     * Submitting to underlying AES that overrides newTaskFor(Runnable,T)
185 >     * returns and eventually runs Future returned by newTaskFor.
186 >     */
187 >    public void testNewTaskForRunnable() throws InterruptedException {
188 >        final AtomicBoolean done = new AtomicBoolean(false);
189 >        class MyRunnableFuture<V> extends FutureTask<V> {
190 >            MyRunnableFuture(Runnable t, V r) { super(t, r); }
191 >            protected void done() { done.set(true); }
192 >        }
193 >        ExecutorService e = new ThreadPoolExecutor(
194                                   1, 1, 30L, TimeUnit.SECONDS,
195                                   new ArrayBlockingQueue<Runnable>(1)) {
196 <             protected <T> RunnableFuture<T> newTaskFor(Runnable t, T r) {
197 <                 return new MyRunnableFuture<T>(t, r);
198 <             }
199 <         };
200 <         ExecutorCompletionService<String> ecs =
201 <             new ExecutorCompletionService<String>(e);
202 <         try {
203 <             assertNull(ecs.poll());
204 <             Runnable r = new NoOpRunnable();
205 <             Future f1 = ecs.submit(r, null);
206 <             assertTrue("submit must return MyRunnableFuture",
207 <                        f1 instanceof MyRunnableFuture);
208 <             Future f2 = ecs.take();
209 <             assertSame("submit and take must return same objects", f1, f2);
210 <             assertTrue("completed task must have set done", done.get());
211 <         } finally {
212 <             joinPool(e);
213 <         }
216 <     }
196 >            protected <T> RunnableFuture<T> newTaskFor(Runnable t, T r) {
197 >                return new MyRunnableFuture<T>(t, r);
198 >            }};
199 >        ExecutorCompletionService<String> ecs =
200 >            new ExecutorCompletionService<String>(e);
201 >        try {
202 >            assertNull(ecs.poll());
203 >            Runnable r = new NoOpRunnable();
204 >            Future f1 = ecs.submit(r, null);
205 >            assertTrue("submit must return MyRunnableFuture",
206 >                       f1 instanceof MyRunnableFuture);
207 >            Future f2 = ecs.take();
208 >            assertSame("submit and take must return same objects", f1, f2);
209 >            assertTrue("completed task must have set done", done.get());
210 >        } finally {
211 >            joinPool(e);
212 >        }
213 >    }
214  
215   }

Diff Legend

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