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.31 by jsr166, Wed Jan 27 01:57:24 2021 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 {
41 <            new ExecutorCompletionService(null);
41 >            new ExecutorCompletionService<Item>(null);
42              shouldThrow();
43          } catch (NullPointerException success) {}
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<Item>(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<Item> cs = new ExecutorCompletionService<>(cachedThreadPool);
61 >        try {
62 >            cs.submit((Callable<Item>) 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<Boolean> 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);
94 <            Future f = ecs.take();
95 <            assertTrue(f.isDone());
96 <        }
81 >    public void testTake() throws Exception {
82 >        CompletionService<String> cs = new ExecutorCompletionService<>(cachedThreadPool);
83 >        cs.submit(new StringTask());
84 >        Future<?> f = cs.take();
85 >        assertTrue(f.isDone());
86 >        assertSame(TEST_STRING, f.get());
87      }
88  
89      /**
90       * Take returns the same future object returned by submit
91       */
92      public void testTake2() throws InterruptedException {
93 <        final ExecutorService e = Executors.newCachedThreadPool();
94 <        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
95 <        try (PoolCleaner cleaner = cleaner(e)) {
96 <            Callable c = new StringTask();
107 <            Future f1 = ecs.submit(c);
108 <            Future f2 = ecs.take();
109 <            assertSame(f1, f2);
110 <        }
93 >        CompletionService<String> cs = new ExecutorCompletionService<>(cachedThreadPool);
94 >        Future<?> f1 = cs.submit(new StringTask());
95 >        Future<?> f2 = cs.take();
96 >        assertSame(f1, f2);
97      }
98  
99      /**
100 <     * If poll returns non-null, the returned task is completed
100 >     * poll returns non-null when the returned task is completed
101       */
102      public void testPoll1() throws Exception {
103 <        final ExecutorService e = Executors.newCachedThreadPool();
104 <        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
105 <        try (PoolCleaner cleaner = cleaner(e)) {
106 <            assertNull(ecs.poll());
107 <            Callable c = new StringTask();
108 <            ecs.submit(c);
109 <
110 <            long startTime = System.nanoTime();
111 <            Future f;
112 <            while ((f = ecs.poll()) == null) {
113 <                if (millisElapsedSince(startTime) > LONG_DELAY_MS)
114 <                    fail("timed out");
115 <                Thread.yield();
103 >        CompletionService<String> cs = new ExecutorCompletionService<>(cachedThreadPool);
104 >        assertNull(cs.poll());
105 >        cs.submit(new StringTask());
106 >
107 >        long startTime = System.nanoTime();
108 >        Future<?> f;
109 >        while ((f = cs.poll()) == null) {
110 >            if (millisElapsedSince(startTime) > LONG_DELAY_MS)
111 >                fail("timed out");
112 >            Thread.yield();
113 >        }
114 >        assertTrue(f.isDone());
115 >        assertSame(TEST_STRING, f.get());
116 >    }
117 >
118 >    /**
119 >     * timed poll returns non-null when the returned task is completed
120 >     */
121 >    public void testPoll2() throws Exception {
122 >        CompletionService<String> cs = new ExecutorCompletionService<>(cachedThreadPool);
123 >        assertNull(cs.poll());
124 >        cs.submit(new StringTask());
125 >
126 >        long startTime = System.nanoTime();
127 >        Future<?> f;
128 >        while ((f = cs.poll(timeoutMillis(), MILLISECONDS)) == null) {
129 >            assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
130 >            if (millisElapsedSince(startTime) > LONG_DELAY_MS)
131 >                fail("timed out");
132 >            Thread.yield();
133 >        }
134 >        assertTrue(f.isDone());
135 >        assertSame(TEST_STRING, f.get());
136 >    }
137 >
138 >    /**
139 >     * poll returns null before the returned task is completed
140 >     */
141 >    public void testPollReturnsNullBeforeCompletion() throws Exception {
142 >        CompletionService<String> cs = new ExecutorCompletionService<>(cachedThreadPool);
143 >        final CountDownLatch proceed = new CountDownLatch(1);
144 >        cs.submit(new Callable<String>() { public String call() throws Exception {
145 >            await(proceed);
146 >            return TEST_STRING;
147 >        }});
148 >        assertNull(cs.poll());
149 >        assertNull(cs.poll(0L, MILLISECONDS));
150 >        assertNull(cs.poll(Long.MIN_VALUE, MILLISECONDS));
151 >        long startTime = System.nanoTime();
152 >        assertNull(cs.poll(timeoutMillis(), MILLISECONDS));
153 >        assertTrue(millisElapsedSince(startTime) >= timeoutMillis());
154 >        proceed.countDown();
155 >        assertSame(TEST_STRING, cs.take().get());
156 >    }
157 >
158 >    /**
159 >     * successful and failed tasks are both returned
160 >     */
161 >    public void testTaskAssortment() throws Exception {
162 >        CompletionService<String> cs = new ExecutorCompletionService<>(cachedThreadPool);
163 >        ArithmeticException ex = new ArithmeticException();
164 >        final int rounds = 2;
165 >        for (int i = rounds; i--> 0; ) {
166 >            cs.submit(new StringTask());
167 >            cs.submit(callableThrowing(ex));
168 >            cs.submit(runnableThrowing(ex), null);
169 >        }
170 >        int normalCompletions = 0;
171 >        int exceptionalCompletions = 0;
172 >        for (int i = 3 * rounds; i--> 0; ) {
173 >            try {
174 >                assertSame(TEST_STRING, cs.take().get());
175 >                normalCompletions++;
176 >            } catch (ExecutionException expected) {
177 >                assertSame(ex, expected.getCause());
178 >                exceptionalCompletions++;
179              }
131 –            assertTrue(f.isDone());
132 –            assertSame(TEST_STRING, f.get());
133 –        }
134 –    }
135 –
136 –    /**
137 –     * If timed poll returns non-null, the returned task is completed
138 –     */
139 –    public void testPoll2() throws InterruptedException {
140 –        final ExecutorService e = Executors.newCachedThreadPool();
141 –        final ExecutorCompletionService ecs = new ExecutorCompletionService(e);
142 –        try (PoolCleaner cleaner = cleaner(e)) {
143 –            assertNull(ecs.poll());
144 –            Callable c = new StringTask();
145 –            ecs.submit(c);
146 –            Future f = ecs.poll(SHORT_DELAY_MS, MILLISECONDS);
147 –            if (f != null)
148 –                assertTrue(f.isDone());
180          }
181 +        assertEquals(1 * rounds, normalCompletions);
182 +        assertEquals(2 * rounds, exceptionalCompletions);
183 +        assertNull(cs.poll());
184      }
185  
186      /**
# Line 157 | Line 191 | public class ExecutorCompletionServiceTe
191          final AtomicBoolean done = new AtomicBoolean(false);
192          class MyCallableFuture<V> extends FutureTask<V> {
193              MyCallableFuture(Callable<V> c) { super(c); }
194 <            protected void done() { done.set(true); }
194 >            @Override protected void done() { done.set(true); }
195          }
196          final ExecutorService e =
197              new ThreadPoolExecutor(1, 1,
# Line 166 | Line 200 | public class ExecutorCompletionServiceTe
200                  protected <T> RunnableFuture<T> newTaskFor(Callable<T> c) {
201                      return new MyCallableFuture<T>(c);
202                  }};
203 <        ExecutorCompletionService<String> ecs =
170 <            new ExecutorCompletionService<String>(e);
203 >        CompletionService<String> cs = new ExecutorCompletionService<>(e);
204          try (PoolCleaner cleaner = cleaner(e)) {
205 <            assertNull(ecs.poll());
205 >            assertNull(cs.poll());
206              Callable<String> c = new StringTask();
207 <            Future f1 = ecs.submit(c);
207 >            Future<?> f1 = cs.submit(c);
208              assertTrue("submit must return MyCallableFuture",
209                         f1 instanceof MyCallableFuture);
210 <            Future f2 = ecs.take();
210 >            Future<?> f2 = cs.take();
211              assertSame("submit and take must return same objects", f1, f2);
212              assertTrue("completed task must have set done", done.get());
213          }
# Line 188 | Line 221 | public class ExecutorCompletionServiceTe
221          final AtomicBoolean done = new AtomicBoolean(false);
222          class MyRunnableFuture<V> extends FutureTask<V> {
223              MyRunnableFuture(Runnable t, V r) { super(t, r); }
224 <            protected void done() { done.set(true); }
224 >            @Override protected void done() { done.set(true); }
225          }
226          final ExecutorService e =
227              new ThreadPoolExecutor(1, 1,
# Line 197 | Line 230 | public class ExecutorCompletionServiceTe
230                  protected <T> RunnableFuture<T> newTaskFor(Runnable t, T r) {
231                      return new MyRunnableFuture<T>(t, r);
232                  }};
233 <        final ExecutorCompletionService<String> ecs =
201 <            new ExecutorCompletionService<String>(e);
233 >        CompletionService<String> cs = new ExecutorCompletionService<>(e);
234          try (PoolCleaner cleaner = cleaner(e)) {
235 <            assertNull(ecs.poll());
235 >            assertNull(cs.poll());
236              Runnable r = new NoOpRunnable();
237 <            Future f1 = ecs.submit(r, null);
237 >            Future<?> f1 = cs.submit(r, null);
238              assertTrue("submit must return MyRunnableFuture",
239                         f1 instanceof MyRunnableFuture);
240 <            Future f2 = ecs.take();
240 >            Future<?> f2 = cs.take();
241              assertSame("submit and take must return same objects", f1, f2);
242              assertTrue("completed task must have set done", done.get());
243          }

Diff Legend

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