harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ndbe...@apache.org
Subject svn commit: r442038 [19/19] - in /incubator/harmony/standard/classlib/trunk/modules/concurrent: ./ src/ src/main/ src/main/java/ src/main/java/java/ src/main/java/java/util/ src/main/java/java/util/concurrent/ src/main/java/java/util/concurrent/atomic/...
Date Sun, 10 Sep 2006 23:59:35 GMT
Added: incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ThreadPoolExecutorTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ThreadPoolExecutorTest.java?view=auto&rev=442038
==============================================================================
--- incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ThreadPoolExecutorTest.java (added)
+++ incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ThreadPoolExecutorTest.java Sun Sep 10 16:59:30 2006
@@ -0,0 +1,1502 @@
+/*
+ * 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 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;
+        }
+    }
+
+    /**
+     *  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]));
+        } 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);
+        }
+    }
+
+
+}

Propchange: incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ThreadPoolExecutorTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ThreadTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ThreadTest.java?view=auto&rev=442038
==============================================================================
--- incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ThreadTest.java (added)
+++ incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ThreadTest.java Sun Sep 10 16:59:30 2006
@@ -0,0 +1,68 @@
+/*
+ * 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 junit.framework.*;
+
+public class ThreadTest extends JSR166TestCase {
+    public static void main(String[] args) {
+	junit.textui.TestRunner.run(suite());	
+    }
+    
+    public static Test suite() {
+	return new TestSuite(ThreadTest.class);
+    }
+
+    static class MyHandler implements Thread.UncaughtExceptionHandler {
+        public void uncaughtException(Thread t, Throwable e) {
+            e.printStackTrace();
+        }
+    }
+    
+    /**
+     * getUncaughtExceptionHandler returns ThreadGroup unless set,
+     * otherwise returning value of last setUncaughtExceptionHandler.
+     */
+    public void testGetAndSetUncaughtExceptionHandler() {
+        // these must be done all at once to avoid state
+        // dependencies across tests
+        Thread current = Thread.currentThread();
+        ThreadGroup tg = current.getThreadGroup();
+        MyHandler eh = new MyHandler();
+	assertEquals(tg, current.getUncaughtExceptionHandler());
+        current.setUncaughtExceptionHandler(eh);
+	assertEquals(eh, current.getUncaughtExceptionHandler());
+        current.setUncaughtExceptionHandler(null);
+	assertEquals(tg, current.getUncaughtExceptionHandler());
+    }
+
+    /**
+     * getDefaultUncaughtExceptionHandler returns value of last
+     * setDefaultUncaughtExceptionHandler. 
+     */
+    public void testGetAndSetDefaultUncaughtExceptionHandler() {
+        assertEquals(null, Thread.getDefaultUncaughtExceptionHandler());
+        // failure due to securityException is OK.
+        // Would be nice to explicitly test both ways, but cannot yet.
+        try {
+            Thread current = Thread.currentThread();
+            ThreadGroup tg = current.getThreadGroup();
+            MyHandler eh = new MyHandler();
+            Thread.setDefaultUncaughtExceptionHandler(eh);
+            assertEquals(eh, Thread.getDefaultUncaughtExceptionHandler());
+            Thread.setDefaultUncaughtExceptionHandler(null);
+        }
+        catch(SecurityException ok) {
+        }
+        assertEquals(null, Thread.getDefaultUncaughtExceptionHandler());
+    }
+
+    
+    // How to test actually using UEH within junit?
+
+}
+

