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.21 by jsr166, Sat Apr 25 04:55:30 2015 UTC vs.
Revision 1.22 by jsr166, Sun Oct 4 18:28:51 2015 UTC

# Line 56 | Line 56 | public class ExecutorCompletionServiceTe
56       * Submitting a null callable throws NPE
57       */
58      public void testSubmitNPE() {
59 <        ExecutorService e = Executors.newCachedThreadPool();
60 <        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
61 <        try {
59 >        final ExecutorService e = Executors.newCachedThreadPool();
60 >        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
61 >        try (PoolCleaner cleaner = cleaner(e)) {
62              Callable c = null;
63 <            ecs.submit(c);
64 <            shouldThrow();
65 <        } catch (NullPointerException success) {
66 <        } finally {
67 <            joinPool(e);
63 >            try {
64 >                ecs.submit(c);
65 >                shouldThrow();
66 >            } catch (NullPointerException success) {}
67          }
68      }
69  
# Line 72 | Line 71 | public class ExecutorCompletionServiceTe
71       * Submitting a null runnable throws NPE
72       */
73      public void testSubmitNPE2() {
74 <        ExecutorService e = Executors.newCachedThreadPool();
75 <        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
76 <        try {
74 >        final ExecutorService e = Executors.newCachedThreadPool();
75 >        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
76 >        try (PoolCleaner cleaner = cleaner(e)) {
77              Runnable r = null;
78 <            ecs.submit(r, Boolean.TRUE);
79 <            shouldThrow();
80 <        } catch (NullPointerException success) {
81 <        } finally {
83 <            joinPool(e);
78 >            try {
79 >                ecs.submit(r, Boolean.TRUE);
80 >                shouldThrow();
81 >            } catch (NullPointerException success) {}
82          }
83      }
84  
# Line 88 | Line 86 | public class ExecutorCompletionServiceTe
86       * A taken submitted task is completed
87       */
88      public void testTake() throws InterruptedException {
89 <        ExecutorService e = Executors.newCachedThreadPool();
90 <        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
91 <        try {
89 >        final ExecutorService e = Executors.newCachedThreadPool();
90 >        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
91 >        try (PoolCleaner cleaner = cleaner(e)) {
92              Callable c = new StringTask();
93              ecs.submit(c);
94              Future f = ecs.take();
95              assertTrue(f.isDone());
98 –        } finally {
99 –            joinPool(e);
96          }
97      }
98  
# Line 104 | Line 100 | public class ExecutorCompletionServiceTe
100       * Take returns the same future object returned by submit
101       */
102      public void testTake2() throws InterruptedException {
103 <        ExecutorService e = Executors.newCachedThreadPool();
104 <        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
105 <        try {
103 >        final ExecutorService e = Executors.newCachedThreadPool();
104 >        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
105 >        try (PoolCleaner cleaner = cleaner(e)) {
106              Callable c = new StringTask();
107              Future f1 = ecs.submit(c);
108              Future f2 = ecs.take();
109              assertSame(f1, f2);
114 –        } finally {
115 –            joinPool(e);
110          }
111      }
112  
# Line 120 | Line 114 | public class ExecutorCompletionServiceTe
114       * If poll returns non-null, the returned task is completed
115       */
116      public void testPoll1() throws Exception {
117 <        ExecutorService e = Executors.newCachedThreadPool();
118 <        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
119 <        try {
117 >        final ExecutorService e = Executors.newCachedThreadPool();
118 >        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
119 >        try (PoolCleaner cleaner = cleaner(e)) {
120              assertNull(ecs.poll());
121              Callable c = new StringTask();
122              ecs.submit(c);
# Line 136 | Line 130 | public class ExecutorCompletionServiceTe
130              }
131              assertTrue(f.isDone());
132              assertSame(TEST_STRING, f.get());
139 –        } finally {
140 –            joinPool(e);
133          }
134      }
135  
# Line 145 | Line 137 | public class ExecutorCompletionServiceTe
137       * If timed poll returns non-null, the returned task is completed
138       */
139      public void testPoll2() throws InterruptedException {
140 <        ExecutorService e = Executors.newCachedThreadPool();
141 <        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
142 <        try {
140 >        final ExecutorService e = Executors.newCachedThreadPool();
141 >        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
142 >        try (PoolCleaner cleaner = cleaner(e)) {
143              assertNull(ecs.poll());
144              Callable c = new StringTask();
145              ecs.submit(c);
146              Future f = ecs.poll(SHORT_DELAY_MS, MILLISECONDS);
147              if (f != null)
148                  assertTrue(f.isDone());
157 –        } finally {
158 –            joinPool(e);
149          }
150      }
151  
# Line 169 | Line 159 | public class ExecutorCompletionServiceTe
159              MyCallableFuture(Callable<V> c) { super(c); }
160              protected void done() { done.set(true); }
161          }
162 <        ExecutorService e = new ThreadPoolExecutor(
163 <                                 1, 1, 30L, TimeUnit.SECONDS,
164 <                                 new ArrayBlockingQueue<Runnable>(1)) {
165 <            protected <T> RunnableFuture<T> newTaskFor(Callable<T> c) {
166 <                return new MyCallableFuture<T>(c);
167 <            }};
162 >        final ExecutorService e =
163 >            new ThreadPoolExecutor(1, 1,
164 >                                   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 {
171 >        try (PoolCleaner cleaner = cleaner(e)) {
172              assertNull(ecs.poll());
173              Callable<String> c = new StringTask();
174              Future f1 = ecs.submit(c);
# Line 186 | Line 177 | public class ExecutorCompletionServiceTe
177              Future f2 = ecs.take();
178              assertSame("submit and take must return same objects", f1, f2);
179              assertTrue("completed task must have set done", done.get());
189 –        } finally {
190 –            joinPool(e);
180          }
181      }
182  
# Line 201 | Line 190 | public class ExecutorCompletionServiceTe
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 <        ExecutorCompletionService<String> ecs =
193 >        final ExecutorService e =
194 >            new ThreadPoolExecutor(1, 1,
195 >                                   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 >        final ExecutorCompletionService<String> ecs =
201              new ExecutorCompletionService<String>(e);
202 <        try {
202 >        try (PoolCleaner cleaner = cleaner(e)) {
203              assertNull(ecs.poll());
204              Runnable r = new NoOpRunnable();
205              Future f1 = ecs.submit(r, null);
# Line 218 | Line 208 | public class ExecutorCompletionServiceTe
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());
221 –        } finally {
222 –            joinPool(e);
211          }
212      }
213  

Diff Legend

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