test/tck/ExecutorCompletionServiceTest.java

/*
 * 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.*;
import java.util.concurrent.*;
import java.math.BigInteger;
import java.security.*;

public class ExecutorCompletionServiceTest extends JSR166TestCase{
    public static void main(String[] args) {
        junit.textui.TestRunner.run (suite());  
    }
    public static Test suite() {
        return new TestSuite(ExecutorCompletionServiceTest.class);
    }


    /**
     * Creating a new ECS with null Executor throw NPE
     */ 
    public void testConstructorNPE() {
        try {
            ExecutorCompletionService ecs = new ExecutorCompletionService(null);
            shouldThrow();
        } catch (NullPointerException success) {
        }
    }

    /**
     * Creating a new ECS with null queue throw NPE
     */ 
    public void testConstructorNPE2() {
        try {
            ExecutorService e = Executors.newCachedThreadPool();
            ExecutorCompletionService ecs = new ExecutorCompletionService(e, null);
            shouldThrow();
        } catch (NullPointerException success) {
        }
    }

    /**
     * Submitting a null callable throws NPE
     */ 
    public void testSubmitNPE() {
        ExecutorService e = Executors.newCachedThreadPool();
        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
        try {
            Callable c = null;
            ecs.submit(c);
            shouldThrow();
        } catch (NullPointerException success) {
        } finally {
            joinPool(e);
        }
    }

    /**
     * Submitting a null runnable throws NPE
     */ 
    public void testSubmitNPE2() {
        ExecutorService e = Executors.newCachedThreadPool();
        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
        try {
            Runnable r = null;
            ecs.submit(r, Boolean.TRUE);
            shouldThrow();
        } catch (NullPointerException success) {
        } finally {
            joinPool(e);
        }
    }

    /**
     * A taken submitted task is completed
     */ 
    public void testTake() {
        ExecutorService e = Executors.newCachedThreadPool();
        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
        try {
            Callable c = new StringTask();
            ecs.submit(c);
            Future f = ecs.take();
            assertTrue(f.isDone());
        } catch (Exception ex) {
            unexpectedException();
        } finally {
            joinPool(e);
        }
    }

    /**
     * Take returns the same future object returned by submit
     */ 
    public void testTake2() {
        ExecutorService e = Executors.newCachedThreadPool();
        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
        try {
            Callable c = new StringTask();
            Future f1 = ecs.submit(c);
            Future f2 = ecs.take();
            assertSame(f1, f2);
        } catch (Exception ex) {
            unexpectedException();
        } finally {
            joinPool(e);
        }
    }

    /**
     * If poll returns non-null, the returned task is completed
     */ 
    public void testPoll1() {
        ExecutorService e = Executors.newCachedThreadPool();
        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
        try {
            assertNull(ecs.poll());
            Callable c = new StringTask();
            ecs.submit(c);
            Thread.sleep(SHORT_DELAY_MS);
            for (;;) {
                Future f = ecs.poll();
                if (f != null) {
                    assertTrue(f.isDone());
                    break;
                }
            }
        } catch (Exception ex) {
            unexpectedException();
        } finally {
            joinPool(e);
        }
    }

    /**
     * If timed poll returns non-null, the returned task is completed
     */ 
    public void testPoll2() {
        ExecutorService e = Executors.newCachedThreadPool();
        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
        try {
            assertNull(ecs.poll());
            Callable c = new StringTask();
            ecs.submit(c);
            Future f = ecs.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
            if (f != null) 
                assertTrue(f.isDone());
        } catch (Exception ex) {
            unexpectedException();
        } finally {
            joinPool(e);
        }
    }
     /**
      * Submitting to underlying AES that overrides newTaskFor(Callable)
      * returns and eventually runs Future returned by newTaskFor.
      */
     public void testNewTaskForCallable() {
         final AtomicBoolean done = new AtomicBoolean(false);
         class MyCallableFuture<V> extends FutureTask<V> {
             MyCallableFuture(Callable<V> c) { super(c); }
             protected void done() { done.set(true); }
         }
         ExecutorService e = new ThreadPoolExecutor(
                                 1, 1, 30L, TimeUnit.SECONDS,
                                 new ArrayBlockingQueue<Runnable>(1)) {
             protected <T> RunnableFuture<T> newTaskFor(Callable<T> c) {
                 return new MyCallableFuture<T>(c);
             }
         };
         ExecutorCompletionService<String> ecs =
             new ExecutorCompletionService<String>(e);
         try {
             assertNull(ecs.poll());
             Callable<String> c = new StringTask();
             Future f1 = ecs.submit(c);
             assertTrue("submit must return MyCallableFuture",
                        f1 instanceof MyCallableFuture);
             Future f2 = ecs.take();
             assertSame("submit and take must return same objects", f1, f2);
             assertTrue("completed task must have set done", done.get());
         } catch (Exception ex) {
             unexpectedException();
         } finally {
             joinPool(e);
         }
     }

     /**
      * Submitting to underlying AES that overrides newTaskFor(Runnable,T)
      * returns and eventually runs Future returned by newTaskFor.
      */
     public void testNewTaskForRunnable() {
         final AtomicBoolean done = new AtomicBoolean(false);
         class MyRunnableFuture<V> extends FutureTask<V> {
             MyRunnableFuture(Runnable t, V r) { super(t, r); }
             protected void done() { done.set(true); }
         }
         ExecutorService e = new ThreadPoolExecutor(
                                 1, 1, 30L, TimeUnit.SECONDS,
                                 new ArrayBlockingQueue<Runnable>(1)) {
             protected <T> RunnableFuture<T> newTaskFor(Runnable t, T r) {
                 return new MyRunnableFuture<T>(t, r);
             }
         };
         ExecutorCompletionService<String> ecs =
             new ExecutorCompletionService<String>(e);
         try {
             assertNull(ecs.poll());
             Callable<String> c = new StringTask();
             Future f1 = ecs.submit(c);
             assertTrue("submit must return MyRunnableFuture",
                        f1 instanceof MyRunnableFuture);
             Future f2 = ecs.take();
             assertSame("submit and take must return same objects", f1, f2);
             assertTrue("completed task must have set done", done.get());
         } catch (Exception ex) {
             unexpectedException();
         } finally {
             joinPool(e);
         }
     }


}
Revision:	1.4
Committed:	Fri Jul 8 20:00:10 2005 UTC (18 years, 9 months ago) by dl
Branch:	MAIN
Changes since 1.3:	+71 -0 lines
Log Message:	Add tests for newTaskFor
#	User	Rev	Content
1	dl	1.1	/*
2	dl	1.2	* Written by Doug Lea with assistance from members of JCP JSR-166
3			* Expert Group and released to the public domain, as explained at
4			* http://creativecommons.org/licenses/publicdomain
5			* Other contributors include Andrew Wright, Jeffrey Hayes,
6			* Pat Fisher, Mike Judd.
7	dl	1.1	*/
8
9
10			import junit.framework.*;
11			import java.util.*;
12			import java.util.concurrent.*;
13			import java.math.BigInteger;
14			import java.security.*;
15
16			public class ExecutorCompletionServiceTest extends JSR166TestCase{
17			public static void main(String[] args) {
18			junit.textui.TestRunner.run (suite());
19			}
20			public static Test suite() {
21			return new TestSuite(ExecutorCompletionServiceTest.class);
22			}
23
24
25			/**
26			* Creating a new ECS with null Executor throw NPE
27			*/
28			public void testConstructorNPE() {
29			try {
30			ExecutorCompletionService ecs = new ExecutorCompletionService(null);
31			shouldThrow();
32			} catch (NullPointerException success) {
33			}
34			}
35
36			/**
37			* Creating a new ECS with null queue throw NPE
38			*/
39			public void testConstructorNPE2() {
40			try {
41			ExecutorService e = Executors.newCachedThreadPool();
42			ExecutorCompletionService ecs = new ExecutorCompletionService(e, null);
43			shouldThrow();
44			} catch (NullPointerException success) {
45			}
46			}
47
48			/**
49			* Submitting a null callable throws NPE
50			*/
51			public void testSubmitNPE() {
52			ExecutorService e = Executors.newCachedThreadPool();
53			ExecutorCompletionService ecs = new ExecutorCompletionService(e);
54			try {
55			Callable c = null;
56			ecs.submit(c);
57			shouldThrow();
58			} catch (NullPointerException success) {
59			} finally {
60			joinPool(e);
61			}
62			}
63
64			/**
65			* Submitting a null runnable throws NPE
66			*/
67			public void testSubmitNPE2() {
68			ExecutorService e = Executors.newCachedThreadPool();
69			ExecutorCompletionService ecs = new ExecutorCompletionService(e);
70			try {
71			Runnable r = null;
72			ecs.submit(r, Boolean.TRUE);
73			shouldThrow();
74			} catch (NullPointerException success) {
75			} finally {
76			joinPool(e);
77			}
78			}
79
80			/**
81			* A taken submitted task is completed
82			*/
83			public void testTake() {
84			ExecutorService e = Executors.newCachedThreadPool();
85			ExecutorCompletionService ecs = new ExecutorCompletionService(e);
86			try {
87			Callable c = new StringTask();
88			ecs.submit(c);
89			Future f = ecs.take();
90	dl	1.3	assertTrue(f.isDone());
91	dl	1.1	} catch (Exception ex) {
92			unexpectedException();
93			} finally {
94			joinPool(e);
95			}
96			}
97
98			/**
99			* Take returns the same future object returned by submit
100			*/
101			public void testTake2() {
102			ExecutorService e = Executors.newCachedThreadPool();
103			ExecutorCompletionService ecs = new ExecutorCompletionService(e);
104			try {
105			Callable c = new StringTask();
106			Future f1 = ecs.submit(c);
107			Future f2 = ecs.take();
108			assertSame(f1, f2);
109			} catch (Exception ex) {
110			unexpectedException();
111			} finally {
112			joinPool(e);
113			}
114			}
115
116			/**
117			* If poll returns non-null, the returned task is completed
118			*/
119			public void testPoll1() {
120			ExecutorService e = Executors.newCachedThreadPool();
121			ExecutorCompletionService ecs = new ExecutorCompletionService(e);
122			try {
123			assertNull(ecs.poll());
124			Callable c = new StringTask();
125			ecs.submit(c);
126			Thread.sleep(SHORT_DELAY_MS);
127			for (;;) {
128			Future f = ecs.poll();
129			if (f != null) {
130	dl	1.3	assertTrue(f.isDone());
131	dl	1.1	break;
132			}
133			}
134			} catch (Exception ex) {
135			unexpectedException();
136			} finally {
137			joinPool(e);
138			}
139			}
140
141			/**
142			* If timed poll returns non-null, the returned task is completed
143			*/
144			public void testPoll2() {
145			ExecutorService e = Executors.newCachedThreadPool();
146			ExecutorCompletionService ecs = new ExecutorCompletionService(e);
147			try {
148			assertNull(ecs.poll());
149			Callable c = new StringTask();
150			ecs.submit(c);
151			Future f = ecs.poll(SHORT_DELAY_MS, TimeUnit.MILLISECONDS);
152			if (f != null)
153	dl	1.3	assertTrue(f.isDone());
154	dl	1.1	} catch (Exception ex) {
155			unexpectedException();
156			} finally {
157			joinPool(e);
158			}
159			}
160	dl	1.4	/**
161			* Submitting to underlying AES that overrides newTaskFor(Callable)
162			* returns and eventually runs Future returned by newTaskFor.
163			*/
164			public void testNewTaskForCallable() {
165			final AtomicBoolean done = new AtomicBoolean(false);
166			class MyCallableFuture<V> extends FutureTask<V> {
167			MyCallableFuture(Callable<V> c) { super(c); }
168			protected void done() { done.set(true); }
169			}
170			ExecutorService e = new ThreadPoolExecutor(
171			1, 1, 30L, TimeUnit.SECONDS,
172			new ArrayBlockingQueue<Runnable>(1)) {
173			protected <T> RunnableFuture<T> newTaskFor(Callable<T> c) {
174			return new MyCallableFuture<T>(c);
175			}
176			};
177			ExecutorCompletionService<String> ecs =
178			new ExecutorCompletionService<String>(e);
179			try {
180			assertNull(ecs.poll());
181			Callable<String> c = new StringTask();
182			Future f1 = ecs.submit(c);
183			assertTrue("submit must return MyCallableFuture",
184			f1 instanceof MyCallableFuture);
185			Future f2 = ecs.take();
186			assertSame("submit and take must return same objects", f1, f2);
187			assertTrue("completed task must have set done", done.get());
188			} catch (Exception ex) {
189			unexpectedException();
190			} finally {
191			joinPool(e);
192			}
193			}
194
195			/**
196			* Submitting to underlying AES that overrides newTaskFor(Runnable,T)
197			* returns and eventually runs Future returned by newTaskFor.
198			*/
199			public void testNewTaskForRunnable() {
200			final AtomicBoolean done = new AtomicBoolean(false);
201			class MyRunnableFuture<V> extends FutureTask<V> {
202			MyRunnableFuture(Runnable t, V r) { super(t, r); }
203			protected void done() { done.set(true); }
204			}
205			ExecutorService e = new ThreadPoolExecutor(
206			1, 1, 30L, TimeUnit.SECONDS,
207			new ArrayBlockingQueue<Runnable>(1)) {
208			protected <T> RunnableFuture<T> newTaskFor(Runnable t, T r) {
209			return new MyRunnableFuture<T>(t, r);
210			}
211			};
212			ExecutorCompletionService<String> ecs =
213			new ExecutorCompletionService<String>(e);
214			try {
215			assertNull(ecs.poll());
216			Callable<String> c = new StringTask();
217			Future f1 = ecs.submit(c);
218			assertTrue("submit must return MyRunnableFuture",
219			f1 instanceof MyRunnableFuture);
220			Future f2 = ecs.take();
221			assertSame("submit and take must return same objects", f1, f2);
222			assertTrue("completed task must have set done", done.get());
223			} catch (Exception ex) {
224			unexpectedException();
225			} finally {
226			joinPool(e);
227			}
228			}
229
230
231	dl	1.1
232			}