Propchange: incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/ThreadTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/TimeUnitTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/TimeUnitTest.java?view=auto&rev=442038
==============================================================================
--- incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/TimeUnitTest.java (added)
+++ incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/TimeUnitTest.java Sun Sep 10 16:59:30 2006
@@ -0,0 +1,332 @@
+/*
+ * 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 junit.framework.*;
+import java.util.concurrent.*;
+import java.io.*;
+
+public class TimeUnitTest extends JSR166TestCase {
+    public static void main(String[] args) {
+	junit.textui.TestRunner.run(suite());	
+    }
+    
+    public static Test suite() {
+	return new TestSuite(TimeUnitTest.class);
+    }
+
+    /**
+     * convert correctly converts sample values across the four units
+     */
+    public void testConvert() {
+        for (long t = 0; t < 10; ++t) {
+            assertEquals(t, 
+                         TimeUnit.SECONDS.convert(t, 
+                                                  TimeUnit.SECONDS));
+            assertEquals(t, 
+                         TimeUnit.SECONDS.convert(1000 * t, 
+                                                  TimeUnit.MILLISECONDS));
+            assertEquals(t, 
+                         TimeUnit.SECONDS.convert(1000000 * t, 
+                                                  TimeUnit.MICROSECONDS));
+            assertEquals(t, 
+                         TimeUnit.SECONDS.convert(1000000000 * t, 
+                                                  TimeUnit.NANOSECONDS));
+            assertEquals(1000 * t, 
+                         TimeUnit.MILLISECONDS.convert(t, 
+                                                  TimeUnit.SECONDS));
+            assertEquals(t, 
+                         TimeUnit.MILLISECONDS.convert(t, 
+                                                  TimeUnit.MILLISECONDS));
+            assertEquals(t, 
+                         TimeUnit.MILLISECONDS.convert(1000 * t, 
+                                                  TimeUnit.MICROSECONDS));
+            assertEquals(t, 
+                         TimeUnit.MILLISECONDS.convert(1000000 * t, 
+                                                  TimeUnit.NANOSECONDS));
+            assertEquals(1000000 * t, 
+                         TimeUnit.MICROSECONDS.convert(t, 
+                                                  TimeUnit.SECONDS));
+            assertEquals(1000 * t, 
+                         TimeUnit.MICROSECONDS.convert(t, 
+                                                  TimeUnit.MILLISECONDS));
+            assertEquals(t, 
+                         TimeUnit.MICROSECONDS.convert(t, 
+                                                  TimeUnit.MICROSECONDS));
+            assertEquals(t, 
+                         TimeUnit.MICROSECONDS.convert(1000 * t, 
+                                                  TimeUnit.NANOSECONDS));
+            assertEquals(1000000000 * t, 
+                         TimeUnit.NANOSECONDS.convert(t, 
+                                                  TimeUnit.SECONDS));
+            assertEquals(1000000 * t, 
+                         TimeUnit.NANOSECONDS.convert(t, 
+                                                  TimeUnit.MILLISECONDS));
+            assertEquals(1000 * t, 
+                         TimeUnit.NANOSECONDS.convert(t, 
+                                                  TimeUnit.MICROSECONDS));
+            assertEquals(t, 
+                         TimeUnit.NANOSECONDS.convert(t, 
+                                                  TimeUnit.NANOSECONDS));
+        }
+    }
+
+    /**
+     * toNanos correctly converts sample values in different units to
+     * nanoseconds
+     */
+    public void testToNanos() {
+        for (long t = 0; t < 10; ++t) {
+            assertEquals(1000000000 * t, 
+                         TimeUnit.SECONDS.toNanos(t));
+
+            assertEquals(1000000 * t, 
+                         TimeUnit.MILLISECONDS.toNanos(t));
+            assertEquals(1000 * t, 
+                         TimeUnit.MICROSECONDS.toNanos(t));
+            assertEquals(t, 
+                         TimeUnit.NANOSECONDS.toNanos(t));
+        }
+    }
+
+    /**
+     * toMicros correctly converts sample values in different units to
+     * microseconds
+     */
+    public void testToMicros() {
+        for (long t = 0; t < 10; ++t) {
+            assertEquals(1000000 * t, 
+                         TimeUnit.SECONDS.toMicros(t));
+
+            assertEquals(1000 * t, 
+                         TimeUnit.MILLISECONDS.toMicros(t));
+            assertEquals(t, 
+                         TimeUnit.MICROSECONDS.toMicros(t));
+            assertEquals(t, 
+                         TimeUnit.NANOSECONDS.toMicros(t * 1000));
+        }
+    }
+
+    /**
+     * toMillis correctly converts sample values in different units to
+     * milliseconds
+     */
+    public void testToMillis() {
+        for (long t = 0; t < 10; ++t) {
+            assertEquals(1000 * t, 
+                         TimeUnit.SECONDS.toMillis(t));
+
+            assertEquals(t, 
+                         TimeUnit.MILLISECONDS.toMillis(t));
+            assertEquals(t, 
+                         TimeUnit.MICROSECONDS.toMillis(t * 1000));
+            assertEquals(t, 
+                         TimeUnit.NANOSECONDS.toMillis(t * 1000000));
+        }
+    }
+
+    /**
+     * toSeconds correctly converts sample values in different units to
+     * seconds
+     */
+    public void testToSeconds() {
+        for (long t = 0; t < 10; ++t) {
+            assertEquals(t, 
+                         TimeUnit.SECONDS.toSeconds(t));
+
+            assertEquals(t, 
+                         TimeUnit.MILLISECONDS.toSeconds(t * 1000));
+            assertEquals(t, 
+                         TimeUnit.MICROSECONDS.toSeconds(t * 1000000));
+            assertEquals(t, 
+                         TimeUnit.NANOSECONDS.toSeconds(t * 1000000000));
+        }
+    }
+
+
+    /**
+     * convert saturates positive too-large values to Long.MAX_VALUE 
+     * and negative to LONG.MIN_VALUE
+     */
+    public void testConvertSaturate() {
+        assertEquals(Long.MAX_VALUE,
+                     TimeUnit.NANOSECONDS.convert(Long.MAX_VALUE / 2,
+                                                  TimeUnit.SECONDS));
+        assertEquals(Long.MIN_VALUE,
+                     TimeUnit.NANOSECONDS.convert(-Long.MAX_VALUE / 4,
+                                                  TimeUnit.SECONDS));
+    }
+
+    /**
+     * toNanos saturates positive too-large values to Long.MAX_VALUE 
+     * and negative to LONG.MIN_VALUE
+     */
+    public void testToNanosSaturate() {
+            assertEquals(Long.MAX_VALUE,
+                         TimeUnit.MILLISECONDS.toNanos(Long.MAX_VALUE / 2));
+            assertEquals(Long.MIN_VALUE,
+                         TimeUnit.MILLISECONDS.toNanos(-Long.MAX_VALUE / 3));
+    }
+
+
+    /**
+     * toString returns string containing common name of unit
+     */
+    public void testToString() {
+        String s = TimeUnit.SECONDS.toString();
+        assertTrue(s.indexOf("ECOND") >= 0);
+    }
+
+    
+    /**
+     *  Timed wait without holding lock throws
+     *  IllegalMonitorStateException
+     */
+    public void testTimedWait_IllegalMonitorException() {
+	//created a new thread with anonymous runnable
+
+        Thread t = new Thread(new Runnable() {
+                public void run() {
+                    Object o = new Object();
+                    TimeUnit tu = TimeUnit.MILLISECONDS;
+                    try {
+                        tu.timedWait(o,LONG_DELAY_MS);
+                        threadShouldThrow();
+                    }
+                    catch (InterruptedException ie) {
+                        threadUnexpectedException();
+                    } 
+                    catch(IllegalMonitorStateException success) {
+                    }
+                    
+                }
+            });
+        t.start();
+        try {
+            Thread.sleep(SHORT_DELAY_MS);
+            t.interrupt();
+            t.join();
+        } catch(Exception e) {
+            unexpectedException();
+        }
+    }
+    
+    /**
+     * timedWait throws InterruptedException when interrupted
+     */
+    public void testTimedWait() {
+	Thread t = new Thread(new Runnable() {
+		public void run() {
+		    Object o = new Object();
+		    
+		    TimeUnit tu = TimeUnit.MILLISECONDS;
+		    try {
+			synchronized(o) {
+			    tu.timedWait(o,MEDIUM_DELAY_MS);
+			}
+                        threadShouldThrow();
+		    }
+		    catch(InterruptedException success) {} 
+		    catch(IllegalMonitorStateException failure) {
+			threadUnexpectedException();
+		    }
+		}
+	    });
+	t.start();
+        try {
+            Thread.sleep(SHORT_DELAY_MS);
+            t.interrupt();
+            t.join();
+        } catch(Exception e) {
+            unexpectedException();
+        }
+    }
+    
+    
+    /**
+     * timedJoin throws InterruptedException when interrupted
+     */
+    public void testTimedJoin() {
+	Thread t = new Thread(new Runnable() {
+		public void run() {
+		    TimeUnit tu = TimeUnit.MILLISECONDS;	
+		    try {
+			Thread s = new Thread(new Runnable() {
+                                public void run() {
+                                    try {
+                                        Thread.sleep(MEDIUM_DELAY_MS);
+                                    } catch(InterruptedException success){}
+                                }
+                            });
+			s.start();
+			tu.timedJoin(s,MEDIUM_DELAY_MS);
+                        threadShouldThrow();
+		    }
+		    catch(Exception e) {}
+		}
+	    });
+	t.start();
+        try {
+            Thread.sleep(SHORT_DELAY_MS);
+            t.interrupt();
+            t.join();
+        } catch(Exception e) {
+            unexpectedException();
+        }
+    }
+    
+    /**
+     *  timedSleep throws InterruptedException when interrupted
+     */
+    public void testTimedSleep() {
+	//created a new thread with anonymous runnable
+
+	Thread t = new Thread(new Runnable() {
+		public void run() {
+		    TimeUnit tu = TimeUnit.MILLISECONDS;
+		    try {
+			tu.sleep(MEDIUM_DELAY_MS);
+                        threadShouldThrow();
+		    }
+		    catch(InterruptedException success) {} 
+		}
+	    });
+	t.start();
+        try {
+            Thread.sleep(SHORT_DELAY_MS);
+            t.interrupt();
+            t.join();
+        } catch(Exception e) {
+            unexpectedException();
+        }
+    }
+
+    /**
+     * a deserialized serialized unit is equal 
+     */
+    public void testSerialization() {
+        TimeUnit q = TimeUnit.MILLISECONDS;
+
+        try {
+            ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
+            ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
+            out.writeObject(q);
+            out.close();
+
+            ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
+            ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
+            TimeUnit r = (TimeUnit)in.readObject();
+            
+            assertEquals(q.toString(), r.toString());
+        } catch(Exception e){
+            e.printStackTrace();
+            unexpectedException();
+        }
+    }
+
+}

Propchange: incubator/harmony/standard/classlib/trunk/modules/concurrent/src/test/java/TimeUnitTest.java
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message