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.99 by jsr166, Mon Oct 5 20:45:41 2015 UTC vs.
Revision 1.104 by jsr166, Mon Oct 5 22:54:45 2015 UTC

# Line 115 | Line 115 | public class ThreadPoolExecutorTest exte
115                      assertEquals(1, p.getActiveCount());
116                      done.await();
117                  }});
118 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
118 >            assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
119              assertEquals(1, p.getActiveCount());
120              done.countDown();
121          }
# Line 329 | Line 329 | public class ThreadPoolExecutorTest exte
329       */
330      public void testGetLargestPoolSize() throws InterruptedException {
331          final int THREADS = 3;
332 +        final CountDownLatch done = new CountDownLatch(1);
333          final ThreadPoolExecutor p =
334              new ThreadPoolExecutor(THREADS, THREADS,
335                                     LONG_DELAY_MS, MILLISECONDS,
336                                     new ArrayBlockingQueue<Runnable>(10));
337 <        try (PoolCleaner cleaner = cleaner(p)) {
337 <            final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
338 <            final CountDownLatch done = new CountDownLatch(1);
337 >        try (PoolCleaner cleaner = cleaner(p, done)) {
338              assertEquals(0, p.getLargestPoolSize());
339 +            final CountDownLatch threadsStarted = new CountDownLatch(THREADS);
340              for (int i = 0; i < THREADS; i++)
341                  p.execute(new CheckedRunnable() {
342                      public void realRun() throws InterruptedException {
# Line 344 | Line 344 | public class ThreadPoolExecutorTest exte
344                          done.await();
345                          assertEquals(THREADS, p.getLargestPoolSize());
346                      }});
347 <            assertTrue(threadsStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
347 >            assertTrue(threadsStarted.await(LONG_DELAY_MS, MILLISECONDS));
348              assertEquals(THREADS, p.getLargestPoolSize());
349 –            done.countDown();   // release pool
349          }
350          assertEquals(THREADS, p.getLargestPoolSize());
351      }
# Line 374 | Line 373 | public class ThreadPoolExecutorTest exte
373       * become active
374       */
375      public void testGetPoolSize() throws InterruptedException {
376 +        final CountDownLatch done = new CountDownLatch(1);
377          final ThreadPoolExecutor p =
378              new ThreadPoolExecutor(1, 1,
379                                     LONG_DELAY_MS, MILLISECONDS,
380                                     new ArrayBlockingQueue<Runnable>(10));
381 <        try (PoolCleaner cleaner = cleaner(p)) {
382 <            final CountDownLatch threadStarted = new CountDownLatch(1);
383 <            final CountDownLatch done = new CountDownLatch(1);
381 >        try (PoolCleaner cleaner = cleaner(p, done)) {
382              assertEquals(0, p.getPoolSize());
383 +            final CountDownLatch threadStarted = new CountDownLatch(1);
384              p.execute(new CheckedRunnable() {
385                  public void realRun() throws InterruptedException {
386                      threadStarted.countDown();
387                      assertEquals(1, p.getPoolSize());
388                      done.await();
389                  }});
390 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
390 >            assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
391              assertEquals(1, p.getPoolSize());
393 –            done.countDown();   // release pool
392          }
393      }
394  
# Line 398 | Line 396 | public class ThreadPoolExecutorTest exte
396       * getTaskCount increases, but doesn't overestimate, when tasks submitted
397       */
398      public void testGetTaskCount() throws InterruptedException {
399 +        final int TASKS = 3;
400 +        final CountDownLatch done = new CountDownLatch(1);
401          final ThreadPoolExecutor p =
402              new ThreadPoolExecutor(1, 1,
403                                     LONG_DELAY_MS, MILLISECONDS,
404                                     new ArrayBlockingQueue<Runnable>(10));
405 <        try (PoolCleaner cleaner = cleaner(p)) {
405 >        try (PoolCleaner cleaner = cleaner(p, done)) {
406              final CountDownLatch threadStarted = new CountDownLatch(1);
407 –            final CountDownLatch done = new CountDownLatch(1);
407              assertEquals(0, p.getTaskCount());
408 +            assertEquals(0, p.getCompletedTaskCount());
409              p.execute(new CheckedRunnable() {
410                  public void realRun() throws InterruptedException {
411                      threadStarted.countDown();
412 –                    assertEquals(1, p.getTaskCount());
412                      done.await();
413                  }});
414 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
414 >            assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
415              assertEquals(1, p.getTaskCount());
416 <            done.countDown();
416 >            assertEquals(0, p.getCompletedTaskCount());
417 >            for (int i = 0; i < TASKS; i++) {
418 >                assertEquals(1 + i, p.getTaskCount());
419 >                p.execute(new CheckedRunnable() {
420 >                    public void realRun() throws InterruptedException {
421 >                        threadStarted.countDown();
422 >                        assertEquals(1 + TASKS, p.getTaskCount());
423 >                        done.await();
424 >                    }});
425 >            }
426 >            assertEquals(1 + TASKS, p.getTaskCount());
427 >            assertEquals(0, p.getCompletedTaskCount());
428          }
429 +        assertEquals(1 + TASKS, p.getTaskCount());
430 +        assertEquals(1 + TASKS, p.getCompletedTaskCount());
431      }
432  
433      /**
# Line 483 | Line 495 | public class ThreadPoolExecutorTest exte
495                      threadStarted.countDown();
496                      done.await();
497                  }});
498 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
498 >            assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
499              assertFalse(p.isTerminating());
500              done.countDown();
501              try { p.shutdown(); } catch (SecurityException ok) { return; }
# Line 511 | Line 523 | public class ThreadPoolExecutorTest exte
523                      threadStarted.countDown();
524                      done.await();
525                  }});
526 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
526 >            assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
527              assertFalse(p.isTerminating());
528              done.countDown();
529              try { p.shutdown(); } catch (SecurityException ok) { return; }
# Line 545 | Line 557 | public class ThreadPoolExecutorTest exte
557                  tasks[i] = new FutureTask(task);
558                  p.execute(tasks[i]);
559              }
560 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
560 >            assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
561              assertSame(q, p.getQueue());
562              assertFalse(q.contains(tasks[0]));
563              assertTrue(q.contains(tasks[tasks.length - 1]));
# Line 575 | Line 587 | public class ThreadPoolExecutorTest exte
587                      }};
588                  p.execute(tasks[i]);
589              }
590 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
590 >            assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
591              assertFalse(p.remove(tasks[0]));
592              assertTrue(q.contains(tasks[4]));
593              assertTrue(q.contains(tasks[3]));
# Line 600 | Line 612 | public class ThreadPoolExecutorTest exte
612              new ThreadPoolExecutor(1, 1,
613                                     LONG_DELAY_MS, MILLISECONDS,
614                                     q);
615 <        try (PoolCleaner cleaner = cleaner(p)) {
615 >        try (PoolCleaner cleaner = cleaner(p, done)) {
616              FutureTask[] tasks = new FutureTask[5];
617              for (int i = 0; i < tasks.length; i++) {
618                  Callable task = new CheckedCallable<Boolean>() {
# Line 612 | Line 624 | public class ThreadPoolExecutorTest exte
624                  tasks[i] = new FutureTask(task);
625                  p.execute(tasks[i]);
626              }
627 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
627 >            assertTrue(threadStarted.await(LONG_DELAY_MS, MILLISECONDS));
628              assertEquals(tasks.length, p.getTaskCount());
629              assertEquals(tasks.length - 1, q.size());
630              assertEquals(1L, p.getActiveCount());
# Line 625 | Line 637 | public class ThreadPoolExecutorTest exte
637              p.purge();         // Nothing to do
638              assertEquals(tasks.length - 3, q.size());
639              assertEquals(tasks.length - 2, p.getTaskCount());
628 –            done.countDown();
640          }
641      }
642  
# Line 1013 | Line 1024 | public class ThreadPoolExecutorTest exte
1024       * get of submitted callable throws InterruptedException if interrupted
1025       */
1026      public void testInterruptedSubmit() throws InterruptedException {
1027 +        final CountDownLatch done = new CountDownLatch(1);
1028          final ThreadPoolExecutor p =
1029              new ThreadPoolExecutor(1, 1,
1030                                     60, SECONDS,
1031                                     new ArrayBlockingQueue<Runnable>(10));
1032  
1033 <        try (PoolCleaner cleaner = cleaner(p)) {
1033 >        try (PoolCleaner cleaner = cleaner(p, done)) {
1034              final CountDownLatch threadStarted = new CountDownLatch(1);
1023 –            final CountDownLatch done = new CountDownLatch(1);
1035              Thread t = newStartedThread(new CheckedInterruptedRunnable() {
1036                  public void realRun() throws Exception {
1037                      Callable task = new CheckedCallable<Boolean>() {
# Line 1032 | Line 1043 | public class ThreadPoolExecutorTest exte
1043                      p.submit(task).get();
1044                  }});
1045  
1046 <            assertTrue(threadStarted.await(MEDIUM_DELAY_MS, MILLISECONDS));
1046 >            await(threadStarted);
1047              t.interrupt();
1048 <            awaitTermination(t, MEDIUM_DELAY_MS);
1038 <            done.countDown();
1048 >            awaitTermination(t);
1049          }
1050      }
1051  

Diff Legend

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