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.47 by jsr166, Wed Jan 4 06:09:58 2017 UTC vs.
Revision 1.54 by jsr166, Sat Feb 1 18:52:17 2020 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 140 | Line 140 | public class ExecutorsTest extends JSR16
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 {
148 <            ExecutorService e = Executors.newFixedThreadPool(2, null);
148 >            ExecutorService unused = Executors.newFixedThreadPool(2, null);
149              shouldThrow();
150          } catch (NullPointerException success) {}
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 {
158 <            ExecutorService e = Executors.newFixedThreadPool(0);
158 >            ExecutorService unused = Executors.newFixedThreadPool(0);
159              shouldThrow();
160          } catch (IllegalArgumentException success) {}
161      }
# Line 176 | 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 186 | 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 276 | 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<>();
# Line 291 | Line 296 | public class ExecutorsTest extends JSR16
296          }
297          for (Thread thread : threads)
298              awaitTermination(thread);
299 +        done.countDown();
300          for (ExecutorService executor : executors)
301              joinPool(executor);
302      }
# Line 306 | Line 312 | public class ExecutorsTest extends JSR16
312              public void realRun() {
313                  try {
314                      Thread current = Thread.currentThread();
315 <                    assertTrue(!current.isDaemon());
315 >                    assertFalse(current.isDaemon());
316                      assertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
311 –                    ThreadGroup g = current.getThreadGroup();
317                      SecurityManager s = System.getSecurityManager();
318 <                    if (s != null)
319 <                        assertTrue(g == s.getThreadGroup());
320 <                    else
316 <                        assertTrue(g == egroup);
317 <                    String name = current.getName();
318 <                    assertTrue(name.endsWith("thread-1"));
318 >                    assertSame(current.getThreadGroup(),
319 >                               (s == null) ? egroup : s.getThreadGroup());
320 >                    assertTrue(current.getName().endsWith("thread-1"));
321                  } catch (SecurityException ok) {
322                      // Also pass if not allowed to change setting
323                  }
# Line 343 | Line 345 | public class ExecutorsTest extends JSR16
345                  Runnable r = new CheckedRunnable() {
346                      public void realRun() {
347                          Thread current = Thread.currentThread();
348 <                        assertTrue(!current.isDaemon());
348 >                        assertFalse(current.isDaemon());
349                          assertTrue(current.getPriority() <= Thread.NORM_PRIORITY);
348 –                        ThreadGroup g = current.getThreadGroup();
350                          SecurityManager s = System.getSecurityManager();
351 <                        if (s != null)
352 <                            assertTrue(g == s.getThreadGroup());
353 <                        else
353 <                            assertTrue(g == egroup);
354 <                        String name = current.getName();
355 <                        assertTrue(name.endsWith("thread-1"));
351 >                        assertSame(current.getThreadGroup(),
352 >                                   (s == null) ? egroup : s.getThreadGroup());
353 >                        assertTrue(current.getName().endsWith("thread-1"));
354                          assertSame(thisccl, current.getContextClassLoader());
355                          assertEquals(thisacc, AccessController.getContext());
356                          done.countDown();
# Line 558 | Line 556 | public class ExecutorsTest extends JSR16
556       */
557      public void testCallableNPE1() {
558          try {
559 <            Callable c = Executors.callable((Runnable) null);
559 >            Callable unused = Executors.callable((Runnable) null);
560              shouldThrow();
561          } catch (NullPointerException success) {}
562      }
# Line 568 | Line 566 | public class ExecutorsTest extends JSR16
566       */
567      public void testCallableNPE2() {
568          try {
569 <            Callable c = Executors.callable((Runnable) null, one);
569 >            Callable unused = Executors.callable((Runnable) null, one);
570              shouldThrow();
571          } catch (NullPointerException success) {}
572      }
# Line 578 | Line 576 | public class ExecutorsTest extends JSR16
576       */
577      public void testCallableNPE3() {
578          try {
579 <            Callable c = Executors.callable((PrivilegedAction) null);
579 >            Callable unused = Executors.callable((PrivilegedAction) null);
580              shouldThrow();
581          } catch (NullPointerException success) {}
582      }
# Line 588 | Line 586 | public class ExecutorsTest extends JSR16
586       */
587      public void testCallableNPE4() {
588          try {
589 <            Callable c = Executors.callable((PrivilegedExceptionAction) null);
589 >            Callable unused = Executors.callable((PrivilegedExceptionAction) null);
590              shouldThrow();
591          } catch (NullPointerException success) {}
592      }
593  
594 +    /**
595 +     * callable(runnable, x).toString() contains toString of wrapped task
596 +     */
597 +    public void testCallable_withResult_toString() {
598 +        if (testImplementationDetails) {
599 +            Runnable r = () -> {};
600 +            Callable<String> c = Executors.callable(r, "");
601 +            assertEquals(
602 +                identityString(c) + "[Wrapped task = " + r.toString() + "]",
603 +                c.toString());
604 +        }
605 +    }
606 +
607 +    /**
608 +     * callable(runnable).toString() contains toString of wrapped task
609 +     */
610 +    public void testCallable_toString() {
611 +        if (testImplementationDetails) {
612 +            Runnable r = () -> {};
613 +            Callable<Object> c = Executors.callable(r);
614 +            assertEquals(
615 +                identityString(c) + "[Wrapped task = " + r.toString() + "]",
616 +                c.toString());
617 +        }
618 +    }
619 +
620 +    /**
621 +     * privilegedCallable(callable).toString() contains toString of wrapped task
622 +     */
623 +    public void testPrivilegedCallable_toString() {
624 +        if (testImplementationDetails) {
625 +            Callable<String> c = () -> "";
626 +            Callable<String> priv = Executors.privilegedCallable(c);
627 +            assertEquals(
628 +                identityString(priv) + "[Wrapped task = " + c.toString() + "]",
629 +                priv.toString());
630 +        }
631 +    }
632 +
633 +    /**
634 +     * privilegedCallableUsingCurrentClassLoader(callable).toString()
635 +     * contains toString of wrapped task
636 +     */
637 +    public void testPrivilegedCallableUsingCurrentClassLoader_toString() {
638 +        if (testImplementationDetails) {
639 +            Callable<String> c = () -> "";
640 +            Callable<String> priv = Executors.privilegedCallableUsingCurrentClassLoader(c);
641 +            assertEquals(
642 +                identityString(priv) + "[Wrapped task = " + c.toString() + "]",
643 +                priv.toString());
644 +        }
645 +    }
646   }

Diff Legend

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