ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ThreadPoolExecutorTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ThreadPoolExecutorTest.java (file contents):
Revision 1.78 by jsr166, Sun Oct 4 02:09:57 2015 UTC vs.
Revision 1.84 by jsr166, Sun Oct 4 02:31:15 2015 UTC

# Line 87 | Line 87 | public class ThreadPoolExecutorTest exte
87              new ThreadPoolExecutor(1, 1,
88                                     LONG_DELAY_MS, MILLISECONDS,
89                                     new ArrayBlockingQueue<Runnable>(10));
90 <        final CountDownLatch done = new CountDownLatch(1);
91 <        final Runnable task = new CheckedRunnable() {
92 <            public void realRun() {
93 <                done.countDown();
94 <            }};
95 <        try {
90 >        try (PoolCleaner cleaner = cleaner(p)) {
91 >            final CountDownLatch done = new CountDownLatch(1);
92 >            final Runnable task = new CheckedRunnable() {
93 >                public void realRun() { done.countDown(); }};
94              p.execute(task);
95 <            assertTrue(done.await(SMALL_DELAY_MS, MILLISECONDS));
98 <        } finally {
99 <            joinPool(p);
95 >            assertTrue(done.await(LONG_DELAY_MS, MILLISECONDS));
96          }
97      }
98  
# Line 109 | Line 105 | public class ThreadPoolExecutorTest exte
105              new ThreadPoolExecutor(2, 2,
106                                     LONG_DELAY_MS, MILLISECONDS,
107                                     new ArrayBlockingQueue<Runnable>(10));
108 <        final CountDownLatch threadStarted = new CountDownLatch(1);
109 <        final CountDownLatch done = new CountDownLatch(1);
110 <        try {
108 >        try (PoolCleaner cleaner = cleaner(p)) {
109 >            final CountDownLatch threadStarted = new CountDownLatch(1);
110 >            final CountDownLatch done = new CountDownLatch(1);
111              assertEquals(0, p.getActiveCount());
112              p.execute(new CheckedRunnable() {
113                  public void realRun() throws InterruptedException {
# Line 119 | Line 115 | public class ThreadPoolExecutorTest exte
115                      assertEquals(1, p.getActiveCount());
116                      done.await();
117                  }});
118 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
118 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
119              assertEquals(1, p.getActiveCount());
124 –        } finally {
120              done.countDown();
126 –            joinPool(p);
121          }
122      }
123  
# Line 408 | Line 402 | public class ThreadPoolExecutorTest exte
402              new ThreadPoolExecutor(1, 1,
403                                     LONG_DELAY_MS, MILLISECONDS,
404                                     new ArrayBlockingQueue<Runnable>(10));
405 <        final CountDownLatch threadStarted = new CountDownLatch(1);
406 <        final CountDownLatch done = new CountDownLatch(1);
407 <        try {
405 >        try (PoolCleaner cleaner = cleaner(p)) {
406 >            final CountDownLatch threadStarted = new CountDownLatch(1);
407 >            final CountDownLatch done = new CountDownLatch(1);
408              assertEquals(0, p.getTaskCount());
409              p.execute(new CheckedRunnable() {
410                  public void realRun() throws InterruptedException {
# Line 418 | Line 412 | public class ThreadPoolExecutorTest exte
412                      assertEquals(1, p.getTaskCount());
413                      done.await();
414                  }});
415 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
415 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
416              assertEquals(1, p.getTaskCount());
423 –        } finally {
417              done.countDown();
425 –            joinPool(p);
418          }
419      }
420  
# Line 434 | Line 426 | public class ThreadPoolExecutorTest exte
426              new ThreadPoolExecutor(1, 1,
427                                     LONG_DELAY_MS, MILLISECONDS,
428                                     new ArrayBlockingQueue<Runnable>(10));
429 <        assertFalse(p.isShutdown());
430 <        try { p.shutdown(); } catch (SecurityException ok) { return; }
431 <        assertTrue(p.isShutdown());
432 <        joinPool(p);
429 >        try (PoolCleaner cleaner = cleaner(p)) {
430 >            assertFalse(p.isShutdown());
431 >            try { p.shutdown(); } catch (SecurityException ok) { return; }
432 >            assertTrue(p.isShutdown());
433 >        }
434      }
435  
436      /**
# Line 448 | Line 441 | public class ThreadPoolExecutorTest exte
441              new ThreadPoolExecutor(1, 1,
442                                     LONG_DELAY_MS, MILLISECONDS,
443                                     new ArrayBlockingQueue<Runnable>(10));
444 <        assertFalse(p.isTerminated());
445 <        assertFalse(p.awaitTermination(Long.MIN_VALUE, NANOSECONDS));
446 <        assertFalse(p.awaitTermination(Long.MIN_VALUE, MILLISECONDS));
447 <        assertFalse(p.awaitTermination(-1L, NANOSECONDS));
448 <        assertFalse(p.awaitTermination(-1L, MILLISECONDS));
449 <        assertFalse(p.awaitTermination(0L, NANOSECONDS));
450 <        assertFalse(p.awaitTermination(0L, MILLISECONDS));
451 <        long timeoutNanos = 999999L;
452 <        long startTime = System.nanoTime();
453 <        assertFalse(p.awaitTermination(timeoutNanos, NANOSECONDS));
454 <        assertTrue(System.nanoTime() - startTime >= timeoutNanos);
455 <        assertFalse(p.isTerminated());
456 <        startTime = System.nanoTime();
457 <        long timeoutMillis = timeoutMillis();
458 <        assertFalse(p.awaitTermination(timeoutMillis, MILLISECONDS));
459 <        assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
460 <        assertFalse(p.isTerminated());
461 <        p.shutdown();
462 <        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
463 <        assertTrue(p.isTerminated());
444 >        try (PoolCleaner cleaner = cleaner(p)) {
445 >            assertFalse(p.isTerminated());
446 >            assertFalse(p.awaitTermination(Long.MIN_VALUE, NANOSECONDS));
447 >            assertFalse(p.awaitTermination(Long.MIN_VALUE, MILLISECONDS));
448 >            assertFalse(p.awaitTermination(-1L, NANOSECONDS));
449 >            assertFalse(p.awaitTermination(-1L, MILLISECONDS));
450 >            assertFalse(p.awaitTermination(0L, NANOSECONDS));
451 >            assertFalse(p.awaitTermination(0L, MILLISECONDS));
452 >            long timeoutNanos = 999999L;
453 >            long startTime = System.nanoTime();
454 >            assertFalse(p.awaitTermination(timeoutNanos, NANOSECONDS));
455 >            assertTrue(System.nanoTime() - startTime >= timeoutNanos);
456 >            assertFalse(p.isTerminated());
457 >            startTime = System.nanoTime();
458 >            long timeoutMillis = timeoutMillis();
459 >            assertFalse(p.awaitTermination(timeoutMillis, MILLISECONDS));
460 >            assertTrue(millisElapsedSince(startTime) >= timeoutMillis);
461 >            assertFalse(p.isTerminated());
462 >            try { p.shutdown(); } catch (SecurityException ok) { return; }
463 >            assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
464 >            assertTrue(p.isTerminated());
465 >        }
466      }
467  
468      /**
# Line 478 | Line 473 | public class ThreadPoolExecutorTest exte
473              new ThreadPoolExecutor(1, 1,
474                                     LONG_DELAY_MS, MILLISECONDS,
475                                     new ArrayBlockingQueue<Runnable>(10));
476 <        final CountDownLatch threadStarted = new CountDownLatch(1);
477 <        final CountDownLatch done = new CountDownLatch(1);
478 <        assertFalse(p.isTerminated());
479 <        try {
476 >        try (PoolCleaner cleaner = cleaner(p)) {
477 >            final CountDownLatch threadStarted = new CountDownLatch(1);
478 >            final CountDownLatch done = new CountDownLatch(1);
479 >            assertFalse(p.isTerminating());
480              p.execute(new CheckedRunnable() {
481                  public void realRun() throws InterruptedException {
482 <                    assertFalse(p.isTerminated());
482 >                    assertFalse(p.isTerminating());
483                      threadStarted.countDown();
484                      done.await();
485                  }});
486 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
486 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
487              assertFalse(p.isTerminating());
488              done.countDown();
494 –        } finally {
489              try { p.shutdown(); } catch (SecurityException ok) { return; }
490 +            assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
491 +            assertTrue(p.isTerminated());
492 +            assertFalse(p.isTerminating());
493          }
497 –        assertTrue(p.awaitTermination(LONG_DELAY_MS, MILLISECONDS));
498 –        assertTrue(p.isTerminated());
494      }
495  
496      /**
# Line 516 | Line 511 | public class ThreadPoolExecutorTest exte
511                      threadStarted.countDown();
512                      done.await();
513                  }});
514 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
514 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
515              assertFalse(p.isTerminating());
516              done.countDown();
517          } finally {
# Line 551 | Line 546 | public class ThreadPoolExecutorTest exte
546                  tasks[i] = new FutureTask(task);
547                  p.execute(tasks[i]);
548              }
549 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
549 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
550              assertSame(q, p.getQueue());
551              assertFalse(q.contains(tasks[0]));
552              assertTrue(q.contains(tasks[tasks.length - 1]));
# Line 583 | Line 578 | public class ThreadPoolExecutorTest exte
578                      }};
579                  p.execute(tasks[i]);
580              }
581 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
581 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
582              assertFalse(p.remove(tasks[0]));
583              assertTrue(q.contains(tasks[4]));
584              assertTrue(q.contains(tasks[3]));
# Line 622 | Line 617 | public class ThreadPoolExecutorTest exte
617                  tasks[i] = new FutureTask(task);
618                  p.execute(tasks[i]);
619              }
620 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
620 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
621              assertEquals(tasks.length, p.getTaskCount());
622              assertEquals(tasks.length - 1, q.size());
623              assertEquals(1L, p.getActiveCount());
# Line 1044 | Line 1039 | public class ThreadPoolExecutorTest exte
1039                      p.submit(task).get();
1040                  }});
1041  
1042 <            assertTrue(threadStarted.await(SMALL_DELAY_MS, MILLISECONDS));
1042 >            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
1043              t.interrupt();
1044              awaitTermination(t, MEDIUM_DELAY_MS);
1045          } finally {

Diff Legend

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