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