| /* |
| * Written by Doug Lea with assistance from members of JCP JSR-166 |
| * Expert Group and released to the public domain, as explained at |
| * http://creativecommons.org/licenses/publicdomain |
| * Other contributors include Andrew Wright, Jeffrey Hayes, |
| * Pat Fisher, Mike Judd. |
| */ |
| |
| import java.util.concurrent.*; |
| import java.util.concurrent.atomic.*; |
| import junit.framework.*; |
| import java.util.*; |
| |
| public class ThreadPoolExecutorTest extends JSR166TestCase { |
| public static void main(String[] args) { |
| junit.textui.TestRunner.run (suite()); |
| } |
| public static Test suite() { |
| return new TestSuite(ThreadPoolExecutorTest.class); |
| } |
| |
| static class ExtendedTPE extends ThreadPoolExecutor { |
| volatile boolean beforeCalled = false; |
| volatile boolean afterCalled = false; |
| volatile boolean terminatedCalled = false; |
| public ExtendedTPE() { |
| super(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>()); |
| } |
| protected void beforeExecute(Thread t, Runnable r) { |
| beforeCalled = true; |
| } |
| protected void afterExecute(Runnable r, Throwable t) { |
| afterCalled = true; |
| } |
| protected void terminated() { |
| terminatedCalled = true; |
| } |
| } |
| |
| static class FailingThreadFactory implements ThreadFactory{ |
| int calls = 0; |
| public Thread newThread(Runnable r){ |
| if (++calls > 1) return null; |
| return new Thread(r); |
| } |
| } |
| |
| |
| /** |
| * execute successfully executes a runnable |
| */ |
| public void testExecute() { |
| ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| p1.execute(new Runnable() { |
| public void run() { |
| try { |
| Thread.sleep(SHORT_DELAY_MS); |
| } catch(InterruptedException e){ |
| threadUnexpectedException(); |
| } |
| } |
| }); |
| Thread.sleep(SMALL_DELAY_MS); |
| } catch(InterruptedException e){ |
| unexpectedException(); |
| } |
| joinPool(p1); |
| } |
| |
| /** |
| * getActiveCount increases but doesn't overestimate, when a |
| * thread becomes active |
| */ |
| public void testGetActiveCount() { |
| ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| assertEquals(0, p2.getActiveCount()); |
| p2.execute(new MediumRunnable()); |
| try { |
| Thread.sleep(SHORT_DELAY_MS); |
| } catch(Exception e){ |
| unexpectedException(); |
| } |
| assertEquals(1, p2.getActiveCount()); |
| joinPool(p2); |
| } |
| |
| /** |
| * prestartCoreThread starts a thread if under corePoolSize, else doesn't |
| */ |
| public void testPrestartCoreThread() { |
| ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| assertEquals(0, p2.getPoolSize()); |
| assertTrue(p2.prestartCoreThread()); |
| assertEquals(1, p2.getPoolSize()); |
| assertTrue(p2.prestartCoreThread()); |
| assertEquals(2, p2.getPoolSize()); |
| assertFalse(p2.prestartCoreThread()); |
| assertEquals(2, p2.getPoolSize()); |
| joinPool(p2); |
| } |
| |
| /** |
| * prestartAllCoreThreads starts all corePoolSize threads |
| */ |
| public void testPrestartAllCoreThreads() { |
| ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| assertEquals(0, p2.getPoolSize()); |
| p2.prestartAllCoreThreads(); |
| assertEquals(2, p2.getPoolSize()); |
| p2.prestartAllCoreThreads(); |
| assertEquals(2, p2.getPoolSize()); |
| joinPool(p2); |
| } |
| |
| /** |
| * getCompletedTaskCount increases, but doesn't overestimate, |
| * when tasks complete |
| */ |
| public void testGetCompletedTaskCount() { |
| ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| assertEquals(0, p2.getCompletedTaskCount()); |
| p2.execute(new ShortRunnable()); |
| try { |
| Thread.sleep(SMALL_DELAY_MS); |
| } catch(Exception e){ |
| unexpectedException(); |
| } |
| assertEquals(1, p2.getCompletedTaskCount()); |
| try { p2.shutdown(); } catch(SecurityException ok) { return; } |
| joinPool(p2); |
| } |
| |
| /** |
| * getCorePoolSize returns size given in constructor if not otherwise set |
| */ |
| public void testGetCorePoolSize() { |
| ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| assertEquals(1, p1.getCorePoolSize()); |
| joinPool(p1); |
| } |
| |
| /** |
| * getKeepAliveTime returns value given in constructor if not otherwise set |
| */ |
| public void testGetKeepAliveTime() { |
| ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| assertEquals(1, p2.getKeepAliveTime(TimeUnit.SECONDS)); |
| joinPool(p2); |
| } |
| |
| |
| /** |
| * getThreadFactory returns factory in constructor if not set |
| */ |
| public void testGetThreadFactory() { |
| ThreadFactory tf = new SimpleThreadFactory(); |
| ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), tf, new NoOpREHandler()); |
| assertSame(tf, p.getThreadFactory()); |
| joinPool(p); |
| } |
| |
| /** |
| * setThreadFactory sets the thread factory returned by getThreadFactory |
| */ |
| public void testSetThreadFactory() { |
| ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| ThreadFactory tf = new SimpleThreadFactory(); |
| p.setThreadFactory(tf); |
| assertSame(tf, p.getThreadFactory()); |
| joinPool(p); |
| } |
| |
| |
| /** |
| * setThreadFactory(null) throws NPE |
| */ |
| public void testSetThreadFactoryNull() { |
| ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| p.setThreadFactory(null); |
| shouldThrow(); |
| } catch (NullPointerException success) { |
| } finally { |
| joinPool(p); |
| } |
| } |
| |
| /** |
| * getRejectedExecutionHandler returns handler in constructor if not set |
| */ |
| public void testGetRejectedExecutionHandler() { |
| RejectedExecutionHandler h = new NoOpREHandler(); |
| ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10), h); |
| assertSame(h, p.getRejectedExecutionHandler()); |
| joinPool(p); |
| } |
| |
| /** |
| * setRejectedExecutionHandler sets the handler returned by |
| * getRejectedExecutionHandler |
| */ |
| public void testSetRejectedExecutionHandler() { |
| ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| RejectedExecutionHandler h = new NoOpREHandler(); |
| p.setRejectedExecutionHandler(h); |
| assertSame(h, p.getRejectedExecutionHandler()); |
| joinPool(p); |
| } |
| |
| |
| /** |
| * setRejectedExecutionHandler(null) throws NPE |
| */ |
| public void testSetRejectedExecutionHandlerNull() { |
| ThreadPoolExecutor p = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| p.setRejectedExecutionHandler(null); |
| shouldThrow(); |
| } catch (NullPointerException success) { |
| } finally { |
| joinPool(p); |
| } |
| } |
| |
| |
| /** |
| * getLargestPoolSize increases, but doesn't overestimate, when |
| * multiple threads active |
| */ |
| public void testGetLargestPoolSize() { |
| ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| assertEquals(0, p2.getLargestPoolSize()); |
| p2.execute(new MediumRunnable()); |
| p2.execute(new MediumRunnable()); |
| Thread.sleep(SHORT_DELAY_MS); |
| assertEquals(2, p2.getLargestPoolSize()); |
| } catch(Exception e){ |
| unexpectedException(); |
| } |
| joinPool(p2); |
| } |
| |
| /** |
| * getMaximumPoolSize returns value given in constructor if not |
| * otherwise set |
| */ |
| public void testGetMaximumPoolSize() { |
| ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| assertEquals(2, p2.getMaximumPoolSize()); |
| joinPool(p2); |
| } |
| |
| /** |
| * getPoolSize increases, but doesn't overestimate, when threads |
| * become active |
| */ |
| public void testGetPoolSize() { |
| ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| assertEquals(0, p1.getPoolSize()); |
| p1.execute(new MediumRunnable()); |
| assertEquals(1, p1.getPoolSize()); |
| joinPool(p1); |
| } |
| |
| /** |
| * getTaskCount increases, but doesn't overestimate, when tasks submitted |
| */ |
| public void testGetTaskCount() { |
| ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| assertEquals(0, p1.getTaskCount()); |
| p1.execute(new MediumRunnable()); |
| Thread.sleep(SHORT_DELAY_MS); |
| assertEquals(1, p1.getTaskCount()); |
| } catch(Exception e){ |
| unexpectedException(); |
| } |
| joinPool(p1); |
| } |
| |
| /** |
| * isShutDown is false before shutdown, true after |
| */ |
| public void testIsShutdown() { |
| |
| ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| assertFalse(p1.isShutdown()); |
| try { p1.shutdown(); } catch(SecurityException ok) { return; } |
| assertTrue(p1.isShutdown()); |
| joinPool(p1); |
| } |
| |
| |
| /** |
| * isTerminated is false before termination, true after |
| */ |
| public void testIsTerminated() { |
| ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| assertFalse(p1.isTerminated()); |
| try { |
| p1.execute(new MediumRunnable()); |
| } finally { |
| try { p1.shutdown(); } catch(SecurityException ok) { return; } |
| } |
| try { |
| assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS)); |
| assertTrue(p1.isTerminated()); |
| } catch(Exception e){ |
| unexpectedException(); |
| } |
| } |
| |
| /** |
| * isTerminating is not true when running or when terminated |
| */ |
| public void testIsTerminating() { |
| ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| assertFalse(p1.isTerminating()); |
| try { |
| p1.execute(new SmallRunnable()); |
| assertFalse(p1.isTerminating()); |
| } finally { |
| try { p1.shutdown(); } catch(SecurityException ok) { return; } |
| } |
| try { |
| assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS)); |
| assertTrue(p1.isTerminated()); |
| assertFalse(p1.isTerminating()); |
| } catch(Exception e){ |
| unexpectedException(); |
| } |
| } |
| |
| /** |
| * getQueue returns the work queue, which contains queued tasks |
| */ |
| public void testGetQueue() { |
| BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10); |
| ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, q); |
| FutureTask[] tasks = new FutureTask[5]; |
| for(int i = 0; i < 5; i++){ |
| tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE); |
| p1.execute(tasks[i]); |
| } |
| try { |
| Thread.sleep(SHORT_DELAY_MS); |
| BlockingQueue<Runnable> wq = p1.getQueue(); |
| assertSame(q, wq); |
| assertFalse(wq.contains(tasks[0])); |
| assertTrue(wq.contains(tasks[4])); |
| for (int i = 1; i < 5; ++i) |
| tasks[i].cancel(true); |
| p1.shutdownNow(); |
| } catch(Exception e) { |
| unexpectedException(); |
| } finally { |
| joinPool(p1); |
| } |
| } |
| |
| /** |
| * remove(task) removes queued task, and fails to remove active task |
| */ |
| public void testRemove() { |
| BlockingQueue<Runnable> q = new ArrayBlockingQueue<Runnable>(10); |
| ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, q); |
| FutureTask[] tasks = new FutureTask[5]; |
| for(int i = 0; i < 5; i++){ |
| tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE); |
| p1.execute(tasks[i]); |
| } |
| try { |
| Thread.sleep(SHORT_DELAY_MS); |
| assertFalse(p1.remove(tasks[0])); |
| assertTrue(q.contains(tasks[4])); |
| assertTrue(q.contains(tasks[3])); |
| assertTrue(p1.remove(tasks[4])); |
| assertFalse(p1.remove(tasks[4])); |
| assertFalse(q.contains(tasks[4])); |
| assertTrue(q.contains(tasks[3])); |
| assertTrue(p1.remove(tasks[3])); |
| assertFalse(q.contains(tasks[3])); |
| } catch(Exception e) { |
| unexpectedException(); |
| } finally { |
| joinPool(p1); |
| } |
| } |
| |
| /** |
| * purge removes cancelled tasks from the queue |
| */ |
| public void testPurge() { |
| ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| FutureTask[] tasks = new FutureTask[5]; |
| for(int i = 0; i < 5; i++){ |
| tasks[i] = new FutureTask(new MediumPossiblyInterruptedRunnable(), Boolean.TRUE); |
| p1.execute(tasks[i]); |
| } |
| tasks[4].cancel(true); |
| tasks[3].cancel(true); |
| p1.purge(); |
| long count = p1.getTaskCount(); |
| assertTrue(count >= 2 && count < 5); |
| joinPool(p1); |
| } |
| |
| /** |
| * shutDownNow returns a list containing tasks that were not run |
| */ |
| public void testShutDownNow() { |
| ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| List l; |
| try { |
| for(int i = 0; i < 5; i++) |
| p1.execute(new MediumPossiblyInterruptedRunnable()); |
| } |
| finally { |
| try { |
| l = p1.shutdownNow(); |
| } catch (SecurityException ok) { return; } |
| |
| } |
| assertTrue(p1.isShutdown()); |
| assertTrue(l.size() <= 4); |
| } |
| |
| // Exception Tests |
| |
| |
| /** |
| * Constructor throws if corePoolSize argument is less than zero |
| */ |
| public void testConstructor1() { |
| try { |
| new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| shouldThrow(); |
| } |
| catch (IllegalArgumentException success){} |
| } |
| |
| /** |
| * Constructor throws if maximumPoolSize is less than zero |
| */ |
| public void testConstructor2() { |
| try { |
| new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| shouldThrow(); |
| } |
| catch (IllegalArgumentException success){} |
| } |
| |
| /** |
| * Constructor throws if maximumPoolSize is equal to zero |
| */ |
| public void testConstructor3() { |
| try { |
| new ThreadPoolExecutor(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| shouldThrow(); |
| } |
| catch (IllegalArgumentException success){} |
| } |
| |
| /** |
| * Constructor throws if keepAliveTime is less than zero |
| */ |
| public void testConstructor4() { |
| try { |
| new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| shouldThrow(); |
| } |
| catch (IllegalArgumentException success){} |
| } |
| |
| /** |
| * Constructor throws if corePoolSize is greater than the maximumPoolSize |
| */ |
| public void testConstructor5() { |
| try { |
| new ThreadPoolExecutor(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| shouldThrow(); |
| } |
| catch (IllegalArgumentException success){} |
| } |
| |
| /** |
| * Constructor throws if workQueue is set to null |
| */ |
| public void testConstructorNullPointerException() { |
| try { |
| new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null); |
| shouldThrow(); |
| } |
| catch (NullPointerException success){} |
| } |
| |
| |
| |
| /** |
| * Constructor throws if corePoolSize argument is less than zero |
| */ |
| public void testConstructor6() { |
| try { |
| new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory()); |
| shouldThrow(); |
| } catch (IllegalArgumentException success){} |
| } |
| |
| /** |
| * Constructor throws if maximumPoolSize is less than zero |
| */ |
| public void testConstructor7() { |
| try { |
| new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory()); |
| shouldThrow(); |
| } |
| catch (IllegalArgumentException success){} |
| } |
| |
| /** |
| * Constructor throws if maximumPoolSize is equal to zero |
| */ |
| public void testConstructor8() { |
| try { |
| new ThreadPoolExecutor(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory()); |
| shouldThrow(); |
| } |
| catch (IllegalArgumentException success){} |
| } |
| |
| /** |
| * Constructor throws if keepAliveTime is less than zero |
| */ |
| public void testConstructor9() { |
| try { |
| new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory()); |
| shouldThrow(); |
| } |
| catch (IllegalArgumentException success){} |
| } |
| |
| /** |
| * Constructor throws if corePoolSize is greater than the maximumPoolSize |
| */ |
| public void testConstructor10() { |
| try { |
| new ThreadPoolExecutor(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory()); |
| shouldThrow(); |
| } |
| catch (IllegalArgumentException success){} |
| } |
| |
| /** |
| * Constructor throws if workQueue is set to null |
| */ |
| public void testConstructorNullPointerException2() { |
| try { |
| new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new SimpleThreadFactory()); |
| shouldThrow(); |
| } |
| catch (NullPointerException success){} |
| } |
| |
| /** |
| * Constructor throws if threadFactory is set to null |
| */ |
| public void testConstructorNullPointerException3() { |
| try { |
| ThreadFactory f = null; |
| new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f); |
| shouldThrow(); |
| } |
| catch (NullPointerException success){} |
| } |
| |
| |
| /** |
| * Constructor throws if corePoolSize argument is less than zero |
| */ |
| public void testConstructor11() { |
| try { |
| new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler()); |
| shouldThrow(); |
| } |
| catch (IllegalArgumentException success){} |
| } |
| |
| /** |
| * Constructor throws if maximumPoolSize is less than zero |
| */ |
| public void testConstructor12() { |
| try { |
| new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler()); |
| shouldThrow(); |
| } |
| catch (IllegalArgumentException success){} |
| } |
| |
| /** |
| * Constructor throws if maximumPoolSize is equal to zero |
| */ |
| public void testConstructor13() { |
| try { |
| new ThreadPoolExecutor(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler()); |
| shouldThrow(); |
| } |
| catch (IllegalArgumentException success){} |
| } |
| |
| /** |
| * Constructor throws if keepAliveTime is less than zero |
| */ |
| public void testConstructor14() { |
| try { |
| new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler()); |
| shouldThrow(); |
| } |
| catch (IllegalArgumentException success){} |
| } |
| |
| /** |
| * Constructor throws if corePoolSize is greater than the maximumPoolSize |
| */ |
| public void testConstructor15() { |
| try { |
| new ThreadPoolExecutor(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new NoOpREHandler()); |
| shouldThrow(); |
| } |
| catch (IllegalArgumentException success){} |
| } |
| |
| /** |
| * Constructor throws if workQueue is set to null |
| */ |
| public void testConstructorNullPointerException4() { |
| try { |
| new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new NoOpREHandler()); |
| shouldThrow(); |
| } |
| catch (NullPointerException success){} |
| } |
| |
| /** |
| * Constructor throws if handler is set to null |
| */ |
| public void testConstructorNullPointerException5() { |
| try { |
| RejectedExecutionHandler r = null; |
| new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),r); |
| shouldThrow(); |
| } |
| catch (NullPointerException success){} |
| } |
| |
| |
| /** |
| * Constructor throws if corePoolSize argument is less than zero |
| */ |
| public void testConstructor16() { |
| try { |
| new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler()); |
| shouldThrow(); |
| } |
| catch (IllegalArgumentException success){} |
| } |
| |
| /** |
| * Constructor throws if maximumPoolSize is less than zero |
| */ |
| public void testConstructor17() { |
| try { |
| new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler()); |
| shouldThrow(); |
| } |
| catch (IllegalArgumentException success){} |
| } |
| |
| /** |
| * Constructor throws if maximumPoolSize is equal to zero |
| */ |
| public void testConstructor18() { |
| try { |
| new ThreadPoolExecutor(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler()); |
| shouldThrow(); |
| } |
| catch (IllegalArgumentException success){} |
| } |
| |
| /** |
| * Constructor throws if keepAliveTime is less than zero |
| */ |
| public void testConstructor19() { |
| try { |
| new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler()); |
| shouldThrow(); |
| } |
| catch (IllegalArgumentException success){} |
| } |
| |
| /** |
| * Constructor throws if corePoolSize is greater than the maximumPoolSize |
| */ |
| public void testConstructor20() { |
| try { |
| new ThreadPoolExecutor(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),new NoOpREHandler()); |
| shouldThrow(); |
| } |
| catch (IllegalArgumentException success){} |
| } |
| |
| /** |
| * Constructor throws if workQueue is set to null |
| */ |
| public void testConstructorNullPointerException6() { |
| try { |
| new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,null,new SimpleThreadFactory(),new NoOpREHandler()); |
| shouldThrow(); |
| } |
| catch (NullPointerException success){} |
| } |
| |
| /** |
| * Constructor throws if handler is set to null |
| */ |
| public void testConstructorNullPointerException7() { |
| try { |
| RejectedExecutionHandler r = null; |
| new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),new SimpleThreadFactory(),r); |
| shouldThrow(); |
| } |
| catch (NullPointerException success){} |
| } |
| |
| /** |
| * Constructor throws if ThreadFactory is set top null |
| */ |
| public void testConstructorNullPointerException8() { |
| try { |
| ThreadFactory f = null; |
| new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f,new NoOpREHandler()); |
| shouldThrow(); |
| } |
| catch (NullPointerException successdn8){} |
| } |
| |
| |
| /** |
| * execute throws RejectedExecutionException |
| * if saturated. |
| */ |
| public void testSaturatedExecute() { |
| ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1)); |
| try { |
| |
| for(int i = 0; i < 5; ++i){ |
| p.execute(new MediumRunnable()); |
| } |
| shouldThrow(); |
| } catch(RejectedExecutionException success){} |
| joinPool(p); |
| } |
| |
| /** |
| * executor using CallerRunsPolicy runs task if saturated. |
| */ |
| public void testSaturatedExecute2() { |
| RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy(); |
| ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); |
| try { |
| |
| TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5]; |
| for(int i = 0; i < 5; ++i){ |
| tasks[i] = new TrackedNoOpRunnable(); |
| } |
| TrackedLongRunnable mr = new TrackedLongRunnable(); |
| p.execute(mr); |
| for(int i = 0; i < 5; ++i){ |
| p.execute(tasks[i]); |
| } |
| for(int i = 1; i < 5; ++i) { |
| assertTrue(tasks[i].done); |
| } |
| try { p.shutdownNow(); } catch(SecurityException ok) { return; } |
| } catch(RejectedExecutionException ex){ |
| unexpectedException(); |
| } finally { |
| joinPool(p); |
| } |
| } |
| |
| /** |
| * executor using DiscardPolicy drops task if saturated. |
| */ |
| public void testSaturatedExecute3() { |
| RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardPolicy(); |
| ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); |
| try { |
| |
| TrackedNoOpRunnable[] tasks = new TrackedNoOpRunnable[5]; |
| for(int i = 0; i < 5; ++i){ |
| tasks[i] = new TrackedNoOpRunnable(); |
| } |
| p.execute(new TrackedLongRunnable()); |
| for(int i = 0; i < 5; ++i){ |
| p.execute(tasks[i]); |
| } |
| for(int i = 0; i < 5; ++i){ |
| assertFalse(tasks[i].done); |
| } |
| try { p.shutdownNow(); } catch(SecurityException ok) { return; } |
| } catch(RejectedExecutionException ex){ |
| unexpectedException(); |
| } finally { |
| joinPool(p); |
| } |
| } |
| |
| /** |
| * executor using DiscardOldestPolicy drops oldest task if saturated. |
| */ |
| public void testSaturatedExecute4() { |
| RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardOldestPolicy(); |
| ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); |
| try { |
| p.execute(new TrackedLongRunnable()); |
| TrackedLongRunnable r2 = new TrackedLongRunnable(); |
| p.execute(r2); |
| assertTrue(p.getQueue().contains(r2)); |
| TrackedNoOpRunnable r3 = new TrackedNoOpRunnable(); |
| p.execute(r3); |
| assertFalse(p.getQueue().contains(r2)); |
| assertTrue(p.getQueue().contains(r3)); |
| try { p.shutdownNow(); } catch(SecurityException ok) { return; } |
| } catch(RejectedExecutionException ex){ |
| unexpectedException(); |
| } finally { |
| joinPool(p); |
| } |
| } |
| |
| /** |
| * execute throws RejectedExecutionException if shutdown |
| */ |
| public void testRejectedExecutionExceptionOnShutdown() { |
| ThreadPoolExecutor tpe = |
| new ThreadPoolExecutor(1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(1)); |
| try { tpe.shutdown(); } catch(SecurityException ok) { return; } |
| try { |
| tpe.execute(new NoOpRunnable()); |
| shouldThrow(); |
| } catch(RejectedExecutionException success){} |
| |
| joinPool(tpe); |
| } |
| |
| /** |
| * execute using CallerRunsPolicy drops task on shutdown |
| */ |
| public void testCallerRunsOnShutdown() { |
| RejectedExecutionHandler h = new ThreadPoolExecutor.CallerRunsPolicy(); |
| ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); |
| |
| try { p.shutdown(); } catch(SecurityException ok) { return; } |
| try { |
| TrackedNoOpRunnable r = new TrackedNoOpRunnable(); |
| p.execute(r); |
| assertFalse(r.done); |
| } catch(RejectedExecutionException success){ |
| unexpectedException(); |
| } finally { |
| joinPool(p); |
| } |
| } |
| |
| /** |
| * execute using DiscardPolicy drops task on shutdown |
| */ |
| public void testDiscardOnShutdown() { |
| RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardPolicy(); |
| ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); |
| |
| try { p.shutdown(); } catch(SecurityException ok) { return; } |
| try { |
| TrackedNoOpRunnable r = new TrackedNoOpRunnable(); |
| p.execute(r); |
| assertFalse(r.done); |
| } catch(RejectedExecutionException success){ |
| unexpectedException(); |
| } finally { |
| joinPool(p); |
| } |
| } |
| |
| |
| /** |
| * execute using DiscardOldestPolicy drops task on shutdown |
| */ |
| public void testDiscardOldestOnShutdown() { |
| RejectedExecutionHandler h = new ThreadPoolExecutor.DiscardOldestPolicy(); |
| ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1), h); |
| |
| try { p.shutdown(); } catch(SecurityException ok) { return; } |
| try { |
| TrackedNoOpRunnable r = new TrackedNoOpRunnable(); |
| p.execute(r); |
| assertFalse(r.done); |
| } catch(RejectedExecutionException success){ |
| unexpectedException(); |
| } finally { |
| joinPool(p); |
| } |
| } |
| |
| |
| /** |
| * execute (null) throws NPE |
| */ |
| public void testExecuteNull() { |
| ThreadPoolExecutor tpe = null; |
| try { |
| tpe = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10)); |
| tpe.execute(null); |
| shouldThrow(); |
| } catch(NullPointerException success){} |
| |
| joinPool(tpe); |
| } |
| |
| /** |
| * setCorePoolSize of negative value throws IllegalArgumentException |
| */ |
| public void testCorePoolSizeIllegalArgumentException() { |
| ThreadPoolExecutor tpe = null; |
| try { |
| tpe = new ThreadPoolExecutor(1,2,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10)); |
| } catch(Exception e){} |
| try { |
| tpe.setCorePoolSize(-1); |
| shouldThrow(); |
| } catch(IllegalArgumentException success){ |
| } finally { |
| try { tpe.shutdown(); } catch(SecurityException ok) { return; } |
| } |
| joinPool(tpe); |
| } |
| |
| /** |
| * setMaximumPoolSize(int) throws IllegalArgumentException if |
| * given a value less the core pool size |
| */ |
| public void testMaximumPoolSizeIllegalArgumentException() { |
| ThreadPoolExecutor tpe = null; |
| try { |
| tpe = new ThreadPoolExecutor(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10)); |
| } catch(Exception e){} |
| try { |
| tpe.setMaximumPoolSize(1); |
| shouldThrow(); |
| } catch(IllegalArgumentException success){ |
| } finally { |
| try { tpe.shutdown(); } catch(SecurityException ok) { return; } |
| } |
| joinPool(tpe); |
| } |
| |
| /** |
| * setMaximumPoolSize throws IllegalArgumentException |
| * if given a negative value |
| */ |
| public void testMaximumPoolSizeIllegalArgumentException2() { |
| ThreadPoolExecutor tpe = null; |
| try { |
| tpe = new ThreadPoolExecutor(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10)); |
| } catch(Exception e){} |
| try { |
| tpe.setMaximumPoolSize(-1); |
| shouldThrow(); |
| } catch(IllegalArgumentException success){ |
| } finally { |
| try { tpe.shutdown(); } catch(SecurityException ok) { return; } |
| } |
| joinPool(tpe); |
| } |
| |
| |
| /** |
| * setKeepAliveTime throws IllegalArgumentException |
| * when given a negative value |
| */ |
| public void testKeepAliveTimeIllegalArgumentException() { |
| ThreadPoolExecutor tpe = null; |
| try { |
| tpe = new ThreadPoolExecutor(2,3,LONG_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10)); |
| } catch(Exception e){} |
| |
| try { |
| tpe.setKeepAliveTime(-1,TimeUnit.MILLISECONDS); |
| shouldThrow(); |
| } catch(IllegalArgumentException success){ |
| } finally { |
| try { tpe.shutdown(); } catch(SecurityException ok) { return; } |
| } |
| joinPool(tpe); |
| } |
| |
| /** |
| * terminated() is called on termination |
| */ |
| public void testTerminated() { |
| ExtendedTPE tpe = new ExtendedTPE(); |
| try { tpe.shutdown(); } catch(SecurityException ok) { return; } |
| assertTrue(tpe.terminatedCalled); |
| joinPool(tpe); |
| } |
| |
| /** |
| * beforeExecute and afterExecute are called when executing task |
| */ |
| public void testBeforeAfter() { |
| ExtendedTPE tpe = new ExtendedTPE(); |
| try { |
| TrackedNoOpRunnable r = new TrackedNoOpRunnable(); |
| tpe.execute(r); |
| Thread.sleep(SHORT_DELAY_MS); |
| assertTrue(r.done); |
| assertTrue(tpe.beforeCalled); |
| assertTrue(tpe.afterCalled); |
| try { tpe.shutdown(); } catch(SecurityException ok) { return; } |
| } |
| catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(tpe); |
| } |
| } |
| |
| /** |
| * completed submit of callable returns result |
| */ |
| public void testSubmitCallable() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| Future<String> future = e.submit(new StringTask()); |
| String result = future.get(); |
| assertSame(TEST_STRING, result); |
| } |
| catch (ExecutionException ex) { |
| unexpectedException(); |
| } |
| catch (InterruptedException ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * completed submit of runnable returns successfully |
| */ |
| public void testSubmitRunnable() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| Future<?> future = e.submit(new NoOpRunnable()); |
| future.get(); |
| assertTrue(future.isDone()); |
| } |
| catch (ExecutionException ex) { |
| unexpectedException(); |
| } |
| catch (InterruptedException ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * completed submit of (runnable, result) returns result |
| */ |
| public void testSubmitRunnable2() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| Future<String> future = e.submit(new NoOpRunnable(), TEST_STRING); |
| String result = future.get(); |
| assertSame(TEST_STRING, result); |
| } |
| catch (ExecutionException ex) { |
| unexpectedException(); |
| } |
| catch (InterruptedException ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| |
| |
| |
| |
| /** |
| * invokeAny(null) throws NPE |
| */ |
| public void testInvokeAny1() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| e.invokeAny(null); |
| } catch (NullPointerException success) { |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * invokeAny(empty collection) throws IAE |
| */ |
| public void testInvokeAny2() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| e.invokeAny(new ArrayList<Callable<String>>()); |
| } catch (IllegalArgumentException success) { |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * invokeAny(c) throws NPE if c has null elements |
| */ |
| public void testInvokeAny3() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); |
| l.add(new StringTask()); |
| l.add(null); |
| e.invokeAny(l); |
| } catch (NullPointerException success) { |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * invokeAny(c) throws ExecutionException if no task completes |
| */ |
| public void testInvokeAny4() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); |
| l.add(new NPETask()); |
| e.invokeAny(l); |
| } catch (ExecutionException success) { |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * invokeAny(c) returns result of some task |
| */ |
| public void testInvokeAny5() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); |
| l.add(new StringTask()); |
| l.add(new StringTask()); |
| String result = e.invokeAny(l); |
| assertSame(TEST_STRING, result); |
| } catch (ExecutionException success) { |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * invokeAll(null) throws NPE |
| */ |
| public void testInvokeAll1() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| e.invokeAll(null); |
| } catch (NullPointerException success) { |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * invokeAll(empty collection) returns empty collection |
| */ |
| public void testInvokeAll2() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>()); |
| assertTrue(r.isEmpty()); |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * invokeAll(c) throws NPE if c has null elements |
| */ |
| public void testInvokeAll3() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); |
| l.add(new StringTask()); |
| l.add(null); |
| e.invokeAll(l); |
| } catch (NullPointerException success) { |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * get of element of invokeAll(c) throws exception on failed task |
| */ |
| public void testInvokeAll4() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); |
| l.add(new NPETask()); |
| List<Future<String>> result = e.invokeAll(l); |
| assertEquals(1, result.size()); |
| for (Iterator<Future<String>> it = result.iterator(); it.hasNext();) |
| it.next().get(); |
| } catch(ExecutionException success) { |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * invokeAll(c) returns results of all completed tasks |
| */ |
| public void testInvokeAll5() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); |
| l.add(new StringTask()); |
| l.add(new StringTask()); |
| List<Future<String>> result = e.invokeAll(l); |
| assertEquals(2, result.size()); |
| for (Iterator<Future<String>> it = result.iterator(); it.hasNext();) |
| assertSame(TEST_STRING, it.next().get()); |
| } catch (ExecutionException success) { |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| |
| |
| /** |
| * timed invokeAny(null) throws NPE |
| */ |
| public void testTimedInvokeAny1() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| e.invokeAny(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); |
| } catch (NullPointerException success) { |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * timed invokeAny(,,null) throws NPE |
| */ |
| public void testTimedInvokeAnyNullTimeUnit() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); |
| l.add(new StringTask()); |
| e.invokeAny(l, MEDIUM_DELAY_MS, null); |
| } catch (NullPointerException success) { |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * timed invokeAny(empty collection) throws IAE |
| */ |
| public void testTimedInvokeAny2() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| e.invokeAny(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); |
| } catch (IllegalArgumentException success) { |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * timed invokeAny(c) throws NPE if c has null elements |
| */ |
| public void testTimedInvokeAny3() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); |
| l.add(new StringTask()); |
| l.add(null); |
| e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); |
| } catch (NullPointerException success) { |
| } catch(Exception ex) { |
| ex.printStackTrace(); |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * timed invokeAny(c) throws ExecutionException if no task completes |
| */ |
| public void testTimedInvokeAny4() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); |
| l.add(new NPETask()); |
| e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); |
| } catch(ExecutionException success) { |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * timed invokeAny(c) returns result of some task |
| */ |
| public void testTimedInvokeAny5() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); |
| l.add(new StringTask()); |
| l.add(new StringTask()); |
| String result = e.invokeAny(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); |
| assertSame(TEST_STRING, result); |
| } catch (ExecutionException success) { |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * timed invokeAll(null) throws NPE |
| */ |
| public void testTimedInvokeAll1() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| e.invokeAll(null, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); |
| } catch (NullPointerException success) { |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * timed invokeAll(,,null) throws NPE |
| */ |
| public void testTimedInvokeAllNullTimeUnit() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); |
| l.add(new StringTask()); |
| e.invokeAll(l, MEDIUM_DELAY_MS, null); |
| } catch (NullPointerException success) { |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * timed invokeAll(empty collection) returns empty collection |
| */ |
| public void testTimedInvokeAll2() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| List<Future<String>> r = e.invokeAll(new ArrayList<Callable<String>>(), MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); |
| assertTrue(r.isEmpty()); |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * timed invokeAll(c) throws NPE if c has null elements |
| */ |
| public void testTimedInvokeAll3() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); |
| l.add(new StringTask()); |
| l.add(null); |
| e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); |
| } catch (NullPointerException success) { |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * get of element of invokeAll(c) throws exception on failed task |
| */ |
| public void testTimedInvokeAll4() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); |
| l.add(new NPETask()); |
| List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); |
| assertEquals(1, result.size()); |
| for (Iterator<Future<String>> it = result.iterator(); it.hasNext();) |
| it.next().get(); |
| } catch(ExecutionException success) { |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * timed invokeAll(c) returns results of all completed tasks |
| */ |
| public void testTimedInvokeAll5() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); |
| l.add(new StringTask()); |
| l.add(new StringTask()); |
| List<Future<String>> result = e.invokeAll(l, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS); |
| assertEquals(2, result.size()); |
| for (Iterator<Future<String>> it = result.iterator(); it.hasNext();) |
| assertSame(TEST_STRING, it.next().get()); |
| } catch (ExecutionException success) { |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * timed invokeAll(c) cancels tasks not completed by timeout |
| */ |
| public void testTimedInvokeAll6() { |
| ExecutorService e = new ThreadPoolExecutor(2, 2, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10)); |
| try { |
| ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); |
| l.add(new StringTask()); |
| l.add(Executors.callable(new MediumPossiblyInterruptedRunnable(), TEST_STRING)); |
| l.add(new StringTask()); |
| List<Future<String>> result = e.invokeAll(l, SHORT_DELAY_MS, TimeUnit.MILLISECONDS); |
| assertEquals(3, result.size()); |
| Iterator<Future<String>> it = result.iterator(); |
| Future<String> f1 = it.next(); |
| Future<String> f2 = it.next(); |
| Future<String> f3 = it.next(); |
| assertTrue(f1.isDone()); |
| assertTrue(f2.isDone()); |
| assertTrue(f3.isDone()); |
| assertFalse(f1.isCancelled()); |
| assertTrue(f2.isCancelled()); |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * Execution continues if there is at least one thread even if |
| * thread factory fails to create more |
| */ |
| public void testFailingThreadFactory() { |
| ExecutorService e = new ThreadPoolExecutor(100, 100, LONG_DELAY_MS, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(), new FailingThreadFactory()); |
| try { |
| ArrayList<Callable<String>> l = new ArrayList<Callable<String>>(); |
| for (int k = 0; k < 100; ++k) { |
| e.execute(new NoOpRunnable()); |
| } |
| Thread.sleep(LONG_DELAY_MS); |
| } catch(Exception ex) { |
| unexpectedException(); |
| } finally { |
| joinPool(e); |
| } |
| } |
| |
| /** |
| * execute allows the same task to be submitted multiple times, even |
| * if rejected |
| */ |
| public void testRejectedRecycledTask() { |
| final int nTasks = 1000; |
| final AtomicInteger nRun = new AtomicInteger(0); |
| final Runnable recycledTask = new Runnable() { |
| public void run() { |
| nRun.getAndIncrement(); |
| } }; |
| final ThreadPoolExecutor p = |
| new ThreadPoolExecutor(1, 30, 60, TimeUnit.SECONDS, |
| new ArrayBlockingQueue(30)); |
| try { |
| for (int i = 0; i < nTasks; ++i) { |
| for (;;) { |
| try { |
| p.execute(recycledTask); |
| break; |
| } |
| catch (RejectedExecutionException ignore) { |
| } |
| } |
| } |
| Thread.sleep(5000); // enough time to run all tasks |
| assertEquals(nRun.get(), nTasks); |
| } catch(Exception ex) { |
| ex.printStackTrace(); |
| unexpectedException(); |
| } finally { |
| p.shutdown(); |
| } |
| } |
| |
| } |
