test/tck/ThreadPoolExecutorTest.java

/*
 * Written by members of JCP JSR-166 Expert Group and released to the
 * public domain. Use, modify, and redistribute this code in any way
 * without acknowledgement. Other contributors include Andrew Wright,
 * Jeffrey Hayes, Pat Fischer, Mike Judd.
 */

import java.util.concurrent.*;
import junit.framework.*;
import java.util.List;

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);
    }
    
    /**
     * For use as ThreadFactory in constructors
     */
    static class MyThreadFactory implements ThreadFactory{
        public Thread newThread(Runnable r){
            return new Thread(r);
        }   
    }

    /**
     * For use as RejectedExecutionHandler in constructors
     */
    static class MyREHandler implements RejectedExecutionHandler{
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor){} 
    }
 
    /**
     *   execute successfully executes a runnable
     */
    public void testExecute() {
        ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_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, MEDIUM_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);
    }
    
    /**
     *   getCompletedTaskCount increases, but doesn't overestimate,
     *   when tasks complete
     */
    public void testGetCompletedTaskCount() {
        ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
        assertEquals(0, p2.getCompletedTaskCount());
        p2.execute(new ShortRunnable());
        try {
            Thread.sleep(MEDIUM_DELAY_MS);
        } catch(Exception e){
            unexpectedException();
        }
        assertEquals(1, p2.getCompletedTaskCount());
        p2.shutdown();
        joinPool(p2);
    }
    
    /**
     *   getCorePoolSize returns size given in constructor if not otherwise set
     */
    public void testGetCorePoolSize() {
        ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_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);
    }
    
    /**
     *   getLargestPoolSize increases, but doesn't overestimate, when
     *   multiple threads active
     */
    public void testGetLargestPoolSize() {
        ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, MEDIUM_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, MEDIUM_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, MEDIUM_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, MEDIUM_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, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
        assertFalse(p1.isShutdown());
        p1.shutdown();
        assertTrue(p1.isShutdown());
        joinPool(p1);
    }

        
    /**
     *  isTerminated is false before termination, true after
     */
    public void testIsTerminated() {
        ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
        assertFalse(p1.isTerminated());
        try {
            p1.execute(new MediumRunnable());
        } finally {
            p1.shutdown();
        }
        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, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
        assertFalse(p1.isTerminating());
        try {
            p1.execute(new SmallRunnable());
            assertFalse(p1.isTerminating());
        } finally {
            p1.shutdown();
        }
        try {
            assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
            assertTrue(p1.isTerminated());
            assertFalse(p1.isTerminating());
        } catch(Exception e){
            unexpectedException();
        }       
    }

    /**
     *   purge removes cancelled tasks from the queue
     */
    public void testPurge() {
        ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
        CancellableTask[] tasks = new CancellableTask[5];
        for(int i = 0; i < 5; i++){
            tasks[i] = new CancellableTask(new MediumPossiblyInterruptedRunnable());
            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, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
        List l;
        try {
            for(int i = 0; i < 5; i++)
                p1.execute(new MediumPossiblyInterruptedRunnable());
        }
        finally {
            l = p1.shutdownNow();
        }
        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 testNullPointerException() {
        try {
            new ThreadPoolExecutor(1,2,SHORT_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 MyThreadFactory());
            shouldThrow();
        } catch (IllegalArgumentException success){}
    }
    
    /** 
     * Constructor throws if maximumPoolSize is less than zero 
     */
    public void testConstructor7() {
        try {
            new ThreadPoolExecutor(1,-1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory());
            shouldThrow();
        }
        catch (IllegalArgumentException success){}
    }

    /** 
     * Constructor throws if maximumPoolSize is equal to zero 
     */
    public void testConstructor8() {
        try {
            new ThreadPoolExecutor(1,0,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory());
            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 MyThreadFactory());
            shouldThrow();
        }
        catch (IllegalArgumentException success){}
    }

    /** 
     * Constructor throws if corePoolSize is greater than the maximumPoolSize 
     */
    public void testConstructor10() {
        try {
            new ThreadPoolExecutor(2,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory());
            shouldThrow();
        }
        catch (IllegalArgumentException success){}
    }

    /** 
     * Constructor throws if workQueue is set to null 
     */
    public void testNullPointerException2() {
        try {
            new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,null,new MyThreadFactory());
            shouldThrow();
        }
        catch (NullPointerException success){}  
    }

    /** 
     * Constructor throws if threadFactory is set to null 
     */
    public void testNullPointerException3() {
        try {
            ThreadFactory f = null;
            new ThreadPoolExecutor(1,2,SHORT_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,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyREHandler());
            shouldThrow();
        }
        catch (IllegalArgumentException success){}
    }

    /** 
     * Constructor throws if maximumPoolSize is less than zero 
     */
    public void testConstructor12() {
        try {
            new ThreadPoolExecutor(1,-1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyREHandler());
            shouldThrow();
        }
        catch (IllegalArgumentException success){}
    }

    /** 
     * Constructor throws if maximumPoolSize is equal to zero 
     */
    public void testConstructor13() {
        try {
            new ThreadPoolExecutor(1,0,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyREHandler());
            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 MyREHandler());
            shouldThrow();
        }
        catch (IllegalArgumentException success){}
    }

    /** 
     * Constructor throws if corePoolSize is greater than the maximumPoolSize 
     */
    public void testConstructor15() {
        try {
            new ThreadPoolExecutor(2,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyREHandler());
            shouldThrow();
        }
        catch (IllegalArgumentException success){}
    }

    /** 
     * Constructor throws if workQueue is set to null 
     */
    public void testNullPointerException4() {
        try {
            new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,null,new MyREHandler());
            shouldThrow();
        }
        catch (NullPointerException success){}  
    }

    /** 
     * Constructor throws if handler is set to null 
     */
    public void testNullPointerException5() {
        try {
            RejectedExecutionHandler r = null;
            new ThreadPoolExecutor(1,2,SHORT_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,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),new MyREHandler());
            shouldThrow();
        }
        catch (IllegalArgumentException success){}
    }

    /** 
     * Constructor throws if maximumPoolSize is less than zero 
     */
    public void testConstructor17() {
        try {
            new ThreadPoolExecutor(1,-1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),new MyREHandler());
            shouldThrow();
        }
        catch (IllegalArgumentException success){}
    }

    /** 
     * Constructor throws if maximumPoolSize is equal to zero 
     */
    public void testConstructor18() {
        try {
            new ThreadPoolExecutor(1,0,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),new MyREHandler());
            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 MyThreadFactory(),new MyREHandler());
            shouldThrow();
        }
        catch (IllegalArgumentException success){}
    }

    /** 
     * Constructor throws if corePoolSize is greater than the maximumPoolSize 
     */
    public void testConstructor20() {
        try {
            new ThreadPoolExecutor(2,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),new MyREHandler());
            shouldThrow();
        }
        catch (IllegalArgumentException success){}
    }

    /** 
     * Constructor throws if workQueue is set to null 
     */
    public void testNullPointerException6() {
        try {
            new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,null,new MyThreadFactory(),new MyREHandler());
            shouldThrow();
        }
        catch (NullPointerException success){}  
    }

    /** 
     * Constructor throws if handler is set to null 
     */
    public void testNullPointerException7() {
        try {
            RejectedExecutionHandler r = null;
            new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),r);
            shouldThrow();
        }
        catch (NullPointerException success){}  
    }

    /** 
     * Constructor throws if ThreadFactory is set top null 
     */
    public void testNullPointerException8() {
        try {
            ThreadFactory f = null;
            new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f,new MyREHandler());
            shouldThrow();
        }
        catch (NullPointerException successdn8){}  
    }
    

    /**
     *  execute throws RejectedExecutionException if shutdown
     */
    public void testRejectedExecutionException() {
        ThreadPoolExecutor tpe = null;
        try {
            tpe = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(1));
        } catch(Exception e){}
        tpe.shutdown();
        try {
            tpe.execute(new NoOpRunnable());
            shouldThrow();
        } catch(RejectedExecutionException success){}
        
        joinPool(tpe);
    }

    /**
     *  execute throws RejectedExecutionException
     *  if saturated.
     */
    public void testSaturatedExecute() {
        ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_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);
    }

    /**
     *  execute (null) throws NPE
     */
    public void testExecuteNull() {
        ThreadPoolExecutor tpe = null;
        try {
            tpe = new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
            tpe.execute(null);
            shouldThrow();
        } catch(NullPointerException success){}
        
        joinPool(tpe);
    }
    
    /**
     *  setCorePoolSize of netaitev value throws IllegalArgumentException
     */
    public void testCorePoolSizeIllegalArgumentException() {
        ThreadPoolExecutor tpe = null;
        try {
            tpe = new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
        } catch(Exception e){}
        try {
            tpe.setCorePoolSize(-1);
            shouldThrow();
        } catch(IllegalArgumentException success){
        } finally {
            tpe.shutdown();
        }
        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,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
        } catch(Exception e){}
        try {
            tpe.setMaximumPoolSize(1);
            shouldThrow();
        } catch(IllegalArgumentException success){
        } finally {
            tpe.shutdown();
        }
        joinPool(tpe);
    }
    
    /**
     *  setMaximumPoolSize throws IllegalArgumentException
     *  if given a negative value
     */
    public void testMaximumPoolSizeIllegalArgumentException2() {
        ThreadPoolExecutor tpe = null;
        try {
            tpe = new ThreadPoolExecutor(2,3,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
        } catch(Exception e){}
        try {
            tpe.setMaximumPoolSize(-1);
            shouldThrow();
        } catch(IllegalArgumentException success){
        } finally {
            tpe.shutdown();
        }
        joinPool(tpe);
    }
    

    /**
     *  setKeepAliveTime  throws IllegalArgumentException
     *  when given a negative value
     */
    public void testKeepAliveTimeIllegalArgumentException() {
        ThreadPoolExecutor tpe = null;
        try {
            tpe = new ThreadPoolExecutor(2,3,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
        } catch(Exception e){}
        
        try {
            tpe.setKeepAliveTime(-1,TimeUnit.MILLISECONDS);
            shouldThrow();
        } catch(IllegalArgumentException success){
        } finally {
            tpe.shutdown();
        }
        joinPool(tpe);
    }
  
}
Revision:	1.6
Committed:	Thu Sep 25 11:02:41 2003 UTC (20 years, 7 months ago) by dl
Branch:	MAIN
Changes since 1.5:	+140 -56 lines
Log Message:	improve tck javadocs; rename and add a few tests
#	Content
1	/*
2	* Written by members of JCP JSR-166 Expert Group and released to the
3	* public domain. Use, modify, and redistribute this code in any way
4	* without acknowledgement. Other contributors include Andrew Wright,
5	* Jeffrey Hayes, Pat Fischer, Mike Judd.
6	*/
7
8	import java.util.concurrent.*;
9	import junit.framework.*;
10	import java.util.List;
11
12	public class ThreadPoolExecutorTest extends JSR166TestCase {
13	public static void main(String[] args) {
14	junit.textui.TestRunner.run (suite());
15	}
16	public static Test suite() {
17	return new TestSuite(ThreadPoolExecutorTest.class);
18	}
19
20	/**
21	* For use as ThreadFactory in constructors
22	*/
23	static class MyThreadFactory implements ThreadFactory{
24	public Thread newThread(Runnable r){
25	return new Thread(r);
26	}
27	}
28
29	/**
30	* For use as RejectedExecutionHandler in constructors
31	*/
32	static class MyREHandler implements RejectedExecutionHandler{
33	public void rejectedExecution(Runnable r, ThreadPoolExecutor executor){}
34	}
35
36	/**
37	* execute successfully executes a runnable
38	*/
39	public void testExecute() {
40	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
41	try {
42	p1.execute(new Runnable() {
43	public void run() {
44	try {
45	Thread.sleep(SHORT_DELAY_MS);
46	} catch(InterruptedException e){
47	threadUnexpectedException();
48	}
49	}
50	});
51	Thread.sleep(SMALL_DELAY_MS);
52	} catch(InterruptedException e){
53	unexpectedException();
54	}
55	joinPool(p1);
56	}
57
58	/**
59	* getActiveCount increases but doesn't overestimate, when a
60	* thread becomes active
61	*/
62	public void testGetActiveCount() {
63	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
64	assertEquals(0, p2.getActiveCount());
65	p2.execute(new MediumRunnable());
66	try {
67	Thread.sleep(SHORT_DELAY_MS);
68	} catch(Exception e){
69	unexpectedException();
70	}
71	assertEquals(1, p2.getActiveCount());
72	joinPool(p2);
73	}
74
75	/**
76	* getCompletedTaskCount increases, but doesn't overestimate,
77	* when tasks complete
78	*/
79	public void testGetCompletedTaskCount() {
80	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
81	assertEquals(0, p2.getCompletedTaskCount());
82	p2.execute(new ShortRunnable());
83	try {
84	Thread.sleep(MEDIUM_DELAY_MS);
85	} catch(Exception e){
86	unexpectedException();
87	}
88	assertEquals(1, p2.getCompletedTaskCount());
89	p2.shutdown();
90	joinPool(p2);
91	}
92
93	/**
94	* getCorePoolSize returns size given in constructor if not otherwise set
95	*/
96	public void testGetCorePoolSize() {
97	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
98	assertEquals(1, p1.getCorePoolSize());
99	joinPool(p1);
100	}
101
102	/**
103	* getKeepAliveTime returns value given in constructor if not otherwise set
104	*/
105	public void testGetKeepAliveTime() {
106	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, 1000, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
107	assertEquals(1, p2.getKeepAliveTime(TimeUnit.SECONDS));
108	joinPool(p2);
109	}
110
111	/**
112	* getLargestPoolSize increases, but doesn't overestimate, when
113	* multiple threads active
114	*/
115	public void testGetLargestPoolSize() {
116	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
117	try {
118	assertEquals(0, p2.getLargestPoolSize());
119	p2.execute(new MediumRunnable());
120	p2.execute(new MediumRunnable());
121	Thread.sleep(SHORT_DELAY_MS);
122	assertEquals(2, p2.getLargestPoolSize());
123	} catch(Exception e){
124	unexpectedException();
125	}
126	joinPool(p2);
127	}
128
129	/**
130	* getMaximumPoolSize returns value given in constructor if not
131	* otherwise set
132	*/
133	public void testGetMaximumPoolSize() {
134	ThreadPoolExecutor p2 = new ThreadPoolExecutor(2, 2, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
135	assertEquals(2, p2.getMaximumPoolSize());
136	joinPool(p2);
137	}
138
139	/**
140	* getPoolSize increases, but doesn't overestimate, when threads
141	* become active
142	*/
143	public void testGetPoolSize() {
144	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
145	assertEquals(0, p1.getPoolSize());
146	p1.execute(new MediumRunnable());
147	assertEquals(1, p1.getPoolSize());
148	joinPool(p1);
149	}
150
151	/**
152	* getTaskCount increases, but doesn't overestimate, when tasks submitted
153	*/
154	public void testGetTaskCount() {
155	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
156	try {
157	assertEquals(0, p1.getTaskCount());
158	p1.execute(new MediumRunnable());
159	Thread.sleep(SHORT_DELAY_MS);
160	assertEquals(1, p1.getTaskCount());
161	} catch(Exception e){
162	unexpectedException();
163	}
164	joinPool(p1);
165	}
166
167	/**
168	* isShutDown is false before shutdown, true after
169	*/
170	public void testIsShutdown() {
171
172	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
173	assertFalse(p1.isShutdown());
174	p1.shutdown();
175	assertTrue(p1.isShutdown());
176	joinPool(p1);
177	}
178
179
180	/**
181	* isTerminated is false before termination, true after
182	*/
183	public void testIsTerminated() {
184	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
185	assertFalse(p1.isTerminated());
186	try {
187	p1.execute(new MediumRunnable());
188	} finally {
189	p1.shutdown();
190	}
191	try {
192	assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
193	assertTrue(p1.isTerminated());
194	} catch(Exception e){
195	unexpectedException();
196	}
197	}
198
199	/**
200	* isTerminating is not true when running or when terminated
201	*/
202	public void testIsTerminating() {
203	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
204	assertFalse(p1.isTerminating());
205	try {
206	p1.execute(new SmallRunnable());
207	assertFalse(p1.isTerminating());
208	} finally {
209	p1.shutdown();
210	}
211	try {
212	assertTrue(p1.awaitTermination(LONG_DELAY_MS, TimeUnit.MILLISECONDS));
213	assertTrue(p1.isTerminated());
214	assertFalse(p1.isTerminating());
215	} catch(Exception e){
216	unexpectedException();
217	}
218	}
219
220	/**
221	* purge removes cancelled tasks from the queue
222	*/
223	public void testPurge() {
224	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
225	CancellableTask[] tasks = new CancellableTask[5];
226	for(int i = 0; i < 5; i++){
227	tasks[i] = new CancellableTask(new MediumPossiblyInterruptedRunnable());
228	p1.execute(tasks[i]);
229	}
230	tasks[4].cancel(true);
231	tasks[3].cancel(true);
232	p1.purge();
233	long count = p1.getTaskCount();
234	assertTrue(count >= 2 && count < 5);
235	joinPool(p1);
236	}
237
238	/**
239	* shutDownNow returns a list containing tasks that were not run
240	*/
241	public void testShutDownNow() {
242	ThreadPoolExecutor p1 = new ThreadPoolExecutor(1, 1, MEDIUM_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
243	List l;
244	try {
245	for(int i = 0; i < 5; i++)
246	p1.execute(new MediumPossiblyInterruptedRunnable());
247	}
248	finally {
249	l = p1.shutdownNow();
250	}
251	assertTrue(p1.isShutdown());
252	assertTrue(l.size() <= 4);
253	}
254
255	// Exception Tests
256
257
258	/**
259	* Constructor throws if corePoolSize argument is less than zero
260	*/
261	public void testConstructor1() {
262	try {
263	new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
264	shouldThrow();
265	}
266	catch (IllegalArgumentException success){}
267	}
268
269	/**
270	* Constructor throws if maximumPoolSize is less than zero
271	*/
272	public void testConstructor2() {
273	try {
274	new ThreadPoolExecutor(1,-1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
275	shouldThrow();
276	}
277	catch (IllegalArgumentException success){}
278	}
279
280	/**
281	* Constructor throws if maximumPoolSize is equal to zero
282	*/
283	public void testConstructor3() {
284	try {
285	new ThreadPoolExecutor(1,0,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
286	shouldThrow();
287	}
288	catch (IllegalArgumentException success){}
289	}
290
291	/**
292	* Constructor throws if keepAliveTime is less than zero
293	*/
294	public void testConstructor4() {
295	try {
296	new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
297	shouldThrow();
298	}
299	catch (IllegalArgumentException success){}
300	}
301
302	/**
303	* Constructor throws if corePoolSize is greater than the maximumPoolSize
304	*/
305	public void testConstructor5() {
306	try {
307	new ThreadPoolExecutor(2,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
308	shouldThrow();
309	}
310	catch (IllegalArgumentException success){}
311	}
312
313	/**
314	* Constructor throws if workQueue is set to null
315	*/
316	public void testNullPointerException() {
317	try {
318	new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,null);
319	shouldThrow();
320	}
321	catch (NullPointerException success){}
322	}
323
324
325
326	/**
327	* Constructor throws if corePoolSize argument is less than zero
328	*/
329	public void testConstructor6() {
330	try {
331	new ThreadPoolExecutor(-1,1,LONG_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory());
332	shouldThrow();
333	} catch (IllegalArgumentException success){}
334	}
335
336	/**
337	* Constructor throws if maximumPoolSize is less than zero
338	*/
339	public void testConstructor7() {
340	try {
341	new ThreadPoolExecutor(1,-1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory());
342	shouldThrow();
343	}
344	catch (IllegalArgumentException success){}
345	}
346
347	/**
348	* Constructor throws if maximumPoolSize is equal to zero
349	*/
350	public void testConstructor8() {
351	try {
352	new ThreadPoolExecutor(1,0,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory());
353	shouldThrow();
354	}
355	catch (IllegalArgumentException success){}
356	}
357
358	/**
359	* Constructor throws if keepAliveTime is less than zero
360	*/
361	public void testConstructor9() {
362	try {
363	new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory());
364	shouldThrow();
365	}
366	catch (IllegalArgumentException success){}
367	}
368
369	/**
370	* Constructor throws if corePoolSize is greater than the maximumPoolSize
371	*/
372	public void testConstructor10() {
373	try {
374	new ThreadPoolExecutor(2,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory());
375	shouldThrow();
376	}
377	catch (IllegalArgumentException success){}
378	}
379
380	/**
381	* Constructor throws if workQueue is set to null
382	*/
383	public void testNullPointerException2() {
384	try {
385	new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,null,new MyThreadFactory());
386	shouldThrow();
387	}
388	catch (NullPointerException success){}
389	}
390
391	/**
392	* Constructor throws if threadFactory is set to null
393	*/
394	public void testNullPointerException3() {
395	try {
396	ThreadFactory f = null;
397	new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f);
398	shouldThrow();
399	}
400	catch (NullPointerException success){}
401	}
402
403
404	/**
405	* Constructor throws if corePoolSize argument is less than zero
406	*/
407	public void testConstructor11() {
408	try {
409	new ThreadPoolExecutor(-1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyREHandler());
410	shouldThrow();
411	}
412	catch (IllegalArgumentException success){}
413	}
414
415	/**
416	* Constructor throws if maximumPoolSize is less than zero
417	*/
418	public void testConstructor12() {
419	try {
420	new ThreadPoolExecutor(1,-1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyREHandler());
421	shouldThrow();
422	}
423	catch (IllegalArgumentException success){}
424	}
425
426	/**
427	* Constructor throws if maximumPoolSize is equal to zero
428	*/
429	public void testConstructor13() {
430	try {
431	new ThreadPoolExecutor(1,0,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyREHandler());
432	shouldThrow();
433	}
434	catch (IllegalArgumentException success){}
435	}
436
437	/**
438	* Constructor throws if keepAliveTime is less than zero
439	*/
440	public void testConstructor14() {
441	try {
442	new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyREHandler());
443	shouldThrow();
444	}
445	catch (IllegalArgumentException success){}
446	}
447
448	/**
449	* Constructor throws if corePoolSize is greater than the maximumPoolSize
450	*/
451	public void testConstructor15() {
452	try {
453	new ThreadPoolExecutor(2,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyREHandler());
454	shouldThrow();
455	}
456	catch (IllegalArgumentException success){}
457	}
458
459	/**
460	* Constructor throws if workQueue is set to null
461	*/
462	public void testNullPointerException4() {
463	try {
464	new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,null,new MyREHandler());
465	shouldThrow();
466	}
467	catch (NullPointerException success){}
468	}
469
470	/**
471	* Constructor throws if handler is set to null
472	*/
473	public void testNullPointerException5() {
474	try {
475	RejectedExecutionHandler r = null;
476	new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),r);
477	shouldThrow();
478	}
479	catch (NullPointerException success){}
480	}
481
482
483	/**
484	* Constructor throws if corePoolSize argument is less than zero
485	*/
486	public void testConstructor16() {
487	try {
488	new ThreadPoolExecutor(-1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),new MyREHandler());
489	shouldThrow();
490	}
491	catch (IllegalArgumentException success){}
492	}
493
494	/**
495	* Constructor throws if maximumPoolSize is less than zero
496	*/
497	public void testConstructor17() {
498	try {
499	new ThreadPoolExecutor(1,-1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),new MyREHandler());
500	shouldThrow();
501	}
502	catch (IllegalArgumentException success){}
503	}
504
505	/**
506	* Constructor throws if maximumPoolSize is equal to zero
507	*/
508	public void testConstructor18() {
509	try {
510	new ThreadPoolExecutor(1,0,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),new MyREHandler());
511	shouldThrow();
512	}
513	catch (IllegalArgumentException success){}
514	}
515
516	/**
517	* Constructor throws if keepAliveTime is less than zero
518	*/
519	public void testConstructor19() {
520	try {
521	new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),new MyREHandler());
522	shouldThrow();
523	}
524	catch (IllegalArgumentException success){}
525	}
526
527	/**
528	* Constructor throws if corePoolSize is greater than the maximumPoolSize
529	*/
530	public void testConstructor20() {
531	try {
532	new ThreadPoolExecutor(2,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),new MyREHandler());
533	shouldThrow();
534	}
535	catch (IllegalArgumentException success){}
536	}
537
538	/**
539	* Constructor throws if workQueue is set to null
540	*/
541	public void testNullPointerException6() {
542	try {
543	new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,null,new MyThreadFactory(),new MyREHandler());
544	shouldThrow();
545	}
546	catch (NullPointerException success){}
547	}
548
549	/**
550	* Constructor throws if handler is set to null
551	*/
552	public void testNullPointerException7() {
553	try {
554	RejectedExecutionHandler r = null;
555	new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),new MyThreadFactory(),r);
556	shouldThrow();
557	}
558	catch (NullPointerException success){}
559	}
560
561	/**
562	* Constructor throws if ThreadFactory is set top null
563	*/
564	public void testNullPointerException8() {
565	try {
566	ThreadFactory f = null;
567	new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f,new MyREHandler());
568	shouldThrow();
569	}
570	catch (NullPointerException successdn8){}
571	}
572
573
574	/**
575	* execute throws RejectedExecutionException if shutdown
576	*/
577	public void testRejectedExecutionException() {
578	ThreadPoolExecutor tpe = null;
579	try {
580	tpe = new ThreadPoolExecutor(1,1,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(1));
581	} catch(Exception e){}
582	tpe.shutdown();
583	try {
584	tpe.execute(new NoOpRunnable());
585	shouldThrow();
586	} catch(RejectedExecutionException success){}
587
588	joinPool(tpe);
589	}
590
591	/**
592	* execute throws RejectedExecutionException
593	* if saturated.
594	*/
595	public void testSaturatedExecute() {
596	ThreadPoolExecutor p = new ThreadPoolExecutor(1,1, SHORT_DELAY_MS, TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(1));
597	try {
598
599	for(int i = 0; i < 5; ++i){
600	p.execute(new MediumRunnable());
601	}
602	shouldThrow();
603	} catch(RejectedExecutionException success){}
604	joinPool(p);
605	}
606
607	/**
608	* execute (null) throws NPE
609	*/
610	public void testExecuteNull() {
611	ThreadPoolExecutor tpe = null;
612	try {
613	tpe = new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
614	tpe.execute(null);
615	shouldThrow();
616	} catch(NullPointerException success){}
617
618	joinPool(tpe);
619	}
620
621	/**
622	* setCorePoolSize of netaitev value throws IllegalArgumentException
623	*/
624	public void testCorePoolSizeIllegalArgumentException() {
625	ThreadPoolExecutor tpe = null;
626	try {
627	tpe = new ThreadPoolExecutor(1,2,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
628	} catch(Exception e){}
629	try {
630	tpe.setCorePoolSize(-1);
631	shouldThrow();
632	} catch(IllegalArgumentException success){
633	} finally {
634	tpe.shutdown();
635	}
636	joinPool(tpe);
637	}
638
639	/**
640	* setMaximumPoolSize(int) throws IllegalArgumentException if
641	* given a value less the core pool size
642	*/
643	public void testMaximumPoolSizeIllegalArgumentException() {
644	ThreadPoolExecutor tpe = null;
645	try {
646	tpe = new ThreadPoolExecutor(2,3,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
647	} catch(Exception e){}
648	try {
649	tpe.setMaximumPoolSize(1);
650	shouldThrow();
651	} catch(IllegalArgumentException success){
652	} finally {
653	tpe.shutdown();
654	}
655	joinPool(tpe);
656	}
657
658	/**
659	* setMaximumPoolSize throws IllegalArgumentException
660	* if given a negative value
661	*/
662	public void testMaximumPoolSizeIllegalArgumentException2() {
663	ThreadPoolExecutor tpe = null;
664	try {
665	tpe = new ThreadPoolExecutor(2,3,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
666	} catch(Exception e){}
667	try {
668	tpe.setMaximumPoolSize(-1);
669	shouldThrow();
670	} catch(IllegalArgumentException success){
671	} finally {
672	tpe.shutdown();
673	}
674	joinPool(tpe);
675	}
676
677
678	/**
679	* setKeepAliveTime throws IllegalArgumentException
680	* when given a negative value
681	*/
682	public void testKeepAliveTimeIllegalArgumentException() {
683	ThreadPoolExecutor tpe = null;
684	try {
685	tpe = new ThreadPoolExecutor(2,3,SHORT_DELAY_MS, TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
686	} catch(Exception e){}
687
688	try {
689	tpe.setKeepAliveTime(-1,TimeUnit.MILLISECONDS);
690	shouldThrow();
691	} catch(IllegalArgumentException success){
692	} finally {
693	tpe.shutdown();
694	}
695	joinPool(tpe);
696	}
697
698	}