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/publicdomain/zero/1.0/
 * Other contributors include Andrew Wright, Jeffrey Hayes,
 * Pat Fisher, Mike Judd.
 */


import junit.framework.*;
import java.util.*;
import java.util.concurrent.*;
import static java.util.concurrent.TimeUnit.MILLISECONDS;
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() throws InterruptedException {
        ExecutorService e = Executors.newCachedThreadPool();
        ExecutorCompletionService ecs = new ExecutorCompletionService(e);
        try {
            Callable c = new StringTask();
            ecs.submit(c);
            Future f = ecs.take();
            assertTrue(f.isDone());
        } finally {
            joinPool(e);
        }
    }

    /**
     * Take returns the same future object returned by submit
     */
    public void testTake2() throws InterruptedException {
        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);
        } finally {
            joinPool(e);
        }
    }

    /**
     * If poll returns non-null, the returned task is completed
     */
    public void testPoll1() throws InterruptedException {
        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;
                }
            }
        } finally {
            joinPool(e);
        }
    }

    /**
     * If timed poll returns non-null, the returned task is completed
     */
    public void testPoll2() throws InterruptedException {
        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, MILLISECONDS);
            if (f != null)
                assertTrue(f.isDone());
        } finally {
            joinPool(e);
        }
    }

    /**
     * Submitting to underlying AES that overrides newTaskFor(Callable)
     * returns and eventually runs Future returned by newTaskFor.
     */
    public void testNewTaskForCallable() throws InterruptedException {
        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());
        } finally {
            joinPool(e);
        }
    }

    /**
     * Submitting to underlying AES that overrides newTaskFor(Runnable,T)
     * returns and eventually runs Future returned by newTaskFor.
     */
    public void testNewTaskForRunnable() throws InterruptedException {
        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());
        } finally {
            joinPool(e);
        }
    }

}
Revision:	1.13
Committed:	Tue Mar 15 19:47:06 2011 UTC (13 years, 1 month ago) by jsr166
Branch:	MAIN
Changes since 1.12:	+1 -1 lines
Log Message:	Update Creative Commons license URL in legal notices
#	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/publicdomain/zero/1.0/
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 static java.util.concurrent.TimeUnit.MILLISECONDS;
14	import java.util.concurrent.atomic.*;
15	import java.math.BigInteger;
16	import java.security.*;
17
18	public class ExecutorCompletionServiceTest extends JSR166TestCase {
19	public static void main(String[] args) {
20	junit.textui.TestRunner.run(suite());
21	}
22	public static Test suite() {
23	return new TestSuite(ExecutorCompletionServiceTest.class);
24	}
25
26
27	/**
28	* Creating a new ECS with null Executor throw NPE
29	*/
30	public void testConstructorNPE() {
31	try {
32	ExecutorCompletionService ecs = new ExecutorCompletionService(null);
33	shouldThrow();
34	} catch (NullPointerException success) {}
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	* 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() throws InterruptedException {
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	assertTrue(f.isDone());
91	} finally {
92	joinPool(e);
93	}
94	}
95
96	/**
97	* Take returns the same future object returned by submit
98	*/
99	public void testTake2() throws InterruptedException {
100	ExecutorService e = Executors.newCachedThreadPool();
101	ExecutorCompletionService ecs = new ExecutorCompletionService(e);
102	try {
103	Callable c = new StringTask();
104	Future f1 = ecs.submit(c);
105	Future f2 = ecs.take();
106	assertSame(f1, f2);
107	} finally {
108	joinPool(e);
109	}
110	}
111
112	/**
113	* If poll returns non-null, the returned task is completed
114	*/
115	public void testPoll1() throws InterruptedException {
116	ExecutorService e = Executors.newCachedThreadPool();
117	ExecutorCompletionService ecs = new ExecutorCompletionService(e);
118	try {
119	assertNull(ecs.poll());
120	Callable c = new StringTask();
121	ecs.submit(c);
122	Thread.sleep(SHORT_DELAY_MS);
123	for (;;) {
124	Future f = ecs.poll();
125	if (f != null) {
126	assertTrue(f.isDone());
127	break;
128	}
129	}
130	} finally {
131	joinPool(e);
132	}
133	}
134
135	/**
136	* If timed poll returns non-null, the returned task is completed
137	*/
138	public void testPoll2() throws InterruptedException {
139	ExecutorService e = Executors.newCachedThreadPool();
140	ExecutorCompletionService ecs = new ExecutorCompletionService(e);
141	try {
142	assertNull(ecs.poll());
143	Callable c = new StringTask();
144	ecs.submit(c);
145	Future f = ecs.poll(SHORT_DELAY_MS, MILLISECONDS);
146	if (f != null)
147	assertTrue(f.isDone());
148	} finally {
149	joinPool(e);
150	}
151	}
152
153	/**
154	* Submitting to underlying AES that overrides newTaskFor(Callable)
155	* returns and eventually runs Future returned by newTaskFor.
156	*/
157	public void testNewTaskForCallable() throws InterruptedException {
158	final AtomicBoolean done = new AtomicBoolean(false);
159	class MyCallableFuture<V> extends FutureTask<V> {
160	MyCallableFuture(Callable<V> c) { super(c); }
161	protected void done() { done.set(true); }
162	}
163	ExecutorService e = new ThreadPoolExecutor(
164	1, 1, 30L, TimeUnit.SECONDS,
165	new ArrayBlockingQueue<Runnable>(1)) {
166	protected <T> RunnableFuture<T> newTaskFor(Callable<T> c) {
167	return new MyCallableFuture<T>(c);
168	}};
169	ExecutorCompletionService<String> ecs =
170	new ExecutorCompletionService<String>(e);
171	try {
172	assertNull(ecs.poll());
173	Callable<String> c = new StringTask();
174	Future f1 = ecs.submit(c);
175	assertTrue("submit must return MyCallableFuture",
176	f1 instanceof MyCallableFuture);
177	Future f2 = ecs.take();
178	assertSame("submit and take must return same objects", f1, f2);
179	assertTrue("completed task must have set done", done.get());
180	} finally {
181	joinPool(e);
182	}
183	}
184
185	/**
186	* Submitting to underlying AES that overrides newTaskFor(Runnable,T)
187	* returns and eventually runs Future returned by newTaskFor.
188	*/
189	public void testNewTaskForRunnable() throws InterruptedException {
190	final AtomicBoolean done = new AtomicBoolean(false);
191	class MyRunnableFuture<V> extends FutureTask<V> {
192	MyRunnableFuture(Runnable t, V r) { super(t, r); }
193	protected void done() { done.set(true); }
194	}
195	ExecutorService e = new ThreadPoolExecutor(
196	1, 1, 30L, TimeUnit.SECONDS,
197	new ArrayBlockingQueue<Runnable>(1)) {
198	protected <T> RunnableFuture<T> newTaskFor(Runnable t, T r) {
199	return new MyRunnableFuture<T>(t, r);
200	}};
201	ExecutorCompletionService<String> ecs =
202	new ExecutorCompletionService<String>(e);
203	try {
204	assertNull(ecs.poll());
205	Runnable r = new NoOpRunnable();
206	Future f1 = ecs.submit(r, null);
207	assertTrue("submit must return MyRunnableFuture",
208	f1 instanceof MyRunnableFuture);
209	Future f2 = ecs.take();
210	assertSame("submit and take must return same objects", f1, f2);
211	assertTrue("completed task must have set done", done.get());
212	} finally {
213	joinPool(e);
214	}
215	}
216
217	}