ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ExecutorsTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ExecutorsTest.java (file contents):
Revision 1.45 by jsr166, Sat Apr 25 04:55:30 2015 UTC vs.
Revision 1.46 by jsr166, Sun Oct 4 16:14:48 2015 UTC

# Line 38 | Line 38 | public class ExecutorsTest extends JSR16
38       * A newCachedThreadPool can execute runnables
39       */
40      public void testNewCachedThreadPool1() {
41 <        ExecutorService e = Executors.newCachedThreadPool();
42 <        e.execute(new NoOpRunnable());
43 <        e.execute(new NoOpRunnable());
44 <        e.execute(new NoOpRunnable());
45 <        joinPool(e);
41 >        final ExecutorService e = Executors.newCachedThreadPool();
42 >        try (PoolCleaner cleaner = cleaner(e)) {
43 >            e.execute(new NoOpRunnable());
44 >            e.execute(new NoOpRunnable());
45 >            e.execute(new NoOpRunnable());
46 >        }
47      }
48  
49      /**
50       * A newCachedThreadPool with given ThreadFactory can execute runnables
51       */
52      public void testNewCachedThreadPool2() {
53 <        ExecutorService e = Executors.newCachedThreadPool(new SimpleThreadFactory());
54 <        e.execute(new NoOpRunnable());
55 <        e.execute(new NoOpRunnable());
56 <        e.execute(new NoOpRunnable());
57 <        joinPool(e);
53 >        final ExecutorService e = Executors.newCachedThreadPool(new SimpleThreadFactory());
54 >        try (PoolCleaner cleaner = cleaner(e)) {
55 >            e.execute(new NoOpRunnable());
56 >            e.execute(new NoOpRunnable());
57 >            e.execute(new NoOpRunnable());
58 >        }
59      }
60  
61      /**
# Line 70 | Line 72 | public class ExecutorsTest extends JSR16
72       * A new SingleThreadExecutor can execute runnables
73       */
74      public void testNewSingleThreadExecutor1() {
75 <        ExecutorService e = Executors.newSingleThreadExecutor();
76 <        e.execute(new NoOpRunnable());
77 <        e.execute(new NoOpRunnable());
78 <        e.execute(new NoOpRunnable());
79 <        joinPool(e);
75 >        final ExecutorService e = Executors.newSingleThreadExecutor();
76 >        try (PoolCleaner cleaner = cleaner(e)) {
77 >            e.execute(new NoOpRunnable());
78 >            e.execute(new NoOpRunnable());
79 >            e.execute(new NoOpRunnable());
80 >        }
81      }
82  
83      /**
84       * A new SingleThreadExecutor with given ThreadFactory can execute runnables
85       */
86      public void testNewSingleThreadExecutor2() {
87 <        ExecutorService e = Executors.newSingleThreadExecutor(new SimpleThreadFactory());
88 <        e.execute(new NoOpRunnable());
89 <        e.execute(new NoOpRunnable());
90 <        e.execute(new NoOpRunnable());
91 <        joinPool(e);
87 >        final ExecutorService e = Executors.newSingleThreadExecutor(new SimpleThreadFactory());
88 >        try (PoolCleaner cleaner = cleaner(e)) {
89 >            e.execute(new NoOpRunnable());
90 >            e.execute(new NoOpRunnable());
91 >            e.execute(new NoOpRunnable());
92 >        }
93      }
94  
95      /**
# Line 102 | Line 106 | public class ExecutorsTest extends JSR16
106       * A new SingleThreadExecutor cannot be casted to concrete implementation
107       */
108      public void testCastNewSingleThreadExecutor() {
109 <        ExecutorService e = Executors.newSingleThreadExecutor();
110 <        try {
111 <            ThreadPoolExecutor tpe = (ThreadPoolExecutor)e;
112 <            shouldThrow();
113 <        } catch (ClassCastException success) {
114 <        } finally {
111 <            joinPool(e);
109 >        final ExecutorService e = Executors.newSingleThreadExecutor();
110 >        try (PoolCleaner cleaner = cleaner(e)) {
111 >            try {
112 >                ThreadPoolExecutor tpe = (ThreadPoolExecutor)e;
113 >                shouldThrow();
114 >            } catch (ClassCastException success) {}
115          }
116      }
117  
# Line 116 | Line 119 | public class ExecutorsTest extends JSR16
119       * A new newFixedThreadPool can execute runnables
120       */
121      public void testNewFixedThreadPool1() {
122 <        ExecutorService e = Executors.newFixedThreadPool(2);
123 <        e.execute(new NoOpRunnable());
124 <        e.execute(new NoOpRunnable());
125 <        e.execute(new NoOpRunnable());
126 <        joinPool(e);
122 >        final ExecutorService e = Executors.newFixedThreadPool(2);
123 >        try (PoolCleaner cleaner = cleaner(e)) {
124 >            e.execute(new NoOpRunnable());
125 >            e.execute(new NoOpRunnable());
126 >            e.execute(new NoOpRunnable());
127 >        }
128      }
129  
130      /**
131       * A new newFixedThreadPool with given ThreadFactory can execute runnables
132       */
133      public void testNewFixedThreadPool2() {
134 <        ExecutorService e = Executors.newFixedThreadPool(2, new SimpleThreadFactory());
135 <        e.execute(new NoOpRunnable());
136 <        e.execute(new NoOpRunnable());
137 <        e.execute(new NoOpRunnable());
138 <        joinPool(e);
134 >        final ExecutorService e = Executors.newFixedThreadPool(2, new SimpleThreadFactory());
135 >        try (PoolCleaner cleaner = cleaner(e)) {
136 >            e.execute(new NoOpRunnable());
137 >            e.execute(new NoOpRunnable());
138 >            e.execute(new NoOpRunnable());
139 >        }
140      }
141  
142      /**
# Line 158 | Line 163 | public class ExecutorsTest extends JSR16
163       * An unconfigurable newFixedThreadPool can execute runnables
164       */
165      public void testUnconfigurableExecutorService() {
166 <        ExecutorService e = Executors.unconfigurableExecutorService(Executors.newFixedThreadPool(2));
167 <        e.execute(new NoOpRunnable());
168 <        e.execute(new NoOpRunnable());
169 <        e.execute(new NoOpRunnable());
170 <        joinPool(e);
166 >        final ExecutorService e = Executors.unconfigurableExecutorService(Executors.newFixedThreadPool(2));
167 >        try (PoolCleaner cleaner = cleaner(e)) {
168 >            e.execute(new NoOpRunnable());
169 >            e.execute(new NoOpRunnable());
170 >            e.execute(new NoOpRunnable());
171 >        }
172      }
173  
174      /**
# Line 189 | Line 195 | public class ExecutorsTest extends JSR16
195       * a newSingleThreadScheduledExecutor successfully runs delayed task
196       */
197      public void testNewSingleThreadScheduledExecutor() throws Exception {
198 <        ScheduledExecutorService p = Executors.newSingleThreadScheduledExecutor();
199 <        try {
198 >        final ScheduledExecutorService p = Executors.newSingleThreadScheduledExecutor();
199 >        try (PoolCleaner cleaner = cleaner(p)) {
200              final CountDownLatch proceed = new CountDownLatch(1);
201              final Runnable task = new CheckedRunnable() {
202                  public void realRun() {
# Line 206 | Line 212 | public class ExecutorsTest extends JSR16
212              assertTrue(f.isDone());
213              assertFalse(f.isCancelled());
214              assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
209 –        } finally {
210 –            joinPool(p);
215          }
216      }
217  
# Line 215 | Line 219 | public class ExecutorsTest extends JSR16
219       * a newScheduledThreadPool successfully runs delayed task
220       */
221      public void testNewScheduledThreadPool() throws Exception {
222 <        ScheduledExecutorService p = Executors.newScheduledThreadPool(2);
223 <        try {
222 >        final ScheduledExecutorService p = Executors.newScheduledThreadPool(2);
223 >        try (PoolCleaner cleaner = cleaner(p)) {
224              final CountDownLatch proceed = new CountDownLatch(1);
225              final Runnable task = new CheckedRunnable() {
226                  public void realRun() {
# Line 232 | Line 236 | public class ExecutorsTest extends JSR16
236              assertTrue(f.isDone());
237              assertFalse(f.isCancelled());
238              assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
235 –        } finally {
236 –            joinPool(p);
239          }
240      }
241  
# Line 241 | Line 243 | public class ExecutorsTest extends JSR16
243       * an unconfigurable newScheduledThreadPool successfully runs delayed task
244       */
245      public void testUnconfigurableScheduledExecutorService() throws Exception {
246 <        ScheduledExecutorService p =
246 >        final ScheduledExecutorService p =
247              Executors.unconfigurableScheduledExecutorService
248              (Executors.newScheduledThreadPool(2));
249 <        try {
249 >        try (PoolCleaner cleaner = cleaner(p)) {
250              final CountDownLatch proceed = new CountDownLatch(1);
251              final Runnable task = new CheckedRunnable() {
252                  public void realRun() {
# Line 260 | Line 262 | public class ExecutorsTest extends JSR16
262              assertTrue(f.isDone());
263              assertFalse(f.isCancelled());
264              assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
263 –        } finally {
264 –            joinPool(p);
265          }
266      }
267  
# Line 322 | Line 322 | public class ExecutorsTest extends JSR16
322                  done.countDown();
323              }};
324          ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
325 <
326 <        e.execute(r);
327 <        await(done);
328 <
329 <        try {
330 <            e.shutdown();
331 <        } catch (SecurityException ok) {
325 >        try (PoolCleaner cleaner = cleaner(e)) {
326 >            e.execute(r);
327 >            await(done);
328          }
333 –
334 –        joinPool(e);
329      }
330  
331      /**
# Line 364 | Line 358 | public class ExecutorsTest extends JSR16
358                          done.countDown();
359                      }};
360                  ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
361 <                e.execute(r);
362 <                await(done);
363 <                e.shutdown();
364 <                joinPool(e);
361 >                try (PoolCleaner cleaner = cleaner(e)) {
362 >                    e.execute(r);
363 >                    await(done);
364 >                }
365              }};
366  
367          runWithPermissions(r,

Diff Legend

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