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.49 by jsr166, Mon May 29 22:44:26 2017 UTC vs.
Revision 1.56 by dl, Tue Mar 22 21:29:23 2022 UTC

# Line 63 | Line 63 | public class ExecutorsTest extends JSR16
63       */
64      public void testNewCachedThreadPool3() {
65          try {
66 <            ExecutorService e = Executors.newCachedThreadPool(null);
66 >            ExecutorService unused = Executors.newCachedThreadPool(null);
67              shouldThrow();
68          } catch (NullPointerException success) {}
69      }
# Line 97 | Line 97 | public class ExecutorsTest extends JSR16
97       */
98      public void testNewSingleThreadExecutor3() {
99          try {
100 <            ExecutorService e = Executors.newSingleThreadExecutor(null);
100 >            ExecutorService unused = Executors.newSingleThreadExecutor(null);
101              shouldThrow();
102          } catch (NullPointerException success) {}
103      }
# Line 145 | Line 145 | public class ExecutorsTest extends JSR16
145       */
146      public void testNewFixedThreadPool3() {
147          try {
148 <            ExecutorService e = Executors.newFixedThreadPool(2, null);
148 >            ExecutorService unused = Executors.newFixedThreadPool(2, null);
149              shouldThrow();
150          } catch (NullPointerException success) {}
151      }
# Line 155 | Line 155 | public class ExecutorsTest extends JSR16
155       */
156      public void testNewFixedThreadPool4() {
157          try {
158 <            ExecutorService e = Executors.newFixedThreadPool(0);
158 >            ExecutorService unused = Executors.newFixedThreadPool(0);
159              shouldThrow();
160          } catch (IllegalArgumentException success) {}
161      }
# Line 177 | Line 177 | public class ExecutorsTest extends JSR16
177       */
178      public void testUnconfigurableExecutorServiceNPE() {
179          try {
180 <            ExecutorService e = Executors.unconfigurableExecutorService(null);
180 >            ExecutorService unused =
181 >                Executors.unconfigurableExecutorService(null);
182              shouldThrow();
183          } catch (NullPointerException success) {}
184      }
# Line 187 | Line 188 | public class ExecutorsTest extends JSR16
188       */
189      public void testUnconfigurableScheduledExecutorServiceNPE() {
190          try {
191 <            ExecutorService e = Executors.unconfigurableScheduledExecutorService(null);
191 >            ExecutorService unused =
192 >                Executors.unconfigurableScheduledExecutorService(null);
193              shouldThrow();
194          } catch (NullPointerException success) {}
195      }
# Line 204 | Line 206 | public class ExecutorsTest extends JSR16
206                      await(proceed);
207                  }};
208              long startTime = System.nanoTime();
209 <            Future f = p.schedule(Executors.callable(task, Boolean.TRUE),
209 >            Future<?> f = p.schedule(Executors.callable(task, Boolean.TRUE),
210                                    timeoutMillis(), MILLISECONDS);
211              assertFalse(f.isDone());
212              proceed.countDown();
# Line 228 | Line 230 | public class ExecutorsTest extends JSR16
230                      await(proceed);
231                  }};
232              long startTime = System.nanoTime();
233 <            Future f = p.schedule(Executors.callable(task, Boolean.TRUE),
233 >            Future<?> f = p.schedule(Executors.callable(task, Boolean.TRUE),
234                                    timeoutMillis(), MILLISECONDS);
235              assertFalse(f.isDone());
236              proceed.countDown();
# Line 254 | Line 256 | public class ExecutorsTest extends JSR16
256                      await(proceed);
257                  }};
258              long startTime = System.nanoTime();
259 <            Future f = p.schedule(Executors.callable(task, Boolean.TRUE),
259 >            Future<?> f = p.schedule(Executors.callable(task, Boolean.TRUE),
260                                    timeoutMillis(), MILLISECONDS);
261              assertFalse(f.isDone());
262              proceed.countDown();
# Line 277 | Line 279 | public class ExecutorsTest extends JSR16
279              Executors.newScheduledThreadPool(2),
280          };
281  
282 <        final Runnable sleeper = new CheckedInterruptedRunnable() {
282 >        final CountDownLatch done = new CountDownLatch(1);
283 >
284 >        final Runnable sleeper = new CheckedRunnable() {
285              public void realRun() throws InterruptedException {
286 <                delay(LONG_DELAY_MS);
286 >                done.await(LONG_DELAY_MS, MILLISECONDS);
287              }};
288  
289          List<Thread> threads = new ArrayList<>();
290          for (final ExecutorService executor : executors) {
291              threads.add(newStartedThread(new CheckedRunnable() {
292                  public void realRun() {
293 <                    Future future = executor.submit(sleeper);
293 >                    Future<?> future = executor.submit(sleeper);
294                      assertFutureTimesOut(future);
295                  }}));
296          }
297          for (Thread thread : threads)
298              awaitTermination(thread);
299 +        done.countDown();
300          for (ExecutorService executor : executors)
301              joinPool(executor);
302      }
# Line 300 | Line 305 | public class ExecutorsTest extends JSR16
305       * ThreadPoolExecutor using defaultThreadFactory has
306       * specified group, priority, daemon status, and name
307       */
308 +    @SuppressWarnings("removal")
309      public void testDefaultThreadFactory() throws Exception {
310          final ThreadGroup egroup = Thread.currentThread().getThreadGroup();
311          final CountDownLatch done = new CountDownLatch(1);
# Line 330 | Line 336 | public class ExecutorsTest extends JSR16
336       * specified group, priority, daemon status, name,
337       * access control context and context class loader
338       */
339 +    @SuppressWarnings("removal")
340      public void testPrivilegedThreadFactory() throws Exception {
341          final CountDownLatch done = new CountDownLatch(1);
342          Runnable r = new CheckedRunnable() {
# Line 363 | Line 370 | public class ExecutorsTest extends JSR16
370                             new RuntimePermission("modifyThread"));
371      }
372  
373 +    @SuppressWarnings("removal")
374      boolean haveCCLPermissions() {
375          SecurityManager sm = System.getSecurityManager();
376          if (sm != null) {
# Line 376 | Line 384 | public class ExecutorsTest extends JSR16
384          return true;
385      }
386  
387 +    @SuppressWarnings("removal")
388      void checkCCL() {
389          SecurityManager sm = System.getSecurityManager();
390          if (sm != null) {
# Line 395 | Line 404 | public class ExecutorsTest extends JSR16
404       * Without class loader permissions, creating
405       * privilegedCallableUsingCurrentClassLoader throws ACE
406       */
407 +    @SuppressWarnings("removal")
408      public void testCreatePrivilegedCallableUsingCCLWithNoPrivs() {
409          Runnable r = new CheckedRunnable() {
410              public void realRun() throws Exception {
# Line 413 | Line 423 | public class ExecutorsTest extends JSR16
423       * With class loader permissions, calling
424       * privilegedCallableUsingCurrentClassLoader does not throw ACE
425       */
426 +    @SuppressWarnings("removal")
427      public void testPrivilegedCallableUsingCCLWithPrivs() throws Exception {
428          Runnable r = new CheckedRunnable() {
429              public void realRun() throws Exception {
# Line 429 | Line 440 | public class ExecutorsTest extends JSR16
440      /**
441       * Without permissions, calling privilegedCallable throws ACE
442       */
443 +    @SuppressWarnings("removal")
444      public void testPrivilegedCallableWithNoPrivs() throws Exception {
445          // Avoid classloader-related SecurityExceptions in swingui.TestRunner
446          Executors.privilegedCallable(new CheckCCL());
# Line 437 | Line 449 | public class ExecutorsTest extends JSR16
449              public void realRun() throws Exception {
450                  if (System.getSecurityManager() == null)
451                      return;
452 <                Callable task = Executors.privilegedCallable(new CheckCCL());
452 >                Callable<?> task = Executors.privilegedCallable(new CheckCCL());
453                  try {
454                      task.call();
455                      shouldThrow();
# Line 501 | Line 513 | public class ExecutorsTest extends JSR16
513      /**
514       * With permissions, calling privilegedCallable succeeds
515       */
516 +    @SuppressWarnings("removal")
517      public void testPrivilegedCallableWithPrivs() throws Exception {
518          Runnable r = new CheckedRunnable() {
519              public void realRun() throws Exception {
# Line 516 | Line 529 | public class ExecutorsTest extends JSR16
529       * callable(Runnable) returns null when called
530       */
531      public void testCallable1() throws Exception {
532 <        Callable c = Executors.callable(new NoOpRunnable());
532 >        Callable<?> c = Executors.callable(new NoOpRunnable());
533          assertNull(c.call());
534      }
535  
# Line 524 | Line 537 | public class ExecutorsTest extends JSR16
537       * callable(Runnable, result) returns result when called
538       */
539      public void testCallable2() throws Exception {
540 <        Callable c = Executors.callable(new NoOpRunnable(), one);
540 >        Callable<?> c = Executors.callable(new NoOpRunnable(), one);
541          assertSame(one, c.call());
542      }
543  
# Line 532 | Line 545 | public class ExecutorsTest extends JSR16
545       * callable(PrivilegedAction) returns its result when called
546       */
547      public void testCallable3() throws Exception {
548 <        Callable c = Executors.callable(new PrivilegedAction() {
548 >        Callable<?> c = Executors.callable(new PrivilegedAction() {
549                  public Object run() { return one; }});
550          assertSame(one, c.call());
551      }
# Line 541 | Line 554 | public class ExecutorsTest extends JSR16
554       * callable(PrivilegedExceptionAction) returns its result when called
555       */
556      public void testCallable4() throws Exception {
557 <        Callable c = Executors.callable(new PrivilegedExceptionAction() {
557 >        Callable<?> c = Executors.callable(new PrivilegedExceptionAction() {
558                  public Object run() { return one; }});
559          assertSame(one, c.call());
560      }
# Line 551 | Line 564 | public class ExecutorsTest extends JSR16
564       */
565      public void testCallableNPE1() {
566          try {
567 <            Callable c = Executors.callable((Runnable) null);
567 >            Callable<?> unused = Executors.callable((Runnable) null);
568              shouldThrow();
569          } catch (NullPointerException success) {}
570      }
# Line 561 | Line 574 | public class ExecutorsTest extends JSR16
574       */
575      public void testCallableNPE2() {
576          try {
577 <            Callable c = Executors.callable((Runnable) null, one);
577 >            Callable<?> unused = Executors.callable((Runnable) null, one);
578              shouldThrow();
579          } catch (NullPointerException success) {}
580      }
# Line 571 | Line 584 | public class ExecutorsTest extends JSR16
584       */
585      public void testCallableNPE3() {
586          try {
587 <            Callable c = Executors.callable((PrivilegedAction) null);
587 >            Callable<?> unused = Executors.callable((PrivilegedAction) null);
588              shouldThrow();
589          } catch (NullPointerException success) {}
590      }
# Line 581 | Line 594 | public class ExecutorsTest extends JSR16
594       */
595      public void testCallableNPE4() {
596          try {
597 <            Callable c = Executors.callable((PrivilegedExceptionAction) null);
597 >            Callable<?> unused = Executors.callable((PrivilegedExceptionAction) null);
598              shouldThrow();
599          } catch (NullPointerException success) {}
600      }
601  
602 +    /**
603 +     * callable(runnable, x).toString() contains toString of wrapped task
604 +     */
605 +    public void testCallable_withResult_toString() {
606 +        if (testImplementationDetails) {
607 +            Runnable r = () -> {};
608 +            Callable<String> c = Executors.callable(r, "");
609 +            assertEquals(
610 +                identityString(c) + "[Wrapped task = " + r.toString() + "]",
611 +                c.toString());
612 +        }
613 +    }
614 +
615 +    /**
616 +     * callable(runnable).toString() contains toString of wrapped task
617 +     */
618 +    public void testCallable_toString() {
619 +        if (testImplementationDetails) {
620 +            Runnable r = () -> {};
621 +            Callable<Object> c = Executors.callable(r);
622 +            assertEquals(
623 +                identityString(c) + "[Wrapped task = " + r.toString() + "]",
624 +                c.toString());
625 +        }
626 +    }
627 +
628 +    /**
629 +     * privilegedCallable(callable).toString() contains toString of wrapped task
630 +     */
631 +    @SuppressWarnings("removal")
632 +    public void testPrivilegedCallable_toString() {
633 +        if (testImplementationDetails) {
634 +            Callable<String> c = () -> "";
635 +            Callable<String> priv = Executors.privilegedCallable(c);
636 +            assertEquals(
637 +                identityString(priv) + "[Wrapped task = " + c.toString() + "]",
638 +                priv.toString());
639 +        }
640 +    }
641 +
642 +    /**
643 +     * privilegedCallableUsingCurrentClassLoader(callable).toString()
644 +     * contains toString of wrapped task
645 +     */
646 +    @SuppressWarnings("removal")
647 +    public void testPrivilegedCallableUsingCurrentClassLoader_toString() {
648 +        if (testImplementationDetails) {
649 +            Callable<String> c = () -> "";
650 +            Callable<String> priv = Executors.privilegedCallableUsingCurrentClassLoader(c);
651 +            assertEquals(
652 +                identityString(priv) + "[Wrapped task = " + c.toString() + "]",
653 +                priv.toString());
654 +        }
655 +    }
656   }

Diff Legend

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