ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ExecutorCompletionServiceTest.java
(Generate patch)

Comparing jsr166/src/test/tck/ExecutorCompletionServiceTest.java (file contents):
Revision 1.22 by jsr166, Sun Oct 4 18:28:51 2015 UTC vs.
Revision 1.28 by jsr166, Sat Mar 25 21:41:10 2017 UTC

# Line 10 | Line 10 | import static java.util.concurrent.TimeU
10  
11   import java.util.concurrent.ArrayBlockingQueue;
12   import java.util.concurrent.Callable;
13 + import java.util.concurrent.CompletionService;
14 + import java.util.concurrent.CountDownLatch;
15 + import java.util.concurrent.ExecutionException;
16   import java.util.concurrent.ExecutorCompletionService;
14 – import java.util.concurrent.Executors;
17   import java.util.concurrent.ExecutorService;
18   import java.util.concurrent.Future;
19   import java.util.concurrent.FutureTask;
# Line 32 | Line 34 | public class ExecutorCompletionServiceTe
34      }
35  
36      /**
37 <     * Creating a new ECS with null Executor throw NPE
37 >     * new ExecutorCompletionService(null) throws NullPointerException
38       */
39      public void testConstructorNPE() {
40          try {
# Line 42 | Line 44 | public class ExecutorCompletionServiceTe
44      }
45  
46      /**
47 <     * Creating a new ECS with null queue throw NPE
47 >     * new ExecutorCompletionService(e, null) throws NullPointerException
48       */
49      public void testConstructorNPE2() {
50          try {
51 <            ExecutorService e = Executors.newCachedThreadPool();
50 <            new ExecutorCompletionService(e, null);
51 >            new ExecutorCompletionService(cachedThreadPool, null);
52              shouldThrow();
53          } catch (NullPointerException success) {}
54      }
55  
56      /**
57 <     * Submitting a null callable throws NPE
57 >     * ecs.submit(null) throws NullPointerException
58       */
59 <    public void testSubmitNPE() {
60 <        final ExecutorService e = Executors.newCachedThreadPool();
61 <        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
62 <        try (PoolCleaner cleaner = cleaner(e)) {
63 <            Callable c = null;
64 <            try {
64 <                ecs.submit(c);
65 <                shouldThrow();
66 <            } catch (NullPointerException success) {}
67 <        }
59 >    public void testSubmitNullCallable() {
60 >        CompletionService cs = new ExecutorCompletionService(cachedThreadPool);
61 >        try {
62 >            cs.submit((Callable) null);
63 >            shouldThrow();
64 >        } catch (NullPointerException success) {}
65      }
66  
67      /**
68 <     * Submitting a null runnable throws NPE
68 >     * ecs.submit(null, val) throws NullPointerException
69       */
70 <    public void testSubmitNPE2() {
71 <        final ExecutorService e = Executors.newCachedThreadPool();
72 <        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
73 <        try (PoolCleaner cleaner = cleaner(e)) {
74 <            Runnable r = null;
75 <            try {
79 <                ecs.submit(r, Boolean.TRUE);
80 <                shouldThrow();
81 <            } catch (NullPointerException success) {}
82 <        }
70 >    public void testSubmitNullRunnable() {
71 >        CompletionService cs = new ExecutorCompletionService(cachedThreadPool);
72 >        try {
73 >            cs.submit((Runnable) null, Boolean.TRUE);
74 >            shouldThrow();
75 >        } catch (NullPointerException success) {}
76      }
77  
78      /**
79       * A taken submitted task is completed
80       */
81 <    public void testTake() throws InterruptedException {
82 <        final ExecutorService e = Executors.newCachedThreadPool();
83 <        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
84 <        try (PoolCleaner cleaner = cleaner(e)) {
85 <            Callable c = new StringTask();
86 <            ecs.submit(c);
87 <            Future f = ecs.take();
95 <            assertTrue(f.isDone());
96 <        }
81 >    public void testTake()
82 >        throws InterruptedException, ExecutionException {
83 >        CompletionService cs = new ExecutorCompletionService(cachedThreadPool);
84 >        cs.submit(new StringTask());
85 >        Future f = cs.take();
86 >        assertTrue(f.isDone());
87 >        assertSame(TEST_STRING, f.get());
88      }
89  
90      /**
91       * Take returns the same future object returned by submit
92       */
93      public void testTake2() throws InterruptedException {
94 <        final ExecutorService e = Executors.newCachedThreadPool();
95 <        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
96 <        try (PoolCleaner cleaner = cleaner(e)) {
97 <            Callable c = new StringTask();
98 <            Future f1 = ecs.submit(c);
99 <            Future f2 = ecs.take();
100 <            assertSame(f1, f2);
94 >        CompletionService cs = new ExecutorCompletionService(cachedThreadPool);
95 >        Future f1 = cs.submit(new StringTask());
96 >        Future f2 = cs.take();
97 >        assertSame(f1, f2);
98 >    }
99 >
100 >    /**
101 >     * poll returns non-null when the returned task is completed
102 >     */
103 >    public void testPoll1()
104 >        throws InterruptedException, ExecutionException {
105 >        CompletionService cs = new ExecutorCompletionService(cachedThreadPool);
106 >        assertNull(cs.poll());
107 >        cs.submit(new StringTask());
108 >
109 >        long startTime = System.nanoTime();
110 >        Future f;
111 >        while ((f = cs.poll()) == null) {
112 >            if (millisElapsedSince(startTime) > LONG_DELAY_MS)
113 >                fail("timed out");
114 >            Thread.yield();
115          }
116 +        assertTrue(f.isDone());
117 +        assertSame(TEST_STRING, f.get());
118      }
119  
120      /**
121 <     * If poll returns non-null, the returned task is completed
121 >     * timed poll returns non-null when the returned task is completed
122       */
123 <    public void testPoll1() throws Exception {
124 <        final ExecutorService e = Executors.newCachedThreadPool();
125 <        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
126 <        try (PoolCleaner cleaner = cleaner(e)) {
127 <            assertNull(ecs.poll());
128 <            Callable c = new StringTask();
129 <            ecs.submit(c);
130 <
131 <            long startTime = System.nanoTime();
132 <            Future f;
133 <            while ((f = ecs.poll()) == null) {
134 <                if (millisElapsedSince(startTime) > LONG_DELAY_MS)
128 <                    fail("timed out");
129 <                Thread.yield();
130 <            }
131 <            assertTrue(f.isDone());
132 <            assertSame(TEST_STRING, f.get());
123 >    public void testPoll2()
124 >        throws InterruptedException, ExecutionException {
125 >        CompletionService cs = new ExecutorCompletionService(cachedThreadPool);
126 >        assertNull(cs.poll());
127 >        cs.submit(new StringTask());
128 >
129 >        long startTime = System.nanoTime();
130 >        Future f;
131 >        while ((f = cs.poll(SHORT_DELAY_MS, MILLISECONDS)) == null) {
132 >            if (millisElapsedSince(startTime) > LONG_DELAY_MS)
133 >                fail("timed out");
134 >            Thread.yield();
135          }
136 +        assertTrue(f.isDone());
137 +        assertSame(TEST_STRING, f.get());
138      }
139  
140      /**
141 <     * If timed poll returns non-null, the returned task is completed
141 >     * poll returns null before the returned task is completed
142       */
143 <    public void testPoll2() throws InterruptedException {
144 <        final ExecutorService e = Executors.newCachedThreadPool();
145 <        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
146 <        try (PoolCleaner cleaner = cleaner(e)) {
147 <            assertNull(ecs.poll());
148 <            Callable c = new StringTask();
149 <            ecs.submit(c);
150 <            Future f = ecs.poll(SHORT_DELAY_MS, MILLISECONDS);
151 <            if (f != null)
152 <                assertTrue(f.isDone());
143 >    public void testPollReturnsNull()
144 >        throws InterruptedException, ExecutionException {
145 >        CompletionService cs = new ExecutorCompletionService(cachedThreadPool);
146 >        final CountDownLatch proceed = new CountDownLatch(1);
147 >        cs.submit(new Callable() { public String call() throws Exception {
148 >            await(proceed);
149 >            return TEST_STRING;
150 >        }});
151 >        assertNull(cs.poll());
152 >        assertNull(cs.poll(0L, MILLISECONDS));
153 >        assertNull(cs.poll(Long.MIN_VALUE, MILLISECONDS));
154 >        long startTime = System.nanoTime();
155 >        assertNull(cs.poll(timeoutMillis(), MILLISECONDS));
156 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
157 >        proceed.countDown();
158 >        assertSame(TEST_STRING, cs.take().get());
159 >    }
160 >
161 >    /**
162 >     * successful and failed tasks are both returned
163 >     */
164 >    public void testTaskAssortment()
165 >        throws InterruptedException, ExecutionException {
166 >        CompletionService cs = new ExecutorCompletionService(cachedThreadPool);
167 >        ArithmeticException ex = new ArithmeticException();
168 >        for (int i = 0; i < 2; i++) {
169 >            cs.submit(new StringTask());
170 >            cs.submit(callableThrowing(ex));
171 >            cs.submit(runnableThrowing(ex), null);
172 >        }
173 >        int normalCompletions = 0;
174 >        int exceptionalCompletions = 0;
175 >        for (int i = 0; i < 3 * 2; i++) {
176 >            try {
177 >                if (cs.take().get() == TEST_STRING)
178 >                    normalCompletions++;
179 >            }
180 >            catch (ExecutionException expected) {
181 >                assertTrue(expected.getCause() instanceof ArithmeticException);
182 >                exceptionalCompletions++;
183 >            }
184          }
185 +        assertEquals(2 * 1, normalCompletions);
186 +        assertEquals(2 * 2, exceptionalCompletions);
187 +        assertNull(cs.poll());
188      }
189  
190      /**
# Line 157 | Line 195 | public class ExecutorCompletionServiceTe
195          final AtomicBoolean done = new AtomicBoolean(false);
196          class MyCallableFuture<V> extends FutureTask<V> {
197              MyCallableFuture(Callable<V> c) { super(c); }
198 <            protected void done() { done.set(true); }
198 >            @Override protected void done() { done.set(true); }
199          }
200          final ExecutorService e =
201              new ThreadPoolExecutor(1, 1,
# Line 166 | Line 204 | public class ExecutorCompletionServiceTe
204                  protected <T> RunnableFuture<T> newTaskFor(Callable<T> c) {
205                      return new MyCallableFuture<T>(c);
206                  }};
207 <        ExecutorCompletionService<String> ecs =
170 <            new ExecutorCompletionService<String>(e);
207 >        CompletionService<String> cs = new ExecutorCompletionService<>(e);
208          try (PoolCleaner cleaner = cleaner(e)) {
209 <            assertNull(ecs.poll());
209 >            assertNull(cs.poll());
210              Callable<String> c = new StringTask();
211 <            Future f1 = ecs.submit(c);
211 >            Future f1 = cs.submit(c);
212              assertTrue("submit must return MyCallableFuture",
213                         f1 instanceof MyCallableFuture);
214 <            Future f2 = ecs.take();
214 >            Future f2 = cs.take();
215              assertSame("submit and take must return same objects", f1, f2);
216              assertTrue("completed task must have set done", done.get());
217          }
# Line 188 | Line 225 | public class ExecutorCompletionServiceTe
225          final AtomicBoolean done = new AtomicBoolean(false);
226          class MyRunnableFuture<V> extends FutureTask<V> {
227              MyRunnableFuture(Runnable t, V r) { super(t, r); }
228 <            protected void done() { done.set(true); }
228 >            @Override protected void done() { done.set(true); }
229          }
230          final ExecutorService e =
231              new ThreadPoolExecutor(1, 1,
# Line 197 | Line 234 | public class ExecutorCompletionServiceTe
234                  protected <T> RunnableFuture<T> newTaskFor(Runnable t, T r) {
235                      return new MyRunnableFuture<T>(t, r);
236                  }};
237 <        final ExecutorCompletionService<String> ecs =
201 <            new ExecutorCompletionService<String>(e);
237 >        CompletionService<String> cs = new ExecutorCompletionService<>(e);
238          try (PoolCleaner cleaner = cleaner(e)) {
239 <            assertNull(ecs.poll());
239 >            assertNull(cs.poll());
240              Runnable r = new NoOpRunnable();
241 <            Future f1 = ecs.submit(r, null);
241 >            Future f1 = cs.submit(r, null);
242              assertTrue("submit must return MyRunnableFuture",
243                         f1 instanceof MyRunnableFuture);
244 <            Future f2 = ecs.take();
244 >            Future f2 = cs.take();
245              assertSame("submit and take must return same objects", f1, f2);
246              assertTrue("completed task must have set done", done.get());
247          }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines