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.17 by jsr166, Sun May 29 06:54:23 2011 UTC vs.
Revision 1.23 by jsr166, Tue May 3 23:06:12 2016 UTC

# Line 6 | Line 6
6   * Pat Fisher, Mike Judd.
7   */
8  
9 – import junit.framework.*;
10 – import java.util.*;
11 – import java.util.concurrent.*;
9   import static java.util.concurrent.TimeUnit.MILLISECONDS;
10 < import java.util.concurrent.atomic.*;
11 < import java.security.*;
10 >
11 > import java.util.concurrent.ArrayBlockingQueue;
12 > import java.util.concurrent.Callable;
13 > import java.util.concurrent.CompletionService;
14 > import java.util.concurrent.ExecutorCompletionService;
15 > import java.util.concurrent.Executors;
16 > import java.util.concurrent.ExecutorService;
17 > import java.util.concurrent.Future;
18 > import java.util.concurrent.FutureTask;
19 > import java.util.concurrent.RunnableFuture;
20 > import java.util.concurrent.ThreadPoolExecutor;
21 > import java.util.concurrent.TimeUnit;
22 > import java.util.concurrent.atomic.AtomicBoolean;
23 >
24 > import junit.framework.Test;
25 > import junit.framework.TestSuite;
26  
27   public class ExecutorCompletionServiceTest extends JSR166TestCase {
28      public static void main(String[] args) {
29 <        junit.textui.TestRunner.run(suite());
29 >        main(suite(), args);
30      }
31      public static Test suite() {
32          return new TestSuite(ExecutorCompletionServiceTest.class);
# Line 26 | Line 37 | public class ExecutorCompletionServiceTe
37       */
38      public void testConstructorNPE() {
39          try {
40 <            ExecutorCompletionService ecs = new ExecutorCompletionService(null);
40 >            new ExecutorCompletionService(null);
41              shouldThrow();
42          } catch (NullPointerException success) {}
43      }
# Line 37 | Line 48 | public class ExecutorCompletionServiceTe
48      public void testConstructorNPE2() {
49          try {
50              ExecutorService e = Executors.newCachedThreadPool();
51 <            ExecutorCompletionService ecs = new ExecutorCompletionService(e, null);
51 >            new ExecutorCompletionService(e, null);
52              shouldThrow();
53          } catch (NullPointerException success) {}
54      }
# Line 46 | Line 57 | public class ExecutorCompletionServiceTe
57       * Submitting a null callable throws NPE
58       */
59      public void testSubmitNPE() {
60 <        ExecutorService e = Executors.newCachedThreadPool();
61 <        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
62 <        try {
60 >        final ExecutorService e = Executors.newCachedThreadPool();
61 >        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
62 >        try (PoolCleaner cleaner = cleaner(e)) {
63              Callable c = null;
64 <            ecs.submit(c);
65 <            shouldThrow();
66 <        } catch (NullPointerException success) {
67 <        } finally {
57 <            joinPool(e);
64 >            try {
65 >                ecs.submit(c);
66 >                shouldThrow();
67 >            } catch (NullPointerException success) {}
68          }
69      }
70  
# Line 62 | Line 72 | public class ExecutorCompletionServiceTe
72       * Submitting a null runnable throws NPE
73       */
74      public void testSubmitNPE2() {
75 <        ExecutorService e = Executors.newCachedThreadPool();
76 <        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
77 <        try {
75 >        final ExecutorService e = Executors.newCachedThreadPool();
76 >        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
77 >        try (PoolCleaner cleaner = cleaner(e)) {
78              Runnable r = null;
79 <            ecs.submit(r, Boolean.TRUE);
80 <            shouldThrow();
81 <        } catch (NullPointerException success) {
82 <        } finally {
73 <            joinPool(e);
79 >            try {
80 >                ecs.submit(r, Boolean.TRUE);
81 >                shouldThrow();
82 >            } catch (NullPointerException success) {}
83          }
84      }
85  
# Line 78 | Line 87 | public class ExecutorCompletionServiceTe
87       * A taken submitted task is completed
88       */
89      public void testTake() throws InterruptedException {
90 <        ExecutorService e = Executors.newCachedThreadPool();
91 <        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
92 <        try {
90 >        final ExecutorService e = Executors.newCachedThreadPool();
91 >        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
92 >        try (PoolCleaner cleaner = cleaner(e)) {
93              Callable c = new StringTask();
94              ecs.submit(c);
95              Future f = ecs.take();
96              assertTrue(f.isDone());
88 –        } finally {
89 –            joinPool(e);
97          }
98      }
99  
# Line 94 | Line 101 | public class ExecutorCompletionServiceTe
101       * Take returns the same future object returned by submit
102       */
103      public void testTake2() throws InterruptedException {
104 <        ExecutorService e = Executors.newCachedThreadPool();
105 <        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
106 <        try {
104 >        final ExecutorService e = Executors.newCachedThreadPool();
105 >        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
106 >        try (PoolCleaner cleaner = cleaner(e)) {
107              Callable c = new StringTask();
108              Future f1 = ecs.submit(c);
109              Future f2 = ecs.take();
110              assertSame(f1, f2);
104 –        } finally {
105 –            joinPool(e);
111          }
112      }
113  
# Line 110 | Line 115 | public class ExecutorCompletionServiceTe
115       * If poll returns non-null, the returned task is completed
116       */
117      public void testPoll1() throws Exception {
118 <        ExecutorService e = Executors.newCachedThreadPool();
119 <        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
120 <        try {
118 >        final ExecutorService e = Executors.newCachedThreadPool();
119 >        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
120 >        try (PoolCleaner cleaner = cleaner(e)) {
121              assertNull(ecs.poll());
122              Callable c = new StringTask();
123              ecs.submit(c);
# Line 126 | Line 131 | public class ExecutorCompletionServiceTe
131              }
132              assertTrue(f.isDone());
133              assertSame(TEST_STRING, f.get());
129 –        } finally {
130 –            joinPool(e);
134          }
135      }
136  
# Line 135 | Line 138 | public class ExecutorCompletionServiceTe
138       * If timed poll returns non-null, the returned task is completed
139       */
140      public void testPoll2() throws InterruptedException {
141 <        ExecutorService e = Executors.newCachedThreadPool();
142 <        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
143 <        try {
141 >        final ExecutorService e = Executors.newCachedThreadPool();
142 >        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
143 >        try (PoolCleaner cleaner = cleaner(e)) {
144              assertNull(ecs.poll());
145              Callable c = new StringTask();
146              ecs.submit(c);
147              Future f = ecs.poll(SHORT_DELAY_MS, MILLISECONDS);
148              if (f != null)
149                  assertTrue(f.isDone());
147 –        } finally {
148 –            joinPool(e);
150          }
151      }
152  
# Line 159 | Line 160 | public class ExecutorCompletionServiceTe
160              MyCallableFuture(Callable<V> c) { super(c); }
161              protected void done() { done.set(true); }
162          }
163 <        ExecutorService e = new ThreadPoolExecutor(
164 <                                 1, 1, 30L, TimeUnit.SECONDS,
165 <                                 new ArrayBlockingQueue<Runnable>(1)) {
166 <            protected <T> RunnableFuture<T> newTaskFor(Callable<T> c) {
167 <                return new MyCallableFuture<T>(c);
168 <            }};
169 <        ExecutorCompletionService<String> ecs =
170 <            new ExecutorCompletionService<String>(e);
171 <        try {
163 >        final ExecutorService e =
164 >            new ThreadPoolExecutor(1, 1,
165 >                                   30L, TimeUnit.SECONDS,
166 >                                   new ArrayBlockingQueue<Runnable>(1)) {
167 >                protected <T> RunnableFuture<T> newTaskFor(Callable<T> c) {
168 >                    return new MyCallableFuture<T>(c);
169 >                }};
170 >        CompletionService<String> ecs =
171 >            new ExecutorCompletionService<>(e);
172 >        try (PoolCleaner cleaner = cleaner(e)) {
173              assertNull(ecs.poll());
174              Callable<String> c = new StringTask();
175              Future f1 = ecs.submit(c);
# Line 176 | Line 178 | public class ExecutorCompletionServiceTe
178              Future f2 = ecs.take();
179              assertSame("submit and take must return same objects", f1, f2);
180              assertTrue("completed task must have set done", done.get());
179 –        } finally {
180 –            joinPool(e);
181          }
182      }
183  
# Line 191 | Line 191 | public class ExecutorCompletionServiceTe
191              MyRunnableFuture(Runnable t, V r) { super(t, r); }
192              protected void done() { done.set(true); }
193          }
194 <        ExecutorService e = new ThreadPoolExecutor(
195 <                                 1, 1, 30L, TimeUnit.SECONDS,
196 <                                 new ArrayBlockingQueue<Runnable>(1)) {
197 <            protected <T> RunnableFuture<T> newTaskFor(Runnable t, T r) {
198 <                return new MyRunnableFuture<T>(t, r);
199 <            }};
200 <        ExecutorCompletionService<String> ecs =
201 <            new ExecutorCompletionService<String>(e);
202 <        try {
194 >        final ExecutorService e =
195 >            new ThreadPoolExecutor(1, 1,
196 >                                   30L, TimeUnit.SECONDS,
197 >                                   new ArrayBlockingQueue<Runnable>(1)) {
198 >                protected <T> RunnableFuture<T> newTaskFor(Runnable t, T r) {
199 >                    return new MyRunnableFuture<T>(t, r);
200 >                }};
201 >        final CompletionService<String> ecs =
202 >            new ExecutorCompletionService<>(e);
203 >        try (PoolCleaner cleaner = cleaner(e)) {
204              assertNull(ecs.poll());
205              Runnable r = new NoOpRunnable();
206              Future f1 = ecs.submit(r, null);
# Line 208 | Line 209 | public class ExecutorCompletionServiceTe
209              Future f2 = ecs.take();
210              assertSame("submit and take must return same objects", f1, f2);
211              assertTrue("completed task must have set done", done.get());
211 –        } finally {
212 –            joinPool(e);
212          }
213      }
214  

Diff Legend

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