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.20 by jsr166, Sun Feb 22 04:34:44 2015 UTC vs.
Revision 1.23 by jsr166, Tue May 3 23:06:12 2016 UTC

# Line 10 | Line 10 | import static java.util.concurrent.TimeU
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;
# Line 25 | Line 26 | 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 56 | 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 {
67 <            joinPool(e);
64 >            try {
65 >                ecs.submit(c);
66 >                shouldThrow();
67 >            } catch (NullPointerException success) {}
68          }
69      }
70  
# Line 72 | 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 {
83 <            joinPool(e);
79 >            try {
80 >                ecs.submit(r, Boolean.TRUE);
81 >                shouldThrow();
82 >            } catch (NullPointerException success) {}
83          }
84      }
85  
# Line 88 | 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());
98 –        } finally {
99 –            joinPool(e);
97          }
98      }
99  
# Line 104 | 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);
114 –        } finally {
115 –            joinPool(e);
111          }
112      }
113  
# Line 120 | 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 136 | Line 131 | public class ExecutorCompletionServiceTe
131              }
132              assertTrue(f.isDone());
133              assertSame(TEST_STRING, f.get());
139 –        } finally {
140 –            joinPool(e);
134          }
135      }
136  
# Line 145 | 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());
157 –        } finally {
158 –            joinPool(e);
150          }
151      }
152  
# Line 169 | 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 186 | 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());
189 –        } finally {
190 –            joinPool(e);
181          }
182      }
183  
# Line 201 | 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 218 | 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());
221 –        } finally {
222 –            joinPool(e);
212          }
213      }
214  

Diff Legend

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