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.41 by jsr166, Sun May 29 06:54:23 2011 UTC vs.
Revision 1.47 by jsr166, Wed Jan 4 06:09:58 2017 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.security.*;
10 >
11 > import java.security.AccessControlContext;
12 > import java.security.AccessControlException;
13 > import java.security.AccessController;
14 > import java.security.PrivilegedAction;
15 > import java.security.PrivilegedExceptionAction;
16 > import java.util.ArrayList;
17 > import java.util.List;
18 > import java.util.concurrent.Callable;
19 > import java.util.concurrent.CountDownLatch;
20 > import java.util.concurrent.Executors;
21 > import java.util.concurrent.ExecutorService;
22 > import java.util.concurrent.Future;
23 > import java.util.concurrent.ScheduledExecutorService;
24 > import java.util.concurrent.ThreadPoolExecutor;
25 >
26 > import junit.framework.Test;
27 > import junit.framework.TestSuite;
28  
29   public class ExecutorsTest extends JSR166TestCase {
30      public static void main(String[] args) {
31 <        junit.textui.TestRunner.run(suite());
31 >        main(suite(), args);
32      }
33      public static Test suite() {
34          return new TestSuite(ExecutorsTest.class);
# Line 24 | 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 56 | 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 88 | 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 {
97 <            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 102 | 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 143 | Line 162 | public class ExecutorsTest extends JSR16
162      /**
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);
165 >    public void testUnconfigurableExecutorService() {
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      /**
175       * unconfigurableExecutorService(null) throws NPE
176       */
177 <    public void testunconfigurableExecutorServiceNPE() {
177 >    public void testUnconfigurableExecutorServiceNPE() {
178          try {
179              ExecutorService e = Executors.unconfigurableExecutorService(null);
180              shouldThrow();
# Line 164 | Line 184 | public class ExecutorsTest extends JSR16
184      /**
185       * unconfigurableScheduledExecutorService(null) throws NPE
186       */
187 <    public void testunconfigurableScheduledExecutorServiceNPE() {
187 >    public void testUnconfigurableScheduledExecutorServiceNPE() {
188          try {
189              ExecutorService e = Executors.unconfigurableScheduledExecutorService(null);
190              shouldThrow();
# Line 175 | 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 {
200 <            final CountDownLatch done = new CountDownLatch(1);
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() {
203 <                    done.countDown();
203 >                    await(proceed);
204                  }};
205 +            long startTime = System.nanoTime();
206              Future f = p.schedule(Executors.callable(task, Boolean.TRUE),
207 <                                  SHORT_DELAY_MS, MILLISECONDS);
207 >                                  timeoutMillis(), MILLISECONDS);
208              assertFalse(f.isDone());
209 <            assertTrue(done.await(MEDIUM_DELAY_MS, MILLISECONDS));
210 <            assertSame(Boolean.TRUE, f.get(SMALL_DELAY_MS, MILLISECONDS));
209 >            proceed.countDown();
210 >            assertSame(Boolean.TRUE, f.get(LONG_DELAY_MS, MILLISECONDS));
211              assertSame(Boolean.TRUE, f.get());
212              assertTrue(f.isDone());
213 <        } finally {
214 <            joinPool(p);
213 >            assertFalse(f.isCancelled());
214 >            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
215          }
216      }
217  
218      /**
219       * a newScheduledThreadPool successfully runs delayed task
220       */
221 <    public void testnewScheduledThreadPool() throws Exception {
222 <        ScheduledExecutorService p = Executors.newScheduledThreadPool(2);
223 <        try {
224 <            final CountDownLatch done = new CountDownLatch(1);
221 >    public void testNewScheduledThreadPool() throws Exception {
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() {
227 <                    done.countDown();
227 >                    await(proceed);
228                  }};
229 +            long startTime = System.nanoTime();
230              Future f = p.schedule(Executors.callable(task, Boolean.TRUE),
231 <                                  SHORT_DELAY_MS, MILLISECONDS);
231 >                                  timeoutMillis(), MILLISECONDS);
232              assertFalse(f.isDone());
233 <            assertTrue(done.await(MEDIUM_DELAY_MS, MILLISECONDS));
234 <            assertSame(Boolean.TRUE, f.get(SMALL_DELAY_MS, MILLISECONDS));
233 >            proceed.countDown();
234 >            assertSame(Boolean.TRUE, f.get(LONG_DELAY_MS, MILLISECONDS));
235              assertSame(Boolean.TRUE, f.get());
236              assertTrue(f.isDone());
237 <        } finally {
238 <            joinPool(p);
237 >            assertFalse(f.isCancelled());
238 >            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
239          }
240      }
241  
242      /**
243       * an unconfigurable newScheduledThreadPool successfully runs delayed task
244       */
245 <    public void testunconfigurableScheduledExecutorService() throws Exception {
246 <        ScheduledExecutorService p =
245 >    public void testUnconfigurableScheduledExecutorService() throws Exception {
246 >        final ScheduledExecutorService p =
247              Executors.unconfigurableScheduledExecutorService
248              (Executors.newScheduledThreadPool(2));
249 <        try {
250 <            final CountDownLatch done = new CountDownLatch(1);
249 >        try (PoolCleaner cleaner = cleaner(p)) {
250 >            final CountDownLatch proceed = new CountDownLatch(1);
251              final Runnable task = new CheckedRunnable() {
252                  public void realRun() {
253 <                    done.countDown();
253 >                    await(proceed);
254                  }};
255 +            long startTime = System.nanoTime();
256              Future f = p.schedule(Executors.callable(task, Boolean.TRUE),
257 <                                  SHORT_DELAY_MS, MILLISECONDS);
257 >                                  timeoutMillis(), MILLISECONDS);
258              assertFalse(f.isDone());
259 <            assertTrue(done.await(MEDIUM_DELAY_MS, MILLISECONDS));
260 <            assertSame(Boolean.TRUE, f.get(SMALL_DELAY_MS, MILLISECONDS));
259 >            proceed.countDown();
260 >            assertSame(Boolean.TRUE, f.get(LONG_DELAY_MS, MILLISECONDS));
261              assertSame(Boolean.TRUE, f.get());
262              assertTrue(f.isDone());
263 <        } finally {
264 <            joinPool(p);
263 >            assertFalse(f.isCancelled());
264 >            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
265          }
266      }
267  
# Line 258 | Line 281 | public class ExecutorsTest extends JSR16
281                  delay(LONG_DELAY_MS);
282              }};
283  
284 <        List<Thread> threads = new ArrayList<Thread>();
284 >        List<Thread> threads = new ArrayList<>();
285          for (final ExecutorService executor : executors) {
286              threads.add(newStartedThread(new CheckedRunnable() {
287                  public void realRun() {
265 –                    long startTime = System.nanoTime();
288                      Future future = executor.submit(sleeper);
289                      assertFutureTimesOut(future);
290                  }}));
# Line 279 | Line 301 | public class ExecutorsTest extends JSR16
301       */
302      public void testDefaultThreadFactory() throws Exception {
303          final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
304 +        final CountDownLatch done = new CountDownLatch(1);
305          Runnable r = new CheckedRunnable() {
306              public void realRun() {
307                  try {
# Line 296 | Line 319 | public class ExecutorsTest extends JSR16
319                  } catch (SecurityException ok) {
320                      // Also pass if not allowed to change setting
321                  }
322 +                done.countDown();
323              }};
324          ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
325 <
326 <        e.execute(r);
327 <        try {
304 <            e.shutdown();
305 <        } catch (SecurityException ok) {
306 <        }
307 <
308 <        try {
309 <            delay(SHORT_DELAY_MS);
310 <        } finally {
311 <            joinPool(e);
325 >        try (PoolCleaner cleaner = cleaner(e)) {
326 >            e.execute(r);
327 >            await(done);
328          }
329      }
330  
# Line 318 | Line 334 | public class ExecutorsTest extends JSR16
334       * access control context and context class loader
335       */
336      public void testPrivilegedThreadFactory() throws Exception {
337 +        final CountDownLatch done = new CountDownLatch(1);
338          Runnable r = new CheckedRunnable() {
339              public void realRun() throws Exception {
340                  final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
# Line 338 | Line 355 | public class ExecutorsTest extends JSR16
355                          assertTrue(name.endsWith("thread-1"));
356                          assertSame(thisccl, current.getContextClassLoader());
357                          assertEquals(thisacc, AccessController.getContext());
358 +                        done.countDown();
359                      }};
360                  ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
361 <                e.execute(r);
362 <                e.shutdown();
363 <                delay(SHORT_DELAY_MS);
364 <                joinPool(e);
361 >                try (PoolCleaner cleaner = cleaner(e)) {
362 >                    e.execute(r);
363 >                    await(done);
364 >                }
365              }};
366  
367          runWithPermissions(r,
# Line 402 | Line 420 | public class ExecutorsTest extends JSR16
420       * With class loader permissions, calling
421       * privilegedCallableUsingCurrentClassLoader does not throw ACE
422       */
423 <    public void testprivilegedCallableUsingCCLWithPrivs() throws Exception {
423 >    public void testPrivilegedCallableUsingCCLWithPrivs() throws Exception {
424          Runnable r = new CheckedRunnable() {
425              public void realRun() throws Exception {
426                  Executors.privilegedCallableUsingCurrentClassLoader
# Line 418 | Line 436 | public class ExecutorsTest extends JSR16
436      /**
437       * Without permissions, calling privilegedCallable throws ACE
438       */
439 <    public void testprivilegedCallableWithNoPrivs() throws Exception {
439 >    public void testPrivilegedCallableWithNoPrivs() throws Exception {
440          // Avoid classloader-related SecurityExceptions in swingui.TestRunner
441          Executors.privilegedCallable(new CheckCCL());
442  
# Line 490 | Line 508 | public class ExecutorsTest extends JSR16
508      /**
509       * With permissions, calling privilegedCallable succeeds
510       */
511 <    public void testprivilegedCallableWithPrivs() throws Exception {
511 >    public void testPrivilegedCallableWithPrivs() throws Exception {
512          Runnable r = new CheckedRunnable() {
513              public void realRun() throws Exception {
514                  Executors.privilegedCallable(new CheckCCL()).call();

Diff Legend

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