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.50 by jsr166, Wed Aug 16 17:18:34 2017 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      /**
143 <     * A new newFixedThreadPool with null ThreadFactory throws NPE
143 >     * A new newFixedThreadPool with null ThreadFactory throws
144 >     * NullPointerException
145       */
146      public void testNewFixedThreadPool3() {
147          try {
# Line 145 | Line 151 | public class ExecutorsTest extends JSR16
151      }
152  
153      /**
154 <     * A new newFixedThreadPool with 0 threads throws IAE
154 >     * A new newFixedThreadPool with 0 threads throws IllegalArgumentException
155       */
156      public void testNewFixedThreadPool4() {
157          try {
# Line 158 | Line 164 | public class ExecutorsTest extends JSR16
164       * An unconfigurable newFixedThreadPool can execute runnables
165       */
166      public void testUnconfigurableExecutorService() {
167 <        ExecutorService e = Executors.unconfigurableExecutorService(Executors.newFixedThreadPool(2));
168 <        e.execute(new NoOpRunnable());
169 <        e.execute(new NoOpRunnable());
170 <        e.execute(new NoOpRunnable());
171 <        joinPool(e);
167 >        final ExecutorService e = Executors.unconfigurableExecutorService(Executors.newFixedThreadPool(2));
168 >        try (PoolCleaner cleaner = cleaner(e)) {
169 >            e.execute(new NoOpRunnable());
170 >            e.execute(new NoOpRunnable());
171 >            e.execute(new NoOpRunnable());
172 >        }
173      }
174  
175      /**
# Line 189 | Line 196 | public class ExecutorsTest extends JSR16
196       * a newSingleThreadScheduledExecutor successfully runs delayed task
197       */
198      public void testNewSingleThreadScheduledExecutor() throws Exception {
199 <        ScheduledExecutorService p = Executors.newSingleThreadScheduledExecutor();
200 <        try {
199 >        final ScheduledExecutorService p = Executors.newSingleThreadScheduledExecutor();
200 >        try (PoolCleaner cleaner = cleaner(p)) {
201              final CountDownLatch proceed = new CountDownLatch(1);
202              final Runnable task = new CheckedRunnable() {
203                  public void realRun() {
# Line 206 | Line 213 | public class ExecutorsTest extends JSR16
213              assertTrue(f.isDone());
214              assertFalse(f.isCancelled());
215              assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
209 –        } finally {
210 –            joinPool(p);
216          }
217      }
218  
# Line 215 | Line 220 | public class ExecutorsTest extends JSR16
220       * a newScheduledThreadPool successfully runs delayed task
221       */
222      public void testNewScheduledThreadPool() throws Exception {
223 <        ScheduledExecutorService p = Executors.newScheduledThreadPool(2);
224 <        try {
223 >        final ScheduledExecutorService p = Executors.newScheduledThreadPool(2);
224 >        try (PoolCleaner cleaner = cleaner(p)) {
225              final CountDownLatch proceed = new CountDownLatch(1);
226              final Runnable task = new CheckedRunnable() {
227                  public void realRun() {
# Line 232 | Line 237 | public class ExecutorsTest extends JSR16
237              assertTrue(f.isDone());
238              assertFalse(f.isCancelled());
239              assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
235 –        } finally {
236 –            joinPool(p);
240          }
241      }
242  
# Line 241 | Line 244 | public class ExecutorsTest extends JSR16
244       * an unconfigurable newScheduledThreadPool successfully runs delayed task
245       */
246      public void testUnconfigurableScheduledExecutorService() throws Exception {
247 <        ScheduledExecutorService p =
247 >        final ScheduledExecutorService p =
248              Executors.unconfigurableScheduledExecutorService
249              (Executors.newScheduledThreadPool(2));
250 <        try {
250 >        try (PoolCleaner cleaner = cleaner(p)) {
251              final CountDownLatch proceed = new CountDownLatch(1);
252              final Runnable task = new CheckedRunnable() {
253                  public void realRun() {
# Line 260 | Line 263 | public class ExecutorsTest extends JSR16
263              assertTrue(f.isDone());
264              assertFalse(f.isCancelled());
265              assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
263 –        } finally {
264 –            joinPool(p);
266          }
267      }
268  
# Line 281 | Line 282 | public class ExecutorsTest extends JSR16
282                  delay(LONG_DELAY_MS);
283              }};
284  
285 <        List<Thread> threads = new ArrayList<Thread>();
285 >        List<Thread> threads = new ArrayList<>();
286          for (final ExecutorService executor : executors) {
287              threads.add(newStartedThread(new CheckedRunnable() {
288                  public void realRun() {
# Line 306 | Line 307 | public class ExecutorsTest extends JSR16
307              public void realRun() {
308                  try {
309                      Thread current = Thread.currentThread();
310 <                    assertTrue(!current.isDaemon());
310 >                    assertFalse(current.isDaemon());
311                      assertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
311 –                    ThreadGroup g = current.getThreadGroup();
312                      SecurityManager s = System.getSecurityManager();
313 <                    if (s != null)
314 <                        assertTrue(g == s.getThreadGroup());
315 <                    else
316 <                        assertTrue(g == egroup);
317 <                    String name = current.getName();
318 <                    assertTrue(name.endsWith("thread-1"));
313 >                    assertSame(current.getThreadGroup(),
314 >                               (s == null) ? egroup : s.getThreadGroup());
315 >                    assertTrue(current.getName().endsWith("thread-1"));
316                  } catch (SecurityException ok) {
317                      // Also pass if not allowed to change setting
318                  }
319                  done.countDown();
320              }};
321          ExecutorService e = Executors.newSingleThreadExecutor(Executors.defaultThreadFactory());
322 <
323 <        e.execute(r);
324 <        await(done);
328 <
329 <        try {
330 <            e.shutdown();
331 <        } catch (SecurityException ok) {
322 >        try (PoolCleaner cleaner = cleaner(e)) {
323 >            e.execute(r);
324 >            await(done);
325          }
333 –
334 –        joinPool(e);
326      }
327  
328      /**
# Line 349 | Line 340 | public class ExecutorsTest extends JSR16
340                  Runnable r = new CheckedRunnable() {
341                      public void realRun() {
342                          Thread current = Thread.currentThread();
343 <                        assertTrue(!current.isDaemon());
343 >                        assertFalse(current.isDaemon());
344                          assertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
354 –                        ThreadGroup g = current.getThreadGroup();
345                          SecurityManager s = System.getSecurityManager();
346 <                        if (s != null)
347 <                            assertTrue(g == s.getThreadGroup());
348 <                        else
359 <                            assertTrue(g == egroup);
360 <                        String name = current.getName();
361 <                        assertTrue(name.endsWith("thread-1"));
346 >                        assertSame(current.getThreadGroup(),
347 >                                   (s == null) ? egroup : s.getThreadGroup());
348 >                        assertTrue(current.getName().endsWith("thread-1"));
349                          assertSame(thisccl, current.getContextClassLoader());
350                          assertEquals(thisacc, AccessController.getContext());
351                          done.countDown();
352                      }};
353                  ExecutorService e = Executors.newSingleThreadExecutor(Executors.privilegedThreadFactory());
354 <                e.execute(r);
355 <                await(done);
356 <                e.shutdown();
357 <                joinPool(e);
354 >                try (PoolCleaner cleaner = cleaner(e)) {
355 >                    e.execute(r);
356 >                    await(done);
357 >                }
358              }};
359  
360          runWithPermissions(r,
# Line 599 | Line 586 | public class ExecutorsTest extends JSR16
586          } catch (NullPointerException success) {}
587      }
588  
589 +    /**
590 +     * callable(runnable, x).toString() contains toString of wrapped task
591 +     */
592 +    public void testCallable_withResult_toString() {
593 +        if (testImplementationDetails) {
594 +            Runnable r = () -> {};
595 +            Callable<String> c = Executors.callable(r, "");
596 +            assertEquals(
597 +                identityString(c) + "[Wrapped task = " + r.toString() + "]",
598 +                c.toString());
599 +        }
600 +    }
601 +
602 +    /**
603 +     * callable(runnable).toString() contains toString of wrapped task
604 +     */
605 +    public void testCallable_toString() {
606 +        if (testImplementationDetails) {
607 +            Runnable r = () -> {};
608 +            Callable<Object> c = Executors.callable(r);
609 +            assertEquals(
610 +                identityString(c) + "[Wrapped task = " + r.toString() + "]",
611 +                c.toString());
612 +        }
613 +    }
614 +
615 +    /**
616 +     * privilegedCallable(callable).toString() contains toString of wrapped task
617 +     */
618 +    public void testPrivilegedCallable_toString() {
619 +        if (testImplementationDetails) {
620 +            Callable<String> c = () -> "";
621 +            Callable<String> priv = Executors.privilegedCallable(c);
622 +            assertEquals(
623 +                identityString(priv) + "[Wrapped task = " + c.toString() + "]",
624 +                priv.toString());
625 +        }
626 +    }
627 +
628 +    /**
629 +     * privilegedCallableUsingCurrentClassLoader(callable).toString()
630 +     * contains toString of wrapped task
631 +     */
632 +    public void testPrivilegedCallableUsingCurrentClassLoader_toString() {
633 +        if (testImplementationDetails) {
634 +            Callable<String> c = () -> "";
635 +            Callable<String> priv = Executors.privilegedCallableUsingCurrentClassLoader(c);
636 +            assertEquals(
637 +                identityString(priv) + "[Wrapped task = " + c.toString() + "]",
638 +                priv.toString());
639 +        }
640 +    }
641   }

Diff Legend

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