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