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 TestCase{
    public static void main(String[] args) {
        junit.textui.TestRunner.run (suite());  
    }


    public static Test suite() {
        return new TestSuite(ThreadPoolExecutorTest.class);
    }
    
    private static long SHORT_DELAY_MS = 100; 
    private static long MEDIUM_DELAY_MS = 1000;
    private static long LONG_DELAY_MS = 10000; 

//---- testThread class to implement ThreadFactory for use in constructors
    static class testThread implements ThreadFactory{
        public Thread newThread(Runnable r){
            return new Thread(r);
        }   
    }

//---- testReject class to implement RejectedExecutionHandler for use in the constructors
    static class testReject implements RejectedExecutionHandler{
        public void rejectedExecution(Runnable r, ThreadPoolExecutor executor){} 
    }

    public Runnable newRunnable(){
        return new Runnable(){
                public void run(){
                    try{Thread.sleep(MEDIUM_DELAY_MS);
                    } catch(Exception e){
                    }
                }
            };
    }

 
    /**
     *  Test to verify that execute successfully executes a runnable
     */
    public void testExecute(){
        ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
        try {
            one.execute(new Runnable(){
                    public void run(){
                        try{
                            Thread.sleep(SHORT_DELAY_MS);
                        }catch(InterruptedException e){
                            fail("unexpected exception");
                        }
                    }
                });
            Thread.sleep(SHORT_DELAY_MS * 2);
        }catch(InterruptedException e){
            fail("unexpected exception");
        } finally {
            one.shutdown();
        }
    }

    /**
     *  Test to verify getActiveCount gives correct values
     */
    public void testGetActiveCount(){
        ThreadPoolExecutor two = new ThreadPoolExecutor(2, 2, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
        try {
            assertEquals(0, two.getActiveCount());
            two.execute(newRunnable());
            try{Thread.sleep(10);}catch(Exception e){}
            assertEquals(1, two.getActiveCount());
        } finally {
            two.shutdown();
        }
    }
    
    /**
     *  Test to verify getCompleteTaskCount gives correct values
     */
    public void testGetCompletedTaskCount(){
        ThreadPoolExecutor two = new ThreadPoolExecutor(2, 2, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
        try {
            assertEquals(0, two.getCompletedTaskCount());
            two.execute(newRunnable());
            try{Thread.sleep(2000);}catch(Exception e){}
            assertEquals(1, two.getCompletedTaskCount());
        } finally {
            two.shutdown();
        }
    }
    
    /**
     *  Test to verify getCorePoolSize gives correct values
     */
    public void testGetCorePoolSize(){
        ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
        try {
            assertEquals(1, one.getCorePoolSize());
        } finally {
            one.shutdown();
        }
    }
    
    /**
     *  Test to verify getKeepAliveTime gives correct values
     */
    public void testGetKeepAliveTime(){
        ThreadPoolExecutor two = new ThreadPoolExecutor(2, 2, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
        try {
            assertEquals(1, two.getKeepAliveTime(TimeUnit.SECONDS));
        } finally {
            two.shutdown();
        }
    }
    
    /**
     *  Test to verify getLargestPoolSize gives correct values
     */
    public void testGetLargestPoolSize(){
        ThreadPoolExecutor two = new ThreadPoolExecutor(2, 2, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
        try {
            assertEquals(0, two.getLargestPoolSize());
            two.execute(newRunnable());
            two.execute(newRunnable());
            try{Thread.sleep(SHORT_DELAY_MS);} catch(Exception e){}
            assertEquals(2, two.getLargestPoolSize());
        } finally {
            two.shutdown();
        }
    }
    
    /**
     *  Test to verify getMaximumPoolSize gives correct values
     */
    public void testGetMaximumPoolSize(){
        ThreadPoolExecutor two = new ThreadPoolExecutor(2, 2, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
        try {
            assertEquals(2, two.getMaximumPoolSize());
        } finally {
            two.shutdown();
        }
    }
    
    /**
     *  Test to verify getPoolSize gives correct values
     */
    public void testGetPoolSize(){
        ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
        try { 
            assertEquals(0, one.getPoolSize());
            one.execute(newRunnable());
            assertEquals(1, one.getPoolSize());
        } finally {
            one.shutdown();
        }
    }
    
    /**
     *  Test to verify getTaskCount gives correct values
     */
    public void testGetTaskCount(){
        ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
        try {
            assertEquals(0, one.getTaskCount());
            for(int i = 0; i < 5; i++)
                one.execute(newRunnable());
            try{Thread.sleep(SHORT_DELAY_MS);}catch(Exception e){}
            assertEquals(5, one.getTaskCount());
        } finally {
            one.shutdown();
        }
    }
    
    /**
     *  Test to verify isShutDown gives correct values
     */
    public void testIsShutdown(){
        
        ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
        try {
            assertFalse(one.isShutdown());
        }
        finally {
            one.shutdown();
        }
        assertTrue(one.isShutdown());
    }

        
    /**
     *  Test to verify isTerminated gives correct values
     *  Makes sure termination does not take an innapropriate
     *  amount of time
     */
    public void testIsTerminated(){
        ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
        try {
            one.execute(newRunnable());
        } finally {
            one.shutdown();
        }
        boolean flag = false;
        try{
            flag = one.awaitTermination(10, TimeUnit.SECONDS);
        }catch(Exception e){}   
        assertTrue(one.isTerminated());
        if(!flag)
            fail("ThreadPoolExecutor - thread pool did not terminate within suitable timeframe");
    }

    /**
     *  Test to verify that purge correctly removes cancelled tasks
     *  from the queue
     */
    public void testPurge(){
        ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
        try {
            CancellableTask[] tasks = new CancellableTask[5];
            for(int i = 0; i < 5; i++){
                tasks[i] = new CancellableTask(newRunnable());
                one.execute(tasks[i]);
            }
            tasks[4].cancel(true);
            tasks[3].cancel(true);
            one.purge();
            long count = one.getTaskCount();
            assertTrue(count >= 2 && count < 5);
        } finally {
            one.shutdown();
        }
    }

    /**
     *  Test to verify shutDownNow returns a list
     *  containing the correct number of elements
     */
    public void testShutDownNow(){
        ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
        List l;
        try {
            for(int i = 0; i < 5; i++)
                one.execute(newRunnable());
        }
        finally {
            l = one.shutdownNow();
        }
        assertTrue(one.isShutdown());
        assertTrue(l.size() <= 4);
    }

    
    // Exception Tests
    

    //---- Tests if corePoolSize argument is less than zero
    public void testConstructor1() {
        try{
            new ThreadPoolExecutor(-1,1,100L,TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
            fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");            
        }
        catch (IllegalArgumentException i){}
    }
    
    //---- Tests if maximumPoolSize is less than zero
    public void testConstructor2() {
        try{
            new ThreadPoolExecutor(1,-1,100L,TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
            fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");            
        }
        catch (IllegalArgumentException i2){}
    }
    
    //---- Tests if maximumPoolSize is equal to zero
    public void testConstructor3() {
        try{
            new ThreadPoolExecutor(1,0,100L,TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
            fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");            
        }
        catch (IllegalArgumentException i3){}
    }

    //---- Tests if keepAliveTime is less than zero
    public void testConstructor4() {
        try{
            new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
            fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");            
        }
        catch (IllegalArgumentException i4){}
    }

    //---- Tests if corePoolSize is greater than the maximumPoolSize
    public void testConstructor5() {
        try{
            new ThreadPoolExecutor(2,1,100L,TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
            fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");            
        }
        catch (IllegalArgumentException i5){}
    }
        
    //---- Tests if workQueue is set to null
    public void testNullPointerException() {
        try{
            new ThreadPoolExecutor(1,2,100L,TimeUnit.MILLISECONDS,null);
            fail("ThreadPoolExecutor constructor should throw a NullPointerException");         
        }
        catch (NullPointerException n){}  
    }
    

    //---- Tests if corePoolSize argument is less than zero
    public void testConstructor6() {
        try{
            new ThreadPoolExecutor(-1,1,100L,TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10),new testThread());
            fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");            
        }catch (IllegalArgumentException i6){}
    }
    
    //---- Tests if maximumPoolSize is less than zero
    public void testConstructor7() {
        try{
            new ThreadPoolExecutor(1,-1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testThread());
            fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");            
        }
        catch (IllegalArgumentException i7){}
    }

    //---- Tests if maximumPoolSize is equal to zero
    public void testConstructor8() {
        try{
            new ThreadPoolExecutor(1,0,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testThread());
            fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");            
        }
        catch (IllegalArgumentException i8){}
    }

    //---- Tests if keepAliveTime is less than zero
    public void testConstructor9() {
        try{
            new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testThread());
            fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");            
        }
        catch (IllegalArgumentException i9){}
    }

    //---- Tests if corePoolSize is greater than the maximumPoolSize
    public void testConstructor10() {
        try{
            new ThreadPoolExecutor(2,1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testThread());
            fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");            
        }
        catch (IllegalArgumentException i10){}
    }

    //---- Tests if workQueue is set to null
    public void testNullPointerException2() {
        try{
            new ThreadPoolExecutor(1,2,100L,TimeUnit.MILLISECONDS,null,new testThread());
            fail("ThreadPoolExecutor constructor should throw a NullPointerException");         
        }
        catch (NullPointerException n2){}  
    }

    //---- Tests if threadFactory is set to null
    public void testNullPointerException3() {
        try{
            ThreadFactory f = null;
            new ThreadPoolExecutor(1,2,100L,TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f);
            fail("ThreadPoolExecutor constructor should throw a NullPointerException");         
        }
        catch (NullPointerException n3){}  
    }
 
    
    //---- Tests if corePoolSize argument is less than zero
    public void testConstructor11() {
        try{
            new ThreadPoolExecutor(-1,1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testReject());
            fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");            
        }
        catch (IllegalArgumentException i11){}
    }

    //---- Tests if maximumPoolSize is less than zero
    public void testConstructor12() {
        try{
            new ThreadPoolExecutor(1,-1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testReject());
            fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");            
        }
        catch (IllegalArgumentException i12){}
    }

    //---- Tests if maximumPoolSize is equal to zero
    public void testConstructor13() {
        try{
            new ThreadPoolExecutor(1,0,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testReject());
            fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");            
        }
        catch (IllegalArgumentException i13){}
    }

    //---- Tests if keepAliveTime is less than zero
    public void testConstructor14() {
        try{
            new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testReject());
            fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");            
        }
        catch (IllegalArgumentException i14){}
    }

    //---- Tests if corePoolSize is greater than the maximumPoolSize
    public void testConstructor15() {
        try{
            new ThreadPoolExecutor(2,1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testReject());
            fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");            
        }
        catch (IllegalArgumentException i15){}
    }

    //---- Tests if workQueue is set to null
    public void testNullPointerException4() {
        try{
            new ThreadPoolExecutor(1,2,100L,TimeUnit.MILLISECONDS,null,new testReject());
            fail("ThreadPoolExecutor constructor should throw a NullPointerException");         
        }
        catch (NullPointerException n4){}  
    }

    //---- Tests if handler is set to null
    public void testNullPointerException5() {
        try{
            RejectedExecutionHandler r = null;
            new ThreadPoolExecutor(1,2,100L,TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),r);
            fail("ThreadPoolExecutor constructor should throw a NullPointerException");         
        }
        catch (NullPointerException n5){}  
    }

    
    //---- Tests if corePoolSize argument is less than zero
    public void testConstructor16() {
        try{
            new ThreadPoolExecutor(-1,1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testThread(),new testReject());
            fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");            
        }
        catch (IllegalArgumentException i16){}
    }

    //---- Tests if maximumPoolSize is less than zero
    public void testConstructor17() {
        try{
            new ThreadPoolExecutor(1,-1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testThread(),new testReject());
            fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");            
        }
        catch (IllegalArgumentException i17){}
    }

    //---- Tests if maximumPoolSize is equal to zero
    public void testConstructor18() {
        try{
            new ThreadPoolExecutor(1,0,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testThread(),new testReject());
            fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");            
        }
        catch (IllegalArgumentException i18){}
    }

    //---- Tests if keepAliveTime is less than zero
    public void testConstructor19() {
        try{
            new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testThread(),new testReject());
            fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");            
        }
        catch (IllegalArgumentException i19){}
    }

    //---- Tests if corePoolSize is greater than the maximumPoolSize
    public void testConstructor20() {
        try{
            new ThreadPoolExecutor(2,1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testThread(),new testReject());
            fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");            
        }
        catch (IllegalArgumentException i20){}
    }

    //---- Tests if workQueue is set to null
    public void testNullPointerException6() {
        try{
            new ThreadPoolExecutor(1,2,100L,TimeUnit.MILLISECONDS,null,new testThread(),new testReject());
            fail("ThreadPoolExecutor constructor should throw a NullPointerException");         
        }
        catch (NullPointerException n6){}  
    }

    //---- Tests if handler is set to null
    public void testNullPointerException7() {
        try{
            RejectedExecutionHandler r = null;
            new ThreadPoolExecutor(1,2,100L,TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),new testThread(),r);
            fail("ThreadPoolExecutor constructor should throw a NullPointerException");         
        }
        catch (NullPointerException n7){}  
    }

    //---- Tests if ThradFactory is set top null
    public void testNullPointerException8() {
        try{
            ThreadFactory f = null;
            new ThreadPoolExecutor(1,2,100L,TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f,new testReject());
            fail("ThreadPoolExecutor constructor should throw a NullPointerException");         
        }
        catch (NullPointerException n8){}  
    }
    

    /**
     *  Test to verify execute will throw RejectedExcutionException
     *  ThreadPoolExecutor will throw one when more runnables are
     *  executed then will fit in the Queue.
     */
    public void testRejectedExecutedException(){
        ThreadPoolExecutor tpe = null;
        try{
            tpe = new ThreadPoolExecutor(1,1,100,TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(1));
        }catch(Exception e){}
        tpe.shutdown();
        try{
            tpe.execute(new Runnable(){
                    public void run(){
                        try{
                            Thread.sleep(1000);
                        }catch(InterruptedException e){}
                    }
                });
            fail("ThreadPoolExecutor - void execute(Runnable) should throw RejectedExecutionException");
        }catch(RejectedExecutionException sucess){}
        
        
    }
    
    /**
     *  Test to verify setCorePoolSize will throw IllegalArgumentException
     *  when given a negative 
     */
    public void testIllegalArgumentException1(){
        ThreadPoolExecutor tpe = null;
        try{
            tpe = new ThreadPoolExecutor(1,2,100,TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
        }catch(Exception e){}
        try{
            tpe.setCorePoolSize(-1);
            fail("ThreadPoolExecutor - void setCorePoolSize(int) should throw IllegalArgumentException");
        }catch(IllegalArgumentException sucess){
        } finally {
            tpe.shutdown();
        }
    }   

    
    /**
     *  Test to verify setMaximumPoolSize(int) will throw IllegalArgumentException
     *  if given a value less the it's actual core pool size
     */  
    public void testIllegalArgumentException2(){
        ThreadPoolExecutor tpe = null;
        try{
            tpe = new ThreadPoolExecutor(2,3,100,TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
        }catch(Exception e){}
        try{
            tpe.setMaximumPoolSize(1);
            fail("ThreadPoolExecutor - void setMaximumPoolSize(int) should throw IllegalArgumentException");
        }catch(IllegalArgumentException sucess){
        } finally {
            tpe.shutdown();
        }
    }
    
    /**
     *  Test to verify that setMaximumPoolSize will throw IllegalArgumentException
     *  if given a negative number
     */
    public void testIllegalArgumentException2SP(){
        ThreadPoolExecutor tpe = null;
        try{
            tpe = new ThreadPoolExecutor(2,3,100,TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
        }catch(Exception e){}
        try{
            tpe.setMaximumPoolSize(-1);
            fail("ThreadPoolExecutor - void setMaximumPoolSize(int) should throw IllegalArgumentException");
        }catch(IllegalArgumentException sucess){
        } finally {
            tpe.shutdown();
        }
    }
    

    /**
     *  Test to verify setKeepAliveTime will throw IllegalArgumentException
     *  when given a negative value
     */
    public void testIllegalArgumentException3(){
        ThreadPoolExecutor tpe = null;
        try{
            tpe = new ThreadPoolExecutor(2,3,100,TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
        }catch(Exception e){}
        
        try{
            tpe.setKeepAliveTime(-1,TimeUnit.MILLISECONDS);
            fail("ThreadPoolExecutor - void setKeepAliveTime(long, TimeUnit) should throw IllegalArgumentException");
        }catch(IllegalArgumentException sucess){
        } finally {
            tpe.shutdown();
        }
    }
  
    
}
Revision:	1.1
Committed:	Sun Aug 31 19:24:56 2003 UTC (20 years, 8 months ago) by dl
Branch:	MAIN
Log Message:	First check-in of tests to be in tck
#	User	Rev	Content
1	dl	1.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 TestCase{
13			public static void main(String[] args) {
14			junit.textui.TestRunner.run (suite());
15			}
16
17
18			public static Test suite() {
19			return new TestSuite(ThreadPoolExecutorTest.class);
20			}
21
22			private static long SHORT_DELAY_MS = 100;
23			private static long MEDIUM_DELAY_MS = 1000;
24			private static long LONG_DELAY_MS = 10000;
25
26			//---- testThread class to implement ThreadFactory for use in constructors
27			static class testThread implements ThreadFactory{
28			public Thread newThread(Runnable r){
29			return new Thread(r);
30			}
31			}
32
33			//---- testReject class to implement RejectedExecutionHandler for use in the constructors
34			static class testReject implements RejectedExecutionHandler{
35			public void rejectedExecution(Runnable r, ThreadPoolExecutor executor){}
36			}
37
38			public Runnable newRunnable(){
39			return new Runnable(){
40			public void run(){
41			try{Thread.sleep(MEDIUM_DELAY_MS);
42			} catch(Exception e){
43			}
44			}
45			};
46			}
47
48
49			/**
50			* Test to verify that execute successfully executes a runnable
51			*/
52			public void testExecute(){
53			ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
54			try {
55			one.execute(new Runnable(){
56			public void run(){
57			try{
58			Thread.sleep(SHORT_DELAY_MS);
59			}catch(InterruptedException e){
60			fail("unexpected exception");
61			}
62			}
63			});
64			Thread.sleep(SHORT_DELAY_MS * 2);
65			}catch(InterruptedException e){
66			fail("unexpected exception");
67			} finally {
68			one.shutdown();
69			}
70			}
71
72			/**
73			* Test to verify getActiveCount gives correct values
74			*/
75			public void testGetActiveCount(){
76			ThreadPoolExecutor two = new ThreadPoolExecutor(2, 2, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
77			try {
78			assertEquals(0, two.getActiveCount());
79			two.execute(newRunnable());
80			try{Thread.sleep(10);}catch(Exception e){}
81			assertEquals(1, two.getActiveCount());
82			} finally {
83			two.shutdown();
84			}
85			}
86
87			/**
88			* Test to verify getCompleteTaskCount gives correct values
89			*/
90			public void testGetCompletedTaskCount(){
91			ThreadPoolExecutor two = new ThreadPoolExecutor(2, 2, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
92			try {
93			assertEquals(0, two.getCompletedTaskCount());
94			two.execute(newRunnable());
95			try{Thread.sleep(2000);}catch(Exception e){}
96			assertEquals(1, two.getCompletedTaskCount());
97			} finally {
98			two.shutdown();
99			}
100			}
101
102			/**
103			* Test to verify getCorePoolSize gives correct values
104			*/
105			public void testGetCorePoolSize(){
106			ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
107			try {
108			assertEquals(1, one.getCorePoolSize());
109			} finally {
110			one.shutdown();
111			}
112			}
113
114			/**
115			* Test to verify getKeepAliveTime gives correct values
116			*/
117			public void testGetKeepAliveTime(){
118			ThreadPoolExecutor two = new ThreadPoolExecutor(2, 2, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
119			try {
120			assertEquals(1, two.getKeepAliveTime(TimeUnit.SECONDS));
121			} finally {
122			two.shutdown();
123			}
124			}
125
126			/**
127			* Test to verify getLargestPoolSize gives correct values
128			*/
129			public void testGetLargestPoolSize(){
130			ThreadPoolExecutor two = new ThreadPoolExecutor(2, 2, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
131			try {
132			assertEquals(0, two.getLargestPoolSize());
133			two.execute(newRunnable());
134			two.execute(newRunnable());
135			try{Thread.sleep(SHORT_DELAY_MS);} catch(Exception e){}
136			assertEquals(2, two.getLargestPoolSize());
137			} finally {
138			two.shutdown();
139			}
140			}
141
142			/**
143			* Test to verify getMaximumPoolSize gives correct values
144			*/
145			public void testGetMaximumPoolSize(){
146			ThreadPoolExecutor two = new ThreadPoolExecutor(2, 2, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
147			try {
148			assertEquals(2, two.getMaximumPoolSize());
149			} finally {
150			two.shutdown();
151			}
152			}
153
154			/**
155			* Test to verify getPoolSize gives correct values
156			*/
157			public void testGetPoolSize(){
158			ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
159			try {
160			assertEquals(0, one.getPoolSize());
161			one.execute(newRunnable());
162			assertEquals(1, one.getPoolSize());
163			} finally {
164			one.shutdown();
165			}
166			}
167
168			/**
169			* Test to verify getTaskCount gives correct values
170			*/
171			public void testGetTaskCount(){
172			ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
173			try {
174			assertEquals(0, one.getTaskCount());
175			for(int i = 0; i < 5; i++)
176			one.execute(newRunnable());
177			try{Thread.sleep(SHORT_DELAY_MS);}catch(Exception e){}
178			assertEquals(5, one.getTaskCount());
179			} finally {
180			one.shutdown();
181			}
182			}
183
184			/**
185			* Test to verify isShutDown gives correct values
186			*/
187			public void testIsShutdown(){
188
189			ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
190			try {
191			assertFalse(one.isShutdown());
192			}
193			finally {
194			one.shutdown();
195			}
196			assertTrue(one.isShutdown());
197			}
198
199
200			/**
201			* Test to verify isTerminated gives correct values
202			* Makes sure termination does not take an innapropriate
203			* amount of time
204			*/
205			public void testIsTerminated(){
206			ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
207			try {
208			one.execute(newRunnable());
209			} finally {
210			one.shutdown();
211			}
212			boolean flag = false;
213			try{
214			flag = one.awaitTermination(10, TimeUnit.SECONDS);
215			}catch(Exception e){}
216			assertTrue(one.isTerminated());
217			if(!flag)
218			fail("ThreadPoolExecutor - thread pool did not terminate within suitable timeframe");
219			}
220
221			/**
222			* Test to verify that purge correctly removes cancelled tasks
223			* from the queue
224			*/
225			public void testPurge(){
226			ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
227			try {
228			CancellableTask[] tasks = new CancellableTask[5];
229			for(int i = 0; i < 5; i++){
230			tasks[i] = new CancellableTask(newRunnable());
231			one.execute(tasks[i]);
232			}
233			tasks[4].cancel(true);
234			tasks[3].cancel(true);
235			one.purge();
236			long count = one.getTaskCount();
237			assertTrue(count >= 2 && count < 5);
238			} finally {
239			one.shutdown();
240			}
241			}
242
243			/**
244			* Test to verify shutDownNow returns a list
245			* containing the correct number of elements
246			*/
247			public void testShutDownNow(){
248			ThreadPoolExecutor one = new ThreadPoolExecutor(1, 1, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
249			List l;
250			try {
251			for(int i = 0; i < 5; i++)
252			one.execute(newRunnable());
253			}
254			finally {
255			l = one.shutdownNow();
256			}
257			assertTrue(one.isShutdown());
258			assertTrue(l.size() <= 4);
259			}
260
261
262
263
264
265
266			// Exception Tests
267
268
269			//---- Tests if corePoolSize argument is less than zero
270			public void testConstructor1() {
271			try{
272			new ThreadPoolExecutor(-1,1,100L,TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
273			fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
274			}
275			catch (IllegalArgumentException i){}
276			}
277
278			//---- Tests if maximumPoolSize is less than zero
279			public void testConstructor2() {
280			try{
281			new ThreadPoolExecutor(1,-1,100L,TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
282			fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
283			}
284			catch (IllegalArgumentException i2){}
285			}
286
287			//---- Tests if maximumPoolSize is equal to zero
288			public void testConstructor3() {
289			try{
290			new ThreadPoolExecutor(1,0,100L,TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
291			fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
292			}
293			catch (IllegalArgumentException i3){}
294			}
295
296			//---- Tests if keepAliveTime is less than zero
297			public void testConstructor4() {
298			try{
299			new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10));
300			fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
301			}
302			catch (IllegalArgumentException i4){}
303			}
304
305			//---- Tests if corePoolSize is greater than the maximumPoolSize
306			public void testConstructor5() {
307			try{
308			new ThreadPoolExecutor(2,1,100L,TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10));
309			fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
310			}
311			catch (IllegalArgumentException i5){}
312			}
313
314			//---- Tests if workQueue is set to null
315			public void testNullPointerException() {
316			try{
317			new ThreadPoolExecutor(1,2,100L,TimeUnit.MILLISECONDS,null);
318			fail("ThreadPoolExecutor constructor should throw a NullPointerException");
319			}
320			catch (NullPointerException n){}
321			}
322
323
324
325			//---- Tests if corePoolSize argument is less than zero
326			public void testConstructor6() {
327			try{
328			new ThreadPoolExecutor(-1,1,100L,TimeUnit.SECONDS, new ArrayBlockingQueue<Runnable>(10),new testThread());
329			fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
330			}catch (IllegalArgumentException i6){}
331			}
332
333			//---- Tests if maximumPoolSize is less than zero
334			public void testConstructor7() {
335			try{
336			new ThreadPoolExecutor(1,-1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testThread());
337			fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
338			}
339			catch (IllegalArgumentException i7){}
340			}
341
342			//---- Tests if maximumPoolSize is equal to zero
343			public void testConstructor8() {
344			try{
345			new ThreadPoolExecutor(1,0,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testThread());
346			fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
347			}
348			catch (IllegalArgumentException i8){}
349			}
350
351			//---- Tests if keepAliveTime is less than zero
352			public void testConstructor9() {
353			try{
354			new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testThread());
355			fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
356			}
357			catch (IllegalArgumentException i9){}
358			}
359
360			//---- Tests if corePoolSize is greater than the maximumPoolSize
361			public void testConstructor10() {
362			try{
363			new ThreadPoolExecutor(2,1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testThread());
364			fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
365			}
366			catch (IllegalArgumentException i10){}
367			}
368
369			//---- Tests if workQueue is set to null
370			public void testNullPointerException2() {
371			try{
372			new ThreadPoolExecutor(1,2,100L,TimeUnit.MILLISECONDS,null,new testThread());
373			fail("ThreadPoolExecutor constructor should throw a NullPointerException");
374			}
375			catch (NullPointerException n2){}
376			}
377
378			//---- Tests if threadFactory is set to null
379			public void testNullPointerException3() {
380			try{
381			ThreadFactory f = null;
382			new ThreadPoolExecutor(1,2,100L,TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f);
383			fail("ThreadPoolExecutor constructor should throw a NullPointerException");
384			}
385			catch (NullPointerException n3){}
386			}
387
388
389			//---- Tests if corePoolSize argument is less than zero
390			public void testConstructor11() {
391			try{
392			new ThreadPoolExecutor(-1,1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testReject());
393			fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
394			}
395			catch (IllegalArgumentException i11){}
396			}
397
398			//---- Tests if maximumPoolSize is less than zero
399			public void testConstructor12() {
400			try{
401			new ThreadPoolExecutor(1,-1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testReject());
402			fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
403			}
404			catch (IllegalArgumentException i12){}
405			}
406
407			//---- Tests if maximumPoolSize is equal to zero
408			public void testConstructor13() {
409			try{
410			new ThreadPoolExecutor(1,0,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testReject());
411			fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
412			}
413			catch (IllegalArgumentException i13){}
414			}
415
416			//---- Tests if keepAliveTime is less than zero
417			public void testConstructor14() {
418			try{
419			new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testReject());
420			fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
421			}
422			catch (IllegalArgumentException i14){}
423			}
424
425			//---- Tests if corePoolSize is greater than the maximumPoolSize
426			public void testConstructor15() {
427			try{
428			new ThreadPoolExecutor(2,1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testReject());
429			fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
430			}
431			catch (IllegalArgumentException i15){}
432			}
433
434			//---- Tests if workQueue is set to null
435			public void testNullPointerException4() {
436			try{
437			new ThreadPoolExecutor(1,2,100L,TimeUnit.MILLISECONDS,null,new testReject());
438			fail("ThreadPoolExecutor constructor should throw a NullPointerException");
439			}
440			catch (NullPointerException n4){}
441			}
442
443			//---- Tests if handler is set to null
444			public void testNullPointerException5() {
445			try{
446			RejectedExecutionHandler r = null;
447			new ThreadPoolExecutor(1,2,100L,TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),r);
448			fail("ThreadPoolExecutor constructor should throw a NullPointerException");
449			}
450			catch (NullPointerException n5){}
451			}
452
453
454			//---- Tests if corePoolSize argument is less than zero
455			public void testConstructor16() {
456			try{
457			new ThreadPoolExecutor(-1,1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testThread(),new testReject());
458			fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
459			}
460			catch (IllegalArgumentException i16){}
461			}
462
463			//---- Tests if maximumPoolSize is less than zero
464			public void testConstructor17() {
465			try{
466			new ThreadPoolExecutor(1,-1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testThread(),new testReject());
467			fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
468			}
469			catch (IllegalArgumentException i17){}
470			}
471
472			//---- Tests if maximumPoolSize is equal to zero
473			public void testConstructor18() {
474			try{
475			new ThreadPoolExecutor(1,0,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testThread(),new testReject());
476			fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
477			}
478			catch (IllegalArgumentException i18){}
479			}
480
481			//---- Tests if keepAliveTime is less than zero
482			public void testConstructor19() {
483			try{
484			new ThreadPoolExecutor(1,2,-1L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testThread(),new testReject());
485			fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
486			}
487			catch (IllegalArgumentException i19){}
488			}
489
490			//---- Tests if corePoolSize is greater than the maximumPoolSize
491			public void testConstructor20() {
492			try{
493			new ThreadPoolExecutor(2,1,100L,TimeUnit.MILLISECONDS, new ArrayBlockingQueue<Runnable>(10),new testThread(),new testReject());
494			fail("ThreadPoolExecutor constructor should throw an IllegalArgumentException");
495			}
496			catch (IllegalArgumentException i20){}
497			}
498
499			//---- Tests if workQueue is set to null
500			public void testNullPointerException6() {
501			try{
502			new ThreadPoolExecutor(1,2,100L,TimeUnit.MILLISECONDS,null,new testThread(),new testReject());
503			fail("ThreadPoolExecutor constructor should throw a NullPointerException");
504			}
505			catch (NullPointerException n6){}
506			}
507
508			//---- Tests if handler is set to null
509			public void testNullPointerException7() {
510			try{
511			RejectedExecutionHandler r = null;
512			new ThreadPoolExecutor(1,2,100L,TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),new testThread(),r);
513			fail("ThreadPoolExecutor constructor should throw a NullPointerException");
514			}
515			catch (NullPointerException n7){}
516			}
517
518			//---- Tests if ThradFactory is set top null
519			public void testNullPointerException8() {
520			try{
521			ThreadFactory f = null;
522			new ThreadPoolExecutor(1,2,100L,TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10),f,new testReject());
523			fail("ThreadPoolExecutor constructor should throw a NullPointerException");
524			}
525			catch (NullPointerException n8){}
526			}
527
528
529			/**
530			* Test to verify execute will throw RejectedExcutionException
531			* ThreadPoolExecutor will throw one when more runnables are
532			* executed then will fit in the Queue.
533			*/
534			public void testRejectedExecutedException(){
535			ThreadPoolExecutor tpe = null;
536			try{
537			tpe = new ThreadPoolExecutor(1,1,100,TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(1));
538			}catch(Exception e){}
539			tpe.shutdown();
540			try{
541			tpe.execute(new Runnable(){
542			public void run(){
543			try{
544			Thread.sleep(1000);
545			}catch(InterruptedException e){}
546			}
547			});
548			fail("ThreadPoolExecutor - void execute(Runnable) should throw RejectedExecutionException");
549			}catch(RejectedExecutionException sucess){}
550
551
552			}
553
554			/**
555			* Test to verify setCorePoolSize will throw IllegalArgumentException
556			* when given a negative
557			*/
558			public void testIllegalArgumentException1(){
559			ThreadPoolExecutor tpe = null;
560			try{
561			tpe = new ThreadPoolExecutor(1,2,100,TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
562			}catch(Exception e){}
563			try{
564			tpe.setCorePoolSize(-1);
565			fail("ThreadPoolExecutor - void setCorePoolSize(int) should throw IllegalArgumentException");
566			}catch(IllegalArgumentException sucess){
567			} finally {
568			tpe.shutdown();
569			}
570			}
571
572
573			/**
574			* Test to verify setMaximumPoolSize(int) will throw IllegalArgumentException
575			* if given a value less the it's actual core pool size
576			*/
577			public void testIllegalArgumentException2(){
578			ThreadPoolExecutor tpe = null;
579			try{
580			tpe = new ThreadPoolExecutor(2,3,100,TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
581			}catch(Exception e){}
582			try{
583			tpe.setMaximumPoolSize(1);
584			fail("ThreadPoolExecutor - void setMaximumPoolSize(int) should throw IllegalArgumentException");
585			}catch(IllegalArgumentException sucess){
586			} finally {
587			tpe.shutdown();
588			}
589			}
590
591			/**
592			* Test to verify that setMaximumPoolSize will throw IllegalArgumentException
593			* if given a negative number
594			*/
595			public void testIllegalArgumentException2SP(){
596			ThreadPoolExecutor tpe = null;
597			try{
598			tpe = new ThreadPoolExecutor(2,3,100,TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
599			}catch(Exception e){}
600			try{
601			tpe.setMaximumPoolSize(-1);
602			fail("ThreadPoolExecutor - void setMaximumPoolSize(int) should throw IllegalArgumentException");
603			}catch(IllegalArgumentException sucess){
604			} finally {
605			tpe.shutdown();
606			}
607			}
608
609
610			/**
611			* Test to verify setKeepAliveTime will throw IllegalArgumentException
612			* when given a negative value
613			*/
614			public void testIllegalArgumentException3(){
615			ThreadPoolExecutor tpe = null;
616			try{
617			tpe = new ThreadPoolExecutor(2,3,100,TimeUnit.MILLISECONDS,new ArrayBlockingQueue<Runnable>(10));
618			}catch(Exception e){}
619
620			try{
621			tpe.setKeepAliveTime(-1,TimeUnit.MILLISECONDS);
622			fail("ThreadPoolExecutor - void setKeepAliveTime(long, TimeUnit) should throw IllegalArgumentException");
623			}catch(IllegalArgumentException sucess){
624			} finally {
625			tpe.shutdown();
626			}
627			}
628
629
630
631			}