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.42 by jsr166, Sun May 29 13:45:35 2011 UTC vs.
Revision 1.48 by jsr166, Sat Mar 18 20:42:20 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 144 | 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 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 {
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 192 | Line 212 | public class ExecutorsTest extends JSR16
212              assertTrue(f.isDone());
213              assertFalse(f.isCancelled());
214              assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
195 –        } finally {
196 –            joinPool(p);
215          }
216      }
217  
# Line 201 | 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 218 | Line 236 | public class ExecutorsTest extends JSR16
236              assertTrue(f.isDone());
237              assertFalse(f.isCancelled());
238              assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
221 –        } finally {
222 –            joinPool(p);
239          }
240      }
241  
# Line 227 | 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 246 | Line 262 | public class ExecutorsTest extends JSR16
262              assertTrue(f.isDone());
263              assertFalse(f.isCancelled());
264              assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
249 –        } finally {
250 –            joinPool(p);
265          }
266      }
267  
# Line 267 | 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() {
274 –                    long startTime = System.nanoTime();
288                      Future future = executor.submit(sleeper);
289                      assertFutureTimesOut(future);
290                  }}));
# Line 293 | Line 306 | public class ExecutorsTest extends JSR16
306              public void realRun() {
307                  try {
308                      Thread current = Thread.currentThread();
309 <                    assertTrue(!current.isDaemon());
309 >                    assertFalse(current.isDaemon());
310                      assertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
298 –                    ThreadGroup g = current.getThreadGroup();
311                      SecurityManager s = System.getSecurityManager();
312 <                    if (s != null)
313 <                        assertTrue(g == s.getThreadGroup());
314 <                    else
303 <                        assertTrue(g == egroup);
304 <                    String name = current.getName();
305 <                    assertTrue(name.endsWith("thread-1"));
312 >                    assertSame(current.getThreadGroup(),
313 >                               (s == null) ? egroup : s.getThreadGroup());
314 >                    assertTrue(current.getName().endsWith("thread-1"));
315                  } catch (SecurityException ok) {
316                      // Also pass if not allowed to change setting
317                  }
318                  done.countDown();
319              }};
320          ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
321 <
322 <        e.execute(r);
323 <        await(done);
315 <
316 <        try {
317 <            e.shutdown();
318 <        } catch (SecurityException ok) {
321 >        try (PoolCleaner cleaner = cleaner(e)) {
322 >            e.execute(r);
323 >            await(done);
324          }
320 –
321 –        joinPool(e);
325      }
326  
327      /**
# Line 336 | Line 339 | public class ExecutorsTest extends JSR16
339                  Runnable r = new CheckedRunnable() {
340                      public void realRun() {
341                          Thread current = Thread.currentThread();
342 <                        assertTrue(!current.isDaemon());
342 >                        assertFalse(current.isDaemon());
343                          assertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
341 –                        ThreadGroup g = current.getThreadGroup();
344                          SecurityManager s = System.getSecurityManager();
345 <                        if (s != null)
346 <                            assertTrue(g == s.getThreadGroup());
347 <                        else
346 <                            assertTrue(g == egroup);
347 <                        String name = current.getName();
348 <                        assertTrue(name.endsWith("thread-1"));
345 >                        assertSame(current.getThreadGroup(),
346 >                                   (s == null) ? egroup : s.getThreadGroup());
347 >                        assertTrue(current.getName().endsWith("thread-1"));
348                          assertSame(thisccl, current.getContextClassLoader());
349                          assertEquals(thisacc, AccessController.getContext());
350                          done.countDown();
351                      }};
352                  ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
353 <                e.execute(r);
354 <                await(done);
355 <                e.shutdown();
356 <                joinPool(e);
353 >                try (PoolCleaner cleaner = cleaner(e)) {
354 >                    e.execute(r);
355 >                    await(done);
356 >                }
357              }};
358  
359          runWithPermissions(r,

Diff Legend

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